代理模式
代理模式(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
下一篇: 代理模式-下篇(源码解析及手动实现自己的动态代理)