Spring中的代理模式

代理模式

概念： 代理（Proxy）是一种设计模式，它提供了对目标对象另外的访问方式；即通过代理访问目标对象。好处：可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。
举例：明星<—经纪人<——-用户
目标 （代理）

Java中的代理主要分为3种：

• 静态代理
• 动态代理
• Cglib代理

---

静态代理

1） 代理对象，要实现与目标对象一样的接口；
2） 举例:
保存用户(模拟)
Dao , 直接保存
DaoProxy, 给保存方法添加事务处理

静态代理总结：
优点：
可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。
缺点：
a.因为代理对象，需要与目标对象实现一样的接口，所以会有很多代理类，类太多。
b.一旦接口增加方法，目标对象与代理对象都要维护。
解决方法：
采用代理工厂，可以使用动态代理。

举例代码：
IUserDao.java

package cn.zj2.a_static;
//接口
public interface IUserDao {
    void save();
}

UserDao.java

package cn.zj2.a_static;
/*
* 目标对象（静态代理）
* */
public class UserDao implements IUserDao{
    public void save() {
        System.out.println("-------已经保存数据-----");
    }
} 

UserDaoProxy.java

package cn.zj2.a_static;
/*
* 代理对象（静态代理）
* */
public class UserDaoProxy implements IUserDao{
    //接收保存目标对象
    private IUserDao target;
    public UserDaoProxy(IUserDao target){
        this.target=target;
    }
    public void save() {
        System.out.println("------开始事务-------");
        target.save();
        System.out.println("------结束事务-------");
    }
}

App.java

package cn.zj2.a_static;
public class App {
    public static void main(String[] args) {
        //目标对象
        IUserDao target=new UserDao();
        //代理
        IUserDao proxy=new UserDaoProxy(target);
        proxy.save();        //执行的是，代理的方法
    }
}

动态代理

1）代理对象，不需要实现接口；
2）代理对象的生成，是利用JDKAPI，动态的在内存中构建代理对象（需要我们指定创建代理对象实现接口的类型）。
3）动态代理也叫作JDK代理，或者也叫作接口代理；

JDK中生成代理对象的API：
|– Proxy
static Object newProxyInstance(
ClassLoader loader, 指定当前目标对象使用类加载器
Class interfaces, 目标对象实现的接口的类型
InvocationHandler h 事件处理器
)
动态代理总结：
代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！(class $Proxy0 implements IuserDao)
思考：
有一个目标对象，想要功能扩展，但目标对象没有实现接口，怎样功能扩展？
Class UserDao{}
// 子类的方式
Class subclass extends UserDao{}
以子类的方式实现(cglib代理)

举例代码：
IUserDao.java

package cn.zj2.a_dynamic;
//接口
public interface IUserDao {
    void save();
}

UserDao.java

package cn.zj2.a_dynamic;
/*
* 目标对象（静态代理）
* */
public class UserDao implements IUserDao{
    public void save() {
        System.out.println("------已保存数据-----");
    }
}

ProxyFactory.java

package cn.zj2.a_dynamic;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/*
 1. 给所有的dao创建代理对象【动态代理】
 2. 代理对象，不需要实现接口
 3. */
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 InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开启事物");
                        //执行目标对象方法
                        Object returnValue=method.invoke(target,args);
                        System.out.println("提交事物");
                        return returnValue;
                    }
                }
        );
    }
}

App.java

package cn.zj2.a_dynamic;
public class App {
    public static void main(String[] args) {
        //目标对象
        IUserDao target=new UserDao();
        //【原始的类型class.cn.zj2.a_dynamic.UserDao】
        System.out.println(target.getClass());

        //给目标对象，创建代理对象
        IUserDao proxy=(IUserDao)new ProxyFactory(target).getProxyInstance();
        //class $Proxy 内存中动态生成的代理对象
        System.out.println(proxy.getClass());

        //执行方法【代理对象】
        proxy.save();
    }
}

Cglib代理

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

1. 需要引入cglib-jar文件，目前在Spring的核心包里已经包含了cglib功能，所以直接引入spring-core-3.2.5.jar。
2. 代理的类不能为final类型，否则将会报错。
3. 目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法。

关于Spring的AOP中代理模式：
如果加入容器的目标对象实现了接口，那么就用JDK代理
如果目标对象没有实现接口，就用Cglib代理

举例代码：
App.java

package cn.zj3.c_cglib;

public class App {
    public static void main(String[] args) {
        //目标对象
        UserDao target = new UserDao();
        System.out.println(target.getClass());

        //代理对象
        UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法
        proxy.save();
    }
}

UserDao.java

package cn.zj3.c_cglib;
public class UserDao {
    //目标对象的方法不能为final/static,不会执行目标对象额外的业务方法
    public void save(){
        System.out.println("------已经保存数据！------");
    }
}

ProxyFactory.java

package cn.zj3.c_cglib;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/*
*Cglib子类代理工厂
* （对UserDDao在内存中动态构建一个子类对象）
* 要使用Cglib需要引入相关的jar包，需要实现MethodInterceptor接口
 */
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();
    }
    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 null;
    }
}