1. Was ist CGLIB?

CGLIB ist ein leistungsstarkes, hochperformantes Codegenerierungspaket. Es stellt Proxys für Klassen bereit, die keine Schnittstellen implementieren, und bietet eine gute Ergänzung zum dynamischen Proxy von JDK. Normalerweise können Sie den dynamischen Proxy von Java verwenden, um Proxys zu erstellen, aber wenn die zu proxyende Klasse keine Schnittstelle implementiert oder für bessere Leistung, ist CGLIB eine gute Wahl.

Als Open-Source-Projekt wird der Code von CGLIB auf GitHub gehostet unter:https://github.com/cglib/cglib


2. CGLIB-Prinzip

CGLIB-Prinzip: Es wird dynamisch eine Unterklasse der zu proxyenden Klasse generiert, und die Unterklasse überschreibt alle nicht-finalen Methoden der zu proxyenden Klasse. In der Unterklasse wird die Technik der Methodeninterzeption verwendet, um alle Aufrufe von Methoden der Elternklasse abzufangen, und Querschnittslogik wird entsprechend eingewoben. Es ist schneller als der dynamische JDK-Proxy, der Java-Reflection verwendet.

CGLIB zugrunde liegende Schicht: Es verwendet das Bytecode-Verarbeitungsframework ASM, um Bytecode zu transformieren und neue Klassen zu generieren. Die direkte Verwendung von ASM wird nicht empfohlen, da sie erfordert, dass Sie mit der internen Struktur der JVM sehr vertraut sind, einschließlich des Formats von Klassendateien und des Befehlssatzes.

CGLIB-Nachteile: Final-Methoden können nicht geproxyt werden.


3. CGLIB-Anwendungen

Es wird von vielen AOP-Frameworks wie Spring AOP und dynaop weit verbreitet eingesetzt. Hibernate verwendet CGLIB, um einseitige (Many-to-one- und One-to-one-)Assoziationen zu proxyen.


4. Warum CGLIB verwenden?

Der CGLIB-Proxy arbeitet hauptsächlich auf Bytecode, um eine Indirektionsebene für Objekte einzuführen, damit der Zugriff auf Objekte kontrolliert werden kann. Wir wissen, dass Java einen dynamischen Proxy hat, der dies ebenfalls tut. Warum also nicht direkt den Java-Dynamic-Proxy verwenden und stattdessen CGLIB einsetzen? Die Antwort ist, dass CGLIB leistungsfähiger ist als der JDK-Dynamic-Proxy. Obwohl der JDK-Dynamic-Proxy einfach und bequem zu verwenden ist, hat er einen fatalen Mangel: Er kann nur Interfaces proxyen. Wenn die zu proxende Klasse eine gewöhnliche Klasse ohne Interface ist, kann der Java-Dynamic-Proxy nicht verwendet werden.


5. Aufbau von CGLIB

Die darunterliegende Schicht von CGLIB verwendet ASM (ein kompaktes und leistungsfähiges Framework zur Bytecode-Manipulation), um Bytecode zu bearbeiten und neue Klassen zu generieren. Neben der CGLIB-Bibliothek verwenden auch Skriptsprachen (wie Groovy und BeanShell) ASM, um Bytecode zu generieren. ASM verwendet einen SAX-ähnlichen Parser, um hohe Leistung zu erzielen. Wir empfehlen nicht die direkte Verwendung von ASM, da sie ausreichende Kenntnisse des Java-Bytecode-Formats erfordert.


6. CGLIB-API

1. JAR-Paket:

  • cglib-nodep-2.2.jar: Bei Verwendung des nodep-Pakets muss das ASM-JAR-Paket nicht eingebunden werden; das JAR-Paket enthält intern ASM-Klassen.
  • cglib-2.2.jar: Bei Verwendung dieses JAR-Pakets müssen Sie das ASM-JAR-Paket einbinden; andernfalls tritt ein Laufzeitfehler auf.

2. CGLIB-Bibliothek:

Da der zugrunde liegende Code minimal ist, ist er etwas schwierig zu erlernen, hauptsächlich aufgrund des Mangels an Dokumentation und Beispielen, was auch ein Nachteil von CGLIB ist.

