spring mvc统一处理接口返回值，filter过滤器和aop切面实现

对于处理接口返回值统一加密，过滤，特定值统一处理，统一返回等多种需求，您需要看一下此文章，java的拦截器前置拦截比较常用，例如：登录校验，参数格式校验等等。后置拦截没有找到好的实现方式。接下来介绍filter和aop。

filter过滤器实现

filter的执行是链式的，对于ServletRequest和ServletResponse都可以做一定的处理，通过对chain.doFilter(req, resp);的执行控制，来实现很多场景。

HttpServletResponse的包装类

ServletResponse的子接口为HttpServletResponse，我们通过创建HttpServletResponse的包装类，来实现spring往response写返回值时进行控制。

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.*;


public class ResponseWrapper extends HttpServletResponseWrapper {

   private ByteArrayOutputStream bytes = new ByteArrayOutputStream();
   private HttpServletResponse response;
   private PrintWriter pwrite;

   public ResponseWrapper(HttpServletResponse response) {
       super(response);
       this.response = response;
   }

   /**
    * 重写父类的 getWriter() 方法，将响应数据缓存在 bytes 中
    */
   @Override
   public ServletOutputStream getOutputStream() throws IOException {
       //将数据写入内部的字节流
       return new MyServletOutputStream(bytes);
   }

   /**
    * 重写父类的 getWriter() 方法，将响应数据由bytes放入pwrite中
    */
   @Override
   public PrintWriter getWriter() {
       try {
           pwrite = new PrintWriter(new OutputStreamWriter(bytes, "utf-8"));
       } catch (UnsupportedEncodingException e) {
           e.printStackTrace();
       }
       return pwrite;
   }

   /**
    * 获取缓存在 pwrite 中的响应数据
    *
    * @return
    */
   public byte[] getBytes() {
       if (null != pwrite) {
           pwrite.close();
           return bytes.toByteArray();
       }

       if (null != bytes) {
           try {
               bytes.flush();
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
       return bytes.toByteArray();
   }

   /**
    * 内部类实现流写入
    */
   class MyServletOutputStream extends ServletOutputStream {
       private ByteArrayOutputStream ostream;

       public MyServletOutputStream(ByteArrayOutputStream ostream) {
           this.ostream = ostream;
       }

       @Override
       public void write(int b) throws IOException {
           // 将数据写到 stream　中
           ostream.write(b);
       }

       @Override
       public boolean isReady() {
           return false;
       }

       @Override
       public void setWriteListener(WriteListener writeListener) {
       }
   }

}

过滤器具体实现

通过将包装类暂时替换接口的ServletResponse，拦截到接口返回值后，处理后再写回接口返回值即可。urlPatterns 指定拦截的url路径。

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebFilter(filterName = "Filter", urlPatterns = {"*.do"})
public class StringFilter implements Filter {
    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException,
            IOException {
        if (resp instanceof HttpServletResponse) {
            HttpServletResponse response = (HttpServletResponse) resp;
            ResponseWrapper mResp = new ResponseWrapper(response);
            //将包装类写入方法执行
            chain.doFilter(req, mResp);
            //获取方法返回值
            byte[] bytes = mResp.getBytes();
            String s = new String(bytes);
            //写回接口返回值
            PrintWriter writer = resp.getWriter();
            writer.write(s);
            writer.close();
            System.out.println("过滤器拦截：" + s);
        } else {
            chain.doFilter(req, resp);
        }

    }

    @Override
    public void init(FilterConfig config) throws ServletException {

    }

}

特殊说明：

不要再在web.xml内添加的配置，这样的话，过滤器会执行两次。

Aop切面实现

添加pom.xml

添加spring中的aop和aspects依赖

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>3.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
        </dependency>
        <dependency>
             <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.11</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.11</version>
        </dependency>

修改配置文件spring-servlet.xml

开启aop的自动注解，切记！
不是applicationContext.xml，是spring-servlet.xml

<aop:aspectj-autoproxy expose-proxy="true"></aop:aspectj-autoproxy>

aop类实现

Aspect的多个方法注解中，只有Around注解的方法是有返回值的，可以对方法的入参和返回值均进行操作。
@Before 在切点方法之前执行
@After 在切点方法之后执行
@AfterReturning 切点方法返回后执行
@AfterThrowing 切点方法抛异常执行
@Around 属于环绕增强，能控制切点执行前，执行后，，用这个注解后，程序抛异常，会影响@AfterThrowing这个注解

import com.alibaba.fastjson.JSONObject;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * @author john
 * @date 2019/12/19
 */
@Component
@Aspect
public class StringAop {

    @Around(value = "@annotation(org.springframework.web.bind.annotation.RequestMapping)")
    public Object afterDeal(ProceedingJoinPoint joinPoint) throws Throwable {
        Object proceed = joinPoint.proceed();
        System.out.println("方法返回值：" + JSONObject.toJSONString(proceed));

        return "修改后的返回值";
    }
}

最后简单说一下拦截器

有一个思路使用拦截器实现，只简单说一下思路，是否可以后期有时间检验，欢迎大家评论反馈

import com.edujia.coll.utils.JsonUtils;
import com.edujia.xcx.portal.redis.RedisXcxTokenManager;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.OutputStream;

public class ByteTokenInterceptor implements HandlerInterceptor {

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object object, Exception arg3)
            throws Exception {
		//拿出前置方法的ResponseWrapper 然后更新response的指向
		ResponseWrapper mResp= (ResponseWrapper) response;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object arg2, ModelAndView arg3) throws Exception {

    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
		//这里将response修改为包装类
		response = new ResponseWrapper(response);
        return true;
    }
}

拦截器的代码仅限参考思路，具体是否可以实现有待检验。

以上代码如有侵权，请与我联系。

如需转载，请注明出处和连接。