1Modo proxy estático / dinámico
El mecanismo subyacente de AOP es el proxy dinámico.
Modo proxy:
1 proxy estático
2 proxy dinámico
1 proxy estático
Análisis de roles Rol
abstracto: Generalmente use interfaces o clases abstractas para lograr
Rol real: El rol que se está representando
Rol de actuación: Actuando para el rol real; Después de actuar para el rol real, generalmente realizará algunas operaciones subsidiarias.
Cliente: Use el rol de agente para realizar algunos
códigos de operación Implementar
1 interfaz Rent. java es un rol abstracto
package com.zs.demo1;
// 租房的接口
public interface Rent {
public void rent();
}
Host de 2 caracteres reales. Java
package com.zs.demo1;
// 房东
public class Host implements Rent {
@Override
public void rent() {
System.out.println("房东要出租房子");
}
}
3 Rol de proxy Proxy. Java
package com.zs.demo1;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
@NoArgsConstructor
@AllArgsConstructor
public class Proxy implements Rent{
private Host host;
@Override
public void rent() {
host.rent();
seeHouse();
fare();
}
// 看房
public void seeHouse() {
System.out.println("中介帮你看房");
}
// 收中介费
public void fare(){
System.out.println("收中介费");
}
}
4 Cliente Cliente. Java
package com.zs.demo1;
public class Client{
public static void main(String[] args) {
// 房东要出租房子
Host host = new Host();
// 代理，中介帮房东租房子 但是？ 代理操作会有一些附属操作！
Proxy proxy = new Proxy(host);
// 你不用面对房东，直接找中介租房即可！
proxy.rent();
}
}
La ventaja de la agencia estática:
puede hacer que nuestro rol real sea más puro. Ya no prestamos atención a algunas cosas públicas.
Los negocios públicos los hace la agencia. La división del trabajo se realiza.
Los negocios públicos se vuelven más centralizados y convenientes cuando se expanden.
Desventajas:
muchos tipos Ahora, con más clases de proxy, la carga de trabajo ha aumentado. Se reduce la eficiencia del desarrollo.
Queremos los beneficios del proxy estático, pero no queremos las deficiencias del proxy estático, por lo que tenemos un proxy dinámico
Proxy estático y luego entender
1 crear un rol abstracto
//抽象角色：增删改查业务
public interface UserService {
void add();
void delete();
void update();
void query();
}
2 Necesitamos un personaje real para completar estas adiciones, eliminaciones e inspecciones
//真实角色，完成增删改查操作的人
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("增加了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("更新了一个用户");
}
public void query() {
System.out.println("查询了一个用户");
}
}
3 La demanda está llegando. Ahora necesitamos agregar una función de registro. Cómo implementarla.
No cambie el código original. Introducimos una clase de proxy para operar. ¡
Configure una clase de proxy para procesar registros! Rol de agente
/代理角色，在这里面增加日志的实现
public class UserServiceProxy implements UserService {
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
public void add() {
log("add");
userService.add();
}
public void delete() {
log("delete");
userService.delete();
}
public void update() {
log("update");
userService.update();
}
public void query() {
log("query");
userService.query();
}
public void log(String msg){
System.out.println("执行了"+msg+"方法");
}
}
4 clase de acceso de prueba
public class Client {
public static void main(String[] args) {
//真实业务
UserServiceImpl userService = new UserServiceImpl();
//代理类
UserServiceProxy proxy = new UserServiceProxy();
//使用代理类实现日志功能！
proxy.setUserService(userService);
proxy.add();
}
}
2 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 es la clase de proxy que escribimos de antemano. El
proxy dinámico se divide en dos categorías: una se basa en el proxy dinámico de interfaz, y el otro se basa en la clase. Proxy
dinámico Proxy dinámico basado en la interfaz-JDK Proxy
dinámico Proxy dinámico basado en clases-cglib
ahora usa javasist para generar proxy dinámico.
Usamos el código nativo de JDK para lograr esta.
El proxy dinámico de JDK necesita comprender dos tipos de
núcleo: InvocationHandler (controlador de llamadas) y Proxy
1 Función abstracta Rent. Java
//抽象角色：租房
public interface Rent {
public void rent();
}
2 Host de carácter real. Java
//真实角色: 房东，房东要出租房子
public class Host implements Rent{
public void rent() {
System.out.println("房屋出租");
}
}
3 Rol de proxy ProxyInvocationHandler. Controlador de invocación de proxy de Java
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
// proxy : 代理类
// method : 代理类的调用处理程序的方法对象.
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 methodName){
System.out.println("执行了"+methodName+"方法");
}
}
4 prueba
public class Test {
public static void main(String[] args) {
//真实对象
UserServiceImpl userService = new UserServiceImpl();
//代理对象的调用处理程序
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setTarget(userService); //设置要代理的对象
UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
proxy.delete();
}
}
Beneficios del
proxy dinámico ¡Algunos proxy estáticos lo tienen, y el proxy estático no lo tiene!
Puede hacer que nuestro rol real sea más puro. Ya no prestar atención a algunas cosas públicas.
Los negocios públicos los hacen agentes. La división del trabajo se realiza y la
expansión de los negocios públicos se vuelve más centralizada y conveniente.
Un agente dinámico, agente general Para un cierto tipo de negocio,
un agente dinámico puede actuar para múltiples clases, ¡y el agente es una interfaz!