java设计模式之代理模式

java代理实现可以简单分为静态代理和动态代理。

代理模式(Proxy Pattern)是GoF 23种Java常用设计模式之一。提供了对目标对象另外的访问方式，即通过代理对象访问目标对象。

这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.

这里使用到编程中的一个思想:开闭原则，就是说对扩展开放，对修改关闭。在工作中不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法。

代理模式包含如下角色：

ISubject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口。

RealSubject：真实主题角色，是实现抽象主题接口的类。

Proxy：代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。代理对象提供与真实对象相同的接口，以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

静态代理

代码实现

(1) Subject

/**
* 抽象主题，定义主要功能
*/
public interface Subject {
public void request();
}

(2) RealSubject

/**
* 具体主题
*/
public class RealSubject implements Subject{

@Override
public void request() {
System.out.println("RealSubject start===========");
}
}

(3) Proxy

/**
* 代理类
*/
public class Proxy implements Subject{

private Subject subject;

public Proxy(Subject subject) {
this.subject = subject;
}

@Override
public void request() {
System.out.println("Proxy before subject start!!!!!!!");
subject.request();
System.out.println("Proxy after subject start-------");
}

public static void main(String[] args) {
Subject subject = new RealSubject();
//生成代理类
Proxy proxy = new Proxy(subject);
proxy.request();
}

}

运行结果： Proxy before subject start!!!!!!!

RealSubject start===========

Proxy after subject start——-

建议用聚合方式实现代理，继承式的实现方式则不够灵活，而聚合因为代理类及被代理类都实现了同一个接口，可实现灵活多变。 比如，在管理员操作的同时需要进行权限的处理，操作内容的日志记录，操作后数据的变化三个功能。三个功能的排列组合有6种，也就是说使用继承要编写6个继承了Admin的代理类，而使用聚合，仅需要针对权限的处理、日志记录和数据变化三个功能编写代理类，在业务逻辑中根据具体需求改变代码顺序即可。

静态代理实现中，一个委托类对应一个代理类，代理类在编译期间就已经确定。

动态代理

动态代理中，代理类并不是在Java代码中实现，而是在运行时期生成，相比静态代理，动态代理可以很方便的对委托类的方法进行统一处理，如添加方法调用次数、添加日志功能等等，动态代理分为jdk动态代理和cglib动态代理。

JDK动态代理

代理类所在包:java.lang.reflect.Proxy

JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<\?>[] interfaces,InvocationHandler h )

注意该方法是在Proxy类中是静态方法,且接收的三个参数依次为:

ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的

Class<\?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型

InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的.方法作为参数传入(Class<\?>中的\只是作为转义 无其他特别意义)

利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口定义代理类的实现。

public class JdkDynamicProxy implements InvocationHandler {
/**
* 维护一个要代理的对象
*/
private Object targert;

public JdkDynamicProxy(Object targert) {
this.targert = targert;
}

@Override
public Object invoke(Object object, Method method, Object[] arg) throws Throwable {
System.out.println("代理方法前执行");
//调用被代理对象的方法
method.invoke(targert, arg);
System.out.println("代理方法后执行");
return null;
}
/**
* 给目标对象生成代理对象 并返回
* @return
*/
public Object getProxyInstance(){
return Proxy.newProxyInstance(targert.getClass().getClassLoader(),        targert.getClass().getInterfaces(), this);
}

public static void main(String[] args) {
RealSubject subject = new RealSubject();
Subject proxy = (Subject) (new JdkDynamicProxy(subject).getProxyInstance());
proxy.request();
}
}

代理方法前执行

RealSubject start===========

代理方法后执行

cglib动态代理

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)

Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.

Cglib子类代理实现方法:

1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.

2.引入功能包后,就可以在内存中动态构建子类

3.代理的类不能为final,否则报错

4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

/**
* 目标对象,没有实现任何接口
*/
public class User {

public void save() {
System.out.println("----已经保存用户信息!----");
}
}

/**
* Cglib子类代理工厂
* 对User
b756
在内存中动态构建一个子类对象
*/
public class CglibDynamicProxy implements MethodInterceptor {

/**
* 内部维护一个被代理对象
*/
private Object targert;

public CglibDynamicProxy(Object targert) {
super();
this.targert = targert;
}
/**
* 创建代理对象并返回
* @return
*/
public Object getProxyInstance(){
//1.工具类
Enhancer en = new Enhancer();
//2.设置父类
en.setSuperclass(targert.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类(代理对象)
return en.create();
}
@Override
public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("代理方法前执行");
//调用被代理对象的方法
method.invoke(targert, args);
System.out.println("代理方法后执行");
return null;
}

public static void main(String[] args) {
User user = new User();
//生成代理对象
User proxy = (User) new CglibDynamicProxy(user).getProxyInstance();
proxy.save();
}
}

jdk和cglib动态代理实现的区别

1、jdk动态代理生成的代理类和委托类实现了相同的接口；

2、cglib动态代理中生成的字节码更加复杂，生成的代理类是委托类的子类，且不能处理被final关键字修饰的方法；

3、jdk采用反射机制调用委托类的方法，cglib采用类似索引的方式直接调用委托类方法；

4、如果被代理的目标对象有实现接口,用JDK代理，如果目标对象没有实现接口,用Cglib代理

代理模式的应用形式

(1)远程代理(Remote Proxy) -可以隐藏一个对象存在于不同地址空间的事实。也使得客户端可以访问在远程机器上的对象，远程机器可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。

(2)虚拟代理(Virtual Proxy) – 允许内存开销较大的对象在需要的时候创建。只有我们真正需要这个对象的时候才创建。

(3)写入时复制代理(Copy-On-Write Proxy) – 用来控制对象的复制，方法是延迟对象的复制，直到客户真的需要为止。是虚拟代理的一个变体。

(4)保护代理(Protection (Access)Proxy) – 为不同的客户提供不同级别的目标对象访问权限

(5)缓存代理(Cache Proxy) – 为开销大的运算结果提供暂时存储，它允许多个客户共享结果，以减少计算或网络延迟。

(6)防火墙代理(Firewall Proxy) – 控制网络资源的访问，保护主题免于恶意客户的侵害。

(7)同步代理(SynchronizationProxy) – 在多线程的情况下为主题提供安全的访问。

(8)智能引用代理(Smart ReferenceProxy) - 当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。

(9)复杂隐藏代理(Complexity HidingProxy) – 用来隐藏一个类的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理(Façade Proxy)，这不难理解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口。