Una breve discusión sobre la reflexión y el poder de Java

El mecanismo de reflexión de Java y el proxy dinámico hacen que Java sea más poderosa. Los conceptos principales de Spring IOC y AOP se implementan a través del mecanismo de reflexión y el proxy dinámico.

1 Reflexión de Java

Ejemplo:

 Usuario user = new User (); user.setTime5flag ("prueba"); Class <?> Cls = class.forname ("com.test.user"); // La interfaz debe ser pública, independientemente de si se usa internamente en esta clase! Use cls.getDeclaredMethod () o Traverse para modificar el método de accesibilidad método = cls.getMethod ("getTime5flag"); String res1 = (String) Method.Invoke (usuario); System.out.println (res1); // Si involucra tipos básicos como int, use int.class! Integer.class! = Int.class! método = cls.getMethod ("setTime5Flag", string.class); método.invoke (usuario, "rollen"); método = cls.getmethod ("getTime5flag"); String res2 = (String) Method.Invoke (usuario); System.out.println (res2);

Obtenga el paquete completo y el nombre de clase a través de un objeto:

 user.getClass (). getName (); // nombre de clase de ruta completa user.getClass (). getSimplename (); // nombre de clase sin nombre de paquete

Obtener clase:

 Class.forname ("com.test.user"); com.test.user.class; user.getclass ();

Instanciar un objeto a través de la clase

 Usuario user = (usuario) cls.newinstance (); // debe haber un constructor de parámetros

Obtener todos los constructores

 Constructor <?> cons [] = cls.getConstructors (); // devolver contraciones [0] .newinstance () en orden de declaración; // Sin declaración de visualización, entonces hay un constructor predeterminado

Obtenga todas las interfaces implementadas por una clase

 Class <?> Intes [] = cls.getInterfaces ();

Obtenga la clase madre

 cls.getSuperClass ();

Obtener el modificador

 int mo = cls.getModifiers (); int mo = cons [0] .getModifiers (); int mo = método.getModifiers (); modificador.toString (mo);

Obtener parámetros de método

 método.getParameters (); Cons [0] .getParameters ();

Tipo de parámetro GET METODO

 Method.getParametortyPes (); Cons [0] .getParametortyPes ();

Obtenga todos los tipos de excepción lanzados por la declaración del método

 método.getExceptionTypes ();

Obtenga todas las propiedades declaradas en esta clase

 Campo [] campo = cls.getDeclaredfields (); // incluye privatefield [0] .getModifiers (); campo [0] .gettype ();

Obtenga todos los atributos públicos de esta clase, incluida la declaración de clase principal, la declaración de interfaz y todos los atributos públicos de esta declaración de clase

 cls.getfields ();

Establecer el atributo especificado para acceder

 campo.setAccessible (true); field.set (obj, 'ces'); field.get (obj);

* La diferencia entre getFields () y getDeclaredfields (): getFields () solo puede acceder a los campos declarados como público en la clase. No puede acceder a campos privados y puede acceder a campos públicos heredados de otras clases. GetDeclaredfields () puede acceder a todos los campos de la clase, que no tienen nada que ver con público, privado y protegido, pero no puede acceder a campos heredados de otras clases.

* La diferencia entre getMethods () y getDeclaredMethods (): getMethods () solo puede acceder a los métodos declarados como público en la clase, y no se puede acceder a los métodos privados, y no se puede acceder a los métodos públicos heredados de otras clases; getDeclaredMethods () puede acceder a todos los campos de la clase, que no tienen nada que ver con público, privado y protegido, y no puede acceder a los métodos heredados de otras clases.

* La diferencia entre getConstructors () y getDeclaredConstructors (): getConstructors () solo puede acceder a los constructores declarados como públicos en la clase; GetDeclaredConstructors () puede acceder a todos los constructores de la clase, y no tiene nada que ver con público, privado y protegido.

