Java动态代理常用方式有哪些

本篇内容介绍了"Java动态代理常用方式有哪些"的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

什么是动态代理？

动态代理就是，在程序运行期，创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。在生成代理对象的过程中，目标对象不变，代理对象中的方法是目标对象方法的增强方法。可以理解为运行期间，对象中方法的动态拦截，在拦截方法的前后执行功能操作(也可以对原方法的参数进行操作)。

代理类在程序运行期间，创建的代理对象称之为动态代理对象。这种情况下，创建的代理对象，并不是事先在Java代码中定义好的。而是在运行期间，根据我们在动态代理对象中的"指示"，动态生成的。也就是说，你想获取哪个对象的代理，动态代理就会为你动态的生成这个对象的代理对象。动态代理可以对被代理对象的方法进行功能增强。有了动态代理的技术，那么就可以在不修改方法源码的情况下，增强被代理对象的方法的功能，在方法执行前后做任何你想做的事情。

特点：字节码随用随创建，随用随加载

作用：不修改源码的基础上对方法增强

动态代理的常用两种方式：

1.基于接口的动态代理

提供者：JDK

使用JDK官方的Proxy类创建代理对象

注意：代理的目标对象必须实现接口(至少一个)

2.基于类的动态代理

提供者：第三方 CGLib

使用CGLib的Enhancer类创建代理对象

注意：被代理类不能用 final 修饰的类（最终类）。如果报 asmxxxx 异常，需要导入 asm.jar包

//JDK动态代理(基于接口的动态代理)Proxy.newProxyInstance(三个参数);        ClassLoader:类加载器                它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。（固定写法）        Class[]:字节码数组                它是用于让代理对象和被代理对象有相同方法。(固定写法)        InvocationHandler：用于提供增强的代码                它是让我们写如何代理。我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须                InvocationHandler该接口的实现类是谁用谁写，此时我们用就需要我们自己写

此处以一个演员的例子为例：

在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。

而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪人来找了。下面我们就用代码演示出来。

package com.haust.service;public interface IActor {        /**        * 基本演出        * @param money        */        public void basicAct(float money);        /**        * 危险演出        * @param money        */        public void dangerAct(float money);}

package com.haust.serviceImpl;import com.haust.service.IActor;public class Actor implements IActor {        /**        * 一个演员        */        //实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求        @Override        public void basicAct(float money) {                System.out.println("拿到钱，开始基本的表演："+money);        }        @Override        public void dangerAct(float money) {                System.out.println("拿到钱，开始危险的表演："+money);        }}

package com.haust.test;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import com.haust.service.IActor;import com.haust.serviceImpl.Actor;public class Client {        public static void main(String[] args) {                //一个剧组找演员：                final Actor actor = new Actor();//被代理的类                /**                * 代理：                * 间接。                * 获取代理对象：                * 要求：                * 被代理类最少实现一个接口                * 创建的方式                * Proxy.newProxyInstance(三个参数)                * 参数含义：                * ClassLoader：和被代理对象使用相同的类加载器。                * Interfaces：和被代理对象具有相同的行为。实现相同的接口。                * InvocationHandler：如何代理。                *                 */                //(IActor)Proxy.newProxyInstance,这里强制转换必须是接口类型                IActor proxyActor = (IActor)Proxy.newProxyInstance(actor.getClass().getClassLoader(),                                 actor.getClass().getInterfaces(),                                 new InvocationHandler() {                         /**                         * 执行被代理对象的任何方法，都会经过该方法。                         * 此方法有拦截的功能。                         *                          * 参数：                         * proxy：代理对象的引用。不一定每次都用得到                         * method：当前执行的方法对象                         * args：执行方法所需的参数                         * 返回值：                         * 当前执行被代理对象方法的返回值                         */                                        @Override                                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                                                String name = method.getName();                                                Float money = (Float) args[0];//执行的方法只有一个参数                                                Object rtValue = null;                                                //每个经纪公司对不同演出收费不一样，此处开始判断                                                if("basicAct".equals(name)){                                                //基本演出，没有 2000 不演                                                if(money > 2000){                                                //看上去剧组是给了 8000，实际到演员手里只有 4000                                                //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强                                                rtValue = method.invoke(actor, money/2);                                                } }                                                if("dangerAct".equals(name)){                                                //危险演出,没有 5000 不演                                                if(money > 5000){                                                //看上去剧组是给了 50000，实际到演员手里只有 25000                                                //这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强                                                rtValue = method.invoke(actor, money/2);                                                } }                                                return rtValue;                                        }                                });                //没有经纪公司的时候，直接找演员。                // actor.basicAct(1000f);                // actor.dangerAct(5000f);                //剧组无法直接联系演员，而是由经纪公司找的演员                proxyActor.basicAct(2000f);//价格低于2000不演                proxyActor.dangerAct(50000f);                        }}

总结：

首先需要创建一个interface然后一个class实现这个interface，然后对这个class进行代理，这个class必须实现至少一个接口

基于子类的动态代理

设计的类：Enhancer提供者：第三方cglib库如何创建代理对象：        使用Enhancer类中的create方法创建代理对象的要求：        被代理对象不是最终类(最终类没有子类)create方法的参数：        Class方法的参数：                Class：字节码                        它是用于指定被代理对象的字节码                callback：用于提供增强的代码                        它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。此接口的实现类都是谁用谁写。                        我们一般写的都是该接口的子接口实现类:MethodInterceptor//CGLib动态代理(基于子类的动态代理)Enhancer.create(两个参数);

代码如下：

package com.haust.serviceImpl;public class Actor{//没有实现任何接口        /**        * 一个演员        */        public void basicAct(float money) {                System.out.println("拿到钱，开始基本的表演："+money);        }        public void dangerAct(float money) {                System.out.println("拿到钱，开始危险的表演："+money);        }}

package com.haust.test;import java.lang.reflect.Method;import org.springframework.cglib.proxy.Enhancer;import org.springframework.cglib.proxy.MethodInterceptor;import org.springframework.cglib.proxy.MethodProxy;import com.haust.serviceImpl.Actor;public class test {        public static void main(String[] args) {                 Actor actor = new Actor();//需要创建此被代理的对象                 /**                 * 基于子类的动态代理                 * 要求：                 * 被代理对象不能是最终类                 * 用到的类：                 * Enhancer                 * 用到的方法：                 * create(Class, Callback)                 * 方法的参数：                 * Class：被代理对象的字节码                 * Callback：如何代理                 * @param args                 */                 //此时强转的类的类型就是被代理类的类型                 Actor cglibActor = (Actor)Enhancer.create(actor.getClass(),new MethodInterceptor() {                        @Override                        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy  methodProxy) throws Throwable {                                /**                                * 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何                                方法进行增强。                                *                                 * 参数：                                * 前三个和基于接口的动态代理是一样的。                                * MethodProxy：当前执行方法的代理对象。                                * 返回值：                                * 当前执行方法的返回值                                */                                String name = method.getName();                                Float money = (Float) args[0];                                Object rtValue = null;                                if("basicAct".equals(name)){                                //基本演出                                if(money > 2000){                                rtValue = method.invoke(actor, money/2);                                } }                                if("dangerAct".equals(name)){                                        //危险演出                                        if(money > 5000){                                        rtValue = method.invoke(actor, money/2);                                        }                                 }                                return rtValue;                        }                });                 cglibActor.basicAct(10000);                 cglibActor.dangerAct(100000);        }}

"Java动态代理常用方式有哪些"的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注网站，小编将为大家输出更多高质量的实用文章！