【结构型】- 代理模式
代理模式的定义：
为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式可以分为三种：静态代理，动态代理，cglib动态代理。
静态代理
服务接口
package com.java.pattern.proxy.staticdemo; public interface UserService { void eat(); }
服务具体实现（委托类）
package com.java.pattern.proxy.staticdemo; public class UserServiceImpl implements UserService { @Override public void eat() { System.out.println("感谢上帝，感谢神，我开动了..."); } }
服务静态代理类
package com.java.pattern.proxy.staticdemo; public class UserProxyServiceImpl implements UserService { private UserService userService; public UserProxyServiceImpl(UserService userService) { this.userService = userService; } @Override public void eat() { System.out.println("先点外卖....."); userService.eat(); System.out.println("清理外卖....."); } }
测试类
package com.java.pattern.proxy.staticdemo; public class Ctest01 { public static void main(String[] args) { UserService userService = new UserServiceImpl();// 使用静态代理，在不改变eat()方法代码的前提下，增强功能（添加额外的功能服务） userService = new UserProxyServiceImpl(userService); userService.eat(); } }
测试结果：
先点外卖.....
感谢上帝，感谢神，我开动了...
清理外卖.....
优点：
- 在不改变委托类代码的前提下，为委托类添加额外的功能。
缺点：
- 代理类和委托类需要实现同一接口。
- 一个代理类只能代理一个服务，这就导致我们需要为每一个服务都创建代理类。
- 委托类实现的接口，一旦发生改变，代理类也要修改代码。
jdk动态代理
JDK动态代理只提供接口的代理，不支持类的代理。核心InvocationHandler接口和Proxy类，InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；接着，Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。
动态代理类
public class DynamicProxyService implements InvocationHandler { private Object target; public DynamicProxyService(Object target) { this.target = target; } public Object getProxyInstance() { return Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("代理类[DynamicProxyService] before doSomething..."); Object res = method.invoke(target, args); System.out.println("代理类[DynamicProxyService] after doSomething..."); return res; } }
代理的目标对象：接口的实现类
public interface TargetService { String doSomething(String params); }
public class TargetServiceImpl implements TargetService { @Override public String doSomething(String params) { System.out.println("[TargetServiceImpl]doSomething..."); return null; } }
代理的目标对象：类的继承类（子类）
public class TargetClass { /** * 普通方法 */ public void doSomething() { System.out.println("[TargetClass]doSomething..."); } /** * final方法 */ public final void finalFunction() { System.out.println("[TargetClass]finalFunction..."); } }
public class TargetSubClass extends TargetClass { @Override public void doSomething() { System.out.println("[TargetSubClass]doSomething..."); } }
测试类：
public class Ctest01 { public static void main(String[] args) { testJDKDynamicProxy(); } public static void testJDKDynamicProxy() { System.out.println("---> 代理对象：接口的实现类"); // 目标类 TargetService targetService = new TargetServiceImpl(); // 代理类 DynamicProxyService dynamicProxyService = new DynamicProxyService(targetService); // 获取代理对象 targetService = (TargetService)dynamicProxyService.getProxyInstance(); targetService.doSomething("params"); System.out.println("----------------------------------------------------------------"); System.out.println("---> 代理对象：继承类"); // 目标类 TargetClass targetClass = new TargetSubClass(); // 代理类 dynamicProxyService = new DynamicProxyService(targetClass); // 获取代理对象 targetClass = (TargetClass) dynamicProxyService.getProxyInstance(); targetClass.doSomething(); } }
测试结果：
---> 代理对象：接口的实现类
代理类[DynamicProxyService] before doSomething...
[TargetServiceImpl]doSomething...
代理类[DynamicProxyService] after doSomething...
----------------------------------------------------------------
---> 代理对象：继承类
Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy1 cannot be cast to com.design.pattern.proxy.target.TargetClass
at com.design.pattern.proxy.Ctest01.testJDKDynamicProxy(Ctest01.java:43)
at com.design.pattern.proxy.Ctest01.main(Ctest01.java:15)
优点：
- 在不改变委托类代码的前提下，为委托类添加额外的功能。
- 代理类无需和委托类实现同一接口。
- 一个代理类能够代理所有委托类
缺点：
- 委托类必须要实现某一接口或继承某一父类
cglib动态代理
JDK实现动态代理需要目标类实现某一接口，对于没有实现任何接口的类，该如何实现动态代理呢，这就需要CGLib了，CGLIB（Code Generation Library）是一个代码生成的类库。采用了非常底层的字节码技术，其原理是通过字节码技术在运行时为指定类创建一个子类对象，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的目标类，以及目标类中的final方法进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。
委托类
public class TargetClass { /** * 普通方法 */ public void doSomething() { System.out.println("[TargetClass]doSomething..."); } /** * final方法 */ public final void finalFunction() { System.out.println("[TargetClass]finalFunction..."); } }
cglib代理类
package com.design.pattern.proxy.cglibmode;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibProxyService implements MethodInterceptor {
private Object target;
public CglibProxyService(Object target) {
this.target = target;
}
public Object getProxyInstance() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("cglib代理类[CglibProxyService] before doSomething...");
Object res = method.invoke(target, args);
System.out.println("cglib代理类[CglibProxyService] after doSomething...");
return res;
}
}
测试类
package com.design.pattern.proxy; import com.design.pattern.proxy.cglibmode.CglibProxyService; import com.design.pattern.proxy.jdkmode.DynamicProxyService; import com.design.pattern.proxy.staticmode.ProxyService; import com.design.pattern.proxy.target.TargetClass; import com.design.pattern.proxy.target.TargetService; import com.design.pattern.proxy.target.TargetServiceImpl; import com.design.pattern.proxy.target.TargetSubClass; public class Ctest01 { public static void main(String[] args) { testCglibProxy(); } public static void testCglibProxy() { // 目标类 TargetClass targetClass = new TargetClass(); // 代理类 CglibProxyService cglibProxyService = new CglibProxyService(targetClass); // 获取代理对象 targetClass = (TargetClass)cglibProxyService.getProxyInstance(); targetClass.doSomething(); // 测试cglib动态代理是否能代理final方法 targetClass.finalFunction(); } }
测试结果如下：
cglib代理类[CglibProxyService] before doSomething...
[TargetClass]doSomething...
cglib代理类[CglibProxyService] after doSomething...
[TargetClass]finalFunction...
优点：
- 在不改变委托类代码的前提下，为委托类添加额外的功能。
- 代理类无需和委托类实现同一接口。
- 一个代理类能够代理所有委托类
- 相比于JDK动态代理，委托类无需要实现某一接口或继承某一父类。
缺点：
- 委托类不能是final类，因为final类无法被继承。
