Introduction to java proxy mode

Let’s first introduce what an agent is.

(Learning video sharing: java video tutorial)

Proxy is a design pattern. Its core idea is to transfer access to the target to the proxy object . The advantage of this is that the target object can add some additional functions through the proxy object without changing the code. This is a programming idea that adds some extended functions through agents without changing the original code.

The proxy process is as shown in the figure. The user accesses the proxy object, and the proxy object achieves the purpose of the user accessing the target object by accessing the target object.

Proxy The pattern contains the following three roles:

ISubject: Interface object, which is the interface shared by the object and its proxy.

TargetSubject: The target object is a class that implements the abstract theme interface.

Proxy: Proxy role, which contains a reference to the target object TargetSubject, so that the real object can be manipulated. The proxy object provides the same interface as the target object so that it can replace the target object at any time. At the same time, the proxy object can add other operations when performing operations on the target object, which is equivalent to encapsulating the real object.

Common proxy modes are divided into static proxy and dynamic proxy. The implementation of dynamic proxy in Java is divided into JDK dynamic proxy and cglib proxy.

Static Proxy

As mentioned before, there are three roles in the proxy mode, one is the target interface, the second is the target object, and the third is the proxy object.

Now implement it with specific code. First, the target interface is as follows:

 public interface IBlogService {

    void writeBlog();
}

The target object implements the target interface, the code is as follows:

public class BlogService implements IBlogService {

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

Static proxy object, through the constructor method The target object is obtained and the target interface is implemented. The method of the target object is called in the method of the target interface. The code is as follows:

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...");
    }
}

Static proxy object, the target object is obtained through the construction method and the goal is achieved. Interface, the method of the target object is called in the method of the target interface, the code is as follows:

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…

Static proxy, without modifying the target object, you can pass the proxy object Make additional extension functions. But static methods are not very flexible. If the code of the target interface is modified, both the target object and the proxy object need to be modified.

Dynamic proxy avoids this situation to a certain extent. Dynamic proxy does not require the proxy object to implement the target interface, and dynamically generates the proxy object in the memory of the java virtual machine

Jdk dynamic object

Jdk's dynamic proxy is generated by the Proxy class, which has three parameters:

ClassLoader loader,: specifies the current target object to use the class loader, and the method of obtaining the loader is fixed

Class[] interfaces,: The type of interface implemented by the target object, use generics to confirm the type

InvocationHandler h: Event processing, will be triggered when the method of the target object is executed The method of the event handler will pass the method of the current execution target object as a parameter into

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

    }

The dynamic proxy code of Jdk is as follows:

 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;
                });
    }
}

Test class:

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 The Taiwan print is as follows:

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

CGLib dynamic proxy

CGLib uses a very low-level bytecode technology. The principle is to create a subclass for a class through bytecode technology, and use it in the subclass The method interception technology is used to intercept all calls to parent class methods and weave in cross-cutting logic accordingly.

CglibBlogFactory proxy factory class is as follows:

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;
    }
}

Test class:

public class TestCglib {

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

Run the program, console printing:

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

Related recommendations: java Getting Started Tutorial

The above is the detailed content of Introduction to java proxy mode. For more information, please follow other related articles on the PHP Chinese website!