(8) Primavera de la entrada al modo de proxy del suelo

Modelo de agencia

El mecanismo subyacente de AOP es el proxy dinámico, por lo que primero debemos aprender el modo proxy.

• Modo de agencia:

• • Proxy estático
  • Proxy dinámico

Proxy estático

Análisis del rol del agente estático

• 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ás algunas operaciones subsidiarias.
• Cliente: utilice el rol de agente para realizar algunas operaciones

Código

Rent.java es el papel abstracto

//抽象角色
public interface Rent{
    public void rent();
}

Host.java es el verdadero papel

// 真实角色：房东、房东要出租的房子
public class Host implements Rent{
    public void rent(){
        System.out.println("房屋出租");
    }
}

Proxy.java es el rol de proxy

//代理角色：中介
public class Proxy implements Rent {
   private Host host;
   public Proxy() { }
   public Proxy(Host host) {
       this.host = host;
  }

   //租房
   public void rent(){
       seeHouse();
       host.rent();
       fare();
  }
   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }
}

Clinet.java es el cliente

//客户类，一般客户都会去找代理！
public class Client {
   public static void main(String[] args) {
       //房东要租房
       Host host = new Host();
       //中介帮助房东
       Proxy proxy = new Proxy(host);
       //你去找中介！
       proxy.rent();
  }
}

análisis

En todo el proceso, el cliente contacta directamente con el intermediario. Al igual que en la vida real, no es necesario contactar con el arrendador, y la casa del arrendador todavía se alquila a través de la agencia. Este es el modelo de agencia.

Beneficios del proxy estático

• Puede ser que nuestro rol real sea más puro, y ya no prestemos atención a algunas cosas públicas (es decir, el propietario solo necesita prestar atención a alquilar una casa, no a preocuparse por otras operaciones como inspecciones de casas)
• El negocio público lo completa el agente, que se da cuenta de la división del trabajo y reduce el acoplamiento
• Sea más centralizado y conveniente cuando las empresas públicas se expandan

Pero hay más clases y más clases de agentes, la carga de trabajo aumenta y la eficiencia del desarrollo se reduce

Re-comprensión de las clases estáticas

Clase abstracta

Adiciones, eliminaciones, revisiones

//抽象角色：增删改查业务
public interface UserService {
   void add();
   void delete();
   void update();
   void query();
}

Objeto real

Complete 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("查询了一个用户");
  }
}

demanda

Agregar un registro de estado

• Idea 1: agregue [engorroso] a la clase de implementación
• Idea 2: Utilice un agente para lograr esta función sin cambiar el negocio original.

Configurar un 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+"方法");
  }

}

Clase de acceso de prueba

public class Client {
   public static void main(String[] args) {
       //真实业务
       UserServiceImpl userServiceimpl = new UserServiceImpl();
       //代理类
       UserServiceProxy proxy = new UserServiceProxy();
       //使用代理类实现日志功能！
       proxy.setUserService(userServiceimpl);

       proxy.add();
  }
}

Sin cambiar el código original, la realización de la mejora del código original es la idea central en AOP.

Proxy dinámico

• El papel de los agentes dinámicos es el mismo que el de los agentes estáticos.

• La clase de proxy del proxy dinámico se genera dinámicamente, y nosotros escribimos de antemano la clase de proxy del proxy estático.

• Los agentes dinámicos se dividen en dos categorías:

• • Proxy dinámico basado en proxy dinámico interfaz-JDK
  • Proxy-cglib dinámico basado en clases

InvocationHandler: controlador de invocación

• • InvocationHandler es una interfaz implementada por el controlador de invocación de la instancia de proxy
  • Cada instancia de agente tiene un administrador de llamadas asociado. Cuando se llama al método en la instancia del proxy, la llamada al método se codificará y enviará al método de invocación de su controlador de llamadas

Invocación de objeto (proxy de objeto, método 方法, argumentos de objeto [])

• parámetro:

• • proxy: la instancia de proxy que llamó al método
  • método: el método corresponde a la instancia de llamar al método de interfaz en la instancia del proxy. La clase declarada del objeto de método será la interfaz declarada por el método, que puede ser la superinterfaz de la interfaz de proxy de la clase de proxy que hereda el método.
  • args: la matriz de objetos que contiene la llamada al método que pasa los valores de parámetro de la instancia de proxy, o nulo. Si el método de interfaz no tiene parámetros, los parámetros del tipo primitivo se incluyen en la instancia de la clase contenedora primitiva apropiada, por ejemplo: java.lang.Integer o java .lang.Boolean

Proxy: proxy

• • Proporciona métodos estáticos para crear instancias y clases de proxy dinámicos. También es la superclase de todos los proxies dinámicos creados por estos métodos.

// 生成代理类
public Object getProxy(){
    return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
}

Código

Papel abstracto de Rent.java

// 抽象角色 租房
public interface Rent{
    public void  rent();
}

Rol real de Host.java

// 真实角色：房东、房东要出租的房子
public class Host implements Rent{
    public void rent(){
        System.out.println("房屋出租");
    }
}

Rol de proxy ProxyInvacationHandler.java

//用于动态生成一个代理类
public class ProxyInvocationHandler implements InvocationHandler {
   private Rent rent;

   public void setRent(Rent rent) {
       this.rent = rent;
  }

   //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
   public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               rent.getClass().getInterfaces(),this);
  }

   // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
   // 处理代理实例上的方法调用并返回结果
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       seeHouse();
       //核心：本质利用反射实现！
       Object result = method.invoke(rent, args);
       fare();
       return result;
  }

   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }

}

Cliente Clinet.java

// 租客
public class Client {

   public static void main(String[] args) {
       //真实角色
       Host host = new Host();
       //代理实例的调用处理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       //通过调用程序处理角色来处理我们要调用的接口对象。
       pih.setRent(host); //将真实角色放置进去！
       Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
       proxy.rent();
  }

}

centro

Un agente dinámico, que generalmente actúa para un cierto tipo de negocio, un agente dinámico puede actuar para múltiples clases, ¡y el agente es una interfaz!

Profundizar la comprensión

¡Usemos un proxy dinámico para implementar el UserService que escribimos más tarde!

¡También podemos escribir una clase de implementación de proxy dinámico genérico! ¡Todos los objetos proxy se pueden configurar como Objeto!

Plantilla universal:

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);
  }

   // 处理代理实例 并返回结果
   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+"方法");
  }

}

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 agentes estáticos lo tienen y los agentes estáticos no lo tienen!

• Puede hacer que nuestro papel real sea más puro. Ya no prestamos atención a algunas cosas públicas.
• El negocio público lo completa el agente. La división del trabajo se realiza,
• Los servicios públicos se vuelven más centralizados y convenientes a medida que se expanden.
• Un agente dinámico, agente general para un determinado tipo de negocio.
• Un proxy dinámico puede proxy de varias clases, ¡y el proxy es una interfaz!

Por fin

• Si siente que ha sido recompensado después de leerlo, espero que me apruebe. Esta será la mayor motivación para actualizar. Gracias por su apoyo.
• Bienvenidos a todos para que presten atención a mi cuenta pública [Java Fox], enfocándome en los conocimientos básicos de Java y la computadora, prometo dejarles obtener algo después de leerlo, si no me creen, péguenme
• Si tiene diferentes opiniones o sugerencias después de leer, por favor comente y comparta con nosotros. Gracias por su apoyo y cariño.

Bienvenido a seguir la cuenta pública "Java Fox" para conocer las últimas noticias.