代理模式(ProxyPattern)的定义也非常简单,是指为其他对象提供一种代理,以控制对这个对象的访问。代理对象在客服端和目标对象之间起到中介作用,代理模式属于结构型设计模式。使用代理模式主要有两个目的:一保护目标对象,二增强目标对象。
本文代码下载地址:https://github.com/zhangxinmin/designpattern.git
静态代理:
代理的代码是静态的。是我们手动完成的。 这里模拟实现分库保存。当我们保存一个订单信息时 根据订单的创建时间,保存到指定的数据库中。比如 创建时间 为 2019 年则保存到 DB_2019 库,创建时间 为 2018 年则保存到 DB_2018 库。
增加类Order
public class Order {
private String id;
private Date createTime;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}
接口 IOrderService
public interface IOrderService {
//保存订单信息
public void save (Order order);
}
接口实现类 OrderServiceImpl
public class OrderServiceImpl implements IOrderService {
@Override
public void save(Order order) {
System.out.println("保存订单信息...."+order.getCreateTime());
}
}
DB选择类
public class DBRouterSelect {
public final static String DEFAULT_DB=null;//默认db为空
private final static ThreadLocal<String> local=new ThreadLocal<String>();
private DBRouterSelect(){}//构造方法私有
//获取本线程当前使用的数据库
public static String get(){
return local.get();
}
//设置本线程使用的数据库
public static void set(String dbname){
local.set(dbname);
}
//设置默认数据库
public static void setDefault(){
local.set(DBRouterSelect.DEFAULT_DB);
}
}
代理类 ProxyOrderService
public class ProxyOrderService implements IOrderService {
private IOrderService orderService;
public ProxyOrderService(IOrderService orderServiceImpl){
orderService=orderServiceImpl;
}
@Override
public void save(Order order) {
String year =new SimpleDateFormat("yyyy").format(order.getCreateTime());
DBRouterSelect.set("DB_"+year);
System.out.println("当前线程使用数据库:"+DBRouterSelect.get());
System.out.println("开始保存");
orderService.save(order);
System.out.println("保存完成");
}
}
测试类:
public class Test {
public static void main (String[] args){
IOrderService serviceImpl = new OrderServiceImpl();
ProxyOrderService prox = new ProxyOrderService(serviceImpl);
Order order = new Order();
order.setCreateTime(new Date());
order.setId("222");
prox.save(order);
}
}
执行 测试代码结果如下:
可以看到静态代理就是我们代理类持有一个被代理对象的实例,然后在调用被代理对象业务方法前后增加自己的扩展功能代码。 接口类和实现类就是我们平常写的 service接口和实现类中的正常业务逻辑。而在代理类中增加了数据库选择代码。增强了原有实现类的功能。同时做到了 实际业务功能和分库功能的解耦。
动态代理
用java动态代理实现上述功能 , 增加 OrderServiceDynamicProxyHander 类
public class OrderServiceDynamicProxyHander implements InvocationHandler {
IOrderService service ;
public IOrderService getProxyInstance(IOrderService service){
this.service=service;
Class clazz=service.getClass();
return (IOrderService)Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//如果是save方法执行如下操作
if(method.getName().equals("save")){
Order order= (Order)args[0];
String year = new SimpleDateFormat("yyyy").format(new Date());
DBRouterSelect.set("DB_"+year);
System.out.println("自动选择数据库"+DBRouterSelect.get());
}
System.out.println("方法开始执行");
Object res= method.invoke(service,args );
System.out.println("方法执行完成");
return res;
}
public static void main(String[] args){
IOrderService serviceImpl = new OrderServiceImpl();
IOrderService proxy = new OrderServiceDynamicProxyHander().getProxyInstance(serviceImpl);
Order order = new Order();
order.setCreateTime(new Date());
order.setId("222");
proxy.save(order);
}
}
直接运行 结果和静态代理类一致:
这里使用jdk动态代理完成了和静态代理相同过得功能。如何实现的呢?实际上 jdk动态生成了一个新的java类。通过如下方法可以将生成的代理类的字节码 保存到$Proxy0.class 。然后反编译 可以看到源码:
public static void main(String[] args) throws Exception {
IOrderService serviceImpl = new OrderServiceImpl();
IOrderService proxy = new OrderServiceDynamicProxyHander().getProxyInstance(serviceImpl);
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{IOrderService.class});
FileOutputStream fos = new FileOutputStream("$Proxy0.class");
fos.write(bytes);
fos.flush();
fos.close();
}
反编译后
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import com.test.proxy.staitc.IOrderService;
import com.test.proxy.staitc.Order;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements IOrderService {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void save(Order var1) throws {
try {
super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.test.proxy.staitc.IOrderService").getMethod("save", Class.forName("com.test.proxy.staitc.Order"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
可以看到 jdk生成的类 和被代理类实现了同样的借口 同时继承了 Proxy类。代理类中覆盖了 原有的方法。方法不是调用 原来被代理类中的方法而是 调用 InvacationHandler 中的invoke方法如:
而handler 中的方法,会有我们新增的逻辑 如下:
总的来说动态搭理就是代码执行的时候自动生成一个新的类,并编译加载到虚拟机中,供我们调用。我们也可以自己动态的生成类。来实现自定义的动态代理。原理一样 这里不演示了。
CGLib 调用 API 及原理分析
实现代码如下,执行代码效果和静态代理效果一样
public class OrderSeriveCGLibMethodInterceptor implements MethodInterceptor {
public Object getInstance(Class clazz){
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz );
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before(o,method,objects,methodProxy);
methodProxy.invokeSuper(o,objects);
after(o,method,objects,methodProxy);
return null;
}
private void before (Object o, Method method, Object[] objects, MethodProxy methodProxy){
Order order= (Order)objects[0];
String year = new SimpleDateFormat("yyyy").format(new Date());
DBRouterSelect.set("DB_"+year);
System.out.println("自动选择数据库"+DBRouterSelect.get());
System.out.println("方法开始执行");
}
private void after (Object o, Method method, Object[] objects, MethodProxy methodProxy){
System.out.println("方法执行结束");
}
public static void main(String[] args) throws Exception {
IOrderService serviceImpl = (IOrderService) new OrderSeriveCGLibMethodInterceptor().getInstance(OrderServiceImpl.class);
Order order = new Order();
order.setCreateTime(new Date());
order.setId("222");
serviceImpl.save(order);
}
}
执行结果:
CGLib 代理的目标对象不需要实现任何接口,它是通过动态继承目标对象实现的动态代理,那么cglib如何实现代理的呢 ?我们通过如下代码将动态生成的代理类写磁盘
public static void main(String[] args) throws Exception {
//利用 cglib 的代理类可以将内存中的 class 文件写入本地磁盘
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
"D://cglib_proxy_class/");
IOrderService serviceImpl = (IOrderService) new OrderSeriveCGLibMethodInterceptor().getInstance(OrderServiceImpl.class);
Order order = new Order();
order.setCreateTime(new Date());
order.setId("222");
serviceImpl.save(order);
}
执行代码后发现 指定目录中有多个文件 ,包名和被代理类相同
OrderServiceImplEnhancerByCGLIB2a8da7b2.class 这个类就是 代理类,它继承了 被代理类,并且重写了被代理类中的所有方法,并 且 会 有 MethodProxy 与 之 对 应。
执行 save 方法时 也是 执行的 创建代理对象时 传入的 MethodInterceptor 的intercept方法,也就是我们添加了附加逻辑的方法。 如下:
调 用 过 程 : 代 理对象调用 this.save()方法 -> 调 用 拦 截 器->methodProxy.invokeSuper->CGLIB$save$0->被代理对象 save()方法。此时,我们发现拦截器 MethodInterceptor 中就是由 MethodProxy 的 invokeSuper方法调用代理方法的,MethodProxy 非常关键 最终调用fci.f2.invoke 如下:
fci.f2.invoke 这个方法实际上在这个类中如下。
这个类是就是fastclass ,在这个类中我们找到了 invoke方法 ,invoke 调用了 var10000 的 save 方法 ,var10000 就是我们传入的 被代理对象。
动态生成的另外一个类是被代理对象的fastClass
CGLib 动态代理执行代理方法效率之所以比 JDK 的高是因为 Cglib 采用了 FastClass 机制,它的原理简单来说就是:为代理类和被代理类各生成一个 Class,这个 Class 会为代理类或被代理类的方法分配一个 index(int 类型)。这个 index 当做一个入参,FastClass就可以直接定位要调用的方法直接进行调用,这样省去了反射调用,所以调用效率比 JDK动态代理通过反射调用高。
CGLib 和 JDK 动态代理对比
1.JDK 动态代理是实现了被代理对象的接口,CGLib 是继承了被代理对象。
2.JDK 和 CGLib 都是在运行期生成字节码,JDK 是直接写 Class 字节码,CGLib 使用 ASM框架写 Class 字节码,Cglib 代理实现更复杂,生成代理类比 JDK 效率低。
3.JDK 调用代理方法,是通过反射机制调用,CGLib 是通过 FastClass 机制直接调用方法,CGLib 执行效率更高。
4.CGLIb不能代理 final修饰的方法
代理模式在 Spring 源码中的应用
ProxyFactoryBean 核心的方法就是 getObject()方法,我们来看一下源码
在 getObject()方法中,主要调用 getSingletonInstance()和 newPrototypeInstance();在 Spring 的配置中,如果不做任何设置,那么 Spring 代理生成的 Bean 都是单例对象。如果修改 scope 则每次创建一个新的原型对象。
Spring 利用动态代理实现 AOP 有两个非常重要的类,一个是 JdkDynamicAopProxy 类和 CglibAopProxy 类,来看一下类图:
Spring 中的代理选择原则
1、当 Bean 有实现接口时,Spring 就会用 JDK 的动态代理
2、当 Bean 没有实现接口时,Spring 选择 CGLib。
3、Spring 可以通过配置强制使用 CGLib,只需在 Spring 的配置文件中加入如下代码:
<aop:aspectj-autoproxy proxy-target-class="true"/>
静态代理和动态的本质区别
1、静态代理只能通过手动完成代理操作,如果被代理类增加新的方法,代理类需要同步新增,违背开闭原则。
2、动态代理采用在运行时动态生成代码的方式,取消了对被代理类的扩展限制,遵循开闭原则。
3、若动态代理要对目标类的增强逻辑扩展,结合策略模式,只需要新增策略类便可完成,无需修改代理类的代码。
代理模式的优缺点
优点:
1、代理模式能将代理对象与真实被调用的目标对象分离。
2、一定程度上降低了系统的耦合度,扩展性好。
3、可以起到保护目标对象的作用。
4、可以对目标对象的功能增强。
缺点:
1、代理模式会造成系统设计中类的数量增加。
2、在客户端和目标对象增加一个代理对象,会造成请求处理速度变慢。
3、增加了系统的复杂度。