Spring AOP

AOP
Spring　AOP:面象切面编程，即织入增强，以子类的形式去扩展及重写。核心通过代理类去实现，例如服务层中的一个Server类中有几个方法添加用户，删除用户，更新用户，查询用户信息，分别调用Dao层中添加用户，删除用户，更新用户，查询用户信息的方法，但在调用前需要做性能测试，日志记录，事务启动等动作。结束后需要做性能测试结果报告，日志结束，事务的提交等操作，发生异常时需要使用异常处理逻辑，此时将性能测试，日志记录，事务，及异常处理逻辑抽取出来，交由代理，还服务层一块纯净的空间，在调用Server类中的方法时，先由代理将事务等方法织入并执行。

实现核心：JDK动态代理和CGLib代理组成
两者的区别：
一、 JDK动态代理代理的目标类需要实现接口，而CGLib则不需要类去实现接口。
二、 JDK使用的是JAVA反射机制生成，而CGLib则是生成了一个新的子类。

织入的方式有三种：
a. 编译期织入，要求使用特殊的JAVA编译器。
b. 类装载期织入，要求使用特殊的类装载器。
c. 运行期织入，在运行期为目标类添加增强生成子类的方式。
Spring采用动态代理织入，而AspectJ采用的是编译期织入，类装载期织入。

切点五个位置：
a. @Before()　执行目标类方法前
b. @AfterReturning()　执行目标类方法后
c. @After()　无论如何都会执行
d. @AfterThrowing()　异常产生时执行
e. @Around()　有固定的格式，在方法执行前后，可取代@Before()，@AfterReturning()。其固定格式为：
@Around("anyMethod()")
public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
// start stopwatch
System.out.println("进入方法");
Object retVal = pjp.proceed();
System.out.println("退出方法");
// stop stopwatch
return retVal;
}
注意：@Before()可接受目标类方法的传递参数。@AfterReturning()接受目标类方法返回值，做为其参数传递。@AfterThrowing()可接收发生的异常

Spring AOP实现具体步骤：
１. 编写Service层的接口。
２. 编写Service层的接口实现类。
３. 编写切面类及增强的方法。
４. 在配置文件中配置。
５. 调试。

package org.service.person;

public interface PeronService {
	public void savePserson(String name);
	public void updatePerson(String name,Integer personID);
	public String getPersonName(Integer personID);
}

package org.service.person.imp;

import org.service.person.PeronService;

public class PersonServiceImp implements PeronService {
	private String name = null;

	public PersonServiceImp() {
	}

	public PersonServiceImp(String name) {
		this.name = name;
	}

	public void savePserson(String name) {
		System.out.println("savePserson方法");
	}

	public void updatePerson(String name, Integer personID) {
		throw new RuntimeException("我是例外");
		// System.out.println("updatePerson方法");
	}

	public String getPersonName(Integer personID) {
		System.out.println("getPersonName方法");
		return "xxxx";
	}

	public String getName() {
		return this.name;
	}

}

package org.service.person.intercep;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class InterceptPersonservice {
	@Pointcut("execution(* org.service.person..*(..))")
	public void anyMethod() {
	}

	@Before("anyMethod() && args(name)")
	public void doBefore(String name) {
		System.out.println("我是前置增强:" + name);
	}

	@AfterReturning(pointcut = "anyMethod()", returning = "result")
	public void doAfterReturning(String result) {
		System.out.println("我是后置增强:" + result);
	}

	@After("anyMethod()")
	public void doAfter() {
		System.out.println("我是最终增强");
	}

	@AfterThrowing(pointcut = "anyMethod()", throwing = "e")
	public void doAfterThrowing(Exception e) {
		System.out.println("我是异常增强:" + e);
	}

	@Around("anyMethod()")
	public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
		// start stopwatch
		System.out.println("进入方法");
		Object retVal = pjp.proceed();
		System.out.println("退出方法");
		// stop stopwatch
		return retVal;
	}

}

<?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"
	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">

	<!-- <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" 
		/> -->

	<aop:aspectj-autoproxy>
		<!-- Explicit testing the whitespace body variant here -->
	</aop:aspectj-autoproxy>

	<bean id="personServiceImp" class="org.service.person.imp.PersonServiceImp" />
	<bean id="interceptPersonservice" class="org.service.person.intercep.InterceptPersonservice" />
</beans>

package org.junit.test;

import org.junit.Test;
import org.proxy.CGLibFactory;
import org.proxy.ProxyFactory;
import org.service.person.PeronService;
import org.service.person.imp.PersonServiceImp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAOPTest {

	@Test
	public void springAOPTest() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
				"org/service/person/springAop.xml");
		PeronService peronService = (PeronService) applicationContext
				.getBean("personServiceImp");
		peronService.savePserson("xx");
		System.out.println("---------------------");
		peronService.getPersonName(2);
		System.out.println("---------------------");
		peronService.updatePerson("xx", 2);
	}
}

JDK编写代理类

package org.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.service.person.imp.PersonServiceImp;

public class ProxyFactory implements InvocationHandler{
	private Object object;
	public Object createProxyInstace(Object object){
		this.object = object;
		return Proxy.newProxyInstance(this.object.getClass().getClassLoader(), this.object.getClass().getInterfaces(), this);
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		PersonServiceImp personServiceImp = (PersonServiceImp) this.object;
		Object result = null;
//		System.out.println(personServiceImp.getName());
		if (personServiceImp.getName()!=null) {
			result = method.invoke(this.object, args);
		}
		return result;
	}
}

CGLib实现

package org.proxy;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.service.person.imp.PersonServiceImp;

import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGLibFactory implements MethodInterceptor{
	private Object object;
	public Object createCGLibInstace(Object object){
		this.object = object;
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(this.object.getClass());
		enhancer.setCallback(this);
		return enhancer.create();
	}
	public Object intercept(Object arg0, Method arg1, Object[] arg2,
			MethodProxy arg3) throws Throwable {
		PersonServiceImp personServiceImp = (PersonServiceImp) this.object;
		Object result = null;
//		System.out.println(personServiceImp.getName());
		if (personServiceImp.getName()!=null) {
			result = arg3.invoke(this.object, arg2);
		}
		return result;
	}
}

测试：JDK动态代理和CGLib代理

package org.junit.test;

import org.junit.Test;
import org.proxy.CGLibFactory;
import org.proxy.ProxyFactory;
import org.service.person.PeronService;
import org.service.person.imp.PersonServiceImp;


public class ProxyTest {

	@Test
	public void personProxyTest(){
		ProxyFactory proxyFactory = new ProxyFactory();
		PersonServiceImp personServiceImp = new PersonServiceImp();
		PersonServiceImp personServiceImp2 = new PersonServiceImp("aaa");
		
		PeronService peronService = (PeronService)proxyFactory.createProxyInstace(personServiceImp);
		peronService.savePserson("xxx");
		System.out.println("----------");
		PeronService peronService2 = (PeronService)proxyFactory.createProxyInstace(personServiceImp2);
		peronService2.savePserson("xxx");
	}
	@Test
	public void cgLibTest(){
		CGLibFactory cglibFactory = new CGLibFactory();
		PersonServiceImp personServiceImp = new PersonServiceImp();
		PersonServiceImp personServiceImp2 = new PersonServiceImp("aaa");
		
		PersonServiceImp peronService = (PersonServiceImp)cglibFactory.createCGLibInstace(personServiceImp);
		peronService.savePserson("xxx");
		System.out.println("----------");
		PersonServiceImp peronService2 = (PersonServiceImp)cglibFactory.createCGLibInstace(personServiceImp2);
		peronService2.savePserson("xxx");
	}
}