1. Réflexion en java
1. Chargez les attributs de la classe et le code d'instance de méthode via la réflexion:
/ ** * java.lang.class est la source de réflexion * Nous avons créé une classe et généré le fichier de classe correspondant en compilant (javac.exe). Après avoir chargé (chargeur de classe de JVM) ce fichier de classe * Une fois que ce fichier de classe est chargé en mémoire, il s'agit d'une classe d'exécution avec une zone de cache. Cette classe d'exécution est une instance de classe * Chaque classe d'exécution n'est chargée qu'une seule fois, * / class <StudentExam> Clazz = StudentExam.class; StudentExam StudentExam = Clazz.NewInstance (); System.err.println (StudentExam); System.out.println (Clazz); // Field Field = Clazz.getField ("ID"); // Appelez l'attribut spécifié de la classe d'exécution via l'attribut: l'attribut est un champ de type public = Clazz.getDeclaredField ("id"); // L'attribut est champ de type non publique [] fields = Clazz.getDeclaredFields (); // Obtenez toutes les propriétés déclarées de la classe d'exécution elle-même (la classe parent ne peut pas faire). La classe parent utilise Clazz.getFields (); for (Field field2: fields) {int i = field2.getModifiers (); Chaîne type = modificateur.tostring (i); // Obtenez le type de données de champ d'attribut de champ System.out.println (type); } field.setAccessible (true); field.set (StudentExam, 11); System.err.println (StudentExam.getId ()); // Appelez la méthode spécifiée de la classe d'exécution via la méthode de réflexion Méthode = Clazz.getMethod ("SetID", Integer.class); Method.invoke (StudentExam, 123); // Appelez la méthode spécifiée de la méthode de classe d'exécution [] Methods = Clazz.getMethods (); // obtient toutes les méthodes déclarées publiques dans toutes les classes d'exécution et leurs classes de parents Méthode [] Methods2 = Clazz.getDeclaredMethods (); // Obtenez la méthode déclarée dans la classe d'exécution elle-même pour (méthode méthode2: méthodes) {System.out.println (méthode2.getName ()); } // * Obtenez la classe d'exécution de l'objet via la méthode getClass () de l'objet, examen examen = new exam (); Classe CllazzExam = examen.getClass ();2. Classloader
/ ** * Description: Class chargeer, charger le fichier xx.properties et lire les données * @param * @author xiazhongwei * @data 29 septembre 2016: 5:32:56 PM * @return * / public void classloader () lance ioException {// Method 1. Load ClassLoader de l'actuel chargeur de projet = this.getClasse (). GetClass.);); // le chemin est écrit sous le package: com // capable // en lignexam // ressources // config.properties inputStream insimed = loder.getResourceSstream ("config.properties"); // Méthode 2. Chargez le fichier à partir du chemin spécifié // fileInputStream fileInputStream = new FileInputStream (nouveau fichier ("config.properties")); Propriétés Properties = New Properties (); Properties.load (InsideRam); // properties.load (fileInputStream); String prop = propriétés.getProperty ("domaine"); System.out.println (PROP); }3. Proxy dynamique
Proxy statique: les types de classe de proxy et l'objet cible sont déterminés pendant la compilation, qui n'est pas propice à l'expansion du programme. Dans le même temps, chaque classe proxy ne peut servir qu'une seule interface, donc trop de proxy se produiront inévitablement dans le développement de programmes.
Proxy dynamique: le client appelle les méthodes d'autres objets via la classe de proxy et crée dynamiquement l'objet proxy de la classe cible au besoin lorsque le programme est en cours d'exécution.
Principes du modèle de conception des agents:
Utilisez un proxy pour envelopper l'objet, puis remplacez l'objet d'origine par cet objet proxy. Tout appel à l'objet d'origine doit être via le proxy, si et quand l'objet proxy détermine si et quand la méthode est appelée
package com.test.junit; import java.lang.reflect.invocationhandler; import java.lang.reflect.method; import java.lang.reflect.proxy; classe publique proxyTest {public static void main (String [] args) {realSubject realSubject = new realSubject (); MyInvocationHandler MyInvocationHandler = new MyInvocationHandler (); Objet objet = myInvocationHandler.bind (realSubject); Sujet sujet = objet (sujet); sujet.action (); }} // Utilisation de l'interface proxy dynamique Sujet {void Action ();} // class realSubject implémente sujet {@Override public void Action () {System.out.println ("Je suis la classe proxy, n'oubliez pas de me exécuter ..."); }} class MyInvocationHandler implémente invocationhandler {objet objet; // Déclaration de l'objet de la classe proxy de l'interface / ** * Description: ① Instancier l'objet proxy ② Renvoie un objet de classe proxy * @param * @Author Xiazhongwei * @data 29 septembre. = objet; return proxy.newProxyInstance (object.getClass (). getClassLoader (), object.getClass (). getInterfaces (), this); } / ** * Lorsqu'un appel à la méthode réécrit est initié via un objet de la classe proxy, il sera converti en un appel à la méthode invok suivante * / @Override public objet invoke (objet proxy, méthode méthode, objet [] args) lance throws {objet returnObject = Method.Invoke (objet, args); return returnObject; }}4. Proxy dynamique et AOP
Exemple 1.
package com.atguigu.spring.aop; Interface publique 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);} package com.atguigu.spring.aop; import org.springframework.sterereotype.Component; @Component ("ArithmeticCalculator") classe publique arithmeticCalculatorIMPl implémente ArithmeticCalculator {@Override public int Add (int i, int j) {int result = i + j; Résultat de retour; } @Override public int sub (int i, int j) {int result = i - j; Résultat de retour; } @Override public int mul (int i, int j) {int result = i * j; Résultat de retour; } @Override public int div (int i, int j) {int result = i / j; Résultat de retour; }} package com.atguigu.spring.aop; La classe publique arithmeticCalculatorLoggingIMPl implémente ArithmeticCalculator {@Override public int Add (int i, int j) {System.out.println ("La méthode add commence par [" + i + "," + j + "]"); Int result = i + j; System.out.println ("La méthode Ajouter se termine avec" + résultat); Résultat de retour; } @Override public int sub (int i, int j) {System.out.println ("Le sous-sous-subdémarré commence par [" + i + "," + j + "]"); INT Result = i - J; System.out.println ("Le sous-sous-subditestre se termine par" + résultat); Résultat de retour; } @Override public int mul (int i, int j) {System.out.println ("La méthode Mul commence par [" + i + "," + j + "]"); Int result = i * j; System.out.println ("La méthode Mul commence par [" + i + "," + j + "]"); Int result = i * j; System.out.println ("La méthode Mul se termine par" + résultat); Résultat de retour; } @Override public int div (int i, int j) {System.out.println ("La méthode div commence par [" + i + "," + j + "]"); Int result = i / j; System.out.println ("La méthode Div se termine par" + résultat); Résultat de retour; }} package com.atguigu.spring.aop; import java.lang.reflect.invocationhandler; import java.lang.reflect.method; import java.lang.reflect.proxy; import java.util.arrays; classe publique ArithmeticCalculatorLoggingProxy {// Objet à être proxy Private ArithmeticCalculator Target; public arithmeticCalculatorLoggingProxy (arithmeticCalculator Target) {super (); this.target = cible; } // Renvoie l'objet proxy public arithmeticcalculator getLoggingProxy () {arithmeticCalculator proxy = null; // Quel chargeur de classe de l'objet proxy est responsable du chargement de classloader lourdeur = cible.getClass (). GetClassLoader (); // Le type de l'objet proxy, c'est-à-dire quelles méthodes y a-t-il. Classe [] interfaces = new class [] {arithmeticCalculator.class}; // Lorsque vous appelez les méthodes de l'objet proxy, exécutez le code suivant InvocationHandler h = new invocationhandler () {/ ** * proxy: objet proxy. Cet objet n'est généralement pas utilisé * Méthode: La méthode étant appelée * args: les paramètres passés dans la méthode d'appel * / @Override Object Invoke (proxy d'objet, méthode de la méthode, objet [] args) lance Throwsable {// Une méthode de l'objet proxy ne sera pas appelée directement à l'intérieur de la méthode. proxy.toString () amènera une boucle morte à appeler la méthode invoquée méthode méthodyname = méthode.getName (); // Imprime le log System.out.println ("[avant] La méthode" + méthode + "commence par" + arrays.aslist (args)); // Appel de la méthode cible Résultat de l'objet = null; try {// pré-notification result = méthode.invoke (cible, args); // Notification de retour, vous pouvez accéder à la valeur de retour de la méthode} catch (nullpointerException e) {e.printStackTrace (); // Notification d'exception, vous pouvez accéder à l'exception de la méthode} // post-notification. Étant donné que la méthode peut avoir une exception, la valeur de retour de la méthode ne peut pas être consultée // imprimer le log System.out.println ("[après] la méthode se termine par" + résultat); Résultat de retour; }}; / ** * chargeur: le chargeur de classe utilisé par l'objet proxy. * Interfaces: spécifiez le type de l'objet proxy. C'est-à-dire quelles méthodes peuvent être trouvées dans l'objet proxy proxy. * H: Lorsque vous appelez la méthode de l'objet proxy, comment doit-il réagir? En fait, il s'agit d'appeler la méthode invoquée d'invocationHandler * / proxy = (arithmeticcalculator) proxy.newproxyinstance (chargeur, interfaces, h); retour proxy; }} package com.atguigu.spring.aop; import org.springframework.context.applicationContext; import org.springframework.context.support.classpathxmlapplicationcontext; classe publique Main {public static void main (String [] args) {// arithmeticCalculator arithmeticCalculator = new ArithmeticCalculatorImpl (); ArithmeticCalculator ArithmeticCalculator = new ArithmeticCalculatorLoggingImpl (); arithmeticCalculator = new arithmeticCalculatorLoggingProxy (arithmeticCalculator) .getLoggingProxy (); INT Result = ArithmeticCalculator.Add (11, 12); System.out.println ("Résultat:" + Résultat); result = arithmeticCalculator.div (21, 3); System.out.println ("Résultat:" + Résultat); }}Exemple 2.
package com.test.junit; import java.lang.reflect.invocationhandler; import java.lang.reflect.method; import java.lang.reflect.proxy; classe publique proxyTest {public static void main (String [] args) {realSubject realSubject = new realSubject (); MyInvocationHandler MyInvocationHandler = new MyInvocationHandler (); Objet objet = myInvocationHandler.bind (realSubject); Sujet sujet = objet (sujet); sujet.action (); }} // Utilisation de l'interface proxy dynamique Sujet {void Action ();} // class realSubject implémente sujet {@Override public void Action () {System.out.println ("Je suis la classe proxy, n'oubliez pas de me exécuter ..."); }} class MyInvocationHandler implémente invocationhandler {objet objet; // Déclaration de l'objet de la classe proxy de l'interface / ** * Description: ① Instancier l'objet proxy ② Renvoie un objet de classe proxy * @param * @Author Xiazhongwei * @data 29 septembre. = objet; return proxy.newProxyInstance (object.getClass (). getClassLoader (), object.getClass (). getInterfaces (), this); } / ** * Lorsqu'un appel à la méthode réécrit est initié via un objet de la classe proxy, il sera converti en un appel à la méthode invok suivante * / @Override public objet invoke (objet proxy, méthode méthode, objet [] args) lance throws {objet returnObject = Method.Invoke (objet, args); return returnObject; }}Merci d'avoir lu cet article, j'espère que cela pourra vous aider. Merci pour votre soutien à ce site!