Introduction au mode proxy Java

Présentons d'abord ce qu'est un agent.

(Partage vidéo d'apprentissage : tutoriel vidéo Java)

Le proxy est un modèle de conception, et son idée principale est de transférer l'accès à la cible à l'objet proxy. L'avantage est que l'objet cible peut ajouter des fonctions supplémentaires via l'objet proxy sans changer le code. Il s'agit d'une idée de programmation qui ajoute des fonctions étendues via des agents sans modifier le code d'origine.

Le processus proxy est tel qu'illustré sur la figure. L'utilisateur accède à l'objet proxy, et l'objet proxy atteint l'objectif de l'utilisateur d'accéder à l'objet cible en accédant à l'objet cible

<.>

Proxy Le modèle contient les trois rôles suivants :

ISubject : objet d'interface, qui est l'interface partagée par l'objet et son proxy.

TargetSubject : L'objet cible est une classe qui implémente l'interface du thème abstrait.

Proxy : rôle proxy, qui contient une référence à l'objet cible TargetSubject, afin que l'objet réel puisse être manipulé. L'objet proxy fournit la même interface que l'objet cible afin qu'il puisse remplacer l'objet cible à tout moment. Dans le même temps, l'objet proxy peut ajouter d'autres opérations lors de l'exécution d'opérations sur l'objet cible, ce qui équivaut à encapsuler l'objet réel.

Les modes de proxy courants sont divisés en proxy statique et proxy dynamique. L'implémentation du proxy dynamique en Java est divisée en proxy dynamique JDK et proxy cglib.

Proxy statique

Comme mentionné précédemment, il existe trois rôles dans le mode proxy, l'un est l'interface cible, le second est l'objet cible et le troisième est l'objet proxy.

Implémentez-le maintenant avec un code spécifique. Tout d'abord, l'interface cible est la suivante :

 public interface IBlogService {

    void writeBlog();
}

L'objet cible implémente l'interface cible, le code est le suivant :

public class BlogService implements IBlogService {

    @Override
    public void writeBlog() {
        System.out.println("i'm writing...");
    }
}

Objet proxy statique, via la méthode constructeur L'objet cible est obtenu et l'interface cible est implémentée. La méthode de l'objet cible est appelée dans la méthode de l'interface cible. Le code est le suivant :

public class BlogStaticProxy implements IBlogService{
    private IBlogService blogService;

    public BlogStaticProxy(IBlogService blogService) {
        this.blogService = blogService;
    }

    @Override
    public void writeBlog() {
        System.out.println("start writing...");
        blogService.writeBlog();
        System.out.println("end writing...");
    }
}

Statique. objet proxy, l'objet cible est obtenu grâce à la méthode de construction et l'objectif est atteint Interface, la méthode de l'objet cible est appelée dans la méthode de l'interface cible, le code est le suivant :

public class BlogStaticProxy implements IBlogService{
    private IBlogService blogService;

    public BlogStaticProxy(IBlogService blogService) {
        this.blogService = blogService;
    }

    @Override
    public void writeBlog() {
        System.out.println("start writing...");
        blogService.writeBlog();
        System.out.println("end writing...");
    }
}

Test. :

public class TestStaticProxy {

    public static void main(String[] args) {
        IBlogService target = new BlogService();
        BlogStaticProxy proxy = new BlogStaticProxy(target);
        proxy.write();
    }
}

start writing…
i’m writing…
end writing…

Proxy statique, sans modifier l'objet cible, vous pouvez passer l'objet proxy Créer des fonctions d'extension supplémentaires. Mais les méthodes statiques ne sont pas très flexibles. Si le code de l'interface cible est modifié, l'objet cible et l'objet proxy doivent être modifiés.

Le proxy dynamique évite cette situation dans une certaine mesure. Le proxy dynamique ne nécessite pas que l'objet proxy implémente l'interface cible et génère dynamiquement l'objet proxy dans la mémoire de la machine virtuelle Java

Objet dynamique Jdk

Le proxy dynamique de Jdk est généré par la classe Proxy, qui a trois paramètres :

Chargeur ClassLoader, : précise que l'objet cible actuel utilise un chargeur de classe, et la méthode d'obtention le chargeur est corrigé

Class>[] interfaces, : le type d'interface implémentée par l'objet cible, utiliser des génériques pour confirmer le type

InvocationHandler h : traitement d'événement, déclenché lorsque la méthode de l'objet cible est exécutée La méthode du gestionnaire d'événements passera la méthode de l'objet cible actuellement exécuté en tant que paramètre dans

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

    }

Le code proxy dynamique de Jdk est le suivant :

 public class JdkBlogProxyFactory {

    private Object target;

    public JdkBlogProxyFactory(Object target) {
        this.target = target;
    }

    public Object newInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    System.out.println("start writing");
                    Object o = method.invoke(target, args);
                    System.out.println("end writing");
                    return o;
                });
    }
}

Classe de test :

public class TestJdkProxy {
    public static void main(String[] args) {

        IBlogService target = new BlogService();

        System.out.println(target.getClass());

        // 给目标对象，创建代理对象
        IBlogService proxy = (IBlogService) new JdkBlogProxyFactory(target).newInstance();
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxy.getClass());

        // 执行方法   【代理对象】
        proxy.writeBlog();
    }
}

Control L'imprimé de Taiwan est le suivant :

class com.forezp.proxy.BlogService
class com.sun.proxy.$Proxy0
start writing
i'm writing...
end writing

Proxy dynamique CGLib

CGLib utilise une technologie de bytecode de très bas niveau. Le principe est de créer une sous-classe. pour une classe via la technologie de bytecode et l'utiliser dans la sous-classe. La technologie d'interception de méthodes est utilisée pour intercepter tous les appels aux méthodes de la classe parent et intégrer une logique transversale en conséquence.

La classe d'usine de proxy CglibBlogFactory est la suivante :

public class CglibBlogFactory implements MethodInterceptor {

    private Object target;

    public CglibBlogFactory(Object target) {
        this.target = target;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance() {
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("start writing...");
        //执行目标对象的方法
        Object returnValue = method.invoke(target, objects);
        System.out.println("end writing...");
        return returnValue;
    }
}

Classe de test :

public class TestCglib {

    public static void main(String[] args) {
        IBlogService target = new BlogService();
        //代理对象
        IBlogService proxy = (IBlogService) new CglibBlogFactory(target).getProxyInstance();
        //执行代理对象的方法
        proxy.writeBlog();
    }
}

Exécuter le programme, impression de la console :

start writing...
i'm writing...
end writing...

Recommandations associées :

Tutoriel de démarrage Java

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!