Die in dieser Serie verwendete CGLIB-Version ist 2.2.

  • net.sf.cglib.core: Low-Level-Bytecode-Verarbeitungsklassen, von denen die meisten mit ASM zusammenhängen.
  • net.sf.cglib.transform: Transformation von Klassen und Klassendateien zur Kompilierzeit oder zur Laufzeit
  • net.sf.cglib.proxy: Klassen, die die Proxy-Erstellung und Methoden-Interceptoren implementieren
  • net.sf.cglib.reflect: Klassen, die schnelle Reflexion und Proxys im C#-Stil implementieren
  • net.sf.cglib.util: Hilfsklassen wie die Sortierung von Collections
  • net.sf.cglib.beans: Hilfsklassen im Zusammenhang mit JavaBean

Dieser Artikel stellt die Implementierung eines dynamischen Proxys mithilfe von MethodInterceptor und Enhancer vor.

1. Sprechen wir zunächst über den dynamischen Proxy im JDK:

Der dynamische Proxy im JDK wird durch die Reflexionsklasse Proxy und die InvocationHandler-Callback-Schnittstelle implementiert. Allerdings muss die Klasse, für die im JDK dynamisch ein Proxy erstellt werden soll, eine Schnittstelle implementieren. Das heißt, nur Methoden, die in der von der Klasse implementierten Schnittstelle definiert sind, können mit einem Proxy versehen werden. Dies hat gewisse Einschränkungen in der tatsächlichen Programmierung, und die Effizienz bei der Verwendung von Reflexion ist nicht sehr hoch.

2. Implementierung mit CGLib:

Die Verwendung von CGLib zur Implementierung eines dynamischen Proxys befreit vollständig von der Einschränkung, dass die Proxy-Klasse eine Schnittstelle implementieren muss. Darüber hinaus verwendet die zugrunde liegende Ebene von CGLib das ASM-Bytecode-Generierungsframework, um Proxy-Klassen mithilfe von Bytecode-Technologie zu generieren, was effizienter ist als die Verwendung von Java-Reflexion. Das Einzige, was zu beachten ist, ist, dass CGLib für als final deklarierte Methoden keinen Proxy erstellen kann, da das Prinzip von CGLib darin besteht, dynamisch eine Unterklasse der Klasse zu generieren, für die ein Proxy erstellt wird.

Nachfolgend wird anhand eines Beispiels die Implementierung des dynamischen Proxys mit CGLib vorgestellt.

1. Zu proxyende Klasse:

Definieren Sie zunächst eine Klasse, die keine Schnittstelle implementiert.

package com.zghw.cglib; /** * Eine Zielklasse, die keine Schnittstelle implementiert und einen dynamischen CGlib-Proxy erfordert. * * @author zghw * */ public class TargetObject { public String method1(String paramName) { return paramName; } public int method2(int count) { return count; } public int method3(int count) { return count; } @Override public String toString() { return "TargetObject []"+ getClass(); } }

2. Interceptor:

Definieren Sie einen Interceptor. Wenn die Zielmethode aufgerufen wird, ruft CGLib die MethodInterceptor-Schnittstellenmethode zur Interzeption auf, um Ihre eigene Proxy-Logik zu implementieren, ähnlich der InvocationHandler-Schnittstelle in JDK.

package com.zghw.cglib; import java.lang.reflect.Method; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; /** * Zielobjekt-Interceptor, implementiert MethodInterceptor * @author zghw * */ public class TargetInterceptor implements MethodInterceptor{ /** * RewriteMethods fängt InMethodsbeforeandMethodsPost-increment in Geschäftsangelegenheit ab * Object obj ist Zielobjekt * Method method ist Zielmethoden * Object[] params sind Parameter, * MethodProxy proxy CGlib Methoden Surrogat-Paar-Objekt*/ @Override public Object intercept(Object obj, Method method, Object[] params, MethodProxy proxy) throws Throwable { System.out.println("Vor dem Aufruf"); Object result = proxy.invokeSuper(obj, params); System.out.println("Nach dem Aufruf"+result); return result; } }

Parameter: Object ist die dynamisch von CGLib generierte Proxy-Klasseninstanz, Method ist die Referenz auf die zu proxyende Methode, die von der obigen Entity-Klasse aufgerufen wird, Object[] ist die Liste der Parameterwerte, und MethodProxy ist die Proxy-Referenz auf die von der Proxy-Klasse generierte Methode.

