1.1 Proxy dynamique
- Le rôle du proxy dynamique est le même que celui du proxy statique. La classe proxy du proxy dynamique est générée dynamiquement. La classe proxy du proxy statique est écrite à l'avance.
- Les agents dynamiques sont divisés en deux catégories: l'une est constituée d'agents dynamiques basés sur des interfaces et l'autre est des agents dynamiques basés sur des classes.
- Proxy dynamique basé sur l'interface ---- Proxy dynamique JDK.
- Proxy-cglib dynamique basé sur les classes.
- De nos jours, javasist est plus fréquemment utilisé pour générer des agents dynamiques.
Le proxy dynamique de JDK doit comprendre deux classes: InvocationHandler et Proxy
InvocationHandler 【Gestionnaire d'invocation】
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 Exemple de code
Interface de location (rôle abstrait)
package cn.guardwhy.domain;
// 抽象角色：租房
public interface Rent {
public void rent();
}
Propriétaire
package cn.guardwhy.domain;
// 真实角色: 房东，要出租房子
public class Landlord implements Rent {
@Override
public void rent() {
System.out.println("房屋出租!!!");
}
}
ProxyInvocationHandler est le rôle 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("收中介费");
}
}
Client (locataire)
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();
}
}
Les résultats
Pour résumer
Un agent dynamique agit généralement pour un certain type d'entreprise, et un agent dynamique peut agir pour plusieurs classes, et l'agent est une interface。
1.3 Approfondir l'agence dynamique
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("查询一个用户");
}
}
Écrivez une classe d'implémentation de proxy dynamique générique! Tous les objets proxy sont définis sur Object.
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 + "方法" );
}
}
Client (locataire)
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();
}
}
Les résultats
1.4 Avantages du proxy dynamique
Certains agents statiques l'ont, et les agents statiques ne l'ont pas!
- Peut rendre notre vrai rôle plus pur. Ne plus prêter attention à certaines choses publiques.
- Les affaires publiques sont accomplies par l'agent. La division du travail est réalisée,
- Lorsque les affaires publiques se développent, elles deviennent plus centralisées et plus pratiques.
- Agent dynamique, généralement agent d'un certain type d'entreprise, un agent dynamique peut agent de plusieurs types, l'agent est une interface.