spring aop通知(advice)分成五类：

1. 前置通知[Before advice]：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常。
2. 后置通知[After returning advice]：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行。
3. 异常通知[After throwing advice]：在连接点抛出异常后执行。
4. 返回通知[After (finally) advice]：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内容。
5. 环绕通知[Around advice]：环绕通知围绕在连接点前后，比如一个方法调用的前后。这是最强大的通知类型，能在方法调用前后自定义一些操作。环绕通知还需要负责决定是继续处理join point(调用ProceedingJoinPoint的proceed方法)还是中断执行。

接下来通过编写示例程序来测试一下五种通知类型：

非注解方式

前置通知

定义aop类

• method：被调用的方法，就是连接点
• objects：被调用方法的参数
• o：调用被调用方法的对象

xml文件

注意要先在ioc容器中放入对象才能使用id引用。

 <bean id="logBefore" class="com.cztcode.spring.aop.LogBefore"/>
    <aop:config>
        <aop:pointcut id="point" expression="execution(public void com.cztcode.spring.impl.StudentServiceImpl.addStudent(com.cztcode.spring.entity.Student))"/>
<!--        关联ref，当执行点时，执行advice-->
        <aop:advisor advice-ref="logBefore" pointcut-ref="point"/> 
    </aop:config>

执行结果

后置通知

后置通知与前置类似，只是参数和接口不同

多了一个

• returnValue：方法返回值

xml文件

执行结果

异常通知

Exception：异常类型

环绕通知

环绕通知很强大，上面那三个通知都可以做到。

xml文件配置方法相同。

如果invocation.proceed()没有写，那么这个切入点方法就不会被执行。但是环绕方法的通知会执行。

环绕通知底层通过拦截器实现。

注解形式

前置和后置通知

开启扫描器和对AOP注解支持

实现效果

异常通知

截获某种异常

若发生异常通知，后置通知将不会触发

环绕通知

最终通知

其实在环绕通知中已经实现了最终通知

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

详细介绍：细说Spring——AOP详解（AOP概览）

找了一些资料，混合着我的理解补充。

Spring AOP 简介

如果说 IoC 是 Spring 的核心，那么面向切面编程就是 Spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。

AOP 即 Aspect Oriented Program 面向切面编程

首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。

• 所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务
• 所谓的周边功能，比如性能统计，日志，事务管理等等

周边功能在 Spring 的面向切面编程AOP思想里，即被定义为切面

在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 “编织” 在一起，这就叫AOP。

AOP 的目的

AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

AOP 当中的概念：

• 切入点（Pointcut）
  在哪些类，哪些方法上切入（where）
• 通知（Advice）
  在方法执行的什么实际（when:方法前/方法后/方法前后）做什么（what:增强的功能）
• 切面（Aspect）
  切面 = 切入点 + 通知，通俗点就是：在什么时机，什么地方，做什么增强！
• 织入（Weaving）
  把切面加入到对象，并创建出代理对象的过程。（由 Spring 来完成）

一个例子

为了更好的说明 AOP 的概念，我们来举一个实际中的例子来说明：

在上面的例子中，包租婆的核心业务就是签合同，收房租，那么这就够了，灰色框起来的部分都是重复且边缘的事，交给中介商就好了，这就是 AOP 的一个思想：让关注点代码与业务代码分离！

实际的代码

我们来实际的用代码感受一下

1.在 Package【pojo】下新建一个【Landlord】类（我百度翻译的包租婆的英文）：

package pojo;

import org.springframework.stereotype.Component;

@Component("landlord")
public class Landlord {

    public void service() {
        // 仅仅只是实现了核心的业务功能
        System.out.println("签合同");
        System.out.println("收房租");
    }
}

2.在 Package【aspect】下新建一个中介商【Broker】类（我还是用的翻译…）：

package aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
class Broker {

    @Before("execution(* pojo.Landlord.service())")
    public void before(){
        System.out.println("带租客看房");
        System.out.println("谈价格");
    }

    @After("execution(* pojo.Landlord.service())")
    public void after(){
        System.out.println("交钥匙");
    }
}

3.在 applicationContext.xml 中配置自动注入，并告诉 Spring IoC 容器去哪里扫描这两个 Bean：

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

    <context:component-scan base-package="aspect" />
    <context:component-scan base-package="pojo" />

    <aop:aspectj-autoproxy/>
</beans>

4.在 Package【test】下编写测试代码：

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.Landlord;

public class TestSpring {

    public static void main(String[] args) {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Landlord landlord = (Landlord) context.getBean("landlord", Landlord.class);
        landlord.service();

    }
}

5.执行看到效果：

这个例子使用了一些注解，现在看不懂没有关系，但我们可以从上面可以看到，我们在 Landlord 的 service() 方法中仅仅实现了核心的业务代码，其余的关注点功能是根据我们设置的切面自动补全的。

