Explicação detalhada do proxy dinâmico jdk do modo proxy java (super detalhado)

Modo de agente:

O proxy é um dos padrões básicos de design, fornece operações adicionais ou diferentes, e o objeto inserido é usado para proxy do objeto "real". Essas operações geralmente envolvem comunicação com o objeto "real", portanto o proxy geralmente age como O papel do intermediário.

Proxy dinâmico

O proxy dinâmico não precisa se preocupar com a classe de proxy na fase de implementação, mas especifica qual objeto na fase de tempo de execução.As
vantagens do proxy dinâmico:

• Responsabilidades claras O
  verdadeiro papel é realizar a lógica de negócios real.Você não precisa se preocupar com outras transações não responsáveis.Você pode concluir a transação através de um agente posterior.O resultado incidental é uma programação simples e clara.
• O objeto proxy pode atuar como intermediário entre o cliente e o objeto de destino, que atua como intermediário e protege o objeto de destino. Ou seja, você pode aprimorar a função sem modificar o objeto de destino.
• Alta escalabilidade, você pode adicionar as funções necessárias aos métodos necessários.

Implemente o proxy dinâmico com base no jdk:

O Java.lang.reflect.Proxy é fornecido na API do jdk. Ele pode nos ajudar a concluir a criação do proxy dinâmico.Nota
: O uso do Proxy em java para concluir a criação de objetos de proxy dinâmico só pode criar objetos de proxy para as classes que implementam a interface.
Proxy dinâmico é gerar objeto de proxy diretamente na memória.
Continue observando a API:
geralmente usamos esse método para construir o objeto proxy, que requer três parâmetros:

1. Carregador ClassLoader:

A tradução é: cada objeto Class contém uma referência ao ClassLoader que o define. O objeto de classe da classe de matriz não é criado pelo carregador de classes, mas criado automaticamente de acordo com as necessidades do tempo de execução Java. O carregador de classes da classe de matriz retornado por Class.getClassLoader () é o mesmo que o carregador de classes de seu tipo de elemento; se o tipo de elemento for um tipo básico, a classe de matriz não terá um carregador de classes. Desde que o objeto que precisamos proxy não seja uma matriz, podemos usar o getClassLoader () do objeto Class para obter o objeto ClassLoader;

1. Interfaces de classe <?> []:

Existe esse método na classe class, que pode ser obtido diretamente.Esta classe representa a interface implementada pelo destino

2. InvocationHandler h:
   Clique para descobrir que essa é uma interface, existe um método invoke (...) não implementado
   
   , ou seja, o objeto que precisa ser passado aqui precisa implementar essa interface, e o método invoke () precisa ser concluído, explicado abaixo Três parâmetros neste método:

• Parâmetro 1: Proxy de objeto, este é o objeto que queremos proxy

• Parâmetro 2: Método: método de destino que precisamos acessar, ou seja, o método que precisamos chamar

• Parâmetro 3: Object [] args: parâmetros necessários ao chamar o comportamento

A principal função desse método é controlar se o comportamento de destino pode ser chamado quando chamamos o comportamento por meio do objeto proxy.
O seguinte é implementado com o código:

//接口
public interface IUserService {
	public String addUser(String username,String password);
}

//实现类
public class UserServiceImpl implements IUserService {
	@Override
	public String addUser(String username, String password) {
		System.out.println("添加用户:" + username + "   " + password);
		return "hello " + username;
	}
}

Agora temos que escrever uma classe de proxy no proxy UserServiceImpl:

public class UserServiceProxy implements InvocationHandler {
    // 目标对象
    private Object target;
    public UserServiceProxy(Object target) {
        this.target = target;
    }
    // 作用:创建代理对象
    public Object createProxy() {
        ClassLoader loader = target.getClass().getClassLoader();
        Class[] interfaces = target.getClass().getInterfaces();
        return Proxy.newProxyInstance(loader, interfaces, this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method);
        System.out.println(Arrays.asList (args));
        System.out.println("方法调用之前");
        Object result = method.invoke (target,args);
        System.out.println("方法调用之后");
        return result;
    }
}

Em seguida, escreva uma classe de teste:

public class Test {
    public static void main(String[] args) {
        //需要代理的对象
        IUserService userservice = new UserServiceImpl ();
        //创建代理类
        UserServiceProxy up =  new UserServiceProxy(userservice);
        IUserService proxy = (IUserService) up.createProxy ();
        //使用代理类进行方法增强
        String s = proxy.addUser ("tom", "123");
        System.out.println("s: " + s);
    }
}

Resultado da saída:

A saída é analisada abaixo: a
primeira saída é o objeto de método, que aponta para IUserService.addUser, e o segundo é o terceiro parâmetro em invoke (), que é realmente o parâmetro que usamos ao usar o objeto proxy (O primeiro parâmetro geralmente não é usado) e, antes e depois do método addUser (), também adicionamos nosso conteúdo personalizado e também obtivemos o valor de retorno da chamada do método.

Resumo:

1. O proxy dinâmico é um método de proxy que não precisa se preocupar com a classe de proxy na fase de implementação, mas especifica qual objeto na fase de tempo de execução.
2. O método de proxy dinâmico do jdk é usar o método Proxy.newProxyInstance (carregador de ClassLoader, classe <?> [] Interfaces, InvocationHandler h) para gerar um objeto proxy.O terceiro parâmetro requer que a classe proxy implemente a interface InvocationHandler e implemente o método invoke () e, finalmente, use A classe do agente executa aprimoramento do método.
3. No desenvolvimento, usamos proxies dinâmicos para concluir operações como monitoramento de desempenho, controle de permissão e registro.O AOP da Spring é parcialmente implementado usando proxies dinâmicos jdk.