Reflexión de Java simplificada

17 de septiembre de 2018

Tabla de contenido

Reflexión de Java simplificada

JavadereflexiónPresentamos una clase de utilidad que le permite utilizar fácilmente la API.

¿Qué es la reflexión?

API de reflexióndientes,"java.lang.reflect"incluido en el paquete,
Esta es una API que recupera información como campos y métodos de clases Java.
Se utilizan principalmente las siguientes clases.

clase java.lang.
java.lang.reflect.Constructor
java.lang.reflect.Método
java.lang.reflect.Field

reflexiónAl utilizar , puede crear clases o llamar a métodos sin tener que codificarlos directamente.
Puede crear una instancia de clase a partir de una cadena o ejecutar un método.

Al escribir las definiciones de nombres de clases y nombres de métodos en archivos externos como XML, puede adaptar dinámicamente la aplicación a los cambios en el entorno durante el tiempo de ejecución.
También es una API muy eficaz para crear aplicaciones muy flexibles.

Propósito de la reflexión

reflexiónlos usuarios no suelen utilizarlo directamente,
Se usa ampliamente en aplicaciones web como Struts y marcos como el mapeo O/R.

Por ejemplo, al configurar automáticamente los datos de entrada de la pantalla web en las propiedades de JavaBeans,
Se utiliza al emitir SQL que se actualiza automáticamente en función de las propiedades de JavaBeans.

Además, están disponibles funciones como cargar y registrar complementos dinámicamente que amplían la funcionalidad cuando se inicia la aplicación.reflexiónEsto se puede lograr fácilmente usando .

Ejecutando la muestra

Ejecute la muestra y experimente la programación similar a un marco.

Aquí usamos la siguiente clase.reflexiónDemuestra un uso simple de la utilidad.

principal.java...Clase a ejecutar
BeanUtil.java...Clase de utilidad de reflexión
FreeSoft.java...Usado como reflexión en una clase que representa el software libre.

●Cuando se ejecuta normalmente

System.out.println(“＞＞＞Caso normal”);
FreeSoft freeSoft = nuevo FreeSoft();
freeSoft.setNombre(“¡Chat y Messenger, Chat y Messenger!!”);
freeSoft.showName();
freeSoft.showPrice(0);

●Cuando se ejecuta utilizando la reflexión

System.out.println(“＞＞＞Cuando se usa la reflexión”);
//Crear una instancia de la clase FreeSoft
Objeto invocarObjeto = BeanUtil.newInstance(“LibreSoft”);
//Establece el valor en el campo de nombre.
BeanUtil.setProperty(invocarObjeto, "nombre" , “¡¡Chat y Messenger Chat y Messenger!!”);
// Ejecuta el método showName() de FreeSoft.
BeanUtil.invoke(invocarObjeto, "mostrar nombre", nulo);
// Ejecuta el método showPrice() de FreeSoft.
// Si el método tiene argumentos, deben pasarse como una matriz de tipo Objeto.
BeanUtil.invoke(invocarObjeto, “mostrarPrecio”,nuevo Objeto[]{nuevo Entero(0)});

●Resultados de ejecución

Los resultados de la ejecución son los mismos ya sea en el caso normal o cuando se utiliza la reflexión.

>>> Caso normal

Nombre del software: Chat&Messenger ¡Chat y messenger! !

Precio: 0 yenes

>>> Cuando se utiliza la reflexión

Nombre del software: Chat&Messenger ¡Chat y messenger! !

Precio: 0 yenes

Detalles del método BeanUtil

nueva instancia

objeto estático público nueva instancia(String className) lanza una excepción

Genera y devuelve una instancia a partir de la cadena "className".

Parámetros:: nombre de la clase – Nombre de clase completo
Valor de retorno:: Una nueva instancia de un nombre de clase completo
excepción:: Excepción

nueva instancia

objeto estático público nueva instancia(String className, Object[] argObj) lanza una excepción

Genera y devuelve una instancia a partir de la cadena "className".

Parámetros:: nombre de la clase – Nombre de clase completo; argObj – Argumentos del constructor
Valor de retorno:: Una nueva instancia de un nombre de clase completo
excepción:: Excepción

nueva instancia

objeto estático público nueva instancia(Clase clazz) lanza una excepción

Genera y devuelve una instancia de la clase "clazz".

Parámetros:: clazz - clase
Valor de retorno:: nueva instancia de clazz
excepción:: Excepción

nueva instancia

objeto estático público nueva instancia(Clase clazz, Objeto[] argObj) arroja una excepción

Genera y devuelve una instancia de la clase "clazz".

Parámetros:: clazz - clase; argObj – Argumentos del constructor
Valor de retorno:: nueva instancia de clazz
excepción:: Excepción

establecer propiedad

vacío público estático establecer propiedad(Objeto invocarObjeto, Nombre de campo de cadena, Valor de objeto) arroja una excepción

Llame al método de establecimiento del campo "fieldName" del objeto "invokeObject" y almacene el valor "value".

Si no existe un método de establecimiento, el valor se establecerá directamente en el campo. Sin embargo, en este caso, el modificador de acceso de la propiedad de destino debe ser público.

Parámetros:: invocarObjeto – Objeto a ejecutar; nombre del campo – Nombre de propiedad del objeto a ejecutar.; valor – Valor a configurar
excepción:: Excepción – Se produce la siguiente excepción.; Excepción de invocación de objetivos – Si el método subyacente arroja una excepción; Excepción de acceso ilegal – Este objeto de método es Java
Cuando se implementa el control de acceso al idioma y no se puede acceder al método subyacente; No existe tal excepción de método – Si no se encuentra un método con el nombre especificado

