-
定义：为其他对象提供一种代理以控制这个对象的访问
-
术语：
- Subject：抽象主题类，声明真实主题与需要代理的方法
- RealSubject：被代理类（委托类），定义了代理所表示的真实对象，客户端通过代理类间接的调用委托类的方法。
- ProxySubject：代理类，持有对委托类的引用，在其所实现的接口方法中调用委托类中相应的被代理方法执行。
- Client：客户端类，调用代理的位置
1、静态代理
/**
* 定义一个抽象对象接口，抽象方法表示要代理做的事
*
* @author LTP 2021/11/9
*/
public interface Subject {
/**
* 外国友人找国人代购华为
*/
void buyHuaWei();
}
/**
* 真实对象类，委托类
*
* @author LTP 2021/11/9
*/
public class RealSubject implements Subject {
@Override
public void buyHuaWei() {
System.out.println("我是美国佬，我要买华为");
}
}
- 创建静态代理类，构造器中传入具体的实现了委托接口的委托对象
/**
* 代理类
*
* @author LTP 2021/11/9
*/
public class Proxy implements Subject {
private final Subject subject;
/**
* 构造器传入代理对象
*
* @param subject 实现代理方法的代理对象
*/
public Proxy(Subject subject) {
this.subject = subject;
}
@Override
public void buyHuaWei() {
// 收取代购费用
System.out.println("收取代购费用");
subject.buyHuaWei();
// 一些其他的操作
System.out.println("快递代理货物");
}
}
/**
* 实际调用静态代理的位置
* 1个静态代理 只服务1种类型的目标对象(实现了同一种委托接口)，
* 若要服务多类型的目标对象，则需要为每种目标对象都实现一个静态代理对象
*
* @author LTP 2021/11/9
*/
public class Client {
public static void main(String[] args) {
Subject subject = new RealSubject();
// 创建代理类，并将委托类传入构造
Proxy proxy = new Proxy(subject);
proxy.buyHuaWei();
}
}
2、动态代理
- 创建一个委托类需要委托的抽象方法Subject（具体跟静态代理中相同）
- 创建委托类实现Subject（具体跟静态代理中相同）
- 创建动态代理类实现InvocationHandler并重写invoke方法，构造器中传入Object(任意委托类型)，即代理类与具体委托类的关系并未确定
/**
* 代理类
*
* @author LTP 2021/11/9
*/
public class DynamicProxy implements InvocationHandler {
// 申明被代理的对象,此时并不知道委托类的类型（Object）
private final Object proxyObject;
public DynamicProxy(Object proxyObject) {
this.proxyObject = proxyObject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 收取代购费用
System.out.println("收取代购费用");
// 利用反射调用被代理对象的方法
Object result = method.invoke(proxyObject, args);
// 一些其他的操作
System.out.println("快递代理货物");
return result;
}
}
/**
* 实际调用动态代理的位置
* 动态代理中，代理类与委托类的关系是运行时才确定的，
* 代理对象可同时代理多个任务而不需要修改代理类的源码，只需要添加新的委托类以及委托方法即可，可同时代理多个类型的目标对象
*
* @author LTP 2021/11/9
*/
public class Client {
public static void main(String[] args) {
// 创建委托类
RealSubject realSubject = new RealSubject();
// 创建代理类，并将委托类传入构造
DynamicProxy dynamicProxy = new DynamicProxy(realSubject);
ClassLoader classLoader = realSubject.getClass().getClassLoader();
Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new Class[]{Subject.class}, dynamicProxy);
subject.buyHuaWei();
}
}
/**
* 定义一个抽象对象接口，抽象方法表示要代理做的事
*
* @author LTP 2021/11/9
*/
public interface Subject2 {
/**
* 外国友人找国人代购小米
*/
void buyXiaomi();
}
/**
* 真实对象类，委托类
*
* @author LTP 2021/11/9
*/
public class RealSubject2 implements Subject2 {
@Override
public void buyXiaomi() {
System.out.println("我是美国佬，我要买小米");
}
}
- 在静态代理中，新增一个委托需要更改代理类的源代码，新增实现Subject2，并新增绑定委托类RealSubject2的构造，重写Subject2中需要委托的方法，破坏了开放封闭原则
/**
* 代理类
*
* @author LTP 2021/11/9
*/
public class Proxy implements Subject, Subject2 {
private Subject subject;
private Subject2 subject2;
/**
* 构造器传入代理对象
*
* @param subject 实现代理方法的代理对象
*/
public Proxy(Subject subject) {
this.subject = subject;
}
/**
* 构造器传入代理对象
*
* @param subject 实现代理方法的代理对象
*/
public Proxy(Subject2 subject) {
this.subject2 = subject;
}
@Override
public void buyHuaWei() {
// 收取代购费用
System.out.println("收取代购费用");
subject.buyHuaWei();
// 一些其他的操作
System.out.println("快递代理货物");
}
@Override
public void buyXiaomi() {
// 收取代购费用
System.out.println("收取代购费用");
subject2.buyXiaomi();
// 一些其他的操作
System.out.println("快递代理货物");
}
}
- 在动态代理中，无需修改代理类的源码，直接在调用处添加新的代理即可
/**
* 实际调用动态代理的位置
* 动态代理中，代理类与委托类的关系是运行时才确定的，
* 代理对象可同时代理多个任务而不需要修改代理类的源码，只需要添加新的委托类以及委托方法即可，可同时代理多个类型的目标对象
*
* @author LTP 2021/11/9
*/
public class Client {
public static void main(String[] args) {
// 创建委托类1
RealSubject realSubject = new RealSubject();
// 创建代理类，并将委托类1传入构造
DynamicProxy dynamicProxy = new DynamicProxy(realSubject);
ClassLoader classLoader = realSubject.getClass().getClassLoader();
Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new Class[]{Subject.class}, dynamicProxy);
subject.buyHuaWei();
// 创建委托类2
RealSubject2 realSubject2 = new RealSubject2();
// 创建代理类，并将委托类2传入构造
DynamicProxy dynamicProxy2 = new DynamicProxy(realSubject2);
ClassLoader classLoader2 = realSubject2.getClass().getClassLoader();
Subject2 subject2 = (Subject2) Proxy.newProxyInstance(classLoader2, new Class[]{Subject2.class}, dynamicProxy2);
subject2.buyXiaomi();
}
}
3、静态代理与动态代理的区别
- 静态代理中，代理类和委托类的关系是编码时运行前就确定了；而动态代理中，代理类与委托类的关系是在运行时通过反射才确定的
- 静态代理一般只代理一种目标委托对象，而动态代理可同时代理多个委托对象
4、Android中的使用场景
-
Retrofit
- retrofit.create(ApiService.class)中使用
public <T> T create(final Class<T> service) {
validateServiceInterface(service);
return (T)
Proxy.newProxyInstance(
service.getClassLoader(),
new Class<?>[] {service},
new InvocationHandler() {
private final Platform platform = Platform.get();
private final Object[] emptyArgs = new Object[0];
@Override
public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
// If the method is a method from Object then defer to normal invocation.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
args = args != null ? args : emptyArgs;
return platform.isDefaultMethod(method)
? platform.invokeDefaultMethod(method, service, proxy, args)
: loadServiceMethod(method).invoke(args);
}
});
}
网友评论