Compréhension approfondie du proxy dynamique Java

Proxy dynamique de JAVA
Mode agent
Le mode proxy est un modèle de conception Java couramment utilisé. Sa caractéristique est que la classe proxy et la classe délégué ont la même interface. et filtrer le message de la classe déléguée, transmettre le message à la classe déléguée et traiter le message par la suite, etc. Il existe généralement une association entre une classe proxy et une classe déléguée. Un objet d'une classe proxy est associé à un objet d'une classe déléguée. L'objet de la classe proxy lui-même n'implémente pas réellement le service, mais en appelant les méthodes appropriées. de l’objet de la classe déléguée. Fournir des services spécifiques.
Selon la période de création de l'agent, les classes d'agents peuvent être divisées en deux types.
Proxy statique : Créé par des programmeurs ou généré automatiquement par des outils spécifiques, puis compilé. Avant l'exécution du programme, le fichier .class de la classe proxy existe déjà.
Proxy dynamique : créé dynamiquement à l'aide du mécanisme de réflexion lorsque le programme est en cours d'exécution.

Premier coup d'œil au proxy statique :

1 Count.java

package net.battier.dao;  
  
/** 
 * 定义一个账户接口 
 *  
 * @author Administrator 
 *  
 */  
public interface Count {  
    // 查看账户方法  
    public void queryCount();  
  
    // 修改账户方法  
    public void updateCount();  
  
}

2.

3. TestCount.java

package net.battier.dao.impl;  
  
import net.battier.dao.Count;  
  
/** 
 * 委托类(包含业务逻辑) 
 *  
 * @author Administrator 
 *  
 */  
public class CountImpl implements Count {  
  
    @Override  
    public void queryCount() {  
        System.out.println("查看账户方法...");  
  
    }  
  
    @Override  
    public void updateCount() {  
        System.out.println("修改账户方法...");  
  
    }  
  
}  
  
、CountProxy.java  
package net.battier.dao.impl;  
  
import net.battier.dao.Count;  
  
/** 
 * 这是一个代理类（增强CountImpl实现类） 
 *  
 * @author Administrator 
 *  
 */  
public class CountProxy implements Count {  
    private CountImpl countImpl;  
  
    /** 
     * 覆盖默认构造器 
     *  
     * @param countImpl 
     */  
    public CountProxy(CountImpl countImpl) {  
        this.countImpl = countImpl;  
    }  
  
    @Override  
    public void queryCount() {  
        System.out.println("事务处理之前");  
        // 调用委托类的方法;  
        countImpl.queryCount();  
        System.out.println("事务处理之后");  
    }  
  
    @Override  
    public void updateCount() {  
        System.out.println("事务处理之前");  
        // 调用委托类的方法;  
        countImpl.updateCount();  
        System.out.println("事务处理之后");  
  
    }  
  
}

En observant le code, vous pouvez constater que chaque classe proxy ne peut servir qu'une seule interface, de cette façon, trop de proxys seront inévitablement générés lors du développement du programme, et tous les proxys À l'exception des différentes méthodes appelées, les autres opérations sont les mêmes, le code doit donc être répété à ce moment-là. La meilleure façon de résoudre ce problème est d'utiliser une classe proxy pour compléter toutes les fonctions proxy. Dans ce cas, un proxy dynamique doit être utilisé pour le compléter.

package net.battier.test;  
  
import net.battier.dao.impl.CountImpl;  
import net.battier.dao.impl.CountProxy;  
  
/** 
 *测试Count类 
 *  
 * @author Administrator 
 *  
 */  
public class TestCount {  
    public static void main(String[] args) {  
        CountImpl countImpl = new CountImpl();  
        CountProxy countProxy = new CountProxy(countImpl);  
        countProxy.updateCount();  
        countProxy.queryCount();  
  
    }  
}

Regardons le proxy dynamique :

Le proxy dynamique JDK contient une classe et une interface :
Interface InvocationHandler :

Description du paramètre :

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

Proxy d'objet : fait référence à l'objet proxy.

Method method : la méthode à appeler
Object[] args : les paramètres requis lors de l'appel de la méthode

Vous pouvez imaginer la sous-classe de l'interface InvocationHandler comme la classe d'opération finale d'un proxy, remplaçant ProxySubject .

Classe Proxy :

