Spring_AOP_Annotation使用Aspect实现动态代理

spring_aop_annotation 的实现：

1.1在beans.xml中加入aop的schema

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

<aop:aspectj-autoproxy/>

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

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

Maven之pom.xml :

<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来声明这个类是一个切面类

//让这个切面类被Spring所管理
@Component("logAspect")
// 声明这是一个切面类
@Aspect
public class LogAspect {
    //......
<span style="font-family:FangSong_GB2312;">}</span>

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

 execution(* com.spring.dao.*.add*(..))
 * 第一个*表示任意返回值
 * 第二个*表示com.spring.dao包中所有类
 * 第三个*表示以add开头的所有方法
 * （..）表示任意参数

1.7如果希望获取相应的调用信息，可以通过joinPoint 传递

/**
 * 程序开始之前执行
 * 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

<?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类

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类

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);
	}

}

测试类及测试结果：