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

JDK动态代理

/***
    接口
**/
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、事务的提交
    代理对象的方法体就把事务和目标方法结合在一起了，这样做的目的就是为了让目标类的目标方法和事务的方法松耦合。

cglib实现代理

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、是用字节码增强技术产生的代理类

**/