场景:
实现一个自定义注解,标记的方法可以自动封装请求的返回结果。
问题描述
要实现上面的功能,我们可以考虑在过滤器中拦截到标记我们自定义注解的方法,然后符合要求的我们就自动封装我们的返回结果。
解决方案:
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注解,只有标记了注解的方法才进行结果封装。