Spring的介绍（三）之AOP的相关概念

什么是AOP？AOP：全称是Aspect Oriented Programming即：面向切面编程。
捡来来说，就是使用动态代理的技术，在不修改源码的基础上，对我们已有的方法进行增强

一、AOP的实现方式

使用动态代理技术：
基于接口的动态代理
提供者：JDK官方的Proxy类。
要求：被代理类最少实现一个接口。
基于子类的动态代理
提供者：第三方的CGLib。
要求：被代理类不能用final修饰的类（最终类）。

二、Spring中的AOP

AOP中的术语：

三、Demo（基于配置文件的）

要求：在AccountServiceImpl中所有方法执行前添加一个打印日志的功能，但是不能修改源码。

public interface IAccountService {
    void saveAccount();
    void updateAccount(int i);
    int deleteAccount();
}

//实现类
public class AccountServiceImpl implements IAccountService {
    public void saveAccount() {
        System.out.println("保存账户");
    }
    public void updateAccount(int i) {
        System.out.println("更新账户");
    }
    public int deleteAccount() {
        System.out.println("删除账户");
        return 0;
    }
}

//切面类
public class Logger {
    public void printLogger(){
        System.out.println("开始打印日志了。。。。。");
    }
    public void printLogger2() {
        System.out.println("Logger类中的printLog2方法开始记录日志了。。。");
    }
    public void printLogger3() {
        System.out.println("Logger类中的printLog3方法开始记录日志了。。。");
    }
    //前置通知
    public void beforePrintLog(){
        System.out.println("前置通知执行了");
    }
    //后置通知
    public void afterReturningPrintLog(){
        System.out.println("后置通知执行了");
    }
    //异常通知
    public void afterThrowingPrintLog(){
        System.out.println("异常通知执行了");
    }
    //最终通知
    public void afterPrintLog(){
        System.out.println("最终通知执行了");
    }
//    环绕通知
    public Object arround(ProceedingJoinPoint pj){
        Object obj = null;
        try {
            System.out.println("前置通知");
            obj = pj.proceed();
            System.out.println("后置通知");
        } catch (Throwable throwable) {
            System.out.println("异常通知");
            throwable.printStackTrace();
        }finally {
            System.out.println("最终通知");
        }
        return obj;
    }
}

<?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">


    <!--装配AccountServiceImpl到容器中-->
    <bean id="accountService" class="cn.itcast.service.impl.AccountServiceImpl"></bean>

    <!--装配Logger到容器中-->
    <bean id="logger" class="cn.itcast.utils.Logger"></bean>

    <!-- 配置AOP -->
    <aop:config>
    <!--改进：统一管理表达式-->
        <aop:pointcut id="p1" expression="execution(* com.itheima.service.Impl.*.*(..))"></aop:pointcut>
        <!-- 配置切面
            id：切面的唯一标识
            ref:引用通知类
         -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置前置通知
                    method:配置通知方法（即具体进行增强的方法）
                    pointcut:配置AspectJ表达式，即将通知增强到哪个方法
                    execution:使用AspectJ的切入点表达式
                            execution(修饰符 返回值类型 包名.类名.方法名(参数列表))
             -->
            <aop:before method="printLog" pointcut="execution(public void cn.itcast.service.impl.AccountServiceImpl.saveAccount())" />
        </aop:aspect>
        <!--后置通知:目标方法执行之后执行-->
<aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>
<!--异常通知：目标方法发生异常时执行-->
<aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>
<!--最终通知：不管有没有异常，最终都会执行-->
<aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>
<!--环绕通知：手动在代码中配置各类通知的执行时机-->
<!--<aop:around method="around" pointcut-ref="pt1"></aop:around>-->

    </aop:config>

</beans>

使用springAOP的xml配置，步骤如下：
1、 创建切面类（通知类）
切面类中的方法即是通知（也称之为增强）
3、将切面类装配到IOC容器中
2、使用AOP标签配置通知和切入点的关系，完成功能的增强

四、基于注解的demo

<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">

    <!--开启注解扫描-->
    <context:component-scan base-package="cn.itcast"></context:component-scan>

    <!--开启注解AOP-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

//service实现类
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Override
    public void saveAccount() {
        System.out.println("保存账户");
        int x = 1 / 0;
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("更新账户");
    }
    @Override
    public int deleteAccount() {
        System.out.println("删除账户");
        return 0;
    }
}

//切面类
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {
    public void printLogger(){
        System.out.println("开始打印日志了。。。。。");
    }
    public void printLogger2() {
        System.out.println("Logger类中的printLog2方法开始记录日志了。。。");
    }
    public void printLogger3() {
        System.out.println("Logger类中的printLog3方法开始记录日志了。。。");
    }
/*    //前置通知
    @Before("execution(* com.itheima.service.Impl.*.*(..))")
    public void beforePrintLog(){
        System.out.println("前置通知执行了");
    }
    //后置通知
    @AfterReturning("execution(* com.itheima.service.Impl.*.*(..))")
    public void afterReturningPrintLog(){
        System.out.println("后置通知执行了");
    }
    //异常通知
    @AfterThrowing("execution(* com.itheima.service.Impl.*.*(..))")
    public void afterThrowingPrintLog(){
        System.out.println("异常通知执行了");
    }
    //最终通知
    @After(("execution(* com.itheima.service.Impl.*.*(..))"))
    public void afterPrintLog(){
        System.out.println("最终通知执行了");
    }*/
//    环绕通知
    @Around("execution(* com.itheima.service.Impl.*.*(..))")
    public Object arround(ProceedingJoinPoint pj){
        Object obj = null;
        try {
            System.out.println("前置通知");
            obj = pj.proceed();
            System.out.println("后置通知");
        } catch (Throwable throwable) {
            System.out.println("异常通知");
            throwable.printStackTrace();
        }finally {
            System.out.println("最终通知");
        }
        return obj;
    }
}

> AOP相关注解：
1、@Aspect
声明当前类使用切面类（通知类）
2、@Before
前置通知：目标方法执行之前执行
3、@AfterReturning
后置通知：目标方法执行完成之后执行
4、@AfterThrowing
异常通知：目标方法发生异常时执行
5、@After
最终通知：不管有没有异常，一定会执行。
6、@Around
环绕通知：手动执行目标方法，完成各类通知的配置。
7、@Pointcut:
切入点表达式：通过一个空方法单独配置切入点表达式。在其他通知引用该切入点表达式时通过：方法名称+()，来进行引用。

五、纯注解的配置类

@Configuration//声明这是个配置类
@ComponentScan("cn.itcast")//配置包扫描
@EnableAspectJAutoProxy//开启AOP的注解扫描
public class SpringConfiguration {
}