Rückgabe: Der Wert, der vom Methodenaufruf auf der Proxy-Instanz zurückgegeben wird.

Darunter,proxy.invokeSuper(obj,arg)Ruft die Superklassenmethode der Proxy-Methode auf der Proxy-Klasseninstanz auf (d. h. die entsprechende Methode in der Entity-Klasse TargetObject).

In diesem Beispiel wird nur ein Satz vor und nach dem Aufruf der Methode der zu proxyenden Klasse ausgegeben. Natürlich kann es in der tatsächlichen Programmierung andere komplexe Logik sein.

3. Dynamische Proxy-Klasse generieren:

package com.zghw.cglib; import net.sf.cglib.proxy.Callback; import net.sf.cglib.proxy.CallbackFilter; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.NoOp; public class TestCglib { public static void main(String args[]) { Enhancer enhancer =new Enhancer(); enhancer.setSuperclass(TargetObject.class); enhancer.setCallback(new TargetInterceptor()); TargetObject targetObject2=(TargetObject)enhancer.create(); System.out.println(targetObject2); System.out.println(targetObject2.method1("mmm1")); System.out.println(targetObject2.method2(100)); System.out.println(targetObject2.method3(200)); } }

Hier ist die Enhancer-Klasse ein Bytecode-Enhancer in CGLib. Sie kann bequem die Klasse erweitern, die Sie verarbeiten möchten, und wir werden sie später oft sehen.

Legen Sie zuerst die zu proxyende Klasse TargetObject als Elternklasse fest, dann legen Sie den Interceptor TargetInterceptor fest, und führen Sie schließlich enhancer.create() aus, um dynamisch eine Proxy-Klasse zu erzeugen, und casten Sie sie von Object in den Elterntyp TargetObject.

Rufen Sie schließlich die Methode auf der Proxy-Klasse auf.

4. Callback-Filter CallbackFilter

1. Funktion:

Wenn CGLib Callbacks ausführt, können Sie für verschiedene Methoden unterschiedliche Callback-Logik festlegen oder sogar ganz auf Callbacks verzichten.

Beim dynamischen JDK-Proxy gibt es keine ähnliche Funktion; der Aufruf der Methode des InvocationHandler-Interfaces wirkt für alle Methoden in der Proxy-Klasse.

Definieren Sie eine Klasse, die das CallbackFilter-Interface implementiert:

package com.zghw.cglib; import java.lang.reflect.Method; import net.sf.cglib.proxy.CallbackFilter; /** * Callback-Methodenfilterung * @author zghw * */ public class TargetMethodCallbackFilter implements CallbackFilter { /** * FilterMethods * returnedValue ist eine Zahl und repräsentiert den Index der Position des bereits im Array befindlichen Callbacks, der verwendet werden soll.*/ @Override public int accept(Method method) { if(method.getName().equals("method1")){ System.out.println("filter method1 ==0"); return 0; } if(method.getName().equals("method2")){ System.out.println("filter method2 ==1"); return 1; } if(method.getName().equals("method3")){ System.out.println("filter method3 ==2"); return 2; } return 0; } }

Der Rückgabewert ist der Positionsindex jeder Methode der geproxyten Klasse im Callback-Array Callback[] (siehe unten).

