AOP的annotation实现方式是基于AspectJ的实现，需要以下几步：
首先，需要添加AspectJ的包：aspectjrt.jar aspectweaver.jar
其次，在applicationContext .xml文件中添加配置，否则不能使用aspectj的语法，在此之前，需要在引入AOP的命名空间xmlns:aop=http://www.springframework.org/schema/aop
再次，添加切面类
@Aspect
@Component
public class LogInterceptor {
@Before(“execution(public void com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
public void beforeMethod(){
System.out.println("method before");
}
@After(“execution(public void com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
public void afterMethod(){
System.out.println("method after");
}
@AfterReturning(“execution(public * com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
public void afterReturning(){
System.out.println("method after returning");
}
@AfterThrowing(“execution(public * com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
public void afterThrowing(){
System.out.println("method throws exception");
}
@Around(“execution(public * com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
public void around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("method around start");
pjp.proceed();
System.out.println("method around end");
}
}
@Before(“execution(public void com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
这句话的意思是：在执行类com.bjsxt.dao.impl.UserDAOImpl中的任何类型的参数，任何返回值为空，访问类型为public的方法之前都会执行beforeMethod（）方法。
@AfterThrowing(“execution(public * com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
这句话所定义的通知是在所调用的函数抛出异常的时候才会调用
@AfterReturning(“execution(public * com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
这句话所定义的通知是在所调用的函数正常返回的时候才会调用
@After(“execution(public void com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
这句话定义的通知在程序返回之后（包括正常返回和抛出异常返回）会调用
@Around(“execution(public * com.bjsxt.dao.impl.UserDAOImpl.*(..))”)
around通知需要一个ProceedingJoinPoint 类型的参数pjp，并且在程序中需调用pjp.proceed();
User实体类：
public class User {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
UserDAO的内容：
public interface UserDAO {
public void save(User user);
}
UserDAOImpl的内容：
@Component(“userDAOImpl”)
public class UserDAOImpl implements UserDAO {
public void save(User user) {
System.out.println(“user saved!”);
}
}
UserService的内容：
@Component(“userService”)
public class UserService {
private UserDAO userDAO;
public UserDAO getUserDAO() {
return userDAO;
}
@Resource(name=”userDAOImpl”)
public void setUserDAO( UserDAO userDAO) {
this.userDAO = userDAO;
}
public void add(User user) {
userDAO.save(user);
}
}
测试类的内容（使用Junit测试）：
public class UserServiceTest {
@Test
public void testAdd() throws Exception {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(“beans.xml”);
UserService service = (UserService)ctx.getBean(“userService”);
service.add(new User());
}
}
最后，直接执行即可，运行结果：
method around start
method before
user saved!
method around end
method after
method after returning
通过观察不难发现，每个通知后面的切入点语法都是一样的，因此，此时可以定义一个切入点，然后不同的通知直接调用即可
@Aspect
@Component
public class LogInterceptor {
@Pointcut("execution(public * com.bjsxt.dao..*.*(..))")
public void myMethod(){}
@Before("myMethod()")
public void beforeMethod(){
System.out.println("method before");
}
@After("myMethod()")
public void afterMethod(){
System.out.println("method after");
}
@AfterReturning("myMethod()")
public void afterReturning(){
System.out.println("method after returning");
}
@AfterThrowing("myMethod()")
public void afterThrowing(){
System.out.println("method throws exception");
}
@Around("myMethod()")
public void around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("method around start");
pjp.proceed();
System.out.println("method around end");
}
}
运行程序，结果相同：
method around start
method before
user saved!
method around end
method after
method after returning