2.6 代理模式
代理的原理可先参看此文章：Java基础-001-枚举、反射、类加载器、内省、注解、泛型、代理
定义：
Proxy Pattern，也叫委托模式
Provide a surrogate or placeholder for another object to control access to it
为其它对象提供一种代理以控制对这个对象的访问
许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。
角色定义：
Subject抽象主题角色
可以是抽象类或接口，是一个最普通的业务类型定义，无特殊要求
RealSubject具体主题角色（真实角色）
也叫做被委托角色、被代理角色。是业务逻辑的具体执行者
Proxy代理主题角色
也叫做委托类、代理类。负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并在真实主题角色处理完毕前后做预处理和善后处理。
优点：
- 职责清晰
真实角色实现实际的业务逻辑，不用关心其它非本职责的逻辑，后期通过代理完成一件事务，结果就是编程简洁清晰
- 高扩展性
具体主题角色可随时发生变化。只要实现了抽象主题接口，代理类就不用再次修改。
- 智能化
动态代理
使用场景：
参考Spring AOP
2.6.1 扩展-普通代理
客户端只能访问代理角色，不能访问真实角色
代码：
/**
* 抽象角色
*/
interface IGamePlayer{
public void login(String user, String password);//登录
public void killBoss();//打怪
public void upgrade();//升级
}
/**
* 真实角色
*/
class GamePlayer implements IGamePlayer{
private String name;
/**
* 构造函数限制谁能创建对象，并同时传递姓名
* 还可以增加其它限制，比如类名必须为Proxy等
*
* 在实际的项目中，一般都是通过约定来禁止new一个真实的角色
*/
public GamePlayer(IGamePlayer gamePlayer, String name) throws Exception{
if(gamePlayer == null){
throw new Exception("不能创建真实角色");
}else{
this.name = name;
}
}
@Override
public void login(String user, String password) {
System.out.println("登录名：" + user +"; 密码：" + password + "。登录成功！");
}
@Override
public void killBoss() {
System.out.println(this.name + "在打怪！");
}
@Override
public void upgrade() {
System.out.println(this.name + "又升了一级！");
}
}
/**
* 代理类
*/
class GamePlayerProxy implements IGamePlayer{
private IGamePlayer gamePlayer;
public GamePlayerProxy(String name){
try{
gamePlayer = new GamePlayer(this, name);
}catch(Exception e){
//异常处理
}
}
@Override
public void login(String user, String password) {
this.gamePlayer.login(user, password);
}
@Override
public void killBoss() {
this.gamePlayer.killBoss();
}
@Override
public void upgrade() {
this.gamePlayer.upgrade();
}
}
/**
* 场景类
*/
class Client{
public static void main(String[] args) {
IGamePlayer proxy = new GamePlayerProxy("张三");
proxy.login("zhangsan", "123456");
proxy.killBoss();
proxy.upgrade();
}
}
2.6.2 扩展-强制代理
要求：
- 必须通过真实角色才能找到代理角色
- 直接通过代理类或new真实角色来调用方法都不能得到想要的结果
- 真实角色管理代理角色
代码：
/**
* 抽象角色
*/
interface IGamePlayer_Force{
public void login(String user, String password);
public void killBoss();
public void upgrade();
//每个类都可以找自己的代理
public IGamePlayer_Force getProxy();
}
/**
* 具体角色
*/
class GamePlayer_Force implements IGamePlayer_Force{
private String name;
private IGamePlayer_Force proxyForce;
public GamePlayer_Force(String name){
this.name = name;
}
@Override
public void login(String user, String password) {
if (this.isProxy()) {
System.out.println("登录名：" + user +"; 密码：" + password + "。登录成功！");
} else {
System.out.println("请使用指定的代理访问");
}
}
@Override
public void killBoss() {
if (this.isProxy()) {
System.out.println(this.name + "在打怪！");
} else {
System.out.println("请使用指定的代理访问");
}
}
@Override
public void upgrade() {
if (this.isProxy()) {
System.out.println(this.name + "又升了一级！");
} else {
System.out.println("请使用指定的代理访问");
}
}
@Override
public IGamePlayer_Force getProxy() {
this.proxyForce = new GamePlayerProxy_Force(this);
return this.proxyForce;
}
// 校验是否是代理访问
private boolean isProxy() {
if (this.proxyForce == null) {
return false;
} else {
return true;
}
}
}
/**
* 代理类
*/
class GamePlayerProxy_Force implements IGamePlayer_Force {
private IGamePlayer_Force gamePlayerForce;
public GamePlayerProxy_Force(IGamePlayer_Force gamePlayerForce){
this.gamePlayerForce = gamePlayerForce;
}
@Override
public void login(String user, String password) {
this.gamePlayerForce.login(user, password);
}
@Override
public void killBoss() {
this.gamePlayerForce.killBoss();
}
@Override
public void upgrade() {
this.gamePlayerForce.upgrade();
}
//代理类的代理暂时没有，返回自己
@Override
public IGamePlayer_Force getProxy() {
return this;
}
}
/**
* 场景类
*/
class Client_Force {
public static void main(String[] args) {
IGamePlayer_Force player = new GamePlayer_Force("张三");
IGamePlayer_Force proxy = player.getProxy();
proxy.login("zhangSan", "password");
proxy.killBoss();
proxy.upgrade();
}
}
2.6.3 扩展-代理类的个性
interface IProxy {
public void count(); //计算费用
}
class GamePlayerProxy_Force implements IGamePlayer_Force, IProxy {
//...
@Override
public void upgrade() {
this.gamePlayerForce.upgrade();
this.count();
}
@Override
public void count() {
System.out.println("升级费用是:￥100");
}
}
2.6.4 扩展-动态代理
动态代理： 在实现阶段不用关心代理是谁，在运行阶段才指定代理哪一个类。
代码一：参考代码（引子）
interface IGamePlayer{
public void login(String user, String password);
public void killBoss();
public void upgrade();
public IGamePlayer getProxy();//每个类都可以找自己的代理
}
class GamePlayer implements IGamePlayer{
private String name;
private IGamePlayer proxyForce;
public GamePlayer(String name){
this.name = name;
}
//...
}
//动态代理
class GamePlayIH implements InvocationHandler {
Object obj ; // 被代理的实例
// 我要代理谁
public GamePlayIH(Object _obj) {
this.obj = _obj;
}
// 调用被代理的方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(this.obj, args);
return result;
}
}
class Client2 {
public static void main(String[] args) throws Throwable {
IGamePlayer player = new GamePlayer("张三");//对应强制代理的GamePlayer_Force
//定义一个handler
InvocationHandler handler = new GamePlayIH(player);
//获得类的class loader
ClassLoader cl = player.getClass().getClassLoader();
//动态产生一个代理者
IGamePlayer proxy = (IGamePlayer)Proxy.newProxyInstance(cl,
new Class[]{IGamePlayer.class}, handler);
proxy.login("zhangSan", "password");
proxy.killBoss();//开始杀怪
proxy.upgrade();//升级
}
}
代码二：模板代码（定义用）
/**
* ❉ ❉ ❉ ❉ ❉ ❉ 主题 ❉ ❉ ❉ ❉ ❉ ❉
*/
//抽象主题
interface Subject{
public void doSomething(String str);
}
//真实主题
class RealSubject implements Subject{
public void doSomething(String str){
System.out.println("doSomething: " + str);
}
}
/**
* ❉ ❉ ❉ ❉ ❉ ❉ 动态代理的Handler ❉ ❉ ❉ ❉ ❉ ❉
*/
class MyInvocationHandler implements InvocationHandler{
private Object target; //被代理对象
public MyInvocationHandler(Object obj){
this.target = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(target, args);
}
}
/**
* ❉ ❉ ❉ ❉ ❉ ❉ 动态代理类 ❉ ❉ ❉ ❉ ❉ ❉
*/
class DynamicProxy<T>{
public static<T> T newProxyInstance(ClassLoader loader,
Class<?>[] interfaces, InvocationHandler h){
//寻找JoinPoint连接点
if(true){
(new BeforeAdvice()).exec();
}
return (T) Proxy.newProxyInstance(loader, interfaces, h);
}
}
/**
* ❉ ❉ ❉ ❉ ❉ ❉ 通知 ❉ ❉ ❉ ❉ ❉ ❉
*/
//通知接口
interface IAdvice{
public void exec();
}
//前置通知
class BeforeAdvice implements IAdvice{
public void exec(){
System.out.println("我是前置通知");
}
}
/**
* ❉ ❉ ❉ ❉ ❉ ❉ 补充：具体业务动态代理类 ❉ ❉ ❉ ❉ ❉ ❉
*/
class SubjectDynamicProxy extends DynamicProxy{
public static<T> T newProxyInstance(Subject subject){
ClassLoader loader = subject.getClass().getClassLoader();
Class<?>[] cls = subject.getClass().getInterfaces();
InvocationHandler h = new MyInvocationHandler(subject);
return newProxyInstance(loader, cls, h);
}
}
/**
* ❉ ❉ ❉ ❉ ❉ ❉ 场景类 ❉ ❉ ❉ ❉ ❉ ❉
*/
class ProxyClient{
public static void main(String[] args) {
//定义主题类
Subject subject = new RealSubject();
//定义主题类的代理
Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);
proxy.doSomething("Finish");
}
}