使用注解来开发 Spring AOP

使用注解的方式已经逐渐成为了主流，所以我们利用上面的例子来说明如何用注解来开发 Spring AOP

第一步：选择连接点

Spring 是方法级别的 AOP 框架，我们主要也是以某个类额某个方法作为连接点，另一种说法就是：选择哪一个类的哪一方法用以增强功能。

    ....
    public void service() {
        // 仅仅只是实现了核心的业务功能
        System.out.println("签合同");
        System.out.println("收房租");
    }
    ....

我们在这里就选择上述 Landlord 类中的 service() 方法作为连接点。

第二步：创建切面

选择好了连接点就可以创建切面了，我们可以把切面理解为一个拦截器，当程序运行到连接点的时候，被拦截下来，在开头加入了初始化的方法，在结尾也加入了销毁的方法而已，在 Spring 中只要使用 @Aspect 注解一个类，那么 Spring IoC 容器就会认为这是一个切面了：

package aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
class Broker {

    @Before("execution(* pojo.Landlord.service())")
    public void before(){
        System.out.println("带租客看房");
        System.out.println("谈价格");
    }

    @After("execution(* pojo.Landlord.service())")
    public void after(){
        System.out.println("交钥匙");
    }
}

• 注意： 被定义为切面的类仍然是一个 Bean ，需要 @Component 注解标注

代码部分中在方法上面的注解看名字也能猜出个大概，下面来列举一下 Spring 中的 AspectJ 注解：

有了上表，我们就知道 before() 方法是连接点方法调用前调用的方法，而 after() 方法则相反，这些注解中间使用了定义切点的正则式，也就是告诉 Spring AOP 需要拦截什么对象的什么方法，下面讲到。

第三步：定义切点

在上面的注解中定义了 execution 的正则表达式，Spring 通过这个正则表达式判断具体要拦截的是哪一个类的哪一个方法：

execution(* pojo.Landlord.service())

依次对这个表达式作出分析：

• execution：代表执行方法的时候会触发
• * ：代表任意返回类型的方法
• pojo.Landlord：代表类的全限定名
• service()：被拦截的方法名称

通过上面的表达式，Spring 就会知道应该拦截 pojo.Lnadlord 类下的 service() 方法。上面的演示类还好，如果多出都需要写这样的表达式难免会有些复杂，我们可以通过使用 @Pointcut 注解来定义一个切点来避免这样的麻烦：

package aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
class Broker {

    @Pointcut("execution(* pojo.Landlord.service())")
    public void lService() {
    }

    @Before("lService()")
    public void before() {
        System.out.println("带租客看房");
        System.out.println("谈价格");
    }

    @After("lService()")
    public void after() {
        System.out.println("交钥匙");
    }
}

第四步：测试 AOP

环绕通知

我们来探讨一下环绕通知，这是 Spring AOP 中最强大的通知，因为它集成了前置通知和后置通知，它保留了连接点原有的方法的功能，所以它及强大又灵活，让我们来看看：

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Aspect
class Broker {

//  注释掉之前的 @Before 和 @After 注解以及对应的方法
//  @Before("execution(* pojo.Landlord.service())")
//  public void before() {
//      System.out.println("带租客看房");
//      System.out.println("谈价格");
//  }
//
//  @After("execution(* pojo.Landlord.service())")
//  public void after() {
//      System.out.println("交钥匙");
//  }

    //  使用 @Around 注解来同时完成前置和后置通知
    @Around("execution(* pojo.Landlord.service())")
    public void around(ProceedingJoinPoint joinPoint) {
        System.out.println("带租客看房");
        System.out.println("谈价格");

        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

        System.out.println("交钥匙");
    }
}

运行测试代码，结果仍然正确.

使用 XML 配置开发 Spring AOP

注解是很强大的东西，但基于 XML 的开发我们仍然需要了解，我们先来了解一下 AOP 中可以配置的元素：

有了之前通过注解来编写的经验，并且有了上面的表，我们将上面的例子改写成 XML 配置很容易（去掉所有的注解）：

<!-- 装配 Bean-->
<bean name="landlord" class="pojo.Landlord"/>
<bean id="broker" class="aspect.Broker"/>

<!-- 配置AOP -->
<aop:config>
    <!-- where：在哪些地方（包.类.方法）做增加 -->
    <aop:pointcut id="landlordPoint"
                  expression="execution(* pojo.Landlord.service())"/>
    <!-- what:做什么增强 -->
    <aop:aspect id="logAspect" ref="broker">
        <!-- when:在什么时机（方法前/后/前后） -->
        <aop:around pointcut-ref="landlordPoint" method="around"/>
    </aop:aspect>
