Proxy mode of design mode

Proxy pattern, one class represents the functionality of another class. This type of design pattern is part of a structural pattern.

Intent: provides a proxy for other objects to control access to this object.

explanation : It's like a star is usually a broker who takes over the job of managing stars. The general job is to visit a star through a broker.

implementation : Proxy mode has static agent and dynamic agent, dynamic agent and JDK agent and cglib agent

Source:

Static Proxy:

public interface Testadd () {

int add (int a, int b);

}

public class Testaddimpl implements Testadd() {

　　int add (int a, int b) {

return a+b;

}

}

public class Testaddproxy implements Testadd() {

Private testadd testadd;

　　Testaddprox (testadd testadd) {

This. Testadd = testadd;

}

int add (int a, int b) {

The work that can be done before the concrete implementation

int result = TEstadd.add (A, b);

The work that can be done after the concrete implementation

return result ;

}

}

The above code belongs to the static proxy. In the code, we define an interface Testadd, a concrete implementation class TestaddimpL and a proxy class Testaddproxy. before and after we actually call the proxy class, we can do some things.

Disadvantage: The static proxy constructs the corresponding proxy class for each Proxied object, and then writes many similar code repeatedly.

Dynamic Agent:

The JDK dynamic Agent provides the ability to generate dynamic proxy classes using the proxy class and the Invocationhandler interface in the Java.lang.reflect package.

Public class Testaddproxy implements Invocationhandler {

private Object obj;
public Object getproxy(object obj) {
This. obj= obj;
Get proxy Object
Return Proxy.newproxyinstance (Obj.getclass (). getClassLoader (),
Obj.getclass (). Getinterfaces (), this); Mark 1
}
@Override
public object invoke (object proxy, Method method, object[] args)
Throws Throwable {
This.dobefore ();
Result=method.invoke (target, args);
This.doafter ();
return result;
} 

public void Dobefore () {}

　 public void Doafter (){}
｝

By tag 1 we can see that the implementation class that needs to be used to the interface when using the JDK proxy

cglib Dynamic agent (import package before using):

Public class testaddproxy implements methodinterceptor{

Private enhancer enhancer = new enhancer ();

Public Object GetProxy (Class clazz) {

Set up classes that need to create subclasses

Enhancer.setsuperclass (Clazz);

Enhancer.setcallback (this);

Dynamically creating subclass instances with bytecode technology

return Enhancer.create ();

}

Implementing the Methodinterceptor interface method

public object intercept (object obj, Method method, object[] args,

Methodproxy proxy) throws Throwable {

This.dobefore ();

Object result = Proxy.invokesuper (obj, args);

this.doafter ();

return result;

}

　public void Dobefore () {}

Public void doafter (){}

}

Cglib is implemented for the class to implement the proxy, his principle is to create a subclass of the specified target class, and override the method implementation enhancements, but because of the inheritance, so the final decorated class can not be proxied

Dynamic Proxy is a proxy class implementation object that dynamically generates a specific delegate, and it does not need to implement proxy classes one at a to each delegate class.

Proxy mode of design mode