带你做个封装虾之封装BaseServlet实现自动封装VO层数据对象

maven依赖

commons-beanutils-1.9.4
commons-logging-1.2
servlet
commons-dbutils
mysql-connector-java

public class baseServlet extends HttpServlet {

    private Class entityClass;// 获取子类中需要反射的实体类的类型
    protected HttpServletRequest httpServletRequest;
    protected HttpServletResponse httpServletResponse;
    
    public baseServlet() {
        // 获取子类中 extends baseServlet<类> 泛型类型 ,值得注意这里的this是继承对象
        entityClass = (Class) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.httpServletRequest = httpServletRequest;
        this.httpServletResponse = httpServletResponse;
        this.doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        response.setContentType("application/json;charset=utf-8");

        // 1.调用子类（UserinfoServlet）中方法
        // 1.1 获取method请求参数
        String methodStr = request.getParameter("method");// 子类中方法的方法名
        try {
            // 1.2 通过method获取子类中的Method
            Method[] declaredMethods = this.getClass().getDeclaredMethods();// 获取子类中定义的方法（共有、私有的、受保护的、默认的）
            Method method = null;
            for (Method declaredMethod : declaredMethods) {
                if (declaredMethod.getName().equals(methodStr)) {
                    method = declaredMethod;
                    break;
                }
            }

            if (method != null) {
                Object[] objects = new Object[method.getParameterCount()];
                // 1.3 获取传递子类方法中的参数值
                if (method.getParameterCount() > 0) {
                    Class[] parameterTypes = method.getParameterTypes();
                    for (int i = 0; i < parameterTypes.length; i++) {
                        Class parameterType = parameterTypes[i];
                        if (parameterType == HttpServletRequest.class) {
                            objects[i] = request;
                        } else if (parameterType == HttpServletResponse.class) {
                            objects[i] = response;
                        } else if (parameterType == entityClass) {// 实体类
                            Map parameterMap = request.getParameterMap();
                            T entity = ConvertEntity.convertEntityByData(parameterMap, entityClass);
                            objects[i] = entity;
                        }
                    }
                }

                // 1.4通过method对象调用当前要执行的方法
                Object result = method.invoke(this, objects);

                // 2.处理响应的数据
                if (result != null) {
                    Annotation[] annotations = method.getAnnotations();
                    for (Annotation annotation : annotations) {
                        annotation.annotationType();
                    }
                    String content = result.toString();
                    PrintWriter out = response.getWriter();
                    out.write(content);
                    out.flush();
                    out.close();
                }
            }
        } catch (IllegalAccessException | InvocationTargetException | NoSuchFieldException | InstantiationException e) {
            e.printStackTrace();
        }
    }
}

public class ConvertEntity {

    
    public static  T convertEntityByData(Map parameterMap, Class tClass)  throws NoSuchFieldException, IllegalAccessException, InstantiationException {
        Set keySet = parameterMap.keySet();
        T entity = tClass.newInstance();
        for (String key : keySet) { // key：请求参数的key值（表单元素的name值）
            boolean flag = flagField(key, tClass);
            if (flag) {
                Field declaredField = tClass.getDeclaredField(key);// 获取实体类中的成员变量
                String[] values = parameterMap.get(key);
                Object message = ConvertUtils.convert(values, String.class);
                declaredField.setAccessible(true);// 暴力破解
                declaredField.set(entity,ConvertUtils.convert(message, declaredField.getType()));
            }
        }
        return entity;
    }

    
    public static  boolean flagField(String fieldName, Class tClass) {
        Field[] declaredFields = tClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if (declaredField.getName().equals(fieldName)) {
                return true;
            }
        }
        return false;
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ResponseTypeAnnotation {
    ResponseEnum type() default ResponseEnum.AJAX;

}

public enum ResponseEnum {

    AJAX, // ajax响应方式
    REDIRECT, // 重定向
    FORWARD //  转发
}

@WebServlet("/product.do")
public class ProductServlet extends baseServlet {

    
    @ResponseTypeAnnotation
    public String showProduct(ProductInfo productInfo) throws IOException {
        //  查询所有的商品信息
        List productTypeInfos = new ProductServiceImpl().showAllProduct(productInfo);

        String json = JSONObject.toJSONString(productTypeInfos);

        return json;
    }