O proxy dinâmico do Java foi explicado na API conectada ao Java, então não vou escrever aqui. O que eu entendo:
Estenda a funcionalidade de um método específico em uma interface específica, e esse é o proxy. Um proxy é um método de chamada através de um objeto de manipulador de chamadas associado a uma instância de proxy.
Vamos dar uma olhada nisso com um exemplo:
interface:
interface pública num {void show (); int getNum (); int getProduct (int x);} Classe de implementação:
public class MyNum implementa num {@Override public int getNum () {return 3; } @Override public int getProduct (int x) {return x; } @Override public void show () {System.out.println ("O método subjacente imprime o número 99"); }} Vamos primeiro olhar como o método de invocado é descrito na API
Ou seja, o manipulador de chamadas chama o método subjacente que representa o objeto do método para o objeto da classe de implementação da interface.
A primeira maneira de implementar o proxy:
classe pública numProxy {private objeto num; // Construa o objeto da classe de implementação da interface através do método do construtor public numProxy (objeto num) {this.num = num; } public Object getNumbyProxy () {objeto numProxy = proxy.NewProxyInstance (num.getclass (). getClassLoader (), nova classe [] {num.class}, new InvocationHandler () { /*** Método: o método correspondente ao método da interface chamado no registro do proxy. Array de parâmetro de métodos reais*/ @Override Objeto público Invoke (Método do Método, objeto [] args) lança {objeto obj = null; (Inteiro) OBJ * 2; retornar numproxy; }} A segunda maneira de implementar proxy: implementando a interface InvocationHandler
classe pública numproxyImpl implementa InvocationHandler {// Aqui eu concretei o tipo de interface e não é escrito como objeto privado num num num; public numProxyImpl (num num) {this.num = num; } @Override Public Object Invoke (proxy do objeto, método do método, objeto [] args) lança arremesso {objeto obj = null; String MethodName = Method.getName (); if ("getProduct" .Equals (MethodName)) {System.out.println ("Proxy: getProduct () start"); obj = métod.invoke (num, args); obj = (inteiro) obj * 2; System.out.println ("proxy: getProduct () end"); } else if ("show" .equals (métodname)) {System.out.println ("proxy: show () start"); obj = métod.invoke (num, args); System.out.println ("proxy: show () end"); } retornar obj; }} Código de teste:
classe pública testnum {public static void main (string [] args) {// teste numProxy np = new numProxy (new mynum ()); Num numProxy = (num) np.getnumbyProxy (); int x = numProxy.getProduct (2); System.out.println (x); numProxy.Show (); System.out.println ("-------------------"); NumProxyImpl npi = new NumProxyImpl (new MyNum ()); Num numPro = (num) proxy.newproxyInstance (num.class.getclassloader (), nova classe [] {num.class}, npi); int n = numPro.getProduct (3); System.out.println (n); numPro.show (); }} Resultados do console:
O segundo método está um pouco confuso. Não sei se você tem. Ou seja, é chamado de método Invoke no numProxyImpl que não é exibido, mas foi executado. Sim, vamos ver isso.
Se você não quer ser problemático, lembre -se disso.
Por exemplo, o processo de codificação pode ser usado para usar o proxy e escrever um exemplo na próxima vez.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.