Java之代理（二）

JDK动态代理的原理是根据定义好的规则，用传入的接口创建一个新类，这就是为什么采用动态代理时为什么只能用接口引用指向代理，而不能用传入的类引用执行动态类。 

cglib采用的是用创建一个继承实现类的子类，用asm库动态修改子类的代码来实现的，所以可以用传入的类引用执行代理类 

Spring AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。Spring主要通过代理来实现AOP。

切面(Aspect):对横切关注点的抽象(类似类对对象的抽象）
连接点(JoinPoint):被拦截到的点,泛指方法。
切入点(CutPoint):对哪些连接点进行拦截的定义。

通知(Advice):在特定的连接点，AOP框架执行的动作.前置/后置/例外/最终/环绕通知。
引入（Introduction）: 添加方法或字段到被通知的类。Spring允许引入新的接口到任何被通知的对象。
目标对象（Target Object）: 包含连接点的对象。也被称作被通知或被代理对象。 
AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
织入（Weaving）: 组装切面来创建一个被通知对象。这可以在编译时完成也可以在运行时完成。Spring在运行时完成织入。

示例代码：

接口类：

Java代码   

1. package org.iti.wxl.springaop;  
2.   
3. public interface UserService {  
4.     public String getUser(String userId);  
5.     public void addUser();  
6. }  

 

对接口的实现：

Java代码   

1. package org.iti.wxl.springaop;  
2.   
3. public class UserServiceImpl implements UserService {  
4.     @Override  
5.     public String getUser(String userId) {  
6.         System.out.println("this is getUser() method!");  
7.         return "user";  
8.     }  
9.     @Override  
10.     public void addUser() {  
11.         System.out.println("this is addUser() method!");  
12.     }  
13. }  

 

定义切面：

Java代码   

1. package org.iti.wxl.springaop;  
2. import org.aspectj.lang.ProceedingJoinPoint;  
3. import org.aspectj.lang.annotation.After;  
4. import org.aspectj.lang.annotation.AfterReturning;  
5. import org.aspectj.lang.annotation.AfterThrowing;  
6. import org.aspectj.lang.annotation.Around;  
7. import org.aspectj.lang.annotation.Aspect;   
8. import org.aspectj.lang.annotation.Before;  
9. import org.aspectj.lang.annotation.Pointcut;  
10. @Aspect  
11. public class MyInterceptor {  
12.     @Pointcut("execution(* org.iti.wxl.springaop..*.*(..))")  
13.     private void pointCutmethod(){  
14.     }  
15.     @Before("pointCutmethod() && args(userId)")  
16.     public void doBefore(String userId){  
17.         System.out.println("前置通知 " + userId);  
18.     }  
19.     @AfterReturning("pointCutmethod()")  
20.     public void doAfterReturning(){  
21.         System.out.println("后置通知");  
22.     }  
23.     @AfterThrowing("pointCutmethod()")  
24.     public void doAfterException(){  
25.         System.out.println("异常通知");  
26.     }  
27.     @After("pointCutmethod()")  
28.     public void doAfter(){  
29.         System.out.println("最终通知");  
30.     }  
31.     @Around("pointCutmethod()")  
32.     public Object doAround(ProceedingJoinPoint pjp) throws Throwable{  
33.         System.out.println("环绕开始");  
34.         Object object = pjp.proceed();  
35.         System.out.println("环绕结束");  
36.         return object;  
37.     }  
38. }  

说明：

第一个*表示方法的返回值,这里使用通配符,只有返回值符合条件的才拦截(!void表示有返回值)。  
第一个..表示com.royzhou.aop包及其子包。  
倒数第二个*表示包下的所有Java类都被拦截。  
最后一个*表示类的所有方法都被拦截。
(..)表示方法的参数可以任意多个，如[(java.lang.String,java.lang.Integer)表示第一个参数是String,第二个参数是int的方法才会被拦截]  

 

配置文件：

Java代码   

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:aop="http://www.springframework.org/schema/aop"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
7.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
8.            http://www.springframework.org/schema/context  
9.            http://www.springframework.org/schema/context/spring-context-3.0.xsd  
10.            http://www.springframework.org/schema/aop  
11.            http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">  
12.     <!-- 使用 annotation -->  
13.     <context:annotation-config />  
14.     <!-- 启用aop -->  
15.     <aop:aspectj-autoproxy proxy-target-class="true" />  
16.     <bean id="myInterceptor" class="org.iti.wxl.springaop.MyInterceptor"/>  
17.     <bean id="userService" class="org.iti.wxl.springaop.UserServiceImpl"/>  
18. </beans>  

 测试类：

Java代码   

1. package org.iti.wxl.springaop;  
2.   
3. import org.springframework.context.ApplicationContext;  
4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
5.   
6. public class SpringAOP {  
7.   
8.     public static void main(String[] args) {  
9.         ApplicationContext cxt = new ClassPathXmlApplicationContext("bean.xml");  
10.         UserService userService = (UserService)cxt.getBean("userService");  
11.         userService.getUser("user1");  
12.         System.out.println("===========");  
13.         userService.addUser();  
14.     }  
15. }  

 运行结果：

Java代码   

1. 前置通知 user1  
2. 环绕开始  
3. this is getUser() method!  
4. 后置通知  
5. 最终通知  
6. 环绕结束  
7. ===========  
8. 环绕开始  
9. this is addUser() method!  
10. 后置通知  
11. 最终通知  
12. 环绕结束  

  在项目开发中，AOP主要用来配置spring的声明式事务管理，它还可用在日志管理，性能监测等。它为程序员编程提供了一种新思路，我们可以不断去发现它的新用途。

 

转载：http://www.iteye.com/topic/1127544