Implementação de proxy dinâmico
Modo usado: Modo proxy.
A função do modo proxy é fornecer um proxy para outros objetos para controlar o acesso a esse objeto. Semelhante a uma agência de aluguel.
Dois proxy dinâmicos:
(1) proxy dinâmico JDK. O proxy dinâmico do JDK é implementado pelo mecanismo de reflexão dentro do Java. A classe de destino é baseada em uma interface unificada (InvocationHandler)
(2) O proxy dinâmico do CGLIB e a camada subjacente do proxy dinâmico do CGLIB são implementados com a ajuda do ASM. O proxy dinâmico implementado pela biblioteca de terceiros, como o CGLIB, é mais amplamente utilizado e tem mais vantagens em eficiência.
Principal Application Framework:
AOP na primavera, interceptador em struts2
Implementação específica:
1. Defina interfaces e implemente classes
pacote com.example.service; interface pública UserService {public string getName (int id); Public integer getage (int id);} pacote com.example.service.impl; import com.example.service.userService; public class UserServiceImpl implementa UserService {public String getName (int id) {System.out.println ("------ GetName -----"); retornar "gato"; } public integer getage (int id) {System.out.println ("------ getage -----"); retornar 10; }}2. Implementação de proxy dinâmico JDK
pacote com.example.jdk; importar java.lang.reflect.invocationHandler; importar java.lang.reflect.method; importar java.lang.reflect.proxy; classe pública myinvocationhandler implementa InvocationHandler {private objeto destino; / ** * Ligue o objeto delegado e retorne uma classe proxy * * @param destino * @return */ public objeto bind (objeto destino) {this.target = target; // Obtenha o proxy Objeto Return proxy.NewProxyInstance (Target.getClass (). GetClassLoader (), Target.getClass (). GetInterfaces (), este); // Para ligar a interface (este é um defeito, o cglib compensa esse defeito)} @Override Public Object Invoke (proxy do objeto, método do método, objeto [] args) lança arremesso {if ("getName" .equals (métod.getName ())) {System.out.println ("----- antes"; Resultado do objeto = method.invoke (alvo, args); System.out.println ("------ After" + method.getName () + "------"); resultado de retorno; } else {objeto resultado = métod.invoke (destino, args); resultado de retorno; }}} pacote com.example.jdk; import com.example.service.userService; importar com.example.service.impl.UserServiceImpl;/*** classe de teste*/public class Runjdk {public static void main (string [] argus) {myInvocationHaHandler proxy = newNinvocation main; UserService UserServiceProxy = (UserService) proxy.bind (new UserserviceImpl ()); System.out.println (UserServiceProxy.getName (1)); System.out.println (UserServiceProxy.getage (1)); }}Resultados em execução:
------ antes de GetName ----
------ GetName -----
------ APÓS GETNAME -----
gato
----- Getage -----
10
3. Implementação de proxy dinâmica do CGLIB:
O mecanismo dinâmico de proxy dinâmico do JDK só pode procurar as classes que implementam interfaces, mas as classes que não podem implementar interfaces não podem implementar o proxy dinâmico do JDK. O CGLIB implementa proxy para classes. Seu princípio é gerar uma subclasse para a classe de destino especificada e substituir o aprimoramento da implementação do método. No entanto, como a herança é usada, a classe modificada pelo final não pode ser proxyed.
Classes principais do CGLIB:
net.sf.cglib.proxy.enhancer aula de aprimoramento principal
net.sf.cglib.proxy.methodinterceptor O método principal intercepta a classe, que é uma subinterface da interface de retorno de chamada e requer implementação do usuário.
net.sf.cglib.proxy.methodProxy A classe de proxy do jdk java.lang.reflect.method do JDK pode facilmente implementar chamadas para os métodos de objeto de origem.
A interface net.sf.cglib.proxy.methodintercept é o tipo de retorno de chamada mais geral e é frequentemente usado pela AOP baseada em proxy para implementar chamadas de método de interceptação. Esta interface define apenas um método
Public Object Intercept (objeto objeto, java.lang.reflect.method Método,
Objeto [] args, MethodProxy Proxy) lança arremesso;
O primeiro parâmetro é o objeto proxy, e o segundo e terceiro parâmetros são o método interceptado e os parâmetros do método, respectivamente. O método original pode ser chamado usando uma chamada de reflexão geral usando um objeto java.lang.reflect.method ou usando um objeto net.sf.cglib.proxy.methodProxy. net.sf.cglib.proxy.methodProxy é geralmente preferido porque é mais rápido.
pacote com.example.cglib; importar org.springframework.cglib.proxy.enhancer; importar org.springframework.cglib.proxy.methodinterceptor; import org.springframework.cglib.proxy.methodProxy; destino de objeto privado; / ** * Crie objeto proxy * * @param Target * @return */ public Object getInstance (objeto destino) {this.target = Target; Intensificador intensificador = new intensancer (); intensancer.SetSuperclass (this.target.getClass ()); // Método de retorno de chamada aprimorador.setCallback (this); // crie proxy objeto retornar intensificador.create (); } @Override Public Object Intercept (objeto o, método do método, objeto [] Objetos, MethodProxy MethodProxy) lança o Throwable {System.out.println ("++++++++ antes"+methodproxy.getSuperName ()+"+++++++++"); System.out.println (métod.getName ()); Resultado do objeto = métodProxy.invokesuper (O, objetos); System.out.println ("++++++ após"+methodproxy.getsupername ()+"+++++++++"); resultado de retorno; }} pacote com.example.cglib; importar com.example.service.userService; importar com.example.service.impl.userServiceImpl;/** * teste cglib */public class RunCglib {public static void main (string [] args) {cglibProxy cGLIBProxy = novo cGliS (string [] args) {CGlibProxy CGLIBProxy = novo cGliS (string [] args) {cglibProxy cglibprox = novo cGliS (string [] args) {cglibProxy cGlibProxy = novo cGliS (string [] args)) UserService UserService = (UserService) cglibProxy.getInstance (new UserServiceImpl ()); UserService.getName (1); UserService.getage (1); }}Resultados em execução:
++++++ antes do CGLIB $ getName $ 0 ++++++++
GetName
------ GetName -----
++++++ Após o CGLIB $ getName $ 0 ++++++++
++++++ antes do CGLIB $ getage $ 1 ++++++++
getage
----- Getage -----
++++++ Após o CGLIB $ getage $ 1 ++++++++
O exposto acima é todo o conteúdo deste artigo. Espero que o conteúdo deste artigo seja de ajuda para estudar ou trabalhar de todos. Eu também espero apoiar mais wulin.com!