定制开发java代理模式教你中间商赚差价

🙊🙊作者主页：🔗

📔📔 精选专栏：🔗

📋📋 精彩摘要：动态代理定制开发属于程序设计中的中的代理模式。定制开发顾名思义就是为其他对定制开发象提供一种以控制对这定制开发个对象的访问。定制开发在某些情况下，定制开发一个对象不适合或者不定制开发能直接引用另一个对象，定制开发而代理对象可以在客户定制开发端和目标对象之间起到定制开发中介的作用。

💞💞定制开发觉得文章还不错的话欢定制开发迎大家点赞👍➕收藏⭐️➕评论💬支持博主🤞

📚目录

📖java定制开发代理模式教你中间商赚差价

📝1️⃣定制开发什么是代理模式（中间商）

定制开发先看大聪明买Lamborghini跑车流程

很简单，定制开发图中北京营销中心便是传说中的代理商。对于卖车这一行为总部和北京营销中心都实现。在整个大聪明买车过程中，总部充当真实卖车角色，北京营销中心充当的是代理角色。

基于上述实例，给出代理模式的定义：代理模式为其他对象提供一种以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

📝2️⃣代理模式的组成

抽象角色

通过接口或抽象类声明真实角色实现的业务方法。
代理角色实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
真实角色实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

📝3️⃣代理模式的实现

代理模式分为静态代理、动态代理。

静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。

在实际开发过程中较为常用的是动态代理，因此本文主要介绍动态代理的具体实现。

📝4️⃣动态代理实现步骤

不使用中间商

  1. /**
  2.  * 要增强的目标对象
  3.  */
  4. public class Italy implements SaleCar{
  5.     @Override
  6.     public String sale(long money) {
  7.         System.out.println("在Italy总部花" + money + "买了一辆Lamborghini");
  8.         return "入手Lamborghini";
  9.     }
  10.  
  11.     public static void main(String[] args) {
  12.         //1.创建真实角色
  13.         Italy italy=new Italy();
  14.         //调用方法
  15.         String car=italy.sale(8888);
  16.         System.out.println(car);
  17.     }
  18. }

使用中间商

1.JDK动态代理：

真实角色及其真实角色的业务接口

  1. ​
  2. /**
  3.  * 要增强的真实角色
  4.  */
  5. class Italy implements SaleCar{
  6.     @Override
  7.     public String sale(long money) {
  8.         System.out.println("在Italy总部花" + money + "买了一辆Lamborghini");
  9.         return "入手Lamborghini";
  10.     }
  11. }
  12. /**
  13.  * 要增强的目标方法
  14.  */
  15. interface SaleCar {
  16.     String sale(long money);
  17. }
  18.  
  19. ​

代理角色及增强方法

  1. public class BeiJing {
  2.     public static void main(String[] args) {
  3.         //1.创建真实角色
  4.         Italy italy=new Italy();
  5.         //2.动态代理增强
  6.         /***
  7.          * 参数列表（代码基本不变）
  8.          * 1.类加载器：真实角色.class.getClassLoader()
  9.          * 2.接口数组：真实角色.getClass().getInterfaces()
  10.          * 3.处理器 ： new InvocationHandler(){}
  11.          * 4.return：代理角色
  12.          */
  13.         SaleCar saleCar= (SaleCar) Proxy.newProxyInstance(Italy.class.getClassLoader(), italy.getClass().getInterfaces(), new InvocationHandler() {
  14.             //调用代理角色的任何方法 invoke()方法都会被执行
  15.             /***
  16.              * 参数列表（代码基本不变）
  17.              * 1.代理角色：proxy
  18.              * 2.method：代理对象调用的方法
  19.              * 3.处理器 ： new InvocationHandler(){}
  20.              * 4.args：代理角色调用方法时，传递的实际参数列表
  21.              */
  22.             @Override
  23.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  24.                 //使用真实角色调用方法
  25.                 method.invoke(italy,args);
  26.                 return null;
  27.             }
  28.         });
  29.         //3.调用方法
  30.         String car=saleCar.sale(8888);
  31.         System.out.println(car);
  32.     }
  33. }

2.Cglib 的动态代理：

真实角色

  1. public class Target {
  2.     public void method() {
  3.         System.out.println("Target running....");
  4.     }
  5. }

