解释
为其他对象提供一种代理以控制对这个对象的访问
示例引入
以打游戏为例子，大概整个打游戏的过程可以概括为登录、打怪、升级、砍人、被人砍等等一系列动作。由于游戏打的时间长了，腰酸背痛、眼睛干涩、手臂麻木等等，其结果就类似于吃了那个“一日丧命散”，“筋脉逆流，胡思乱想，而致走火入魔”，那怎么办？我们想玩游戏，但又不想碰触到游戏中的烦恼，如何解决呢？有办法，现在游戏代练的公司非常多，可以把自己的账号交给代练人员，由他们去帮我们升级打怪，非常好的想法，整个过程抽象成程序如下：
游戏类图
游戏类图
/**
* Created by zs on 2017/3/23.
*
* 游戏者接口
*/
public interface IGamePlayer{
//登录
public void login(String user,String password);
//杀怪
public void killBoss();
//升级
public void upgrade();
}
/**
* Created by zs on 2017/3/23.
*
* 游戏者
*/
public class GamePlayer implements IGamePlayer {
private String mName = "";
public GamePlayer(String name){
this.mName = name;
}
@Override
public void login(String user, String password) {
System.out.println("登录名为" +user + "的用户" + this.mName + "登录成功！" );
}
@Override
public void killBoss() {
System.out.println(this.mName + "在打怪");
}
@Override
public void upgrade() {
System.out.println(this.mName + "又升了一级");
}
}
/**
* Created by zs on 2017/3/23.
*
* 代练者
*/
public class GamePlayerProxy implements IGamePlayer {
private IGamePlayer mGamePlayer = null;
public GamePlayerProxy(IGamePlayer gamePlayer){
this.mGamePlayer = gamePlayer;
}
@Override
public void login(String user, String password) {
this.mGamePlayer.login(user,password);
}
@Override
public void killBoss() {
this.mGamePlayer.killBoss();
}
@Override
public void upgrade() {
this.mGamePlayer.upgrade();
}
}
/**
* Created by zs on 2017/3/23.
*
* 场景类
*/
public class Client {
public static void main(String[] args) {
IGamePlayer player = new GamePlayer("张三");
IGamePlayer proxy = new GamePlayerProxy(player);
proxy.login("San","123456");
proxy.killBoss();
proxy.upgrade();
}
}
通用类图
代理模式通用类图
类图解析
Subject：抽象主题角色，可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。（目标接口）
RealSubject：具体主题角色，也叫做被委托角色、被代理角色、是业务逻辑的具体执行者。（目标类）
Proxy：代理主题角色，也叫委托类、代理类。它负责最真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作（代理类）
写法
静态代理：目标类和代理类实现或继承目标接口或抽象类，代理类中有目标类的引用
动态代理：见下文描述
通用代码
/**
* Created by zs on 2017/3/24.
*
* 抽象主题类
*/
public interface Subject {
public void request();
}
/**
* Created by zs on 2017/3/24.
*
* 真实主题类
*/
public class RealSubject implements Subject {
@Override
public void request() {
// to do you work
}
}
/**
* Created by zs on 2017/3/24.
*
* 代理类
*/
public class Proxy implements Subject {
private Subject mSubject = null;
//默认代理者
public Proxy(){
this.mSubject = new Proxy();
}
//通过构造函数传递代理者
public Proxy(Subject subject){
this.mSubject = subject;
}
@Override
public void request() {
this.before();
this.mSubject.request();
this.after();
}
//预处理
private void before(){
//to do you work...
}
//善后
private void after(){
// to do you work...
}
}
代理模式分类
总的分为：静态代理和动态代理
远程代理：隐藏了一个对象存在于不同的地址空间的事实，也即是客户通过远程代理去访问一个对象，根本就不关心这个对象在哪里，也不关心如何通过网络去访问到这个对象，从客户的角度来讲，它只是在使用代理对象而已。
虚拟代理：可以根据需要来创建“大”对象，只有到必须创建对象的时候，虚代理才会创建对象，从而大大加快程序运行速度，并节省资源。通过虚代理可以对系统进行优化。
保护代理：可以在访问一个对象的前后，执行很多附加的操作，除了进行权限控制之外，还可以进行很多跟业务相关的处理，而不需要修改被代理的对象。也就是说，可以通过代理来给目标对象增加功能。
智能引用代理：允许在访问一个对象的前后，执行很多附加的操作，这样一来就可以做很多额外的事情。（本文中重点解释描述）
应用场景
需要为一个对象在不同的地址空间提供局部代表的时候，可以使用远程代理；
需要按照需要创建开销很大的对象的时候，可以使用虚拟代理；
需要控制对原始对象的访问的时候，可以使用保护代理；
需要在访问对象的时候执行一些附加操作的时候，可以使用智能引用代理；（本文中重点解释描述 ）--->（重要的事说三遍）
压轴大戏之动态代理
问题：
- 对于静态代理而言，我们每一个代理类都只能为一个接口服务，这样一来程序开发必然会产生过多的代理
- 如果Subject接口发生变化，那么代理类和具体的目标实现都要变化，不是很灵活
解决这些问题的最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。现在有一个非常流行的名称叫做面向切面编程，也就是AOP，其核心就是采用了动态代理机制。
对于动态代理jdk和cglib都已经做了实现，我们在开发中使用它们封装好的动态代理很方便。（本文重点描述jdk是如何实现动态代理）Java对代理模式提供了内建的支持，在java.lang.reflect包下面，提供了一个Proxy的类和一个InvocationHandler的接口。
示例代码
/**
* Created by zs on 2017/3/23.
*
* 游戏者接口
*/
public interface IGamePlayer {
//登录
public void login(String user, String password);
//杀怪
public void killBoss();
//升级
public void upgrade();
}
/**
* Created by zs on 2017/3/23.
*
* 游戏者
*/
public class GamePlayer implements IGamePlayer {
private String mName = "";
public GamePlayer(String name){
this.mName = name;
}
@Override
public void login(String user, String password) {
System.out.println("登录名为" +user + "的用户" + this.mName + "登录成功！" );
}
@Override
public void killBoss() {
System.out.println(this.mName + "在打怪");
}
@Override
public void upgrade() {
System.out.println(this.mName + "又升了一级");
}
}
/**
* Created by zs on 2017/3/24.
*
* 动态代理类
* 动态代理是根据被代理的接口生成所有的方法，
* 也就是说给定一个接口，动态代理会宣称"我已经实现了该接口的所有方法了"
*/
public class GamePlayerIH implements InvocationHandler{
//被代理者
Class cls = null;
//被代理实例
Object obj = null;
//我要代理谁
public GamePlayerIH(Object obj){
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(this.obj,args);
return result;
}
}
/**
* Created by zs on 2017/3/23.
*
* 场景类
*/
public class Client {
public static void main(String[] args) {
//定义一个玩家
IGamePlayer player = new GamePlayer("张三");
//定义一个handler
InvocationHandler handler = new GamePlayerIH2(player);
//获得类的class loader
ClassLoader cl = player.getClass().getClassLoader();
//动态产生一个代理者
IGamePlayer proxy = (IGamePlayer) Proxy.newProxyInstance(cl,new Class[]{IGamePlayer.class},handler);
//登录
proxy.login("San","123456");
//杀怪
proxy.killBoss();
//升级
proxy.upgrade();
}
}
动态代理类图
动态代理类图
相关概念
切面：例如：在用户注册时候，上传用户头像、获取表单数据、权限验证等就是一个个切面
通知：切面中的方法（前置通知、后置通知、环绕通知、最终通知、异常通知等）
切入点：只有符合切入点，才能让通知和目标方法结合在一起
织入：形成代理对象的方法的过程
动态代理通用代码
/**
* Created by zs on 2017/3/24.
*
* 抽象主题
*/
public interface Subject {
//业务处理
public void doSomething(String string);
}
**
* Created by zs on 2017/3/24.
*
* 真实主题
*/
public class RealSubject implements Subject {
@Override
public void doSomething(String string) {
System.out.println("do something ---> " + string);
}
}
/**
* Created by zs on 2017/3/24.
*
* 动态代理的Handler类
*/
public class MyInvocationHandler implements InvocationHandler {
//被代理的对象
private Object target = null;
//通过构造函数传递一个对象
public MyInvocationHandler(Object object){
this.target = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(this.target,args);
}
}
/**
* Created by zs on 2017/3/24.
*
* 通知
*/
public interface IAdvice {
public void execute();
}
/**
* Created by zs on 2017/3/24.
*
* 前置通知
*/
public class BeforeAdvice implements IAdvice {
@Override
public void execute() {
System.out.println("我是前置通知，我被执行了");
}
}
/**
* Created by zs on 2017/3/24.
*
* 动态代理类
*/
public class DynamicProxy<T> {
public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler invocationHandler){
//寻找JoinPoint切入点
if(true){
(new BeforeAdvice()).execute();
}
//执行目标，并返回结果
return (T)Proxy.newProxyInstance(loader,interfaces,invocationHandler);
}
}
/**
* Created by zs on 2017/3/24.
*
* 场景类
*/
public class Client {
public static void main(String[] args) {
Subject subject = new RealSubject();
InvocationHandler handler = new MyInvocationHandler(subject);
Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(),subject.getClass().getInterfaces(),handler);
proxy.doSomething("Finish");
}
}
代码赏析
Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(),subject.getClass().getInterfaces(),handler);
该方法是重新生成了一个对象，subject.getClass().getInterfaces()：查找到该类的所有接口，然后实现接口的所有方法，最终由new MyInvocationHandler(subject)这个对象接管。
代理模式示意图
代理模式示意图
jdk动态代理与cglib区别
Java的动态代理目前只能代理接口，基本的实现是依靠Java的反射机制和动态生成class的技术，来动态生成被代理的接口的实现对象。如果要实现类的代理，可以使用cglib（一个开源的Code Generation Library）
效果
- 职责清晰：真实的角色不用关心其他非本职工作的事务，通过后期的代理完成一件事务，附带的结果就是编程简介清晰
- 高扩展性：具体主题角色是随时都会变化，只要它实现了接口，甭管它如何变化，都逃不开如来佛的手掌（接口）
- 智能化：主要用来做方法的增强，让你可以在不修改源码的情况下，增强一些方法，在方法执行前后做任何你想做的事情
