代理模式(Proxy pattern)：
– 核心作用：
• 通过代理，控制对对象的访问！ 可以详细控制访问某个（某类）对象的方法{从而实现将统一 流程代码放到代 理类中处理}，在调用这个方法前做前置处理，调用这个方法后 做后置处理。（即：AOP的微观实现！）
– AOP(Aspect Oriented Programming面向切面编程)的核心实现机制！
– 核心角色：
• 抽象角色
– 定义代理角色和真实角色的公共对外方法
• 真实角色
– 实现抽象角色，定义真实角色所要实现的业务逻辑， 供代理角色调用。
– 关注真正的业务逻辑！
• 代理角色
– 实现抽象角色，是真实角色的代理，通过真实角色 的业务逻辑方法来实现抽象方法，并可以附加 自己的操作。
– 将统一的流程控制放到代理角色中处理！
• 应用场景：
– 安全代理：屏蔽对真实角色的直接访问。
– 远程代理：通过代理类处理远程方法调用(RMI)
– 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
• 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以 使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
分类：
– 静态代理(静态定义代理类)
– 动态代理(动态生成代理类)
• JDK自带的动态代理
• javaassist字节码操作库实现
• CGLIB • ASM(底层使用指令，可维护性较差)
静态代理(静态定义代理类)
代码实现：
抽象角色：明星
公共动作：面谈；签合同和拿定金；订票；唱歌；收尾款
package com.bjsxt.proxy.staticproxy;
public interface Star {
void confer();
void signContract();
void bootTicket();
void sing();
void collectMoney();
}
真实角色：周杰伦
动作：周杰伦面谈；周杰伦…
package com.bjsxt.proxy.staticproxy;
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 bootTicket() {
System.out.println("RealStar.bootTicket()");
}
@Override
public void sing() {
System.out.println("RealStar.sing()");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
代理角色：经纪公司
实例变量：真实角色（周杰伦）
构造器：输入参数真实角色引用变量，输出代理角色对象
动作：经纪公司面谈；经纪公司签合同；经纪公司订票；经纪公司找周杰伦唱歌；经纪公司那尾款
package com.bjsxt.proxy.staticproxy;
public class ProxyStar implements Star {
private RealStar realStar;
public ProxyStar(RealStar realStar) {
this.realStar = realStar;
}
@Override
public void confer() {
System.out.println("ProxyStar.confer()");
}
@Override
public void signContract() {
System.out.println("ProxyStar.signContract()");
}
@Override
public void bootTicket() {
System.out.println("ProxyStar.bootTicket()");
}
@Override
public void sing() {
realStar.sing();
}
@Override
public void collectMoney() {
System.out.println("ProxyStar.collectMoney()");
}
}
客户
找经纪公司，定周杰伦唱歌。
package com.bjsxt.proxy.staticproxy;
public class Client {
public static void main(String[] args) {
Star star = new ProxyStar(new RealStar());
star.confer();
star.signContract();
star.bootTicket();
star.sing();
star.collectMoney();
}
}
uml图：
运行结果：
动态代理(动态生成代理类)
• JDK自带的动态代理
• javaassist字节码操作库实现
• CGLIB • ASM(底层使用指令，可维护性较差)
代码：
package com.bjsxt.proxy.dynamicproxy;
public interface Star {
void confer();
void signContract();
void bootTicket();
void sing();
void collectMoney();
}
package com.bjsxt.proxy.dynamicproxy;
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 bootTicket() {
System.out.println("RealStar.bootTicket()");
}
@Override
public void sing() {
System.out.println("RealStar.sing()");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
重点关注类：实现InvocationHandler接口的实现类，实现方法invoke，输入Object对象，Method对象，Object[]对象，输出一个Objectdu对象。拥有实例变量真实角色，通过构造器关联。
package com.bjsxt.proxy.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class StarHandler implements InvocationHandler {
Star realStar;
public StarHandler(Star realStar) {
this.realStar = realStar;
}
// jdk生成的代理角色！
// 调用者调用代理角色，代理角色任一方法都调用handler中的invoke方法！
// 根据方法名称判断，如果是唱歌让周杰伦唱，如果是面谈，签合同，付定金，订车票，结尾款让经纪人做！
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
Object result=null;
System.out.println("真正的方法执行前！");
System.out.println("经纪人面谈！");
System.out.println("经纪人签合同！");
System.out.println("经纪人收定金！");
System.out.println("经纪人订车票！");
if(method.getName().equals("sing")){
// 经纪人找周杰伦唱歌！
result = method.invoke(realStar,objects);
}
System.out.println("真正的方法执行后！");
System.out.println("经纪人收尾款！");
return result;
}
}
重点关注语句：Star proxyStar = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
new Class[]{Star.class},handler);
jdk的Proxy类中有静态方法newProxyInstance，传入抽象角色Star，系统默认类加载器，刚才说的自定义的InvocationHandler接口实现类（含有真实角色RealSatr）,输出一个代理角色。这句就是灵魂，是通过Proxy这个类的方法获取的代理角色。刚才是我们手动编写的代理角色。这个代理类的结构是每一个公共动作都调用starHandler中的invoke，所以，需要在starHandler中根据方法名称走不同逻辑。
package com.bjsxt.proxy.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
Star realStar = new RealStar();
// 关键：自己创建一个Handler实现InvocationHandler接口，含有真是角色
StarHandler handler = new StarHandler(realStar);
// 关键：使用Proxy(jdk工具类)动态生成自己要的代理角色（参数类加载器，抽象角色，自己创建的Handler）
Star proxyStar = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
new Class[]{Star.class},handler);
// 生成的代理角色大致内容
proxyStar.sing();
}
}
jdk的Proxy生成的代理对象的结构大致如下：
package com.bjsxt.proxy.dynamicproxy;
/**
* 模拟jdk的Proxy.nnewProxyInstance生成的代理角色
*/
public class ProxyStar implements Star{
StarHandler starHandler;
public ProxyStar(StarHandler starHandler) {
this.starHandler = starHandler;
}
@Override
public void confer() {
//starHandler.invoke(this,当前方法，当前参数);
}
@Override
public void signContract() {
//starHandler.invoke(this,当前方法，当前参数);
}
@Override
public void bootTicket() {
//starHandler.invoke(this,当前方法，当前参数);
}
@Override
public void sing() {
//starHandler.invoke(this,当前方法，当前参数);
}
@Override
public void collectMoney() {
//starHandler.invoke(this,当前方法，当前参数);
}
}
uml图：
运行结果：
动态代理相比于静态代理的优点
– 抽象角色中(接口)声明的所以方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
JDK自带的动态代理
– java.lang.reflect.Proxy
•作用：动态生成代理类和对象
– java.lang.reflect.InvocationHandler(处理器接口)
• 可以通过invoke方法实现对真实角色的代理访问。
• 每次通过Proxy生成代理类对象对象时都要指定对应的处理器对象
开发框架中应用场景：
– struts2中拦截器的实现
– 数据库连接池关闭处理
– Hibernate中延时加载的实现
– mybatis中实现拦截器插件
– AspectJ的实现
– spring中AOP的实现
• 日志拦截
• 声明式事务处理
– web service
– RMI远程方法调用
– …
– 实际上，随便选择一个技术框架都会用到代理模式！！
AOP（Aspect-Oriented Programming，面向切面的编程）
– 它是可以通过预编译方式和运行期动态代理实现在不修改源代码的情 况下给程序动态统一添加功能的一种技术。它是一种新的方法论，它 是对传统OOP编程的一种补充。
常用术语：
– 切面（Aspect）：其实就是共有功能的实现。
– 通知（Advice）：是切面的具体实现。
– 连接点（Joinpoint）：就是程序在运行过程中能够插入切面的地点。
– 切入点（Pointcut）：用于定义通知应该切入到哪些连接点上。
– 目标对象（Target）：就是那些即将切入切面的对象，也就是那些被通知的对象
– 代理对象（Proxy）：将通知应用到目标对象之后被动态创建的对象。
– 织入（Weaving）：将切面应用到目标对象从而创建一个新的代理对象的过程。
• 开源的AOP框架 – AspectJ
164
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
