1. Reflexión en Java
1. Cargue los atributos y el código de instancia del método de la clase a través de la reflexión:
/*** java.lang.class es la fuente de reflexión* Creamos una clase y generamos el archivo de clase correspondiente compilando (javac.exe). Después de cargar (cargador de clase de JVM) este archivo de clase* Después de cargar este archivo de clase en la memoria, es una clase de tiempo de ejecución con un área de caché. Esta clase de tiempo de ejecución es una instancia de clase * Cada clase de tiempo de ejecución solo se carga una vez, */ clase <deudentExam> clazz = studentExam.class; StudentExam StudentExam = clazz.newinstance (); System.err.println (StudentExam); System.out.println (Clazz); // campo campo = clazz.getfield ("id"); // Llame al atributo especificado de la clase de tiempo de ejecución a través del atributo: el atributo es el campo de tipo público campo = clazz.getDeclaredField ("id"); // El atributo es campo de tipo no público [] campos = clazz.getDeclaredfields (); // Obtenga todas las propiedades declaradas de la clase de tiempo de ejecución (la clase principal no puede hacer). La clase principal usa Clazz.getFields (); for (campo Field2: Fields) {int i = field2.getModifiers (); String type = modifier.ToString (i); // Obtenga el tipo de datos de atributo de campo System.out.println (type); } campo.setAccessible (verdadero); campo.set (StudentExam, 11); System.err.println (studentExam.getId ()); // llame al método especificado de la clase de tiempo de ejecución a través del método de reflexión método = clazz.getMethod ("setid", integer.class); Method.Invoke (StudentExam, 123); // Llame al método especificado del método de clase de tiempo de ejecución [] métodos = clazz.getMethods (); // Obtenga todos los métodos declarados como público en todas las clases de tiempo de ejecución y su método de clases de padres [] métodos2 = clazz.getDeClaredMethods (); // Obtenga el método declarado en la clase de tiempo de ejecución en sí para (método Method2: Methods) {System.out.println (método2.getName ()); } // * Obtenga la clase de tiempo de ejecución del objeto a través del método getClass () del objeto, examen examen = new Exam (); Clase ClazzExam = Exam.getClass ();2. Classloader
/** * Descripción: Class Loader, cargue el archivo xx.properties y lea los datos * @param * @author xiazhongwei * @data 29 de septiembre de 2016: 5:32:56 pm * @@return */public void classLoader () lanza ioexception {// método 1. Carga de clases de carga de la carga del proyecto = this.getClass (). // La ruta está escrita en el paquete: com // sable // onlineexam // recursos // config.properties inputStream Insteam = Loader.getResourceasStream ("config.properties"); // Método 2. Cargue el archivo en la ruta especificada // fileInputStream fileInputStream = new FileInputStream (nuevo archivo ("config.properties")); Propiedades Propiedades = New Properties (); Properties.Load (InSteam); // Properties.load (fileInputStream); Cadena prop = Properties.getProperty ("dominio"); System.out.println (Prop); }3. Proxy dinámico
Proxy estático: los tipos de la clase proxy y el objeto objetivo se determinan durante la compilación, que no conduce a la expansión del programa. Al mismo tiempo, cada clase de proxy solo puede servir una interfaz, por lo que se producirá inevitablemente en el desarrollo del programa.
Proxy dinámico: el cliente llama a los métodos de otros objetos a través de la clase proxy, y crea dinámicamente el objeto proxy de la clase de destino según sea necesario cuando el programa se está ejecutando.
Principios del patrón de diseño del agente:
Use un proxy para envolver el objeto y luego reemplace el objeto original con ese objeto proxy. Cualquier llamada al objeto original debe ser a través del proxy, si el objeto proxy determina si el método se llama y cuándo se llama
paquete com.test.junit; import 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 (); Objeto objeto = myInVocationHandler.bind (RealSubject); Sujeto sujeto = (sujeto) objeto; Sujeto.Action (); }} // Uso de la interfaz proxy dinámica sujeto {void action ();} // class RealSubject implementa sujeto {@Override public void Action () {System.out.println ("Soy la clase proxy, recuerda ejecutarme ..."); }} clase MyInVocationHandler implementa InvocationHandler {Object Object; // Declaración del objeto de la clase proxy de la interfaz/ ** * Descripción: ① Instancia del objeto proxy ② return a proxy class object * @param * @author xiazhongwei * @data 29 de septiembre, 2016: 4:13:43 pm * @return */ público público objeto (objeto) {objeto) objeto; return proxy.newproxyInstance (object.getClass (). getClassLoader (), object.getClass (). getInterfaces (), this); } / ** * Cuando se inicia una llamada al método reescrito a través de un objeto de la clase proxy, se convertirá en una llamada al siguiente método Invok * / @Override Public Object Invoke (Object Proxy, Method Method, Object [] Args) lanza lando {objeto returnObject = método.invoke (objeto, args); return returnObject; }}4. Proxy dinámico y AOP
Ejemplo 1.
paquete com.atguigu.spring.aop; interfaz pública 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);} paquete com.atguigu.spring.aop; importar org.springframework.stereotype.component; @Component ("arithmeticcalculator") clase pública arithmeticcalculatorImpl implementa arithmeticcalculator {@override public int add (int i, int j) {int resultado = i + j; resultado de retorno; } @Override public int sub (int i, int j) {int result = i - j; resultado de retorno; } @Override public int mul (int i, int j) {int result = i * j; resultado de retorno; } @Override public int div (int i, int j) {int result = i / j; resultado de retorno; }} paquete com.atguigu.spring.aop; Public Class arithmeticCalculatorLoggingImpl implementa arithmeticcalculator {@Override public int add (int i, int j) {system.out.println ("El método AGREGAR comienza con [" + i + "," + j + "]"); int resultado = i + j; System.out.println ("El método agrega termina con" + resultado); resultado de retorno; } @Override public int sub (int i, int j) {System.out.println ("El subs de método comienza con [" + i + "," + j + "]"); int resultado = i - j; System.out.println ("El método sub termina con" + resultado); resultado de retorno; } @Override public int mul (int i, int j) {System.out.println ("El método MUL comienza con [" + i + "," + j + "]"); int resultado = i * j; System.out.println ("El método MUL comienza con [" + i + "," + j + "]"); int resultado = i * j; System.out.println ("El método MUL termina con" + resultado); resultado de retorno; } @Override public int div (int i, int j) {system.out.println ("El método div comienza con [" + i + "," + j + "]"); int resultado = i / j; System.out.println ("El método Div termina con" + resultado); resultado de retorno; }} paquete com.atguigu.spring.aop; import java.lang.reflect.invocationHandler; import java.lang.reflect.method; import java.lang.reflect.proxy; import java.util.arrays; clase pública aritmeticcalculatorLoggingProxy {// Object para ser proxy objetivo privado aritmeticcalculator; Public aritmeticcalculatorLoggingProxy (aritmeticcalculator objetivo) {super (); this.target = Target; } // Devuelve el objeto proxy público arithmeticcalculator getloggingproxy () {arithmeticcalculator proxy = null; // Qué cargador de clase del objeto proxy es responsable de cargar classloader carger = target.getClass (). GetClassLoader (); // El tipo de objeto proxy, es decir, qué métodos hay en él. Class [] interfaces = new class [] {arithmeticcalculator.class}; // Al llamar a los métodos del objeto proxy, ejecute el siguiente código invocationHandler h = new InvocationHandler () { /*** proxy: objeto proxy. Este objeto generalmente no se usa* Método: el método se llama* Args: los parámetros pasados en el método de llamada*/ @Override Public Object Invoke (Proxy de objeto, método Método, objeto [] args) lanza lando {// Un método del objeto proxy no se llamará directamente dentro del método. proxy.ToString () hará que un bucle muerto llame al método de invocación de string metodName = método.getName (); // Imprima el registro System.out.println ("[Antes] el método" + MethodName + "comienza con" + Arrays.aslist (args)); // llamando al objeto del método de destino resultado = nulo; intente {// pre-notificación resultado = método.invoke (target, args); // Notificación de retorno, puede acceder al valor de retorno del método} Catch (NullPointerException e) {E.PrintStackTrace (); // Notificación de excepción, puede acceder a la excepción del método} // post-notificación. Debido a que el método puede tener una excepción, no se puede acceder al valor de retorno del método // imprimir registro de registro.out.println ("[Después] el método termina con" + resultado); resultado de retorno; }}; /*** cargador: el cargador de clase utilizado por el objeto proxy. * Interfaces: especifique el tipo de objeto proxy. Es decir, qué métodos se pueden encontrar en el objeto proxy proxy. * H: Al llamar al método del objeto proxy, ¿cómo debe responder? De hecho, es llamar al método Invoke de InvocationHandler*/ proxy = (arithmeticcalculator) proxy.newproxyInstance (cargador, interfaces, h); Return proxy; }} paquete com.atguigu.spring.aop; importar org.springframework.context.applicationContext; import org.springframework.context.support.classpathxmlaPplicationContext; clase pública Main {public static void main (string [] args) {// aritmeticcalculator arithmeticcalculator = new arithmeticCalculatorImpl (); Aritmeticcalculator aritmeticcalculator = new arithmeticcalculatorLoggingImpl (); aritmeticcalculator = nuevo aritmeticcalculatorLoggingProxy (aritmeticcalculator) .getLoggingProxy (); int resultado = aritmeticcalculator.add (11, 12); System.out.println ("resultado:" + resultado); resultado = aritmeticcalculator.div (21, 3); System.out.println ("resultado:" + resultado); }}Ejemplo 2.
paquete com.test.junit; import 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 (); Objeto objeto = myInVocationHandler.bind (RealSubject); Sujeto sujeto = (sujeto) objeto; Sujeto.Action (); }} // Uso de la interfaz proxy dinámica sujeto {void action ();} // class RealSubject implementa sujeto {@Override public void Action () {System.out.println ("Soy la clase proxy, recuerda ejecutarme ..."); }} clase MyInVocationHandler implementa InvocationHandler {Object Object; // Declaración del objeto de la clase proxy de la interfaz/ ** * Descripción: ① Instancia del objeto proxy ② return a proxy class object * @param * @author xiazhongwei * @data 29 de septiembre, 2016: 4:13:43 pm * @return */ público público objeto (objeto) {objeto) objeto; return proxy.newproxyInstance (object.getClass (). getClassLoader (), object.getClass (). getInterfaces (), this); } / ** * Cuando se inicia una llamada al método reescrito a través de un objeto de la clase proxy, se convertirá en una llamada al siguiente método Invok * / @Override Public Object Invoke (Object Proxy, Method Method, Object [] Args) lanza lando {objeto returnObject = método.invoke (objeto, args); return returnObject; }}Gracias por leer este artículo, espero que pueda ayudarlo. ¡Gracias por su apoyo para este sitio!