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

本文链接：https://blog.youkuaiyun.com/zhanglf02/article/details/78135654

上一节我们举了个用注解方式的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.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();
    }  
}