10.Java Basics - Agent-javaTutorial-php.cn

10.Java Basics - Agent

黄舟

Release： 2017-02-27 10:41:02

Original

1140 people have browsed it

Basic concept

In Java, proxy means: providing a proxy object to an object, and the proxy The object controls access to the original object, that is, the client does not directly control the original object, but indirectly controls the original object through the proxy object.

In layman's terms, it's like buying a train ticket. Originally we needed a train station to buy a ticket, but now there are ticket sales points, and you can buy tickets directly through the ticket sales points.

The types of agents are:

The implementation of agents can be divided into static agents and dynamic agents;
Dynamic agents are also Divided into JDK dynamic proxy and CLGIB dynamic proxy.

Static proxy

In a static proxy, each proxy class can only serve one interface.

The disadvantages of this approach are obvious:

Generates too many proxies. Because multiple interfaces require multiple proxy classes.
Code redundancy. All proxy operations are the same except for the method they call.

Let’s look at the example of static proxy:

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

Copy after login

Dynamic proxy

Dynamic proxy can solve the problem of static proxy Disadvantages, it can complete all proxy functions through a proxy class.

Dynamic proxies are divided into JDK dynamic proxies and CLGIB dynamic proxies.

DK's dynamic proxy relies on interface, and CLGIB dynamic proxy just makes up for this shortcoming.

1. JDK dynamic proxy

JDK's dynamic proxy relies on interface implementation. If some classes do not implement the interface, you cannot use the JDK proxy.

Let’s look at its example:

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

Copy after login

2.CLGIB dynamic proxy

clgib implements proxy for classes, principle It generates a subclass for the specified target class and overrides its methods to achieve enhancement.

Because inheritance is used, final-modified classes cannot be proxied.

Let’s take a look at its example:

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

Copy after login

The above is the content of 10.Java Basics - Proxy. For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!