Spring三种代理方式

一.静态代理

代理对象要实现与目标对象一样的接口；
eg：
    保存用户
    UserDao（save）直接保存
    UserDaoProxy 给保存方法添加事务处理

IUserDao.java 目标对象实现接口
public interface IUserDao{
    void save();
}

UserDao.java  目标对象
public class UserDao{
    public void save(){
      System.out.println("已经保存数据")
    }
}

ProxyFactory.java  代理对象
public class ProxyFactory implements IUserDao{
//维护一个目标对象
private IUserDao target;
public ProxyFactory(target){
this.target=target;
  }
}
public void save(){
    System.out.println("事务开启");
    target.save();
    System.out.println("事务关闭");
}

TestMain.java
public class TestMain{
    @Test
    public void test(){
        IUserDao target =new UserDao();
        IUserDao proxy=new ProxyFactory(target);
        proxy.save();
    }
}

总结静态代理：
1）可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。
2）缺点：
    --》  因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。
    --》  一旦接口增加方法，目标对象与代理对象都要维护。

二.动态代理

1）代理对象，不需要实现接口；
2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);
3) 动态代理， JDK代理， 接口代理；
JDK中生成代理对象的API：
|– Proxy
static Object newProxyInstance(
ClassLoader loader, 指定当前目标对象使用类加载器
Class<？>[] interfaces, 目标对象实现的接口的类型
InvocationHandler h 事件处理器
)

IUserDao.java  UserDao.java 同上

//代理工厂不用实现IUserDao
public class ProxyFactory{

    //维护一个目标对象
    private Object target;

    public ProxyFactory(Object target){
        this.target=target;
    }

    //生成代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
        target.getClass().getClassLoader(),
        target.getClass().getInterfaces(),
        new InvacationHandler(){
        @Override
        public Object invoke(Object proxy,Method method,Ojbect[] args)
            throws Throwable{
            System.out.println("开启事务");
            //执行目标对象方法
            Object returnValue=method.invoke(target,args);
            System.out.println("提交事务");
            return returnValue;
            }
        });
    }
}

App.java
public class App{
    IUserDao target =new UserDao();
    IUserDao proxy=new ProxyFactory(target).getProxyInstance();
    proxy.save();

}


动态代理总结：
代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！
(class  $Proxy0  implements IuserDao)



思考：
    有一个目标对象，想要功能扩展，但目标对象没有实现接口，怎样功能扩展？
    Class  UserDao{}
    // 子类的方式
    Class subclass  extends  UserDao{}

    以子类的方式实现(cglib代理)

三.cglib代理
Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。

 JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。
 CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
 CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

Cglib子类代理：
    1) 需要引入cglib – jar文件， 但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。
    2）引入功能包后，就可以在内存中动态构建子类
    3）代理的类不能为final， 否则报错。
    4） 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。


在Spring的AOP编程中，
    如果加入容器的目标对象有实现接口，用JDK代理；
    如果目标对象没有实现接口，用Cglib代理；

    没有IUserDao了已经
    UserDao 同上

    ProxyFactory.java
    public class ProxyFactory implements MethodInterceptor{
        private Object target;
        public ProxyFactory(Object target){
            this.target=target;
        }

        // 给目标对象创建代理对象
        public Object getProxyInstance(){
            //1. 工具类
            Enhancer en = new Enhancer();
            //2. 设置父类
            en.setSuperclass(target.getClass());
            //3. 设置回调函数
            en.setCallback(this);
            //4. 创建子类(代理对象)
            return en.create();
        }

        @Override
        public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy proxy) throws Throwable{

            System.out.println("开启事务");
            Object returnValue=method.invoke(target,args);
            System.out.println("关闭事务");
            return returnValue;
        }
    }

    App.java
    public class App{
        @Test
        public void test(){
            UserDao target=new UserDao();
            UserDao proxy=(UserDao)new ProxyFactory(target).getProxyInstance();
            proxy.save();
        }
    }