Exemple d'analyse de proxy dynamique et de proxy statique en Java

0. Mode Agent

Pourquoi devrions-nous apprendre le mode Agent ? Il s'agit de la couche inférieure de SpringAOP [SpringAOP et SpringMVC]

Classification des modèles de proxy :

• Procuration statique

• Procuration dynamique

1. objets L'amélioration de chaque méthode se fait manuellement (le code sera démontré en détail plus tard), ce qui est très peu flexible (par exemple, une fois qu'une nouvelle méthode est ajoutée à l'interface, l'objet cible et l'objet proxy doivent être modifiés) et gênant (doit modifier chaque cible. Chaque classe écrit une classe proxy distincte

). Il existe très peu de scénarios d’application réels et il n’existe pratiquement aucun scénario dans lequel des proxys statiques sont utilisés dans le développement quotidien.

Analyse des rôles :

Rôle abstrait : généralement, des interfaces ou des classes abstraites sont utilisées pour résoudre le problème

• Rôle réel : le rôle proxy

• Rôle d'agent : proxy le rôle réel après. proxy le rôle réel, Nous effectuons généralement quelques opérations subsidiaires

• Client : la personne qui accède à l'objet proxy !
Étapes du code :

1. Interface

public interface Rent {
    public void rent();
}

2. Rôle réel

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

3. Rôle d'agent

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

4.

Peut rendre le fonctionnement de vrais personnages plus pur ! Il n'est pas nécessaire de prêter attention à certaines affaires publiques

Les affaires publiques seront laissées au rôle d'agent ! Réalisez la division du travail en entreprise !
Quand les services publics se développent, la gestion centralisée est pratique !
• Inconvénients :

Un rôle réel générera un rôle de proxy ; du point de vue de la JVM, les proxys statiques transforment les interfaces, les classes d'implémentation et les classes proxy en fichiers de classe réels lors de la compilation.

2. Approfondissez votre compréhension de AOP, le modèle de proxy sous-jacent

3. Proxy dynamique

Les rôles du proxy dynamique et du proxy statique sont les mêmes

La classe proxy du proxy dynamique est généré dynamiquement, pas par nous Écrit directement !
Les proxys dynamiques sont divisés en deux catégories : les proxys dynamiques basés sur les interfaces, les proxys dynamiques basés sur les classes
• basés sur les interfaces ——les proxys dynamiques JDK

basés sur les classes : les proxys dynamiques cglib
Implémentation du bytecode Java : javasist
• Vous devez comprendre deux classes : Proxy : classe proxy, InvocationHandler : gestionnaire d'appels

Du point de vue de la JVM, le proxy dynamique génère dynamiquement le bytecode de classe au moment de l'exécution et est chargé dans le JVM.

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

Avantages du proxy dynamique :

peut rendre le fonctionnement de vrais personnages plus pur ! Il n'est pas nécessaire de s'occuper de certaines affaires publiques

Les affaires publiques seront laissées au rôle d'agent ! Implémentation

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

• 1.

  loader

 : Class Loader, utilisé pour charger des objets proxy.

2.interfaces  : Certaines interfaces implémentées par la classe proxy 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.

h : Implémentation de l'objet d'interface InvocationHandler ; ;

Pour implémenter un proxy dynamique, vous devez également implémenter InvocationHandler pour personnaliser la logique de traitement. Lorsque notre objet proxy dynamique appelle une méthode, l'appel à cette méthode sera transmis à la méthode invoke de la classe qui implémente l'interface InvocationHandler.

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

1.

proxy : Classe proxy générée dynamiquement

2.

méthode : Correspondant à la méthode appelée par l'objet classe proxy🎜🎜🎜3.🎜args : Paramètres de la méthode actuelle method🎜

Dynamique Exemple de proxy

🎜1. Définir l'interface🎜

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

🎜2. Implémenter l'interface de location🎜rrreee🎜3 Définir une classe de proxy dynamique JDK🎜rrreee🎜invoke() : lorsque notre dynamique Lorsque l'objet proxy appelle la méthode native, ce qui est en réalité appelé est la méthode invoke(), puis la méthode invoke() appelle la méthode native de l'objet proxy sur notre nom. 🎜🎜4. Obtenez la classe d'usine de l'objet proxy🎜rrreee🎜getProxy() : obtenez principalement l'objet proxy d'une certaine classe via la méthode Proxy.newProxyInstance() 🎜🎜5. Résultat de l'exécution de l'agent ci-dessus en utilisant 🎜rrreee🎜🎜🎜🎜🎜🎜avant la méthode de location🎜Le propriétaire veut louer🎜après la méthode de location🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!