代理模式之静态代理的简单实现---理解AOP(面向切面编程)的前奏---想要理解AOP，必须先理解一下

版权声明：请注意：不点赞就算了，别乱踩文章。有错指出来，湿胸我改。我给你答案抄，你不谢谢我就算啦，但是也别倒打一耙！做人要讲道理！

Aspect Oriented Programming  面向切面编程。
解耦是程序员编码开发过程中一直追求的。AOP也是为了解耦所诞生。
具体思想是：定义一个切面，在切面的纵向定义处理方法，处理完成之后，回到横向业务流。
(汉字就是这么绕，一会看代码的注释，就很详细的解释这句话)

AOP 主要是利用代理模式的技术来实现的。

先看类继承图：

target obj 还被代理类引用，即代理类内部有target obj的引用。图上忘记画了。

这样实现的好处是：本来需要target obj 去完成的事，现在可以让代理类来干。(隐藏了具体实现类，然后只能看到代理类。)

目标接口：后面2个对象都要实现这个接口，即面向接口编程思想

[java] view plain copy

 

1. package lxk.aop;  
2.   
3. /** 
4.  * 目标接口： 
5.  * 包含目标方法的声明 
6.  */  
7. public interface TargetInterface {  
8.     /** 
9.      * 目标方法 
10.      */  
11.     void business();  
12. }  

目标对象类：实现目标接口

[java] view plain copy

 

1. package lxk.aop;  
2.   
3. /** 
4.  * 目标对象类实现目标接口. 
5.  * 继而实现目标方法。 
6.  */  
7. public class TargetObject implements TargetInterface {  
8.   
9.     /** 
10.      * 目标方法(即目标操作) 
11.      */  
12.     @Override  
13.     public void business() {  
14.         System.out.println("business");  
15.     }  
16.   
17. }  

代理对象类：也实现目标接口，但是还包含目标对象的引用。

[java] view plain copy

 

1. package lxk.aop;  
2.   
3. /** 
4.  * 代理对象类也实现目标接口 
5.  * 继而实现目标方法。 
6.  */  
7. public class ProxyObject implements TargetInterface {  
8.   
9.     /** 
10.      * 面向接口编程，这个target其实指的是目标对象 
11.      * MainTest测试的时候，传入的就是目标接口的实现类的对象。 
12.      */  
13.     private TargetInterface target;  
14.   
15.     /** 
16.      * 构造方法，代理对象得到真实的目标对象 
17.      * 即：给真实目标对象赋值 
18.      */  
19.     public ProxyObject(TargetInterface target) {  
20.         this.target = target;  
21.     }  
22.   
23.     /** 
24.      * 在目标类的目标方法的上下文加一些内容 
25.      * 
26.      * 代理对象和真实对象的方法名是相同的，但是相对目标对象的目标方法，得到了扩展。 
27.      * 对外看来，使用方式是一致的,都调用同 一方法名。 
28.      * 类似生活中： 
29.      * 商店买的和直接厂家买的东西都是一样的。 
30.      * 厂家买：直接OK； 
31.      * 商店买：这个税，那个税，这个程序，那个程序。前前后后加了很多包装 
32.      * 只是经历的程序不一样，走的程序的多少的问题。代理一词来源于生活。 
33.      * 代理看似麻烦，但是却解决了很多问题。解耦，分工明确。 
34.      * 你不用到工厂去买你想要的东西。 
35.      * 工厂也不用管一些乱七八糟的东西。 
36.      * 
37.      * AOP:定义一个切面，在切面的纵向定义处理方法，处理完成之后，回到横向业务流。 
38.      * 具体看下示意图：注释不好整，就在下面截图啦。 
39.      */  
40.     @Override  
41.     public void business() {  
42.         System.out.println("aaaaa");//切面方法a();  
43.         //。。。  
44.         this.target.business();//目标类的目标方法(横向业务流：对应示意图的5();)  
45.         //。。。  
46.         System.out.println("bbbbb");//切面方法f();  
47.     }  
48.   
49. }  

测试类：

[java] view plain copy

 

1. package lxk.aop;  
2.   
3. public class MainTest {  
4.     public static void main(String[] args) {  
5.         //横向业务流：方法1();  
6.         //。。。  
7.         TargetInterface proxy = new ProxyObject(new TargetObject());  
8.         proxy.business();//代理对象来代理目标对象，执行目标方法。  
9.         //。。。  
10.         //横向业务流：方法7();  
11.     }  
12. }  

然后就是，AOP的示意图：

以上就是静态代理的简单实现：

不好的地方就是静态。