Spring框架重要知识点总结（三）

一、AOP是什么？

1、AOP（面向切面编程），它是利用对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2、AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）

二、为什么要学习AOP？

因为可以在运行期间，不修改源代码的情况下对已有的方法进行增强。

三、AOP的优势是什么？

1. 减少重复的代码 2. 提供开发的效率 3. 维护方便

四、AOP的底层原理

​JDK的动态代理技术（主要）​

1、为接口创建代理类的字节码文件

2、使用ClassLoader将字节码文件加载到JVM

3、创建代理类实例对象，执行对象的目标方法

​cglib代理技术​

五、AOP相关的术语

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

​Pointcut(切入点)​ – （编写切入点表达式），程序增强的入口。

​Advice(通知/增强)​–对spring中方法要进行增强，编写事务管理相关代码。

​Target(目标对象)​– 代理的目标对象

​Weaving(织入)​– 是指把增强应用到目标对象来创建新的代理对象的过程

​Proxy（代理）​– 一个类被AOP织入增强后，就产生一个结果代理类

​​Aspect(切面)​ = 切入点 + 通知​

六、入门案例

（一）首先简单说下步骤

​①​引入新的坐标AOP、Spring-aspects、aspect； ​②​配置文件引入具体的AOP约束； ​③​编写包结构，编写具体的接口和实现类； ​④​将目标类注入； ​⑤​定义切面类； ​⑥​在配置文件中注入切面类； ​⑦​完成AOP配置; ​⑧​测试

（二）具体实施

​①引入新的坐标AOP、Spring-aspects、aspect；​

<dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <!-- Spring Aspects -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!-- aspectj -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.3</version>
    </dependency>

​②配置文件引入具体的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">

​③编写包结构，编写具体的接口和实现类；​

接口：
package demo3;
public interface UserService {
    public void save();
}
实现类：
package demo3;
public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("业务层：保护用户...");
    }
}

​④将目标类注入；​

<bean id="userService2" class="demo3.UserServiceImpl">

​⑤定义切面类；​

package demo3;
/*
* 自定义切面类 = 切入点(表达式) + 通知(增强的代码)
* */
public class MyXmlAspect {
    /*通知*/
    public void log(){
        System.out.println("增强的方法执行了......");
    }
}

​⑥在配置文件中注入切面类；​

<bean id="myXmlAspect" class="demo3.MyXmlAspect"/>

​⑦完成AOP配置;​

<!--
             切入点的表达式：
                   execution() 固定的写法
                   public          是可以省略不写的
                   方法的返回值      int String 通用的写法，可以编写 * 不能省略不写的
                   包名+类名        不能省略不写的，编写 *  UserServiceImpl AccountServiceImpl
                   方法名称         save() 可以写 *
                   参数列表         (..) 表示任意类型和个数的参数
                   比较通用的表达式：execution(public * cn.tx.*.*ServiceImpl.*(..))
            -->

<aop:config>
            <!--配置切面 = 切入点 + 通知组成-->
            <aop:aspect ref="myXmlAspect">
                <!--前置通知-->
                <aop:before method="log" pointcut="execution(public * demo3.UserServiceImpl.save(..)))"/>
            </aop:aspect>
</aop:config>

​⑧编写测试类进行测试​

//运行单元测试  切记需要单元测试环境  导入spring-test
@RunWith(SpringJUnit4ClassRunner.class)
//加载类路径下的配置文件
@ContextConfiguration("classpath:applicationContext4.xml")
public class demo4 {
    //按照类型自动导入
    @Autowired
    private UserService userService;

    /*测试*/
    @Test
    public void run(){
        userService.save();
    }
}

（三）AOP的通知类型

<!--
                AOP的通知类型
                    前置通知：目标方法执行前，进行增强。
                        <aop:before method="log" pointcut="execution(* cn.tx.*.*ServiceImpl.save*(..))" />
                    最终通知：目标方法执行成功或者失败，进行增强。
                        <aop:after method="log" pointcut="execution(* cn.tx.*.*ServiceImpl.save*(..))" />
                    后置通知：目标方法执行成功后，进行增强。
                        <aop:after-returning method="log" pointcut="execution(* cn.tx.*.*ServiceImpl.save*(..))" />
                    异常通知：目标方法执行失败后，进行增强。
                        <aop:after-throwing method="log" pointcut="execution(* cn.tx.*.*ServiceImpl.save*(..))" />
                    环绕通知：目标方法执行前后，都可以进行增强。目标对象的方法需要手动执行。
            -->

七、Spring的AOP技术-注解方式

在上面基础上

​1、给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明​

@Component  // 把该类交给IOC去管理
@Aspect     // 声明是切面类  == <aop:aspect ref="myXmlAspect">
public class MyXmlAspect {

    /*通知*/
    // @Before(value = "切入点的表达式")
    @Before(value = "execution(public * demo3.UserServiceImpl.save(..))")
    public void log(){

        System.out.println("增强的方法执行了......");
    }
}

​2、配置文件中开启自动代理​

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

        <!--开启自动代理--> c
        <aop:aspectj-autoproxy/

八、Spring的AOP技术-纯注解方式

通知类型注解

@Before – 前置通知

@AfterReturing – 后置通知

@Around – 环绕通知（目标对象方法默认不执行的，需要手动执行）

@After – 最终通知

@AfterThrowing – 异常抛出通知

​编写配置类​

@Configuration      // 配置类
@ComponentScan(value = "cn.tx.demo3")   // 扫描包
@EnableAspectJAutoProxy     // 开启自动代理 == <aop:aspectj-autoproxy />
public class SpringConfig {

}