设计模式五（代理模式-上篇）

最新推荐文章于 2023-05-31 20:45:02 发布

搬运Gong

最新推荐文章于 2023-05-31 20:45:02 发布

阅读量105

点赞数

分类专栏：设计模式文章标签：设计模式 proxy

本文链接：https://blog.csdn.net/qq_20315217/article/details/114294246

版权

设计模式专栏收录该内容

15 篇文章 0 订阅

订阅专栏

代理模式

代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。在某些情况下，一个对象不适合或不能直接引用另外一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。

在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而是调用者无感知。代理模式分为静态代理和动态代理。

代理模式的应用场景

生活中的租房中介、售票黄牛、婚介、经纪人、快递、事务代理、非入侵式日志监听等，都是代理模式的具体的实际体现。当无法或不想直接引用某个对象或访问某个对象存在困难时，可以通过代理对象来间接访问。使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。

代理模式的通用写法

下面是代理模式的通用代码展示，首先创建代理主题角色类：

public interface ISubject {
	
	void requestSubject();
}

创建真实主题角色类：

public class RealSubject implements ISubject {

    @Override
	public void requestSubject() {
        System.out.println("real service is called.");
    }

}

创建代理主题角色类：

public class Proxy implements ISubject {

    private ISubject subject;

    public Proxy(ISubject subject){
        this.subject = subject;
    }


    @Override
	public void requestSubject() {
        before();
        subject.requestSubject();
        after();
    }

    public void before(){
        System.out.println("called before request.");
    }

    public void after(){
        System.out.println("called after request.");
    }
}

测试：

public class Client {

    public static void main(String[] args) {

        Proxy proxy = new Proxy(new RealSubject());
        proxy.requestSubject();

    }
}

执行结果：
在这里插入图片描述

从静态代理到动态代理

举个栗子，有写人到了适婚年龄，其父母总是迫不及待的希望报上孙子。而现在在各种压力之下，很多人都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲，比子女自己还着急。下面来看代码实现，首先创建顶层接口 IPerson类：

public interface IPerson {

	/**
	 * 相亲寻找真爱
	 */
    void findLove();

}

儿子张三要找对象，实现ZhangSan类：

public class ZhangSan implements IPerson {

    @Override
	public void findLove() {
        System.out.println("儿子要求：肤白貌美大长腿");
    }

}

父亲张老三帮儿子相亲，实现 ZhangLaoSan 类：

public class ZhangLaosan implements IPerson {

    private ZhangSan zhangsan;

    public ZhangLaosan(ZhangSan zhangsan) {
        this.zhangsan = zhangsan;
    }

    @Override
	public void findLove() {
        System.out.println("张老三开始物色");
        zhangsan.findLove();
        System.out.println("开始交往");
    }
}

来看测试类：

public class Test {
    public static void main(String[] args) {
        ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
        zhangLaosan.findLove();
    }
}

在这里插入图片描述但上面的场景有个弊端，就是自己父亲只会给自己子女物色对象，别人家的孩子是不会管的。社会上这项业务发展成了一个产业，出现了媒婆、婚介所等，还有各种各样的定制套餐。如果还使用静态代理，成本就太高了，需要一个更加通用的解决方案，满足任何单身人士找对象的需求。这就由静态代理升级为了动态代理。采用动态代理，基本上是人（IPerson）就可以提供相亲服务。动态代理的底层实现一般不需要我们自己去亲自实现，已经有很多现成的API。在 Java 生态中，目前最普遍使用的是 JDK 自带的代理和Cglib 提供的类库。下面我们首先基于 JDK 的动态代理来升级一下上面的代码。
首先，创建媒婆类，需要实现 InvocationHandler：

public class JdkMeipo implements InvocationHandler {
    
	private IPerson target;
    public IPerson getInstance(IPerson target){
        this.target = target;
        Class<?> clazz =  target.getClass();
        return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    @Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target,args);
        after();
        return result;
    }

    private void after() {
        System.out.println("双方同意，开始交往");
    }

    private void before() {
        System.out.println("我是媒婆，已经收集到你的需求，开始物色");
    }
}

再创建一个类：

public class ZhaoLiu implements IPerson {

    @Override
	public void findLove() {
        System.out.println("赵六要求：有车有房学历高");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        JdkMeipo jdkMeipo = new JdkMeipo();
        IPerson zhangsan = jdkMeipo.getInstance(new Zhangsan());
        zhangsan.findLove();

        IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
        zhaoliu.findLove();

    }
}

运行结果如下：
在这里插入图片描述

静态代理模式在业务中的应用

可能你会觉得不知道如何将代理模式应用到业务场景中，我们来看一个实际的业务场景。在分布式业务场景中，通常会对数据库进行分库分表，分库分表之后使用 Java 操作时就可能需要配置多个数据源，我们通过设置数据源路由来动态切换数据源。先创建 Order订单类：

@Data
public class Order {
    private Object orderInfo;
	/**
	 * 订单创建时间进行按年分库
	 */
	private Long createTime;
    private String id;
}

