javaweb接口安全校验预备知识——spring aop之 配置方式

上一节我们举了个用注解方式的aop简单实现。这节我们说配置方式的aop的具体实现。重点在于@Around注解的方法是什么时候处理，进入接入点——核心方法的。

框架上大体还是上一节的框架。整体项目结构是这样的。



1 pom.xml引入jar包，和注解的pom比几乎没有变化

<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/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion>
<groupId>com.echarts</groupId>
<artifactId>EchartsProjectForAop</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>EchartsProject Maven Webapp</name>
<url>http://maven.apache.org</url>

<properties>
<spring.version>4.0.2.RELEASE</spring.version>
<jdk.version>1.7</jdk.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
<scope>test</scope>
</dependency>

<!-- Spring的面向切面编程,提供AOP(面向切面编程)实现 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
<build>
<finalName>EchartsProjectForAop</finalName>
<plugins>
<!--        指定jdk版本 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.3</version>
<configuration>
<source>${jdk.version}</source>
<target>${jdk.version}</target>
<showWarnings>true</showWarnings>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
</project>

2.aop的配置文件

这里的配置文件依赖于自定义的aop类和切入的路径。这里正常的思路是先定义aop类——

com.zhanglf.advice.AdviceUtils

,然后才根据自定义advice类进行配置。

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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<!-- 实现注入实体类 -->
<bean id="filmShow" class="com.zhanglf.Service.impl.FilmShowImpl"></bean>

<!-- 自定义的aop类声明 -->
<bean id="adviceDemo" class="com.zhanglf.advice.AdviceUtils"></bean>
<aop:config>
<aop:aspect id="aspect" ref="adviceDemo">
<aop:pointcut expression="execution(* com.zhanglf.Service..*.*(..))" id="filmPoint"/>
<aop:around method="doAround" pointcut-ref="filmPoint"/>
<!--        <aop:before method="doBefore" pointcut-ref="filmPoint"/> -->
</aop:aspect>
</aop:config>

</beans>

这样就完成了全部的配置。下面是自定义advice类。

3 AdviceUtils.java,这也是这个工程的重点部分。就是doAround()方法的运行结果。

package com.zhanglf.advice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

/**
* Advice通知类
* 测试after,before,around,throwing,returning Advice.
* @author Administrator
*
*/
public class AdviceUtils {
/**
* 在核心业务执行前执行，不能阻止核心业务的调用。
* @param joinPoint
*/
private void doBefore(JoinPoint joinPoint) {
System.out.println("-----doBefore().invoke-----");
System.out.println(" 此处意在执行核心业务逻辑前，做一些安全性的判断等等");
System.out.println(" 可通过joinPoint来获取所需要的内容");
System.out.println("-----End of doBefore()------");
}

/**
* 手动控制调用核心业务逻辑，以及调用前和调用后的处理,
*
* 注意：当核心业务抛异常后，立即退出，转向After Advice
* 执行完毕After Advice，再转到Throwing Advice
* @param pjp
* @return
* @throws Throwable
*/
private Object doAround(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("-----doAround().invoke-----");
System.out.println(" 此处可以做类似于Before Advice的事情");

//调用核心逻辑
Object retVal = pjp.proceed();

System.out.println(" 此处可以做类似于After Advice的事情");
System.out.println("-----End of doAround()------");
return retVal;
}

/**
* 核心业务逻辑退出后（包括正常执行结束和异常退出），执行此Advice
* @param joinPoint
*/
private void doAfter(JoinPoint joinPoint) {
System.out.println("-----doAfter().invoke-----");
System.out.println(" 此处意在执行核心业务逻辑之后，做一些日志记录操作等等");
System.out.println(" 可通过joinPoint来获取所需要的内容");
System.out.println("-----End of doAfter()------");
}

/**
* 核心业务逻辑调用正常退出后，不管是否有返回值，正常退出后，均执行此Advice
* @param joinPoint
*/
private void doReturn(JoinPoint joinPoint) {
System.out.println("-----doReturn().invoke-----");
System.out.println(" 此处可以对返回值做进一步处理");
System.out.println(" 可通过joinPoint来获取所需要的内容");
System.out.println("-----End of doReturn()------");
}

/**
* 核心业务逻辑调用异常退出后，执行此Advice，处理错误信息
* @param joinPoint
* @param ex
*/
private void doThrowing(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()------");
}
}

4 然后是连接点的定义，用来测试aop。连接点就是aop要拦截的包，类或者方法。也就是本例的FilmShowImpl.java所在的包——Serivce包



先看接口类，定义了两个电影的方法。

package com.zhanglf.Service;

import java.util.List;

//电影查询的接口，实现查看在售电影票，在上映电影排行榜这两个功能
public interface IFilmShow {
public void getFilmOnSale();
public List orderFilm();
}

然后是实现类——FilmShowImpl.java

package com.zhanglf.Service.impl;

import java.
10ce4
util.List;

public class FilmShowImpl implements com.zhanglf.Service.IFilmShow {

@Override
public void getFilmOnSale() {
System.out.println("在上映的有《蜘蛛侠3》，《加勒比海盗5-死无对证》");

}

@Override
public List orderFilm() {
System.out.println("电影排行榜：1 《加勒比海盗5》 2 《蜘蛛侠3》 3 《变形金刚5》");
return null;
}

}

完成以上就可以进行测试。由于我这里只关注around方式，所以配置文件我把其他的advice配置注释掉了。



5.测试类。

package com;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhanglf.Service.IFilmShow;

public class TestAOP {
@Test
public void inteceptorTest(){
ApplicationContext ctx = new ClassPathXmlApplicationContext("META-INF/aop/spring-aop.xml");
IFilmShow ifshow=(IFilmShow)ctx.getBean("filmShow");
ifshow.getFilmOnSale();
}
}

然后用junit方式运行，结果如下：



参考博文：Spring Aop实例之xml配置