Proxy-ul dinamic este împărțit în proxy dinamic JDK și proxy dinamic Cglib. Utilizarea obișnuită este în arcul AOP.
- Dynamic Proxy JDK : Metoda cu același nume în interfață este utilizată pentru a apela metoda aceeași implementare în clasa proxy generată dinamic; Proxy-ul implementează clasa de interfață și clasa fără interfață nu poate utiliza proxy-ul dinamic JDK. ZH
- Dynamic Cglib Proxy: Modificarea clasei de afaceri, clasa proxy generată dinamică este o subclasă a clasei de afaceri, care se înlocuiește prin anularea metodei de afaceri; Clasa modificată finală nu poate fi proxy. Pentru a utiliza agentul CGLIB, trebuie să importați pachetul JAR CGLIB Programul solicită obiectul clasei proxy. Motorul rulează și apoi efectuează apeluri la metode prin acest obiect de clasă proxy.
De ce interfețele dinamice de implementare a proxy JDK?
Când proxy-ul dinamic JDK este implementat utilizând InvocationHandler, proxy-ul Clasa trebuie să moștenească proxy. În timp ce clasa proxy trebuie să fie moștenită pentru a obține metodele relevante și constructorii de invocare, Java nu poate moșteni ambele clase în același timp. Pentru a stabili o legătură cu clasa proxy, numai implementarea interfeței
a proxy-ului dinamic JDK (interfața are clasa de implementare)
1. Creați clase proxy și interfețe
IV ID = „612FD58BC9”
iv id = „EF3B1A67FC”
Creați o clasă proxy invocă și implementarea interfeței InvocationHandler
/* * @author uv * @date 2018/10/12 13:04 * */import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class InvokeProxy implements InvocationHandler{ // El objeto real para proxy private Object subject; public InvokeProxy(Object subject) { this.subject = subject; } /** * El objeto real que el proxy @param está representando * Método @param Objeto Método para llamar a un método del objeto real * @param args Los parámetros aceptados al llamar a un método del objeto real */ @Override public Object invoke(Object proxy, Method method, Object args) throws Throwable { System.out.println("start method:" + method.getName()); method.invoke(subject, args); System.out.println("end method:" + method.getName()); return null; }}3. Utilizarea proxy-ului dinamic
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"); }}Implementarea proxy-ului dinamic JDK (interfața nu are clasa de implementare)
1. Creați o interfață proxy
public interface SellService { String sell(String name);}2. Creați clasa proxy invocă și implementarea interfeței 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. Utilizarea proxy-ului dinamic
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 dinamic cglib
cglib implementează proxy-uri pentru clase. Principiul este de a genera o subclasă a clasei de afaceri specificate și de a suprascrie metodele de afaceri pentru implementarea proxy-ului. Deoarece este utilizată moștenirea, nu poate fi proxy clase modificate finisate. Zh
1. Adăugați dependențe
<dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.2.4</version> </dependency>2. Creați o clasă proxy fără a implementa o interfață (este posibilă și implementarea unei interfețe, nu afectează)
/* * @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. Implementați interfața proxy a metodei intermedorului metodei și a crea o clasă 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. Utilizarea proxy-ului dinamic
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"); }}