Spring之AOP面向切片

   一、理论基础：

AOP（Aspectoriented programming）面向切片/服务的编程，在Spring中使用最多的是对事物的处理。而AOP这种思想在程序中很多地方可以使用的，比如说，对某些规则的验证，可以抽象封装到一个模块中，并在该模块中定义一定的使用规则，然后植入到原有的程序中，其实这就是面向切片。这个模块叫做Aspect，定义的规则是pointcut，具体的验证的实现是advice，植入的目标叫TargetObject，切入到目标中的方法叫做joinpint，植入的过程叫weave。

Advice在模块中关注点的具体位置有：前、后或者抛出   Before、After、Throw 三种：

Before Advice	代用之前的处理
After Advice	调用之后的处理
Throw Advice	调用的时候抛出的异常处理

二、实践：

有了理论基础后，重点还是在程序中使用。下面的实例使用注解和配置两种方式，实现对添加用户的方法的验证服务的切入。

1、Anotation注解的方式：

1.首先定义业务逻辑接口UserManager类的方法：

public interface UserManager {

	public void addUser(String username, String password);

	public void delUser(int userId);

	public String findUserById(int userId);

	public void modifyUser(int userId, String username, String password);
}

2.UserManagerImpl类定义接口的实现：

public class UserManagerImpl implements UserManager {

	public void addUser(String username, String password) {
				System.out.println("---------UserManagerImpl.add()--------");
	}

	public void delUser(int userId) {
			System.out.println("---------UserManagerImpl.delUser()--------");
	}

	public String findUserById(int userId) {
				System.out.println("---------UserManagerImpl.findUserById()--------");
		return "张三";
	}

	public void modifyUser(int userId, String username, String password) {

		System.out.println("---------UserManagerImpl.modifyUser()--------");
	}
}

3.SecurityHandler定义要切入的方法：

@Aspect
public class SecurityHandler {

	/**
	 * 定义Pointcut，Pointcut的名称为addAddMethod()，此方法没有返回值和参数
	 * 该方法就是一个标识，不进行调用
	 */
	@Pointcut("execution(* add*(..))")
	private void addAddMethod(){};

	/**
	 * 定义Advice，表示我们的Advice应用到哪些Pointcut订阅的Joinpoint上
	 */
	@Before("addAddMethod()")
	//@After("addAddMethod()")
	private void checkSecurity() {
		System.out.println("-------checkSecurity-------");
	}
}

Anotation注解规则：

@Aspect表示注解的类是抽象的服务方法模块；

@Pointcut定义服务的使用规则，也就是服务方法要应用到目标类中哪些方法上。

@Pointcut("execution(*add*(..))") 第一个*表示不论是否有返回值，所有以add开头的方法，不管是否有参数。

private voidaddAddMethod(){};该方法只是注解模式中一个空的方法体，是一个模式化的方法定义结构，该方法不能有返回值，不能有任何参数，也不能对其进行实现。在Advice中要使用该方法名的标识。

Advice注解checkSecurity()方法，表示该方法是具体的服务方法，使用注解的方式，Advice不出现，而是使用上面理论部分提到的使用@After、@Befor、@Throw来表示，同时要在Advice中关联pointcut中定义的规则。

4.Client客户端调用：

public class Client {

	public static void main(String[] args) {
		BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserManager userManager = (UserManager)factory.getBean("userManager");
		userManager.addUser("张三", "123");
	}

}

AspecJ是通过applicationContext.xml文件中的配置，依据SecurityHandler类中的Anotation规则，将服务方法切入到UserManagerImpl类中的方法中的，所以，在客户端使用的时候要通过工厂取得UserManager对象。

5.applicationContext.xml文件中注入AspectJ的AOP服务：

  <!-- 启用AspectJ对Annotation的支持 -->
	<aop:aspectj-autoproxy/>           

	<bean id="userManager" class="com.xxx.spring.UserManagerImpl"/>

	<bean id="securityHandler" class="com.xxx.spring.SecurityHandler"/>

2、配置文件的方式：

注解的方式灵活性不够，不便于业务的修改，下面是使用配置文件的方式：

接口和实现接口类的方法以及在客户端的调用都是一样的，这里略。

1.SecurityHandler类像其他普通类一样，定义服务的方法即可：

public class SecurityHandler {

	private void checkSecurity() {
		System.out.println("-------checkSecurity-------");
	}
}

2.重点是applicationContext.xml文件的配置：

