【设计模式】结构型：代理模式（一）静态代理

代理模式（Proxy Pattern）定义非常简单，是指为其他对象提供一种代理，以控制对这个对象的访问。 代理对象在客服端和目标对象之间起到中介作用，代理模式属于结构型设计模式。使用代理模式主要有两个目的：一保护目标对象，二增强目标对象。

在生活中，我们经常见到这样的场景，如：租房中介、售票黄牛、婚介、经纪人、快递、 事务代理、非侵入式日志监听等，这些都是代理模式的实际体现。

代理模式一般分为静态代理和动态代理，本篇我们先来看静态代理…

举个例子，人到了适婚年龄，父母总是迫不及待希望早点抱孙子。而现在社会的人在各种压力之下，都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲，比子女自己还着急。这个相亲的过程，就是一种我们人人都有份的代理。来看代码实现：

//  顶层接口 Person
public interface Person {
    void findLove();
} 

// 儿子要找对象，实现 Son 类
public class Son implements Person {

    public void findLove(){
        System.out.println("儿子要求：没啥要求...");
    }

    public void findJob(){
    }

    public void eat(){
    }
}

// 父亲要帮儿子相亲，实现 Father 类
public class Father implements Person {
    
    // 将 Son 组合进来
    private Son person;
    public Father(Son person){
        this.person = person;
    }

    public void findLove(){
        System.out.println("父亲物色对象");
        // 调用父类
        this.person.findLove();
        System.out.println("双方父母同意，确立关系");
    }
}

来看测试代码：

public class FatherProxyTest {

    public static void main(String[] args) {
		// 入参新建一个 Son 实例
        Father father = new Father(new Son());
        father.findLove();
    }
}

运行结果如下：

父亲物色对象
儿子要求：没啥要求...
双方父母同意，确立关系

实际业务场景示例

我们下面再来举一个实际的业务场景的例子，在分布式业务场景中，我们通常会对数据库进行分库分表，分库分表之后使用 Java 操作时，就可能需要配置多个数据源，所以，我们通过设置数据源路由来动态切换数据源。

下面是基本流程：

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

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


public interface IOrderService {
    int createOrder(Order order);
}

public class OrderService implements IOrderService {
    
    private OrderDao orderDao;

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

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

接下来使用静态代理，主要完成的功能是，根据订单创建时间自动按年进行分库。根据开闭原则，原来写好的逻辑我们不去修改，通过代理对象来完成。

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

// 实现 IOrderService 接口
public class OrderServiceStaticProxy implements IOrderService {
    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    // 被代理对象：OrderService
    private IOrderService orderService;
    public OrderServiceStaticProxy(IOrderService orderService) {
        this.orderService = orderService;
    }
	
    // 实现接口方法
    public int createOrder(Order order) {
        
        // 计算当前 Order 分配到哪个数据库
        Long time = order.getCreateTime();
        Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
        System.out.println("静态代理类自动分配到【DB_" +  dbRouter + "】数据源处理数据" );
        
		// 调用被代理对象的当前方法
        this.orderService.createOrder(order);
        
        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("2020/02/01");
            order.setCreateTime(date.getTime());

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

    }

}

运行结果如下：

静态代理类自动分配到【DB_2020】数据源处理数据
OrderService调用orderDao创建订单
OrderDao创建Order成功!