1. Reflexão em Java
1. Carregue os atributos da classe e o código da instância do método através da reflexão:
/*** java.lang.class é a fonte de reflexão* Criamos uma classe e geramos o arquivo de classe correspondente compilando (javac.exe). Depois de carregarmos (carregador de classe da JVM), este arquivo de classe* depois que este arquivo de classe for carregado na memória, é uma classe de tempo de execução com uma área de cache. Esta aula de tempo de execução é uma instância da classe * Cada aula de tempo de execução é carregada apenas uma vez, */ classe <Conturexam> clazz = studentExam.class; StudentExam studentExam = clazz.newinstance (); System.err.println (StudentExam); System.out.println (clazz); // campo de campo = clazz.getfield ("id"); // Ligue para o atributo especificado da classe de tempo de execução através do atributo: o atributo é o campo do tipo público de tipo = clazz.getDecaredfield ("id"); // O atributo é o campo não-público [] campos = clazz.getDecLaredFields (); // recebe todas as propriedades declaradas da própria classe de tempo de execução (a classe pai não pode fazer). A classe pai usa clazz.getfields (); for (campo de campo2: campos) {int i = field2.getModifiers (); String type = modifier.toString (i); // Obtenha o tipo de dados de atributo de campo System.out.println (type); } field.setAccessible (true); field.set (StudentExam, 11); System.err.println (studentExam.getId ()); // Ligue para o método especificado da classe de tempo de execução através do método de reflexão Método = clazz.getMethod ("SetId", Integer.class); Method.inVoke (StudentExam, 123); // Ligue para o método especificado do método da classe de tempo de execução [] métodos = clazz.getMethods (); // obtém todos os métodos declarados como públicos em todas as classes de tempo de execução e em suas classes pais [] métodos2 = clazz.getDecLaredMethods (); // Obtenha o método declarado na própria classe de execução para (método Method2: Methods) {System.out.println (MethodetName ()); } // * Obtenha a classe de tempo de execução do objeto através do método getClass () do objeto, exame exame = new Exam (); Classe clazzExam = exam.getclass ();2. Classeloader
/** * Descrição: Classe carregador, carregue o arquivo xx.properties e leia os dados * @param * @author xiazhongwei * @data 29 de setembro de 2016: 17:32:56 * @return */public void classLoader () lança thisoException {// métod. // O caminho é escrito sob o pacote: com // capaz // onlinexam // resources // config.properties inputStream Instruam = carregador.getResourceasStream ("config.properties"); // Método 2. Carregue o arquivo do caminho especificado // FileInputStream fileInputStream = new FileInputStream (new File ("config.properties")); Propriedades Propriedades = new Properties (); Propriedades.Load (Instruam); // Properties.Load (FILEInputStream); String prop = Properties.getProperty ("domínio"); System.out.println (prop); }3. Proxy dinâmico
Proxy estático: os tipos de classe proxy e o objeto de destino são determinados durante a compilação, o que não é propício à expansão do programa. Ao mesmo tempo, cada classe de proxy pode servir apenas uma interface; portanto, muitos proxy ocorrem inevitavelmente no desenvolvimento do programa.
Proxy dinâmico: o cliente chama métodos de outros objetos por meio da classe Proxy e cria dinamicamente o objeto proxy da classe de destino, conforme necessário quando o programa estiver em execução.
Princípios do padrão de design de agentes:
Use um proxy para envolver o objeto e substitua o objeto original por esse objeto proxy. Qualquer chamada para o objeto original deve ser através do proxy, seja e quando o objeto proxy determina se e quando o método é chamado
pacote com.test.junit; importar java.lang.reflect.invocationHandler; importar java.lang.reflect.method; importar java.lang.reflect.proxy; classe pública proxytest {public static void main (string [] args) {realsubject realsubject = new realsubject (); MyInvocationHandler myInvocationHandler = new MyInvocationHandler (); Objeto objeto = myInvocationHandler.bind (realsubject); Sujeito objeto = (sujeito) objeto; sujeito.Action (); }} // Uso da interface proxy dinâmica Assunto {void action ();} // class RealSubject implementa o assunto {@Override public void Action () {System.out.println ("Eu sou a classe Proxy, lembre -se de me executar ..."); } } class MyInvocationHandler implements InvocationHandler{ Object object;// Declaration of the object of the proxy class of the interface/** * Description: ① Instantiate the proxy object ② Return a proxy class object* @param * @author xiazhongwei * @data September 29, 2016: 4:13:43 pm * @return */ public Object bind(Object object){ this.Object = Object; return proxy.newproxyInstance (object.getClass (). getClassLoader (), object.getClass (). getInterfaces (), this); } / ** * Quando uma chamada para o método reescrita é iniciada por meio de um objeto da classe Proxy, ele será convertido em uma chamada para o seguinte método Invok * / @Override Public Object Invoke (proxy do objeto, método do método, objeto [] args) lança arrastável {objeto returnObject = Method.inVoke (objeto, Args); return returnObject; }}4. Proxy dinâmico e AOP
Exemplo 1.
pacote com.atguigu.spring.aop; interface pública aritmeticcalculator {int add (int i, int j); int sub (int i, int j); int mul (int i, int j); int div (int i, int j);} pacote com.atguigu.spring.aop; importar org.springframework.tereotype.component; @Component ("aritmeticCalCulator") classe pública arithmeticcalculatorImpl implementa aritmeticcalculator {@Override public int add (int i, int j) {int resultado = i + j; resultado de retorno; } @Override public int sub (int i, int j) {int resultado = i - j; resultado de retorno; } @Override public int mul (int i, int j) {int resultado = i * j; resultado de retorno; } @Override public int div (int i, int j) {int resultado = i / j; resultado de retorno; }} pacote com.atguigu.spring.aop; classe pública arithmeticCalCulatorLogGingImpl implementa aritmeticcalculator {@Override public int add (int i, int j) {System.out.println ("O método add começa com [" + i + "," + j + "]"); int resultado = i + j; System.out.println ("O método adiciona termina com" + resultado); resultado de retorno; } @Override public int sub (int i, int j) {System.out.println ("O sub -método começa com [" + i + "," + j + "]"); int resultado = i - j; System.out.println ("O sub -método termina com" + resultado); resultado de retorno; } @Override public int mul (int i, int j) {System.out.println ("O método MUL começa com [" + i + "," + j + "]"); int resultado = i * j; System.out.println ("O método MUL começa com [" + i + "," + j + "]"); int resultado = i * j; System.out.println ("O método MUL termina com" + resultado); resultado de retorno; } @Override public int div (int i, int j) {System.out.println ("O método div começa com [" + i + "," + j + "]"); int resultado = i / j; System.out.println ("O método div termina com" + resultado); resultado de retorno; }} pacote com.atguigu.spring.aop; importar java.lang.reflect.invocationHandler; importar java.lang.reflect.method; importar java.lang.reflect.proxy; importar java.util.arrays; classe pública ArithmeticCalCulatorLoggingProxy {// Objeto para ser o alvo de aritmético privado de proxy; public arithmeticCalCulatorLoggingProxy (alvo aritmético do Calculator) {super (); this.target = Target; } // retorna o objeto proxy public aritmeticcalculator getLoggingproxy () {aritmeticcalculator proxy = null; // Qual carregador de classe do objeto proxy é responsável por carregar o carregador de classe = Target.getClass (). GetClassLoader (); // O tipo de objeto proxy, ou seja, quais métodos existem nele. Classe [] interfaces = nova classe [] {arithmeticCalculator.class}; // Ao chamar os métodos do objeto Proxy, execute o seguinte Código InvocationHandler H = new InvocationHandler () { /*** Proxy: Proxy Object. Esse objeto geralmente não é usado* Método: o método que está sendo chamado* args: os parâmetros passados no método de chamada*/ @Override Public Object Invoke (proxy do objeto, método do método, objeto [] args) lança lançável {// Um método do objeto proxy não será chamado diretamente dentro do método. proxy.toString () fará com que um loop morto chame o método de invasão String MethodName = Method.getName (); // imprima o log System.out.println ("[Antes] o método" + MethodName + "começa com" + Arrays.asList (args)); // chamando o resultado do objeto do método de destino = nulo; tente {// resultado pré-notificação = method.invoke (destino, args); // Notificação de retorno, você pode acessar o valor de retorno do método} catch (nullPointerException e) {e.printStackTrace (); // Notificação de exceção, você pode acessar a exceção do método} // pós-notificação. Como o método pode ter uma exceção, o valor de retorno do método não pode ser acessado // Print Log System.out.println ("[Após] o método termina com" + resultado); resultado de retorno; }}; /*** Loader: o carregador de classe usado pelo objeto proxy. * Interfaces: especifique o tipo de objeto proxy. Ou seja, quais métodos podem ser encontrados no objeto Proxy Proxy. * H: Ao chamar o método do objeto proxy, como ele deve responder? De fato, é para chamar o método Invoke de InvocationHandler*/ proxy = (aritmeticcalculator) proxy.newproxyInstance (carregador, interfaces, h); Retornar proxy; }} pacote com.atguigu.spring.aop; importar org.springframework.context.applicationContext; importar org.springframework.context.support.classpathxmlapplicationContext; classe pública main {public static void main (string [] args) {// aritmeticcalculator aritmeticcalculator = novo aritmeticcalculatorImpl (); Aritmeticcalculator aritmeticcalculator = novo arithmeticCalCulatorLoggingImpl (); aritmeticcalculator = novo arithmeticCalCulatorLoggingProxy (aritmeticcalculator) .getLoggingProxy (); int resultado = arithmeticcalculator.add (11, 12); System.out.println ("Resultado:" + resultado); resultado = aritmeticcalculator.div (21, 3); System.out.println ("Resultado:" + resultado); }}Exemplo 2.
pacote com.test.junit; importar java.lang.reflect.invocationHandler; importar java.lang.reflect.method; importar java.lang.reflect.proxy; classe pública proxytest {public static void main (string [] args) {realsubject realsubject = new realsubject (); MyInvocationHandler myInvocationHandler = new MyInvocationHandler (); Objeto objeto = myInvocationHandler.bind (realsubject); Sujeito objeto = (sujeito) objeto; sujeito.Action (); }} // Uso da interface proxy dinâmica Assunto {void action ();} // class RealSubject implementa o assunto {@Override public void Action () {System.out.println ("Eu sou a classe Proxy, lembre -se de me executar ..."); } } class MyInvocationHandler implements InvocationHandler{ Object object;// Declaration of the object of the proxy class of the interface/** * Description: ① Instantiate the proxy object ② Return a proxy class object* @param * @author xiazhongwei * @data September 29, 2016: 4:13:43 pm * @return */ public Object bind(Object object){ this.Object = Object; return proxy.newproxyInstance (object.getClass (). getClassLoader (), object.getClass (). getInterfaces (), this); } / ** * Quando uma chamada para o método reescrita é iniciada por meio de um objeto da classe Proxy, ele será convertido em uma chamada para o seguinte método Invok * / @Override Public Object Invoke (proxy do objeto, método do método, objeto [] args) lança arrastável {objeto returnObject = Method.inVoke (objeto, Args); return returnObject; }}Obrigado por ler este artigo, espero que possa ajudá -lo. Obrigado pelo seu apoio a este site!