详解spring面向切面aop拦截器

spring中有很多概念和名词，其中有一些名字不同，但是从功能上来看总感觉是那么的相似，比如过滤器、拦截器、aop等。
过滤器filter、spring mvc拦截器interceptor 、面向切面编程aop，实际上都具有一定的拦截作用，都是拦截住某一个面，然后进行一定的处理。

在这里主要想着手的是aop，至于他们的比较，我想等三个都一一了解完了再说，因此这里便不做过多的比较。

在我目前的项目实践中，只在一个地方手动显示的使用了aop，那便是日志管理中对部分重要操作的记录。

据我目前所知，aop拦截一般都是用在具体的方法上，或者说是具体的某一类方法，我所用过的实现方式有两种，一种是直接代码声明，一种是在xml文件中配置。

由于我目前实际开发的项目都是使用spring+spring mvc的架构，然后使用maven管理，然后junit测试。因此我自己几乎所有的个人项目也都是采用这些架构和项目管理工具，在这个理解aop的小项目中，自然也是这样，依赖包如下：

<project xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelversion>4.0.0</modelversion>
 <groupid>springtest</groupid>
 <artifactid>aoptest</artifactid>
 <version>0.0.1-snapshot</version>
 <dependencies>
  <dependency>
    <groupid>junit</groupid>
    <artifactid>junit</artifactid>
    <version>4.12</version>
  </dependency>
  <dependency>
    <groupid>org.springframework</groupid>
    <artifactid>spring-context</artifactid>
    <version>4.0.3.release</version>
  </dependency>
  <dependency>
    <groupid>org.springframework</groupid>
    <artifactid>spring-aop</artifactid>
    <version>4.0.3.release</version>
  </dependency>
  <dependency>
    <groupid>org.springframework</groupid>
    <artifactid>spring-test</artifactid>
    <version>4.0.3.release</version>
  </dependency>
  <dependency>
    <groupid>org.aspectj</groupid>
    <artifactid>aspectjweaver</artifactid>
    <version>1.8.4</version>
  </dependency>
 </dependencies>
</project>

第一种方式，java代码声明：

这里实例中，我要声明一个aop来拦截dao层中的get开头的所有方法，首先建一个dao以及简单的额imp实现：

dao接口如下：

package com.ck.aoptest.dao;
import com.ck.aoptest.model.usermodel;

public interface myaopdao {
  public void getuser();
  public void getname(usermodel user);
  public void adduser();
}

简单的实现：

package com.ck.aoptest.dao.impl;
import org.springframework.stereotype.repository;
import com.ck.aoptest.dao.myaopdao;
import com.ck.aoptest.model.usermodel;

@repository
public class myaopdaoimpl implements myaopdao {

  @override
  public void getuser() {
    system.out.println("这是我的aop测试dao方法一");
  }
  @override
  public void getname(usermodel usermodel) {
    system.out.println("这是我的aop测试dao方法二");
  }
  @override
  public void adduser() {
    system.out.println("这是我的aop测试dao方法三");
  }
}

然后声明一个aop：

package com.ck.aoptest.aop;
import java.util.date;
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.aspectj.lang.annotation.pointcut;
import org.springframework.stereotype.component;
import com.ck.aoptest.model.usermodel;

@aspect
@component
public class myaop {

  @pointcut("execution(public * com.ck.aoptest.dao.impl.*.get*(..))")
  private void aoptest() {

  }
  @before("aoptest()")
  public void before() {
    system.out.println("调用dao方法前拦截" + new date().gettime());
  }
  @after("aoptest()" + "&&args(user)")
  public void after(usermodel user) {
    system.out.println(user.getname());
    system.out.println("调用dao方法之后拦截" + new date().gettime());
  }
  @around("aoptest()")
  public void around(proceedingjoinpoint pdj) {
    system.out.println("调用dao之前的环绕拦截" + new date().gettime());
    try {
      pdj.proceed();
    } catch (throwable e) {
      e.printstacktrace();
    }
    system.out.println("调用dao之后的环绕拦截" + new date().gettime());
  }
}

上述代码便是用java声明aop的核心代码，其中注解@aspect的作用的就是告诉spring这是一个aop类，然后@component就不用多说了，告诉spring这是一个需要扫描的类。

