代理模式
什么是代理模式?
首先说什么是代理。记得有这么个神评论“请说出一个最像日本人名字的中文职位”,神评论:房屋中介
。
代理的作用就类似房屋中介。试想一个业主想要出售自己的房屋,但是业主本身并不是干这行的,对这行的规矩和行情并不了解,因此他将房屋在出售过程中的行使权交给中介,由中介代替他去完成挂牌、引流、洽谈和成交等过程。房屋中介是业主的代理。反过来,中介并没有拥有房屋的所有权,因此对于房屋在出售过程中的签字,证件证明等过程仍需要业主出面提供,所以代理必须要调用被代理(业主)提供的方法。
代理起到的作用就是保护和增强功能的作用,代理拥有部分被代理对象不持有的逻辑,通过代理的逻辑,被代理的对象原有的行为能够得到一定的增强。
静态代理
如下游戏玩家自己有账号,但是自己没时间玩,因此花钱请了代练来帮助自己练级。代练可以通过游戏外挂对号主的账号进行加强,因为代练持有了号主的账号,因此可以对账号进行前后的增强。
public interface Game {
void login(String username,String password);
void play();
void levelUp();
}
玩家正常的玩法:
public class GamePlayer implements Game {
@Override
public void login(String username, String password) {
System.out.printf("登录成功!用户名:%s,密码:%s\n",username,password);
}
@Override
public void play() {
System.out.println("用户正在刷野");
}
@Override
public void levelUp() {
System.out.println("用户已升级");
}
}
代练(代理)的玩法:
public class GamePlayerProxy implements Game {
private Game game;
public GamePlayerProxy(Game game) {
this.game = game;
}
@Override
public void login(String username, String password) {
System.out.println("代理获取用户登录账号和密码");
game.login(username,password);
}
@Override
public void play() {
System.out.println("代理开启自动刷图外挂");
game.play();
}
@Override
public void levelUp() {
game.levelUp();
System.out.println("代理通过邮件转出升级奖励");
}
}
代理必须持有玩家的引用,才能在其正常的逻辑前后进行增强处理。
public class Test {
public static void main(String[] args) {
System.out.println("================玩家自己玩游戏===================");
GamePlayer gamePlayer = new GamePlayer();
gamePlayer.login("root","123456");
gamePlayer.play();
gamePlayer.levelUp();
System.out.println("===================代练后===================");
GamePlayerProxy proxy = new GamePlayerProxy(new GamePlayer());
proxy.login("root","123456");
proxy.play();
proxy.levelUp();
}
}
================玩家自己玩游戏===================
登录成功!用户名:root,密码:123456
用户正在刷野
用户已升级
===================代练后===================
代理获取用户登录账号和密码
登录成功!用户名:root,密码:123456
代理开启自动刷图外挂
用户正在刷野
用户已升级
代理通过邮件转出升级奖励
不同的调用方式可以看出使用了代理后,用户的刷野效率得到了很高的提升,用户足不出户就能够快速升级。
这是一种静态代理的实现,缺点是代理类的逻辑是写死的,如果用户想要切换账号,则必须要通知代练进行修改,因此不是很灵活。既然有静态代理,name必定也会有动态代理。
动态代理
动态代理中逻辑并不是写死的,而是根据被代理类的逻辑动态生成的,能适应不同的逻辑变化。
JDK动态代理
JDK中自带了一种动态代理的实现。只需实现InvocationHandler
接口即可实现动态代理。
public interface Game {
void login(String username,String password);
void play();
void levelUp();
}
public class GamePlayer implements Game {
@Override
public void login(String username, String password) {
System.out.printf("登录成功!用户名:%s,密码:%s\n",username,password);
}
@Override
public void play() {
System.out.println("用户正在刷野");
}
@Override
public void levelUp() {
System.out.println("用户已升级");
}
}
使用代理
其中:
Proxy.newProxyInstance(
this.getClass().getClassLoader(),
this.game.getClass().getInterfaces(),
this)
方法中,参数依次为
类加载器,被代理的接口,实现了InvocationHandler接口的类实例。
public class JDKGamePlayerProxy implements InvocationHandler {
// 必须持有被代理类的引用
private Game game;
public Object getInstance(Game game){
if(this.game == null){
synchronized(JDKGamePlayerProxy.class){
if(this.game == null){
this.game = game;
}
}
}
return Proxy.newProxyInstance(
this.getClass().getClassLoader(),
this.game.getClass().getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object reslt = null;
if("login".equals(method.getName())){
System.out.println("代练开始为玩家练号");
reslt = method.invoke(game,args);
}
if("play".equals(method.getName())){
System.out.println("外挂已打开,即将开始全屏自动刷怪");
reslt = method.invoke(game,args);
}
if("levelUp".equals(method.getName())){
reslt = method.invoke(game,args);
System.out.println("代理通过邮件转出升级奖励");
}
return reslt;
}
}
在重写的invoke
方法中可以获取被代理的方法,因此可以在方法的调用前后进行相应的处理。方法的调用采用反射机制。
============用户自己练级============
登录成功!用户名:root,密码:123456
用户正在刷野
用户已升级
===========用户请了代练============
代练开始为玩家练号
登录成功!用户名:root,密码:123456
外挂已打开,即将开始全屏自动刷怪
用户正在刷野
用户已升级
代理通过邮件转出升级奖励
当我想着写博客的时候,当然不是写API,但是如果没有API的使用反而显得有点空洞。那么JDK动态代理是怎么实现的呢?
JDK动态代理的实现原理
在上述的测试类代码行,我们打下一个断点(如下图),通过debug看看这个instance到底是什么:
断点显示instance是一个 $Proxy0 ,这个类直接去全局搜索当然是搜不到的。上边说道动态代理会动态生成类,那么这个类是否就是动态生成的那个类呢?到这里似乎线索断了,如果我能弄出这个类,那么想要解决上述的疑问也就不在话下了。
只要敢想,方法总会有的。通过下方的方法就能把这个类给保存下来:
JDKGamePlayerProxy proxy = new JDKGamePlayerProxy();
Game instance = (Game) proxy.getInstance(new GamePlayer());
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Game.class});
FileOutputStream os = new FileOutputStream("./$Proxy0.class");
代码执行完成后,在src目录下就会生成这个类:
源码的代码会影响页面浏览体验,因此开启一个传送门
在静态代码块中:
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m5 = Class.forName("proxy.dynamicproxy.Game").getMethod("levelUp");
m4 = Class.forName("proxy.dynamicproxy.Game").getMethod("play");
m3 = Class.forName("proxy.dynamicproxy.Game").getMethod("login", Class.forName("java.lang.String"), Class.forName("java.lang.String"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
通过反射将被代理类的方法创建了实例,并保存起来。而public final class $Proxy0 extends Proxy implements Game
可知这个$Proxy0继承了Proxy
,被缓存的方法在调用的时候通过super.h.invoke(this, m5, (Object[])args);
来调用。super.h 指的就是Proxy#h
public class Proxy implements java.io.Serializable {
protected InvocationHandler h;
}
这个h在此处被赋值:
protected Proxy(InvocationHandler h) {
Objects.requireNonNull(h);
this.h = h;
}
这是一个构造方法,构造方法在调用Proxy.newInstance
的时候会被调用,也就是说将 Proxy.newProxyInstance(
this.getClass().getClassLoader(),
this.game.getClass().getInterfaces(),
this)中的最后一个this赋值。因此调用super.h.invoke会转回调用JDKGamePlayerProxy#invoke
,所以最后既获取了被代理的对象的方法,又能实现方法的调用。拿到这个方法后,想要在方法上前后进行操作那还是不是轻而易举吗?
既然JDK中通过动态生成class文件,用类加载器加载到JVM中来实现动态运行,基于这样的思路,我们是否也可以实现自己的动态加载呢?
当然可以,主要思路是:
- 找到类路径
- 编写动态类的代码
- 将代码编译称为.class文件
- 将class文件加载到JVM中
限于篇幅和阅读耐力,仅贴出部分核心代码,有兴趣的话本人会考虑将全部源代码放到传送门(如果链接到百度则说明源码未贴出)
public static Object newProxyInstance(BufferClassLoader classloader,
Class<?>[] interfaces,
BufferInvocationHandler handler){
// 生成代理类的源码
String srcCode = generaterSrcCode(interfaces);
// 获取当前类的路径
String path = BufferInvocationHandler.class.getResource("").getPath();
File file = new File(path+"$Proxy0.class");
try{
FileWriter fileWriter = new FileWriter(file);
fileWriter.write(srcCode);
fileWriter.flush();
fileWriter.close();
// 执行文件的编译
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
Iterable<? extends JavaFileObject> javaFile = manager.getJavaFileObjects(file);
JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, null);
task.call();
manager.close();
Class<?> aClass = classloader.findClass("$Proxy0.class");
Constructor<?> constructor = aClass.getConstructor(BufferInvocationHandler.class);
......
return constructor.newInstance(handler);
}catch(Exception e){
e.printStackTrace();
}
return null;
}
Cglib动态代理
与JDK动态代理不同的是,Cglib动态代理既能代理接口,也能代理类(JDK动态创建的类已经继承了Proxy,因为不能多继承,因此无法代理类,而且因为代理接口需要调用接口的方法,因此还要求接口要有实现类),用法上稍微比JDK动态代理复杂,但是整体上更加灵活。两种动态的代理有不同的使用场景,并无好坏之分。
public class Customer {
public void printSomething(){
System.out.println("我是普通的那个需要玩家");
}
}
public class CglibProxy implements MethodInterceptor {
public Object getInstance(Class<?> clazz) {
Enhancer enhancer = new Enhancer();
enhancer.setCallback(this);
enhancer.setSuperclass(clazz);
return enhancer.create();
}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
Object reslt = null;
System.out.println("前置增强");
reslt = methodProxy.invokeSuper(o,objects);
System.out.println("后置增强");
return reslt;
}
}
其中reslt = methodProxy.invokeSuper(o,objects)
表示调用父类的方法,而enhancer.setSuperclass(clazz)
刚好设置了父类是谁,因此最后也就是调用被代理的类的方法。
public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy();
Customer customer = (Customer) cglibProxy.getInstance(Customer.class);
customer.printSomething();
}
前置增强
我是普通的那个需要玩家
后置增强
Cglib代理接口的时候,如果需要调用方法,但是接口没有实现类的话,方法的调用就会有问题。那么为什么mybatis的DAO层不用写实现类也可以调用方法呢?mybatis也是用的动态代理实现的,会生成类来实现接口,关于这个实现类的方法体怎么写,在这里算是题外话。mybatis虽然不需要写DAO层的实现类,但是要求写Mapper.xml文件,而xml文件的namespace绑定了DAO的路径,sql的标枪id也与方法名一一对应,而sql语句也可以从标签中获取到,接下来不就是JDBC的操作了吗?
烟鬼正传,在还没了解cglib动态生成的类之前,一切都是不可信的,眼见为实,我们采用如下方法将cglib生成的动态代理类的代码保存到本地。
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"D://cglib_proxy_classes")
需要注意这方法必须放在代理类产生之前,否则无效如:
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"D://cglib_proxy_classes");
CglibProxy cglibProxy = new CglibProxy();
Customer customer = (Customer) cglibProxy.getInstance(Customer.class);
customer.printSomething();
代码运行结束后看到提示CGLIB debugging enabled, writing to 'D://cglib_proxy_classes表示生成成功。限于篇幅将代码放到额外的篇幅中,此处设立传送门。可以看到一共生成了三个类,分别是
Customer$$EnhancerByCGLIB$$1be8ba4$$FastClassByCGLIB$$fdb70e35.class
Customer$$EnhancerByCGLIB$$1be8ba4.class
Customer$$FastClassByCGLIB$$bd784a6a.class
其中继承实现关系如下:- extends Customer implements Factory
- extends FastClass
- extends FastClass
也就是说cglib都是用继承的方式去生成类,因此cglib可以代理类
。
主要方法如图:
通过FastClass机制,将方法进行缓存(包含集成Object的方法和自定义的方法),调用的时候直接通过索引去获取,不用再通过反射去调用,因此调用的效率会比JDK动态代理的高。
总结:
Cglib和JDK动态代理的异同
JDK动态代理采用实现的方式去生成新的类,继承已经自己使用了(extends Proxy),由于java允许多实现,只允许单继承,所以JDK动态代理只能代理接口,而且要求接口要有实现类,否则方法无法调用。
Cglib采用继承的方式去生成类,覆盖父类的方法。
Cglib和JDK动态代理都是生成字节码,从而组装成新的类。
JDK动态代理对于用户而言,依赖性更强,因为要求类必须实现一个接口,但是调用也更加复杂。
Cglib对目标类没有任何要求。
Cglib效率更高,生成的类复杂耗时,但是会将方法缓存起来,下次调用就会很快,性能也更高,底层没有用到反射。
JDK生成的类的逻辑较为简单,执行效率低,每次都要反射(method.invoke()),调用效率低。
Cglib中有一个坑,就是被代理类中的final方法会被忽略。
代理模式的优缺点
优点:
- 代理模式能将代理对象与真是被调用的目标对象分离,一定程度上降低了系统的耦合程度,易于扩展。
- 代理模式可以起到保护目标对象的作用。
- 代理模式可以增强目标的职责。
缺点:
- 代理模式会造成系统设计中类的数量增加。
- 在客户端和目标对象之间增加了一个代理对象,请求处理速度变慢。
- 增加系统的复杂度。
拓展
Spring中的代理选择原则
- 当Bean有实现接口时,Spring会用JDK的动态代理。
- 当Bean没有实现接口时,Spring选择Cglib。
- Spring可以通过配置强制使用Cglib,只需在Spring的配置文件中加入
<aop:aspectj-autoproxy proxy-target-class="true">
。