Obtenga y modifique la información de la matriz a través de la reflexión

 int [] temp = {1,2,3,4,5}; class <?> demo = temp.getClass (). getComponentType (); System.out.println ("Tipo de matriz:"+Demo.getName ()); // Intsystem.out.Println ("Longitud de matriz:: "+Array.getLength (temp)); // 5system.out.println (" El primer elemento de la matriz: "+array.get (temp, 0)); // 1array.set (temp, 0, 100); system.out.println (" El primer elemento de la matriz después de la modificación es: "+array.get (temp, 0); // 100

Obtenga el tipo de matriz

 cls.getComponentType ();

Determinar si es un tipo de matriz

 cls.isArray ();

2 agente de Java

El modelo proxy es un modelo de diseño Java de uso común. Su característica es que la clase proxy y la clase delegada tienen la misma interfaz. La clase proxy es el principal responsable del preprocesamiento de mensajes, filtrando mensajes, enviando mensajes a la clase delegada y procesar mensajes después del evento. Por lo general, hay una asociación entre la clase proxy y la clase delegada. El objeto de una clase proxy está asociado con el objeto de una clase delegada. El objeto de la clase proxy en sí no implementa realmente el servicio, sino que proporciona servicios específicos llamando a los métodos relevantes del objeto de clase delegada.

Según el período de creación de agentes, las clases de agentes se pueden dividir en dos tipos.

• Proxy estático: creado por programadores o genera automáticamente el código fuente por herramientas específicas y luego lo compila. Antes de que se ejecute el programa, el archivo .class de la clase proxy ya existe.

• Proxy dinámico: cuando el programa se está ejecutando, el bytecode se genera dinámicamente por el mecanismo de reflexión Java.

2.1 proxy estático

 Conteo de interfaz pública {public void QueryCount ();} public class CountImpl implements Count {public void QueryCount () {System.out.println ("Ver método de cuenta ..."); }} // clase de proxy public class countProxy implements count {private countImpl countImpl; public CountProxy (CountImpl CountImpl) {this.countImpl = CountImpl; } @Override public void QueryCount () {System.out.println ("Antes del procesamiento de transacciones"); CountImpl.QueryCount (); // llamar al método de clase delegada; System.out.println ("después del procesamiento de transacciones"); }} // Test Class public class TestCount {public static void main (string [] args) {countIpl countImpl = new CountImpl (); CountProxy countProxy = new CountProxy (CountImpl); countProxy.QueryCount (); }}

Observe el código y descubra que cada clase de proxy solo puede servir una interfaz, de modo que se producirá inevitablemente demasiados proxy en el desarrollo del programa. Además, todas las operaciones proxy, excepto los diferentes métodos de llamada, todas las demás operaciones son las mismas, por lo que el código debe repetirse en este momento. La mejor manera de resolver este problema es completar todas las funciones proxy a través de una clase de proxy, por lo que debe hacerse utilizando proxy dinámico en este momento.

2.2 Agente dinámico

El código bytecodo de la clase proxy dinámica es generado dinámicamente por el mecanismo de reflexión Java cuando se ejecuta el programa, sin la necesidad de que los programadores escriban su código fuente manualmente. Las clases de proxy dinámicas no solo simplifican la programación, sino que también mejoran la escalabilidad de los sistemas de software, porque el mecanismo de reflexión Java puede generar cualquier tipo de clases de proxy dinámicas.

2.2.1 JDK proxy dinámico

La clase Proxy e InvocationHandler interfaces en el paquete java.lang.reflect proporcionan la capacidad de generar clases de proxy dinámicas.

Interfaz InvocationHandler:

interfaz pública InvocationHandler {
Public Object Invoke (proxy de objeto, método de método, objeto [] args) lanza luneable;
}

Descripción del parámetro:

Proxy del objeto: se refiere al objeto que se proxyan.
Método Método: el método a llamar
Objeto [] args: los parámetros requeridos al llamar al método

Puede pensar en una subclase de la interfaz Invocathandler como la clase de operación final de un proxy, reemplazando el proxysubject.