obtener propiedad

objeto estático público obtener propiedad(Objeto invokeObject, String fieldName) arroja una excepción

Llama al método getter del campo fieldName del objeto invokeObject para obtener el valor.
Si no existe un método getter, el valor se recuperará directamente del campo. Sin embargo, en este caso, el modificador de acceso de la propiedad de destino debe ser público.

Parámetros:: invocarObjeto – Objeto a ejecutar; nombre del campo – Nombre de propiedad del objeto a ejecutar.
Valor de retorno:: Valor de retorno del método getter
excepción:: Excepción – Se produce la siguiente excepción.; Excepción de invocación de objetivos – Si el método subyacente arroja una excepción; Excepción de acceso ilegal – Este objeto de método es Java
Cuando se implementa el control de acceso al idioma y no se puede acceder al método subyacente; Ninguna excepción de campo tal – Si no se encuentra un campo con el nombre especificado

invocar

objeto estático público invocar(Objeto invokeObject, String callMethod, Object[] argObjects) lanza InvocationTargetException, IllegalAccessException, NoSuchMethodException

Ejecuta el método "callMethod" del objeto "invokeObject".
Si hay un valor de retorno, se puede obtener como Objeto.

Parámetros:: invocarObjeto – Objeto a ejecutar; método de llamada – Nombre del método a ejecutar.; argObjetos – Si hay argumentos, páselos como una matriz de objetos. Si no hay argumentos, pase nulo.
Valor de retorno:: Valor de retorno de la ejecución de "callMethod"
excepción:: Excepción de invocación de objetivos – Si el método subyacente arroja una excepción; Excepción de acceso ilegal – Este objeto de método es Java
Cuando se implementa el control de acceso al idioma y no se puede acceder al método subyacente; No existe tal excepción de método – Si no se encuentra un método con el nombre especificado

encontrarmétodo

método estático público encontrarmétodo(Objeto invokeObject, String callMethod, Object[] argObjects) lanza NoSuchMethodException

Busque el método 'callMethod' del objeto 'invokeObject'.

Parámetros:: invocarObjeto – Objeto a ejecutar; método de llamada – Nombre del método del objeto a ejecutar.; argObjetos – Si hay argumentos, páselos como una matriz de objetos. Si no hay argumentos, pase nulo.
Valor de retorno:: Un objeto Método que coincide con las condiciones del argumento especificado.
excepción:: No existe tal excepción de método – Si no se encuentra ningún método coincidente, o si el nombre es “” o “”

establecer campo

vacío público estático establecer campo(Objeto invokeObject, nombre de campo de cadena, valor de objeto) lanza IllegalAccessException, NoSuchFieldException

Almacena el valor "value" en el nombre del campo "fieldName" del objeto a ejecutar "invokeObject".

Parámetros:: invocarObjeto – Objeto a ejecutar; nombre del campo – Nombre del campo del objeto a ejecutar.; valor – Valor a configurar
excepción:: Excepción de acceso ilegal – El campo en el que se basa el objeto especificado (o su subclase o implementador)
no es una instancia de la clase o interfaz que declara, o si falla la conversión de desempaquetado; Ninguna excepción de campo tal – Si no se encuentra un campo con el nombre especificado

obtener campo

objeto estático público obtener campo(Objeto invokeObject, String fieldName) lanza IllegalAccessException, NoSuchFieldException

Obtiene el valor del nombre de campo "fieldName" del objeto a ejecutar "invokeObject".

Parámetros:: invocarObjeto – Objeto a ejecutar; nombre del campo – Nombre del campo del objeto a ejecutar.
Valor de retorno:: valor de retorno
excepción:: Excepción de acceso ilegal – El campo en el que se basa el objeto especificado (o su subclase o implementador)
no es una instancia de la clase o interfaz que declara, o si falla la conversión de desempaquetado; Ninguna excepción de campo tal – Si no se encuentra un campo con el nombre especificado

tiene campo

booleano estático público tiene campo(Objeto objeto, nombre de campo de cadena) arroja una excepción

Comprueba si el objeto 'objeto' declara el nombre de campo 'nombreDeCampo'.

Parámetros:: objeto – Objeto a inspeccionar; nombre del campo – Nombre del campo a comprobar
Valor de retorno:: verdadero si se declara
excepción:: Excepción

obtener todos los campos

público estático java.util.TreeSet obtener todos los campos(Objeto objeto) lanza una excepción

Parámetros:: objeto –
Valor de retorno:
excepción:: Excepción

obtener nombre de clase corta

cadena estática pública obtener nombre de clase corta(Objeto Objeto)

Obtiene el nombre de clase no calificado de un objeto.

Parámetros:: objeto –
Valor de retorno:

obtener nombre de clase corta

cadena estática pública obtener nombre de clase corta(Nombre de clase de cadena)

Obtiene el nombre de la clase a partir del nombre completo.

Parámetros:: nombre de la clase –
Valor de retorno:

obtener nombre de campo

cadena estática pública obtener nombre de campo(Nombre del método de cadena)

Cambie el nombre del campo del nombre del método. Debe ajustarse a las convenciones de JavaBeans.

Parámetros:: nombre del método –
Valor de retorno:

esClaseExiste

booleano estático público esClaseExiste(Nombre de clase de cadena)

Verifica que el nombre completo "className" sea un nombre de clase existente.

Parámetros:: nombre de la clase –
Valor de retorno:

obtenerDescriptores de propiedad

PropertyDescriptor estático público [] obtenerDescriptores de propiedad(Objeto objeto) lanza IntrospectionException

