1.1 Proxy dinámico
- La función del proxy dinámico es la misma que la del proxy estático. La clase de proxy de proxy dinámico se genera dinámicamente. La clase de proxy de proxy estático se escribe de antemano.
- Los agentes dinámicos se dividen en dos categorías: uno son agentes dinámicos basados en interfaces y el otro son agentes dinámicos basados en clases.
- Proxy dinámico basado en interfaz ---- Proxy dinámico JDK.
- Proxy-cglib dinámico basado en clases.
- Hoy en día, javasist se utiliza con más frecuencia para generar agentes dinámicos Baidu sobre javasist.
El proxy dinámico de JDK debe comprender dos clases: InvocationHandler y Proxy
Manejador de invocación 【Manejador de invocación】
Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。 方法对象的声明类将是该方法声明的接
口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。 原始
类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean
。
Pxoxy 【Proxy】
//生成代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(),this);
}
1.2 Ejemplo de código
Interfaz de alquiler (función abstracta)
package cn.guardwhy.domain;
// 抽象角色：租房
public interface Rent {
public void rent();
}
Propietario
package cn.guardwhy.domain;
// 真实角色: 房东，要出租房子
public class Landlord implements Rent {
@Override
public void rent() {
System.out.println("房屋出租!!!");
}
}
ProxyInvocationHandler es el rol de proxy
package cn.guardwhy.proxy;
import cn.guardwhy.domain.Rent;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 该类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
// 1.被代理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
// 2.生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(), this);
}
// 3.处理代理实例，并且返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHouse();
// 动态代理的本质。就是使用反射机制实现
Object result = method.invoke(rent, args);
fare();
return result;
}
// 4.方法
public void seeHouse(){
System.out.println("带房客看房...");
}
// 收中介费
public void fare(){
System.out.println("收中介费");
}
}
Cliente (inquilino)
package cn.guardwhy.client;
import cn.guardwhy.domain.Landlord;
import cn.guardwhy.domain.Rent;
import cn.guardwhy.proxy.ProxyInvocationHandler;
public class Client {
public static void main(String[] args) {
// 1.真实角色
Landlord landlord = new Landlord();
// 2.代理角色
ProxyInvocationHandler pith = new ProxyInvocationHandler();
// 3.通过调用程序处理角色来处理要调用的接口对象
pith.setRent(landlord);
Rent proxy = (Rent) pith.getProxy();
// 4.调用接口
proxy.rent();
}
}
Los resultados
para resumir
Un agente dinámico generalmente actúa para un cierto tipo de negocio, y un agente dinámico puede actuar para múltiples clases, y el agente es una interfaz.。
1.3 Profundizar la agencia dinámica
UserService
package cn.guardwhy.domain;
// 抽象角色,增删改查业务
public interface UserService {
void add();
void delete();
void update();
void query();
}
UserServiceImpl
package cn.guardwhy.domain;
// 真实对象,完成增删改查的操作
public class UserServiceImpl implements UserService {
@Override
public void add() {
System.out.println("增加了一个用户");
}
@Override
public void delete() {
System.out.println("删除了一个用户");
}
@Override
public void update() {
System.out.println("更新了一个用户");
}
@Override
public void query() {
System.out.println("查询一个用户");
}
}
¡Escriba una clase de implementación de proxy dinámico genérico! Todos los objetos de proxy se establecen en Objeto.
package cn.guardwhy.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyInvocationHandler2 implements InvocationHandler {
// 1.被代理的接口
private Object target;
// 2.set注入
public void setTarget(Object target) {
this.target = target;
}
// 3.生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
// 4.处理代理实例,并且返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 调用方法
log(method.getName());
Object result = method.invoke(target, args);
return result;
}
// 定义日志方法
public void log(String msg){
System.out.println("执行了" + msg + "方法" );
}
}
Cliente (inquilino)
package cn.guardwhy.client;
import cn.guardwhy.domain.UserService;
import cn.guardwhy.domain.UserServiceImpl;
import cn.guardwhy.proxy.ProxyInvocationHandler2;
public class Client2 {
public static void main(String[] args) {
//1.真实角色
UserServiceImpl userService = new UserServiceImpl();
//2.代理对象的调用处理程序
ProxyInvocationHandler2 pith = new ProxyInvocationHandler2();
//3.设置要代理的对象
pith.setTarget(userService);
// 动态生成代理类
UserService proxy = (UserService) pith.getProxy();
//4.调用方法
proxy.add();
}
}
Los resultados
1.4 Beneficios del proxy dinámico
¡Algunos agentes estáticos lo tienen y los agentes estáticos no lo tienen!
- Puede hacer que nuestro rol real sea más puro. Ya no prestemos atención a algunas cosas públicas.
- El negocio público lo completa el agente. La división del trabajo se realiza,
- Cuando el negocio público se expande, se vuelve más centralizado y conveniente.
- Agente dinámico, generalmente agente de un cierto tipo de negocio, un agente dinámico puede representar varios tipos, el agente es una interfaz.