前言
代理模式是一种常见的设计模式,其中分为静态代理和动态代理,最近这两天简单总结了一下代理的使用,发现网上大部分教程都不太好理解,然后我总结了一下,由一个简单的需求去说明。
静态代理
代理这个词就有很多人不理解,我们身边就有很多代理,比如微商,他们并不生产任何东西,只是一个代理,那么咱们就从微商的模式来理解代理。
下面我们这里有个卖面膜的微商代理(代理了水面膜和植物面膜),首先他不生产面膜,是相应面膜工厂生产面膜,微商代理实际只负责发朋友圈宣传和交货后的收款,工厂只负责生产交付,下面就开始实例化出这个模式
定义面膜工厂接口(使用代理必须使用接口,后面代码中解释)
public interface Mask {
void getMask();
}
实现水面膜的交付
public class WaterMask implements Mask {
@Override
public void getMask() {
System.out.println("交付一个水面膜");
}
}
实现植物面膜的交付
public class PlantMask implements Mask {
@Override
public void getMask() {
System.out.println("交付一个植物面膜");
}
}
实现面膜代理
import factory.Mask;
import factory.impl.PlantMask;
import factory.impl.WaterMask;
//面膜静态代理
public class MaskStaticProxy implements Mask {
//创建一个私有的交付对象,因为会交付不同对象,这就是必须使用接口的原因
private Mask mask;
//通过构造参数得到相应交付对象
public MaskStaticProxy(Mask mask) {
this.mask = mask;
}
@Override
public void getMask() {
System.out.println("发朋友圈推销:"+mask.getClass().getSimpleName()); //交付前操作
mask.getMask(); //交付
System.out.println("收钱"); //交付后操作
}
}
测试整个流程
public static void main(String[] args) {
//实例化交付对象
Mask waterMask = new WaterMask();
Mask plantMask = new PlantMask();
//实例化不同交付对象代理
MaskStaticProxy waterStaticProxy = new MaskStaticProxy(waterMask);
MaskStaticProxy plantStaticProxy = new MaskStaticProxy(plantMask);
//代理交付
waterStaticProxy.getMask();
plantStaticProxy.getMask();
}
测试结果
发朋友圈推销:WaterMask
交付一个水面膜
收钱
发朋友圈推销:PlantMask
交付一个植物面膜
收钱
为什么要使用代理?推销过程直接在水面膜工厂和植物面膜工厂实现不好吗?
答:不够优雅,代码冗余,后期不好修改
上面就是一个静态代理的构建过程,相信大家都很好理解
动态代理
咱们微商故事继续,随着业务的不断发展壮大,我不光要卖假面膜,我还准备拓展业务,做假鞋代理
首先再来个制鞋接口
public interface Shoes {
void getShoses();
}
我们通过制鞋接口生产耐克运动鞋
public class NikeShoes implements Shoes {
@Override
public void getShoses() {
System.out.println("交付一双耐克鞋");
}
}
问题来了
现在发现我现在代理,只会代理面膜,我们可以再写一个卖鞋的代理,但是那样就会有两个代理,怎样才能一个代理实现所有业务的销售呢?
解决思路
如果有一个东西,可以生产代理,我们给他面膜他就给我面膜代理,给他鞋他就给我鞋代理就好了,这个java已经给我们实现好了,就是动态代理,我们要做的只是编写我们的业务代码,使用java提供好的动态代理绑定即可,那么我们下面去实现一个动态代理
import factory.Mask;
import factory.Shoes;
import factory.impl.NikeShoes;
import factory.impl.WaterMask;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//动态代理
public class DynamicProxy implements InvocationHandler {
private Object target;
/**
* 绑定委托对象并返回一个相应的代理
*
* @param target 真实对象
* @return 代理对象【占位】
*/
public Object bind(Object target, Class[] interfaces) {
this.target = target;
//第一个参数是类加载器,第二个参数是或者对象的接口(代理对象挂在那个接口下),第三个参数this代表当前Proxy类
return Proxy.newProxyInstance(target.getClass().getClassLoader(), interfaces, this);
}
/**
* 同过代理对象调用方法首先进入这个方法.
*
* @param proxy --代理对象
* @param method -- 方法,被调用方法.
* @param args -- 方法的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
System.out.println("发朋友圈推销:" + proxy.getClass().getName()); //交付前操作
result = method.invoke(target, args); //交付
System.out.println("收钱"); //交付后操作
return result;
}
}
这里的bind方法里面有句:
Proxy.newProxyInstance(target.getClass().getClassLoader(), interfaces, this)
他的意思就是生成一个代理对象,绑定this(DynamicProxy ),即使用DynamicProxy 作为对象的代理。
一旦这样绑定后,那么在进入代理对象方法调用的时候就会到DynamicProxy 的invoke方法上,invoke方法有三个参数:第一个proxy是代理对象,第二个是当前调用那个方法,第三个是方法的参数。
举例,现在WaterMask对象用bind方法绑定后,返回其【占位】(proxy),我们在调用waterMask.getMask(),那么它就会进入到DynamicProxy 的invoke()方法。而invoke参数中第一个便是代理对象proxy,方法便是getMask。那么我们就可以通过反射技术调度真实对象的方法。
测试动态代理
public static void main(String[] args) {
Mask waterMask = new WaterMask();
Shoes nikeShoes = new NikeShoes();
DynamicProxy dynamicProxy = new DynamicProxy();
//绑定代理对象
waterMask = (Mask) dynamicProxy.bind(waterMask, new Class[]{Mask.class});
//经过绑定,再次调用就会进入invoke方法
waterMask.getMask();
//卖鞋
nikeShoes = (Shoes) dynamicProxy.bind(nikeShoes, new Class[]{Shoes.class});
nikeShoes.getShoses();
}
测试结果
发朋友圈推销:com.sun.proxy.$Proxy0
交付一个水面膜
收钱
发朋友圈推销:com.sun.proxy.$Proxy1
交付一双耐克鞋
收钱
最后这个代理又给我们卖面膜,又卖鞋,完美。
遗留问题
发现使用动态代理测试结果打印推向内容为com.sun.proxy.$Proxy0,为什么proxy.getClass().getName()打印出的并不是类型名?
提示:动态代理的代理对象并不是真正的代理对象,是一个占位,大家感兴趣,可以去探究一下,深入研究动态代理实现机理。
如果我们调用nikeShoes对象的toString()方法,发现也会被代理,但是我们并不想这个方法被代理,怎么实现?