ars.invoke.channel.http.AbstractHttpChannel Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ars-core Show documentation
Ars framework core
The newest version!
package ars.invoke.channel.http;

import java.util.Map;
import java.util.HashMap;
import java.util.Map.Entry;
import java.io.IOException;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import ars.util.Streams;
import ars.util.Strings;
import ars.invoke.Context;
import ars.invoke.convert.Converter;

/**
 * Http请求通道抽象实现
 *
 * @author wuyongqiang
 */
public abstract class AbstractHttpChannel implements HttpChannel {
    private Context context; // 应用上下文
    private Redirector[] redirectors = new Redirector[0]; // 请求重定向配置
    private Map renders = new HashMap(0); // 视图渲染配置
    private Map templates = new HashMap(0); // 模板映射
    private Map converters = new HashMap(0); // 数据转换映射

    public Redirector[] getRedirectors() {
        return redirectors;
    }

    public void setRedirectors(Redirector... redirectors) {
        this.redirectors = redirectors;
    }

    public Map getRenders() {
        return renders;
    }

    public void setRenders(Map renders) {
        this.renders = renders;
    }

    public Map getTemplates() {
        return templates;
    }

    public void setTemplates(Map templates) {
        this.templates = templates;
    }

    public Map getConverters() {
        return converters;
    }

    public void setConverters(Map converters) {
        this.converters = converters;
    }

    /**
     * 获取请求对象
     *
     * @param uri      资源地址
     * @param config   Servlet配置对象
     * @param request  Http请求对象
     * @param response Http响应对象
     * @return 请求对象
     * @throws IOException      IO操作异常
     * @throws IOException      IO操作异常
     * @throws ServletException Servlet操作异常
     */
    protected abstract HttpRequester getRequester(String uri, ServletConfig config, HttpServletRequest request,
                                                  HttpServletResponse response) throws IOException, ServletException;

    /**
     * 获取请求资源地址
     *
     * @param request Http请求对象
     * @return 资源地址
     */
    protected String getUri(HttpServletRequest request) {
        String uri = request.getRequestURI().trim();
        String context = request.getContextPath();
        if (context != null) {
            uri = uri.substring(context.length());
        }
        if (uri.isEmpty()) {
            uri = Https.ROOT_URI;
        } else if (!uri.equals(Https.ROOT_URI)) {
            uri = uri.substring(1);
        }
        return uri;
    }

    /**
     * 查找请求资源模板
     *
     * @param requester 请求对象
     * @return 模板路径
     */
    protected String lookupTemplate(HttpRequester requester) {
        String template = null;
        String uri = requester.getUri();
        if (uri.indexOf('.') >= 0) {
            template = uri;
        } else if (!this.templates.isEmpty()) {
            for (Entry entry : this.templates.entrySet()) {
                if (Strings.matches(uri, entry.getKey())) {
                    template = entry.getValue();
                    break;
                }
            }
        }
        if (template != null) {
            int index = template.indexOf('?');
            if (index > 0) {
                template = template.substring(0, index);
            }
        }
        return template;
    }

    /**
     * 查找请求转换处理对象
     *
     * @param requester 请求对象
     * @return 数据转换处理对象
     */
    protected Converter lookupConverter(HttpRequester requester) {
        if (!this.converters.isEmpty()) {
            for (Entry entry : this.converters.entrySet()) {
                if (Strings.matches(requester.getUri(), entry.getKey())) {
                    return entry.getValue();
                }
            }
        }
        return null;
    }

    /**
     * 请求重定向
     *
     * @param requester 请求对象
     * @param content   重定向内容
     * @return 是否重定向成功
     * @throws Exception 操作异常
     */
    protected boolean redirect(HttpRequester requester, Object content) throws Exception {
        for (Redirector redirector : this.redirectors) {
            String redirect = redirector.getRedirect(requester, content);
            if (redirect == null) {
                continue;
            }
            if (redirect.indexOf('.') > 0) {
                requester.render(redirect, content);
            } else {
                String context = requester.getHttpServletRequest().getContextPath();
                if (context != null && !context.isEmpty()) {
                    redirect = new StringBuilder(context).append(redirect).toString();
                }
                requester.getHttpServletResponse().sendRedirect(redirect);
            }
            return true;
        }
        return false;
    }

    @Override
    public Context getContext() {
        return this.context;
    }

    @Override
    public void setContext(Context context) {
        this.context = context;
    }

    @Override
    public void dispatch(ServletConfig config, HttpServletRequest request, HttpServletResponse response)
        throws Exception {
        Object value = null;
        Converter converter = null;
        HttpRequester requester = this.getRequester(this.getUri(request), config, request, response);
        String template = this.lookupTemplate(requester);
        if (template == null) {
            try {
                value = requester.execute();
            } catch (Exception e) {
                value = e;
            }
            if (!Streams.isStream(value) && (converter = this.lookupConverter(requester)) != null) {
                value = converter.serialize(value);
            }
        } else if (Strings.isEmpty(request.getContentType()) || (converter = this.lookupConverter(requester)) == null) {
            try {
                requester.render(template, null);
            } catch (Exception e) {
                value = e;
            }
        } else {
            try {
                value = requester.view(template, null);
            } catch (Exception e) {
                value = e;
            }
            value = converter.serialize(value);
        }
        if (value != null && !this.redirect(requester, value)) {
            if (value instanceof Exception) {
                throw (Exception) value;
            }
            Https.response(response, value);
        }
    }

}