10.Java-Grundlagen – Agent

Grundkonzepte

Proxy bedeutet in Java: Bereitstellung eines Proxy-Objekts für ein Objekt, und der Proxy Das Objekt steuert den Zugriff zum Originalobjekt, das heißt, der Client steuert das Originalobjekt nicht direkt, sondern steuert das Originalobjekt indirekt über das Proxy-Objekt.

Für Laien ist es so, als würde man eine Fahrkarte kaufen. Ursprünglich brauchten wir einen Bahnhof, um eine Fahrkarte zu kaufen, aber jetzt haben wir Fahrkartenverkaufsstellen eingerichtet, und Sie können Fahrkarten direkt über die Fahrkartenverkaufsstellen kaufen.

Die Arten von Agenten sind:

• Die Implementierung von Agenten kann in statische Agenten und dynamische Agenten unterteilt werden;

• Dynamische Agenten werden auch in dynamische JDK-Proxys und dynamische CLGIB-Proxys unterteilt.

---

Statischer Proxy

In einem statischen Proxy kann jede Proxy-Klasse nur eine Schnittstelle bedienen.

Die Nachteile dieses Ansatzes liegen auf der Hand:

• Zu viele Proxys generieren. Weil mehrere Schnittstellen mehrere Proxy-Klassen erfordern.

• Code-Redundanz. Alle Proxy-Operationen sind bis auf die von ihnen aufgerufene Methode gleich.

Sehen wir uns das Beispiel eines statischen Proxys an:

// 定义一个接口，代表书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();
    }
}

---

Dynamischer Proxy

Dynamischer Proxy kann Lösen Sie das Problem. Der Nachteil des statischen Proxys besteht darin, dass er alle Proxy-Funktionen über eine Proxy-Klasse ausführen kann.

Dynamische Proxys werden in dynamische JDK-Proxys und dynamische CLGIB-Proxys unterteilt.

DKs dynamischer Proxy basiert auf der Schnittstelle, und der dynamische CLGIB-Proxy gleicht dieses Manko einfach aus.

---

1. Dynamischer JDK-Proxy

Der dynamische JDK-Proxy basiert auf der Schnittstellenimplementierung. Wenn einige Klassen die Schnittstelle nicht implementieren, können Sie den JDK-Proxy nicht verwenden.

Sehen wir uns das Beispiel an:

// 定义一个接口，代表书...// 委托类（实现接口，包含了具体的业务逻辑）...
// 动态代理类
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();
    }
}

---

2.CLGIB dynamischer Proxy

clgib implementiert Proxy für Klassen, das Prinzip ist um eine Unterklasse für die angegebene Zielklasse zu generieren und die Methode zu überschreiben, um eine Verbesserung zu erreichen.

Da Vererbung verwendet wird, können endgültig geänderte Klassen nicht als Proxy verwendet werden.

Schauen wir uns das Beispiel an:

// 实现类（没有了接口，直接实现业务逻辑）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();
    }
}

Das Obige ist der Inhalt von 10.Java Basics - Proxy. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (. www.php.cn)!