我的Spring之旅——（二）Spring AOP实现的两种方式

我在《我的Spring之旅--aop构建项目》中说了，最近在学习aop怎么用，到现在大概体会到了aop的好处，也使用了不同的方式实现了aop，所以趁着休息时间写一下这两天的学习过程、过程中遇见的问题和对应的解决方案。与君共勉！

一、需求：

1.搭建Spring+Maven项目（在《我的Spring之旅--aop构建项目》中已经实现）

2.编写UserService类，类中包括saveUser(String name,int age)和deleteUser(String name)方法

3.编写StudentService类，类中包括saveStudent(String name,int age)和deleteStudent(String name)方法

4.所有方法执行后都要打印日志，输出内容为“XXX方法已执行，参数为param1，param2...”

5.saveUser()和saveSttudent()的参数age，如果传入的值小于0，则不再执行方法，并且打印日志“XXX方法执行失败，age：{$age}”

注：{$age}中输出传入的参数的值

二、实现

1.项目构建

构建后的目录：



2.编写两个类

package lm.practice.services;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
* Created by Administrator on 2017/4/11.
*/
public class StudentService {
Log log=LogFactory.getLog(this.getClass());
public void saveStudent(String name,int age){
System.out.println("保存了一个学生的信息");
}
public void deteleStudent(String name){
System.out.println("删除了一个学生的信息");
}
}

package lm.practice.services;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
* Created by Administrator on 2017/4/11.
*/
public  class UserService {
Log log=LogFactory.getLog(this.getClass());
public  void saveUser(String name,int age){
System.out.println("保存了一个用户的信息");
}
public void deleteUser(String name)
{
System.out.println("删除了一个用户的信息");
}
}

3.实现切面

方法一：配置文件法

(1)在aop包中编写LogInterceptor类作为切面类

package lm.practice.aop;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;

/**
* Created by Administrato
4000
r on 2017/4/12.
*/

public class LogInterceptor {
private Log log= LogFactory.getLog(this.getClass());

/**
* 后置通知
* @param joinPoint  连接点
*/
public void after(JoinPoint joinPoint){
//获取执行的方法名
String methodName=joinPoint.getSignature().getName();
//获取方法的参数
Object[] objects=joinPoint.getArgs();

//在日志中输出
log.info(methodName+"方法执行了，参数为：");
for (Object object:objects){
log.info(object+" ");
}
}
}

（2）配置文件spring-aop.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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> 
<!--将类注入到bean中-->
<!--切面-->
<bean id="logInterceptor" class="lm.practice.aop.LogInterceptor"></bean>

<bean id="studentService" class="lm.practice.services.StudentService"></bean>
<bean id="userService" class="lm.practice.services.UserService"></bean>

<aop:config>

<!--调用日志类-->
<!--配置在services包下的所有类都会被拦截-->
<aop:pointcut id="logService" expression="execution(* lm.practice.services.*.*(..))"/>
<!--expresstion中参数的含义：
lm.practice.services：包名
.*.*(..)表示该包下的所有类的所有方法，括号中的两个点表示参数没有限制
-->
<aop:aspect id="b" ref="logInterceptor">
<!--后置通知-->
<aop:after  method="after" pointcut-ref="logService"/>
</aop:aspect>
</aop:config>
<aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>

方法二：注解法

（1）切面类的写法

package lm.practice.aop;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

/**
* Created by Administrator on 2017/4/12.
*/

/**
* 日志切面类
*/
@Aspect
public class LogInterceptor {
private Log log= LogFactory.getLog(this.getClass());

//定义切入点
@Pointcut("execution(* lm.practice.services.*.*(..))")
private void allMethod(){

}
/**
* 后置通知
* @param joinPoint  连接点
*/
@After("allMethod()")
public void after(JoinPoint joinPoint){
//获取执行的方法名
String methodName=joinPoint.getSignature().getName();
//获取方法的参数
Object[] objects=joinPoint.getArgs();

//在日志中输出
log.info(methodName+"方法执行了，参数为：");
for (Object object:objects){
log.info(object+" ");
}
}}

（2）配置文件的写法

<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> 
<!--将类注入到spring容器-->
<bean id="userService" class="lm.practice.services.UserService"></bean>
<bean id="studentService" class="lm.practice.services.StudentService"></bean>

<!--把切面类交由spring容器来管理-->
<bean id="logInterceptor" class="lm.practice.aop.LogInterceptor"></bean>

<!--启动spring对AspectJ注解的支持-->
<aop:aspectj-autoproxy/>
</beans>

4.测试类

package test;

import lm.practice.services.UserService;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
* Created by Administrator on 2017/4/12.
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-aop.xml")
public class LonInterceptorTest {

@Autowired
private UserService userService;

@Test
public void test(){
userService.saveUser("dd",12);
}
/**
* -------------我是分界线，我上面的叫做注解测试方法，我下面的是传统的代码，都可以实现-----------------
*/
//    public static void main(String[] args){
//        ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-aop.xml");
//        UserService userService=ctx.getBean("userService",UserService.class);
//        userService.saveUser("小小",25);
//    }
}

5.运行结果：

（1）控制台输出



（2）日志文件

a.注解方式



b.main方法的方式



在实现这些功能的时候，中间为了搞清楚AOP通知的几种类型，以及类型的区别，犯了一些错误，我会在下一篇文章中做总结和说明，希望本篇博客达到了共勉的效果，也希望我们不断成长！