baseservlet封装（只关注参数传递，不关注参数获取）

最新推荐文章于 2024-11-12 21:14:07 发布

llxxqq5

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量300

点赞数

分类专栏：问题与方法文章标签： java java-ee 开发语言

本文链接：https://blog.csdn.net/m0_58574228/article/details/122134359

版权

问题与方法专栏收录该内容

50 篇文章 1 订阅

订阅专栏

该博客介绍了一个基于Servlet的类，它扩展了HttpServlet并实现了请求方法的自动调用。通过对HttpServletRequest和HttpServletResponse的处理，该类能够自动获取请求参数，调用相应的方法，并根据返回值进行重定向或转发操作。同时，它简化了方法参数的获取和封装，使得开发者在编写具体业务方法时，只需要关注实际业务逻辑，而不需要关心参数的获取细节。

摘要由CSDN通过智能技术生成



public class BaseServlet extends HttpServlet {

    @SneakyThrows
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        // 1.获取请求的方法名称
        String methodName = getMethodName(req);
        System.out.println(methodName);

        // 2.调用action
        Object o = invocateAction(req, methodName, resp);

        if (o != null) { //不为null，说明有返回值，且统一是字符串类型
            String s = (String) o;
            //判断前缀
            if (s.startsWith(ConstUtils.REDIREC)) { //重定向
                String content = s.split(":")[1];
                resp.sendRedirect(req.getContextPath() + content);
            } else if (s.startsWith(ConstUtils.FORWARD)) { //转发
                String content = s.split(":")[1];
                req.getRequestDispatcher(content).forward(req, resp);
            } else {    //返回字符串
                resp.getWriter().write(s);
            }
        }//为null，此处不做处理，需要自己写跳转
    }

    private Object invocateAction(HttpServletRequest req, String methodName, HttpServletResponse response) {

        // 1.找到需要调用的方法
        Method method = null;
        for (Method me : this.getClass().getMethods()) {
            if (me.getName().equals(methodName)) {
                method = me;
                break;
            }
        }

        // 2.判断是否找打了调用的action
        if (method != null) {
            // 准备方法的参数
            Object[] args = methodParam(method, req, response);

            try {
                // 调用方法
                Object invoke = method.invoke(this, args);
                return invoke;
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }

        } else {
            System.err.println("【" + methodName + "】没有定义");
        }

        return null;
    }

    private Object[] methodParam(Method method, HttpServletRequest req, HttpServletResponse response) {

        // 1.创建一个数组,数组的长度就是方法的形参的个数
        Object[] args = new Object[method.getParameterCount()];

        // 2.获取调用方法传递的参数列表
        Parameter[] parameters = method.getParameters();
        for (int i = 0; i < parameters.length; i++) {
            Parameter parameter = parameters[i];
            String paramName = parameter.getName(); // 形参名称
            Class<?> paramType = parameter.getType();
            if (paramType.getSimpleName().equals(HttpServletRequest.class.getSimpleName())) {
                args[i] = req;
            } else if (paramType.getSimpleName().equals(HttpServletResponse.class.getSimpleName())) {
                args[i] = response;
            } else if (paramType.getSimpleName().equals(Integer.class.getSimpleName())) {
                String parameter1 = req.getParameter(paramName);
                if (parameter1 != null && !"".equals(parameter1)) {
                    Integer value = Integer.parseInt(parameter1);
                    args[i] = value;
                }
            } else {
                String value = req.getParameter(paramName);
                if (value == null || "".equals(value)) {
                    // 把这个参数当成对象来处理,
                    Map<String, String[]> parameterMap = req.getParameterMap();

                    // 把参数Map的数据拷贝到一个对象中
                    try {
                        Object obj = parameter.getType().newInstance(); // 实例化一个对象
                        BeanUtils.populate(obj, parameterMap); // 把map中的数据拷贝到对象中
                        args[i] = obj;
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    } catch (InstantiationException e) {
                        e.printStackTrace();
                    }
                } else {
                    args[i] = value;
                }
            }
        }
        return args;
    }

    private String getMethodName(HttpServletRequest req) {
        String requestURI = req.getRequestURI(); // sever
        int index = req.getRequestURI().lastIndexOf("/");
        return requestURI.substring(index + 1);
    }

    public String index(HttpServletRequest request, HttpServletResponse response) {
        return ConstUtils.REDIREC + "index.jsp";
    }
}

该方法封装了服务器获取参数的过程，最后写方法的时候只关注传递需要的参数即可，不再关注参数的获取过程，也不关注参数封装成为对象的过程