O proxy dinámico está dividido en Proxy Dynamic JDK e Dynamic Proxy Cglib. O uso común está na primavera AOP.
- Dynamic Proxy JDK : O método co mesmo nome da interface úsase para chamar ao método da mesma implementación en clase proxy xerada dinámicamente; O proxy implementa a clase de interface e a clase sen a interface non pode usar o proxy dinámico de JDK. Zh
- Proxy dinámico cglib: herdando a clase empresarial, a clase proxy dinámica xerada é unha subclase da clase empresarial, que é substituída ao anular o método empresarial; A clase modificada final non pode ser proxy. Para usar o axente CGLIB, ten que importar o paquete JAR CGLIB.
Proxy dinámico JDK
A clase proxy utilizada polo Proxy JDK dinámico é realmente creada por JVM cando O programa chama ao obxecto da clase proxy. O motor execútase e logo fai chamadas a métodos a través deste obxecto de clase proxy.
Por que a dinámica proxy jdk implementa interfaces?
Cando o Proxy JDK Dynamic está implementado usando InvocationHandler, o proxy A clase debe herdar proxy. Mentres a clase proxy debe ser herdada para obter os métodos relevantes e os construtores de Invocationhandler, Java non pode herdar ambas clases ao mesmo tempo. Para establecer unha conexión coa clase de proxy, só a
Implementación da interface do proxy dinámico JDK (a interface ten clase de implementación)
1. Crea clases de proxy e interfaces
public interface BuyService { void buy(String name);}import com.uv.service.BuyService;public class BuyServiceImpl implements BuyService{ @Override public void buy(String name) { System.out.println("buy " + name); }}Crear unha clase proxy invokproxy e implementar a interface InvocationHandler
IV id = “7B497CD2C6” “
3. Uso do proxy dinámico
import com.uv.proxy.InvokeProxy;import com.uv.service.BuyService;import com.uv.service.impl.BuyServiceImpl;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;/** * <uv> */public class Main { public static void main(String args) { // El objeto real para proxy BuyService service = new BuyServiceImpl(); InvocationHandler handler = new InvokeProxy(service); /* * El nuevo método ProxyInstance del proxy para crear nuestro objeto proxy * El primer parámetro handler.getClass (). GetClassLoader () usa el objeto ClassLoader de la clase handler para cargar nuestro objeto proxy * El segundo parámetro realSubject.getClass (). GetInterfaces (), la interfaz proporcionada para el objeto proxy es la interfaz implementada por el objeto real, lo que significa que quiero proxy del objeto real, por lo que puedo llamar a los métodos en este conjunto de interfaces Arriba * El tercer controlador de parámetros, asocia este objeto proxy con el objeto InvocationHandler anterior */ BuyService buyService = (BuyService)Proxy.newProxyInstance(handler.getClass().getClassLoader(), service.getClass().getInterfaces(), handler); buyService.buy("cap"); }}Implementación do proxy dinámico JDK (a interface non ten clase de implementación)
1. Crear unha interface proxy
public interface SellService { String sell(String name);}2. Crea a clase proxy invokproxy e implementa a interface InvocationHandler
/* * @author uv * @date 2018/10/12 13:56 * No hay proxy dinámico que implemente la interfaz de clase */import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class InterfaceProxy implements InvocationHandler { @Override public Object invoke(Object proxy, Method method, Object args) throws Throwable { System.out.println ("Llamada al método de interfaz iniciada"); // método de ejecución System.out.println("method name:" + method.getName()); System.out.println("method args:" + args); System.out.println ("Fin de la llamada al método de interfaz"); return "sell " + args; } public static <T> T newInterfaceProxy(Class<T> intf) { ClassLoader classLoader = intf.getClassLoader(); Class<?> interfaces = new Class{intf}; InterfaceProxy proxy = new InterfaceProxy(); return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy); }}3. Uso de proxy dinámico
import com.uv.proxy.InterfaceProxy;import com.uv.service.SellService;/** * <uv> */public class Main { public static void main(String args) { SellService sellService = InterfaceProxy.newInterfaceProxy(SellService.class); System.out.println(sellService.sell("cap")); }}Proxy dinámico cglib
Cglib implementa proxies para as clases. O principio é xerar unha subclase da clase empresarial especificada e substituír os métodos empresariais para implementar o proxy. Debido a que se usa a herdanza, non pode proxy clases modificadas. Zh
1. Engade dependencias
<dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.2.4</version> </dependency>2. Crea unha clase proxy sen implementar unha interface (tamén é posible implementar unha interface, non afecta)
/* * @author uv * @date 2018/10/12 14:37 * Clase de proxy que no implementa ninguna interfaz */public class SayService { public void say(String name) { System.out.println("Hello " + name); }}3. Implementar a interface proxy do método de interceptor do método e crear unha clase proxy
/* * @author uv * @date 2018/10/12 14:36 * */import java.lang.reflect.Method;import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;public class CglibProxy implements MethodInterceptor{ // Objeto comercial, que se representará private Object subject; // Equivalente al enlace en proxy dinámico JDK public <T> T getInstance(T subject) { // Asigna valores a objetos comerciales this.subject = subject; // Crear potenciador, usado para crear clases de proxy dinámico Enhancer enhancer = new Enhancer(); // Especifique la clase de negocio a proxy para el potenciador (es decir, especifique la clase padre para la clase de proxy generada a continuación) enhancer.setSuperclass(this.subject.getClass()); // Establezca la devolución de llamada: se llamará a CallBack para todos los métodos en la clase proxy, y Callback debe implementar el método intercept () para bloquear enhancer.setCallback(this); // Crea un objeto de clase proxy dinámico y devuelve return (T)enhancer.create(); } @Override public Object intercept(Object obj, Method method, Object args, MethodProxy proxy) throws Throwable { System.out.println("before"); // Llamar al método de la clase de negocios (en la clase padre) proxy.invokeSuper(obj, args); System.out.println("after"); return null; }}4. Uso do proxy dinámico
import com.uv.proxy.CglibProxy;import com.uv.service.impl.SayService;/** * <uv> */public class Main { public static void main(String args) { // El objeto que se representa SayService sayService = new SayService(); // clase de proxy CglibProxy cglibProxy = new CglibProxy(); SayService service = cglibProxy.getInstance(sayService); service.say("Tom"); }}