带你深入了解java-代理机制

更新时间：2021年08月20日 17:09:42 作者：haijiao12138

Java 有两种代理方式，一种是静态代理，另一种是动态代理。如果我们在代码编译时就确定了被代理的类是哪一个，那么就可以直接使用静态代理；如果不能确定，那么可以使用类的动态加载机制，在代码运行期间加载被代理的类这就是动态代理

1-代理模式

代理（Proxy）是一种设计模式。提供了对目标对象另外的访问方式，即通过代理对象访问目标对象，这样的优点是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。

编程思想：不随意去修改别人已经写好的代码或者方法，如果需要修改，通过代理的方式来拓展该方法。

例子：比如邀请一位明星，那么并不是直接连线邀请明星，而是联系明星的经纪人来达到同样的目的，明星就是一个目标对象，他只要负责活动中的节目，而其他琐碎的事情就交给他的代理人（经纪人）来解决，这就是生活中的一个代理的例子；

图例如下：

1.1静态代理

使用静态代理时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同的父类。

代码实例：

接口：TargetInteface.java

/**
*  接口类
*/
public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

目标对象类：Target.java，用来实现接口，实现接口，实现接口中的方法

public class Target implements TargetInteface {
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }

    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }

    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

代理对象类：TargetProxy.java

public class TargetProxy implements TargetInteface {

    @Override
    public void method1() {
        System.out.println("执行方法前...");//在此处填写自己的业务需求
        new Target().method1();
        System.out.println("执行方法后...");
    }

    @Override
    public void method2() {
        System.out.println("执行方法前...");
        new Target().method2();
        System.out.println("执行方法后...");
    }

    @Override
    public int method3(Integer i) {
        System.out.println("执行方法前...");
        int method3 = new Target().method3(i);
        System.out.println("执行方法后...");
        return method3;
    }
}

测试类：TargetUser.java

public static void main(String[] args) {
    TargetInteface target = new TargetProxy();
    target.method1();
    System.out.println("-----------------------------");
    target.method2();
    System.out.println("-----------------------------");
    System.out.println(target.method3(3));
}

运行结果如下：

静态代理总结：

1-在不修改目标对象的前提下，对功能目标进行拓展

2-缺点：因为代理对象需要和目标对象实现一样的接口，所以会有很多代理类，导致类太多；同时一旦接口增加方法，目标对象与代理对象都需要增加维护，使用动态代理解决此缺点；

1.2 动态代理

特点：

1-代理对象，不需要实现接口；

2-代理对象的生成是利用JDK的API，动态的在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口的类型）

3-动态代理也叫作JDK代理，接口代理；

JDK中生成代理对象的API

代理对象坐在的包:java.lang.reflect.Proxy

JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:

static Object newProxyInstance(
 ClassLoader loader,//指定当前目标对象使用类加载器,获取加载器的方法是固定的
 Class<?>[] interfaces,//目标对象实现的接口的类型,使用泛型方式确认类型
 InvocationHandler h )//事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

代码示例：

接口类：TargetInteface.java

public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

接口实现类：Target.java

public class Target implements TargetInteface {
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }

    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }

    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

代理工厂类：TargetProxy.java

public class TargetProxy {
    public static  <T> Object getTarget(T t) {
        return Proxy.newProxyInstance(t.getClass().getClassLoader(),
                t.getClass().getInterfaces(),
                new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // proxy就是目标对象t，method就是调用目标对象中方法，args就是调用目标对象中方法的参数。
                //比如说：代理对象.method1(),这时proxy就是目标类，method1就是method,args就是method1方法参数。
                System.out.println("执行方法前...");
                Object invoke = method.invoke(t, args);//执行目标对象方法
                System.out.println("执行方法后...");
                return invoke;
            }
        });
    }
}

测试类：TargetUser.java

    public static void main(String[] args) {
        TargetInteface target = (TargetInteface) TargetProxy.getTarget(new Target());
        target.method1();
        System.out.println("-----------------------------");
        target.method2();
        System.out.println("-----------------------------");
        System.out.println(target.method3(3));
    }

