代理设计就是为其他对象提供一种代理以控制对这个对象的访问
使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原
始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原
始对象上
应用场景:
-
安全代理:屏蔽对真实角色的直接访问。
-
远程代理:通过代理类处理远程方法调用(RMI)
-
延迟加载:先加载轻量级的代理对象,真正需要再加载真实对象
比如你要开发一个大文档查看软件,大文档中有大的图片,有可能一个图片有100MB,在打开文件时,不可能将所有的图片都显示出来,这样就可以使用代理模式,当需要查看图片时,用proxy来进行大图片的打开
静态代理
package JavaFour;
/**
* @ClassName : StaticProxyTest //类名
* @Description : 静态代理测试 //描述
* @Author : Gao //作者
* @Date: 2022/3/19 19:04
*/
interface ClothFactory {
public void produceCloth();
}
//被代理类
class NikeClothFactory implements ClothFactory {
@Override
public void produceCloth() {
System.out.println("Nike正在生产");
}
}
//代理类
class ProxyClothFactory implements ClothFactory {
private ClothFactory clothFactory;
public ProxyClothFactory(ClothFactory clothFactory) {
this.clothFactory = clothFactory;
}
@Override
public void produceCloth() {
System.out.println("代理类进行预处理————————————————————————————");
clothFactory.produceCloth();
System.out.println("代理类进行后续处理————————————————————————————");
}
}
public class StaticProxyTest {
public static void main(String[] args) {
ProxyClothFactory proxyClothFactory = new ProxyClothFactory(new NikeClothFactory());
proxyClothFactory.produceCloth();
}
}
静态代理,特征是代理类和目标对象的类都是在编译期间确定下来,不利于程序的扩展。同时,每一个代理类只能为一个接口服务,这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。故需要动态代理
动态代理是指客户通过代理类来调用其它对象的方法,并且是在程序运行时根据需要动态创建目标类的代理对象。
动态代理相比于静态代理的优点:
抽象角色中(接口)声明的所有方法都被转移到调用处理器一个集中的方法中处理,这样,我们可以更加灵活和统一的处理众多的方法
Java动态代理相关API:
- Proxy :专门完成代理的操作类,是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 直接创建一个动态代理对象:
- 参数1:获取类加载器。
- 参数2:获取被代理类实现的所有接口。
- 参数3:得InvocationHandler接 口的实现类实例
实现InvocationHandler的类必须实现方法public Object invoke(Object theProxy, Method method, Object[] params)
- theProxy:代理对象
- method:要调用的方法
- params:方法调用时所需要的参数
package JavaFour;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @ClassName : ProxyTest //类名
* @Description : 动态代理的测试 //描述
* @Author : Gao //作者
* @Date: 2022/3/19 19:55
*/
//接口
interface Human {
public void getBelief();
public void getEat();
}
//被代理类
class SuperMan implements Human {
@Override
public void getBelief() {
System.out.println("I believe I can fly!");
}
@Override
public void getEat() {
System.out.println("超人爱吃饭");
}
}
//动态代理的工厂
class ProxyFactory {
public static Object getProxy(Object obj) {//obj即是被代理对象
//创建实现InvocationHandler的接口的类
MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
//将被被代理类传入,用于方法调用时指定调用被代理类的方法
myInvocationHandler.setObj(obj);
//用于创建代理对象
//参数分别是:类加载器、获取被代理类实现的接口、实现InvocationHandler的接口的类(该类主要实现方法invoke())
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), myInvocationHandler);
}
}
class MyInvocationHandler implements InvocationHandler {
private Object obj;//为被代理对象
public void setObj(Object obj) {
this.obj = obj;
}
//当我们通过代理类的对象,调用方法a时,就会自动的调用如下的方法:invoke()
//将被代理类要执行的方法a的功能就声明在invoke()中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//method:即为代理类对象调用的方法,此方法也就作为了被代理类对象要调用的方法
//obj:被代理类的对象
Object invoke = method.invoke(obj, args);
return invoke;
}
}
public class ProxyTest {
public static void main(String[] args) {
//创建被代理对象
SuperMan superMan = new SuperMan();
//获取代理类并把被代理类传入
Human proxy = (Human) ProxyFactory.getProxy(superMan);
//代理类调用的方法实际上调用被代理的方法
proxy.getBelief();
proxy.getEat();
// NikeClothFactory nikeClothFactory = new NikeClothFactory();
// ClothFactory proxy1 = (ClothFactory) ProxyFactory.getProxy(nikeClothFactory);
// proxy1.produceCloth();
}
}