Beispielanalyse eines dynamischen Proxys und eines statischen Proxys in Java

0. Agentenmodus

Warum sollten wir den Agentenmodus lernen? Dies ist die untere Schicht von Springaop [Springaop und SpringMVC]. Objekte Die Erweiterung jeder Methode erfolgt manuell (der Code wird später demonstriert), was sehr unflexibel (z. B. müssen das Zielobjekt und das Proxy-Objekt geändert werden, sobald eine neue Methode zur Schnittstelle hinzugefügt wird) und mühsam (jeweils) ist Ziel muss geändert werden) Jede Klasse schreibt eine separate Proxy-Klasse

). Es gibt nur sehr wenige tatsächliche Anwendungsszenarien und es gibt fast keine Szenarien, in denen statische Proxys in der täglichen Entwicklung verwendet werden.

Rollenanalyse:

• Abstrakte Rolle: Im Allgemeinen werden Schnittstellen oder abstrakte Klassen verwendet, um das Problem zu lösen.

• Echte Rolle: Die Rolle, die vertreten wird.

Agentenrolle: Stellvertreter der tatsächlichen Rolle Stellvertretend für die eigentliche Rolle. Normalerweise führen wir einige Nebenvorgänge aus

Kunde: die Person, die auf das Proxy-Objekt zugreift!

Codeschritte:

• 1. Echte Rolle
rrree
• 3. Agentenrolle für den Clientzugriff

  public interface Rent {
      public void rent();
  }

Vorteile von das Agentenmodell:
• Kann die Bedienung echter Charaktere reiner machen! Es besteht keine Notwendigkeit, auf einige öffentliche Angelegenheiten zu achten

Öffentliche Angelegenheiten werden der Agentenrolle überlassen! Verwirklichen Sie die Arbeitsteilung in der Wirtschaft!

Wenn öffentliche Dienste expandieren, ist eine zentrale Verwaltung praktisch!

Nachteile:

Eine echte Rolle generiert aus JVM-Perspektive eine Proxy-Rolle. Statische Proxys verwandeln Schnittstellen, Implementierungsklassen und Proxy-Klassen während der Kompilierung in tatsächliche Klassendateien.

2. Vertiefen Sie Ihr Verständnis von

AOP, dem zugrunde liegenden Proxy-Modell

3. Die Rollen des dynamischen Proxys und des statischen Proxys sind die gleichen
Die Proxy-Klasse des dynamischen Proxys wird dynamisch generiert, nicht von uns direkt geschrieben!
Dynamische Proxys sind in zwei Kategorien unterteilt: schnittstellenbasierte dynamische Proxys, klassenbasierte dynamische Proxys

basierend auf Schnittstellen ––JDK-dynamische Proxys

basierend auf Klassen: cglib dynamische Proxys

Java-Bytecode-Implementierung: javasist

• Sie müssen zwei Klassen verstehen: Proxy: Proxy-Klasse, InvocationHandler: Aufrufhandler

Aus JVM-Perspektive generiert der dynamische Proxy zur Laufzeit dynamisch Klassenbytecode und lädt ihn in die JVM.

• //房东
  public class Host implements Rent {
      public void rent() {
          System.out.println("房东要租房子");
      }
  }

Vorteile des dynamischen Proxys:
kann die Bedienung echter Charaktere reiner machen! Es besteht keine Notwendigkeit, sich um öffentliche Angelegenheiten zu kümmern
Öffentliche Angelegenheiten werden der Agentenrolle überlassen! Implementierung

• 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("中介收费");
      }
  }

• 1.

  loader

: Klassenlader, der zum Laden von Proxy-Objekten verwendet wird.

2.

interfaces: Einige von der Proxy-Klasse implementierte Schnittstellen;

3.

h: Das Schnittstellenobjekt InvocationHandler wurde implementiert ;

Um einen dynamischen Proxy zu implementieren, müssen Sie auch InvocationHandler implementieren, um die Verarbeitungslogik anzupassen. Wenn unser dynamisches Proxy-Objekt eine Methode aufruft, wird der Aufruf dieser Methode an die Methode invoke der Klasse weitergeleitet, die die Schnittstelle InvocationHandler implementiert.

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        //代理，代理角色一般会有附属操作！
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

1.
• proxy: Dynamisch generierte Proxy-Klasse

2.
• Methode: Entspricht der vom Proxy-Klassenobjekt aufgerufenen Methode

3.

args: Parameter der aktuellen Methodenmethode

Dynamisch Proxy-Beispiele

1. Definieren Sie die Schnittstelle

//Proxy是生成动态代理类，提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。
//InvocationHandler-- invoke 调用处理程序并返回接口， 是由代理实例的调用处理程序实现的接口 。

loader :类加载器，用于加载代理对象。

2.interfaces : 被代理类实现的一些接口；

3.h : 实现了 InvocationHandler 接口的对象；

要实现动态代理的话，还必须需要实现InvocationHandler 来自定义处理逻辑。 当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
}

1.proxy :动态生成的代理类

2.method : 与代理类对象调用的方法相对应

3.args : 当前 method 方法的参数

动态代理的例子

1、定义接口

public interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

2、实现租房的接口

public interface Rent {
    public void rent();
}

3、定义一个JDK动态代理类

public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要租房");
    }
}

invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。

4、获取代理对象的工厂类

public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理类中的真实对象
     */
    private final Object target;
    public DebugInvocationHandler(Object target){
        this.target = target;
    }
    /**
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //调用方法前
        System.out.println("before method" + method.getName());
        Object res = method.invoke(target, args);
        //调用方法后
        System.out.println("after method" + method.getName());
        return res;
    }
}

getProxy() ：主要通过Proxy.newProxyInstance（）3. Definieren Sie eine dynamische JDK-Proxy-Klasse

public class JdkProxyFactory {
    public static Object getProxy(Object target){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new DebugInvocationHandler(target)
        );
    }
}

invoke() Methode: Wenn unsere dynamische Wenn das Proxy-Objekt die native Methode aufruft, wird tatsächlich die Methode invoke() aufgerufen, und dann ruft die Methode invoke() die native Methode des Proxy-Objekts auf in unserem Namen.

4. Rufen Sie die Factory-Klasse des Proxy-Objekts ab

public static void main(String[] args) {
        //Rent rent = new Host();
        //Rent rentProxy= (Rent) Proxy.newProxyInstance(rent.getClass().getClassLoader(), rent.getClass().getInterfaces(),new DebugInvocationHandler(rent));
        Rent rentProxy = (Rent)JdkProxyFactory.getProxy(new Host());
        rentProxy.rent();
    }

getProxy(): Rufen Sie das Proxy-Objekt einer bestimmten Klasse hauptsächlich über die Methode Proxy.newProxyInstance() ab

5. Ausgabe der tatsächlichen Ausführung des oben genannten Agenten mit

rrreee

🎜🎜vor methodrent🎜Der Vermieter möchte mieten🎜nach methodrent🎜🎜

Das obige ist der detaillierte Inhalt vonBeispielanalyse eines dynamischen Proxys und eines statischen Proxys in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!