</aop:config>

作者：我没有三颗心脏

IDEA配置

在创建项目时点击Spring项目即可快速创建。IDEA可以少导入很多jar包的，这里我添加进去缺少的两个。

<dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>[1.4,)</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>

关于数据库的配置，例子里虽然没有用到：

 <tx:annotation-driven transaction-manager="transactionManager"/>

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="mysql"/>
    </bean>


    <bean id="mysql" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <!-- schema_person是模式名，cj版本的驱动必须提前设置好时区-->
        <property name="url"
                  value="jdbc:mysql://localhost:3306/jd_schema?useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="  "/>
    </bean>

创建项目的时候分号包。

• aop中存放需要织入的方法
• dao中存放Dao层的接口，对数据库的操作
• entity存放实体类型
• impl存放实现类
• service存放主要实现代码

后置通知

后置通知和前置通知类似，接口更换为：

AfterReturningAdvice

Spring简介

IOC

IOC全称: Inverse of Control, 控制反转,IOC其实不是什么技术，而是一种设计思想。

简要的说就是：原本需要程序去主动new创建的对象，现在反转过来交给spring的容器去创建。

什么是Spring IOC 和DI（最好的讲解）

创建

IDEA创建Spring项目比eclipse简单了很多很多很多很多。

首先打开IDEA，新建project，勾选新建Spring，点击Finish，完成。

IDEA会自动帮你下载需要的依赖。

之后我们创建学生类，写出基本属性。

右键src创建spring的配置文件

在这里我们给创建的实例初始化值

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student_chen" class="Student">
        <property name="age" value="10"/>
        <property name="name" value="chen"/>
        <property name="number" value="01"/>
    </bean>
</beans>

新建一个测试类，实例化对象。

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

public class Main {
  public static void main(String[] args) {
    ApplicationContext app = new ClassPathXmlApplicationContext("bean.xml");
    Student student = (Student) app.getBean("student_chen");
    System.out.println(student.toString());
  }
}

完成。

如果类之间有继承关系，使用ref引用

使用constructor

使用构造器创建对象，上面的方法使用的是setter方法。

<bean id="classes_02" class="Classes">
        <constructor-arg value="02"/>
        <constructor-arg ref="teacher_li"/>
    </bean>

顺序与构造方法中的顺序一致，当然也可以手动指定顺序

<bean id="classes_02" class="Classes">
        <constructor-arg value="02" index="0"/>
        <constructor-arg ref="teacher_li" index="1"/>
    </bean>

使用name指定，感觉比index方便

  <bean id="classes_02" class="Classes">
        <constructor-arg value="02" index="0" name="num"/>
        <constructor-arg ref="teacher_li" index="1" name="teacher"/>
    </bean>

数组属性类型的注入

 <bean id="abcd" class="ABCD">
        <property name="array">
            <array>
                <value>czt</value>
                <value>slh</value>
            </array>
        </property>
        <property name="arrayList">
            <array>
                <value>czt</value>
                <value>slh</value>
            </array>
        </property>
        <property name="map" >
            <map>
            <entry key="chen" value="01"/>
        </map>
        </property>
    </bean>
</beans>

value中的字符串空值，直接写

<null/>

使用构造方法赋值

使用IOC时，类中必须有无参构造方法

构造方法赋值和普通类型的属性方式相同

使用autowire自动注入

  <bean id="teacher" class="Teacher">
        <property name="name" value="li"/>
        <property name="sex" value="女"/>
     </bean>

    <bean id="classes_02" class="Classes" autowire="byName">
      <property name="num" value="02"/>
    </bean>

若类中属性名和Bean的id相同，将会自动注入

知识存储

静态资源路径：

而spring boot静态资源路径如下：（其中classpath为src.resources文件夹下）

"classpath: /META-INF/resources/", 
"classpath: /resources/",
"classpath: /static/", 
"classpath: /public/" 
"/"：当前项目的根路径

欢迎页映射规则：

以“/**”的方式映射，系统会默认访问静态资源下的index.html文件

例如：

localhost:8080/（当静态文件夹中有index.html文件时，才可以映射到）

动态资源

之前讲的thymeleaf便是模板引擎，用来动态渲染

只要我们把HTML页面放在classpath:/templates/，thymeleaf就能自动渲染；

本章仅仅只是简单入门Thymeleaf。

之前学习的是jsp，但是现在不是很推荐使用jsp来实现网页页面效果。但是还走了不少弯路。 简单说，Thymeleaf 是一个跟 Velocity、FreeMarker 类似的模板引擎，它可以完全替代 JSP 。 推荐详细介绍网址：https://www.cnblogs.com/ityouknow/p/5833560.html

快速创建spring boot项目

选择相应的jar包组件

添加依赖

寻找依赖的网站： 点击这里

需要的依赖

<!-- https://mvnrepository.com/artifact/org.thymeleaf/thymeleaf -->
<dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf</artifactId>
    <version>3.0.11.RELEASE</version>
</dependency>

尝试运行

编写ThymeleafController文件

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller

public class ThymeleafController {

    /**
     * Spring Boot默认存放模板页面的路径在src/main/resources/templates或者src/main/view/templates
     * 所以它会自动去访问src/main/resources/templates/show（return中的内容）.html
     * @return
     */

    @RequestMapping(value = "show",method = RequestMethod.GET)
    public String show(){
        return "show";
    }
}

