Reflexão Java facilitada

17 de setembro de 2018

índice

Reflexão Java facilitada

JavadereflexãoApresentando uma classe utilitária que permite usar facilmente a API.

O que é reflexão?

API de reflexãodentes,"java.lang.reflect”incluído no pacote,
Esta é uma API que recupera informações como campos e métodos de classes Java.
As seguintes classes são usadas principalmente.

java.lang.Class
java.lang.reflect.Constructor
java.lang.reflect.Method
java.lang.reflect.Field

reflexãoUsando , você pode criar classes ou chamar métodos sem precisar codificá-los diretamente.
Você pode criar uma instância de classe a partir de uma string ou executar um método.

Ao escrever as definições de nomes de classes e métodos em arquivos externos, como XML, você pode adaptar dinamicamente o aplicativo às mudanças no ambiente durante o tempo de execução.
É também uma API muito eficaz para construir aplicações altamente flexíveis.

Objetivo da reflexão

reflexãomuitas vezes não é usado diretamente pelos usuários,
É amplamente utilizado em aplicações web como Struts e estruturas como mapeamento O/R.

Por exemplo, ao configurar automaticamente os dados de entrada da tela da web para propriedades JavaBeans,
É usado ao emitir SQL que atualiza automaticamente com base nas propriedades JavaBeans.

Além disso, estão disponíveis funções como carregamento dinâmico e registro de plug-ins que ampliam a funcionalidade quando o aplicativo é iniciado.reflexãoIsso pode ser facilmente alcançado usando .

Executando a amostra

Execute o exemplo e experimente a programação semelhante a uma estrutura.

Aqui usamos a seguinte classereflexãoDemonstra um uso simples do utilitário.

Principal.java...Classe a ser executada
BeanUtil.java... Classe de utilidade de reflexão
FreeSoft.java...Usado como reflexão em uma classe que representa software livre.

●Quando executado normalmente

Sistema.out.println(“＞＞＞Caso normal”);
FreeSoft freeSoft = new FreeSoft();
freeSoft.setName(“Chat&Messenger Chat e Messenger!!”);
freeSoft.showName();
freeSoft.showPrice(0);

●Quando executado usando reflexão

Sistema.out.println(“＞＞＞Ao usar reflexão”);
//Cria uma instância da classe FreeSoft
Objeto invocarObject = BeanUtil.newInstance(“FreeSoft”);
//Defina o valor no campo nome.
BeanUtil.setProperty(invokeObject, "nome" , “Bate-papo e Messenger Bate-papo e Messenger !!”);
// Executa o método showName() do FreeSoft.
BeanUtil.invoke(invokeObject, “mostrarNome”, nulo);
// Executa o método showPrice() do FreeSoft.
// Se o método tiver argumentos, eles devem ser passados como um array do tipo Object.
BeanUtil.invoke(invokeObject, “mostrar preço”,novo Objeto[]{novo Inteiro(0)});

●Resultado da execução

Os resultados da execução são os mesmos tanto no caso normal quanto no uso da reflexão.

>>> Caso normal

Nome do software: Chat&Messenger Bate-papo e mensageiro! !

Preço: 0 ienes

>>> Ao usar reflexão

Nome do software: Chat&Messenger Bate-papo e mensageiro! !

Preço: 0 ienes

Detalhes do método BeanUtil

novaInstância

objeto estático público novaInstância(String className) lança exceção

Gera e retorna uma instância da string "className".

Parâmetros:: nome da classe – Nome de classe totalmente qualificado
Valor de retorno:: Uma nova instância de um nome de classe totalmente qualificado
exceção:: Exceção

novaInstância

objeto estático público novaInstância(String className, Object[] argObj) lança exceção

Gera e retorna uma instância da string "className".

Parâmetros:: nome da classe – Nome de classe totalmente qualificado; argObj – Argumentos do construtor
Valor de retorno:: Uma nova instância de um nome de classe totalmente qualificado
exceção:: Exceção

novaInstância

objeto estático público novaInstância(Classe clazz) lança exceção

Gera e retorna uma instância da classe "clazz".

Parâmetros:: clazz - aula
Valor de retorno:: nova instância de clazz
exceção:: Exceção

novaInstância

objeto estático público novaInstância(Classe clazz, Object[] argObj) lança exceção

Gera e retorna uma instância da classe "clazz".

Parâmetros:: clazz - aula; argObj – Argumentos do construtor
Valor de retorno:: nova instância de clazz
exceção:: Exceção

definirPropriedade

vazio estático público definirPropriedade(Objeto invocarObject, String fieldName, valor do objeto) lança exceção

Chame o método setter do campo “fieldName” do objeto “invokeObject” e armazene o valor “value”.

Se não houver método setter, o valor será definido diretamente no campo. Porém, neste caso, o modificador de acesso da propriedade alvo deve ser público.

Parâmetros:: invocarObject – Objeto a ser executado; campoNome – Nome da propriedade do objeto a ser executado; valor – Valor a definir
exceção:: Exceção – Ocorre a seguinte exceção.; InvocaçãoTargetException – Se o método subjacente lançar uma exceção; Exceção de acesso ilegal – Este objeto Método é Java
Quando o controle de acesso ao idioma é implementado e o método subjacente não pode ser acessado; NoSuchMethodException – Se um método com o nome especificado não for encontrado

