Spring AOP

通过XML注释使用AOP

参考以下

http://blog.csdn.net/xiaoxian8023/article/details/17258933

1：添加aspectj的支持

<dependency>
　　<groupId>org.aspectj</groupId>
　　<artifactId>aspectjrt</artifactId>
　　<version>1.8.1</version>
</dependency>
<dependency>
　　<groupId>org.aspectj</groupId>
　　<artifactId>aspectjweaver</artifactId>
　　<version>1.8.1</version>
</dependency>

 

2：User类和UserDao类

public class User {
    private String name;
    public User(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public interface UserDao {
    public User findUserById(int id);
}

public class UserDaoImpl implements UserDao {
    public User findUserById(int id) {
        if(id < 0) {
            throw new IllegalArgumentException("用户id不能小于0");
        }
         return new User("zang");
    }
}

 

 

3：客户端代码

public class SpringTest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        UserDao userDao = (UserDao)ac.getBean("userDao");  
        
        //可以查找张三  
        userDao.findUserById(1);  
          
        System.out.println("===================");  
  
        try {  
            // 查不到数据，会抛异常，异常会被AfterThrowingAdvice捕获  
            userDao.findUserById(-1);  
        } catch (IllegalArgumentException e) {
            
        }  
    }
}

 

 

4：在applicationContext.xml中进行aop配置

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    
    <context:component-scan base-package="test"/>
    
    <bean id="userDao" class="dao.UserDaoImpl"></bean>
    
    <bean id="xmlAspect" class="aspect.XMLAspect"></bean>
    
    <aop:config>
        <aop:aspect id="aspect" ref="xmlAspect">
            <!-- 定义切入点,一个切入点可能横切多个业务组件 -->
            <aop:pointcut expression="execution(* dao.*.find*(..))" id="pointcut"/>
            
            <!-- 定义切入点上的增强处理 -->
            <aop:before method="doBefore" pointcut-ref="pointcut"/>
            <aop:around method="doAround" pointcut-ref="pointcut"/>
            <aop:after method="doAfter" pointcut-ref="pointcut"/>
            <aop:after-returning method="doAfterReturning" pointcut-ref="pointcut" returning="rObj"/>
            <aop:after-throwing method="doAfterThrowing" pointcut-ref="pointcut" throwing="ex"/>
        
        </aop:aspect>
    </aop:config>

    
</beans>

 

其中execution的规则如下图

 

5：XMLAspect.java

public class XMLAspect {
    private void doBefore(JoinPoint joinPoint) {
    }
    
    private Object doAround(ProceedingJoinPoint joinPoint) throws Throwable { 
        Object retVal = joinPoint.proceed();  
        return retVal;  
    }
    
    private void doAfter(JoinPoint joinPoint) {
    }
    
    private void doAfterReturning(JoinPoint joinPoint,Object rObj) {
    }
    
    private void doAfterThrowing(JoinPoint joinPoint,Throwable ex) {
    }
}

 

 

a.doBefore

private void doBefore(JoinPoint joinPoint) {
         System.out.println("-----doBefore().invoke-----");  
         
         Signature signature = joinPoint.getSignature();  
         System.out.println("DeclaringType:" + signature.getDeclaringType());   
         System.out.println("DeclaringTypeName:" + signature.getDeclaringTypeName());  
         System.out.println("Modifiers:" + signature.getModifiers());  
         System.out.println("Name:" + signature.getName());  
         System.out.println("LongString:" + signature.toLongString());  
         System.out.println("ShortString:" + signature.toShortString());  
        
         for (int i = 0; i < joinPoint.getArgs().length; i++) {  
             Object arg = joinPoint.getArgs()[i];  
             if(null != arg) {  
                  System.out.println("Args:" + arg.toString());   
             }  
         } 
         
         
         System.out.println("-----End of doBefore()------");  
    }

 

结果

 

b.doAround

private Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("-----doAround().invoke-----");  
        System.out.println(" 此处可以做类似于Before Advice的事情");  
          
        //调用核心逻辑  
        Object retVal = joinPoint.proceed();  
        System.out.println(retVal.getClass());
        User user = (User)retVal;
        System.out.println(user.getName());
        
        System.out.println(" 此处可以做类似于After Advice的事情");  
        System.out.println("-----End of doAround()------");  
        return retVal;  
    }

 

结果

 

c.doAfter

private void doAfter(JoinPoint joinPoint) {
        System.out.println("-----doAfter().invoke-----");  
        System.out.println(" 此处意在执行核心业务逻辑之后，做一些日志记录操作等等");  
        System.out.println(" 可通过joinPoint来获取所需要的内容");  
        System.out.println("-----End of doAfter()------"); 
    }

 

d.doAfterReturning

private void doAfterReturning(JoinPoint joinPoint,Object rObj) {
        System.out.println("-----doAfterReturning().invoke-----");  
       
        User user = (User)rObj;
        System.out.println(user.getName());
        
        Signature signature = joinPoint.getSignature();  
        System.out.println("DeclaringType:" + signature.getDeclaringType());   
        System.out.println("DeclaringTypeName:" + signature.getDeclaringTypeName());  
        System.out.println("Modifiers:" + signature.getModifiers());  
        System.out.println("Name:" + signature.getName());  
        System.out.println("LongString:" + signature.toLongString());  
        System.out.println("ShortString:" + signature.toShortString());  
        
        for (int i = 0; i < joinPoint.getArgs().length; i++) {  
            Object arg = joinPoint.getArgs()[i];  
            if(null != arg) {  
                System.out.println("Args:" + arg.toString());   
            }  
        }  
        
        System.out.println("-----End of doAfterReturning()------");
    }

结果

通过JoinPoint和返回参数我们可以得到类运行时的所有相关信息，如通过方法名我们可以鉴别出是insert, update还是delete操作，针对不同的操作实现不同的处理方法，如调用缓存的add()，remove()，refresh()方法。我们还可以获取方法的调用参数及返回值，这极大的方便了我们对原业务逻辑的AOP处理。

 

e.doAfterThrowing

private void doAfterThrowing(JoinPoint joinPoint,Throwable ex) {
        System.out.println("-----doThrowing().invoke-----");  
        System.out.println(" 错误信息："+ex.getMessage());  
        System.out.println(" 此处意在执行核心业务逻辑出错时，捕获异常，并可做一些日志记录操作等等");  
        System.out.println(" 可通过joinPoint来获取所需要的内容");  
        System.out.println("-----End of doThrowing()------"); 
    }

 

结果

 

 

通过注解使用AOP 

参考以下两篇博文

http://blog.csdn.net/a906998248/article/details/7514969

http://blog.csdn.net/xiaoxian8023/article/details/17285809