Spring_AOP_Annotation使用Aspect实现动态代理 .

于 2014-09-22 15:46:37 发布
阅读量473 收藏
点赞数
分类专栏： Spring 文章标签： aop spring 对象

spring_aop_annotation 的实现：

1.1在beans.xml中加入aop的schema

1.2在xml中打开aop的自动检索

[java] view plain copy print ?
  1. <aop:aspectj-autoproxy/>  
<aop:aspectj-autoproxy/>

1.3创建一个需要实现动态代理的类

1.4导入aspectj包，Spring使用的是aspect这个包来实现AOP，所以需要导入这个包。

Maven之pom.xml :

[html] view plain copy print ?
  1. <dependency>  
  2.     <groupId>org.aspectj</groupId>  
  3.     <artifactId>aspectjweaver</artifactId>  
  4.     <version>1.6.8</version>  
  5. </dependency>  
  6. <dependency>  
  7.     <groupId>org.aspectj</groupId>  
  8.     <artifactId>aspectjrt</artifactId>  
  9.     <version>1.6.8</version>  
  10.     </dependency>  
  11. <dependency>  
  12.     <groupId>aopalliance</groupId>  
  13.     <artifactId>aopalliance</artifactId>  
  14.     <version>1.0</version>  
  15. </dependency>  
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.6.8</version>
</dependency>
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjrt</artifactId>
	<version>1.6.8</version>
	</dependency>
<dependency>
	<groupId>aopalliance</groupId>
	<artifactId>aopalliance</artifactId>
	<version>1.0</version>
</dependency>

1.5在这类上面使用@Aspect来声明这个类是一个切面类

[java] view plain copy print ?
  1. //让这个切面类被Spring所管理   
  2. @Component("logAspect")  
  3. // 声明这是一个切面类   
  4. @Aspect  
  5. public class LogAspect {  
  6.     //......   
  7. <span style="font-family:FangSong_GB2312;">}</span>  
//让这个切面类被Spring所管理
@Component("logAspect")
// 声明这是一个切面类
@Aspect
public class LogAspect {
    //......
<span style="font-family:FangSong_GB2312;">}</span>


1.6在相应的要进行横切点上面加入PointCut的说明

[java] view plain copy print ?
  1. execution(* com.spring.dao.*.add*(..))  
  2. * 第一个*表示任意返回值  
  3. * 第二个*表示com.spring.dao包中所有类  
  4. * 第三个*表示以add开头的所有方法  
  5. * （..）表示任意参数  
 execution(* com.spring.dao.*.add*(..))
 * 第一个*表示任意返回值
 * 第二个*表示com.spring.dao包中所有类
 * 第三个*表示以add开头的所有方法
 * （..）表示任意参数

1.7如果希望获取相应的调用信息，可以通过joinPoint 传递
[java] view plain copy print ?
  1. /** 
  2.  * 程序开始之前执行 
  3.  * execution(* com.spring.dao.*.add*(..)) 第一个*表示任意返回值 
  4.  * 第二个*表示com.spring.dao包中所有类 第三个*表示以add开头的所有方法 （..）表示任意参数 
  5.  */  
  6. @Before("execution(* com.spring.dao.*.add*(..)) || "  
  7.         + "execution(* com.spring.dao.*.update*(..)) || "  
  8.         + "execution(* com.spring.dao.*.delete*(..))")  
  9. public void logStart(JoinPoint jp) {  
  10.     // 得到执行的对象   
  11.     System.out.println(jp.getTarget());  
  12.     // 得到执行的方法   
  13.     System.out.println(jp.getSignature().getName());  
  14.     Logger.info("方法执行前加入日志，来自LogAspect");  
  15. }  
/**
 * 程序开始之前执行
 * execution(* com.spring.dao.*.add*(..)) 第一个*表示任意返回值
 * 第二个*表示com.spring.dao包中所有类 第三个*表示以add开头的所有方法 （..）表示任意参数
 */
@Before("execution(* com.spring.dao.*.add*(..)) || "
		+ "execution(* com.spring.dao.*.update*(..)) || "
		+ "execution(* com.spring.dao.*.delete*(..))")
