动态代理的深入了解

总结结构：

   静态代理模式的缺点：

      1、如果一个系统中有100Dao，则创建100个代理对象

      2、如果一个dao中有很多方法需要事务，则代理对象的方法中重复代码还是很多

      3、由第一点和第二点可以得出：proxy的重用性不强

 

因为静态代理无法满足开发需求所以 引出动态代理

 

动态代理模式：

   1、产生的代理对象和目标对象实现了共同的接口

       jdk动态代理

   2、代理对象是目标对象的子类

       hibernate: Person person = session.load(Person.class,1L);  javassisit

       spring:cglib动态代理

 

jdk的动态代理：

   1、因为是用jdk的API做到的

   2、代理对象是动态产生的

cglib产生的代理类是目标类的子类

 

注意事项：

    1、拦截器中invoke方法体的内容就是代理对象方法体的内容

    2、当客户端执行代理对象.方法时，进入到了拦截器的invoke方法体

    3、拦截器中invoke方法的method参数是在调用的时候赋值的

 

aop:

   1、切面

        事务、日志、安全性框架、权限等都是切面  

   2、通知

      切面中的方法就是通知

   3、目标类

   4、切入点

         只有符合切入点，才能让通知和目标方法结合在一起

   5、织入：

         形成代理对象的方法的过程

         

 

好处：

   事务、日志、安全性框架、权限、目标方法之间完全是松耦合的

 

 

jdk的动态代理举例

PersonDao.java

package cn.itcast.jdkproxy.sh;

public interface PersonDao {
    public void savePerson();
    public void updatePerson();
    public void deletePerson();
}

PersonDaoImpl.java

package cn.itcast.jdkproxy.sh;

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

Transaction.java

package cn.itcast.jdkproxy.sh;

public class Transaction {
    public void beginTransaction(){
        System.out.println("开启事务 ");
    }
    public void commit(){
        System.out.println("事务提交");
    }
}

PersonInterceptor.java

package cn.itcast.jdkproxy.sh;

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

/**
 * 拦截器
 * @author Think
 *   1、引入目标类
 *   2、引入事务
 *   3、通过构造函数给目标类和事务赋值
 *   4、填充invoke方法
 *
 */
public class PersonInterceptor implements InvocationHandler{
    
    private Object target;//目标类
    private Transaction transaction;//引入事务
    
    public PersonInterceptor(Object target,Transaction transaction){
        this.target = target;
        this.transaction = transaction;
    }
    

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        this.transaction.beginTransaction();
        method.invoke(this.target, args);//调用目标类的方法
        this.transaction.commit();
        return null;
    }

}

ProxyTest.java

package cn.itcast.jdkproxy.sh;

import java.lang.reflect.Proxy;

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

public class ProxyTest {
    @Test
    public void test(){
        Object target = new PersonDaoImpl();
        Transaction transaction = new Transaction();
        PersonInterceptor interceptor = new PersonInterceptor(target, transaction);
        /**
         * 1、目标类的类加载器
         * 2、目标类实现的所有的接口
         * 3、拦截器
         */
        PersonDao personDao = (PersonDao)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), interceptor);
        personDao.deletePerson();
    }
}

实现jdk的动态代理，以上例子的改进可以在PersonInterceptor.java中添加成员函数

private List<Interceptor> interceptors;

然后让切面都继承 Interceptor接口，这个接口是自己定义的。

 

改进版例子：

package cn.itcast.jdkproxy.salary;

public interface Interceptor {
    public void interceptor();
}

 

其它类：很多

package cn.itcast.jdkproxy.salary;

public class Logger implements Interceptor{

    @Override
    public void interceptor() {
        // TODO Auto-generated method stub
        System.out.println("logging");
    }
    
}

 

 

package cn.itcast.jdkproxy.salary;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.List;

public class SalaryInterceptor implements InvocationHandler{

    
    private Object target;
    
    private List<Interceptor> interceptors;
    
    public SalaryInterceptor(Object target,List<Interceptor> interceptors){
        this.target = target;
        this.interceptors = interceptors;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        for(Interceptor interceptor:interceptors){
            interceptor.interceptor();
        }
        method.invoke(this.target, args);
        return null;
    }

}

客户端测试类

package cn.itcast.jdkproxy.salary;

import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class SalaryTest {
    @Test
    public void test(){
        Object target = new SalaryManagerImpl();
        Logger logger = new Logger();
        Security security = new Security();
        Privilege privilege = new Privilege();
        List<Interceptor> interceptors = new ArrayList<Interceptor>();
        interceptors.add(logger);
        interceptors.add(security);
        interceptors.add(privilege);
        SalaryInterceptor interceptor = new SalaryInterceptor(target, interceptors);
        SalaryManager salaryManager = (SalaryManager)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), interceptor);
        salaryManager.showSalary();
    }
}