Spring MVC系列（一）利用切面编程进行加密

最近在做基于Oauth2.0协议的认证系统，整体认证流程已经完成，但是Oauth2.0需要HTTPS配合，否则会有安全隐患。由于没有HTTPS证书，所以只有自己进行数据加密。利用切面编程可以在不改变原有模块的情况下加入加密功能，与原有模块解耦。

问题描述

以一个常见的场景举例。

• 客户端传个服务器一个用户ID和token值，服务器验证token并根据ID返回数据
• 传来的token参数已经加密，服务器要根据用户ID查出AES密钥，进行解密，再验证token，并把返回信息加密。

  基本功能

  使用Spring MVC构建这个简单的接口。

UserController类

使用@Controller注解声明控制器。@RequestMapping注解映射地址。@Autowired注解自动注入UserService对象，执行业务逻辑。@RequestParam注解绑定参数。

@Controller
@RequestMapping(value = "/user")
public class UserController {
	
	@Autowired
	@Qualifier("userService")
	private UserService userService;
	
	
	@RequestMapping(value="/message",method=RequestMethod.GET)
	public @ResponseBody UserModel message(@RequestParam("id") String id,@RequestParam("token") String token){
		return userService.message(id,token);
	}
}

UserService类

@Service注解声明服务类。从UserDao中查到用户信息并返回。

@Service("userService")
public class UserService {
	@Autowired
	@Qualifier("userDao")
	private UserDao userDao;
	
	public UserModel message(String id,String token){
		
		/*验证token......*/
		return userDao.getUserById(id);
	}
}

UserDao类

@Repository注解声明仓库类。此处模拟一个数据返回。（Spring MVC 提供的JDBC工具类还是不错的）

@Repository("userDao")
public class UserDao {

	public UserModel getUserById(String id){
		UserModel user=new UserModel();
		user.setUserName("MagicWolf");
		user.setEmail("dai.dongliang@foxmail.com");
		return user;
	}
}

UserModel类

一个简单的POJO对象

public class UserModel{
	private String userName;
	private String email;
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
}

web.xml

配置Spring MVC。此处简化了些配置，没有使用模块化配置。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="3.0">
	<!--字符过滤器-->
    <filter>
		<filter-name>CharacterEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>utf-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	    	
	<!-- spring 前端控制器 -->
	<servlet>
		<servlet-name>WebTest</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>WebTest</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
</web-app>

WebTest-Servlet.xml

Spring配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 注册注解驱动特性 -->
    <mvc:annotation-driven />  
    <!-- 开启注解装配 -->
    <context:annotation-config />
    <!-- 扫描注解 -->
    <context:component-scan base-package="com.magicwolf" />   	
    <!-- 内容视图解析器 -->
    <bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
        <property name="mediaTypes">
            <map>
                <entry key="json" value="application/json" />
            </map>
        </property>
        <property name="defaultContentType" value="application/json" />
    </bean>
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

测试

在浏览器输入http://localhost:8080/WebTest/user/message?id=123&token=123
可以看到返回了用户信息，基本功能完成。

返回值

{
    "userName": "MagicWolf",
    "email": "dai.dongliang@foxmail.com"
}

解密/加密功能

方案一：过滤器+拦截器

