代理模式可分为静态代理和动态代理,什么是代理模式以及代理模式怎么使用?
代理模式
1. 代理模式的定义
为其他对象提供一种代理以控制对这个对象的访问。也称为“委托模式”。根据字节码的创建时机又分为静态代理和动态代理。
如果根据字节码的创建时机来分类,可以分为静态代理和动态代理:
静态代理:在程序运行前就已经存在代理类的字节码文件,代理类和真实主题角色的关系在运行前就确定了。
动态代理:源码是在程序运行期间由JVM根据反射等机制动态的生成,所以在运行前并不存在代理类的字节码文件。
2. 静态代理
普通代理:上层模块必须知道代理类的存在。访问真实主题角色的时候,要通过代理,因此要在上层模块创建代理对象。代理对象关联真实角,第一种方式:创建代理对象时,传一个真实对象的引用;第二种方式:在代理类内部实现。如果采用第二种关联的方式,在代理类创建时,由代理类决定创建一个真实角色,上层模块也并不需要知道真实角色的具体类。
强制代理:真实角色必须通过代理才能访问,并且真实角色的代理的产生,由真实对象决定(与普通代理恰好相反)
2.1 普通代理
![image-20200725031319840](https://raw.githubusercontent.com/zicair/MyBlog/master/picbed/%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86%E6%A8%A1%E5%BC%8F/image-20200725031319840.png)
interface Subject {
void doSomething();
}
class RealSubject implements Subject{
public void doSomething() {
System.out.println("调用真实角色的方法");
}
}
class Proxy implements Subject{
private Subject realSubject;
//关联真实角色的第一种方式:外部传入
public Proxy(Suubject realSubject){
this.realSubject = realSubject;
}
//关联真实角色的第二种方式:由代理类决定
public Proxy(){
realSubject = new RealSubject();
}
public void doSomething() {
this.realSubject.doSomething();
}
}
public class Clinet {
public static void main(String[] args){
Subject proxy = new Proxy();
proxy.doSometing();
}
}
上层模块在创建代理时,并不用知道真实角色,但是要知道代理角色的”类”(通过new创建一个RealSubject对象,一定要知道类型)。简而言之,是将真实类对象传给代理类。
2.2 强制代理
对于普通代理来说,上层模块一定要知道代理的类型,但对于强制代理来说,强制代理的创建由真实角色决定,也就是说,通过真实角色找到代理,然后通过代理完成真实角色要完成的工作。
interface Subject {
void doSomething();
Subject getProxy();
}
class RealSubject implements Subject{
private Subject proxy;
private boolean hasProxy() {
return proxy != null;
}
public void doSomething() {
if(hasProxy())
System.out.println("调用真实角色的方法");
else {
System.err.println("请使用代理调用!!!!");
}
}
//代理的创建由真实角色决定
public Subject getProxy() {
if(!hasProxy())
this.proxy = new Proxy(this);
return this.proxy;
}
}
class Proxy implements Subject {
private Subject realSubject;
public Proxy(Subject realSubject) {
this.realSubject = realSubject;
}
public void doSomething() {
this.realSubject.doSomething();
}
public Subject getProxy() {
return this;
}
}
public class Client {
public static void main(String[] args) {
Subject realSubject = new RealSubject();
realSubject.doSomething();
realSubject.getProxy().doSomething();
}
}
强制代理就是必须通过真实角色获得代理,然后由代理去完成真实角色的工作。除了强制代理需为接口增加获取代理的方法外,与普通代理不同的是强制代理的生成需要在真实角色的内部new出来,并将真是角色的this(本身对象)传给new出来的代理。
2.3 静态代理的缺点
虽然静态代理实现简单,且不侵入原代码,但是,当场景稍微复杂一些的时候,静态代理的缺点也会暴露出来。
当需要代理多个类的时候,由于代理对象要实现与目标对象一致的接口,有两种方式:
只维护一个代理类,由这个代理类实现多个接口,但是这样就导致代理类过于庞大
新建多个代理类,每个目标对象对应一个代理类,但是这样会产生过多的代理类
当接口需要增加、删除、修改方法的时候,目标对象与代理类都要同时修改,不易维护。
3. 动态代理
![image-20200725014137191](https://raw.githubusercontent.com/zicair/picbed/master/img/%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86%E6%A8%A1%E5%BC%8F/image-20200725014137191.png)
3.1 实现原理
- 设计动态代理类(
DynamicProxy
)时,不需要显式实现与目标对象类(RealSubject
)相同的接口,而是将这种实现推迟到程序运行时由JVM
来实现
- 即:在使用时再创建动态代理类 & 实例
- 静态代理则是在代理类实现时就指定与目标对象类(
RealSubject
)相同的接口
- 通过
Java
反射机制的method.invoke()
,通过调用动态代理类对象方法,从而自动调用目标对象的方法
3.2 步骤详解
步骤1: 声明目标对象的抽象接口
Subject.java
public interface Subject {
// 定义目标对象的接口方法
// 代购物品
public void buybuybuy();
}
步骤2: 声明目标对象类
Buyer1.java
// 小成,真正的想买Mac的对象 = 目标对象 = 被代理的对象
// 实现抽象目标对象的接口
public class Buyer1 implements Subject {
public void buybuybuy() {
System.out.println("小成要买Mac");
}
}
Buyer2.java
// 小何,真正的想买iPhone的对象 = 目标对象 = 被代理的对象
// 实现抽象目标对象的接口
public class Buyer2 implements Subject {
public void buybuybuy() {
System.out.println("小何要买iPhone");
}
}
步骤3: 声明代理类
DynamicProxy.java
public class DynamicProxy implements InvocationHandler {
// 声明代理对象
// 作用:绑定关系,即关联到哪个接口(与具体的实现类绑定)的哪些方法将被调用时,执行invoke()
private Object ProxyObject;
public Object getProxyInstance(Object ProxyObject){
this.ProxyObject =ProxyObject;
return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
ProxyObject.getClass().getInterfaces(),this);
// 参数1:指定产生代理对象的类加载器,需要将其指定为和目标对象同一个类加载器
// 参数2:指定目标对象的实现接口
// 即要给目标对象提供一组什么接口。若提供了一组接口给它,那么该代理对象就默认实现了该接口,这样就能调用这组接口中的方法
// 参数3:指定InvocationHandler对象。即动态代理对象在调用方法时,会关联到哪个InvocationHandler对象
}
// 复写InvocationHandler接口的invoke()
// 动态代理对象调用目标对象的任何方法前,都会调用处理器类的invoke()
public Object invoke(Object proxy, Method method, Object[] args)
// 参数1:动态代理对象(即哪个动态代理对象调用了method()
// 参数2:目标对象被调用的方法
// 参数3:指定被调用方法的参数
System.out.println("代购出门了");
// 通过Java反射机制调用目标对象方法
Object result = method.invoke(ProxyObject, args);
return result;
}
}
步骤4: 通过动态代理对象,调用目标对象的方法
Main.java
public static void main(String args[]) {
DynamicProxy DynamicProxy = new DynamicProxy();
// 通过调用动态代理对象方法从而调用目标对象方法
// 实际上是调用了invoke(),再通过invoke()里的反射机制调用目标对象的方法
Buyer1 mBuyer1 = new Buyer1();
Subject Buyer1_DynamicProxy = (Subject)DynamicProxy.getProxyInstance(mBuyer1);
Buyer1_DynamicProxy.buybuybuy();
// 以下是代购为小何代购iPhone
Buyer2 mBuyer2 = new Buyer2();
Subject Buyer2_DynamicProxy = (Subject)DynamicProxy.getProxyInstance(mBuyer2);
Buyer2_DynamicProxy.buybuybuy();
}
// 输出:
// 代购出门了
// 小成要买Mac
// 代购出门了
// 小何要买iPhone
3.3 优点
- 只需要1个动态代理类就可以解决创建多个静态代理的问题,避免重复、多余代码
- 更强的灵活性
- 设计动态代理类(
DynamicProxy
)时,不需要显式实现与目标对象类(RealSubject
)相同的接口,而是将这种实现推迟到程序运行时由JVM
来实现- 在使用时(调用目标对象方法时)才会动态创建动态代理类 & 实例,不需要事先实例化
3.4 缺点
- 效率低
相比静态代理中 直接调用目标对象方法,动态代理则需要先通过Java
反射机制 从而 间接调用目标对象方法 - 应用场景局限
因为 Java 的单继承特性(每个代理类都继承了 Proxy 类),即只能针对接口 创建 代理类,不能针对类 创建代理类
即只能动态代理 实现了接口的类