La classe Proxy est une classe spécialisée dans les opérations de proxy. Les classes d'implémentation peuvent être générées dynamiquement pour une ou plusieurs interfaces via cette classe. Cette classe fournit les méthodes de fonctionnement suivantes :

public static Object newProxyInstance (ClassLoader loader, Class[] interfaces,
InvocationHandler h)
 🎜>ClassInvocationHandler h : récupère la sous-classe instance de l'interface InvocationHandler

Ps : chargeur de classe
Une classe ClassLoader est requise dans la méthode newProxyInstance() de la classe Proxy. Les instances de ClassLoader correspondent en fait aux chargeurs de classe. Il existe trois chargeurs de classes principaux en Java. ;
Booststrap ClassLoader : Ce chargeur est écrit en C et n'est pas visible en développement général
Extendsion ClassLoader : utilisé pour charger des classes étendues, correspondant généralement aux classes du répertoire jrelibext ; ) charge la classe spécifiée par le chemin de classe, qui est le chargeur le plus couramment utilisé.

Proxy dynamique
Le contraste avec la classe proxy statique est la classe proxy dynamique. Le bytecode de la classe proxy dynamique est généré dynamiquement par le mécanisme de réflexion Java lorsque le programme est en cours d'exécution, sans que les programmeurs aient besoin de le faire. écrire manuellement son code source. Les classes proxy dynamiques simplifient non seulement le travail de programmation, mais améliorent également l'évolutivité des systèmes logiciels, car le mécanisme de réflexion Java peut générer tout type de classe proxy dynamique. La classe Proxy et l'interface InvocationHandler du package java.lang.reflect offrent la possibilité de générer des classes proxy dynamiques.

Exemple de proxy dynamique :

1. BookFacade.java

2. BookFacadeImpl.java

3. 🎜>

package net.battier.dao;  
  
public interface BookFacade {  
    public void addBook();  
}

Cependant, le proxy dynamique du JDK repose sur l'implémentation de l'interface. Si certaines classes n'implémentent pas l'interface, le proxy JDK ne peut pas être utilisé, le proxy dynamique cglib doit donc être utilisé.

Proxy dynamique Cglib

package net.battier.dao.impl;  
  
import net.battier.dao.BookFacade;  
  
public class BookFacadeImpl implements BookFacade {  
  
    @Override  
    public void addBook() {  
        System.out.println("增加图书方法。。。");  
    }  
  
}  
  
、BookFacadeProxy.java  
  
package net.battier.proxy;  
  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
  
/** 
 * JDK动态代理代理类 
 *  
 * @author student 
 *  
 */  
public class BookFacadeProxy implements InvocationHandler {  
    private Object target;  
    /** 
     * 绑定委托对象并返回一个代理类 
     * @param target 
     * @return 
     */  
    public Object bind(Object target) {  
        this.target = target;  
        //取得代理对象  
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
                target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)  
    }  
  
    @Override  
    /** 
     * 调用方法 
     */  
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable {  
        Object result=null;  
        System.out.println("事物开始");  
        //执行方法  
        result=method.invoke(target, args);  
        System.out.println("事物结束");  
        return result;  
    }  
  
}

Le mécanisme de proxy dynamique du JDK ne peut proxy que les classes qui implémentent des interfaces, et les classes qui ne peuvent pas implémenter d'interfaces ne peuvent pas implémenter le proxy dynamique de JDK pour les classes. la classe cible spécifiée et écraser les méthodes pour obtenir une amélioration. Cependant, comme l'héritage est utilisé, la classe finale modifiée ne peut pas être proxy.

Exemple

package net.battier.test;  
  
import net.battier.dao.BookFacade;  
import net.battier.dao.impl.BookFacadeImpl;  
import net.battier.proxy.BookFacadeProxy;  
  
public class TestProxy {  
  
    public static void main(String[] args) {  
        BookFacadeProxy proxy = new BookFacadeProxy();  
        BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
        bookProxy.addBook();  
    }  
  
}

1. BookFacadeCglib.java

2. BookCadeImpl1.java

3. 🎜>4. TestCglib.java

package net.battier.dao;  
  
public interface BookFacade {  
    public void addBook();  
}

Pour une compréhension plus approfondie des articles liés au proxy dynamique Java, veuillez faire attention au site Web PHP chinois !