Java代理机制之初见（理解及实现）

都知道Java中的Spring,有一重要思想：AOP，也就是Java的动态代理机制。初见代理这个名词时，觉得生活中常有代理的这一说法。

那么，在Java中，代理又是什么呢？它又是如何实现的？实现后是干什么的？

其实啊，Java中的代理也就是生活中代理的意思，我认为，在Java中，代理就是帮助类实现一些修改的动作。

也就是说，用代理类来修改已经存在的类。那么，问题又来了，为何这样做呢？在存在的类上修改不就完事了吗？

首先，这种想法时错的，Java中，已经编译好的类不要随随便便的修改，容易造成整个工程的一系列问题。所以，使用这种方法就不需要修改已存在的类了，

可以对原类进行相应的动作。这样才符合编程的需求。

一、下面来具体说说代理：

大的方向来说代理可分为：静态代理和动态代理。而动态代理又有两种产生代理的方式：JDK和CGLiB。

二、静态代理的实现：

首先创建一个接口，然后创建具体实现类来实现这个接口，在创建一个代理类同样实现这个接口，不同之处在于，

具体实现类的方法中需要将接口中定义的方法的业务逻辑功能实现，而代理类中的方法只要调用具体类中的对应方法即可，

这样我们在需要使用接口中的某个方法的功能时直接调用代理类的方法即可，将具体的实现类隐藏在底层。

1.首先需要创建的接口：

1 package com.xupt.proxy.classes;
2
3 public interface IStudentProxyId {
4     void setId(String id);
5     String getId();
6 }

1 package com.xupt.proxy.classes;
2
3 public interface IStudentProxyName {
4     void setName(String name);
5     String getName();
6 }

2.实现这个接口的类：

 1 package com.xupt.proxy.classes;
 2
 3 public class StudentMessage implements IStudentProxyId,IStudentProxyName {
 4
 5     private String id;
 6     private String name;
 7
 8     public StudentMessage() {}
 9
10     @Override
11     public void setName(String name) {
12         this.name  = name;
13
14         System.out.println("StudentMessage.setName()");
15     }
16
17     @Override
18     public String getName() {
19         System.out.println("StudentMessage.getName()");
20
21         return name;
22     }
23
24     @Override
25     public void setId(String id) {
26         this.id = id;
27
28         System.out.println("StudentMessage.setId()");
29
30     }
31
32     @Override
33     public String getId() {
34         System.out.println("StudentMessage.getId()");
35
36         return id;
37     }
38
39 }

3.实现类的代理类：

无用框。。。。。。

 1 package com.xupt.proxy.proxy;
 2
 3 import com.xupt.proxy.classes.IStudentProxyId;
 4 import com.xupt.proxy.classes.IStudentProxyName;
 5 import com.xupt.proxy.classes.StudentMessage;
 6
 7 public class StudentProxy implements IStudentProxyId,IStudentProxyName{
 8
 9     StudentMessage message;
10
11     public StudentProxy() {
12     }
13
14     public StudentProxy(StudentMessage message) {
15         this.message = message;
16     }
17
18     @Override
19     public void setName(String name) {
20
21         System.out.println("置前拦截StudentProxy.setName()");
22         message.setName(name);
23         System.out.println("置后拦截StudentProxy.setName()");
24     }
25
26     @Override
27     public String getName() {
28
29         System.out.println("置前拦截StudentProxy.getName()");
30         String name = message.getName();
31         System.out.println("置后拦截StudentProxy.getName()");
32
33         return name;
34     }
35
36     @Override
37     public void setId(String id) {
38
39         System.out.println("置前拦截StudentProxy.setId()");
40         message.setName(id);
41         System.out.println("置后拦截StudentProxy.setId()");
42     }
43
44     @Override
45     public String getId() {
46         System.out.println("置前拦截StudentProxy.getId()");
47         String id = message.getId();
48         System.out.println("置后拦截StudentProxy.getId()");
49
50         return id;
51     }
52
53 }

4.定义测试类：

package com.xupt.proxy.demo;

import com.xupt.proxy.classes.StudentMessage;
import com.xupt.proxy.proxy.StudentProxy;

public class StudentProxyTest {

	public static void main(String[] args) {
		StudentProxy proxy = new StudentProxy(new StudentMessage());
		proxy.setId("222666");
		proxy.setName("张三");
		System.out.println("id: " + proxy.getId() + " " +  "name: " +proxy.getName());
	}

}

5.执行结果：

以上就是静态代理的实现过程，实现一次就觉得挺简单的。但是，静态代理就是将接口、实现类、代理类一次全部手动执行。但细想一下，如果我们需要很多代理，每次都重新手动完成，是不是不现实呢？每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码。所以，动态代理就出现了。事情总有解决的办法。

三：动态代理的实现：

后续更新。。。。。。。

原文地址：https://www.cnblogs.com/youdiaodaxue16/p/9867909.html