• Spring MVC中有拦截器可以在处理方法执行前拦截，其实内部也是用的切面编程。
• 由于`HttpServletRequest``没有提供改变请求参数的接口，所以需要包装一下，使用自己的Request。

HttpRequestWapperFilter类

在doFilter方法中，使用自己的包装类替换HttpServletRequest

public class HttpRequestWapperFilter implements Filter{
    @Override
    public void destroy() {}
    @Override
    public void init(FilterConfig arg0) throws ServletException {}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        request=new HttpRequestWapper((HttpServletRequest)request);
        chain.doFilter(request, response);
    }
}

HttpRequestWapper类

• 继承HttpServletRequestWrapper。
• Spring MVC在绑定参数过程中使用getParameterValues方法，所以我们重写这个方法。
• 增加一个私有属性key表示加密密钥。
• 如果不怕麻烦完全可以在这一步从request中得到ID参数，然后写JDBC操作查到用户密钥进行解密。但是我想在Spring中使用之前写好的数据库操作类UserDao，所以把查密钥这一步放到了拦截器中。　　

   class HttpRequestWapper extends HttpServletRequestWrapper{
       private String key;
	public HttpRequestWapper(HttpServletRequest request) {
		super(request);
	}

	@Override
	public String[] getParameterValues(String name) {
		String[] strs=super.getParameterValues(name);
		if(name.equals("id")){
			for(int i=0;i<strs.length;i++)
				strs[i]=AESCodec.decrypt(strs[i], key);//AES解密
		}
		return strs;
	}
	public void setKey(String key) {
		this.key = key;
	}
}

UserMessageInterceptor类

在拦截器里可以方便的使用SPring注入UserDao。在preHandle方法中设置key的值

    public class UserMessageInterceptor extends HandlerInterceptorAdapter{
    	@Autowired
    	@Qualifier("userDao")
    	private UserDao userDao;
    	
    	@Override
    	public boolean preHandle(HttpServletRequest request,
    			HttpServletResponse response, Object handler) throws Exception {
    		String key=userDao.getAESKeyByUserId(request.getParameter("id"));
    		((HttpRequestWapper)request).setKey(key);
    		return true;
    	}
    }
```    
#### web.xml
在配置文件中加入包装类的过滤器
``` xml
    	<filter>
    	   <filter-name>HttpWapperFilter</filter-name>
    	   <filter-class>com.magicwolf.HttpRequestWapperFilter</filter-class>
    	</filter>
    	<filter-mapping>
    	   <filter-name>HttpWapperFilter</filter-name>
    	<url-pattern>/*</url-pattern>
    	</filter-mapping>

WebTest-Servlet.xml

加入拦截器配置

<mvc:interceptors>    
   <mvc:interceptor>    
       <mvc:mapping path="/user/**" />  
       <bean class="com.magicwolf.UserMessageInterceptor"></bean>    
   </mvc:interceptor>  
</mvc:interceptors>

测试

• 在浏览器输入http://localhost:8080/WebTest/user/message?id=123&token=0lCQPVTc8WCNP2FxocbC7Q==
• 此时token值已经经过加密，在控制器message方法中打印token参数，可以成功打印出123

返回信息加密

返回信息的加密原理上跟解密一样，而且本文重点也不在这，所以这里就简单说一下思路。

• 包装HttpServletResponse对象，添加一个toByteArray()方法返回输出缓冲区的内容
• 在过滤器中先调用doFilter执行请求，之后使用toByteArray()方法得到缓冲区字节，在进行加密。

方案二：切面编程

使用了Spring的AOP后，解决这个问题就变的轻松加愉快了。关于AOP这里就不做详细描述了。

AESAspect类

声明切面。

• @Component注解用于声明组件。
• @Aspect注解用于声明切面。
• @Pointcut注解声明切点，括号里是切点表达式，这里定位到UserService类的message方法
• @Around声明是环绕通知方法

@Component("AESAspect")
@Aspect
public class AESAspect {

	@Autowired
	@Qualifier("userDao")
	private UserDao userDao;

	@Pointcut("execution(* com.magicwolf.UserService.message(..))")
	public void messagePointcut() {}

	@Around("messagePointcut()")
	public UserModel messagePointcut(ProceedingJoinPoint point) throws Throwable {
		Object[] args = point.getArgs();
		String id = (String) args[0];
		String key = userDao.getAESKeyByUserId(id);
		AESCodec.decrypt((String) args[1], key);
		// 执行
		UserModel result = (UserModel) point.proceed(args);
		// 返回值加密
		result.encrypt(key);
		// 返回结果
		return result;
	}
}

UserModel类

在UserModel中添加一个加密成员变量的方法

public void encrypt(String key){
	this.userName=AESCodec.encrypt(userName, key);
	this.email=AESCodec.encrypt(email, key);
}

WebTest-servlet.xml

更改代理方式，使用cglib代理来替换JDK代理。

    <aop:aspectj-autoproxy proxy-target-class="true" />
```   
#### 测试
在浏览器中输入`http://localhost:8080/WebTest/user/message?id=123&token=0lCQPVTc8WCNP2FxocbC7Q==`  
##### 返回值
此时返回值已经加密
``` json
    {
    userName: "U/6CJMzF1IRV/HpEjDJPEQ==",
    email: "kQAV7t4611RYADmDC69odyQmES+MXv+p4OmYMC8fSoU="
    }

总结

• 通过两种方法的对比可以看到，使用切面编程，模块间耦合程度很低，架构清晰，易于实现。
• 但是这仅仅是一个小小的测试，如果项目规模扩大，想要织入一个功能就需要经过精心的设计，从何处切入，切点如何组织都是需要考虑的。如果没设计好，切面部位或许将成为一个重灾区（认证系统里的加密切面就显得有些凌乱，庞杂，但我也不知道该如何优化）
• 还有个小问题，拦截器里应该是可以直接对request对象进行包装的，可是我在拦截器里进行包装却没有效果，可能是此处的request对象只是一个拷贝吧。