代理角色动态代理

  1. Target target = new Target(); //创建目标对象
  2. Enhancer enhancer = new Enhancer(); //创建增强器
  3. enhancer.setSuperclass(Target.class); //设置父类
  4. enhancer.setCallback(new MethodInterceptor() { //设置回调
  5.     @Override
  6.     public Object intercept(Object o, Method method, Object[] objects, 
  7.         MethodProxy methodProxy) throws Throwable {
  8.         System.out.println("前置代码增强....");
  9.         Object invoke = method.invoke(target, objects);
  10.         System.out.println("后置代码增强....");
  11.         return invoke;
  12.     }
  13. });
  14. Target proxy = (Target) enhancer.create(); //创建代理对象
  15. //测试,当调用接口的任何方法时，代理对象的代码都无序修改
  16. proxy.method();

📝5️⃣增强方法详解

  1. 增强参数列表 
    1. @Override
    2. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    3.       //增强参数,赚差价
    4.       long newargs = (long)args[0] - 1000;
    5.       //使用真实角色调用方法
    6.       Object invoke = method.invoke(italy, newargs);
    7.       return invoke;
    8. }

    增强效果      

  2. 增强返回值 
    1. @Override
    2.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    3.                 //增强参数,赚差价
    4.                 long newargs = (long)args[0] - 1000;
    5.                 //使用真实角色调用方法
    6.                 Object invoke = method.invoke(italy, newargs);
    7.                 return invoke + "又送了一辆游艇";
    8.             }

    增强效果      

  3. 增强方法具体实现 
    1. @Override
    2.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    3.                 //增强参数,赚差价
    4.                 long newargs = (long)args[0] - 1000;
    5.                 //增强方法
    6.                 System.out.println("专车接送");
    7.                 //使用真实角色调用方法
    8.                 Object invoke = method.invoke(italy, newargs);
    9.                 //增强方法
    10.                 System.out.println("包邮到家");
    11.                 return invoke + "又送了一辆游艇";
    12.             }

    增强效果      

📝6️⃣小结

动态代理实现方式

  1. JDK动态代理
  2. Cglib动态代理

动态代理实现步骤

  1. 代理角色和真实角色实现相同接口
  2. 使用Proxy.newProxyInstance创建代理角色
  3. 增强方法
  4. 使用代理角色调用方法
  5. 整体代码 
    1. import java.lang.reflect.InvocationHandler;
    2. import java.lang.reflect.Method;
    3. import java.lang.reflect.Proxy;
    4.  
    5. /**
    6.  * 代理角色
    7.  */
    8. public class BeiJing {
    9.     public static void main(String[] args) {
    10.         //1.创建真实角色
    11.         Italy italy=new Italy();
    12.         //2.动态代理增强
    13.         /***
    14.          * 参数列表（代码基本不变）
    15.          * 1.类加载器：真实角色.class.getClassLoader()
    16.          * 2.接口数组：真实角色.getClass().getInterfaces()
    17.          * 3.处理器 ： new InvocationHandler(){}
    18.          * 4.return：代理角色
    19.          */
    20.         SaleCar saleCar= (SaleCar) Proxy.newProxyInstance(Italy.class.getClassLoader(), italy.getClass().getInterfaces(), new InvocationHandler() {
    21.             //调用代理角色的任何方法 invoke()方法都会被执行
    22.             /***
    23.              * 参数列表（代码基本不变）
    24.              * 1.代理角色：proxy
    25.              * 2.method：代理对象调用的方法
    26.              * 3.处理器 ： new InvocationHandler(){}
    27.              * 4.args：代理角色调用方法时，传递的实际参数列表
    28.              */
    29.             @Override
    30.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    31.                 //增强参数,赚差价
    32.                 long newargs = (long)args[0] - 1000;
    33.                 //增强方法
    34.                 System.out.println("专车接送");
    35.                 //使用真实角色调用方法
    36.                 Object invoke = method.invoke(italy, newargs);
    37.                 //增强方法
    38.                 System.out.println("包邮到家");
    39.                 return invoke + "又送了一辆游艇";
    40.             }
    41.         });
    42.         //3.调用方法
    43.         String car=saleCar.sale(8888);
    44.         System.out.println(car);
    45.     }
    46. }
    47. /**
    48.  * 要增强的目标对象
    49.  */
    50. class Italy implements SaleCar{
    51.     @Override
    52.     public String sale(long money) {
    53.         System.out.println("在Italy总部花" + money + "买了一辆Lamborghini");
    54.         return "入手Lamborghini";
    55.     }
    56. }
    57. /**
    58.  * 要增强的目标方法
    59.  */
    60. interface SaleCar {
    61.     String sale(long money);
    62. }
    63.
网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发