Spring框架AOP的理解

一.什么是AOP？

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

二.AOP的相关术语

Joinpoint(连接点):

所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

Pointcut(切入点):

所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

Advice(通知/增强):

所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

Introduction(引介):

引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

Target(目标对象):

代理的目标对象。

Weaving(织入):

是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

Proxy（代理）:

一个类被 AOP 织入增强后，就产生一个结果代理类。

Aspect(切面):

是切入点和通知（引介）的结合。

三.代码实例

1.首先导入IOC和AOP所需要的jar包

 2.创建BookService接口

package com.shi.service;


public interface BookService {

    void findAll();

    void add();

    void delete();

    void update();

}

3.创建BookServiceImpl实现对BookService继承，这个类完成核心功能操作。

package com.shi.service.impl;

import com.shi.service.BookService;

import java.awt.print.Book;

/*
* 核心类
* */
public class BookServiceImpl implements BookService {

    @Override
    public void findAll() {
        System.out.println("查询所有");
    }

    @Override
    public void add() {
        System.out.println("添加");
    }

    @Override
    public void delete() {
        System.out.println("删除");
    }

    @Override
    public void update() {
        System.out.println("修改");
    }
}

4.创建Logger类，这个类是用来做功能的增强。

package com.shi.logger;

/*
* 增强类
* */
public class Logger {

    public void check(){
        System.out.println("前置通知/增强：权限验证");
    }

    public void logPrint(){
        System.out.println("后置通知/增强：日志输出");
    }

    public void afterThroeing(){
        System.out.println("异常通知/增强：异常处理");
    }

    public void after(){
        System.out.println("最终通知/增强：资源释放");
    }
}

5.在spring的spring.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: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.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.xsd">

    <!--1.把所有类的对象交给IOC容器进行管理-->
    <bean id="logger" class="com.shi.logger.Logger"/>
    <bean id="bookService" class="com.shi.service.impl.BookServiceImpl"/>

    <!--2.AOP的配置：让增强类 的 哪个方法  动态进行何种增强   核心类 的 哪个方法-->
    <aop:config>
        <!--指定增强类并起个名字-->
        <aop:aspect id="lod" ref="logger">
            <!--前置通知/增强：在核心类方法执行之前  进行  增强-->
            <aop:before method="check" pointcut="execution(* *..BookServiceImpl.*(..))"/>
            <aop:after-returning method="logPrint" pointcut="execution(* *..BookServiceImpl.*(..))"/>
            <aop:after-throwing method="afterThroeing" pointcut="execution(* *..BookServiceImpl.*(..))"/>
            <aop:after method="after" pointcut="execution(* *..BookServiceImpl.*(..))"/>

        </aop:aspect>
    </aop:config>

</beans>

6.在测试类中测试BookService的方法是否被增强

package com.shi.servlet;

import com.shi.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test01 {

    @Test
    public void test01(){
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        BookService bookService=context.getBean(BookService.class);
        bookService.add();
        System.out.println("---------------");
        bookService.findAll();
        System.out.println("---------------");
        bookService.delete();
        System.out.println("---------------");
        bookService.update();
    }
}

运行结果：