Clase proxy:

La clase proxy es una clase de operación que se especializa en el proxy. Puede generar dinámicamente clases de implementación para una o más interfaces a través de esta clase. Esta clase proporciona los siguientes métodos de operación:

Objeto estático público NewProxyInstance (ClassLoader Loader, Clase <?> [] Interfaces, InvocationHandler h) Lanza ilegalargumentException

Descripción del parámetro:

Cargador de cargadores de clases: cargador de clases
Clase <?> [] Interfaces: Obtenga todas las interfaces
InvocationHandler H: Obtener una instancia de subclase de InvocationHandler Interface

Si desea completar un proxy dinámico, primero debe definir una subclase de la interfaz InvocationHandler para completar la operación específica del proxy.

 Interface Sujeto {public String Says (String Name, Int Age);} class RealSubject implementa sujeto {@Override public String Says (String Name, Int Age) {Return Name + "" + Age; }} // JDK Dynamic Proxy Clase MyInVocationHandler implementa InvocationHandler {private Object Target = null; // Atrae el objeto delegado y devuelva un enlace de objeto público de clase proxy (objetivo de objeto) {esto. Target = Target; return proxy.newproxyInstance (target.getClass (). getClassLoader (), target.getClass (). getInterfaces (), this); // Atar la interfaz (CGLIB compensa para esto)} @Override Public Object Invoke (Object Proxy, Method Method, Object [] Args) lanza {System.out.println ("¡Antes del método!"); Objeto temp = Method.Invoke (Target, Args); System.out.println ("After Method!"); regresar temp; }} clase Hello {public static void main (string [] args) {myInVocationHandler demo = new MyInVocationHandler (); Sujeto sub = (sujeto) demo.bind (new RealSubject ()); String info = sub.say ("rollen", 20); System.out.println (info); }}

Sin embargo, el proxy dinámico de JDK se basa en la implementación de la interfaz. Si algunas clases no implementan interfaces, no pueden usar el proxy JDK, por lo que deben usar el proxy dinámico CGLIB.

2.2.2 proxy dinámico CGLIB

El mecanismo de proxy dinámico de JDK solo puede proxy clases que implementan interfaces, mientras que las clases que no implementan interfaces no pueden implementar el proxy dinámico de JDK.

CGLIB implementa proxy para clases. Su principio es generar una subclase para la clase de destino especificada y anular la mejora de la implementación del método. Sin embargo, debido a que se usa la herencia, la clase modificada final no puede ser proxyedas.

 Public Interface BookFacade {public void addbook (); } public class BookFacadeImpl1 {public void addbook () {System.out.println ("Método ordinario para agregar libros ..."); }} import java.lang.reflect.method; importar net.sf.cglib.proxy.enhancer; importar net.sf.cglib.proxy.methodinterceptor; importar net.sf.cglib.proxy.methodproxy; // CGLIB Dynamic Proxy Clase Public Class BookFacadeCglib implementa MethodInterceptor {objetivo de objeto privado; // Atrae el objeto delegado y devuelva una clase de proxy Public Object getInstance (objetivo de objeto) {this.target = target; Potencador potencador = nuevo mejor (); potencer.setsuperClass (this.target.getclass ()); // Método de devolución de llamada potencador.setCallback (esto); // Crea proxy Object Return Former.create (); } @Override // Método de devolución de llamada Intercept (Object OBJ, Método, Método, Object [] Args, MethodProxy Proxy) lanza {System.out.println ("Function Start"); Objeto temp = proxy.invokesuper (obj, args); System.out.println ("Function End"); regresar temp; }} public class testCglib {public static void main (string [] args) {bookFacadeCglib cglib = new BookFacadeCglib (); BookFacadeImpl1 bookcglib = (bookFacadeImpl1) cglib.getInstance (nuevo bookFacadeImpl1 ()); bookcglib.addbook (); }}

La breve discusión anterior sobre la reflexión y el poder de Java es todo el contenido que comparto con ustedes. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.