设计模式GOF23-代理模式
代理模式(Proxy Pattern)
核心作用
- 通过代理控制对对象的访问:可以详细控制访问某个(类)对象的方法,在调用这个方法前做前置处理,在方法后做后置处理。(即AOP的微观实现)
- AOP(Aspect Oriented Programming 面向切面编程)的核心机制。
高琪老师用一张明星唱歌的图来具体说明:客户要求周杰伦唱歌,可以有这么几个步骤:面谈–合同起草 – 签字收预付款 – 安排机票和车辆 – 唱歌 --收尾款。然而,除了唱歌这个动作除了他自己做并且有可能每次都不一样外,其他的步骤都是统一的,要是每年就唱这么一次歌,这些动作他一个人可以完成,但要是唱的次数多了呢,这些重复的动作就浪费了很多时间,在我们的代码中,这些重复的动作就是重复的代码,每个明星都一样,所以,除了唱歌之外的动作是不是可以找个代理人来做呢?明星就只负责唱歌,而客户就跟代理人商量就可以了,并且一个代理人可以为多个明星代理这些动作。在代码中我们叫它为代理类,用来解决除了核心业务的一些其他辅助代码,但是又不得不做,当客户端客户端直接调用代理类就能完成真实的功能。
核心角色
- 抽象角色:
-定义代理角色和真实角色的公共对外方法。 - 真实角色:
-实现抽象角色,定义真实角色所需要实现的业务逻辑,供代理角色调用。
-关注真正的业务逻辑。 - 代理角色:
-实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的方法。
-将统一的流程控制放到代理角色中处理。
用类图表示如下:
应用场景
- 安全代理:屏蔽对真实角色的直接访问。
- 远程调用:通过代理类来处理远程方法的调用(RMI)。
- 延迟加载:先加载轻量级的代理对象,真正需要时在加载真实的对象
- … … 几乎所有的框架里面都有代理模式
分类
- 静态代理(静态定义代理类)
- 动态代理(动态生成代理类)
-JDK自带的动态代理
-Javaassist字节码操作库实现
-CGLIB
-ASM(底层使用指令,可维护性较差)
静态代理(Static Proxy)示例
- 首先创建一个明星接口,定义面谈、签合同、订票、唱歌、收尾款等方法。
/**
* User:tumbler
* Desc:静态代理--明星接口
* 面谈,签合同,订票,唱歌,收尾款等方法
*/
public interface Star {
void confer();
void signContract();
void bookTicket();
void sing();
void collectMoney();
}
- 定义真实角色,实现明星接口,重写方法。
/**
* User:tumbler
* Desc:静态代理--真实角色
*/
public class RealStar implements Star{
@Override
public void confer() {
System.out.println("RealStar.真实角色面谈");
}
@Override
public void signContract() {
System.out.println("RealStar.真实角色签合同");
}
@Override
public void bookTicket() {
System.out.println("RealStar.真实角色订票");
}
@Override
public void sing() {
System.out.println("RealStar.真实角色唱歌");
}
@Override
public void collectMoney() {
System.out.println("RealStar.真实角色收尾款");
}
}
- 定义代理角色,实现明星接口,重写方法,加入要代理的真实角色属性,然后代理调用真实角色的唱歌方法取唱歌,因为代理可以干其他的事,但是他不能唱歌,否则明星就失业了。
/**
* User:tumbler
* Desc:静态代理--代理角色
*/
public class ProxyStar implements Star{
private Star star; //被代理的真实对象
public ProxyStar(Star star){
this.star = star;
}
@Override
public void confer() {
System.out.println("ProxyStar.代理角色面谈");
}
@Override
public void signContract() {
System.out.println("ProxyStar.代理角色面谈");
}
@Override
public void bookTicket() {
System.out.println("ProxyStar.代理角色面谈");
}
/**
* 代理角色什么都能干,但就是不能唱歌,要是歌也被代唱了,那真实角色就完蛋了
* 所以这里调用真实角色唱歌
*/
@Override
public void sing() {
star.sing();
}
@Override
public void collectMoney() {
System.out.println("ProxyStar.代理角色面谈");
}
}
- 定义客户端测试,客户端只跟代理打交道,代理又去调用真实角色去唱歌,避免了与真实角色的直接接触,并且完成了所有流程。
/**
* User:tumbler
* Desc:静态代理--客户端
*/
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();
}
}
运行结果:
ProxyStar.代理角色面谈
ProxyStar.代理角色面谈
ProxyStar.代理角色面谈
RealStar.真实角色唱歌 // 真实角色唱歌
ProxyStar.代理角色面谈
- UML图:
动态代理(Dynamic Proxy)示例
动态代理 VS 静态代理 的优点
- 抽象角色(接口)中申明的所有方法都被转移到调用处理器一个集中的方法中处理,这样,有利于灵活和统一的处理更多的方法。
JDK自带的动态代理
- java.lang.reflect.Proxy : 动态生成代理类和对象
- java.lang.reflect.InvocationHandler : 处理器接口
-可以通过invoke方法实现对真实角色的代理访问
-每次通过Proxy生成代理类对象时都要指定对应的处理器
- 创建抽象接口Star,提供面谈、签合同、订票、唱歌、收尾款等方法
/**
* User:tumbler
* Desc:动态代理--明星接口
* 面谈,签合同,订票,唱歌,收尾款等方法
*/
public interface Star {
void confer();
void signContract();
void bookTicket();
void sing();
void collectMoney();
}
- 创建真实角色,实现抽象角色,重写方法
/**
* User:tumbler
* Desc:动态代理--真实角色
*/
public class RealStar implements Star {
@Override
public void confer() {
System.out.println("RealStar.真实角色面谈");
}
@Override
public void signContract() {
System.out.println("RealStar.真实角色签合同");
}
@Override
public void bookTicket() {
System.out.println("RealStar.真实角色订票");
}
@Override
public void sing() {
System.out.println("RealStar.真实角色唱歌");
}
@Override
public void collectMoney() {
System.out.println("RealStar.真实角色收尾款");
}
}
- 定义处理器StarHandler,实现InvocationHandler接口,重写invoke方法,将真实角色传入,自动生成代理角色
/**
* User:tumbler
* Desc:动态代理--处理器
*/
public class StarHandler implements InvocationHandler {
Star realStar;
public StarHandler(Star realStar) {
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 ("sing".equals(method.getName())){
object = method.invoke(realStar, args);
}
System.out.println("真正方法执行后...");
System.out.println("这里统一做后置处理,例如收尾款");
return object;
}
}
- 定义客户端测试
/**
* User:tumbler
* Desc:动态代理--客户端测试
*/
public class Client {
public static void main(String[] args) {
Star realStar = new RealStar();
StarHandler handler = new StarHandler(realStar);
Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, handler);
proxy.sing();
}
}
运行结果:
真正角色执行前...
这里可以将需要统一处理的事情(面谈、签合同、订票)放到单独的类或方法取调用
RealStar.真实角色唱歌
真正方法执行后...
这里统一做后置处理,例如收尾款
可以看出,当动态生成代理类后,其实调用代理类的方法后,都走了一遍invoke方法,统一添加了前置或者后置的一些操作,从而做到统一处理。
- UML图
开发框架中的应用场景
- Struts2中的拦截器的实现
- 数据库连接池关闭处理
- Hibernate中延迟加载的实现
- Mybatis中实现拦截器插件
- AspectJ的实现
- Spring中AOP的实现
-日志拦截
-声明式事务的处理 - web service
- RMI远程方法调用