What is a proxy in java?

javaWhat is a proxy?

Proxy is a design pattern that provides another way to access the target object, that is, access the target object through the proxy object. You can expand the target object's functions without modifying the target object.

The role of the agent: reduce code redundancy.

The implementation of proxy mode is divided into two categories: static implementation and dynamic implementation. Dynamic implementation is divided according to the implementation method: jdk dynamic implementation, cglib dynamic implementation

Three types of Java An agent mode

There are three ways to achieve the above requirements. In this part, we will only look at how to write the code for the three modes, and will not cover the implementation principles first.

1. Static proxy

public interface ISinger {
    void sing();
}

/**
 *  目标对象实现了某一接口
 */
public class Singer implements ISinger{
    public void sing(){
        System.out.println("唱一首歌");
    }  
}

/**
 *  代理对象和目标对象实现相同的接口
 */
public class SingerProxy implements ISinger{
    // 接收目标对象，以便调用sing方法
    private ISinger target;
    public UserDaoProxy(ISinger target){
        this.target=target;
    }
    // 对目标对象的sing方法进行功能扩展
    public void sing() {
        System.out.println("向观众问好");
        target.sing();
        System.out.println("谢谢大家");
    }
}

Test

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        //目标对象
        ISinger target = new Singer();
        //代理对象
        ISinger proxy = new SingerProxy(target);
        //执行的是代理的方法
        proxy.sing();
    }
}

Advantages: Expand the target function without modifying the function of the target object

Disadvantages: This implementation method is very intuitive and simple, but its disadvantage is that the proxy object must be written in advance. If the interface layer changes, the code of the proxy object must also be maintained. If proxy objects can be written dynamically at runtime, it will not only reduce a large number of proxy class codes, but also reduce the trouble of constant maintenance, but the efficiency of runtime will definitely be affected. This method is the next dynamic proxy.

2. JDK proxy

The premise of the static proxy is the same, it still extends the Singer object

public interface ISinger {
    void sing();
}

/**
 *  目标对象实现了某一接口
 */
public class Singer implements ISinger{
    public void sing(){
        System.out.println("唱一首歌");
    }  
}

This time, it is tested directly, because the bottom layer of java encapsulates the implementation details (I will talk about it in detail later), so the code is very simple and the format is basically fixed.

Just call the static method newProxyInstance of the Proxy class. This method will return the proxy class object.

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

The three parameters received are:

●ClassLoader loader: Specify the current The target object uses a class loader, the writing method is fixed

●　Class>[] interfaces: The type of interface implemented by the target object, the writing method is fixed

●InvocationHandler h: Event processing interface, required Pass in an implementation class, generally use the anonymous inner class directly

Test code

public class Test{
    public static void main(String[] args) {
  Singer target = new Singer();
        ISinger proxy  = (ISinger) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("向观众问好");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("谢谢大家");
                        return returnValue;
                    }
                });
        proxy.sing();
    }
}

Advantages: Dynamically implement the extension that does not change the logic of the target object

Disadvantages: It can be seen Static proxies and JDK proxies have a common disadvantage, that is, the target object must implement one or more interfaces, otherwise dynamic proxies cannot be implemented.

3. Cglib agent

Prerequisites:

● You need to introduce the jar file of cglib. Since Spring’s core package already includes the Cglib function, you can also introduce it directly. spring-core-3.2.5.jar

● The target class cannot be final

● If the method of the target object is final/static, it will not be intercepted, that is, the target will not be executed. Additional business methods of objects

/**
 * 目标对象,没有实现任何接口
 */
public class Singer{

    public void sing() {
        System.out.println("唱一首歌");
    }
}

/**
 * Cglib子类代理工厂
 */
public class ProxyFactory implements MethodInterceptor{
    // 维护目标对象
    private Object target;

    public ProxyFactory(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 obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("向观众问好");
        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("谢谢大家");
        return returnValue;
    }
}

The code here is also very fixed. Only the yellow marked parts need to be written by yourself

Test

/**
 * 测试类
 */
public class Test{
    public static void main(String[] args){
        //目标对象
        Singer target = new Singer();
        //代理对象
        Singer proxy = (Singer)new ProxyFactory(target).getProxyInstance();
        //执行代理对象的方法
        proxy.sing();
    }
}

Advantages: Dynamic implementation without changing the goal Extension of object logic

Disadvantages: The target must implement the interface, otherwise dynamic proxying cannot be achieved

Summary: The three proxy modes each have their own advantages and disadvantages and corresponding scope of application. It mainly depends on whether the target object is implemented interface. Take the proxy mode selected by the Spring framework as an example

In Spring's AOP programming:
If the target object added to the container has an implementation interface, use JDK proxy
If the target object does not implement the interface , use Cglib proxy

The above is the detailed content of What is a proxy in java?. For more information, please follow other related articles on the PHP Chinese website!