• 设计模式-代理模式-静态代理和动态代理在Java中的使用示例

    场景

    代理模式(Proxy Pattern)

    租房中介、代理律师、售票黄牛、中介、婚介、经纪人、快递等，都是代理模式的实际体现。

    代理模式是指为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客户端和目标对象

    之间起到中介作用，代理模式属于结构型设计模式。

    使用代理模式两个目的：一是保护目标对象，二是增强目标对象。

    静态代理

    比如，父母为自己的孩子相亲，这个相亲的过程实现如下

    顶层接口Person代码实现

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. /**
    4.  * 人有很多行为，比如下面的谈恋爱、找对象
    5.  */
    6. public interface Person {
    7.     public void findLove();
    8. }

    儿子要找对象，实现Son类

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. public class Son implements Person{
    4.     @Override
    5.     public void findLove() {
    6.         System.out.println("儿子要求:白富美");
    7.     }
    8. }

    父亲要帮儿子相亲，实现Father类

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. public class Father {
    4.     private Son son;
    5.     public Father(Son son){
    6.         this.son = son;
    7.     }
    8.     //获取目标对象的引用
    9.     public void  findLove(){
    10.         System.out.println("父亲帮忙安排相亲");
    11.         this.son.findLove();
    12.         System.out.println("双方同意，确定关系");
    13.     }
    14. }

    注意这里：

    父亲通过构造方法获取儿子的引用，并且在findLove中进行了增强，给儿子安排了相亲，然后再

    促使儿子去谈恋爱，调用findLove方法。

    测试代码

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. public class fatherTest {
    4.     public static void main(String[] args) {
    5.         Father father = new Father(new Son());
    6.         father.findLove();
    7.     }
    8. }

    注：

    博客：
    霸道流氓气质的博客_CSDN博客-C#,架构之路,SpringBoot领域博主
    关注公众号
    霸道的程序猿
    获取编程相关电子书、教程推送与免费下载。

    静态代理业务场景举例

    看一个实际的业务场景。

    在分布式业务中，需要分库分表，分库分表之后使用Java操作时可能需要配置多个数据源。

    通过设置数据源路由来动态切换数据源。

    创建Order订单类

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. public class Order {
    4.     private Object orderInfo;
    5.     private Long createTime;
    6.     private String id;
    7.  
    8.     public Object getOrderInfo() {
    9.         return orderInfo;
    10.     }
    11.  
    12.     public void setOrderInfo(Object orderInfo) {
    13.         this.orderInfo = orderInfo;
    14.     }
    15.  
    16.     public Long getCreateTime() {
    17.         return createTime;
    18.     }
    19.  
    20.     public void setCreateTime(Long createTime) {
    21.         this.createTime = createTime;
    22.     }
    23.  
    24.     public String getId() {
    25.         return id;
    26.     }
    27.  
    28.     public void setId(String id) {
    29.         this.id = id;
    30.     }
    31. }

    创建Order持久层操作类

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. public class OrderDao {
    4.     public int insert(Order order){
    5.         System.out.println("OrderDao创建order成功!");
    6.         return 1;
    7.     }
    8. }

    创建IOrderService接口

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. public interface IOrderService {
    4.     int createOrder(Order order);
    5. }

    创建OrderService实现类

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. public class OrderService implements IOrderService{
    4.     private OrderDao orderDao;
    5.     public OrderService(){
    6.         //如果使用Spring应该是自动注入的，这里为方便，直接在构造方法中初始化
    7.         orderDao = new OrderDao();
    8.     }
    9.     @Override
    10.     public int createOrder(Order order) {
    11.         System.out.println("OrderService 调用orderDao创建订单");
    12.         return orderDao.insert(order);
    13.     }
    14. }

    然后进行静态代理，主要完成的功能是：根据订单创建时间自动按年进行分库。

    先创建数据源路由对象，使用ThreadLocal的单例实现DynamicDataSourceEntry

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. //动态切换数据源
    4. public class DynamicDataSourceEntry {
    5.     //默认数据源
    6.     public final static String DEFAULT_SOURCE = null;
    7.  
    8.     private final static ThreadLocal local = new ThreadLocal<>();
    9.  
    10.     private DynamicDataSourceEntry(){}
    11.  
    12.     //清空数据源
    13.     public static void clear(){
    14.         local.remove();
    15.     }
    16.  
    17.     //获取当前正在使用的数据源名字
    18.     public static String get(){
    19.         return local.get();
    20.     }
    21.  
    22.     //还原当前切换的数据源
    23.     public static void restore(){
    24.         local.set(DEFAULT_SOURCE);
    25.     }
    26.  
    27.     //设置已知名字的数据源
    28.     public static void set(String source){
    29.         local.set(source);
    30.     }
    31.  
    32.     //根据年份动态设置数据源
    33.     public static void set(int year){
    34.         local.set("DB_"+year);
    35.     }
    36. }

    创建切换数据源的代理类OrderServiceStaticProxy

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. import java.text.SimpleDateFormat;
    4. import java.util.Date;
    5.  
    6. public class OrderServiceStaticProxy implements IOrderService{
    7.  
    8.     private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
    9.  
    10.     private IOrderService orderService;
    11.  
    12.     public OrderServiceStaticProxy(IOrderService orderService){
    13.         this.orderService = orderService;
    14.     }
    15.  
    16.     @Override
    17.     public int createOrder(Order order) {
    18.         before();
    19.         Long time = order.getCreateTime();
    20.         Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
    21.         System.out.println("静态代理类自动分配到【DB_"+dbRouter+"】数据源处理数据");
    22.         DynamicDataSourceEntry.set(dbRouter);
    23.         orderService.createOrder(order);
    24.         after();
    25.         return 0;
    26.     }
    27.  
    28.     private void before(){
    29.         System.out.println("Proxy before method");
    30.     }
    31.  
    32.     private void after(){
    33.         System.out.println("Proxy after method");
    34.     }
    35. }

    来看测试代码

    1. package com.ruoyi.demo.designPattern.staticProxy;
    2.  
    3. import java.text.ParseException;
    4. import java.text.SimpleDateFormat;
    5. import java.util.Date;
    6.  
    7. public class StaticProxyTest {
    8.     public static void main(String[] args) {
    9.         try {
    10.             Order order = new Order();
    11.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
    12.             Date date = sdf.parse("2022/10/29");
    13.             order.setCreateTime(date.getTime());
    14.             IOrderService orderService = new OrderServiceStaticProxy(new OrderService());
    15.             orderService.createOrder(order);
    16.         }catch (ParseException e) {
    17.             e.printStackTrace();
    18.         }
    19.     }
    20. }

    运行结果

     

    动态代理-JDK实现方式

    动态代理和静态代理思路基本一致，只不过动态代理功能更加强大，随着业务的扩展适应性更强。

    还以上面找对象为例，那么动态代理能适用复杂的业务场景。

    不仅包括父亲给儿子找对象，还包括媒婆、婚介所等，所以需要一个更加通用的解决方案。

    创建媒婆类

    1. package com.ruoyi.demo.designPattern.jdkDynamicProxy;
    2.  
    3. import java.lang.reflect.InvocationHandler;
    4. import java.lang.reflect.Method;
    5. import java.lang.reflect.Proxy;
    6.  
    7. public class JDKMeipo implements InvocationHandler {
    8.  
    9.     //被代理的对象，把引用保存下来
    10.     private Object target;
    11.     public  Object getInstance(Object target) throws Exception{
    12.         this.target = target;
    13.         Class clazz = target.getClass();
    14.         return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    15.     }
    16.     @Override
    17.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    18.         before();
    19.         Object obj = method.invoke(this.target,args);
    20.         after();
    21.         return obj;
    22.     }
    23.  
    24.     private void before(){
    25.         System.out.println("我是媒婆，已经确定你的需求，开始给你找对象");
    26.     }
    27.  
    28.     private void after(){
    29.         System.out.println("合适的话，就在一起吧");
    30.     }
    31. }

    创建单身客户类

    1. package com.ruoyi.demo.designPattern.jdkDynamicProxy;
    2.  
    3. import com.ruoyi.demo.designPattern.staticProxy.Person;
    4.  
    5. public class Customer implements Person {
    6.  
    7.     @Override
    8.     public void findLove() {
    9.         System.out.println("高富帅单身优质对象");
    10.     }
    11. }

    测试代码

    1. package com.ruoyi.demo.designPattern.jdkDynamicProxy;
    2.  
    3. import com.ruoyi.demo.designPattern.staticProxy.Person;
    4.  
    5. public class jdkDynamicProxy {
    6.     public static void main(String[] args) {
    7.         try {
    8.             Person obj = (Person) new JDKMeipo().getInstance(new Customer());
    9.             obj.findLove();
    10.         } catch (Exception e) {
    11.             e.printStackTrace();
    12.         }
    13.     }
    14. }

    为加深印象，用JDK动态代理修改上面数据源动态路由的业务

    创建动态代理的类

    1. package com.ruoyi.demo.designPattern.jdkDynamicProxy;
    2.  
    3. import com.ruoyi.demo.designPattern.staticProxy.DynamicDataSourceEntry;
    4.  
    5. import java.lang.reflect.InvocationHandler;
    6. import java.lang.reflect.Method;
    7. import java.lang.reflect.Proxy;
    8. import java.text.SimpleDateFormat;
    9. import java.util.Date;
    10.  
    11. public class OrderServiceDynamicProxy implements InvocationHandler {
    12.  
    13.     private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
    14.     private Object target;
    15.     public Object getInstance(Object target){
    16.         this.target = target;
    17.         Class clazz = target.getClass();
    18.         return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    19.     }
    20.     @Override
    21.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    22.         before(args[0]);
    23.         Object object = method.invoke(target,args);
    24.         after();
    25.         return object;
    26.     }
    27.  
    28.     private void before(Object target){
    29.         System.out.println("Proxy before method");
    30.         try {
    31.             Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
    32.             Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
    33.             System.out.println("动态代理类自动分配到【DB_"+dbRouter+"】数据源处理数据");
    34.             DynamicDataSourceEntry.set(dbRouter);
    35.         } catch (Exception e) {
    36.             e.printStackTrace();
    37.         }
    38.     }
    39.  
    40.     private void after(){
    41.         System.out.println("Proxy after method");
    42.     }
    43. }

    测试代码如下

    1. package com.ruoyi.demo.designPattern.jdkDynamicProxy;
    2.  
    3. import com.ruoyi.demo.designPattern.staticProxy.IOrderService;
    4. import com.ruoyi.demo.designPattern.staticProxy.Order;
    5. import com.ruoyi.demo.designPattern.staticProxy.OrderService;
    6.  
    7. import java.text.ParseException;
    8. import java.text.SimpleDateFormat;
    9. import java.util.Date;
    10.  
    11. public class DyDataDyProTest {
    12.     public static void main(String[] args) {
    13.         Order order = new Order();
    14.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
    15.         Date date;
    16.         {
    17.             try {
    18.                 date = sdf.parse("2022/10/31");
    19.                 order.setCreateTime(date.getTime());
    20.                 IOrderService orderService = (IOrderService) new OrderServiceDynamicProxy().getInstance(new OrderService());
    21.                 orderService.createOrder(order);
    22.             } catch (ParseException e) {
    23.                 e.printStackTrace();
    24.             }
    25.         }
    26.     }
    27. }

    动态代理-CGLib方式

    还是 以上面媒婆为例

    1. package com.ruoyi.demo.designPattern.cglibDynamicProxy;
    2.  
    3.  
    4. import org.springframework.cglib.proxy.Enhancer;
    5. import org.springframework.cglib.proxy.MethodInterceptor;
    6. import org.springframework.cglib.proxy.MethodProxy;
    7.  
    8. import java.lang.reflect.Method;
    9.  
    10. public class CglibMeipo implements MethodInterceptor {
    11.  
    12.     public Object getInstance(Class clazz) throws Exception{
    13.         Enhancer enhancer = new Enhancer();
    14.         enhancer.setSuperclass(clazz);
    15.         enhancer.setCallback(this);
    16.         return enhancer.create();
    17.     }
    18.  
    19.     @Override
    20.     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    21.         //业务增强
    22.         before();
    23.         Object obj = methodProxy.invokeSuper(o,objects);
    24.         after();
    25.         return obj;
    26.     }
    27.  
    28.     private void before(){
    29.         System.out.println("我是媒婆:要按照你的要求给你找对象");
    30.     }
    31.  
    32.     private void after(){
    33.         System.out.println("如果觉得合适你们就谈恋爱吧");
    34.     }
    35. }

    创建单身客户类

    1. package com.ruoyi.demo.designPattern.cglibDynamicProxy;
    2.  
    3. public class Customer {
    4.     public void findLove(){
    5.         System.out.println("白富美");
    6.     }
    7. }

    测试代码

    1. package com.ruoyi.demo.designPattern.cglibDynamicProxy;
    2.  
    3. public class CGlibProxyTest {
    4.     public static void main(String[] args) {
    5.         try {
    6.             Customer obj = (Customer) new CglibMeipo().getInstance(Customer.class);
    7.             obj.findLove();
    8.         } catch (Exception e) {
    9.             e.printStackTrace();
    10.         }
    11.     }
    12. }

  • 相关阅读:
    NPS：使用 Windows NPS Server 部署 802.1X 无线认证（4）
    振南技术干货集：比萨斜塔要倒了,倾斜传感器快来！（1）
    遗传算法GA求解TSP问题
    自动化办公01 smtplib 邮件⾃动发送
    Android 音频框架 基于android 12
    MySQL开发技巧——行列转换
    filp_open
    网络安全工程师的职责 103.219.28.X
    ffmpeg的下载和编译(vs2022)
    初探工厂抽象模式
  • 原文地址：https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/127615676