package com.zghw.cglib; import net.sf.cglib.proxy.Callback; import net.sf.cglib.proxy.CallbackFilter; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.NoOp; public class TestCglib { public static void main(String args[]) { Enhancer enhancer =new Enhancer(); enhancer.setSuperclass(TargetObject.class); CallbackFilter callbackFilter = new TargetMethodCallbackFilter(); /** * (1)callback1: Methoden fangen device ab (2)NoOp.INSTANCE: Dieses NoOp repräsentiert keinen Operator, d. h. es wird keine Operation ausgeführt; die Proxy-Klasse ruft die Methode der geproxyten Klasse direkt auf, ohne Abfangen. (3)FixedValue: Stellt einen festgelegten Methodenrückgabewert dar; egal, welchen Wert die Methode der Proxy-Klasse zurückgibt, geben die Callback-Methoden alle den Fixed-Wert zurück.*/ Callback noopCb=NoOp.INSTANCE; Callback callback1=new TargetInterceptor(); Callback fixedValue=new TargetResultFixed(); Callback[] cbarray=new Callback[]{callback1,noopCb,fixedValue}; //enhancer.setCallback(new TargetInterceptor()); enhancer.setCallbacks(cbarray); enhancer.setCallbackFilter(callbackFilter); TargetObject targetObject2=(TargetObject)enhancer.create(); System.out.println(targetObject2); System.out.println(targetObject2.method1("mmm1")); System.out.println(targetObject2.method2(100)); System.out.println(targetObject2.method3(100)); System.out.println(targetObject2.method3(200)); } }
package com.zghw.cglib; import net.sf.cglib.proxy.FixedValue; /** Gibt an, dass der Rückgabewert der Methode fixiert wird: Unabhängig davon, was die Methode der zu proxyenden Klasse zurückgibt, gibt die Callback-Methode immer einen festen Wert zurück. * @author zghw * */ public class TargetResultFixed implements FixedValue{ /** * Diese Klasse implementiert das FixedValue-Interface,gleichzeitig wird der Callback-Wert auf 999 fixiert * (integer,im CallbackFilter definierte/verwendete Callback-Methode vom Typ FixedValue ist getConcreteMethodFixedValue, diese Methode gibt einen integer-Wert zurück)。*/ @Override public Object loadObject() throws Exception { System.out.println("Gesperrtes Ergebnis"); Object obj = 999; return obj; } }

5. Lazy-Loading von Objekten

1. Funktion:

Wenn von Lazy Loading die Rede ist, sollte man ihm häufig begegnen, insbesondere bei der Verwendung von Hibernate. Dieser Artikel wird die Implementierung von Lazy Loading anhand eines Beispiels analysieren. Das LazyLoader-Interface erbt von Callback, ist also auch eine Art von Callback in CGLib.

Ein weiteres Lazy-Loading-Interface ist Dispatcher.

Das Dispatcher-Interface erbt ebenfalls von Callback und ist auch eine Art von Callback.

Der Unterschied zwischen Dispatcher und LazyLoader besteht jedoch darin: LazyLoader löst die Callback-Methode der Proxy-Klasse nur aus, wenn zum ersten Mal auf die lazy geladene Eigenschaft zugegriffen wird, während Dispatcher die Callback-Methode der Proxy-Klasse jedes Mal auslöst, wenn auf die lazy geladene Eigenschaft zugegriffen wird.

II. Beispiel:

Definieren Sie zuerst eine Entity-Klasse LoaderBean. Diese Bean hat eine Eigenschaft PropertyBean, die Lazy Loading benötigt.

package com.zghw.cglib; import net.sf.cglib.proxy.Enhancer; public class LazyBean { private String name; private int age; private PropertyBean propertyBean; private PropertyBean propertyBeanDispatcher; public LazyBean(String name, int age) { System.out.println("Lazy-Bean-Initialisierung"); this.name = name; this.age = age; this.propertyBean = createPropertyBean(); this.propertyBeanDispatcher = createPropertyBeanDispatcher(); } /** * Nur beim ersten Mal Lazy Loading * @return */ private PropertyBean createPropertyBean() { /** * Verwenden Sie cglib für Lazy Loading. Fügen Sie dem Objekt, das Lazy Loading benötigt, einen Proxy hinzu. Beim Abrufen der Eigenschaften des Objekts wird das Objekt zuerst über die Callback-Methode der Proxy-Klasse initialisiert. * Wenn das Objekt nicht geladen werden muss, wird das Objekt nicht initialisiert, solange nicht auf die Eigenschaften innerhalb des Objekts zugegriffen wird (in der CGLib-Implementierung wird, solange auf die Getter-Methoden der Eigenschaften des Objekts zugegriffen wird, * der Callback der Proxy-Klasse automatisch ausgelöst).*/ Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(PropertyBean.class); PropertyBean pb = (PropertyBean) enhancer.create(PropertyBean.class, new ConcreteClassLazyLoader()); return pb; } /** * Jedes Mal Lazy Loading * @return */ private PropertyBean createPropertyBeanDispatcher() { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(PropertyBean.class); PropertyBean pb = (PropertyBean) enhancer.create(PropertyBean.class, new ConcreteClassDispatcher()); return pb; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public PropertyBean getPropertyBean() { return propertyBean; } public void setPropertyBean(PropertyBean propertyBean) { this.propertyBean = propertyBean; } public PropertyBean getPropertyBeanDispatcher() { return propertyBeanDispatcher; } public void setPropertyBeanDispatcher(PropertyBean propertyBeanDispatcher) { this.propertyBeanDispatcher = propertyBeanDispatcher; } @Override public String toString() { return "LazyBean [name=" + name + ", age=" + age + ", propertyBean=" + propertyBean + "]"; } }
package com.zghw.cglib; public class PropertyBean { private String key; private Object value; public String getKey() { return key; } public void setKey(String key) { this.key = key; } public Object getValue() { return value; } public void setValue(Object value) { this.value = value; } @Override public String toString() { return "PropertyBean [key=" + key + ", value=" + value + "]" +getClass(); } }
package com.zghw.cglib; import net.sf.cglib.proxy.LazyLoader; public class ConcreteClassLazyLoader implements LazyLoader { /** * Fügen Sie dem Objekt, das Lazy Loading benötigt, einen Proxy hinzu. Beim Abrufen der Eigenschaften des Objekts initialisieren Sie das Objekt zuerst über die Callback-Methode der Proxy-Klasse. * Wenn das Objekt nicht geladen werden muss, wird das Objekt nicht initialisiert, solange nicht auf die Eigenschaften innerhalb des Objekts zugegriffen wird (in CGLibs Implementierung wird, sobald auf die Getter-Methoden der Eigenschaften des Objekts zugegriffen wird, * die Callback-Methode der Proxy-Klasse automatisch ausgelöst).*/ @Override public Object loadObject() throws Exception { System.out.println("vor lazyLoader..."); PropertyBean propertyBean = new PropertyBean(); propertyBean.setKey("zghw"); propertyBean.setValue(new TargetObject()); System.out.println("nach lazyLoader..."); return propertyBean; } }
package com.zghw.cglib; import net.sf.cglib.proxy.Dispatcher; public class ConcreteClassDispatcher implements Dispatcher{ @Override public Object loadObject() throws Exception { System.out.println("vor Dispatcher..."); PropertyBean propertyBean = new PropertyBean(); propertyBean.setKey("xxx"); propertyBean.setValue(new TargetObject()); System.out.println("nach Dispatcher..."); return propertyBean; } }

6. InterfaceMaker - Interface-Generator

I. Funktion:

InterfaceMaker generiert dynamisch eine Schnittstelle, die alle von der angegebenen Klasse definierten Methoden enthält.

II. Beispiel:

package com.zghw.cglib; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.InterfaceMaker; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; public class TestInterfaceMaker { public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { InterfaceMaker interfaceMaker =new InterfaceMaker(); //Extrahiere die Methoden einer Klasse, um Interface-Methoden zu generieren. interfaceMaker.add(TargetObject.class); Class<?> targetInterface=interfaceMaker.create(); for(Method method : targetInterface.getMethods()){ System.out.println(method.getName()); } //Interface-Proxy und Proxy-Interface-Methodeninterzeption festlegen. Object object = Enhancer.create(Object.class, new Class[]{targetInterface}, new MethodInterceptor(){ @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { if(method.getName().equals("method1")){ System.out.println("Filter Methode1 "); return "mmmmmmmmm"; } if(method.getName().equals("method2")){ System.out.println("Filter Methode2 "); return 1111111; } if(method.getName().equals("method3")){ System.out.println("Filter Methode3 "); return 3333; } return "default"; }}); Method targetMethod1=object.getClass().getMethod("method3",new Class[]{int.class}); int i=(int)targetMethod1.invoke(object, new Object[]{33}); Method targetMethod=object.getClass().getMethod("method1",new Class[]{String.class}); System.out.println(targetMethod.invoke(object, new Object[]{"sdfs"})); } }

Ursprüngliche Adresse:

https://blog.csdn.net/zghwaicsdn/article/details/50957474

https://blog.csdn.net/danchu/article/details/70238002