再往下，@pointcut(“execution(public * com.ck.aoptest.dao.impl..get(..))”)正式声明需要拦截的切面，@pointcut以及后边的额execution是固定的写法，execution后括号内的内容便是具体的切面，这里的意思是拦截所有public的任何返回值或者void的、命名空间是com.ck.aoptest.dao.impl下边的所有的类中的所有get开头的拥有任意多个参数的方法。

简单点说也就是当任何调用了com.ck.aoptest.dao.impl这个包中任何类中的get开头的方法，便会激活这个aop。

而紧接着上边这一段，我们看到了一个private void aoptest() 空的方法，实际上这个方法的作用是为这个aop切面声明一个名字，便于使用，也便于在多个aop切面时正常区分。

再后边的@before、@after、@around便是三个可选拦截方式，见名之意，分别是在上边声明的切面指明的方法调用之前执行、调用之后执行、以及环绕执行，调用之前和调用之后比较好理解，环绕的意思是在调用之前和之后都执行一定的逻辑。
从代码中可以看出，pdj.proceed();之前和之后各打印了两行数据，pdj.proceed();就代表了继续执行，如果是了解filter的应该很容易想到这个方法实际上和chain.dofilter很像，可以理解成放行。

在这三个注解之后需要指定要使用的切面，即@pointcut声明的切面，指定名称就行。

从代码中可以看到有一个地方后边加了“&&args(usermodel user)”，意思是指定形参，也就是说指定的切面中有效方法的参数，例如上边dao中的getname方法有一个usermodel类型的参数，这里便可以使用。

主要代码写好了，接下来还有个必不可少的步骤，既然是spring项目，是spring的aop，那么自然需要配置spring文件，指明需要spring管理的包：

<?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" " 
  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-3.0.xsd"> 
  <context:component-scan base-package="com.ck.aoptest.*" />
</beans>

为了验证这里的aop是否真的有效，我写了一个junit测试：

package com.ck.aoptest.test;
import org.junit.test;
import org.junit.runner.runwith;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.test.context.contextconfiguration;
import org.springframework.test.context.junit4.springjunit4classrunner;
import com.ck.aoptest.dao.myaopdao;
import com.ck.aoptest.model.usermodel;

@runwith(springjunit4classrunner.class)
@contextconfiguration(locations = "classpath:spring.xml")
public class aoptest {
  @autowired
  private myaopdao myaopdao;

  @test
  public void aoptest2() {
    usermodel user = new usermodel();
    myaopdao.getname(user);
  }
}

按理说，这里运行测试方法后应该打印出很多条输出，但是遗憾的是结果只是打印出了dao中的一条输出，原因是spring配置中并没有启用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:context="http://www.springframework.org/schema/context" 
  xmlns:aop="http://www.springframework.org/schema/aop" 
  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-3.0.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.0.xsd"> 

  <aop:aspectj-autoproxy />
  <context:component-scan base-package="com.ck.aoptest.*" />  

</beans>

我们需要再文件头加入

xmlns:aop=”http://www.springframework.org/schema/aop”

以及

除此之外，还要启用aop：

<aop:aspectj-autoproxy />

再次运行测试方法会看到控制台如下：

由此证明这个aop是有效的。

第二种方式，配置文件配置：

同样的，这里还是用之前的dao以及对应的impl，因此这段代码便不再重复，不一样的是具体的aop类如下：

package com.ck.aoptest.aop;
public class myaop2 {
  public void before2() {
    system.out.println("这是我的使用注解的aop，调用dao之前拦截");
  }
}

可以看到这个类实际上也是极致简单，普通类，普通方法，没有任何特别，然后我们要做的是在spring中配置：

<?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/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-3.0.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.0.xsd"> 

  <aop:aspectj-autoproxy />
  <bean id="myaop2" class="com.ck.aoptest.aop.myaop2"></bean>
  <aop:config>
   <aop:pointcut expression="execution(public * com.ck.aoptest.dao.impl.*.add*(..))" id="aoptest1"/>
   <aop:aspect id="myaoptest2" ref="myaop2">
    <aop:before method="before2" pointcut-ref="aoptest1"/>
   </aop:aspect>
  </aop:config>
  <context:component-scan base-package="com.ck.aoptest.*" />

</beans>

至于这里配置内容的具体解释，我想通过我对第一种方式的解释后，也没有太大必要再说，稍微一对比就会一清二楚。

同样的，这里只演示了before，至于after和round的配置应该也很容易就可以根据before推理出来。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。