Spring 模拟AOP（JDK和CGLIB动态代理）

1，使用JDK和CGLIB动态代理模拟AOP

package cn.itcast.service.impl;

interface PersonService {
	public void save(String name);
	public void update(String name, Integer personid);
	public String getPersonName(Integer personid);
}


public class PersonServiceBean implements PersonService{
	private String user = null;
	
	public String getUser() {
		return user;
	}

	public PersonServiceBean(){}
	
	public PersonServiceBean(String user){
		this.user = user;
	}

	public String getPersonName(Integer personid) {
		System.out.println("我是getPersonName()方法");
		return "xxx";
	}

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

	public void update(String name, Integer personid) {
		System.out.println("我是update()方法");
	}

}

 

package cn.itcast.aop;

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

import cn.itcast.service.impl.PersonServiceBean;
//当目标类实现了接口，我们可以使用jdk的Proxy来生成代理对象，如果没有实现接口是不能用此方法的。要用CGLIB
public class JDKProxyFactory implements InvocationHandler{
	private Object targetObject;//代理目标对象
	
	public Object createProxyIntance(Object targetObject){
		this.targetObject = targetObject;
		return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(), 
				this.targetObject.getClass().getInterfaces(), this);
	}

	/*
	* 第一个参数设置代码使用的类装载器,一般采用跟目标类相同的类装载器
	* 第二个参数设置代理类实现的接口
	* 第三个参数设置回调对象,当代理对象的方法被调用时,会委派给该参数指定对象的invoke方法
	*/
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {	//环绕通知
		PersonServiceBean bean = (PersonServiceBean) this.targetObject;
		Object result = null; 
		if(bean.getUser()!=null){
			//..... advice()-->前置通知
			try {
				result = method.invoke(targetObject, args);//把方法调用委派给目标对象
				// afteradvice() -->后置通知
			} catch (RuntimeException e) {
				//exceptionadvice()--> 例外通知
			}finally{
				//finallyadvice(); -->最终通知
			}
		}
		return result;
	}

}

package cn.itcast.aop;

import java.lang.reflect.Method;
import cn.itcast.service.impl.PersonServiceBean;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
//CGlibProxyFactory在spring中也有提供对应的jar，当目标对象没有实现接口时，不能用传统的JDK代理的实现，
public class CGlibProxyFactory implements MethodInterceptor{
	private Object targetObject;
	
	public Object createProxyIntance(Object targetObject){
		this.targetObject = targetObject;
		Enhancer enhancer = new Enhancer();//该类用于生成代理对象
		//cglib创建的代理对象，继承了目标类，并覆盖了目标类中所有非final的方法，同时在里面加一些自己的代码。
		//CGLIB可以生成目标类的子类，并重写父类非final修饰符的方法。
		//如果是final方法的话，可以测试是否能否执行被代理？？？？？？
		enhancer.setSuperclass(this.targetObject.getClass());//设置父类
		//回调，如果要回调的话，需要继承MethodInterceptor
		enhancer.setCallback(this);//设置回调用对象为本身
		//返回代理对象
		return enhancer.create();
	}

	//代理对象，被拦截到的方法，方法的参数，方法的代理对象
	public Object intercept(Object proxy, Method method, Object[] args,
			MethodProxy  methodProxy) throws Throwable {
		PersonServiceBean bean = (PersonServiceBean) this.targetObject;
		Object result = null;
		if(bean.getUser()!=null){
			result = methodProxy.invoke(targetObject, args);
		}
		return result;
	}
}

package junit.test;

import org.junit.BeforeClass;
import org.junit.Test;

import cn.itcast.aop.CGlibProxyFactory;
import cn.itcast.aop.JDKProxyFactory;
import cn.itcast.service.PersonService;
import cn.itcast.service.impl.PersonServiceBean;

public class AOPTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@Test public void proxyTest(){
		JDKProxyFactory factory = new JDKProxyFactory();
		PersonService service = (PersonService) factory.createProxyIntance(new PersonServiceBean("xxx"));
		service.save("888");
	}
	
	@Test public void proxyTest2(){
		CGlibProxyFactory factory = new CGlibProxyFactory();
		PersonServiceBean service = (PersonServiceBean) factory.createProxyIntance(new PersonServiceBean("xxx"));
		service.save("999");
	}
}

2，Spring中AOP的两种实现方式

Spring提供了两种切面声明方式：基于XML配置方式声明切面，基于注解方式声明切面。

[2-1]注解实现方式：

 

package cn.itcast.service;

public interface PersonService {
	public void save(String name);
	public void update(String name, Integer id);
	public String getPersonName(Integer id);
}

package cn.itcast.service.impl;

import cn.itcast.service.PersonService;

public class PersonServiceBean implements PersonService {

	public String getPersonName(Integer id) {
		System.out.println("我是getPersonName()方法");
		return "xxx";
	}

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

	public void update(String name, Integer id) {
		System.out.println("我是update()方法");
	}

}

package cn.itcast.service;

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 MyInterceptor {
	@Pointcut("execution (* cn.itcast.service.impl.PersonServiceBean.*(..))")
	private void anyMethod() {}//声明一个切入点
	
	@Before("anyMethod() && args(name)")
	public void doAccessCheck(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 {
		//if(){//判断用户是否在权限
		System.out.println("进入方法");
		Object result = pjp.proceed();
		System.out.println("退出方法");
		//}
		return result;
	}
	
}

 

package junit.test;


import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.itcast.service.PersonService;

public class SpringAOPTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@Test public void interceptorTest(){
		ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
		PersonService personService = (PersonService)cxt.getBean("personService");
		personService.save("xx");
	}
}

<?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: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-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
        <aop:aspectj-autoproxy/> 
        <bean id="myInterceptor" class="cn.itcast.service.MyInterceptor"/>
        <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean"></bean>
</beans>

[2-2]XML实现方式：

public class LogPrint {
	public void doAccessCheck() {}定义前置通知
	public void doReturnCheck() {}定义后置通知
    public void doExceptionAction() {}定义例外通知
	public void doReleaseAction() {}定义最终通知
	public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
		return pjp.proceed();环绕通知
	}
}

<bean id="orderservice" class="cn.itcast.service.OrderServiceBean"/>
<bean id="log" class="cn.itcast.service.LogPrint"/>
<aop:config>
  <aop:aspect id="myaop" ref="log">
  	<aop:pointcut id="mycut" expression="execution(* cn.itcast.service..*.*(..))"/>
  	<aop:before pointcut-ref="mycut" method="doAccessCheck"/>
  	<aop:after-returning pointcut-ref="mycut" method="doReturnCheck "/>
  	<aop:after-throwing pointcut-ref="mycut" method="doExceptionAction"/>
  	<aop:after pointcut-ref="mycut" method=“doReleaseAction"/>
  	<aop:around pointcut-ref="mycut" method="doBasicProfiling"/>
  </aop:aspect>
</aop:config>