1. Reflexion in Java
1. Laden Sie die Attribute und den Methodeninstanzcode der Klasse durch Reflexion:
/*** java.lang.class ist die Quelle der Reflexion* Wir haben eine Klasse erstellt und die entsprechende Klassendatei durch Kompilieren (javac.exe) generiert. Nachdem wir diese Klassendatei* geladen haben (JVMs Klassenload), nachdem diese Klassendatei in den Speicher geladen wurde, handelt es sich um eine Laufzeitklasse mit einem Cache -Bereich. Diese Laufzeitklasse ist eine Instanz der Klasse * Jede Laufzeitklasse wird nur einmal geladen, */ Klasse <StudentExam> clazz = studentExam.class; StudentExam studentExam = clazz.newinstance (); System.err.println (studentExam); System.out.println (Clazz); // field field = clazz.getfield ("id"); // Rufen Sie das angegebene Attribut der Laufzeitklasse über das Attribut an: Das Attribut ist das Field Field = clazz.getDeclaredfield ("ID"). // Das Attribut ist nicht öffentliches Feld [] fields = clazz.getDeclaredfields (); // Erhalten Sie alle deklarierten Eigenschaften der Laufzeitklasse selbst (die übergeordnete Klasse kann nicht). Die übergeordnete Klasse verwendet Clazz.getFields (); für (Field Field2: Felder) {int i = field2.getModifiers (); String type = modifier.toString (i); // den Datentyp des Feldattributs system.out.println (Typ) abrufen; } field.setAccessible (true); Field.Set (studentExam, 11); System.err.println (studentExam.getId ()); // rufen Sie die angegebene Methode der Laufzeitklasse über die Reflexionsmethode auf = clazz.getMethod ("setID", Integer.class); method.invoke (studentExam, 123); // rufen Sie die angegebene Methode der Laufzeitklassenmethode auf [] methods = clazz.getMethods (); // Alle Methoden in allen Laufzeitklassen und deren übergeordneten Klassen Methode [] methods2 = clazz.getDeclaredMethods () erhalten; // Die in der Laufzeitklasse selbst deklarierte Methode selbst für (Methode Methode2: Methoden) {System.out.println (methode2.getName ()); } // * Die Laufzeitklasse des Objekts über die Methode getClass () des Objekts, Prüfung Prüfung = New Exam () erhalten; Klasse clazzexam = Prüfung.getClass ();2. Klassenloader
/** * Beschreibung: Klassenloader, laden Sie die XX.Properties -Datei und lesen Sie die Daten * @param * @author xiazhongwei * @data 29. September 2016: 5:32:56 PM * @Return */public void classLader () lodert IOException {// methode 1. // Der Pfad wird unter dem Paket geschrieben: com // fan // onlineexam // ressourcen // config.properties inputStream instream = lader.getResourceAsStream ("config.Properties"); // Methode 2. Laden Sie die Datei aus dem angegebenen Pfad // FileInputStream FileInputStream = New FileInputStream (neue Datei ("config.Properties")); Eigenschaften Eigenschaften = neue Eigenschaften (); Eigenschaften.Load (Instreme); // Properties.load (FileInputStream); String prop = properties.getProperty ("Domain"); System.out.println (Prop); }3. Dynamischer Proxy
Statische Proxy: Die Arten der Proxy -Klasse und des Zielobjekts werden während der Zusammenstellung bestimmt, was der Ausdehnung des Programms nicht förderlich ist. Gleichzeitig kann jede Proxy -Klasse nur eine Schnittstelle bedienen, sodass in der Programmentwicklung zwangsläufig zu viele Stellvertreter auftreten.
Dynamischer Proxy: Der Client fordert Methoden anderer Objekte über die Proxy -Klasse auf und erstellt das Proxy -Objekt der Zielklasse dynamisch nach Bedarf, wenn das Programm ausgeführt wird.
Prinzipien des Agentenentwurfsmusters:
Verwenden Sie einen Proxy, um das Objekt zu wickeln, und ersetzen Sie das ursprüngliche Objekt dann durch dieses Proxy -Objekt. Ein Aufruf des ursprünglichen Objekts muss über den Proxy erfolgen, ob und wann das Proxy -Objekt bestimmt, ob und wann die Methode aufgerufen wird
Paket com.test.junit; importieren java.lang.reflect.invocationHandler; import java.lang.reflect.method; import Java.lang.reflect.proxy; public class ProxyTest {public static void main (String [] args) {RealSubject realSubject = new RealSubject (); MyInvocationHandler myInvocationHandler = new myInvocationHandler (); Object Object = myInvocationHandler.bind (realSubject); Subjekt = (Subjekt) Objekt; Betreff.Action (); }} // Verwendung der dynamischen Proxy -Schnittstelle Subjekt {void action ();} // Klasse RealSubject implementiert Betreff {@Override public void action () {System.out.println ("Ich bin die Proxy -Klasse, denken Sie daran, mich auszuführen ..."); }} class MyInvocationHandler implementiert InvocationHandler {Objektobjekt; // Deklaration des Objekts der Proxy -Klasse der Schnittstelle/ ** * Beschreibung: ① Instanziierung des Proxy -Objekts ② Rückgabe eines Proxy -Klasse -Objekts * @param * @Author xiazhongwei * @data. this.Object = Objekt; return proxy.newproxyinstance (Object.getClass (). getClassloader (), Object.getClass (). getInterfaces (), this); } / ** * Wenn ein Aufruf an die umgeschriebene Methode über ein Objekt der Proxy -Klasse initiiert wird, wird er in einen Aufruf zur folgenden Invok -Methode konvertiert * / @Override öffentliches Objekt invoke (Object Proxy, Methode Methode, Object [] args) wirft Throwable {Object returnObject = method.invoke (Objekt, args, args) aus; return returnObject; }}4. Dynamischer Proxy und AOP
Beispiel 1.
Paket com.atguigu.spring.aop; public interface arithmeticcalculator {int add (int i, int j); int sub (int i, int j); int mul (int i, int j); int div (int i, int j);} Paket com.atguigu.spring.aop; import org.springframework.stereotype.comPonent; @Component ("ArithmeticCalculator") public Class ArithmeticCalculatorImpl implementiert ArithmeticCalculator {@Override public int add add (int i, int j) {int result = i + j; Rückgabeergebnis; } @Override public int sub (int i, int j) {int result = i - j; Rückgabeergebnis; } @Override public int mul (int i, int j) {int result = i * j; Rückgabeergebnis; } @Override public int div (int i, int j) {int result = i / j; Rückgabeergebnis; }} Paket com.atguigu.spring.aop; public class ArithmeticCalculatorLoggingImpl implementiert ArithmeticCalculator {@Override public int add (int i, int j) {System.out.println ("Die Methode add beginnt mit [" + i + "," + j + "]); int result = i + j; System.out.println ("Die Methode addieren mit" + Ergebnis); Rückgabeergebnis; } @Override public int sub (int i, int j) {System.out.println ("Die Methode sub beginnt mit [" + i + "," + j + "]"); int result = i - j; System.out.println ("Die Methode endet mit" + Ergebnis); Rückgabeergebnis; } @Override public int mul (int i, int j) {System.out.println ("Die Methode mul beginnt mit [" + i + "," + j + "]"); int result = i * j; System.out.println ("Die Methode MUL beginnt mit [" + i + "," + j + "]"); int result = i * j; System.out.println ("Die Methode mul endet mit" + Ergebnis); Rückgabeergebnis; } @Override public int div (int i, int j) {System.out.println ("Die Methode Div beginnt mit [" + i + "," + j + "]"); int result = i / j; System.out.println ("Die Methode div endet mit" + Ergebnis); Rückgabeergebnis; }} Paket com.atguigu.spring.aop; importieren java.lang.reflect.invocationHandler; import java.lang.reflect.method; import Java.lang.reflect.proxy; Import Java.util.Arrays; public class arithmeticcalculatorloggingProxy {// Objekt als Proxy Private Arithmeticcalculator Ziel; public arithmeticcalculatorloggingProxy (Arithmeticcalculator -Ziel) {Super (); this.target = Ziel; } // Rückgabe des Proxy -Objekts public arithmeticCalculator getLoggingProxy () {ArithmeticCalculator proxy = null; // Welcher Klassenlader des Proxy -Objekts ist für das Laden von Classloader loader = target.getClass () verantwortlich. GetClassloader (); // Die Art des Proxy -Objekts, dh welche Methoden sind darin. Class [] interfaces = new class [] {arithmeticcalculator.class}; // Führen Sie beim Aufrufen der Methoden des Proxy -Objekts den folgenden Code -InvocationHandler H = New InvocationHandler () { /*** Proxy: Proxy -Objekt aus. Dieses Objekt wird im Allgemeinen nicht verwendet. proxy.toString () führt dazu, dass eine tote Schleife die Invoke -Methode -String -Methode aufrufen kann. Method.getName (); // Drucken Sie das log system.out.println ("[vor] die Methode" + MethodName + "mit" + arrays.aslist (args)); // Aufrufen des Zielmethodeobjekts Ergebnis = NULL; Versuchen Sie {// Vorabmesserergebnis = methode.invoke (Ziel, Argumente); // Return -Benachrichtigung können Sie auf den Rückgabewert der Methode zugreifen} catch (nullPointerexception e) {e.printstacktrace (); // Ausnahmebenachrichtigung können Sie auf die Ausnahme der Methode zugreifen} // Post-Notifikation. Da die Methode möglicherweise eine Ausnahme aufweist, kann der Rückgabewert der Methode nicht zugegriffen werden // Log System.out.println ("[Nach] die Methode endet mit" + Ergebnis "); Rückgabeergebnis; }}; /*** Loader: Der Klassenlader, der vom Proxy -Objekt verwendet wird. * Schnittstellen: Geben Sie den Typ des Proxy -Objekts an. Das heißt, welche Methoden finden Sie im Proxy -Proxy -Objekt. * H: Wie sollte es beim Aufrufen der Methode des Proxy -Objekts reagieren? In der Tat soll die Invoke -Methode des Invoke -Handlers*/ proxy = (Arithmeticcalculator) proxy.newProxyInstance (Loader, Schnittstellen, H) aufrufen; Proxy zurückgeben; }} Paket com.atguigu.spring.aop; import org.springframework.context.applicationContext; import org.springframework.context.support.classPathxMlApplicationContext; public class main {public static void main (String [] args) {// Arithmeticcalculator Arithmeticcalculator = new ArithmeticcalculatorImpl (); Arithmeticcalculator Arithmeticcalculator = New ArithmeticcalculatorLoggingImpl (); arithmeticcalculator = neuer arithmetikcalculatorloggingProxy (Arithmeticcalculator) .GetLoggingProxy (); int result = arithmeticcalculator.add (11, 12); System.out.println ("Ergebnis:" + Ergebnis); result = arithmeticcalculator.div (21, 3); System.out.println ("Ergebnis:" + Ergebnis); }}Beispiel 2.
Paket com.test.junit; importieren java.lang.reflect.invocationHandler; import java.lang.reflect.method; import Java.lang.reflect.proxy; public class ProxyTest {public static void main (String [] args) {RealSubject realSubject = new RealSubject (); MyInvocationHandler myInvocationHandler = new myInvocationHandler (); Object Object = myInvocationHandler.bind (realSubject); Subjekt = (Subjekt) Objekt; Betreff.Action (); }} // Verwendung der dynamischen Proxy -Schnittstelle Subjekt {void action ();} // Klasse RealSubject implementiert Betreff {@Override public void action () {System.out.println ("Ich bin die Proxy -Klasse, denken Sie daran, mich auszuführen ..."); }} class MyInvocationHandler implementiert InvocationHandler {Objektobjekt; // Deklaration des Objekts der Proxy -Klasse der Schnittstelle/ ** * Beschreibung: ① Instanziierung des Proxy -Objekts ② Rückgabe eines Proxy -Klasse -Objekts * @param * @Author xiazhongwei * @data. this.Object = Objekt; return proxy.newproxyinstance (Object.getClass (). getClassloader (), Object.getClass (). getInterfaces (), this); } / ** * Wenn ein Aufruf an die umgeschriebene Methode über ein Objekt der Proxy -Klasse initiiert wird, wird er in einen Aufruf zur folgenden Invok -Methode konvertiert * / @Override öffentliches Objekt invoke (Object Proxy, Methode Methode, Object [] args) wirft Throwable {Object returnObject = method.invoke (Objekt, args, args) aus; return returnObject; }}Vielen Dank, dass Sie diesen Artikel gelesen haben, ich hoffe, er kann Ihnen helfen. Vielen Dank für Ihre Unterstützung für diese Seite!