代理模式

一、概念

　　1、定义

　　为其他对象提供一种代理以控制对这个对象的访问，在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

　　2、优点

真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事物。

代理对象可以在客户端和目标对象之间起到中介作用、

高扩展性

二、代理模式组成

　　在代理模式中，通常涉及到下面4中角色：

　　ISubject：该接口是对被访问者或被访问资源的抽象

　　SubjectImpl：被访问者的具体实现类

　　SubjectProxy：被访问者的代理实现类，SubjectProxy持有SubjectImpl的实例

　　Client：代表访问者的角色，Client将会访问ISubject类型的对象或资源，Client必须通过ISubject资源的访问代理类SubjectProxy进行

三、代理模式实现方式

　　1、静态代理

　　SubjectImpl和SubjectProxy都实现了相同的接口，而SubjectProxy内部持有SubjectImpl的引用，当Client通过request()请求服务的时候，SubjectProxy将请求转发给SubjectImpl。在将请求转发给被代理对象SubjectImpl之前或者之后，都可以根据情况插入其他处理逻辑，比如在转发之前记录方法执行开始时间，在转发之后记录结束时间。示例代码如下：

/*
* ISubject角色
*/
public interface Aithmetic
{
public int add(int i,int j);
public int sub(int i,int j);
}

/**
* ISubjectImpl角色
*/
public class AithmeticImpl implements Aithmetic
{
public int add(int i, int j)
{
int result=i+j;
return result;
}
public int sub(int i, int j)
{
int result=i-j;
return result;
}
}

/*
* SubjectProxy角色
*/
public class AithmeticProxy implements Aithmetic
{
private Aithmetic aithmetic;
public AithmeticProxy(Aithmetic aithmetic)
{
this.aithmetic=aithmetic;
}
public int add(int i, int j)
{
//加入自己的逻辑
System.out.println("自定义逻辑开始");
int sum=aithmetic.add(i, j);
return sum;
}
public int sub(int i, int j)
{
System.out.println("自定义逻辑开始");
int sub=aithmetic.sub(i, j);
return sub;
}
}

/*
* Client角色
*/
public class AithmeticProxyTest
{
@Test
public void test()
{
Aithmetic aithmetic=new AithmeticImpl();
AithmeticProxy aithmeticProxy=new AithmeticProxy(aithmetic);
int sum=aithmeticProxy.add(2, 3);
System.out.println(sum);
}
}

　　


　　静态代理的缺点：针对不一样的目标对象类型，我们要为其单独实现一个代理对象，而实际上，这些代理对象所要添加的横切逻辑是一样的。

　　2、动态代理

　　我们利用动态代理机制，可以为指定的接口在系统运行期间动态的生成代理对象。

　　动态代理机制的实现主要由一个类和一个接口组成，即Java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler接口，下面给出示例为两种不同的类型提供代理对象。

　　假设现在有两个接口，都有request方法，我们想在request方法执行之前加入自己的处理逻辑。两个接口如下：

public interface Aithmetic
{
public int add(int i,int j);
public int sub(int i,int j);
public void request();
}

public interface IRequestable
{
public void request();
}

public class AithmeticImpl implements Aithmetic
{
public int add(int i, int j)
{
int result=i+j;
return result;
}
public int sub(int i, int j)
{
int result=i-j;
return result;
}
public void request()
{
System.out.println("执行AithmeticImpl的request函数");
}
}

public class IRequestableImpl implements IRequestable
{

public void request()
{
System.out.println("执行IRequestableImpl的request函数");
}
}

　　为了达到目的，我们需要实现一个InvocationHandler：

public class MyInvocationHandler implements InvocationHandler
{

private Object target;
public MyInvocationHandler(Object target)
{
this.target=target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
if(method.getName().equals("request"))
{
System.out.println("加入自己的逻辑");
}
return method.invoke(target, args);
}
}

　　然后就可以使用Proxy类，根据MyInvocationHandler的逻辑，为Aithmetic和IRequestable两种类型生成相应的代理对象实例：

public class MyInvocationHandlerTest
{
@Test
public void test()
{
Aithmetic aithmetic=(Aithmetic) Proxy.newProxyInstance(MyInvocationHandlerTest.class.getClassLoader(), new Class[]{Aithmetic.class}, new MyInvocationHandler(new AithmeticImpl()));
aithmetic.request();
System.out.println(aithmetic.add(2,3));

IRequestable iRequestable=(IRequestable) Proxy.newProxyInstance(MyInvocationHandlerTest.class.getClassLoader(), new Class[]{IRequestable.class}, new MyInvocationHandler(new IRequestableImpl()));
iRequestable.request();
}
}

　　执行结果为：

　　


　　动态代理的缺点：动态代理的只能对实现了相应的接口的类使用，如果某个类没有实现任何接口，就无法使用 动态代理机制为其生成相应的动态代理对象。

　　3、动态字节码生成

　　原理：我们可以对目标对象进行继承扩展，为其生成相应的子类，而子类可以通过覆写来扩展父类的行为，只要将横切逻辑的实现放在子类中，然后让系统使用扩展后的目标对象的子类，就可以达到与代理模式相同的效果了。我们借助于CGLIB这样的动态字节码生成库，在系统运行期间为目标对象生成相应的扩展子类。

　　注：需要用到以下三个包

　　


　　下面是示例代码：

　　首先编写需要代理的目标对象：

public class TargetObject
{
public int add(int i, int j)
{
int result = i + j;
return result;
}
}

　　创建cglib代理的工厂类：

public class CglibProxy implements MethodInterceptor
{
//设置需要创建子类的类
private Object targetObject;
public Object createProxyInstance(Object target)
{
this.targetObject = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.targetObject.getClass());
//设置回调函数
enhancer.setCallback(this);
//通过字节码技术动态创建子类实例
return enhancer.create();
}
public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable
{
/*obj:目标类实例
*method：目标类法方法的反射对象
*args:方法的动态入参
*methodProxy:代理类实例
*/
System.out.println("加入自己的逻辑");
//通过代理类调用父类中的方法
Object result = methodProxy.invoke(targetObject, args);
System.out.println("操作结束");
return result;
}

}

　　测试：

public class CglibProxyTest
{
@Test
public void test()
{
CglibProxy cglibProxy=new CglibProxy();
TargetObject t=(TargetObject) cglibProxy.createProxyInstance(new TargetObject());
System.out.println(t.add(2, 3));
}
}

　　执行结果：

　　


　　注：CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法。因为是继承，所以该类或方法不要声明成final。