obterPropriedade

objeto estático público obterPropriedade(Objeto invocarObject, String fieldName) lança exceção

Chama o método getter do campo fieldName do objeto invocaObject para obter o valor.
Se não houver método getter, o valor será recuperado diretamente do campo. Porém, neste caso, o modificador de acesso da propriedade alvo deve ser público.

Parâmetros:: invocarObject – Objeto a ser executado; campoNome – Nome da propriedade do objeto a ser executado
Valor de retorno:: Valor de retorno do método getter
exceção:: Exceção – Ocorre a seguinte exceção.; InvocaçãoTargetException – Se o método subjacente lançar uma exceção; Exceção de acesso ilegal – Este objeto Método é Java
Quando o controle de acesso ao idioma é implementado e o método subjacente não pode ser acessado; NoSuchFieldException – Se um campo com o nome especificado não for encontrado

invocar

objeto estático público invocar(Objeto invocaObject, String callMethod, Object[] argObjects) lança InvocationTargetException, IllegalAccessException, NoSuchMethodException

Executa o método "callMethod" do objeto "invokeObject".
Se houver um valor de retorno, ele poderá ser obtido como um Objeto.

Parâmetros:: invocarObject – Objeto a ser executado; método de chamada – Nome do método a ser executado; argObjects – Se houver argumentos, passe-os como um array de objetos. Se não houver argumentos, passe nulo.
Valor de retorno:: Valor de retorno da execução de "callMethod"
exceção:: InvocaçãoTargetException – Se o método subjacente lançar uma exceção; Exceção de acesso ilegal – Este objeto Método é Java
Quando o controle de acesso ao idioma é implementado e o método subjacente não pode ser acessado; NoSuchMethodException – Se um método com o nome especificado não for encontrado

encontrarMetodo

método estático público encontrarMetodo(Objeto invocarObject, String callMethod, Object[] argObjects) lança NoSuchMethodException

Procure o método 'callMethod' do objeto 'invokeObject'.

Parâmetros:: invocarObject – Objeto a ser executado; método de chamada – Nome do método do objeto a ser executado; argObjects – Se houver argumentos, passe-os como um array de objetos. Se não houver argumentos, passe nulo.
Valor de retorno:: Um objeto Method que corresponde às condições de argumento especificadas
exceção:: NoSuchMethodException – Se nenhum método correspondente for encontrado ou se o nome for “” ou “”

setField

vazio estático público setField(Objeto invocarObject, String fieldName, valor do objeto) lança IllegalAccessException, NoSuchFieldException

Armazena o valor “value” no nome do campo “fieldName” do objeto a ser executado “invokeObject”.

Parâmetros:: invocarObject – Objeto a ser executado; campoNome – Nome do campo do objeto a ser executado; valor – Valor a definir
exceção:: Exceção de acesso ilegal – O campo no qual o objeto especificado se baseia (ou sua subclasse ou implementador)
não é uma instância da classe ou interface que declara ou se a conversão de desembrulhamento falhar; NoSuchFieldException – Se um campo com o nome especificado não for encontrado

getField

objeto estático público getField(Objeto invocarObject, String fieldName) lança IllegalAccessException, NoSuchFieldException

Obtém o valor do nome do campo "fieldName" do objeto a ser executado "invokeObject".

Parâmetros:: invocarObject – Objeto a ser executado; campoNome – Nome do campo do objeto a ser executado
Valor de retorno:: valor de retorno
exceção:: Exceção de acesso ilegal – O campo no qual o objeto especificado se baseia (ou sua subclasse ou implementador)
não é uma instância da classe ou interface que declara ou se a conversão de desembrulhamento falhar; NoSuchFieldException – Se um campo com o nome especificado não for encontrado

hasField

público estático booleano hasField(Objeto objeto, String fieldName) lança exceção

Verifica se o objeto 'object' declara o nome do campo 'fieldName'.

Parâmetros:: objeto – Objeto a ser inspecionado; campoNome – Nome do campo a verificar
Valor de retorno:: verdadeiro se declarado
exceção:: Exceção

getAllFields

java.util.TreeSet público estático getAllFields(Objeto objeto) lança exceção

Parâmetros:: objeto –
Valor de retorno:
exceção:: Exceção

getShortClassName

String estática pública getShortClassName(Objeto objeto)

Obtém o nome de classe não qualificado de um objeto.

Parâmetros:: objeto –
Valor de retorno:

getShortClassName

String estática pública getShortClassName(String nomedaclasse)

Obtém o nome da classe a partir do nome totalmente qualificado.

Parâmetros:: nome da classe –
Valor de retorno:

getFieldName

String estática pública getFieldName(String nome do método)

Altere o nome do campo do nome do método. Deve estar em conformidade com as convenções JavaBeans.

Parâmetros:: nome do método –
Valor de retorno:

isClassExist

público estático booleano isClassExist(String nomedaclasse)

Verifica se o nome completo "className" é um nome de classe existente.