public void logStart(JoinPoint jp) {
	// 得到执行的对象
	System.out.println(jp.getTarget());
	// 得到执行的方法
	System.out.println(jp.getSignature().getName());
	Logger.info("方法执行前加入日志，来自LogAspect");
}

具体实现代码：

XML

[html] view plain copy print ?
  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" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
  6.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
  7.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
  8.   
  9.     <!-- 打开Spring的Annotation的支持 -->  
  10.     <context:annotation-config />  
  11.     <!-- 设定Spring去哪些包中找Annotation -->  
  12.     <context:component-scan base-package="com.spring" />  
  13.     <!-- 打开基于Annotation的aop自动代理 -->  
  14.     <aop:aspectj-autoproxy/>  
  15. </beans>  
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

	<!-- 打开Spring的Annotation的支持 -->
	<context:annotation-config />
	<!-- 设定Spring去哪些包中找Annotation -->
	<context:component-scan base-package="com.spring" />
	<!-- 打开基于Annotation的aop自动代理 -->
	<aop:aspectj-autoproxy/>
</beans>

LogAspect类
[java] view plain copy print ?
  1. package com.spring.proxy;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.ProceedingJoinPoint;  
  5. import org.aspectj.lang.annotation.After;  
  6. import org.aspectj.lang.annotation.Around;  
  7. import org.aspectj.lang.annotation.Aspect;  
  8. import org.aspectj.lang.annotation.Before;  
  9. import org.springframework.stereotype.Component;  
  10.   
  11. //让这个切面类被Spring所管理   
  12. @Component("logAspect")  
  13. // 声明这是一个切面类   
  14. @Aspect  
  15. public class LogAspect {  
  16.     /** 
  17.      * 程序开始之前执行 
  18.      * execution(* com.spring.dao.*.add*(..)) 第一个*表示任意返回值 
  19.      * 第二个*表示com.spring.dao包中所有类 第三个*表示以add开头的所有方法 （..）表示任意参数 
  20.      */  
  21.     @Before("execution(* com.spring.dao.*.add*(..)) || "  
  22.             + "execution(* com.spring.dao.*.update*(..)) || "  
  23.             + "execution(* com.spring.dao.*.delete*(..))")  
  24.     public void logStart(JoinPoint jp) {  
  25.         // 得到执行的对象   
  26.         System.out.println(jp.getTarget());  
  27.         // 得到执行的方法   
  28.         System.out.println(jp.getSignature().getName());  
  29.         Logger.info("方法执行前加入日志，来自LogAspect");  
  30.     }  
  31.       
  32.     /** 
  33.      * 程序结束之后执行 
  34.      * @param jp 
  35.      */  
  36.     @After("execution(* com.spring.dao.*.add*(..)) || "  
  37.             + "execution(* com.spring.dao.*.update*(..)) || "  
  38.             + "execution(* com.spring.dao.*.delete*(..))")  
  39.     public void logEnd(JoinPoint jp) {  
  40.         // 得到执行的对象   
  41.         System.out.println(jp.getTarget());  
  42.         // 得到执行的方法   
  43.         System.out.println(jp.getSignature().getName());  
  44.         Logger.info("方法执行后加入日志，来自LogAspect");  
  45.     }  
  46.   
  47.     /** 
  48.      * 函数调用过程中执行 
  49.      * @param pjp 
  50.      * @throws Throwable 
  51.      */  
  52.     @Around("execution(* com.spring.dao.*.add*(..)) || "  
  53.             + "execution(* com.spring.dao.*.update*(..)) || "  
  54.             + "execution(* com.spring.dao.*.delete*(..))")  
  55.     public void logAround(ProceedingJoinPoint pjp) throws Throwable {  
  56.         Logger.info("开始在Around中加入日志，来自LogAspect");  
  57.         //执行程序   
  58.         pjp.proceed();  
  59.         Logger.info("结束Around");  
  60.     }  
  61. }  
