10.Bases de Java - Proxy

Concepts de base

En Java, proxy signifie : fournir un objet proxy à un objet, et le proxy L'objet contrôle l'accès à l'objet d'origine, c'est-à-dire que le client ne contrôle pas directement l'objet d'origine, mais contrôle indirectement l'objet d'origine via l'objet proxy.

En termes simples, c'est comme acheter un billet de train. Au départ, nous avions besoin d'une gare pour acheter un billet, mais maintenant nous avons mis en place des points de vente de billets, et vous pouvez acheter des billets directement via les points de vente de billets.

Les types d'agents sont :

• La mise en œuvre des agents peut être divisée en agents statiques et agents dynamiques ; Les agents dynamiques sont également divisés en proxy dynamique JDK et proxy dynamique CLGIB.

Proxy statique

---

Dans un proxy statique, chaque classe de proxy ne peut servir qu'une seule interface. Les inconvénients de cette approche sont évidents :

Générer trop de proxys

. Parce que plusieurs interfaces nécessitent plusieurs classes proxy.

• Redondance des codes
. Toutes les opérations de proxy sont les mêmes, à l'exception de la méthode qu'elles appellent.

• Regardons l'exemple d'un proxy statique :

Un proxy dynamique

// 定义一个接口，代表书interface Book {    void read(); 
}// 委托类（实现接口，包含了具体的业务逻辑）class Bible implements Book {    @Override
    public void read() {
        System.out.println("Reading...");
    }
}// 静态代理类（其实是对 Bible 类的增强)class BookProxy implements Book {    //委托对象，作为构造函数的参数
    private Book book;  

    BookProxy(Book book) {        this.book = book;
    }    @Override
    public void read() {
        System.out.println("Reading 调用之前");
        book.read();
        System.out.println("Reading 调用之后");
    }
}public class Test {
    public static void main(String[] args) {        //静态代理调用
        Book book = new Bible()
        BookProxy bookProxy = new BookProxy(book);
        bookProxy.read();
    }
}

---

Un proxy dynamique peut résoudre le problème L'inconvénient du proxy statique est qu'il peut remplir toutes les fonctions de proxy via une classe proxy. Les proxys dynamiques sont divisés en proxys dynamiques JDK et proxys dynamiques CLGIB.

Le proxy dynamique de DK s'appuie sur l'

interface

, et le proxy dynamique CLGIB compense tout simplement cette lacune.

1. Proxy dynamique JDK

---

Le proxy dynamique du JDK repose sur l'implémentation de l'interface Si certaines classes n'implémentent pas l'interface, vous ne pouvez pas utiliser le proxy JDK. Regardons son exemple :

2.Le proxy dynamique CLGIB

// 定义一个接口，代表书...// 委托类（实现接口，包含了具体的业务逻辑）...
// 动态代理类
class BookHandler implements InvocationHandler{    
private Object target;    
//绑定委托对象（JDK 动态代理的缺陷，只能绑定接口）并返回一个代理类
    Object bind(Object target){        
    this.target = target;        
    // 取得代理对象
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(), // 类加载器
            target.getClass().getInterfaces(),  // 类的所有接口
            this); // InvocationHandler
    }    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Reading 调用之前");
        method.invoke(target, args);
        System.out.println("Reading 调用之后");        return null;
    }
}public class Test {
    public static void main(String[] args) {        // 动态代理调用
        Book book = new Bible();
        BookHandler bookHandler = new BookHandler();
        Book bookProxy = (Book) bookHandler.bind(book);
        bookProxy.read();
    }
}

---

clgib implémente le proxy pour les classes, le principe est pour générer une sous-classe pour la classe cible spécifiée et remplacer la méthode pour obtenir une amélioration. Étant donné que l'héritage est utilisé, les classes finales modifiées ne peuvent pas être proxy.

Jetons un coup d'œil à son exemple :

Ce qui précède est le contenu de 10.Java Basics - Proxy Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (. www.php.cn) !

// 实现类（没有了接口，直接实现业务逻辑）class Book {    public void read() {
        System.out.println("Reading...");
    }
}// 动态代理类class BookCglib implements MethodInterceptor{    private Object target;

    Object getInstance(Object target){        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());        //回调方法
        enhancer.setCallback(this);        //创建代理对象
        return enhancer.create();
    }    @Override
    public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Reading 调用之前");
        proxy.invoke(target, args);
        System.out.println("Reading 调用之后");        return null;
    }

}public class Test {
    public static void main(String[] args) {
        BookCglib bookCglib =  new BookCglib();
        Book book = (Book) bookCglib.getInstance(new Book());
        book.read();
    }
}