Parâmetros:: nome da classe –
Valor de retorno:

getPropertyDescriptors

PropertyDescriptor público estático[] getPropertyDescriptors(Objeto objeto) lança IntrospectionException

Retorna um PropertyDescriptor que contém informações de objeto para "objeto".

Parâmetros:: objeto –
Valor de retorno:
exceção:: java.beans.IntrospectionException

Código-fonte 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; /** * Classe utilitária que permite usar facilmente a API de reflexão do Java */ classe pública BeanUtil { /** */ string final estática privada GET = “GET”; /** */ string final estático privado SET = “SET”; // ————————————————『novaInstância』 /** * Gera e retorna uma instância da string "className". * @param className nome de classe totalmente qualificado * @return nova instância do nome de classe totalmente qualificado * @throws Exceção */ objeto estático público newInstance (String className) lança exceção { tentar { return Class.forName(className).newInstance(); } catch (NoClassDefFoundError e) { System.err.println(“NoClassDefFoundError:” + className); jogue e; } } /** * Gera e retorna uma instância da string "className". * @param className nome de classe totalmente qualificado * Argumento do construtor @param argObj * @return nova instância do nome de classe totalmente qualificado * @throws Exceção */ objeto estático público newInstance (String className, Object [] argObj) lança exceção { Classe[] argClass = new Classe[argObj.length]; for (int i = 0; i < argObj.length; i++) { argClass[i] = argObj[i].getClass(); } Construtor c = Class.forName(className).getConstructor(argClass); retornar c.newInstance(argObj); } /** * Crie e retorne uma instância da classe 'clazz'. * @param classe clazz * @return nova instância do clazz * @throws Exceção */ objeto estático público newInstance (classe clazz) lança exceção { retornar clazz.newInstance(); } /** * Crie e retorne uma instância da classe 'clazz'. * @param classe clazz * Argumento do construtor @param argObj * @return nova instância do clazz * @throws Exceção */ objeto estático público newInstance (classe clazz, objeto [] argObj) lança exceção { Classe[] argClass = new Classe[argObj.length]; for (int i = 0; i < argObj.length; i++) { argClass[i] = argObj[i].getClass(); } Construtor c = clazz.getConstructor(argClass); retornar c.newInstance(argObj); } // ———————————————— 『Método』 /** * Método setter do campo “fieldName” do objeto “invokeObject” * Ligue, armazene o valor 'valor'. * * Se não houver método setter, defina o valor diretamente no campo. * Porém, neste caso, o modificador de acesso da propriedade alvo deve ser público. * @param invocaObject Objeto a ser executado * @param fieldName Nome da propriedade do objeto a ser executado * @param valor valor a ser definido * @throws Exceção A seguinte exceção ocorre. * @throws InvocationTargetException se o método subjacente lançar uma exceção * @throws IllegalAccessException Se este objeto Method for Java * Quando o controle de acesso ao idioma é implementado e o método subjacente não pode ser acessado * @throws NoSuchMethodException se um método com o nome especificado não for encontrado */ public static void setProperty(Objeto invocarObjeto, String nomeDoCampo, Valor do objeto) lança exceção { tentar { Método método = searchMethod(invokeObject, fieldName, SET); Class[] paramClasses = método.getParameterTypes(); Object[] valorArray = null; if (paramClasses[0].isInstance(valor)) { //Não converte se o objeto a ser definido for uma subclasse da classe de argumento. arrayArray = new Object[] { valor }; } outro { valueArray = new Object[] { convObject(valor, paramClasses[0] .getNome()) }; } método.invoke(invokeObject, valueArray); } catch (NoSuchMethodException e) { tentar { // Se não houver método setter, configure-o diretamente no campo. setField(invokeObject, nomecampo, valor); } catch (NoSuchFieldException fe) { String errorMes = “\nClasse” + getShortClassName(invokeObject) + “é” + “para campo “” + nomedocampo + “”\n” + “Não existe um método setter acessível e.” + “Campo “” + nomeDoCampo + “” também não é público. ”+“”; lançar nova IllegalAccessException(errorMes); } } } /** * Método getter do campo fieldName do objeto invocaObject * Obtenha o valor da chamada. * Caso não exista método getter, o valor será obtido diretamente do campo. * Porém, neste caso, o modificador de acesso da propriedade alvo deve ser público. * @param invocaObject Objeto a ser executado * @param fieldName Nome da propriedade do objeto a ser executado * @return valor de retorno do método getter * @throws Exceção A seguinte exceção ocorre. * @throws InvocationTargetException se o método subjacente lançar uma exceção * @throws IllegalAccessException Se este objeto Method for Java * Quando o controle de acesso ao idioma é implementado e o método subjacente não pode ser acessado * @throws NoSuchFieldException se um campo com o nome especificado não for encontrado */ objeto estático público getProperty (objeto invocarobjeto, string nomedocampo) lança exceção { tentar { Método método = searchMethod(invokeObject, fieldName, GET); retornar método.invoke(invokeObject, null); } catch (NoSuchMethodException e) { return getField(invokeObject, nomeDoCampo); } } /** * Executa o método "callMethod" do objeto "invokeObject". * Se houver um valor de retorno, ele poderá ser obtido como um tipo de objeto. * @param invocaObject Objeto a ser executado * @param callMethod Nome do método a ser executado * @param argObjects Se houver um argumento, passe-o como um array de objetos. * Passe nulo se não houver argumento. * @return Valor de retorno da execução de "callMethod" * @throws InvocationTargetException se o método subjacente lançar uma exceção * @throws IllegalAccessException Se este objeto Method for Java * Quando o controle de acesso ao idioma é implementado e o método subjacente não pode ser acessado * @throws NoSuchMethodException se um método com o nome especificado não for encontrado */ invocação de objeto estático público (objeto invoqueObject, String callMethod, Object[] argObjects) lança InvocationTargetException, IllegalAccessException, NoSuchMethodException { Método método = findMethod(invokeObject, callMethod, argObjects); retornar método.invoke(invokeObject, argObjects); } /** * Procure pelo método 'callMethod' do objeto 'invokeObject'. * @param invocaObject Objeto a ser executado * @param callMethod Nome do método do objeto a ser executado * @param argObjects Se houver um argumento, passe-o como um array de objetos. * Passe nulo se não houver argumento. * @return Objeto de método que corresponde às condições de argumento especificadas * @throws NoSuchMethodException Se nenhum método correspondente for encontrado, * Ou se o nome for “ " ou " "no caso de */ Método estático público findMethod (Objeto invocarObject, String callMethod, Object[] argObjects) lança NoSuchMethodException { Class[] paramClasses = null; Método[] métodos = invocaObject.getClass().getMethods(); topo: for (int i = 0; i < métodos.length; i++) { if (métodos[i].getName().equals(callMethod)) { if (argObjects == null && métodos[i].getParameterTypes().length == 0) { métodos de retorno[i]; } if (argObjects == null) { continuar; } paramClasses = métodos[i].getParameterTypes(); if (paramClasses.length == argObjects.length) { // Valida todos os tipos de lista de parâmetros e tipos de argumentos for (int j = 0; j < paramClasses.length; j++) { Classe paramClass = paramClasses[j]; Objeto argObj = argObjects[j]; // Se o tipo de argumento for primitivo, o objeto de argumento // não é nulo e é primitivo //Se for uma subclasse de Number, tudo bem. if (argObj == nulo) { continuar; } if (paramClass.isPrimitive() && (argObj instância de Número || argObj .getClass().isPrimitive())) { continuar; } if (!paramClass.isInstance(argObj)) { // Prossegue para o próximo método quando os tipos não são compatíveis com conversão implícita continue no topo; } } métodos de retorno[i]; } } } String paramLength = (paramClasses != null) ?Inteiro .toString(paramClasses.length): “”; String errorMes = getShortClassName(invokeObject) + “método” + callMethod + “Não existe.” + “[ paramClasses.length ] = ” + paramLength + “,[ argObjects.length ] = ” + argObjects.length + “”; lançar novo NoSuchMethodException(errorMes); } // ----------------------"Campo" /** * Valor para o nome do campo "fieldName" do objeto "invokeObject" a ser executado * Armazena "valor". * @param invocaObject Objeto a ser executado * @param fieldName Nome do campo do objeto a ser executado * @param valor valor a ser definido * @throws IllegalAccessException Se o objeto especificado for * campo (ou sua subclasse ou implementador) * Se não for uma instância de classe ou interface, declare * ou se a conversão de desempacotamento falhar * @throws NoSuchFieldException se um campo com o nome especificado não for encontrado */ public static void setField(Objeto invocarObjeto, String nomeDoCampo, Valor do objeto) lança IllegalAccessException, NoSuchFieldException { Campo campo = searchField(invokeObject, fieldName); String className = field.getType().getName(); Objeto convObj = null; if (field.getType().isInstance(valor)) { convObj = valor; } outro { convObj = convObject(valor, nomedaclasse); } field.set(invokeObject, convObj); } /** * Defina o valor do nome do campo "fieldName" do objeto de execução "invokeObject" como * Pegar. * @param invocaObject Objeto a ser executado * @param fieldName Nome do campo do objeto a ser executado * @return valor de retorno * @throws IllegalAccessException Se o objeto especificado for * campo (ou sua subclasse ou implementador) * Se não for uma instância de classe ou interface, declare * ou se a conversão de desempacotamento falhar * @throws NoSuchFieldException se um campo com o nome especificado não for encontrado */ objeto estático público getField (objeto invocarobjeto, string nomedocampo) lança IllegalAccessException, NoSuchFieldException { Campo campo = searchField(invokeObject, fieldName); retornar campo.get(invokeObject); } /** * Verifique se o objeto "object" declara o nome do campo "fieldName" * confirme. * @param object Objeto a ser inspecionado * @param fieldName Nome do campo a ser inspecionado * @return verdadeiro se declarado * @throws Exceção */ hasField booleano estático público (objeto objeto, String nomedocampo) lança exceção { PropertyDescriptor[] props = getPropertyDescriptors(objeto); for (int i = 0; i < props.length; i++) { String _fieldName = props[i].getName(); if (nomecampo.equals(_nomecampo)) { retornar verdadeiro; } } retorna falso; } /** * * @param objeto * @retornar * @throws Exceção */ public static TreeSet getAllFields (objeto objeto) lança exceção { TreeSet fieldSet = new TreeSet(); // Obtém o nome da propriedade do método PropertyDescriptor[] props = getPropertyDescriptors(objeto); for (int i = 0; i < props.length; i++) { String nomeDoCampo = props[i].getNome(); fieldSet.add(campoNome); } // Obtém o nome da propriedade do campo Campo[] campos = object.getClass().getFields(); for (int i = 0; i <campos.comprimento; i++) { String nomeDoCampo = campos[i].getNome(); if (!fieldSet.contains(fieldName)) { fieldSet.add(campoNome); } } retornar campoSet; } /** * * @param invocaObject Objeto a ser executado * @param fieldName Nome do campo do objeto a ser executado * @return Objetos arquivados que correspondem às condições de argumento especificadas * @throws NoSuchFieldException se um campo com o nome especificado não for encontrado */ Campo estático privado searchField (Objeto invocarObject, String fieldName) lança NoSuchFieldException { tentar { retornar invocarObject.getClass().getField(fieldName); } catch (NoSuchFieldException e) { //Este escopo é obtido a partir do nome da coluna da tabela nomeDoCampo = verificarNomeCampo(NomeCampo); Campo[] campos = invocaObject.getClass().getFields(); for (int i = 0; i <campos.comprimento; i++) { if (fields[i].getName().equalsIgnoreCase(fieldName)) { campos de retorno[i]; } } lançar novo NoSuchFieldException(fieldName); } } // ----------------------" outros " /** * Obtenha o nome da classe não qualificada de um objeto. * @param objeto * @retornar */ public static String getShortClassName (objeto objeto) { if (objeto == nulo) { retorne “nulo”; } String nome = object.getClass().getName(); return getShortClassName(nome); } /** * Obtenha o nome da classe a partir do nome totalmente qualificado. * @param nomedaclasse * @retornar */ public static String getShortClassName(String className) { int índice = className.lastIndexOf(“.”); return nomedaclasse.substring(índice + 1); } /** * Altere o nome do campo do nome do método. Está em conformidade com as convenções JavaBeans * é preciso. * @param nome do método * @retornar */ public static String getFieldName(String nomemétodo) { String nomeDoCampo = null; if (nomedométodo.startsWith(“é”)) { nomedocampo = nomedométodo.substring(2); } outro { nomedocampo = nomedométodo.substring(3); } nomecampo = convString(nomecampo, 0, “L”); return nomeDoCampo; } /** * Verifique se o nome completo "className" é um nome de classe existente. * @param nomedaclasse * @retornar */ public static boolean isClassExist(String className) { tentar { Class.forName(className); retornar verdadeiro; } catch (Exceção e) { retorna falso; } } mapa estático final privado beanInfoCache = new HashMap(); /** * Retorna um PropertyDescriptor que contém informações do objeto para "objeto". * @param objeto * @retornar * @throws IntrospectionException */ PropertyDescriptor estático público [] getPropertyDescriptors (objeto objeto) lança IntrospectionException { BeanInfo beanInfo = (BeanInfo) beanInfoCache.get(object.getClass()); if (beanInfo == nulo) { beanInfo = Introspector.getBeanInfo(object.getClass()); beanInfoCache.put(object.getClass(), beanInfo); } // BeanInfo beanInfo = Introspector.getBeanInfo(object.getClass()); retornar beanInfo.getPropertyDescriptors(); } // ————————————————————————– // ———————————————“Método privado abaixo” // ————————————————————————– /** * Procure o método acessador para o argumento fieldName com base em PropertyDescriptor. * @param invocaObject Objeto a ser executado * @param fieldName nome do campo * @param tipo Método Getter ⇒ Método Getter GET ⇒ SET * @return Objeto de método que corresponde às condições de argumento especificadas * @throws NoSuchMethodException Se nenhum método correspondente for encontrado, * Ou se o nome for “ " ou " ” * no caso de * @throws IntrospectionException */ Método estático privado searchMethod (Objeto invocarObject, String fieldName, Tipo String) lança NoSuchMethodException, IntrospectionException { Método método = null; nomeDoCampo = verificarNomeCampo(NomeCampo); PropertyDescriptor[] props = getPropertyDescriptors(invokeObject); for (int i = 0; i < props.length; i++) { String nome = adereços[i].getName(); if (!name.equalsIgnoreCase(fieldName)) { continuar; } if (type.equals(GET)) { método = adereços[i].getReadMethod(); } outro { método = adereços[i].getWriteMethod(); } if (método == nulo) { continuar; } método de retorno; } //Se o método não existir. throw new NoSuchMethodException(“A classe não possui métodos.” + “(Não diferencia maiúsculas de minúsculas.): ” + type.toLowerCase() + convString(campoNome, 0, “U”) + “()”); } /** * Verifica se o argumento fieldName é um nome de coluna; se for um nome de coluna, * Converta de volta. * * MAIL_ADDRESS ⇒ MAILADDRESS ↓ mailaddress = mailAddress * @param fieldName nome do campo ou nome da coluna * @return nome do campo */ private static String checkFieldName(String nomeDoCampo) { int índice = fieldName.indexOf(“_”); enquanto (verdadeiro) { if (índice == -1) { return nomeDoCampo; } StringBuffer convcloumn = new StringBuffer(fieldName); convcloumn.deleteCharAt(índice); nomedocampo = convcloumn.toString(); índice = nomeDoCampo.indexOf(“_”); } } /** * Converte o objeto a ser convertido, object, para o tipo convClassName. * * @param object Objeto a ser convertido * @param convClassName string de classe do tipo a ser convertido * @return o objeto convertido */ objeto estático privado convObject (objeto objeto, String convClassName) { if (objeto == nulo) { // Retornar nulo ao converter para um tipo primitivo resultará em erro. // Faça dele um wrapper para 0. if (convClassName.equals(“int”)) { retornar novo inteiro(0); } else if (convClassName.equals(“longo”)) { retornar novo Long(0); } outro { retornar nulo; } } if (object.getClass().getName().equals(convClassName)) { objeto de retorno; } // —————————————-『objeto instanceof String』 if (objeto instância de String) { if (convClassName.equals(“java.lang.String”)) { objeto de retorno; } else if (convClassName.equals(“java.lang.Long”) || convClassName.equals(“longo”)) { String str = (String) objeto; if (isExist(str)) { // Será ruim se você não converter para BigDecimal uma vez // 1000.00000 BigDecimal grande = novo BigDecimal(str); retornar novo Long(big.longValue()); } outro { // Se str for um literal de shell, defina o valor inicial como “0” retornar novo Long(0); } } else if (convClassName.equals(“java.sql.Date”)) { retornar paraSqlDate((String) objeto); } else if (convClassName.equals(“java.sql.Timestamp”)) { Data data = objeto toSqlDate((String)); retornar novo carimbo de data/hora (date.getTime()); } else if (convClassName.equals(“java.lang.Integer”) || convClassName.equals(“int”)) { // Se str for um literal de shell, defina o valor inicial como “0” String str = (String) objeto; if (isExist(str)) { BigDecimal grande = novo BigDecimal(str); retornar novo Inteiro(big.intValue()); } outro { retornar novo inteiro(0); } } else if (convClassName.equals(“boolean”)) { retornar Boolean.valueOf(object.toString()); } else if (convClassName.equals(“java.math.BigDecimal”)) { String temp = ((String) objeto).trim(); // Se temp.length() == 0, é seguro defini-lo como nulo em vez de 0. if (temp.comprimento() == 0) { retornar nulo; } outro { retornar novo BigDecimal(temp); } } throwNoSupprt(objeto, convClassName); } // ——————————— “objeto instância de java.sql.Date” senão if (objeto instância de java.sql.Date) { if (convClassName.equals(“java.lang.String”)) { retornar toStringDate((java.sql.Date) objeto, “aaaa/MM/dd”); } else if (convClassName.equals(“java.sql.Date”)) { objeto de retorno; } else if (convClassName.equals(“java.sql.Timestamp”)) { retornar novo objeto Timestamp(((Data)).getTime()); } throwNoSupprt(objeto, convClassName); } // ————————————-『objeto instanceof Timestamp』 senão if (objeto instância de carimbo de data/hora) { muito tempo = ((Timestamp) objeto).getTime(); if (convClassName.equals(“java.lang.String”)) { return toStringDate(hora, “aaaa/MM/dd HH:mm:ss”); } else if (convClassName.equals(“java.sql.Date”)) { retornar novo java.sql.Date(hora); } else if (convClassName.equals(“java.sql.Timestamp”)) { objeto de retorno; } throwNoSupprt(objeto, convClassName); } // —————————————-『objeto instanceof Integer』 senão if (objeto instância de número inteiro) { if (convClassName.equals(“java.lang.Integer”) || convClassName.equals(“int”)) { objeto de retorno; } else if (convClassName.equals(“java.lang.String”)) { retornar object.toString(); } else if (convClassName.equals(“java.lang.Long”) || convClassName.equals(“longo”)) { retornar novo objeto Long(((Integer)).longValue()); } else if (convClassName.equals(“java.math.BigDecimal”)) { retornar novo objeto BigDecimal(((Integer)).intValue()); } throwNoSupprt(objeto, convClassName); } // ——————————————『objeto instanceof Long』 senão if (objeto instância de Long) { if (convClassName.equals(“java.lang.Long”) || convClassName.equals(“longo”)) { objeto de retorno; } else if (convClassName.equals(“java.lang.String”)) { retornar object.toString(); } else if (convClassName.equals(“java.lang.Integer”) || convClassName.equals(“int”)) { retornar novo Inteiro(((Long) objeto).intValue()); } else if (convClassName.equals(“java.math.BigDecimal”)) { retornar novo objeto BigDecimal(((Long) object).longValue()); } throwNoSupprt(objeto, convClassName); } // —————————————-『objeto instanceof Double』 senão if (objeto instância de duplo) { if (convClassName.equals(“java.lang.String”)) { //NÚMERO DA COLUNA(8,0) // oracle do Windows > BigDecimal // oráculo UNIX > Duplo BigDecimal grande = novo objeto BigDecimal(((Double)).doubleValue()); escala interna = big.scale(); se (escala == 0) { retornar big.toString(); } outro { // Não suportado se o arredondamento for necessário. throwNoSupprt(objeto, convClassName); } } if (convClassName.equals(“java.lang.Integer”) || convClassName.equals(“int”)) { retornar novo Inteiro(((Double) objeto).intValue()); } else if (convClassName.equals(“java.lang.Long”) || convClassName.equals(“longo”)) { retornar novo objeto Long(((Double)).longValue()); } else if (convClassName.equals(“java.math.BigDecimal”)) { retornar novo objeto BigDecimal(((Double)).doubleValue()); } throwNoSupprt(objeto, convClassName); } // ————————————“ instância do objeto BigDecimal ” senão if (objeto instância de BigDecimal) { if (convClassName.equals(“java.lang.String”)) { retornar object.toString(); } else if (convClassName.equals(“java.lang.Long”) || convClassName.equals(“longo”)) { retornar novo objeto Long(((BigDecimal)).longValue()); } else if (convClassName.equals(“java.lang.Integer”) || convClassName.equals(“int”)) { retornar novo objeto Integer(((BigDecimal)).intValue()); } throwNoSupprt(objeto, convClassName); } // —————————————-『objeto instância de byte[]』 senão if (objeto instância de byte[]) { if (convClassName.equals(“java.sql.Blob”)) { objeto de retorno; } throwNoSupprt(objeto, convClassName); } // ———————————————“objeto é booleano” senão if (objeto instância de Boolean) { if (convClassName.equals(“boolean”)) { objeto de retorno; } throwNoSupprt(objeto, convClassName); } // ———————————————-『objeto é booleano[]』 senão if (objeto instância de boolean[]) { if (convClassName.equals(“java.lang.String”)) { boolean[] bs = (boolean[]) objeto; StringBuffer buff = new StringBuffer(“[“); for (int i = 0; i <bs.length; i++) { buff.append(bs[i] + “,”); } buff.deleteCharAt(buff.length() – 1); buff.append(“]”); retornar buff.toString(); } throwNoSupprt(objeto, convClassName); } throwNoSupprt(objeto, convClassName); retornar nulo; } /** * Lança se a conversão não for suportada. * * @param object Objeto a ser convertido * @param convClassName Digite para converter */ private static void throwNoSupprt (objeto objeto, String convClassName) { String className = (objeto! = null) ?objeto.getClass().getName() : "nulo"; String errorMess = “\nO processamento de conversão de tipo para este objeto ainda não é suportado.\n” + ”[Objeto] =” + objeto + “,[Tipo de objeto] =” + nomedaclasse + “,[ convertClass ] = ” + convClassName + “”; lançar novo UnsupportedOperationException(errorMess); } /** * Converte o caractere na posição [index] da string [str] para maiúscula ou minúscula. * * @param str String a ser avaliada * @param index Posição especificada * @param toCase Converter para maiúsculas ⇒ U | u Converter para minúsculas ⇒ L | l * @return String após a conversão */ private static String convString(String str, int index, String toCase) { if (str == nulo || str.trim().length() == 0) { retornar string; } outro { String temp = str.substring(índice, índice + 1); if (toCase.equalsIgnoreCase(“u”)) { temp = temp.toUpperCase(); } outro { temp = temp.toLowerCase(); } StringBuffer tempBuffer = new StringBuffer(str); tempBuffer.replace(índice, índice + 1, temp); retornar tempBuffer.toString(); } } /** * Verifique se [valor] é um valor válido. * * @param valor String a ser avaliada * @return [true]: Se não for nulo e não “” */ private static boolean isExist(String valor) { if (valor! = nulo && valor.comprimento()! = 0) { retornar verdadeiro; } retorna falso; } /** * classe java.util.Date ou sua subclasse no formato especificado * Converta em string. * @param data classe java.util.Date a ser convertida * @param padrão especificado formato * @return string de data formatada */ private static String toStringDate(Data data, String padrão) { SimpleDateFormat sdFormat = new SimpleDateFormat(padrão); retornar sdFormat.format(data); } private static java.sql.Date toSqlDate (String strDate) { Calendário cal = toCalendar(strDate); retornar paraSqlDate(cal); } private static java.sql.Date toSqlDate (Calendário cal) { longo l = cal.getTime().getTime(); retornar novo java.sql.Date(l); } /** * Converte um valor de longa data em uma string no formato especificado. * @param time Um valor longo que representa milissegundos da hora atual. * @param padrão especificado formato * @return string de data formatada */ private static String toStringDate(tempo longo, padrão String) { return toStringDate(nova Data(hora), padrão); } /** * String ⇒ java.sql.Date * * Converta a seguinte string de data em 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 * @retornar */ calendário estático privado toCalendar(String strDate) { strData = formato(strData); Calendário cal = Calendar.getInstance(); int aaaa = 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(Calendário.HOUR_OF_DAY); int mm = cal.get(Calendário.MINUTE); int ss = cal.get(Calendário.SECOND); int SSS = cal.get(Calendário.MILLISECOND); cal.claro(); cal.set(aaaa, MM – 1, dd); int len = strDate.length(); mudar (len) { caso 10: quebrar; caso 16: // aaaa/MM/dd HH:mm HH = Integer.parseInt(strDate.substring(11, 13)); mm = Integer.parseInt(strDate.substring(14, 16)); cal.set(Calendário.HOUR_OF_DAY, HH); cal.set(Calendário.MINUTE, mm); quebrar; 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(Calendário.HOUR_OF_DAY, HH); cal.set(Calendário.MINUTE, mm); cal.set(Calendário.SEGUNDO,ss); quebrar; 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(Calendário.HOUR_OF_DAY, HH); cal.set(Calendário.MINUTE, mm); cal.set(Calendário.SEGUNDO,ss); cal.set(Calendário.MILLISECOND, SSS); quebrar; padrão: lançar new IllegalStateException( “Esta string String não pode ser convertida em uma string de data:” +strData); } retornar cal; } /** * Qualquer string de data como “aaaa/MM/dd” ou “aaaa/MM/dd HH:mm:ss” * Tentativas de converter para formato. * Exemplo: 01/03/3 ⇒ 03/01/2003 * @param strDate * @retornar */ formato de string estático privado (String strDate) { strDate = strDate.trim(); String aaaa = null; Sequência MM = nulo; String dd = nulo; String HH = nulo; Sequência mm = nulo; String ss = nulo; String SSS = nulo; //Se “-” ou “/” estiver faltando if (strDate.indexOf(“/”) == -1 && strDate.indexOf(“-“) == -1) { if (strDate.length() == 8) { aaaa = strDate.substring(0, 4); MM = strDate.substring(4, 6); dd = strDate.substring(6, 8); retornar aaaa + “/” + MM + “/” + dd; } outro { aaaa = strDate.substring(0, 4); MM = strDate.substring(4, 6); dd = strDate.substring(6, 8); HH = strDate.substring(9, 11); mm = strDate.substring(12, 14); ss = strDate.substring(15, 17); retornar aaaa + “/” + MM + “/” + dd + ” ” + HH + “:” + mm + “:” +ss; } } Token StringTokenizer = new StringTokenizer(strDate, “_/-:. “); Resultado StringBuffer = new StringBuffer(); for (int i = 0; token.hasMoreTokens(); i++) { String temp = token.nextToken(); mudar (eu) { caso 0:// ano parte aaaa = fillString(strDate, temp, “f”, “20”, 4); resultado.append(aaaa); quebrar; caso 1: // parte do mês MM = fillString(strDate, temp, “f”, “0”, 2); resultado.append(“/” + MM); quebrar; caso 2: // parte do dia dd = fillString(strData, temp, “f”, “0”, 2); resultado.append(“/” + dd); quebrar; caso 3: // parte do tempo HH = fillString(strDate, temp, “f”, “0”, 2); resultado.append(” ” + HH); quebrar; caso 4: // parte do minuto mm = fillString(strData, temp, “f”, “0”, 2); resultado.append(“:” + mm); quebrar; caso 5: // segunda parte ss = fillString(strDate, temp, “f”, “0”, 2); resultado.append(“:” + ss); quebrar; caso 6: // parte do milissegundo SSS = fillString(strDate, temp, “b”, “0”, 3); resultado.append(“.” + SSS); quebrar; } } retornar resultado.toString(); } String estática privada fillString (String strDate, String str, Posição da string, String addStr, int len) { if (str.length() > len) { String mes = strDate + “Esta string String não pode ser convertida em uma string de data”; lançar novo IllegalStateException(mes); } return fillString(str, posição, addStr, len); } /** * Adicione a string [addStr] para ser adicionada à string [str] em [posição] em [len] * Insira até ficar cheio. * * Exemplo: String ss = StringUtil.fillString(“aaa”,”b”,”0″,7); ss ⇒ “aaa0000” * * *fillString() insere até que len seja preenchido, mas addString() insere len. * * @param str string de destino * @param position Inserir antes ⇒ F/f Inserir depois ⇒ B/b * @param addStr String a ser inserida * @param len Número de dígitos a serem reabastecidos * @return A string após a conversão. [str] é literal nulo ou vazio, [addStr] é definido como [len] * Retorna resultados inseridos até ficar satisfeito. */ string estática privada fillString (String str, posição da string, String addStr, int len) { StringBuffer tempBuffer = null; if (!isExist(str)) { tempBuffer = new StringBuffer(); for (int i = 0; i < len; i++) { tempBuffer.append(addStr); } retornar tempBuffer.toString(); } else if (str.length() != len) { tempBuffer = new StringBuffer(str); while (len > tempBuffer.length()) { if (posição.equalsIgnoreCase(“f”)) { tempBuffer.insert(0, addStr); } outro { tempBuffer.append(addStr); } } retornar tempBuffer.toString(); } retornar string; } }

URLをコピーしました！