代理模式（Proxy）为其他对象提供一种代理以控制对这个对象的访问 。
场景：随着移动支付业务的扩展，交电话费不在需要跑到营业厅缴纳，使用支付宝、微信、网上银行等网上支付渠道就可以足不出户轻松缴纳电话费。
角色
抽象主题角色(Subject) 主要用来声明代理类和真实类的共同接口。代理类和真实类都需要实现该接口。例如：缴纳电话费。
代理主题角色(ProxySubject)。(含有对真实主题的引用),通常在调用真实主题的方法前后加入些其他的操作, 这是目的所在。例如：网上银行。
真实主题角色(RealSubject)。需要真实引用的那个角色。例如：缴费人。
// Subject抽象主题角色:
public interface class PhonePay {
//手机号码及缴纳金额
void pay(String phoneNo，double money);
}
// RealSubject 真实主题角色:
public class SomeonePhonePay implements PhonePay {
//手机号码及缴纳金额
public void pay(String phoneNo，double money) {
//此处可以调用运营商充值接口。
System.out.println(“ 为手机号为： “ +phoneNo + ” 充值 “+ money);
}
}
// ProxySubject代理主题角色:
public class BankPhonePay extends PhonePay {
private PhonePay someone;
public void pay(String ，double money) {
String id = beforRequest(phoneNo，money);
someone.pay(phoneNo，money);
afterRequest(phoneNo， id);
}
private void beforRequest(String phoneNo ，money) {
someone = new SomeonePhonePay();
System.out.println(phoneNo + " login Web Bank");
System.out.println(“ 提取需要充值的转账金额,并生成流水ID");
return id;
}
private void afterRequest(String phoneNo ， id) {
System.out.println(“ 依照ID确认转账成功。");
System.out.println(phoneNo + " after request，logout");
}
}
上面一种是普通代理，还有一种强制代理。强制代理在代理模式中比较另类，一般的思维都是通过代理找到真实的角色，但是强制代理却是要“强制” 你必须通过真实角色查找到代理角色，否则你不能访问，不管是通过代理类还是通过直接new一个主题角色类，都不能访问，只有通过真实角色指定的代理类才可以访问，也就是说由真实角色管理代理角色，可以这样讲就是new了一个真实角色的对象，返回的却是代理角色。
场景：一天，A找局长办一件事情，但是局长当天的行程安排很满，只能指定秘书完成。这样只有秘书才是局长指定的代理，其他任何人都无法替代。
public interface Subject{
void doRequest();
Subject getProxy(); //指定代理
}
public class ProxySubject implements Subject{
private Subject proxy = null;
public ProxySubject(Subject proxy){
this.proxy = proxy;
}
public void doRequest(){
proxy.doRequest();
}
// 代理的代理暂时还没有,就是自己
public Subject getProxy(){
return this;
}
}
public class RealSubject implements Subject {
private Subject proxy = null; // 指定的代理是谁
public void doRequest(){
if (proxy != null){
System.out.println("do Request");
} else{
System.out.println("please use proxy，refuse doing this request");
}
}
public Subject getProxy(){
this.proxy = new ProxySubject(this);
return proxy;
}
}
public class Client{
public static void main(String[] args) {
Subject playerR = new RealSubject();
playerR.doRequest();// 不可以直接使用 需要由指定的代理完成
playerR.getProxy().doRequest();// 由代理可以完成
// 在代理中即使指定真实对象，但是由于不是由真实对象指定的依然不能完成
Subject playerR1 = new RealSubject();
Subject playerP = new ProxySubject(playerR1);
playerP.doRequest();
//代理即使获取代理依然无法执行
playerP.getProxy().doRequest();
}
}
代理模式使用场景
远程代理(Remote Proxy )：该代理可以让客户端透明地引用一个存在于不同地址空间（远程或本地）的对象。 Java中的RMI技术是远程调用和webservice服务就是典型的远程代理模式，客户并不知道网络访问细节（访问本地还是远程网络），代理对象对外屏蔽了网络通讯细则。
保护代理（Protection Proxy）控制对RealSubject对象的访问。可以实现给不同的用户提供不同级别的使用权限。保护代理可以在运行时间对用户的有关权限进行检查，然后在核实后决定将调用传递给被代理的对象，应用于权限控制。
虚拟代理(Virtual Proxy)：该代理允许一个对象只有在真正被用到时才被创建。 hibernate中的懒加载。或文档中有非常大的图片，为了保证文档打开速度，在打开文档的时候并不真正创建图片对象，只有当用到图片的时候，才会去创建图片对象， 百度文库的预览。
防火墙代理（Firewall Proxy）：保护目标对象不受某些不良客户端的侵害。
同步代理（Synchronization Proxy）： 使几个用户能够同时使用一个对象而没有冲突，提供并发控制。
对象拷贝延迟代理(Copy-on-Write Proxy)：该代理可以延迟一个对象的拷贝操作到客户调用里，它是Virtual Proxy模式的一种特殊情况。一般来说，对象的深度克隆是一个高开销的动作，该代理可以让这个动作延迟，只有对象被用到的时候才被克隆。比如，有一个很大的Collection,具体如hashtable,有很多客户端会并发同时访问它。其中一个特别的客户端要进行连续的数据获取,此时由于是针对clone 出来的对象操作,如果原来的母体被其他客户端操作修改了,那么对clone出来的对象操作就没有意义了。可以等其他客户端修改完成后再进行clone,也就是说,这个特别的客户端先通过调用一个叫clone的方法来进行一系列数据获取操作。但实际上没有真正的进行对象拷贝,直至有其他客户端修改了这个对象Collection。
智能引用代理（Smart Reference Proxy）：当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。
缓存代理（Cache Proxy）： 为创建时高开销的对象提供缓存，以供多客户端共享。如数据库代理，客户端进行Sql查询时，并不访问数据库，而是通过与数据库代理之间进行交互，如果数据库代理中没有缓存数据，才真正去数据库查询。
Java实现代理的方式分为静态代理和动态代理，动态代理又分为基于jdk的动态代理和基于cglib的动态代理。
JAVA代理机制之静态代理：静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。
//Subject
public interface IUserDao {
void save();
}
//realSubject
public class UserDao implements IUserDao {
public void save() {
System.out.println("----已经保存数据!----");
}
}
//代理对象,静态代理 proxySubject
public class UserDaoProxy implements IUserDao{
//接收保存目标对象
private IUserDao target;
public UserDaoProxy(IUserDao target){
this.target=target;
}
public void save() {
System.out.println("开始事务...");
target.save();//执行目标对象的方法
System.out.println("提交事务...");
}
}
public class App {
public static void main(String[] args) {
//目标对象
UserDao target = new UserDao();
//代理对象,把目标对象传给代理对象,建立代理关系
UserDaoProxy proxy = new UserDaoProxy(target);
proxy.save();//执行的是代理的方法
}
}
优点：可以做到在不修改目标对象的功能前提下,对目标功能在代理类中完成扩展。
缺点: 因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护。
JAVA代理机制之基于JDK的动态代理
动态代理有以下特点:
代理对象,不需要实现接口。
代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型) ，利用Java反射机制实现。
动态代理也叫做:JDK代理,接口代理。
JDK中生成代理对象的API，代理类所在包:java.lang.reflect.Proxy。
JDK实现代理只需要使用newProxyInstance方法即可。
通过实现接口的方式 -> JDK动态代理
//Subject
public interface IUserDao {
void save();
}
//realSubject
public class UserDao implements IUserDao {
public void save() {
System.out.println("----已经保存数据!----");
}
}
public class ProxyFactory{ //proxy不需要继承接口
//维护一个目标对象
private Object target;
public ProxyFactory(Object target){
this.target=target;
}
//给目标对象生成代理对象，并将要实现的动作，原接口的声明，通过匿名类的方式实现。
public Object getProxyInstance(){
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始事务2");
//执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("提交事务2");
return returnValue;
}
}
);
}
}
public class App {
public static void main(String[] args) {
// 目标对象
IUserDao target = new UserDao();
System.out.println(target.getClass());
// 给目标对象，创建代理对象
IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
// class $Proxy0 内存中动态生成的代理对象
System.out.println(proxy.getClass());
// 执行方法 【代理对象】
proxy.save();
}
}
代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理。
public class ProxyFactory implements InvocationHandler {
//proxy不需要继承需要代理实现的接口，但需要继承InvocationHandler类来简化instance
//维护一个目标对象
private Object target;
public ProxyFactory(Object target){
this.target=target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始事务2");
//执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("提交事务2");
return returnValue;
}
}
public class App {
public static void main(String[] args) {
IUserDao target = new UserDao();
System.out.println(target.getClass());
InvocationHandler subjectProxy = new SubjectProxy(target);
IUserDao proxyInstance = (IUserDao)
Proxy.newProxyInstance(subjectProxy.getClass().getClassLoader(),
target.getClass().getInterfaces(), subjectProxy);
proxyInstance.save();
}
}
JAVA代理机制之基于CGILB的动态代理
静态代理和基于JDK的动态代理模式都是要求目标对象是实现一个接口的目标对象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理
通过继承类的方式 -> CGLIB动态代理
Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。
Cglib子类代理实现方法：
代理的类不能为final,否则报错。
目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法。
//realSubject
public class UserDao {
//subject简化成方法而不是接口
public void save() {
System.out.println("----已经保存数据!----");
}
}
//proxysbuject
public class ProxyFactory implements MethodInterceptor{
//维护目标对象
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
//给目标对象创建一个代理对象
public Object getProxyInstance(){
//1.工具类
Enhancer en = new Enhancer();
//2.设置父类
en.setSuperclass(target.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类(代理对象)
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("开始事务...");
//执行目标对象的方法
Object returnValue = method.invoke(target, args);
System.out.println("提交事务...");
return returnValue;
}
}
public class App {
public static void main(String[] args){
//目标对象
UserDao target = new UserDao();
//代理对象
UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();
//执行代理对象的方法
proxy.save();
}
}