创建订单 OrderDao 持久层类：

public class OrderDao {
    
	public int insert(Order order){
        System.out.println("OrderDao创建Order成功!");
        return 1;
    }
}

创建 IOrderService 接口：

public interface IOrderService {
	/**
	 * 创建订单
	 * @param order
	 * @return
	 */
	int createOrder(Order order);
}

创建对应实现类：

public class OrderService implements IOrderService {
    private OrderDao orderDao;

    public OrderService(){
        //如果使用Spring应该是自动注入的
        //我们为了使用方便，在构造方法中将orderDao直接初始化了
        orderDao = new OrderDao();
    }

    @Override
	public int createOrder(Order order) {
        System.out.println("OrderService调用orderDao创建订单");
        return orderDao.insert(order);
    }
}

接下来是用静态代理主要完成的功能是：根据订单创建时间，自动按照年份进行分库。根据开闭原则，我们修改原来写好的代码逻辑，通过代理对象来完成。先创建数据源路由对象，使用ThreadLocal的单例实现DynamicDataSourceEntity类：

public class DynamicDataSourceEntity {

    public final static String DEFAULE_SOURCE = null;

    private final static ThreadLocal<String> local = new ThreadLocal<>();

    private DynamicDataSourceEntity(){}

	/**
	* 获取当前使用的数据源的名字
	*/
    public static String get(){return  local.get();}

    public static void restore(){
         local.set(DEFAULE_SOURCE);
    }

    //DB_2020
    //DB_2021
    public static void set(String source){local.set(source);}

    public static void set(int year){local.set("DB_" + year);}

}

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

public class OrderServiceStaticProxy implements IOrderService {
    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    private IOrderService orderService;
    public OrderServiceStaticProxy(IOrderService orderService) {
        this.orderService = orderService;
    }

    @Override
	public int createOrder(Order order) {
        Long time = order.getCreateTime();
        Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
        System.out.println("静态代理类自动分配到【DB_" +  dbRouter + "】数据源处理数据" );
        DynamicDataSourceEntity.set(dbRouter);

        this.orderService.createOrder(order);
        DynamicDataSourceEntity.restore();

        return 0;
    }
}

测试：

public class DbRouteProxyTest {
    public static void main(String[] args) {
        try {
            Order order = new Order();

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Date date = sdf.parse("2021/03/03");
            order.setCreateTime(date.getTime());

            IOrderService orderService = new OrderServiceStaticProxy(new OrderService());
            orderService.createOrder(order);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：在这里插入图片描述结果符合我们的预期。动态代理和静态代理的基本思路是一致的，只不过动态代理的功能更加强大，随着业务的扩展，适应性更强。

动态代理在业务场景中的应用

上面的案例理解了，我们再来看数据源动态路由业务，来加深一下对动态代理的理解，创建动态代理的类OrderServiceDynamicProxy：

public class OrderServiceDynamicProxy implements InvocationHandler {

    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    Object proxyObj;
    public Object getInstance(Object proxyObj) {
        this.proxyObj = proxyObj;
        Class<?> clazz = proxyObj.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    @Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before(args[0]);
        Object object = method.invoke(proxyObj,args);
        after();
        return object;
    }

    private void after() {
        System.out.println("Proxy after method");
        //还原成默认的数据源
        DynamicDataSourceEntity.restore();
    }

    //target 应该是订单对象Order
    private void before(Object target) {
        try {
            //进行数据源的切换
            System.out.println("Proxy before method");

            //约定优于配置
            Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
            Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
            System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据");
            DynamicDataSourceEntity.set(dbRouter);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

测试代码：

public class DbRouteProxyTest {
    public static void main(String[] args) {
        try {
            Order order = new Order();

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Date date = sdf.parse("2021/03/03");
            order.setCreateTime(date.getTime());

            IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy().getInstance(new OrderService());
            orderService.createOrder(order);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述
依然能够达到相同的运行结果。但是，使用动态代理实现之后，我们不仅能实现Order 数据源的动态路由，还可以实现其他任意类的数据源动态路由。当然，有个比较重要的约定，必须实现getCreatTime()方法，因为路由规则是根据时间来运算的，我们可以通过接口规范来达到约束的目的。

本篇文章先记录于此，下一篇来进行源码分析，一探代理模式的真面目。

上一篇：建造者模式 https://blog.csdn.net/qq_20315217/article/details/114282763
下一篇：代理模式-下篇(源码解析及手动实现自己的动态代理)

搬运Gong

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式五（代理模式-上篇）

代理模式代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。在某些情况下，一个对象不适合或不能直接引用另外一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而是调用者无感知。代理模式分为静态代理和动态代理。代理模式的应用场景生活中的租房中介、售票黄牛、婚介、经纪人、快递、事务代理、非入侵式日志监听等，都是代理模式的具体的实际体现。当无法或不想直接引用某个对
复制链接

扫一扫