<?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:aop="http://www.springframework.org/schema/aop"
	     xmlns:tx="http://www.springframework.org/schema/tx"
	     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
	<bean id="userManager" class="com.bjpowernode.spring.UserManagerImpl"/>
	<bean id="securityHandler" class="com.bjpowernode.spring.SecurityHandler"/>

	<aop:config>
		<aop:aspect id="securityAspect" ref="securityHandler">
			<!--
			以add开头的方法
			<aop:pointcut id="addAddMethod" expression="execution(* add*(..))"/>
			 -->
			 <!--
			 com.bjpowernode.spring包下所有的类所有的方法
			<aop:pointcut id="addAddMethod" expression="execution(* com.bjpowernode.spring.*.*(..))"/>
			 -->
			<aop:pointcut id="addAddMethod" expression="execution(* com.bjpowernode.spring.*.add*(..)) || execution(* com.bjpowernode.spring.*.del*(..))"/>
			<aop:before method="checkSecurity" pointcut-ref="addAddMethod"/>
		</aop:aspect>
	</aop:config>
</beans>

注意到：

1.      Pointcut的匹配规则很灵活，可以使用|| 也可以指定包下的类。

2.      采用配置文件的方法是将服务模块Aspect通过DI注入的方式

3.      配置文件的方式不同于注解的方式，不需要在配置文件中显式的启用AspectJ对Annotation的支持。

3、参数的传递：

在Advice的方法中使用JoinPoint对象可以取得客户端传入的参数值和调用的方法名：

public class SecurityHandler {

	private void checkSecurity(JoinPoint joinPoint) {
		for (int i=0; i<joinPoint.getArgs().length; i++) {
			System.out.println(joinPoint.getArgs()[i]);
		}

		System.out.println(joinPoint.getSignature().getName());

		System.out.println("-------checkSecurity-------");
	}
}

4、使用CGLIB的方式：

如果UserManagerImpl不是实现UserManager接口，那么就需要使用CGLIB的方式，这时候工厂返回的不是UserManager接口对象。

1.UserManagerImpl类：

public class UserManagerImpl {

	public void addUser(String username, String password) {

		System.out.println("---------UserManagerImpl.add()--------");
	}

	public void delUser(int userId) {

		System.out.println("---------UserManagerImpl.delUser()--------");
	}

	public String findUserById(int userId) {

		System.out.println("---------UserManagerImpl.findUserById()--------");
		return "张三";
	}

	public void modifyUser(int userId, String username, String password) {

		System.out.println("---------UserManagerImpl.modifyUser()--------");
	}

}

2.客户端Client：修改返回值

public class Client {

	public static void main(String[] args) {
		BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");

		//UserManager userManager = (UserManager)factory.getBean("userManager");
		UserManagerImpl userManager = (UserManagerImpl)factory.getBean("userManager");

		userManager.addUser("张三", "123");

	}

}

这里需要注意的是：

如果UserManagerImpl实现了UserManager接口，那么默认情况下，AspectJ采用jdk的动态代理，返回的是UserManager接口的动态代理对象；

如果UserManagerImpl不是实现了UserManager接口这种方式，那么，AspectJ就会使用CGLIB的方式返回UserManagerImpl的一个CGLIB对象。

Jdk的动态代理和CGLIB实现机制的区别：

Jdk基于接口实现：JDK动态代理对实现了接口的类进行代理

CGLIB基于继承：CGLIB代理可以对类代理，主要对指定的类生成一个子类，因为是继承，所以，目标类最好不要使用final声明。

通常情况下，鼓励使用jdk代理，因为业务一般都会抽象出一个接口，而且不用引入新的东西。

如果是遗留的系统，以前没有实现接口，那么只能使用CGLIB。

三、对比动态代理的实现服务切入：

动态代理的实现：接口和实现的方法不变，这里代码略。

1.动态代理类SecurityHandler：

public class SecurityHandler implements InvocationHandler {

	private Object targetObject;

	public Object createProxyInstance(Object targetObject) {
		this.targetObject = targetObject;
		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
							   targetObject.getClass().getInterfaces(),
							   this);
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		checkSecurity();

		//调用目标方法
		Object ret = method.invoke(targetObject, args);

		return ret;
	}

	private void checkSecurity() {
		System.out.println("-------checkSecurity-------");
	}
}

2.客户端Client：

public class Client {

	public static void main(String[] args) {
		SecurityHandler hander = new SecurityHandler();
		UserManager useraManager = (UserManager)hander.createProxyInstance(new UserManagerImpl());
		useraManager.addUser("张三", "123");
	}

}

对比Spring的IOC和AOP，动态代理有几点是不同的：

1.动态代理使用new的方式创建接口的代理服务类。

2.代理类中将需要添加将服务方法植入到目标类方法中的代码。

3.需要在客户端维护接口类的实现，不够灵活。

四、结尾感触：

Aop面向切片（服务）的编程时一种思想，在学习框架使用的时候，更应该学习这种设计思路，这是架构的基础，也是灵活架构的灵魂所在。