Java设计模式之代理模式原理及实现代码分享

2023-09-21 04:07:06 146

简介

Java编程的目标是实现现实不能完成的，优化现实能够完成的，是一种虚拟技术。生活中的方方面面都可以虚拟到代码中。代理模式所讲的就是现实生活中的这么一个概念：中介。

代理模式的定义：给某一个对象提供一个代理，并由代理对象控制对原对象的引用。

代理模式包含如下角色：

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

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

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

实现动态代理的关键技术是反射。

静态代理

代理模式有几种，虚拟代理，计数代理，远程代理，动态代理。主要分为两类，静态代理和动态代理。静态代理比较简单，是由程序员编写的代理类，并在程序运行前就编译好的，而不是由程序动态产生代理类，这就是所谓的静态。

考虑这样的场景，管理员在网站上执行操作，在生成操作结果的同时需要记录操作日志，这是很常见的。此时就可以使用代理模式，代理模式可以通过聚合和继承两种方式实现：

/**方式一：聚合式静态代理
*@authorGoser(mailto:goskalrie@163.com)
*@Since2016年9月7日
*/
//1.抽象主题接口
publicinterfaceManager{
voiddoSomething();
}
//2.真实主题类
publicclassAdminimplementsManager{
publicvoiddoSomething(){
System.out.println("Admindosomething.");
}
}
//3.以聚合方式实现的代理主题
publicclassAdminPolyimplementsManager{
privateAdminadmin;

publicAdminPoly(Adminadmin){
super();
this.admin=admin;
}

publicvoiddoSomething(){
System.out.println("Log:admin操作开始");
admin.doSomething();
System.out.println("Log:admin操作结束");
}
}
//4.测试代码
Adminadmin=newAdmin();
Managerm=newAdminPoly(admin);
m.doSomething();
//方式二：继承式静态代理
//与上面的方式仅代理类和测试代码不同
//1.代理类
publicclassAdminProxyextendsAdmin{
@Override
publicvoiddoSomething(){
System.out.println("Log:admin操作开始");
super.doSomething();
System.out.println("Log:admin操作开始");
}
}
//2.测试代码
AdminProxyproxy=newAdminProxy();
proxy.doSomething();

聚合实现方式中代理类聚合了被代理类，且代理类及被代理类都实现了同一个接口，可实现灵活多变。继承式的实现方式则不够灵活。

比如，在管理员操作的同时需要进行权限的处理，操作内容的日志记录，操作后数据的变化三个功能。三个功能的排列组合有6种，也就是说使用继承要编写6个继承了Admin的代理类，而使用聚合，仅需要针对权限的处理、日志记录和数据变化三个功能编写代理类，在业务逻辑中根据具体需求改变代码顺序即可。

动态代理

一般来说，对代理模式而言，一个主题类与一个代理类一一对应，这也是静态代理模式的特点。

但是，也存在这样的情况，有n各主题类，但是代理类中的“前处理、后处理”都是一样的，仅调用主题不同。也就是说，多个主题类对应一个代理类，共享“前处理，后处理”功能，动态调用所需主题，大大减小了程序规模，这就是动态代理模式的特点。

JDK动态代理

实现

//1.抽象主题
publicinterfaceMoveable{
voidmove()throwsException;
}
//2.真实主题
publicclassCarimplementsMoveable{
publicvoidmove()throwsException{
Thread.sleep(newRandom().nextInt(1000));
System.out.println("汽车行驶中…");
}
}
//3.事务处理器
publicclassTimeHandlerimplementsInvocationHandler{
privateObjecttarget;
publicTimeHandler(Objecttarget){
super();
this.target=target;
}
/**
*参数：
*proxy被代理的对象
*method被代理对象的方法
*args方法的参数
*返回：
*Object方法返回值
*/
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
throwsThrowable{
longstartTime=System.currentTimeMillis();
System.out.println("汽车开始行驶…");
method.invoke(target,args);
longstopTime=System.currentTimeMillis();
System.out.println("汽车结束行驶…汽车行驶时间："+(stopTime-startTime)+"毫秒！");
returnnull;
}
}
//测试类
publicclassTest{
publicstaticvoidmain(String[]args)throwsException{
Carcar=newCar();
InvocationHandlerh=newTimeHandler(car);
Classcls=car.getClass();
/**
*loader类加载器
*interfaces实现接口
*hInvocationHandler
*/
Moveablem=(Moveable)Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),h);
m.move();
}
}

代码讲解：

在测试代码中，Proxy.newProxyInstance()方法需要3个参数：类加载器（要进行代理的类）、被代理类实现的接口，事务处理器。所以先实例化Car，实例化InvocationHandler的子类TimeHandler，将各参数传入Proxy的静态方法newProxyInstance()即可获得Car的代理类，前面的静态代理，代理类是我们编写好的，而动态代理则不需要我们去编写代理类，是在程序中动态生成的。

JDK动态代理步骤

1.创建一个实现InvocationHandler接口的类，它必须实现invoke()方法

2.创建被代理的类及接口

3.调用Proxy的静态方法，创建一个代理类

4.通过代理调用方法

而为什么要进行如此操作，可以从Proxy和InvocationHandler的源码中找打答案。对源码不感兴趣的可以将下面的源码部分小节略过。

JDK动态代理原理与源码

newProxyInstance()方法的源码：

publicstaticObjectnewProxyInstance(ClassLoaderloader,
Class[]interfaces,
InvocationHandlerh)
throwsIllegalArgumentException{
if(h==null){
thrownewNullPointerException();
}
finalClass[]intfs=interfaces.clone();
finalSecurityManagersm=System.getSecurityManager();
if(sm!=null){
checkProxyAccess(Reflection.getCallerClass(),loader,intfs);
}
/*查找或生成指定的代理类*/
Classcl=getProxyClass0(loader,intfs);
/*用指定的调用处理程序调用它的构造函数.*/
try{
//获得类的构造函数
finalConstructorcons=cl.getConstructor(constructorParams);
finalInvocationHandlerih=h;
if(sm!=null&&ProxyAccessHelper.needsNewInstanceCheck(cl)){
//当需要代理的类实现了一个非public的接口时，因为这样的接口需要特殊的权限，因此调用doPrivilege（native修饰的方法）创建代理实例。
returnAccessController.doPrivileged(newPrivilegedAction

Java设计模式之代理模式原理及实现代码分享

热门推荐

随机推荐