spring(AOP)静态代理、JDK动态代理、cglib实现代理

public interface PersonDao {
public void savePerson();
}

public class PersonDaoImpl implements PersonDao{
public void savePerson() {
System.out.println("save person");
}
}

/**
* dao 代理类
* @author w7
*
*/
public class PersonDaoProxy implements PersonDao{
private PersonDao personDao;
private Transaction transaction;

public PersonDaoProxy(PersonDao personDao,Transaction transaction){
this.personDao = personDao;
this.transaction = transaction;
}

public void savePerson() {
/**
* 1、开启事务
* 2、进行save操作
* 3、事务提交
*/
this.transaction.beginTransaction();

this.personDao.savePerson();//目标对象执行的方法

this.transaction.commit();
}
}

@Test
public void testProxy(){
/**
* 创建PersonDaoImpl对象
* 创建事务对象
* 创建PersonDaoProxy对象
*/
PersonDao personDao = new PersonDaoImpl();
Transaction transaction = new Transaction();

PersonDaoProxy personDaoProxy =
new PersonDaoProxy(personDao, transaction);

personDaoProxy.savePerson();
}

//结果：
begin transaction
save person
commit

/***
接口
**/
public interface PersonDao {
public void savePerson();
public void updatePerson();
}

/**
* 实现接口类
* @author w7
*
*/
public class PersonDaoImpl implements PersonDao{
public void savePerson() {
System.out.println("save person");
}
public void updatePerson(){
System.out.println("update person");
}
}

/**
* 拦截器
*    1、把目标类和事务引入进来
*    2、完成invoke方法
*         1、开启事务
*         2、执行save person操作
*         3、事务提交
* @author zd
*/
public class PersonDaoInterceptor implements InvocationHandler{
private Object target; //目标对象
private Transaction transaction;

public PersonDaoInterceptor(Object target, Transaction transaction) {
this.target = target;
this.transaction = transaction;
}

public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if(method.getName().equals("savePerson")
||method.getName().equals("updatePerson")){

//开启事务
this.transaction.beginTransaction();

//进行save person的操作
method.invoke(target, args);//目标对象调用方法

this.transaction.commit();
}else{
method.invoke(target, args);
}
return null;
}
}
=============================================
@Test
public void testJDKProxy(){
//目标俱体实现类
Object target = new PersonDaoImpl();

//事务操作
Transaction transaction = new Transaction();
/**
*  创建一个拦截器
*/
PersonDaoInterceptor interceptor = new PersonDaoInterceptor(target, transaction);
/**
* 参数：
* 1、目标类的类加载器
* 2、目标类实现的所有的接口
* 3、拦截器
*/
PersonDao personDao = (PersonDao)Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(), interceptor);

personDao.updatePerson();
}

1、代理对象有多少方法，方法的名称是什么？
因为代理对象和目标类一样，同样的实现了接口，所以接口中有多少方法，代理对象中就有多少个方法，名称和接口中的方法的名称一样。
2、拦截器中的invoke方法在什么时候执行的？
当在客户端，代理对象调用方法的时候，进入到了invoke方法
3、拦截器中的invoke方法中的method参数在什么时候传递的值？
当在客户端，代理对象调用方法的时候，进入到了invoke方法，这个时候，method参数就是代理对象调用的方法。
4、代理对象的方法体的内容是什么？
代理对象的方法体的内容就是invoke方法体的内容
代理对象的方法体：
1、开启事务
2、目标方法
3、事务的提交
代理对象的方法体就把事务和目标方法结合在一起了，这样做的目的就是为了让目标类的目标方法和事务的方法松耦合。

public class PersonDaoImpl{
public void savePerson() {
System.out.println("save person");
}
public void updatePerson(){
System.out.println("update person");
}
}

public class Transaction {
public void beginTransaction(){
System.out.println("begin transaction");
}
public void commit(){
System.out.println("commit");
}
}

/**
* cglib 实现的代理类
* @author w7
*
*/
public class PersonDaoInterceptor implements MethodInterceptor{
private Object target;
private Transaction transaction;

/**
* 产生代理类
* @return
*/
public Object createProxy(){
Enhancer enhancer = new Enhancer();
//设置代理类的父类是目标类
enhancer.setSuperclass(target.getClass());

enhancer.setCallback(this);
return enhancer.create();
}

public PersonDaoInterceptor(Object target, Transaction transaction) {
this.target = target;
this.transaction = transaction;
}

public Object intercept(Object arg0, Method method, Object[] arg2,
MethodProxy arg3) throws Throwable {
if(method.getName().equals("savePerson")
||method.getName().equals("updatePerson")){

this.transaction.beginTransaction();

method.invoke(target, arg2);

this.transaction.commit();
}else{

method.invoke(target, arg2);
}
return null;
}
}

@Test
public void testJDKProxy(){
Object target = new PersonDaoImpl();
Transaction transaction = new Transaction();
/**
*  创建一个拦截器
*/
PersonDaoInterceptor interceptor = new PersonDaoInterceptor(target, transaction);

/**
* 1、产生的代理类是目标类的子类
*/
PersonDaoImpl proxy =
(PersonDaoImpl)interceptor.createProxy();
proxy.savePerson();
}

/**
Cglib代理
1、产生的代理类是目标类的子类
2、是用字节码增强技术产生的代理类

**/