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

maven依赖

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

public class BaseServlet<T> extends HttpServlet {

    private Class<T> entityClass;// 获取子类中需要反射的实体类的类型
    protected HttpServletRequest request;
    protected HttpServletResponse response;

    public BaseServlet() {
        // 获取子类中 extends BaseServlet<类> 泛型类型
        entityClass = (Class) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        System.out.println("hsuhfshafhkjasd");
        System.out.println("hsuhfshafhkjasd");
        System.out.println("hsuhfshafhkjasd");
        System.out.println("hsuhfshafhkjasd");
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.request = request;
        this.response = response;
        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 {
            System.out.println(this);// 现在访问的baseServlet的子类
            // 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<String, String[]> 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) {
                    // 方法上的ResponseTypeAnnotation注解
                    ResponseTypeAnnotation responseTypeAnnotation = null;
                    // 获取方法上的所有的注解
                    Annotation[] annotations = method.getAnnotations();
                    // 遍历annotations
                    for (Annotation annotation : annotations) {
                        // annotation.annotationType():获取注解类的类型-->Class
                        // ResponseTypeAnnotation.class:ResponseTypeAnnotation的类型
                        if (annotation.annotationType() == ResponseTypeAnnotation.class) {
                            responseTypeAnnotation = (ResponseTypeAnnotation) annotation;
                            break;
                        }
                    }

                    String content = result.toString();
                    if (responseTypeAnnotation != null) {
                        ResponseEnum type = responseTypeAnnotation.type();
                        if (type.equals(ResponseEnum.AJAX)) {
                            PrintWriter writer = response.getWriter();
                            writer.write(content);
                            writer.flush();
                            writer.close();
                        } else if (type.equals(ResponseEnum.FORWARD)) {
                            request.getRequestDispatcher(content).forward(request, response);
                        } else if (type.equals(ResponseEnum.REDIRECT)) {
                            response.sendRedirect(content);
                        }
                    } else {
                        PrintWriter writer = response.getWriter();
                        writer.write(content);
                        writer.flush();
                        writer.close();
                    }
                }
            }
        } catch (IllegalAccessException | InvocationTargetException | NoSuchFieldException | InstantiationException e) {
            e.printStackTrace();
        }
    }
}

public class ConvertEntity {

    /**
     * 将map集合封装为实体类对象
     */
    public static <T> T convertEntityByData(Map<String, String[]> parameterMap, Class<T> tClass)  throws NoSuchFieldException, IllegalAccessException, InstantiationException {
        Set<String> 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 <T> boolean flagField(String fieldName, Class<T> 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 //  转发
}

now 如何使用?

@WebServlet("/product.do")
public class ProductServlet extends BaseServlet<ProductInfo> {

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

        String json = JSONObject.toJSONString(productTypeInfos);

        return json;
    }