Java中AOP技术详解

AOP是Aspect Oriented Programming的缩写，意思是面向方面编程，与OOP(Object Oriented Programming)面向对象编程对等，都是一种编程思想。  
从OOP角度分析，我们关注业务的处理逻辑，是属于纵向的行为，从AOP角度分析，我们关注对象行为发生时的问题，是属于横向的行为。  
  
AOP 作用：  
1   监控函数的调用  
2   捕获异常发生  
  
实际应用在：事务、安全、日志等横切关注。  
  
两种实现AOP的方式：  

    1，JDK提供的动态代理实现   

public interface UserBean
{
	void getUser();

	void addUser();

	void updateUser();

	void deleteUser();
};

public class UserBeanImpl implements UserBean
{
	private String user = null;

	public UserBeanImpl()
	{
	}

	public UserBeanImpl(String user)
	{
		this.user = user;
	}

	public String getUserName()
	{
		return user;
	}

	public void getUser()
	{
		System.out.println("this is getUser() method!");
	}

	public void setUser(String user)
	{
		this.user = user;
		System.out.println("this is setUser() method!");
	}

	public void addUser()
	{
		System.out.println("this is addUser() method!");
	}

	public void updateUser()
	{
		System.out.println("this is updateUser() method!");
	}

	public void deleteUser()
	{
		System.out.println("this is deleteUser() method!");
	}
}

//代理类
public class UserBeanProxy implements InvocationHandler  
{  
    private Object targetObject;  
      
    public  UserBeanProxy(Object targetObject)  
    {  
        this.targetObject = targetObject;         
    }  
      
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable  
    {  
        UserBeanImpl userBean = (UserBeanImpl) targetObject;  
        String userName = userBean.getUserName();  
        Object result = null;  
          
        //权限判断  
        if(userName != null && !"".equals(userName))  
        {  
            result = method.invoke(targetObject, args);  
        }  
          
        return result;  
    }  
}  

//测试类    
public class Test
{
	public static void main(String[] args)
	{
		System.out.println("Proved.............");
		UserBeanImpl targetObject = new UserBeanImpl("Bob Liang");
		UserBeanProxy proxy = new UserBeanProxy(targetObject);
		// 生成代理对象
		UserBean object = (UserBean) Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
				targetObject.getClass().getInterfaces(), proxy);
		object.addUser();

		System.out.println("NO Proved.............");
		targetObject = new UserBeanImpl();
		proxy = new UserBeanProxy(targetObject);
		// 生成代理对象
		object = (UserBean) Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
				targetObject.getClass().getInterfaces(), proxy);
		object.addUser();

	}
}

// 输出：
// Proved.............
// this is addUser() method!
// NO Proved.............

1.  2, 通过cglib创建代理类, 好处是不要求我们的目标对象实现接口  
2. //原始类  
3. public class ClientBean  
4. {  
5.     private String name = null;  
6.   
7.     public ClientBean()  
8.     {  
9.   
10.     }  
11.   
12.     public ClientBean(String name)  
13.     {  
14.         this.name = name;  
15.     }  
16.   
17.     public void addClient()  
18.     {  
19.         System.out.println("this is addClient() method!");  
20.     }  
21.   
22.     public void deleteClient()  
23.     {  
24.         System.out.println("this is deleteClient() method!");  
25.     }  
26.   
27.     public void getClient()  
28.     {  
29.         System.out.println("this is getClient() method!");  
30.     }  
31.   
32.     public void updateClient()  
33.     {  
34.         System.out.println("this is updateClient() method!");  
35.     }  
36.   
37.     public String getClientName()  
38.     {  
39.         return name;  
40.     }  
41.   
42.     public void setClientName(String name)  
43.     {  
44.         this.name = name;  
45.     }  
46. }  
47. //代理类  
48. import java.lang.reflect.Method;  
49.   
50. import com.cignacmc.finance.bean.ClientBean;  
51.   
52. import net.sf.cglib.proxy.Enhancer;  
53. import net.sf.cglib.proxy.MethodInterceptor;  
54. import net.sf.cglib.proxy.MethodProxy;  
55.   
56. public class CGLibProxy implements MethodInterceptor  
57. {  
58.     private Object targetObject;  
59.       
60.     public Object createProxyObject(Object targetObject)  
61.     {  
62.         this.targetObject = targetObject;  
63.         Enhancer enhancer = new Enhancer();  
64.         enhancer.setSuperclass(this.targetObject.getClass());  
65.         enhancer.setCallback(this);  
66.         return enhancer.create();  
67.     }  
68.       
69.     public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable  
70.     {  
71.         ClientBean clientBean = (ClientBean)targetObject;  
72.         String userName = clientBean.getClientName();  
73.         Object result = null;  
74.           
75.         if(userName != null && !"".equals(userName))  
76.         {  
77.             result = method.invoke(targetObject, args);  
78.         }  
79.         return result;  
80.     }  
81. }  
82. //测试类  
83. import java.lang.reflect.Proxy;  
84.   
85. import com.cignacmc.finance.bean.ClientBean;  
86. import com.cignacmc.finance.bean.UserBean;  
87. import com.cignacmc.finance.bean.UserBeanImpl;  
88. import com.cignacmc.finance.proxy.CGLibProxy;  
89. import com.cignacmc.finance.proxy.UserBeanProxy;  
90.   
91. public class ProxyExe  
92. {  
93.     public static void main(String[] args)  
94.     {     
95.         System.out.println(".............CGLIB Proxy....................");  
96.         System.out.println("Proved....................");  
97.         CGLibProxy cproxy = new CGLibProxy();  
98.         ClientBean clientBean = (ClientBean)cproxy.createProxyObject(new ClientBean("Bob Liang"));  
99.         clientBean.addClient();  
100.           
101.         System.out.println("NO Proved....................");  
102.         cproxy = new CGLibProxy();  
103.         clientBean = (ClientBean)cproxy.createProxyObject(new ClientBean());  
104.         clientBean.addClient();  
105.                   
106.     }  
107. }  
108.   
109. 输出：  
110. .............CGLIB Proxy....................  
111. Proved....................  
112. this is addClient() method!  
113. NO Proved....................  
114.   
115.   
116. 切面(Aspect):对横切关注点的抽象(类似类对对象的抽象)   
117. 连接点(JoinPoint):被拦截到的点,泛指方法   
118. 切入点(CutPoint):对哪些连接点进行拦截的定义   
119. 通知(Advice):在特定的连接点，AOP框架执行的动作.前置/后置/例外/最终/环绕通知(调用方法之前执行,全部执行完毕之后)   
120. 引入（Introduction）: 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。   
121. 目标对象（Target Object）: 包含连接点的对象。也被称作 被通知或被代理对象。   
122. AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。   
123. 织入（Weaving）: 组装方面来创建一个被通知对象。这可以在编译时 完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样， 在运行时完成织入。   

原文链接：http://perfect5085.iteye.com/blog/1612930