Devuelve un PropertyDescriptor que contiene información de objeto para "objeto".

Parámetros:: objeto –
Valor de retorno:
excepción:: java.beans.IntrospectionException

Código fuente de BeanUtil

import java.beans.BeanInfo; import java.beans.IntrospectionException; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.math.BigDecimal; import java.sql.Timestamp; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.HashMap; import java.util.Map; import java.util.StringTokenizer; import java.util.TreeSet; /** * Clase de utilidad que le permite utilizar fácilmente la API de reflexión de Java */ clase pública BeanUtil { /** */ Cadena final estática privada GET = “GET”; /** */ Cadena final estática privada SET = “SET”; // --------------------"nueva instancia" /** * Genera y devuelve una instancia a partir de la cadena "className". * @param className nombre de clase completo * @return nueva instancia de nombre de clase completo * @throws Excepción */ Objeto estático público newInstance (String className) lanza una excepción { intentar { return Class.forName(className).newInstance(); } captura (NoClassDefFoundError e) { System.err.println(“NoClassDefFoundError:” + nombredeclase); tirar e; } } /** * Genera y devuelve una instancia a partir de la cadena "className". * @param className nombre de clase completo * Argumento del constructor @param argObj * @return nueva instancia de nombre de clase completo * @throws Excepción */ Objeto estático público nueva instancia (nombre de clase de cadena, objeto [] argObj) lanza una excepción { Clase[] argClass = nueva Clase[argObj.length]; for (int i = 0; i < argObj.length; i++) { argClass[i] = argObj[i].getClass(); } Constructor c = Class.forName(className).getConstructor(argClass); devolver c.newInstance(argObj); } /** * Crea y devuelve una instancia de la clase 'clazz'. * @param clase clazz * @return nueva instancia de clazz * @throws Excepción */ Objeto estático público newInstance (Clase clazz) lanza una excepción { return clazz.newInstance(); } /** * Crea y devuelve una instancia de la clase 'clazz'. * @param clase clazz * Argumento del constructor @param argObj * @return nueva instancia de clazz * @throws Excepción */ Objeto estático público newInstance(Clase clazz, Objeto[] argObj) lanza una excepción { Clase[] argClass = nueva Clase[argObj.length]; for (int i = 0; i < argObj.length; i++) { argClass[i] = argObj[i].getClass(); } Constructor c = clazz.getConstructor(argClass); devolver c.newInstance(argObj); } // ---------------------"Método" /** * Método de establecimiento del campo “fieldName” del objeto “invokeObject” * Llamar, almacenar valor 'valor'. * * Si no existe un método de establecimiento, establezca el valor directamente en el campo. * Sin embargo, en este caso, el modificador de acceso de la propiedad de destino debe ser público. * @param invokeObject Objeto a ejecutar * @param fieldName Nombre de propiedad del objeto a ejecutar * Valor @param valor a establecer * @throws Excepción Se produce la siguiente excepción. * @throws InvocationTargetException si el método subyacente genera una excepción * @throws IllegalAccessException Si este objeto Método es Java * Cuando se implementa el control de acceso al idioma y no se puede acceder al método subyacente * @throws NoSuchMethodException si no se encuentra un método con el nombre especificado */ setProperty público estático vacío (Objeto invocarObjeto, Nombre de campo de cadena, Valor del objeto) arroja una excepción { intentar { Método método = searchMethod(invokeObject, fieldName, SET); Clase[] paramClasses = método.getParameterTypes(); Objeto[] valueArray = nulo; if (paramClasses[0].isInstance(valor)) { //No convertir si el objeto a establecer es una subclase de la clase de argumento. valueArray = nuevo Objeto[] { valor }; } demás { valueArray = nuevo Objeto[] { convObject(valor, paramClasses[0] .getName()) }; } método.invoke(invokeObject, valueArray); } captura (NoSuchMethodException e) { intentar { // Si no hay un método de establecimiento, configúrelo directamente en el campo. setField(invocarObjeto, nombre de campo, valor); } captura (NoSuchFieldException fe) { Error de cadenaMes = “\nClase” + getNombreClaseCorta(invocarObjeto) + “es” + “para el campo “” + nombre del campo + “”\n” + "No existe un método de establecimiento accesible y". + “Campo “” + Nombre del campo + “” tampoco es público. "+""; lanzar nueva IllegalAccessException(errorMes); } } } /** * Método getter del campo nombre del campo del objeto invokeObject * Obtener el valor de la llamada. * Si no existe un método getter, el valor se obtendrá directamente del campo. * Sin embargo, en este caso, el modificador de acceso de la propiedad de destino debe ser público. * @param invokeObject Objeto a ejecutar * @param fieldName Nombre de propiedad del objeto a ejecutar * @return valor de retorno del método getter * @throws Excepción Se produce la siguiente excepción. * @throws InvocationTargetException si el método subyacente genera una excepción * @throws IllegalAccessException Si este objeto Método es Java * Cuando se implementa el control de acceso al idioma y no se puede acceder al método subyacente * @throws NoSuchFieldException si no se encuentra un campo con el nombre especificado */ Objeto estático público getProperty (Objeto invocarObjeto, Nombre de campo de cadena) lanza una excepción { intentar { Método método = searchMethod(invokeObject, fieldName, GET); método de retorno.invoke (invokeObject, nulo); } captura (NoSuchMethodException e) { return getField(invokeObject, fieldName); } } /** * Ejecuta el método "callMethod" del objeto "invokeObject". * Si hay un valor de retorno, se puede obtener como tipo Objeto. * @param invokeObject Objeto a ejecutar * @param callMethod Nombre del método a ejecutar * @param argObjects Si hay un argumento, páselo como una matriz de objetos. * Pasa nulo si no hay argumento. * @return Valor de retorno de la ejecución de "callMethod" * @throws InvocationTargetException si el método subyacente genera una excepción * @throws IllegalAccessException Si este objeto Método es Java * Cuando se implementa el control de acceso al idioma y no se puede acceder al método subyacente * @throws NoSuchMethodException si no se encuentra un método con el nombre especificado */ Invocación de objeto estático público (Invocación de objetoObjeto, Método de llamada de cadena, Object[] argObjects) lanza InvocationTargetException, IllegalAccessException, NoSuchMethodException { Método método = findMethod(invokeObject, callMethod, argObjects); método de retorno.invoke(invokeObject, argObjects); } /** * Busque el método 'callMethod' del objeto 'invokeObject'. * @param invokeObject Objeto a ejecutar * @param callMethod Nombre del método del objeto a ejecutar * @param argObjects Si hay un argumento, páselo como una matriz de objetos. * Pasa nulo si no hay argumento. * @return Objeto de método que coincide con las condiciones del argumento especificado * @throws NoSuchMethodException Si no se encuentra ningún método coincidente, *O si el nombre es “ " o " "En el caso de */ Método estático público findMethod (Objeto invokeObject, String callMethod, Objeto[] argObjects) lanza NoSuchMethodException { Clase[] paramClasses = nulo; Método[] métodos = invokeObject.getClass().getMethods(); arriba: for (int i = 0; i < métodos.longitud; i++) { if (métodos[i].getName().equals(callMethod)) { si (argObjects == nulo && métodos[i].getParameterTypes().length == 0) { métodos de retorno [i]; } si (argObjects == nulo) { continuar; } paramClasses = métodos[i].getParameterTypes(); if (paramClasses.length == argObjects.length) { // Validar todos los tipos de lista de parámetros y tipos de argumentos for (int j = 0; j < paramClasses.length; j++) { Clase paramClass = paramClasses[j]; Objeto argObj = argObjects[j]; // Si el tipo de argumento es primitivo, el objeto del argumento // no es nulo y es primitivo //Si es una subclase de Número, está bien. si (argObj == nulo) { continuar; } si (paramClass.isPrimitive() && (argObj instancia de Número || argObj .getClass().isPrimitive())) { continuar; } si (!paramClass.isInstance(argObj)) { // Pasar al siguiente método cuando los tipos no sean compatibles con la conversión implícita continuar arriba; } } métodos de retorno [i]; } } } Cadena paramLength = (paramClasses! = null)? Entero .toString(paramClasses.length): “”; Cadena errorMes = getShortClassName(invokeObject) + “método” + callMethod + “No hay.” + “[ paramClasses.length ] = ” + paramLength + “,[ argObjects.length ] = ” + argObjects.length + “”; lanzar nueva NoSuchMethodException(errorMes); } // ----------------------"Campo" /** * Valor del nombre de campo "fieldName" del objeto "invokeObject" que se ejecutará * Almacena "valor". * @param invokeObject Objeto a ejecutar * @param fieldName Nombre del campo del objeto a ejecutar * Valor @param valor a establecer * @throws IllegalAccessException Si el objeto especificado es * campo (o su subclase o implementador) * Si no es una instancia de una clase o interfaz, declara * o si falla la conversión de desenvolvimiento * @throws NoSuchFieldException si no se encuentra un campo con el nombre especificado */ setField vacío estático público (Objeto invocarObjeto, Nombre de campo de cadena, Valor del objeto) arroja IllegalAccessException, NoSuchFieldException { Campo campo = searchField(invokeObject, fieldName); Cadena nombre de clase = campo.getType().getName(); Objeto convObj = nulo; si (campo.getType().isInstance(valor)) { convObj = valor; } demás { convObj = convObject(valor, nombre de clase); } campo.set(invokeObject, convObj); } /** * Establezca el valor del nombre de campo "fieldName" del objeto de ejecución "invokeObject" en * Conseguir. * @param invokeObject Objeto a ejecutar * @param fieldName Nombre del campo del objeto a ejecutar * @return valor de retorno * @throws IllegalAccessException Si el objeto especificado es * campo (o su subclase o implementador) * Si no es una instancia de una clase o interfaz, declara * o si falla la conversión de desenvolvimiento * @throws NoSuchFieldException si no se encuentra un campo con el nombre especificado */ Objeto estático público getField (Objeto invokeObject, Cadena nombre de campo) lanza IllegalAccessException, NoSuchFieldException { Campo campo = searchField(invokeObject, fieldName); devolver campo.get(invokeObject); } /** * Compruebe si el objeto "objeto" declara el nombre del campo "fieldName" * confirmar. * @param object Objeto a inspeccionar * @param fieldName Nombre del campo a inspeccionar * @return verdadero si se declara * @throws Excepción */ hasField booleano estático público (objeto objeto, nombre de campo de cadena) lanza una excepción { PropertyDescriptor[] accesorios = getPropertyDescriptors(objeto); for (int i = 0; i < props.length; i++) { Cadena _fieldName = props[i].getName(); if (nombredelcampo.equals(_nombredelcampo)) { devolver verdadero; } } falso retorno; } /** * * objeto @param * @devolver * @throws Excepción */ TreeSet estático público getAllFields (objeto objeto) lanza una excepción { TreeSet fieldSet = nuevo TreeSet(); // Obtener el nombre de la propiedad del método PropertyDescriptor[] accesorios = getPropertyDescriptors(objeto); for (int i = 0; i < props.length; i++) { Cadena nombre del campo = props[i].getName(); fieldSet.add(nombredelcampo); } // Obtener el nombre de la propiedad del campo Campo[] campos = object.getClass().getFields(); for (int i = 0; i < campos.longitud; i++) { Cadena nombre del campo = campos[i].getName(); if (!fieldSet.contains(nombredelcampo)) { fieldSet.add(nombredelcampo); } } conjunto de campos de retorno; } /** * * @param invokeObject Objeto a ejecutar * @param fieldName Nombre del campo del objeto a ejecutar * @return Objetos archivados que coinciden con las condiciones del argumento especificado * @throws NoSuchFieldException si no se encuentra un campo con el nombre especificado */ Campo de búsqueda de campo estático privado (objeto de invocación de objeto, nombre de campo de cadena) lanza NoSuchFieldException { intentar { devolver invokeObject.getClass().getField(fieldName); } captura (NoSuchFieldException e) { // Este alcance se obtiene del nombre de la columna de la tabla nombredelcampo = checkFieldName(nombredelcampo); Campo[] campos = invokeObject.getClass().getFields(); for (int i = 0; i < campos.longitud; i++) { if (campos[i].getName().equalsIgnoreCase(nombredelcampo)) { campos de retorno [i]; } } lanzar nueva NoSuchFieldException(fieldName); } } // ----------------------" otros " /** * Obtener el nombre de clase no calificado de un objeto. * objeto @param * @devolver */ cadena estática pública getShortClassName (objeto objeto) { si (objeto == nulo) { devolver "nulo"; } Nombre de cadena = object.getClass().getName(); devuelve getShortClassName(nombre); } /** * Obtenga el nombre de la clase a partir del nombre completo. * @param nombre de clase * @devolver */ Cadena estática pública getShortClassName (String className) { int índice = className.lastIndexOf(“.”); devolver className.substring(índice + 1); } /** * Cambie el nombre del campo del nombre del método. Cumple con las convenciones de JavaBeans * es necesario. * @param nombre del método * @devolver */ cadena estática pública getFieldName (cadena nombre del método) { Nombre del campo de cadena = nulo; if (nombremétodo.startsWith(“es”)) { nombre del campo = nombre del método.substring(2); } demás { nombre del campo = nombre del método.substring(3); } nombre de campo = convString(nombre de campo, 0, “L”); devolver nombre del campo; } /** * Verifique que el nombre completo "className" sea un nombre de clase existente. * @param nombre de clase * @devolver */ público estático booleano isClassExist (String className) { intentar { Class.forName(nombredeclase); devolver verdadero; } captura (Excepción e) { falso retorno; } } Mapa estático final privado beanInfoCache = new HashMap(); /** * Devuelve un PropertyDescriptor que contiene información de objeto para "objeto". * objeto @param * @devolver * @throws IntrospecciónExcepción */ PropertyDescriptor estático público [] getPropertyDescriptors (objeto objeto) lanza IntrospectionException { BeanInfo beanInfo = (BeanInfo) beanInfoCache.get(object.getClass()); si (beanInfo == nulo) { beanInfo = Introspector.getBeanInfo(object.getClass()); beanInfoCache.put(object.getClass(), beanInfo); } // BeanInfo beanInfo = Introspector.getBeanInfo(object.getClass()); devolver beanInfo.getPropertyDescriptors(); } // ————————————————————————– // ———————————————“Método privado a continuación” // ————————————————————————– /** * Busque el método de acceso para el argumento fieldName basado en PropertyDescriptor. * @param invokeObject Objeto a ejecutar * @param fieldName nombre del campo * @param tipo Método getter ⇒ GET Método getter ⇒ SET * @return Objeto de método que coincide con las condiciones del argumento especificado * @throws NoSuchMethodException Si no se encuentra ningún método coincidente, *O si el nombre es “ " o " " * En el caso de * @throws IntrospecciónExcepción */ Método estático privado método de búsqueda (Objeto invocarObjeto, Nombre de campo de cadena, Tipo de cadena) arroja NoSuchMethodException, IntrospectionException { Método método = nulo; nombredelcampo = checkFieldName(nombredelcampo); PropertyDescriptor[] accesorios = getPropertyDescriptors(invokeObject); for (int i = 0; i < props.length; i++) { Nombre de cadena = props[i].getName(); if (!nombre.equalsIgnoreCase(nombredelcampo)) { continuar; } si (tipo.equals(OBTENER)) { método = accesorios[i].getReadMethod(); } demás { método = accesorios[i].getWriteMethod(); } si (método == nulo) { continuar; } método de devolución; } // Si el método no existe. lanza una nueva NoSuchMethodException ("La clase no tiene métodos". + “(No distingue entre mayúsculas y minúsculas):” + type.toLowerCase() + convString(fieldName, 0, “U”) + “()”); } /** * Comprueba si el argumento fieldName es un nombre de columna; si es un nombre de columna, * Convertir de nuevo. * * DIRECCIÓN_MAIL ⇒ DIRECCIÓN MAIL ↓ dirección de correo = dirección de correo * @param fieldName nombre de campo o nombre de columna * @nombre del campo de retorno */ cadena estática privada checkFieldName (String campoName) { int índice = nombredelcampo.indexOf(“_”); mientras (verdadero) { si (índice == -1) { devolver nombre del campo; } StringBuffer convcloumn = new StringBuffer(fieldName); convcloumn.deleteCharAt(índice); nombre de campo = convcloumn.toString(); índice = nombredelcampo.indexOf(“_”); } } /** * Convierte el objeto a convertir, objeto, al tipo de convClassName. * * @param object Objeto a convertir * @param convClassName cadena de clase de tipo a convertir * @return el objeto convertido */ Objeto estático privado convObject (objeto objeto, cadena convClassName) { si (objeto == nulo) { // Devolver nulo al convertir a un tipo primitivo generará un error. // Conviértelo en un contenedor para 0. if (convClassName.equals(“int”)) { devolver nuevo entero(0); } else if (convClassName.equals(“largo”)) { devolver nuevo Largo(0); } demás { devolver nulo; } } if (object.getClass().getName().equals(convClassName)) { objeto de retorno; } // —————————————-『instancia de objeto de cadena』 si (objeto instancia de cadena) { if (convClassName.equals(“java.lang.String”)) { objeto de retorno; } else if (convClassName.equals(“java.lang.Long”) || convClassName.equals(“largo”)) { Cadena cadena = (Cadena) objeto; si (isExist(cadena)) { // Será malo si no lo conviertes a BigDecimal una vez // 1000.00000 BigDecimal grande = nuevo BigDecimal(cadena); devolver nuevo Long(big.longValue()); } demás { // Si str es un literal de shell, establece el valor inicial en "0" devolver nuevo Largo(0); } } else if (convClassName.equals(“java.sql.Fecha”)) { volver a SqlDate (objeto (Cadena)); } else if (convClassName.equals(“java.sql.Timestamp”)) { Fecha fecha = toSqlDate((String) objeto); devolver nueva marca de tiempo (date.getTime()); } else if (convClassName.equals(“java.lang.Integer”) || convClassName.equals(“int”)) { // Si str es un literal de shell, establece el valor inicial en "0" Cadena cadena = (Cadena) objeto; si (isExist(cadena)) { BigDecimal grande = nuevo BigDecimal(cadena); devolver nuevo entero (big.intValue()); } demás { devolver nuevo entero(0); } } else if (convClassName.equals(“booleano”)) { return Boolean.valueOf(object.toString()); } else if (convClassName.equals(“java.math.BigDecimal”)) { Temperatura de cadena = ((Cadena) objeto).trim(); // Si temp.length() == 0, es seguro establecerlo en nulo en lugar de 0. si (temp.longitud() == 0) { devolver nulo; } demás { devolver nuevo BigDecimal(temp); } } throwNoSupprt(objeto, convClassName); } // ———————————“ objeto instancia de java.sql.Date ” else if (objeto instancia de java.sql.Date) { if (convClassName.equals(“java.lang.String”)) { volver aStringDate((java.sql.Date) objeto, “aaaa/MM/dd”); } else if (convClassName.equals(“java.sql.Fecha”)) { objeto de retorno; } else if (convClassName.equals(“java.sql.Timestamp”)) { devolver nueva marca de tiempo (((fecha) objeto). getTime()); } throwNoSupprt(objeto, convClassName); } // ————————————-『instancia de objeto de marca de tiempo』 else if (objeto instancia de marca de tiempo) { mucho tiempo = ((Marca de tiempo) objeto).getTime(); if (convClassName.equals(“java.lang.String”)) { volver aStringDate(hora, “aaaa/MM/dd HH:mm:ss”); } else if (convClassName.equals(“java.sql.Fecha”)) { devolver nuevo java.sql.Date(hora); } else if (convClassName.equals(“java.sql.Timestamp”)) { objeto de retorno; } throwNoSupprt(objeto, convClassName); } // —————————————-『instancia de objeto de Integer』 else if (objeto instancia de entero) { si (convClassName.equals ("java.lang.Integer") || convClassName.equals(“int”)) { objeto de retorno; } else if (convClassName.equals(“java.lang.String”)) { devolver objeto.toString(); } else if (convClassName.equals(“java.lang.Long”) || convClassName.equals(“largo”)) { devolver nuevo objeto Long(((Integer)).longValue()); } else if (convClassName.equals(“java.math.BigDecimal”)) { devolver nuevo BigDecimal(((Integer) objeto).intValue()); } throwNoSupprt(objeto, convClassName); } // ——————————————『instancia de objeto de Long』 else if (objeto instancia de Long) { si (convClassName.equals (“java.lang.Long”) || convClassName.equals(“largo”)) { objeto de retorno; } else if (convClassName.equals(“java.lang.String”)) { devolver objeto.toString(); } else if (convClassName.equals(“java.lang.Integer”) || convClassName.equals(“int”)) { devolver nuevo entero(((objeto largo)).intValue()); } else if (convClassName.equals(“java.math.BigDecimal”)) { devolver nuevo BigDecimal(((Long) objeto).longValue()); } throwNoSupprt(objeto, convClassName); } // —————————————-『instancia de objeto de Doble』 else if (objeto instancia de Doble) { if (convClassName.equals(“java.lang.String”)) { // NÚMERO DE COLUMNA(8,0) // oráculo de Windows > BigDecimal // oráculo UNIX > Doble BigDecimal grande = nuevo BigDecimal(((Doble) objeto).doubleValue()); escala int = grande.escala(); si (escala == 0) { devolver grande.toString(); } demás { // No se admite si se requiere redondeo. throwNoSupprt(objeto, convClassName); } } si (convClassName.equals ("java.lang.Integer") || convClassName.equals(“int”)) { devolver nuevo Integer(((Doble) objeto).intValue()); } else if (convClassName.equals(“java.lang.Long”) || convClassName.equals(“largo”)) { devolver nuevo Long(((Doble) objeto).longValue()); } else if (convClassName.equals(“java.math.BigDecimal”)) { devolver nuevo BigDecimal(((Doble) objeto).doubleValue()); } throwNoSupprt(objeto, convClassName); } // ————————————“ instancia de objeto de BigDecimal ” else if (ejemplo de objeto de BigDecimal) { if (convClassName.equals(“java.lang.String”)) { devolver objeto.toString(); } else if (convClassName.equals(“java.lang.Long”) || convClassName.equals(“largo”)) { devolver nuevo objeto Long(((BigDecimal)).longValue()); } else if (convClassName.equals(“java.lang.Integer”) || convClassName.equals(“int”)) { devolver nuevo Integer(((BigDecimal) objeto).intValue()); } throwNoSupprt(objeto, convClassName); } // —————————————-『instancia de objeto de byte[]』 else if (objeto instancia de byte[]) { if (convClassName.equals(“java.sql.Blob”)) { objeto de retorno; } throwNoSupprt(objeto, convClassName); } // ————————————————“el objeto es booleano” else if (objeto instancia de booleano) { if (convClassName.equals(“booleano”)) { objeto de retorno; } throwNoSupprt(objeto, convClassName); } // ———————————————-『el objeto es booleano[]』 else if (objeto instancia de booleano[]) { if (convClassName.equals(“java.lang.String”)) { booleano[] bs = (booleano[]) objeto; Mejora de StringBuffer = nuevo StringBuffer(“[“); for (int i = 0; i < bs.length; i++) { buff.append(bs[i] + “,”); } buff.deleteCharAt(buff.length() – 1); buff.append(“]”); devolver buff.toString(); } throwNoSupprt(objeto, convClassName); } throwNoSupprt(objeto, convClassName); devolver nulo; } /** *Se lanza si la conversión no es compatible. * * @param object Objeto a convertir * @param convClassName Tipo a convertir */ throwNoSupprt vacío estático privado (objeto objeto, cadena convClassName) { Cadena nombre de clase = (objeto! = nulo) ?objeto.getClass().getName() : "nulo"; String errorMess = “\nEl procesamiento de conversión de tipo para este objeto aún no es compatible.\n” + ”[ Objeto ] = ” + objeto + “,[ Tipo de objeto ] = ” + nombre de clase + “,[ convertClass ] = ” + convClassName + “”; lanzar nueva UnsupportedOperationException(errorMess); } /** * Convierte el carácter en la posición [index] de la cadena [str] a mayúsculas o minúsculas. * * @param str Cadena a evaluar * @param index Posición especificada * @param toCase Convertir a mayúsculas ⇒ U | u Convertir a minúsculas ⇒ L | l * @return Cadena después de la conversión */ cadena estática privada convString (cadena cadena, índice int, cadena toCase) { si (cadena == nulo || str.trim().length() == 0) { devolver cadena; } demás { Temperatura de cadena = str.substring(índice, índice + 1); si (toCase.equalsIgnoreCase(“u”)) { temperatura = temp.toUpperCase(); } demás { temperatura = temp.toLowerCase(); } StringBuffer tempBuffer = nuevo StringBuffer(str); tempBuffer.replace(índice, índice + 1, temperatura); devolver tempBuffer.toString(); } } /** * Verifique si [valor] es un valor válido. * * @param valor Cadena a evaluar * @return [true]: Si no es nulo y no es "" */ isExist booleano estático privado (valor de cadena) { si (valor! = nulo && valor.longitud()! = 0) { devolver verdadero; } falso retorno; } /** * clase java.util.Date o su subclase en el formato especificado * Convertir a cadena. * @param fecha java.util.Date clase a convertir * @param patrón formato especificado * Cadena de fecha con formato @return */ cadena estática privada toStringDate (fecha fecha, patrón de cadena) { SimpleDateFormat sdFormat = nuevo SimpleDateFormat(patrón); devolver sdFormat.format(fecha); } java.sql.Date estático privado toSqlDate (String strDate) { Calendario cal = toCalendar(strDate); volver aSqlDate(cal); } privado estático java.sql.Date toSqlDate (calendario cal) { largo l = cal.getTime().getTime(); devolver nuevo java.sql.Date(l); } /** * Convierte un valor de tiempo largo en una cadena en el formato especificado. * @param time Un valor largo que representa milisegundos de la hora actual. * @param patrón formato especificado * Cadena de fecha con formato @return */ Cadena estática privada toStringDate (mucho tiempo, patrón de cadena) { volver aStringDate(nueva Fecha(hora), patrón); } /** * Cadena ⇒ java.sql.Date * * Convierta la siguiente cadena de fecha a java.sql.Date * aaaa/MM/dd HH:mm:ss.SSS aaaa-MM-dd HH:mm:ss.SSS * * “20030407” “2003/04/07” “2003-04-07” “2003/04/07 15:20:16” “2003-04-07 * 15:20:16” * @param strDate * @devolver */ Calendario estático privado toCalendar (String strDate) { strFecha = formato(strFecha); Calendario cal = Calendar.getInstance(); int yyyy = Integer.parseInt(strDate.substring(0, 4)); int MM = Integer.parseInt(strDate.substring(5, 7)); int dd = Integer.parseInt(strDate.substring(8, 10)); int HH = cal.get(Calendario.HOUR_OF_DAY); int mm = cal.get(Calendario.MINUTO); int ss = cal.get(Calendario.SEGUNDO); int SSS = cal.get(Calendario.MILLISECOND); cal.clear(); cal.set(aaaa, MM – 1, dd); int len = strDate.length(); cambiar (len) { caso 10: romper; caso 16: // aaaa/MM/dd HH:mm HH = Integer.parseInt(strDate.substring(11, 13)); mm = Integer.parseInt(strDate.substring(14, 16)); cal.set(Calendario.HOUR_OF_DAY, HH); cal.set(Calendario.MINUTO, mm); romper; caso 19: // aaaa/MM/dd HH:mm:ss HH = Integer.parseInt(strDate.substring(11, 13)); mm = Integer.parseInt(strDate.substring(14, 16)); ss = Integer.parseInt(strDate.substring(17, 19)); cal.set(Calendario.HOUR_OF_DAY, HH); cal.set(Calendario.MINUTO, mm); cal.set(Calendario.SEGUNDO, ss); romper; caso 23: // aaaa/MM/dd HH:mm:ss.SSS HH = Integer.parseInt(strDate.substring(11, 13)); mm = Integer.parseInt(strDate.substring(14, 16)); ss = Integer.parseInt(strDate.substring(17, 19)); SSS = Integer.parseInt(strDate.substring(20, 23)); cal.set(Calendario.HOUR_OF_DAY, HH); cal.set(Calendario.MINUTO, mm); cal.set(Calendario.SEGUNDO, ss); cal.set(Calendario.MILLISECOND, SSS); romper; por defecto: lanzar una nueva IllegalStateException( "Esta cadena de cadena no se puede convertir en una cadena de fecha:" +strFecha); } devolver llamada; } /** * Cualquier cadena de fecha como “aaaa/MM/dd” o “aaaa/MM/dd HH:mm:ss” * Intenta convertir al formato. * Ejemplo: 1/03/3 ⇒ 03/01/2003 * @param strDate * @devolver */ formato de cadena estática privada (String strDate) { strFecha = strFecha.trim(); Cadena yyyy = nulo; Cadena MM = nula; Cadena dd = nulo; Cadena HH = nula; Cadena mm = nulo; Cadena ss = nulo; Cadena SSS = nula; // Si falta "-" o "/" si (strDate.indexOf(“/”) == -1 && strDate.indexOf(“-“) == -1) { si (strDate.length() == 8) { aaaa = strDate.substring(0, 4); MM = strDate.substring(4, 6); dd = strDate.substring(6, 8); devolver aaaa + “/” + MM + “/” + dd; } demás { aaaa = strDate.substring(0, 4); MM = strDate.substring(4, 6); dd = strDate.substring(6, 8); HH = strDate.substring(9, 11); mm = strFecha.substring(12, 14); ss = strDate.substring(15, 17); devolver aaaa + “/” + MM + “/” + dd + ” ” + HH + “:” + mm + “:” +ss; } } Token StringTokenizer = nuevo StringTokenizer(strDate, “_/-:. “); Resultado de StringBuffer = nuevo StringBuffer(); para (int i = 0; token.hasMoreTokens(); i++) { Temperatura de cadena = token.nextToken(); cambiar (i) { caso 0:// parte del año yyyy = fillString(strDate, temp, “f”, “20”, 4); resultado.append(aaaa); romper; caso 1:// parte del mes MM = fillString(strDate, temp, “f”, “0”, 2); resultado.append(“/” + MM); romper; caso 2:// parte del día dd = fillString(strDate, temp, “f”, “0”, 2); resultado.append(“/” + dd); romper; caso 3:// parte del tiempo HH = fillString(strDate, temp, “f”, “0”, 2); resultado.append(” ” + HH); romper; caso 4:// parte minuto mm = fillString(strDate, temp, “f”, “0”, 2); resultado.append(“:” + mm); romper; caso 5:// segunda parte ss = fillString(strDate, temp, “f”, “0”, 2); resultado.append(“:” + ss); romper; caso 6:// parte de milisegundos SSS = fillString(strDate, temp, “b”, “0”, 3); resultado.append(“.” + SSS); romper; } } devolver resultado.toString(); } Cadena estática privada fillString (String strDate, String str, Posición de la cadena, cadena addStr, int len) { si (cadena.longitud() > len) { String mes = strDate + “Esta cadena no se puede convertir en una cadena de fecha”; lanzar nueva IllegalStateException(mes); } devolver cadena de relleno (cadena, posición, agregarCadena, len); } /** * Agregue la cadena [addStr] que se agregará a la cadena [str] en [posición] en [len] * Insertar hasta llenar. * * Ejemplo: String ss = StringUtil.fillString(“aaa”,”b”,”0″,7); ss ⇒ “aaa0000” * * *fillString() inserta hasta que se llena len, pero addString() inserta len. * * @param str cadena de destino * @param posición Insertar antes ⇒ F/f Insertar después ⇒ B/b * @param addStr Cadena para insertar * @param len Número de dígitos a reponer * @return La cadena después de la conversión. [str] es un literal nulo o vacío, [addStr] está establecido en [len] * Devuelve los resultados insertados hasta que esté satisfecho. */ cadena estática privada fillString (cadena cadena, posición de la cadena, Cadena addStr, int len) { StringBuffer tempBuffer = nulo; si (!isExist(cadena)) { tempBuffer = nuevo StringBuffer(); para (int i = 0; i < len; i++) { tempBuffer.append(addStr); } devolver tempBuffer.toString(); } más si (str.length()! = len) { tempBuffer = nuevo StringBuffer(cadena); mientras (len > tempBuffer.length()) { si (posición.equalsIgnoreCase(“f”)) { tempBuffer.insert(0, addStr); } demás { tempBuffer.append(addStr); } } devolver tempBuffer.toString(); } devolver cadena; } }

URLをコピーしました！