Java代理

目录

1. 代理简介

2. 代理分类

3. 静态代理

4. 基于JDK的动态代理

5. Cglib代理

---

1. 代理简介

代理：某些场景下，对象会找一个代理对象，来辅助（增强）自己完成一些工作。

2. 代理分类

• 静态代理
• 基于JDK的动态代理
• Cglib代理

3. 静态代理

需要一个接口，原对象和代理对象均要实现这个接口。

/**
 * 接口
 */
public interface IUserDao {

    void save();
}

/**
 * 接口实现
 * 目标对象
 */
public class UserDao implements IUserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}

/**
 * 代理对象,静态代理
 */
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("提交事务...");
    }
}


/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        //目标对象
        UserDao target = new UserDao();

        //代理对象,把目标对象传给代理对象,建立代理关系
        UserDaoProxy proxy = new UserDaoProxy(target);

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

可以做到在不修改目标对象的功能前提下,对目标功能扩展。

缺点：一旦接口的方法增加，原对象类和代理类都需要维护。

4. 基于JDK的动态代理

怎么解决上述静态代理的缺点，这就要说到动态代理了。

什么叫动态？我的理解就是通过反射的方法在类运行的时候获取字节码文件，然后再进行加强。

动态代理特点：

• 代理对象不需要实现接口
• 代理对象的生成是利用JDK的API
• 也叫做接口代理

原对象实现接口，代理对象使用JDK的API返回代理对象。

//接口
public interface Skill {
    public void dance();
    public void sing();
}

//原对象
public class Star implements Skill{
    private String name;

    public Star(String name) {
        this.name = name;
    }

    @Override
    public void dance() {
        System.out.println("跳舞");
    }

    @Override
    public void sing() {
        System.out.println("唱歌");
    }
}

//代理对象，返回代理类
public class StarAgentProxy {

    /**
     public static Object newProxyInstance(ClassLoader loader,
                    Class<?>[] interfaces,
                    InvocationHandler h)
     throws IllegalArgumentException返回指定接口的代理类的实例，
                                    该接口将方法调用分派给指定的调用处理程序。

     loader - 类加载器来定义代理类
     interfaces - 代理类实现的接口列表
     h - 调度方法调用的调用处理函数
    */
    public static Skill getProxy(Star obj) {
        return (Skill) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                                              obj.getClass().getInterfaces(),
                                              new InvocationHandler() {
            @Override
            /**
             * proxy:代理类代理的真实代理对象
             * method:我们所要调用某个对象真实的方法的Method对象
             * args:指代代理对象方法传递的参数
             */
            public Object invoke(Object proxy, Method method, Object[] args) 
                                throws Throwable {
                System.out.println("收首付款");
                Object res = method.invoke(obj, args);
                System.out.println("收尾款");
                return res;
            }
        });
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Star s = new Star("杨超越");
//        //原始操作
//        s.dance();
//        s.sing();
        //生成代理对象
        Skill s1 = StarAgentProxy.getProxy(s);
        s1.dance();
        s1.sing();
    }
}

动态代理中代理类不需要实现接口，但是原对象需要实现接口。有没有都不需要实现接口的方法？当然有，那就是Cglib代理

5. Cglib代理

上面说的静态代理和基于JDK的动态代理都是要求原对象实现接口，有时候没有接口要实现代理，可以以原对象的子类的方式实现代理，这种代理就叫做Cglib代理。

• Cglib代理，也叫做子类代理，它实在内存中构建一个子类对象从而实现对原对象功能的扩展。
• Cglib是一个强大的高性能代码生成包，它可以在运行期间扩展Java类与Java接口。被广泛应用许多AOP框架，例如Spring AOP。
• Cglib底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类。

实现方法：

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

/**
 * 目标对象,没有实现任何接口
 */
public class UserDao {

    public void save() {
        System.out.println("----已经保存数据!----");
    }
}


/**
 * Cglib子类代理工厂
 * 对UserDao在内存中动态构建一个子类对象
 */
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;
    }
}


/**
 * 测试类
 */
public class App {

    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();

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

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

在Spring的AOP编程中:

• 如果加入容器的目标对象有实现接口,用JDK代理
• 如果目标对象没有实现接口,用Cglib代理