1. Modo Agente
Um agente é uma pessoa ou instituição que atua em nome de outra pessoa ou instituição. Em alguns casos, um cliente não deseja ou não pode fazer referência direta a um objeto, e um objeto proxy pode atuar como intermediário entre o cliente e o objeto de destino.
O padrão proxy fornece um objeto proxy para um objeto, e o objeto proxy controla a referência ao objeto original.
Exemplo na vida real: você está ocupado fazendo horas extras durante o Ano Novo e não tem tempo para comprar passagens de trem. Nesse momento, você pode ligar para a bilheteria mais próxima e pedir que comprem uma passagem de trem para casa. adicione taxas trabalhistas extras. Mas deve ficar claro que a própria central de ingressos não vende ingressos. Somente a estação de trem vende os ingressos. Os ingressos que a central de ingressos vende para você são realmente vendidos através da estação de trem. Isto é muito importante!
No exemplo acima, você é o “cliente”, a central de ingressos é a “função do agente”, a estação de trem é a “função real” e a venda de passagens é chamada de “função abstrata”!
Exemplo de código JAVA do modo agente:
Função abstrata: classe ou interface abstrata
Copie o código do código da seguinte forma:
interfaceNegócios
{
void doAction();
}
Função real: implementa verdadeiramente a interface lógica de negócios
Função do agente: não implementa a interface lógica de negócios, mas chama a função real para implementá-la.
Copie o código do código da seguinte forma:
classe BusinessImplProxy implementa Negócios
{
BusinessImpl bi privado;
public void doAction()
{
se (bi==nulo)
{
bi = novo BusinessImpl();
}
doBefore();
bi.doAction();
doDepois();
}
public void doBefore()
{
System.out.println("Pré-processamento!");
}
público vazio doAfter()
{
System.out.println("Pós-processamento!");
}
}
//classe de teste
teste de classe
{
público estático void principal(String[] args)
{
//Variáveis de referência são definidas como tipos de papéis abstratos
Business bi = new BusinessImplProxy();
bi.doAction();
}
}
Copie o código do código da seguinte forma:
<span></span>
Portanto, com o suporte da JVM, as classes de proxy ("funções de agente") podem ser geradas dinamicamente em tempo de execução, e podemos resolver o problema de expansão do código no modo de proxy acima. Depois de usar o proxy dinâmico, as "funções de agente" não serão necessárias. a ser gerado manualmente, que é gerado dinamicamente pela JVM em tempo de execução, especificando três parâmetros: carregador de classe, matriz de interface e manipulador de chamada.
Exemplo de código JAVA do modo proxy dinâmico:
Copie o código do código da seguinte forma:
importar java.lang.reflect.InvocationHandler;
importar java.lang.reflect.Proxy;
importar java.lang.reflect.Method;
//Função abstrata: A implementação do proxy dinâmico java atualmente suporta apenas interfaces e não suporta classes abstratas
interface BusinessFoo
{
vazio foo();
}
interfaceBusinessBar
{
Barra de string (mensagem de string);
}
//Função real: Implementar realmente métodos de lógica de negócios
classe BusinessFooImpl implementa BusinessFoo
{
público vazio foo()
{
System.out.println("BusinessFooImpl.foo()");
}
}
classe BusinessBarImpl implementa BusinessBar
{
barra de string pública (mensagem de string)
{
System.out.println("BusinessBarImpl.bar()");
mensagem de retorno;
}
}
//Função dinâmica: gera classe proxy dinamicamente
classe BusinessImplProxy implementa InvocationHandler
{
objetoobj privado;
BusinessImplProxy() {
}
BusinessImplProxy(Objeto obj) {
isto.obj = obj;
}
invocação de objeto público (proxy de objeto, método de método, objeto [] args) lança Throwable
{
Resultado do objeto = null;
doBefore();
resultado = método.invoke(obj,args);
doDepois();
resultado de retorno;
}
public void doBefore(){
System.out.println("faça algo antes da lógica de negócios");
}
public void doAfter(){
System.out.println("faça algo após Business Logic");
}
fábrica de objetos estáticos públicos (objeto obj)
{
Classe cls = obj.getClass();
retornar Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new BusinessImplProxy(obj));
}
}
//classe de teste
classe pública DynamicProxy
{
public static void main(String[] args) lança Throwable
{
BusinessFooImpl bfoo = new BusinessFooImpl();
BusinessFoo bf = (BusinessFoo)BusinessImplProxy.factory(bfoo);
bf.foo();
System.out.println();
BusinessBarImpl bbar = new BusinessBarImpl();
BusinessBar bb = (BusinessBar)BusinessImplProxy.factory(bbar);
String mensagem = bb.bar("Olá, Mundo");
System.out.println(mensagem);
}
}
Descrição do fluxo do programa:
new BusinessFooImpl(); cria uma "função real", passa-a para o método fábrica BusinessImplProxy.factory() e, em seguida, inicializa o "processador de invocação" - a classe que implementa InvocationHandler. E retorna uma instância de classe proxy criada dinamicamente. Como a "função de agente" também deve implementar os métodos de lógica de negócios fornecidos pela "função abstrata", ela pode ser transformada em BusinessBar e atribuída à referência bb apontando para o tipo BusinessBar.
O método newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) permite que os programadores especifiquem parâmetros e retornem dinamicamente a classe proxy necessária, enquanto o métodovocation(Object proxy, Method method, Object[] args) é usado por a JVM. Chamado dinamicamente em tempo de execução. Ao executar o método "bb.bar("Hello,World");", a JVM atribui dinamicamente um "manipulador de invocação", passa parâmetros para a invocação externa e chama method.invoke(obj, args) para realmente executá-lo!
O método estático BusinessImplProxy.Factory é usado para gerar dinamicamente classes de proxy ("funções de agente"). As funções de proxy são geradas dinamicamente em tempo de execução com base em diferentes interfaces de lógica de negócios BusinessFoo e BusinessBar. "Função abstrata", "função de agente" e manipulador de invocação (classe que implementa a interface InvocationHandler) podem ser alterados, portanto, o proxy dinâmico do JAVA é muito poderoso.