A classe de proxy dinâmica Java está localizada no pacote java.lang.reflect e geralmente envolve principalmente as duas classes a seguir:
(1) InvocationHandler: apenas um método é definido nesta interface
Public Object Invoke (Object Obj, método do método, objeto [] args)
No uso real, o primeiro parâmetro OBJ geralmente se refere à classe de proxy, o método é o método de proxy, como a solicitação () no exemplo acima, o ARGS é a matriz de parâmetros do método. Este método abstrato é implementado dinamicamente na classe de proxy.
(2) Proxy: Esta classe é uma classe dinâmica de proxy, e sua função é semelhante ao proxysubject no exemplo acima, que contém principalmente o seguinte conteúdo protegido por proxy (InvocationHandler H): um construtor, usado para atribuir valores ao h.
classe estática getProxyclass (carregador de classe, interfaces de classe []
Obtenha uma classe proxy em que o carregador é o carregador de classe e as interfaces é uma matriz de todas as interfaces de propriedade da classe real.
Objeto estático NewProxyInstance (Classloader carregador, Class [] Interfaces, InvocationHandler H)
Retorna uma instância da classe proxy.
O chamado proxy dinâmico é uma classe: é uma classe gerada em tempo de execução. É claro que você pode usar a instância da classe como qualquer uma dessas interfaces. Obviamente, esse proxy dinâmico é na verdade um proxy, que não fará um trabalho substancial para você.
Ao usar classes dinâmicas de proxy, devemos implementar a interface InvocationHandler:
Veja o programa sujeito.java
Veja o programa realsubject.java
Veja o programa dinamicsubject.java
Veja o programa client.java
A cópia do código é a seguinte:
pacote com.langsin.dynamicproxy;
// Função abstrata (anteriormente era uma classe abstrata, deve ser alterada para uma interface aqui):
Assunto da interface pública
{
Resumo Pedido de Vazio Público ();
}
A cópia do código é a seguinte:
pacote com.langsin.dynamicproxy;
// papel específico
Public Class RealSubject Iplementos Assunto
{
Public RealSubject ()
{
}
solicitação pública de vazio ()
{
System.out.println ("do assunto real");
}
}
A cópia do código é a seguinte:
pacote com.langsin.dynamicproxy;
importar java.lang.reflect.invocationHandler;
importar java.lang.reflect.method;
// Processador proxy
/**
* As propriedades internas da classe proxy são da classe de objeto.
* Além disso, o método Invoke também é implementado nesta classe, Method.invoke (sub, args);
* De fato, é para chamar o método a ser executado pelo objeto Proxy.
* ARGS é o parâmetro necessário para executar a operação correspondente do objeto proxy.
* Através de aulas dinâmicas de proxy, podemos executar algumas operações relacionadas antes ou depois da chamada
*/
Public Class Dynamicsubject implementos InvocationHandler
{
Sub de objeto privado;
public dynamicsubject ()
{
}
Public Dynamicsubject (objeto obj)
{
sub = obj;
}
Public Object Invoke (proxy do objeto, método do método, objeto [] args) lança arremesso
{
System.out.println ("Antes de chamar" + método);
método.invoke (sub, args);
System.out.println ("depois de chamar" + método);
retornar nulo;
}
}
A cópia do código é a seguinte:
pacote com.langsin.dynamicproxy;
importar java.lang.reflect.invocationHandler;
importar java.lang.reflect.proxy;
//Cliente
cliente de classe pública
{
estático public void main (string [] args) lança jogável
{
RealSubject rs = new RealSubject ();
InvocationHandler DS = new Dynamicsubject (RS);
Classe <?> Cls = rs.getclass ();
// o seguinte é um agente de geração único
Assunto = (sujeito) proxy.newproxyInstance (
cls.getclassloader (), cls.getInterfaces (), ds);
sujeito.Request ();
}
}
Exemplo 2:
A cópia do código é a seguinte:
pacote com.langsin.dynamicproxy;
importar java.lang.reflect.invocationHandler;
importar java.lang.reflect.method;
importar java.lang.reflect.proxy;
importar java.util.list;
importar java.util.Vector;
Public Class Vectorproxy implementa InvocationHandler
{
Objeto privado proxyobj;
public Vectorproxy (objeto obj) {
proxyobj = obj;
}
Factory de Objeto estático público (objeto obj) {
Classe <?> Cls = obj.getclass ();
return proxy.newproxyInstance (cls.getclassloader (), cls.getInterfaces (), novo VectorProxy (OBJ));
}
Public Object Invoke (proxy do objeto, método do método, objeto [] args) lança arremesso {
System.out.println ("Antes de chamar" + método);
if (args! = null) {
for (int i = 0; i <args.length; i ++) {
System.out.println (args [i] + "");
}
}
Objeto objeto = métod.invoke (proxyobj, args);
System.out.println ("depois de chamar" + método);
objeto de retorno;
}
@Suppresswarnings ("sem controle")
public static void main (string [] args) {
Lista <String> v = (list <string>) Factory (novo vetor <string> (10));
v.add ("novo");
V.Add ("York");
System.out.println (v);
v.Remove (0);
System.out.println (v);
}
}
Exemplo 3.
A cópia do código é a seguinte:
pacote com.langsin.dynamicproxy;
interface pública Foo {
Void Doaction ();
}
pacote com.langsin.dynamicproxy;
classe pública Fooimpl implementa foo {
public fooimpl () {
}
public void Doaction () {
System.out.println ("in fooimp1.doaction ()");
}
}
pacote com.langsin.dynamicproxy;
classe pública FooImpl2 implementa foo {
public FooImpl2 () {
}
public void Doaction () {
System.out.println ("in fooimp2.doaction ()");
}
}
pacote com.langsin.dynamicproxy;
importar java.lang.reflect.invocationHandler;
importar java.lang.reflect.method;
classe pública CommonInvocationHandler implementa InvocationHandler {
// Execução dinâmica de objetos, objetos que requerem retornos de chamada
destino de objeto privado;
// injeção de construtor de suporte
public CommonInvocationHandler () {
}
// injeção de construtor de suporte
public CommoninvocationHandler (Object Target) {
Settarget (Target);
}
/**
*
* Use o método Setter para injetar
*
* @param alvo
*
*/
public void Settarget (destino do objeto) {
this.target = Target;
}
/**
*
* Ligue para o método especificado em proxy e passe na lista de parâmetros args
*
* @param proxy
* O tipo de classe de proxy, como definir a interface proxy correspondente ao método
*
* Método @param
* Método de ser proxyed
*
* @param args
* Parâmetros que chamam o método de proxy
*
* @retornar
*
* @THOWS Java.lang.Throwable
*
*/
Public Object Invoke (proxy do objeto, método do método, objeto [] args) lança arremesso {
Return Method.inVoke (Target, Args);
}
}
pacote com.langsin.dynamicproxy;
importar java.lang.reflect.proxy;
classe pública demonstração {
public static void main (string [] args) {
// 1. Implementação geral de proxy dinâmico
CommonInvocationHandler Handler = new CommonInvocationHandler ();
Foo f;
// 2. Implementação da interface 1
Handler.setTarget (novo FooImpl ());
// Método Parâmetro Descrição: Classe de proxy, lista de implementação da classe de proxy, processador de classe de proxy
// Associar a classe de proxy, os métodos de interface e os processadores na classe proxy.
// Se a classe proxy não implementar a lista de interface especificada, uma exceção ilegal de parâmetros será lançada
f = (foo) proxy.newproxyInstance (foo.class.getclassloader (),
nova classe [] {foo.class},
manipulador);
f.DoAction ();
// 3. Implementação da interface 2
Handler.setTarget (novo FooImpl2 ());
f = (foo) proxy.newproxyInstance (foo.class.getclassloader (),
nova classe [] {foo.class},
manipulador);
f.DoAction ();
}
}
Porque eu tenho talento literário limitado, a maior parte do conteúdo é o código