一.图文详解代理模式
什么是代理模式？代理模式有什么作用？
-
代理模式
为真实对象提供一个代理，从而控制对真实对象的访问 -
代理模式的作用
通过代理，控制对对象的访问！
可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现！）
我们以客户找周杰伦唱歌的场景来举例说明。
- 在未使用代理模式时，假如有客户要找周杰伦唱歌，则流程如下
可以看到，未使用代理时所有事宜都需要周杰伦处理。 - 使用代理模式后，客户不再与周杰伦直接接触，而是由周杰伦的代理对象 “经纪人” 接触，也就是经纪人安排周杰伦唱歌的一切事宜。
对于歌手而言，整个流程只有“唱歌”环节需要自己完成，而其他环节（面谈、合同起草、收尾款等）都只需要交给经纪人（代理对象）完成即可。
使用代理还有一个好处就是假如客户还要找蔡依林唱歌，那么代理对象可以同时为周杰伦和蔡依林代理。这在开发中相当于将相同业务流程进行统一拦截处理（AOP），可大大减少冗余代码。
代理模式的应用场景及分类
- 应用场景
- 安全代理：屏蔽对真实角色的直接访问。
- 远程代理：通过代理类处理远程方法调用(RMI)
- 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
- 分类
-
静态代理(静态定义代理类)
-
动态代理(动态生成代理类)
a.JDK自带的动态代理
b. javaassist字节码操作库实现
c. CGLIB
d. ASM(底层使用指令，可维护性较差)
代理模式模型图
角色作用
-
抽象角色
– 定义代理角色和真实角色的公共对外方法 -
真实角色
– 实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。 – 关注真正的业务逻辑！ -
代理角色
– 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。 – 将统一的流程控制放到代理角色中处理！
二.通过代码来说明静态代理和动态代理（JDK、CGLIB）
静态代理
静态代理的代理类是静态定义的，还是以周杰伦唱歌为例，首先我们创建抽象接口Star
public interface Star {
/**
* 面谈
*/
void confer();
/**
* 签合同
*/
void signContract();
/**
* 订票
*/
void bookTicket();
/**
* 唱歌
*/
void sing();
/**
* 收钱
*/
void collectMoney();
}
然后我们创建真实类 RealStar 实现抽象接口
public class RealStar implements Star {
@Override
public void confer() {
System.out.println("RealStar.confer()");
}
@Override
public void signContract() {
System.out.println("RealStar.signContract()");
}
@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}
@Override
public void sing() {
System.out.println("RealStar(周杰伦本人).sing()");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
除了唱歌方法打印了“周杰伦本人”字样，其他的方法都不打印，因为其他操作让代理对象（经纪人）执行即可。
接着我们创建代理类 ProxyStar ,代理类同样也实现抽象接口
public class ProxyStar implements Star {
// 持有真实对象，为真实对象进行代理
private Star star;
public ProxyStar(Star star){
super();
this.star = star;
}
@Override
public void confer() {
System.out.println("ProxyStar.confer()");
}
@Override
public void signContract() {
System.out.println("ProxyStar.signContract()");
}
@Override
public void bookTicket() {
System.out.println("ProxyStar.bookTicket()");
}
@Override
public void sing() {
// 调用真实对象方法
star.sing();
}
@Override
public void collectMoney() {
System.out.println("ProxyStar.collectMoney()");
}
}
最后创建客户类进行调用
public class Client {
public static void main(String[] args) {
Star real = new RealStar();
Star proxy = new ProxyStar(real);
proxy.confer();
proxy.signContract();
proxy.bookTicket();
proxy.sing();
proxy.collectMoney();
}
}
运行后结果如下：
可以看到，只有 sing 方法调用了真实对象方法，而其他通用流程方法都由代理对象完成。
静态代理模型图如下
动态代理
动态代理的本质和静态代理一样，相比静态代理，动态代理有以下优点
- 抽象角色中(接口)声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
动态代理的实现方式有多重，下面介绍两种较为常见的实现方式，JDK自带的动态代理和CGLIB
JDK自带的动态代理
JDK动态代理只能代理实现了抽象接口的真实对象。JDK动态代理主要涉及到Proxy类和InvocationHandler接口
-
java.lang.reflect.Proxy ， 负责动态生成代理类和对象
-
java.lang.reflect.InvocationHandler(处理器接口)
- 可以通过 invoke 方法实现对真实角色的代理访问。 - 每次通过 Proxy 生成代理类对象对象时都要指定对应的处理器对象
Star接口、RealStar真实类的代码与静态代理一样，在此不再赘述，代理类由 StarHandler 代替
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class StarHandler implements InvocationHandler {
private Star realStar;
public StarHandler(Star realStar) {
super();
this.realStar = realStar;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object object = null;
System.out.println("真正的方法执行前！");
System.out.println("面谈，签合同，预付款，订机票");
if(method.getName().equals("sing")){
// 通过反射调用真实对象的方法
object = method.invoke(realStar, args);
}
System.out.println("真正的方法执行后！");
System.out.println("收尾款");
return object;
}
}
客户端类
import java.lang.reflect.Proxy;
import base.proxy.dynamicProxy.RealStar;
import base.proxy.dynamicProxy.Star;
import base.proxy.dynamicProxy.StarHandler;
public class Client {
public static void main(String[] args) {
// 真实对象
Star realStar = new RealStar();
// 处理器对象
StarHandler handler = new StarHandler(realStar);
// 通过Proxy类生成代理类以及代理对象
Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader()
, new Class[]{Star.class}
, handler);
proxy.sing();
}
}
运行后结果如下：
可以看到，抽象角色中(接口)声明的所有方法都被转移到 invoke 方法中处理。
CGLIB动态代理
CGLIB动态代理与JDK自带的动态代理不同的是，CGLIB可以代理没有实现抽象接口的真实类。且CGLIB不能对 final修饰的类、方法进行代理，因为CGLIB是对指定的类生成一个子类，覆盖其中的方法进行代理。
CGLIB 动态代理主要涉及以下两个接口、类
-
net.sf.cglib.proxy.Enhancer，负责动态生成代理类和对象
-
net.sf.cglib.proxy.MethodInterceptor，拦截器接口
- 可以通过 intercept 方法实现对真实角色的代理访问。 - 每次通过 Enhancer 生成代理类对象时都要指定对应的拦截器对象
要使用CGLIB动态代理,首先要引入相关依赖库
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-nodep</artifactId>
<version>3.2.10</version>
</dependency>
RealStarInterceptor拦截器代码
import java.lang.reflect.Method;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class RealStarInterceptor implements MethodInterceptor{
@Override
public Object intercept(Object object, Method method, Object[] params, MethodProxy methodProxy) throws Throwable {
Object result = null;
System.out.println("真正的方法执行前！");
System.out.println("面谈，签合同，预付款，订机票");
if(method.getName().equals("sing")){
result = methodProxy.invokeSuper(object, params);
}
System.out.println("真正的方法执行后！");
System.out.println("收尾款");
return result;
}
}
客户端代码
import net.sf.cglib.proxy.Enhancer;
public class Client {
public static void main(String[] args) {
// 真实对象
RealStar realStar = new RealStar();
Enhancer enhancer = new Enhancer();
// 设置代理类的类型
enhancer.setSuperclass(realStar.getClass());
// 设置拦截器对象
enhancer.setCallback(new RealStarInterceptor());
// 创建代理对象
RealStar proxy = (RealStar) enhancer.create();
proxy.sing();
}
}
运行结果如下
可以看到，CGLIB的动态代理可以达到JDK自带动态代理一样的效果。
三.开发框架中应用场景例举
- struts2中拦截器的实现
- 数据库连接池关闭处理
- Hibernate中延时加载的实现
- mybatis中实现拦截器插件
- AspectJ的实现
- spring中AOP的实现
1）日志拦截
2）声明式事务处理 - – web service
- RMI远程方法调用
…
实际上，随便选择一个技术框架都会用到代理模式！
四.面向切面编程介绍
AOP（Aspect-Oriented Programming，面向切面的编程）
它是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。它是一种新的方法论，它是对传统OOP编程的一种补充。
常用术语
- 切面（Aspect）：其实就是共有功能的实现。
- 通知（Advice）：是切面的具体实现。
- 连接点（Joinpoint）：就是程序在运行过程中能够插入切面的地点。
- 切入点（Pointcut）：用于定义通知应该切入到哪些连接点上。
- 目标对象（Target）：就是那些即将切入切面的对象，也就是那些被通知的对象
- 代理对象（Proxy）：将通知应用到目标对象之后被动态创建的对象。
- 织入（Weaving）：将切面应用到目标对象从而创建一个新的代理对象的过程。
本文完整代码如有需要请访问github获取: https://github.com/liaozq0426/design-pattern.git