运行结果：

总结：代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理

1.2 Cglib代理

前面说的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候就可以使用以目标对象子类的方式类实现代理，成为Cglib代理；

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

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

Cglib子类代理实现方法:

1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.

2.引入功能包后,就可以在内存中动态构建子类

3.代理的类不能为final,否则报错

4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

代码示例：

目标对象类：Target.java

public class Target {
    public void method1() {
        System.out.println("method1 running ...");
    }

    public void method2() {
        System.out.println("method2 running ...");
    }

    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

Cglib代理工厂:TargetProxy.java

public class TargetProxy {

    static <T> Object getProxy(T t) {
        Enhancer en = new Enhancer(); //帮我们生成代理对象
        en.setSuperclass(t.getClass());//设置要代理的目标类
        en.setCallback(new MethodInterceptor() {//代理要做什么
            @Override
            public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("执行方法前。。。");
                //调用原有方法  
                Object invoke = methodProxy.invokeSuper(object, args);
                // Object invoke = method.invoke(t, args);// 作用等同与上面。
                System.out.println("执行方法后。。。");
                return invoke;
            }
        });
        return en.create();
    }
}

测试类：TargetUser.java

public class TargetUser {

    public static void main(String[] args) {
        Target target = (Target) TargetProxy.getProxy(new Target());
        target.method1();
    }

}

运行结果：

在Spring的AOP编程中:

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

如果目标对象没有实现接口,用Cglib代理

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注脚本之家的更多内容！

您可能感兴趣的文章:

Java基于redis和mysql实现简单的秒杀(附demo)
这篇文章主要介绍了Java基于redis和mysql实现简单的秒杀(附demo)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-02-02
java日期格式化YYYY-MM-dd遇坑指南小结
本文主要介绍了java日期格式化YYYY-MM-dd遇坑指南小结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-08-08
Java CountDownLatch的源码硬核解析
对于并发执行，Java中的CountDownLatch是一个重要的类。为了更好的理解CountDownLatch这个类，本文将通过例子和源码带领大家深入解析这个类的原理，感兴趣的可以学习一下
2022-10-10
深入Java Robot实现控制鼠标和键盘的方法详解
本篇文章是对Java中用Robot实现控制鼠标和键盘的方法进行了详细的分析介绍，需要的朋友参考下
2013-05-05
Java 8跳过本次循环,继续执行以及跳出循环,终止循环的代码实例
今天小编就为大家分享一篇关于Java 8跳过本次循环,继续执行以及跳出循环,终止循环的代码实例，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
2018-10-10
Springboot项目优雅地处理日志的方法详解
这篇文章主要介绍了Springboot项目---优雅地处理日志,本文通过实例图文相结合给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-07-07
SpringBoot选择自有bean优先加载实现方法
在一些需求中，可能存在某些场景，比如先加载自己的bean，然后自己的bean做一些DB操作，初始化配置问题，然后后面的bean基于这个配置文件，继续做其他的业务逻辑。因此有了本文的这个题目
2023-03-03
用SpringBoot Admin监控SpringBoot程序
这篇文章主要介绍了用SpringBoot Admin监控SpringBoot程序，帮助大家更好的理解和使用springboot框架，感兴趣的朋友可以了解下
2020-10-10
Java修饰符abstract与static及final的精华总结
abstract、static、final三个修饰符是经常会使用的，对他们的概念必须非常清楚，弄混了会产生些完全可以避免的错误，比如final和abstract不能一同出现，static和abstract不能一同出现，下面我们来详细了解
2022-04-04
java Scanner类的使用示例代码
这篇文章主要介绍了java Scanner类的使用,Scanner类还可以任意地对字符串和基本类型(如int和double)的数据进行分析。借助于Scanner，可以针对任何要处理的文本内容编写自定义的语法分析器，感兴趣的朋友跟随小编一起看看吧
2021-07-07