自定义注解

场景：

实现一个自定义注解，标记的方法可以自动封装请求的返回结果。

---

问题描述

要实现上面的功能，我们可以考虑在过滤器中拦截到标记我们自定义注解的方法，然后符合要求的我们就自动封装我们的返回结果。

---

解决方案：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 定义注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface WrapResult {
}

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;
import java.lang.reflect.Method;

public class WrapResultFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化操作
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 在请求被处理前进行拦截
        if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;

            // 获取请求的URI
            String requestURI = httpRequest.getRequestURI();

            // 获取请求的方法名
            String methodName = requestURI.substring(requestURI.lastIndexOf('/') + 1);

            // 获取请求的类名
            String className = requestURI.substring(requestURI.indexOf('/', 1) + 1, requestURI.lastIndexOf('/'));

            // 获取请求的类
            try {
                Class<?> targetClass = Class.forName("your.package." + className);

                // 获取请求的方法
                Method targetMethod = null;
                for (Method method : targetClass.getDeclaredMethods()) {
                    if (method.getName().equals(methodName)) {
                        targetMethod = method;
                        break;
                    }
                }

                // 判断方法上是否标记了WrapResult注解
                if (targetMethod != null && targetMethod.isAnnotationPresent(WrapResult.class)) {
                    WrapResultWrapper wrapper = new WrapResultWrapper(httpResponse);
                    chain.doFilter(request, wrapper);
                    // 在响应被发送到客户端之前进行封装
                    wrapper.wrapResult();
                    return;
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }

        // 对于未标记注解的方法，直接放行
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
        // 销毁操作
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;

import javax.servlet.http.HttpServletResponse;
import java.io.CharArrayWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class WrapResultWrapper extends HttpServletResponseWrapper {

    private CharArrayWriter charArrayWriter = new CharArrayWriter();

    public WrapResultWrapper(HttpServletResponse response) {
        super(response);
    }

    @Override
    public PrintWriter getWriter() {
        return new PrintWriter(charArrayWriter);
    }

    public void wrapResult() throws IOException {
        // 获取原始响应
        HttpServletResponse originalResponse = (HttpServletResponse) getResponse();

        // 获取原始响应的Writer
        PrintWriter originalWriter = originalResponse.getWriter();

        // 封装返回结果
        ResultWrapper resultWrapper = new ResultWrapper();
        String content = charArrayWriter.toString();
        ApiResponse<Object> apiResponse = resultWrapper.wrap(content, Object.class);

        // 将封装后的结果转为JSON字符串
        ObjectMapper objectMapper = new ObjectMapper();
        String wrappedResult = objectMapper.writeValueAsString(apiResponse);

        // 将封装后的结果写回响应
        originalWriter.write(wrappedResult);

        // 关闭原始Writer
        originalWriter.close();
    }
}

public class ResultWrapper {

    public <T> ApiResponse<T> wrap(String content, Class<T> dataType) throws IOException {
        // 在实际应用中，可以根据业务需求进行更复杂的封装
        T data = parseContent(content, dataType);
        return new ApiResponse<>(true, "Success", data);
    }

    private <T> T parseContent(String content, Class<T> dataType) throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.readValue(content, dataType);
    }
}

public class ApiResponse<T> {

    private boolean success;
    private String message;
    private T data;

    public ApiResponse(boolean success, String message, T data) {
        this.success = success;
        this.message = message;
        this.data = data;
    }

    // Getters and setters
}

在上面的Filter中，我们获取了请求的URI，解析出请求的类名和方法名，然后通过反射获取到请求的方法。最后判断方法上是否标记了WrapResult注解，只有标记了注解的方法才进行结果封装。