java动态代理

静态代理

代码步骤:

1.接口

1
2
3
4
5


//租房接口
public interface Rent {
    public void rent();

}

2.真实角色

1
2
3
4
5
6
7
8


//房东
public class Host implements Rent {
public void rent()
{
    System.out.println("房东出租房子");
}

}

3.代理角色

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


public class Proxy {

    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }
    public void rent()
    {   fare();
        host.rent();
    }
    //看房
    public void watch()
    {
        System.out.println("中介带你看房");
    }
    public void fare(){
        System.out.println("中介收费");

    }

}

4.客户

1
2
3
4
5
6
7


public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

动态代理

动态代理的角色和静态代理的一样。需要一个实体类，一个代理类，一个启动器。
动态代理的代理类是动态生成的，静态代理的代理类是我们提前写好的。

JDK的动态代理需要了解两个类

核心 : InvocationHandler 调用处理程序类和 Proxy 代理类

InvocationHandler：调用处理程序

public interface InvocationHandler ```

InvocationHandler是由代理实例的调用处理程序实现的接口

每个代理实例都有一个关联的调用处理程序。

1

Object invoke(Object proxy, 方法 method, Object[] args)；

当在代理实例上调用方法的时候，方法调用将被编码并分派到其调用处理程序的invoke()方法。

参数：

proxy – 调用该方法的代理实例
method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

Proxy : 代理

1

public class Proxy extends Object implements Serializable

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。

动态代理类（以下简称为代理类）是一个实现在类创建时在运行时指定的接口列表的类，具有如下所述的行为。代理接口是由代理类实现的接口。代理实例是代理类的一个实例。

1

public static Object newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。

参数

loader – 类加载器来定义代理类
interfaces – 代理类实现的接口列表
h – 调度方法调用的调用处理函数

动态代理的代码实现

要写动态代理的代码，需要抓牢两个要点

①：我们代理的是接口，而不是单个用户。
②：代理类是动态生成的，而非静态定死。

我只能说这种编程思想是真的牛逼，其实我们还可以实现任意接口的动态代理实现，在这里就不贴出来了。

首先是我们的接口类
UserService.java

1
2
3
4
5
6
7
8
9


package src.JdkProxy.DynamicProxy;  
  
  
public interface UserService {  
    public void add();  
 public void delete();  
 public void update();  
 public void query();  
}

接着，我们需要用实体类去实现这个抽象类

UserServiceImpl.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package src.JdkProxy.DynamicProxy;  
  
public class UserServiceImpl implements UserService{  
    @Override  
 public void add() {  
        System.out.println("增加了一个用户");  
 }  
  
    @Override  
 public void delete() {  
        System.out.println("删除了一个用户");  
 }  
  
    @Override  
 public void update() {  
        System.out.println("更新了一个用户");  
 }  
  
    @Override  
 public void query() {  
        System.out.println("查询了一个用户");  
 }  
}

接着，是动态代理的实现类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


package src.JdkProxy.DynamicProxy;  
  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
  
public class UserProxyInvocationHandler implements InvocationHandler {  
  
    // 被代理的接口  
 private UserService userService;  
  
 public void setUserService(UserService userService) {  
        this.userService = userService;  
 }  
  
    // 动态生成代理类实例  
 public Object getProxy(){  
        Object obj = Proxy.newProxyInstance(this.getClass().getClassLoader(), userService.getClass().getInterfaces(), this);  
 return obj;  
 }  
  
    // 处理代理类实例，并返回结果  
 @Override  
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        log(method);  
 Object obj = method.invoke(userService, args);  
 return obj;  
 }  
  
    //业务自定义需求  
 public void log(Method method){  
        System.out.println("[Info] " + method.getName() + "方法被调用");  
 }  
}

最后编写我们的 Client，也就是启动器

Client.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package src.JdkProxy.DynamicProxy;  
  
import src.JdkProxy.DynamicProxy.UserServiceImpl;  
  
public class Client {  
    public static void main(String[] args) {  
        // 真实角色  
 UserServiceImpl userServiceImpl = new UserServiceImpl();  
 // 代理角色，不存在  
 UserProxyInvocationHandler userProxyInvocationHandler = new UserProxyInvocationHandler();  
 userProxyInvocationHandler.setUserService((UserService) userServiceImpl); // 设置要代理的对象  
  
 // 动态生成代理类  
 UserService proxy = (UserService) userProxyInvocationHandler.getProxy();  
  
 proxy.add();  
 proxy.delete();  
 proxy.update();  
 proxy.query();  
 }  
}

cc1正链的分析

1
2


Constructor<?> constructor = clz.getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);  // 允许访问私有构造函数

**实例化 ****AnnotationInvocationHandler**：
使用获取到的构造函数创建 AnnotationInvocationHandler 实例。这个实例负责处理代理对象的方法调用。

1

Object o = constructor.newInstance(Override.class, decoratemap);

**强制转换为 ****InvocationHandler**：
将创建的实例强制转换为 InvocationHandler 类型，以便后续可以通过这个处理器处理代理对象的调用。

1

InvocationHandler invocationHandler = (InvocationHandler) o;

创建代理对象：
使用 Proxy.newProxyInstance() 方法创建一个动态代理对象，代理 Map 接口。此时，所有对 proxymap 的方法调用（如 entrySet()、get() 等）都会转发给 invocationHandler 的 invoke() 方法。

1
2
3
4
5


Map proxymap = (Map) Proxy.newProxyInstance(
    Map.class.getClassLoader(),
    new Class[]{Map.class},
    invocationHandler
);

调用代理方法：
通过代理对象（proxymap）调用 entrySet() 方法。这个调用实际上会被转发到 InvocationHandler 的 invoke() 方法，进行处理。

1

proxymap.entrySet();  // 代理方法调用

最后将代理类的实例化

1

Object ob = constructor.newInstance(Override.class,proxymap);

大多内容参考的是:Drunkbaby大佬的博客