Spring 代理模式 (六)

代理概念

Proxy, 表示代理！提供了对目标对象另外的访问方式，即通过代理访问目标对象！

代理的好处

模板对象没有直接暴露给用户
代理在目标对象的基础上增加额外的验证,功能等
用户直接访问代理即可

Java中代理：

静态代理
动态代理
- Jdk 代理
- Cglib 代理
Spring默认支持

静态代理

特点

目标对象必须要实现接口
代理对象，要实现与目标对象一样的接口

IUserDao.java   dao接口
UserDao.java    dao实现
Void save();  // 保存实现
UserDaoProxy.java   dao代理类，对UserDao中功能进行扩展！
App

缺点

代理对象，需要依赖目标对象的接口！如果接口功能变化，目标对象变化，会引入代理对象的变化!
对每一个目标对象，都要分别写一个代理类，麻烦！(代理工厂)

动态代理

通常说的动态代理，就是指jdk代理!因为是通过jdk的api在运行时期，动态的生成代理对象的！
目标对象一定要实现接口,代理对象不用实现接口!

JDK 生成代理对象的Api

Proxy 
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

参数loader : 当前目标对象使用的类加载器！

参数interfaces : 当前目标对象实现的接口

参数 h: 接口类型，事件处理器.当执行目标对象方法的时候，会触发事件；把当前执行的方法(method对象)，传入事件处理器方法参数中, 这样就可以根据业务逻辑，判断是否执行目标对象方法或扩展功能！

// 接口
public interface IUserDao {
    void save();

    void find();
}

// 目标对象
public class UserDao implements IUserDao{
    @Override
    public void save() {
        System.out.println("模拟： 保存用户！");
    }

    @Override
    public void find() {
        System.out.println("查询");
    }
}

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

/**
 * 动态代理：
 *    代理工厂，给多个目标对象生成代理对象！
 * @author AdminTH
 *
 */
public class ProxyFactory {

    // 接收一个目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }

    // 返回对目标对象(target)代理后的对象(proxy)
    public Object getProxyInstance() {
        Object proxy = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),  // 目标对象使用的类加载器
                target.getClass().getInterfaces(),   // 目标对象实现的所有接口
                new InvocationHandler() {           // 执行代理对象方法时候触发
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {

                        // 获取当前执行的方法的方法名
                        String methodName = method.getName();
                        // 方法返回值
                        Object result = null;

                        // 判断
                        if ("find".equals(methodName)) {
                            // 直接调用目标对象方法
                            result = method.invoke(target, args);
                        } else {
                            System.out.println("开启事务...");
                            // 执行目标对象方法
                            result = method.invoke(target, args);
                            System.out.println("提交事务...");

                        }

                        return result;
                    }
                }
        );
        return proxy;
    }
}

public class App {

    public static void main(String[] args) {

        // 创建目标对象
        IUserDao target = new UserDao();
        System.out.println("目标对象：" + target.getClass());  // class cn.itcast.b_dynamic.UserDao

        // 代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        System.out.println("代理对象： " + proxy.getClass());  //  class $Proxy0

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

Cglib代理

也叫"子类代理",当目标对象没有实现接口，就不能使用jdk提供的代理，可以以子类的方式实现！在运行时期动态在内存中构建一个子类对象的方法，从而对目标对象扩展，这种就是cglib代理！

Spring也支持cglib代理，核心包中已经包含此功能！

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

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

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

/**
 * cglib代理：
 *    代理工厂，给多个目标对象生成代理对象！
 *
 */
public class ProxyFactory implements MethodInterceptor{

    // 接收一个目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }

    // 返回目标对象代理后的子类对象
    public Object getProxyInstance() {
        // 对target生成子类对象

        // 字节码生成工具类
        Enhancer en = new Enhancer();
        // 设置父类
        en.setSuperclass(target.getClass());
        // 设置回调函数
        en.setCallback(this);
        // 创建子类对象
        return en.create();

    }

    // 事件处理器，执行目标方法时候触发
    @Override
    public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable {
        System.out.println("开启事务...");
        Object result = method.invoke(target, args);
        System.out.println("提交事务...");
        return result;
    }
}

总结：

目标对象可以不实现接口
目标类不能为final，如果为final报错
方法如果为final/static, 不会被代理拦截！会直接执行目标对象方法！

代理总结

在SpringAop编程中，如果目标对象有实现接口，spring使用jdk提供的代理生成代理对象！如果目标对象没有实现接口，使用cglib代理！如果目标没有实现接口、且为final , 不能进行aop编程，报错！不能生成代理！

Matrix42