package com.spring.proxy;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//让这个切面类被Spring所管理
@Component("logAspect")
// 声明这是一个切面类
@Aspect
public class LogAspect {
	/**
	 * 程序开始之前执行
	 * execution(* com.spring.dao.*.add*(..)) 第一个*表示任意返回值
	 * 第二个*表示com.spring.dao包中所有类 第三个*表示以add开头的所有方法 （..）表示任意参数
	 */
	@Before("execution(* com.spring.dao.*.add*(..)) || "
			+ "execution(* com.spring.dao.*.update*(..)) || "
			+ "execution(* com.spring.dao.*.delete*(..))")
	public void logStart(JoinPoint jp) {
		// 得到执行的对象
		System.out.println(jp.getTarget());
		// 得到执行的方法
		System.out.println(jp.getSignature().getName());
		Logger.info("方法执行前加入日志，来自LogAspect");
	}
	
	/**
	 * 程序结束之后执行
	 * @param jp
	 */
	@After("execution(* com.spring.dao.*.add*(..)) || "
			+ "execution(* com.spring.dao.*.update*(..)) || "
			+ "execution(* com.spring.dao.*.delete*(..))")
	public void logEnd(JoinPoint jp) {
		// 得到执行的对象
		System.out.println(jp.getTarget());
		// 得到执行的方法
		System.out.println(jp.getSignature().getName());
		Logger.info("方法执行后加入日志，来自LogAspect");
	}

	/**
	 * 函数调用过程中执行
	 * @param pjp
	 * @throws Throwable
	 */
	@Around("execution(* com.spring.dao.*.add*(..)) || "
			+ "execution(* com.spring.dao.*.update*(..)) || "
			+ "execution(* com.spring.dao.*.delete*(..))")
	public void logAround(ProceedingJoinPoint pjp) throws Throwable {
		Logger.info("开始在Around中加入日志，来自LogAspect");
		//执行程序
		pjp.proceed();
		Logger.info("结束Around");
	}
}

UserService类
[java] view plain copy print ?
  1. package com.spring.service;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.springframework.stereotype.Component;  
  6. import org.springframework.stereotype.Service;  
  7.   
  8. import com.spring.dao.IUserDao;  
  9. import com.spring.model.User;  
  10.   
  11. //@Component(value="userService")   
  12. @Service("userService")     //业务层一般用@Service注入   
  13. public class UserService implements IUserService {  
  14.     private IUserDao userDao;  
  15.       
  16.     public IUserDao getUserDao() {  
  17.         return userDao;  
  18.     }  
  19.       
  20.     //默认通过名称注入，在JSR330中提供了@Inject来注入   
  21.     //@Resource(name="userProxyDao")    //此处用代理类注入   
  22.     //@Resource(name="userDynamicDao")   
  23.     @Resource(name="userDao") //aspect    
  24.     public void setUserDao(IUserDao userDao) {  
  25.         this.userDao = userDao;  
  26.     }  
  27.   
  28.     @Override  
  29.     public void add(User user) {  
  30.         userDao.add(user);  
  31.     }  
  32.   
  33.     @Override  
  34.     public void delete(int id) {  
  35.         userDao.delete(id);  
  36.     }  
  37.   
  38.     @Override  
  39.     public User load(int id) {  
  40.         return userDao.load(id);  
  41.     }  
  42.   
  43. }  
package com.spring.service;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import com.spring.dao.IUserDao;
import com.spring.model.User;

//@Component(value="userService")
@Service("userService")		//业务层一般用@Service注入
public class UserService implements IUserService {
	private IUserDao userDao;
	
	public IUserDao getUserDao() {
		return userDao;
	}
	
	//默认通过名称注入，在JSR330中提供了@Inject来注入
	//@Resource(name="userProxyDao")	//此处用代理类注入
	//@Resource(name="userDynamicDao")
	@Resource(name="userDao") //aspect 
	public void setUserDao(IUserDao userDao) {
		this.userDao = userDao;
	}

	@Override
	public void add(User user) {
		userDao.add(user);
	}

	@Override
	public void delete(int id) {
		userDao.delete(id);
	}

	@Override
	public User load(int id) {
		return userDao.load(id);
	}

}

测试类及测试结果：


huangqiang12
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值