Le proxy dynamique est divisé en un proxy dynamique JDK et de la proxy dynamique. Utilisation commune est dans l’AOP à ressort.
- PROXY DYNAMIQUE JDK : La méthode avec le même nom de l’interface est utilisée pour appeler la méthode de la même implémentation dans la classe proxy générée dynamiquement; Le proxy implémente la classe d’interface et la classe sans l’interface ne peuvent pas utiliser le proxy dynamique JDK. ZH
- Dynamic CGLIB Proxy: héritage de la classe d’entreprise, la classe de proxy dynamique générée est une sous-classe de la classe Business, remplacée en annulant la méthode des entreprises; La classe modifiée finale ne peut pas être proxy. Pour utiliser l’agent CGLIB, vous devez importer le package JAR CGLIB.
JDK dynamique JDK
La classe proxy utilisée par le proxy dynamique JDK est vraiment créée par JVM quand Le programme appelle à l’objet de la classe proxy. Le moteur fonctionne, puis appelle des appels vers des méthodes via cet objet de classe proxy.
Pourquoi la proxy dynamique JDK implémente-t-elle des interfaces?
lorsque le proxy dynamique JDK est implémenté à l’aide de InvocationHandler, le proxy La classe doit hériter du proxy. Bien que la classe de proxy doit être héritée pour obtenir les méthodes pertinentes et les constructeurs d’invocationHandler, Java ne peut pas hériter les deux classes en même temps. Pour établir une connexion avec la classe proxy, seule la mise en œuvre de l’interface
du proxy dynamique JDK (l’interface a une classe de mise en œuvre)
1. Créez des classes de proxy et des interfaces
public interface BuyService { void buy(String name);}Créer une classe de proxy InvokeProxy et implémenter l’interface d’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. Utilisation d’une proxy dynamique
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"); }}Implémentation du proxy dynamique JDK (l’interface n’a pas de classe de mise en œuvre)
1. Créez une interface proxy
public interface SellService { String sell(String name);}2. Créez la classe proxy InvokeProxy et implémentez l’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. Utilisation d’une proxy dynamique
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 DYNAMIQUE CGLIB
CGLIB implémente les proxies pour les classes. Le principe consiste à générer une sous-classe de la classe d’entreprise spécifiée et à remplacer les méthodes commerciales pour mettre en œuvre le proxy. Étant donné que l’héritage est utilisé, il ne peut pas formuler des classes modifiées de proxy finis. ZH
1. Ajouter des dépendances
<dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.2.4</version> </dependency>2. Créez une classe de proxy sans implémenter une interface (il est également possible d’implémenter une interface, elle n’affecte pas)
/* * @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. Implémentez l’interface proxy de la méthode de la méthode interceptor et créez une classe 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. Utilisation de proxy dynamique
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"); }}