编写HTML文件

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>SpringBoot模板渲染</title>
    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"/>
</head>
<body>
    <h1>成功!</h1>
</body>
</html>

<html xmlns:th=”http://www.thymeleaf.org”>

导入thymeleaf的名称空间，可以用于检查代码的正确性

显示效果

@Controller的理解

@Controller
/**
 * 1.在controller类中，@Controller配合视图解析器InternalResourceViewResolver，
 *   返回的内容就是return中的内容的html文件（即show.html），显示show.html页面
 * 2.@RestController注释Controller类，则方法无法返回jsp页面，
 *   将会直接将return中的内容展示成json格式
 */

thymeleaf的语法等之后详细介绍

先感受一下spring boot功能的强大，有了感觉再慢慢入门。

开发工具：

IDEA

构建项目

直接构造一个项目，将自己需要的功能直接加到spring boot的项目框架中，例如web，mysql等。这就是spring boot便捷处之一

1.可以使用spring官网 SPRING INITIALIZR来构造项目。

2.直接使用IDEA开发工具来构建项目。

使用spring官网SPRING INITIALIZR来构造项目

首先打开官网 https://spring.io/projects/spring-boot

其次,按照你的需要选择不同的依赖,进行创建

依赖:便是利用各功能jar包,将需要的功能引进自己的项目中.例如web jar包,便是使用了网页展示的功能.

然后,便将此压缩包下载到自己合适的文件夹中解压后,点击文件夹,便会看到如此模样

之后在IntelliJ IDBA中点击file->open,便可以使用了

直接使用IDEA开发工具来构建项目。

首先，打开 IntelliJ IDEA，点击Create New Project

其次，选择Spring Initializr，点击next。

接着，修改一下文件名，我们是以helloworld为例，其中的Language是我们使用的编程语言，Packaging是我们打包的形式。接着点击next。

然后，便是选择你想要的dependencies依赖了，我们在这里选择web依赖。我们所选中的 dependencies 会在Eelected Dependencies中显示出来。

接着选择你存放的位置，建议放在一个专门写spring boot的文件中，文件管理很重要。

呈现的效果：

了解部分spring boot结构功能

了解某些类和注解（@后的）的具体内容，可以按住ctrl，然后点击你想了解的类的内容。

生成的文件解释：

• HelloWorldApplication  该类是程序的入口类内有个main方法，可以直接通过run as运行项目
• application.properties  该配置文件是项目的核心配置文件，以xx.xx.xx的形式存在
• pom.xml  maven配置文件，因为我们采用的maven管理jar，所以这里会自动生成一个pom文件
• HelloWorldApplicationTest 测试入口

@SpringBootApplication注解

可以看到@SpringBootApplication内部的内容，里面也是使用的许多注释，现在咱们只需要简单的知道它是代码运行的入口。放着main函数之前，也只能使用一次。程序是通过它，找到主函数，开始运行的。

运行现有的框架,看看效果

Tomcat简介： 全世界最著名的基于Java语言的轻量级应用服务器，是一款完全开源免费的Servlet容器实现。同时，它支持HTML、JS等静态资源的处理，因此又可以作为轻量级Web服务器使用。

在浏览器的地址栏输入127.0.0.1:8080，或者localhost:8080。便会看到一个显示错误页面。这是我们还没有向他发出请求，所以显示错误页面，那接下来我们开始书写代码吧

开始编写第一个代码

在main.java.com.example下的helloworld文件下创建一个controller文件，文件内创建一个HelloWorldController的Java文件。 注意controller文件是与HelloWorldApplication文件在同一级。

如图编写代码

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping
public class HelloWorldController {
    @RequestMapping(value = "/hello",method = RequestMethod.GET)
    public String index(){
        return "HelloWorld!";
    }
}

运行代码

代码分析

@RestController

@RestController 的效果相当于@Controller + @ResponseBody
在返回json（JavaSpring Objection Notation）数据需要 @RestController

@RequestMapping

可以标注在类上，也可以直接标注在方法上。建议在类上也写上

这一章节结束了，下一章准备写Thymeleaf模板引擎的使用