Java的23种设计模式---(6)代理模式
代理模式（Proxy pattern）
代理模式：通过代理，控制对对象的访问。可以详细控制某个对象的方法，在调用这个方法前做前置处理，调用者这个方法后做后置处理。核心使用了AOP机制。
AOP（Aspect Oriented Programming面向切面编程）
它是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加一种功能的一种技术。是一种新的方法论，对传统OOP编程的一种补充。
常用术语：
切面（Aspect）：其实就是共有功能的实现。
通知（Advice）：是切面的具体实现。
连接点（Joinpoint）：就是程序在运行过程中能够插入切面的地点。
切入点（Pointcut）：用于定义通知应该切入到哪些连接点上。
目标对象（Target）：就是那些即将切入切面的对象，也就是那些被通知的对象
代理对象（Proxy）：将通知应用到目标对象之后被动态创建的对象。
织入（Weaving）：将切面应用到目标对象从而创建一个新的代理对象的过程。
代理模式的核心角色：
抽象角色：定义代理角色和真实角色的公共对外方法。
真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，提供给代理角色调用，只关注真正的业务逻辑。
代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。（将统一的流程控制放到代理角色中处理）
应用场景：
- 安全代理：屏蔽对真实角色的直接访问。
- 远程代理：通过代理类处理远程方法调用(RMI)
- 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
- 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
分类
静态代理（静态定义代理类）
动态代理（动态生成代理类）
- 动态代理相比于静态代理的优点：抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
静态代理模式
抽象角色
package com.kevin.结构型模式.代理模式.staticProxy;
/**
* @author kevin
* @version 1.0
* @description 抽象角色
* @createDate 2019/2/25
*/
public interface Star {
/**
* 面谈
*/
void confer();
/**
* 签合同
*/
void signContract();
/**
* 订票
*/
void bookTicket();
/**
* 唱歌
*/
void sing();
/**
* 收钱
*/
void collectMoney();
}
代理角色
package com.kevin.结构型模式.代理模式.staticProxy;
import com.kevin.结构型模式.代理模式.proxy.Star;
/**
* @author kevin
* @version 1.0
* @description 代理角色
* @createDate 2019/2/25
*/
public class ProxyStar implements Star {
private Star star; // 代理的对象
public ProxyStar() {
}
public ProxyStar(Star star) {
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()");
}
}
真实角色
package com.kevin.结构型模式.代理模式.staticProxy;
/**
* @author kevin
* @version 1.0
* @description 真实角色
* @createDate 2019/2/25
*/
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("周杰伦唱歌...");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
测试静态代理模式
package com.kevin.结构型模式.代理模式.staticProxy;
import com.kevin.结构型模式.代理模式.proxy.RealStar;
import com.kevin.结构型模式.代理模式.proxy.Star;
/**
* @author kevin
* @version 1.0
* @description 静态代理测试
* @createDate 2019/2/25
*/
public class Test {
public static void main(String[] args) {
RealStar real = new RealStar(); // 真实对象
Star proxy = new ProxyStar(real); // 将真实角色传入代理角色
proxy.confer();
proxy.signContract();
proxy.bookTicket();
proxy.sing();
proxy.collectMoney();
}
}
动态代理模式
抽象角色
package com.kevin.结构型模式.代理模式.proxy;
/**
* @author kevin
* @version 1.0
* @description 抽象角色
* @createDate 2019/2/25
*/
public interface Star {
/**
* 面谈
*/
void confer();
/**
* 签合同
*/
void signContract();
/**
* 订票
*/
void bookTicket();
/**
* 唱歌
*/
void sing();
/**
* 收钱
*/
void collectMoney();
}
动态代理
package com.kevin.结构型模式.代理模式.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* @author kevin
* @version 1.0
* @description 动态代理
* @createDate 2019/2/26
*/
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(method.getName().equals("sing")){
method.invoke(realStar,args);
}
System.out.println("真正的方法执行后");
System.out.println("收尾款");
return null;
}
}
真实角色
package com.kevin.结构型模式.代理模式.proxy;
/**
* @author kevin
* @version 1.0
* @description 真实角色
* @createDate 2019/2/25
*/
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("周杰伦唱歌...");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
模拟动态生成的代理结构
package com.kevin.结构型模式.代理模式.proxy;
/**
* @author kevin
* @version 1.0
* @description 模拟动态生成的代理结构
* @createDate 2019/2/26
*/
public class ProxyStar implements Star{
StarHandler handler;
public ProxyStar(StarHandler handler) {
this.handler = handler;
}
@Override
public void confer() {
// handler.invoke(this,当前方法，args);
// 每个方法都这么写，相当于调用每个方法的时候都会到invoke调用
}
@Override
public void signContract() {
// handler.invoke(this,当前方法，args);
// 每个方法都这么写，相当于调用每个方法的时候都会到invoke调用
}
@Override
public void bookTicket() {
// handler.invoke(this,当前方法，args);
// 每个方法都这么写，相当于调用每个方法的时候都会到invoke调用
}
@Override
public void sing() {
// handler.invoke(this,当前方法，args);
// 每个方法都这么写，相当于调用每个方法的时候都会到invoke调用
}
@Override
public void collectMoney() {
// handler.invoke(this,当前方法，args);
// 每个方法都这么写，相当于调用每个方法的时候都会到invoke调用
}
}
测试动态代理模式
package com.kevin.结构型模式.代理模式.proxy;
import java.lang.reflect.Proxy;
/**
* @author kevin
* @version 1.0
* @description 测试动态代理模式
* @createDate 2019/2/26
*/
public class Test {
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.bookTicket();
proxy.sing();
}
}
开发框架中应用场景：
– struts2中拦截器的实现
– 数据库连接池关闭处理
– Hibernate中延时加载的实现
– mybatis中实现拦截器插件
– AspectJ的实现
– spring中AOP的实现
• 日志拦截
• 声明式事务处理
– web service
– RMI远程方法调用