一、Spring学习目标

1.1 为什么要学习Spring框架？

• Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>90%

• 专业角度：

  • 简化开发，降低企业级开发的复杂性
  • 框架整合，高效整合其他技术，提高企业级应用开发与运行效率
    

1.2 主要学什么？

• 简化开发：
  • IOC(反转控制)
  • AOP(面向切面编程)
    • 事务处理
• 框架整合:
  • MyBatis
  • Mybatis-Plus
  • Struts
  • Hibernate

1.3 怎么学？

• 学习Spring框架设计思想
• 学习基础操作，思考操作与思想间联系
• 学习案例，熟练应用操作的同时，体会思想

二、初识Spring

2.1Spring家族

• 官网：https://spring.io
• Spring发展到今天已经形成了一种开发生态圈，Spring提供了若干个项目，每个项目用于完成特定的功能。
  

2.2 Spring发展史

2.3 Spring体系结构

2.3.1 Spring Framework系统架构图

Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基

2.3.2 Spring Framework课程学习路线

2.4 Spring核心概念

2.4.1 目前我们代码存在的问题

• 代码书写现状
  • 耦合度偏高
• 解决方案
  • 使用对象时，程序不要主动使用对象，转换为由外部提供对象

2.4.2 核心概念

• IOC（Inversion of Control）控制反转
  使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。通俗的讲就是==“将new对象权利交给Spring，我们从Spring中获取对象使用即可”==
• Spring技术对IOC思想进行了实现
  • Spring提供了一个容器，称为IOC容器，用来充当IOC思想的外部
  • IOC容器负责对象的创建，初始化等一系列工作，被创建或管理的对象在IOC容器中统称为Bean
• DI（Dependency Injection）依赖注入
  • 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入
    
• 目标：充分解耦
  • 使用IOC容器管理bean（IOC）
  • 在IOC容器内将有依赖关系的bean进行关系绑定（DI）
• 最终效果
  • 使用对象是不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

三、IOC和DI入门案例

3.1 IOC入门案例

3.1.1 实现步骤

【第一步】导入Spring坐标
【第二步】定义Spring管理的类（接口）
【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象
【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取bean对象

3.1.2 实现代码

【第一步】导入Spring坐标

<dependencies><!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency>
</dependencies>

【第二步】定义Spring管理的类（接口）

• BookDao接口和BookDaoImpl实现类

public interface BookDao {public void save();
}public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ...");}
}

• BookService接口和BookServiceImpl实现类

public interface BookDao {public void save();
}public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ...");}
}

【第三步】创建Spring配置文件，配置对应类作为Spring管理的Bean对象

• 定义applicationContext.xml 配置文件并配置BookServiceImpl

<?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标签：表示配置beanid属性：表示给bean起名字class属性：表示给bean定义类型--><bean id="bookService" class="com.itheima.service.impl.BookServiceImpl"></bean></beans>

注意事项：bean定义时id属性在同一个上下文中(IOC容器中)不能重复

【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取Bean对象

public class App {public static void main(String[] args) {//1.创建IoC容器对象，加载spring核心配置文件ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");//2 从IOC容器中获取Bean对象(BookService对象)BookService bookService= (BookService)ctx.getBean("bookService");//3 调用Bean对象(BookService对象)的方法bookService.save();}
}

3.2 DI入门案例

3.2.1 实现步骤

【第一步】删除使用new的形式创建对象的代码
【第二步】提供依赖对象对应的setter方法
【第三步】配置service与dao之间的关系

3.2.2 实现代码

【第一步】删除使用new的形式创建对象的代码

public class BookServiceImpl implements BookService {private BookDao bookDao;  //【第一步】删除使用new的形式创建对象的代码public void save() {System.out.println("book service save ...");bookDao.save();}
}

【第二步】 提供依赖对象对应的setter方法

public class BookServiceImpl implements BookService {private BookDao bookDao;public void save() {System.out.println("book service save ...");bookDao.save();}//【第二步】提供依赖对象对应的setter方法public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}
}

【第三步】 配置service与 dao之间的关系

在applicationContext.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"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!--bean标签：表示配置beanid属性：表示给bean起名字class属性：表示给bean定义类型--><bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/><bean id="bookService" class="com.itheima.service.impl.BookServiceImpl"><!--配置server与dao的关系property标签：表示配置当前bean的属性name属性：表示配置哪一个具体的属性ref属性：表示参照哪一个bean--><property name="bookDao" ref="bookDao"/></bean>
</beans>

3.2.3 图解演示

四、Bean基础配置

4.1 Bean基础配置【重点】

【配置说明】

4.2 Bean别名设置

【配置说明】

【代码演示】

4.3 Bean 作用范围配置【重点】

【配置说明】

扩展：scope的取值不仅仅只有singleton和prototype，还有request、session、application、 websocket ，表示创建出的对象放置在web容器(tomcat)对应的位置。比如：request表示保存到request域中。

【代码演示】

五、Bean实例化

5.1 Bean是如何创建的

bean本质上就是对象，创建Bean使用构造方法完成

5.2 实例化Bean的三种方式

5.2.1 构造方法方式【重点】

• BookDaoImpl实现类

public class BookDaoImpl implements BookDao {public BookDaoImpl() {System.out.println("book dao constructor is running ....");}public void save() {System.out.println("book dao save ...");}
}

• applicationContext.xml

<!--方式一：构造方法实例化bean-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

5.2.2 静态共厂式

• OrderDao接口 和 OrderDaoImpl

public interface OrderDao {public void save();
}
public class OrderDaoImpl implements OrderDao {public void save() {System.out.println("order dao save ...");}
}

• OrderDaoFactory工厂类

//静态工厂创建对象
public class OrderDaoFactory {public static OrderDao getOrderDao(){System.out.println("factory setup....");return new OrderDaoImpl();}
}

• applicationContext.xml配置

<!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

5.2.3 实例工厂方式

• UserDao接口和UserDaoImpl实现类

public interface UserDao {public void save();
}
public class UserDaoImpl implements UserDao {public void save() {System.out.println("user dao save ...");}
}

• UserDaoFactory工厂类

//实例工厂创建对象
public class UserDaoFactory {public UserDao getUserDao(){return new UserDaoImpl();}
}

• applicationContext.xml配置

<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/><bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

六、Bean的生命周期

6.1 生命周期相关概念介绍

• 生命周期：从创建到消亡的完整过程
• bean生命周期：bean从创建到销毁的整体过程
• bean生命周期控制：在bean创建后到销毁前做一些事情

6.2 代码演示

6.2.1Bean生命周期控制

• 提供生命周期控制方法

public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ...");}//表示bean初始化对应的操作public void init(){System.out.println("init...");}//表示bean销毁前对应的操作public void destory(){System.out.println("destory...");}
}

• applicationContext.xml配置

<!--init-method：设置bean初始化生命周期回调函数,此处填写init方法名-->
<!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象，此处填写destory方法名-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>

6.2.2 Bean生命周期控制

• 实现InitializingBean, DisposableBean接口

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {private BookDao bookDao;public void setBookDao(BookDao bookDao) {System.out.println("set .....");this.bookDao = bookDao;}public void save() {System.out.println("book service save ...");bookDao.save();}public void destroy() throws Exception {System.out.println("service destroy");}public void afterPropertiesSet() throws Exception {System.out.println("service init");}
}

6.3 Bean销毁时机

• 容器关闭前触发bean的销毁
• 关闭容器方式：
  • 手工关闭容器
    ConfigurableApplicationContext接口close()操作
  • 注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机
    ConfigurableApplicationContext接口registerShutdownHook()操作

public class AppForLifeCycle {public static void main( String[] args ) {//此处需要使用实现类类型，接口类型没有close方法ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDao");bookDao.save();//注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器ctx.registerShutdownHook();//关闭容器//ctx.close();}
}

七、第三方资源配置管理

7.1 管理DataSource连接池对象

7.1.1 管理Druid连接池【重点】

【数据库准备】

create database if not exists spring_db character set utf8;
use spring_db;
create table if not exists tbl_account(id int primary key auto_increment,name varchar(20),money double
);
insert into tbl_account values(null,'Tom',1000);
insert into tbl_account values(null,'Jerry',1000);

【第一步】添加Druid连接池依赖

<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.16</version>
</dependency>
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version>
</dependency>

【第二步】配置DruidDataSource连接池Bean对象

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/spring_db"/><property name="username" value="root"/><property name="password" value="root"/>
</bean>

【第三步】在测试类中从IOC容器中获取连接池对象并打印

public class App {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");DataSource dataSource = (DataSource) ctx.getBean("dataSource");System.out.println(dataSource);}
}

7.1.2 管理c3p0连接池

【第一步】添加c3p0连接池依赖

<dependency><groupId>c3p0</groupId><artifactId>c3p0</artifactId><version>0.9.1.2</version>
</dependency>

【第二步】配置c3p0连接池Bean对象

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"><property name="driverClass" value="com.mysql.jdbc.Driver"/><property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_db"/><property name="user" value="root"/><property name="password" value="root"/><property name="maxPoolSize" value="1000"/>
</bean>

【第三步】在测试类中从IOC容器中获取连接池对象并打印

public class App {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");DataSource dataSource = (DataSource) ctx.getBean("dataSource");System.out.println(dataSource);}
}

7.2 加载properties属性文件

7.2.1 基本用法

【第一步】编写jdbc.properties属性文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root

【第二步】在applicationContext.xml中开启开启context命名空间，加载jdbc.properties属性文件

【第三步】在配置连接池Bean的地方使用EL表达式获取jdbc.properties属性文件中的值

<bean class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driver}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/>
</bean>

八、Spring容器

8.1 Spring容器介绍

8.1.1 创建容器

• 方式一：类路径加载配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

• 方式二：文件路径加载配置文件

ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\applicationContext.xml");

• 加载多个配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("bean1.xml", "bean2.xml");

8.1.2 获取bean对象

• 方式一：使用bean名称获取

弊端：需要自己强制类型转换

BookDao bookDao = (BookDao) ctx.getBean("bookDao");

• 方式二：使用bean名称获取并指定类型

弊端：推荐使用

BookDao bookDao = ctx.getBean("bookDao", BookDao.class);

• 方式三：使用bean类型获取

弊端：如果IOC容器中同类型的Bean对象有多个，此处获取会报错

BookDao bookDao = ctx.getBean(BookDao.class);

8.1.3容器类层次结构

8.1.4 BeanFactory

• 类路径加载配置文件

Resource resources = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(resources);
BookDao bookDao = bf.getBean("bookDao", BookDao.class);
bookDao.save();

• BeanFactory创建完毕后，所有的Bean均为延迟加载，也就是说我们调用getBean()方法获取Bean对象时才创建Bean对象并返回给我们

8.2 Spring 核心容器总结

8.2.1 容器相关

• BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载
• ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载
• ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能
• ApplicationContext接口常用初始化类
  • ClassPathXmlApplicationContext(常用)
  • FileSystemXmlApplicationContext

8.2.2 bean相关

8.2.3 依赖注入相关

九、Spring注解开发

9.1 注解开发定义Bean对象【重点】

目的：xml配置Bean对象有些繁琐，使用注解简化Bean对象的定义

9. 1.1 基本使用

【第一步】在applicationContext.xml中开启Spring注解包扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:context="http://www.springframework.org/schema/context"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.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"><!--扫描com.itheima包及其子包下的类中注解--><context:component-scan base-package="com.itheima"/>
</beans>

【第二步】在类上使用@Component注解定义Bean。

//@Component定义bean
@Component("bookDao")
public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ...");}
}
@Component
public class BookServiceImpl implements BookService {private BookDao bookDao;public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}public void save() {System.out.println("book service save ...");bookDao.save();}
}

补充说明：如果@Component注解没有使用参数指定Bean的名称，那么类名首字母小写就是Bean在IOC容器中的默认名称。例如：BookServiceImpl对象在IOC容器中的名称是bookServiceImpl。

【第三步】在测试类中获取Bean对象

public class AppForAnnotation {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDao");System.out.println(bookDao);//按类型获取beanBookService bookService = ctx.getBean(BookService.class);System.out.println(bookService);}
}

注意：在测试类中不要调用bookService的save方法，因为还没有给BookServiceImpl中的bookDao赋值，调用bookService的save方法会出现空指针异常。

9.1.2 @Component三个衍生注解

说明：加粗的注解为常用注解

• Spring提供**@Component**注解的三个衍生注解
  • @Controller：用于表现层bean定义
  • @Service：用于业务层bean定义
  • @Repository：用于数据层bean定义

@Repository("bookDao")
public class BookDaoImpl implements BookDao {}@Service
public class BookServiceImpl implements BookService {}

9.2 纯注解开发模式

9.2.1 纯注解开发模式介绍

• Spring3.0开启了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道

• Java类代替Spring核心配置文件
  

• @Configuration注解用于设定当前类为配置类

• @ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式

@ComponentScan({com.itheima.service","com.itheima.dao"})

• 读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象

//加载配置文件初始化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//加载配置类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

9.2.2 代码演示

【第一步】定义配置类代替配置文件

//声明当前类为Spring配置类
@Configuration
//Spring注解扫描，相当于<context:component-scan base-package="com.itheima"/>
@ComponentScan("com.itheima")
//设置bean扫描路径，多个路径书写为字符串数组格式
//@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class SpringConfig {}

【第二步】在测试类中加载配置类，获取Bean对象并使用

public class AppForAnnotation {public static void main(String[] args) {//AnnotationConfigApplicationContext加载Spring配置类初始化Spring容器ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = (BookDao) ctx.getBean("bookDao");System.out.println(bookDao);//按类型获取beanBookService bookService = ctx.getBean(BookService.class);System.out.println(bookService);}
}

9.3 注解开发Bean作用范围和生命周期管理

9.3.1 bean作用范围注解配置

• 使用@Scope定义bean作用范围

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {}

9.3.2 bean生命周期注解配置

• 使用@PostConstruct、@PreDestroy定义bean生命周期

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {public BookDaoImpl() {System.out.println("book dao constructor ...");}@PostConstructpublic void init(){System.out.println("book init ...");}@PreDestroypublic void destroy(){System.out.println("book destory ...");}
}

注意：@PostConstruct和@PreDestroy注解是jdk中提供的注解，从jdk9开始，jdk中的javax.annotation包被移除了，也就是说这两个注解就用不了了，可以额外导入一下依赖解决这个问题。

<dependency><groupId>javax.annotation</groupId><artifactId>javax.annotation-api</artifactId><version>1.3.2</version>
</dependency>

9.4注解开发依赖注入

9.4.1 使用@Autowired注解开启自动装配模式（按类型）

@Service
public class BookServiceImpl implements BookService {//@Autowired：注入引用类型，自动装配模式，默认按类型装配@Autowiredprivate BookDao bookDao;public void save() {System.out.println("book service save ...");bookDao.save();}
}

说明：不管是使用配置文件还是配置类，都必须进行对应的Spring注解包扫描才可以使用。@Autowired默认按照类型自动装配，如果IOC容器中同类的Bean有多个，那么默认按照变量名和Bean的名称匹配，建议使用@Qualifier注解指定要装配的bean名称

注意：自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据，因此无需提供setter方法。

9.4.2 使用@Qualifier注解指定要装配的bean名称

目的：解决IOC容器中同类型Bean有多个装配哪一个的问题

@Service
public class BookServiceImpl implements BookService {//@Autowired：注入引用类型，自动装配模式，默认按类型装配@Autowired//@Qualifier：自动装配bean时按bean名称装配@Qualifier("bookDao")private BookDao bookDao;public void save() {System.out.println("book service save ...");bookDao.save();}
}

注意：@Qualifier注解无法单独使用，必须配合@Autowired注解使用

9.4.3 使用@Value实现简单类型注入

@Repository("bookDao")
public class BookDaoImpl implements BookDao {//@Value：注入简单类型（无需提供set方法）@Value("${name}")private String name;public void save() {System.out.println("book dao save ..." + name);}
}

以上@Value注解中使用${name}从属性文件中读取name值，那么就需要在配置类或者配置文件中加载属性文件。

@Configuration
@ComponentScan("com.itheima")
//@PropertySource加载properties配置文件
@PropertySource({"classpath:jdbc.properties"}) //{}可以省略不写
public class SpringConfig {}

注意：@PropertySource()中加载多文件请使用数组格式配置，不允许使用通配符*

9.5 注解开发管理第三方Bean

【第一步】单独定义配置类

public class JdbcConfig {//@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/spring_db");ds.setUsername("root");ds.setPassword("root");return ds;}
}

【第二步】将独立的配置类加入核心配置

方式1：@Import注解导入式

@Configuration
@ComponentScan("com.itheima")
//@Import:导入配置信息
@Import({JdbcConfig.class})
public class SpringConfig {}

方式2：@ComponentScan扫描式

@Configuration
@ComponentScan({"com.itheima.config","com.itheima.service","com.itheima.dao"})  //只要com.itheima.config包扫到了就行，三个包可以合并写成com.itheima
public class SpringConfig {}

9.6 注解开发为第三方Bean注入资源

9.6.1 简单类型依赖注入

public class JdbcConfig {//1.定义一个方法获得要管理的对象@Value("com.mysql.jdbc.Driver")private String driver;@Value("jdbc:mysql://localhost:3306/spring_db")private String url;@Value("root")private String userName;@Value("root")private String password;//2.@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;}
}

说明：如果@Value()中使用了EL表达式读取properties属性文件中的内容，那么就需要加载properties属性文件。

9.6.2 引用类型依赖注入

//Spring会自动从IOC容器中找到BookDao对象赋值给参数bookDao变量，如果没有就会报错。
@Bean
public DataSource dataSource(BookDao bookDao){System.out.println(bookDao);DruidDataSource ds = new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;
}

说明：引用类型注入只需要为bean定义方法设置形参即可，容器会根据类型自动装配对象

十、AOP

10.1 AOP简介

10.1.1 AOP简介和作用

• AOP（Aspect Oriented Programming）面向切面编程，一种编程范式，指导开发者如何组织程序结构
  • OOP（Object Oriented Programming）面向对象编程
• 作用：在不惊动原始设计的基础上为其进行功能增强，简单来说就是在不改变方法源码的基础上对对方进行功能增强。
• Spring理念：无入侵式 /无入侵式

10.1.2 AOP中的核心概念

• 连接点（JoinPoint）：正在执行的方法，例如：update()、delete()、select()等都是连接点。
• 切入点（Pointcut）：进行功能增强了的方法，例如:update()、delete()方法，select()方法没有被增强所以不是切入点，但是是连接点。
  • 在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
    • 一个具体方法：com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
    • 匹配多个方法：所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
• 通知（Advice）：在切入点前后执行的操作，也就是增强的共性功能
  • 在SpringAOP中，功能最终以方法的形式呈现
• 通知类：通知方法所在的类叫做通知类
• 切面（Aspect）：描述通知与切入点的对应关系，也就是哪些通知方法对应哪些切入点方法。

10.2 AOP入门案例

10.2.1 AOP入门案例思路分析

• 案例设定：测定接口执行效率
• 简化设定：在接口执行前输出当前系统时间
• 开发模式：XML or 注解
• 思路分析：
  1. 导入坐标（pom.xml）
  2. 制作连接点方法（原始操作，dao接口与实现类）
  3. 制作共性功能（通知类与通知）
  4. 定义切入点
  5. 绑定切入点与通知关系（切面）

10.2.2 AOP入门案例实现

【第一步】导入aop相关坐标

<dependencies><!--spring核心依赖，会将spring-aop传递进来--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency><!--切入点表达式依赖，目的是找到切入点方法，也就是找到要增强的方法--><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version></dependency>
</dependencies>

【第二步】定义dao接口与实现类

public interface BookDao {public void save();public void update();
}@Repository
public class BookDaoImpl implements BookDao {public void save() {System.out.println(System.currentTimeMillis());System.out.println("book dao save ...");}public void update(){System.out.println("book dao update ...");}
}

【第三步】定义通知类，制作通知方法

//通知类必须配置成Spring管理的bean
@Component
public class MyAdvice {public void method(){System.out.println(System.currentTimeMillis());}
}

【第四步】定义切入点表达式、配置切面(绑定切入点与通知关系)

//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {//设置切入点，@Pointcut注解要求配置在方法上方@Pointcut("execution(void com.itheima.dao.BookDao.update())")private void pt(){}//设置在切入点pt()的前面运行当前操作(前置通知)@Before("pt()")public void method(){System.out.println(System.currentTimeMillis());}
}

【第五步】在配置类中进行Spring注解包扫描和开启AOP功能

@Configuration
@ComponentScan("com.itheima")
//开启注解开发AOP功能
@EnableAspectJAutoProxy
public class SpringConfig {}

10.3 AOP工作流程【理解】

10. 3.1 AOP工作流程

1. Spring容器启动
2. 读取所有切面配置中的切入点
3. 初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
   • 匹配失败，创建原始对象
   • 匹配成功，创建原始对象（目标对象）的代理对象
4. 获取bean执行方法
   • 获取的bean是原始对象时，调用方法并执行，完成操作
   • 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

10.3.2 AOP核心概念

目标对象（Target）：被代理的对象，也叫原始对象，该对象中的方法没有任何功能增强。
代理对象（Proxy）：代理后生成的对象，由Spring帮我们创建代理对象。

10.3.3 在测试类中验证代理对象

public class App {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);bookDao.update();//打印对象的类名System.out.println(bookDao.getClass());}
}

10.4 AOP切入点表达式

10.4.1 语法格式

• 切入点：要进行增强的方法

• 切入点表达式：要进行增强的方法的描述方式

  • 描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法

  execution(void com.itheima.dao.BookDao.update())
  

  • 描述方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法

  execution(void com.itheima.dao.impl.BookDaoImpl.update())
  

• 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）

  execution(public User com.itheima.service.UserService.findById(int))
  

  • 动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点
  • 访问修饰符：public，private等，可以省略
  • 返回值：写返回值类型
  • 包名：多级包使用点连接
  • 类/接口名：
  • 方法名：
  • 参数：直接写参数的类型，多个类型用逗号隔开
  • 异常名：方法定义中抛出指定异常，可以省略

10.4.2 通配符

目的：可以使用通配符描述切入点，快速描述。

• ：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

execution（public * com.itheima.*.UserService.find*(*))

• … ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

execution（public User com..UserService.findById(..))

• +：专用于匹配子类类型

execution(* *..*Service+.*(..))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cTYLwsa4-1658313225093)(assets/image-20210730153824117.png)]

10.4.3 书写技巧

• 所有代码按照标准规范开发，否则以下技巧全部失效
• 描述切入点通**常描述接口**，而不描述实现类
• 访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
• 返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述
• 包名书写尽量不使用…匹配，效率过低，常用*做单个包描述匹配，或精准匹配
• 接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名
• 方法名书写以动词进行精准匹配，名词采用匹配，例如getById书写成getBy,selectAll书写成selectAll
• 参数规则较为复杂，根据业务方法灵活调整
• 通常**不使用异常作为匹配**规则

10.5 AOP通知类型【重点】

10.5.1 AOP通知分类

• AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置
• AOP通知共分为5种类型
  • 前置通知：在切入点方法执行之前执行
  • 后置通知：在切入点方法执行之后执行，无论切入点方法内部是否出现异常，后置通知都会执行。
  • **环绕通知(重点)：**手动调用切入点方法并对其进行增强的通知方式。
  • 返回后通知(了解)：在切入点方法执行之后执行，如果切入点方法内部出现异常将不会执行。
  • 抛出异常后通知(了解)：在切入点方法执行之后执行，只有当切入点方法内部出现异常之后才执行。

10.5.2 AOP通知详解

【前置通知】

• 名称：@Before
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行
• 范例：

@Before("pt()")
public void before() {System.out.println("before advice ...");
}

【后置通知】

• 名称：@After
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行
• 范例：

@After("pt()")
public void after() {System.out.println("after advice ...");
}

【返回后通知】

• 名称：@AfterReturning（了解）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行
• 范例：

@AfterReturning("pt()")
public void afterReturning() {System.out.println("afterReturning advice ...");
}

【抛出异常后通知】

• 名称：@AfterThrowing（了解）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行
• 范例：

@AfterThrowing("pt()")
public void afterThrowing() {System.out.println("afterThrowing advice ...");
}

【环绕通知】

• 名称：@Around（重点，常用）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行
• 范例：：

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {System.out.println("around before advice ...");Object ret = pjp.proceed();System.out.println("around after advice ...");return ret;
}

环绕通知注意事项

1. 环绕通知方法形参必须是ProceedingJoinPoint，表示正在执行的连接点，使用该对象的proceed()方法表示对原始对象方法进行调用，返回值为原始对象方法的返回值。
2. 环绕通知方法的返回值建议写成Object类型，用于将原始对象方法的返回值进行返回，哪里使用代理对象就返回到哪里。

十一 Spring事务管理

11.1 Spring事务简介

11.1.1Spring事务作用

• 事务作用：在数据层保障一系列的数据库操作同成功失败
• Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败
  

11.2 Spring事务角色

11.2.1 Spring事务角色

• 事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
• 事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法
  

11.3 Spring事务相关配置

11.3.1 事务配置

说明：对于RuntimeException类型异常或者Error错误，Spring事务能够进行回滚操作。但是对于编译器异常，Spring事务是不进行回滚的，所以需要使用rollbackFor来设置要回滚的异常。

11.3.2 案例：转账业务追加日志

需求和分析

• 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕
• 需求微缩：A账户减钱，B账户加钱，数据库记录日志
• 分析：
  ①：基于转账操作案例添加日志模块，实现数据库中记录日志
  ②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能
• 实现效果预期：
  无论转账操作是否成功，均进行转账操作的日志留痕
• 存在的问题：
  日志的记录与转账操作隶属同一个事务，同成功同失败
• 实现效果预期改进：
  无论转账操作是否成功，日志必须保留
• 事务传播行为：事务协调员对事务管理员所携带事务的处理态度

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5kBeQmhw-1658314398223)(assets/image-20210802153216460.png)]

【准备工作】环境整备

USE spring_db;
CREATE TABLE tbl_log(id INT PRIMARY KEY AUTO_INCREMENT,info VARCHAR(255),createDate DATE
);

public interface LogService {//propagation设置事务属性：传播行为设置为当前操作需要新事务@Transactionalvoid log(String out, String in, Double money);
}@Service
public class LogServiceImpl implements LogService {@Autowiredprivate LogDao logDao;public void log(String out,String in,Double money ) {logDao.log("转账操作由"+out+"到"+in+",金额："+money);}
}public interface LogDao {@Insert("insert into tbl_log (info,createDate) values(#{info},now())")void log(String info);
}

【第一步】在AccountServiceImpl中调用logService中添加日志的方法

@Service
public class AccountServiceImpl implements AccountService {@Autowiredprivate AccountDao accountDao;@Autowiredprivate LogService logService;public void transfer(String out,String in ,Double money) {try{accountDao.outMoney(out,money);int i = 1/0;accountDao.inMoney(in,money);}finally {logService.log(out,in,money);}}
}

【第二步】在LogService的log()方法上设置事务的传播行为

public interface LogService {//propagation设置事务属性：传播行为设置为当前操作需要新事务@Transactional(propagation = Propagation.REQUIRES_NEW)void log(String out, String in, Double money);
}

【第三步】运行测试类，查看结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {@Autowiredprivate AccountService accountService;@Testpublic void testTransfer() throws IOException {accountService.transfer("Tom","Jerry",50D);}
}

11.3.3 事务传播行为

Spring框架【超详细学习笔记】相关推荐

1. 【台大郭彦甫】Matlab入门教程超详细学习笔记二：基本操作与矩阵运算（附PPT链接）

   Matlab入门教程超详细学习笔记二:基本操作与矩阵运算 前言 一.基本操作 1.把matlab当作计算器使用 2.变量 3.控制格式输出 二.矩阵运算 1.矩阵 2.矩阵索引 3.使用:创建向量 4 ...

2. Java数据库部分（MySQL+JDBC）（一、MySQL超详细学习笔记）

   所有示例使用的数据表均为Oracle提供的SQL基础数据表(t_employees.sql dept.sql emp.sql salgrade.sql) 熟练掌握多多练习即可达到完成后端开发所需具备的 ...

3. 陈宝林《最优化理论与算法》超详细学习笔记 （八）————最优性条件

   陈宝林<最优化理论与算法>超详细学习笔记 (八)----最优性条件 无约束问题的极值条件 必要条件 二阶充分条件 充要条件 约束极值问题的最优性条件 不等式约束的一阶最优性条件 无约束问题 ...

4. 陈宝林《最优化理论与算法》超详细学习笔记 （七）————第五章 运输问题

   陈宝林<最优化理论与算法>超详细学习笔记 (七)----第五章 运输问题 第1节 运输问题的数学模型 第2节 表上作业法 2.1 确定初始基可行解 2.2 最优解的判别 2.3 改进的方法 ...

5. 陈宝林《最优化理论与算法》超详细学习笔记 （四）————第四章 对偶理论

   陈宝林<最优化理论与算法>超详细学习笔记 (四)----第四章 对偶理论 1. 对偶问题的提出 2. 线性规划的对偶理论 2.1 原问题与对偶问题的关系 2.2 对偶问题的基本性质 3. ...

6. 陈宝林《最优化理论与算法》超详细学习笔记 （一）————第十章 使用导数的最优化方法（最速下降法、牛顿法、阻尼牛顿法）

   陈宝林<最优化理论与算法>超详细学习笔记 (一)----第十章 使用导数的最优化方法(最速下降法.牛顿法.阻尼牛顿法) 写在前面 第十章 使用导数的最优化方法 最速下降法 牛顿法 阻尼牛顿 ...

7. 陈宝林《最优化理论与算法》超详细学习笔记 （五）————最优性条件 之 KKT条件

   陈宝林<最优化理论与算法>超详细学习笔记 (五)----最优性条件 之 KKT条件 Lagrange对偶问题 原问题 Lagrange函数 Lagrange对偶函数 强/弱对偶性 弱对偶性 ...

8. 陈宝林《最优化理论与算法》超详细学习笔记 （二）————补充知识（凸集） 第二章 线性规划的基本性质

   陈宝林<最优化理论与算法>超详细学习笔记 (二)----补充知识 凸集 & 第二章 线性规划的基本性质 补充知识 凸集 方向与极方向 表示定理 择一定理 第一章 线性规划的基本性质 ...

9. 陈宝林《最优化理论与算法》超详细学习笔记 （三）————单纯形法

   陈宝林<最优化理论与算法>详细学习笔记 (三)----单纯形法 数学模型 最优性检验与解的判别 最优解的判别定理 无穷多最优解判别定理 无界解判别定理 其他情形 第三章 单纯形法 单纯形表 ...

最新文章

1. 查看磁盤使用情况linux,在Linux系统下安装Filelight来查看磁盘使用情况
2. hdu 1872(稳定排序)
3. Shell 变量的作用域
4. trouble identification check tree
5. 使用PYTORCH复现ALEXNET实现MNIST手写数字识别
6. C++之virtual 方法
7. android java tga转png_java 里.tga图片怎么用啊，是不是要导入一个包，真的找不到资源，希望来位大神帮帮我 小弟在此拜谢！...
8. 利用正则表达式 替换字符串中多个 URL
9. 从苏宁电器到卡巴斯基（后传）第04篇：还愿吾爱破解视频教程大赛
10. 原来长期佩戴耳机危害那么大!现在你知道还不算太晚
11. 骨传导耳机靠谱吗？骨传导耳机是不是智商税？
12. UE4搭建场景与特效文档—地形、水体、植被、雨雾效果
13. Python登录豆瓣并爬取影评
14. 微软提供的无限次延长Vista激活
15. linux登录界面鼠标键盘失灵,在archlinux安装界面这卡住了，鼠标键盘失灵
16. CTO，技术总监和技术经理有啥区别？
17. BarTender打开提示：错误消息#2622
18. Python语言程序设计 - 北京理工大学 网课所有资料（源码，pdf，ppt课件，视频等）
19. 祝大家新年快乐，鼠年平安健康、阖家幸福如意！
20. 距离空间,线性空间,赋范线性空间,Banach空间,内积空间,Hilbert空间的内在关系

热门文章

1. uniapp 小程序车牌号输入键盘
2. 根据学生分数给学生成绩分等级
3. CCF 201903-3 损坏的RAID5（Python100分）
4. 【UTAU插件】辅音速度重载
5. 使用wacom数位板配套的笔无法利用按键实现滚动的问题
6. 3D建模软件FreeCAD
7. PHP之道 - php各方面的知识汇总
8. zzulioj -- 1261 : 小媛在努力
9. 惠普计算机进入安全模式,惠普电脑怎么进安全模式，分享详细的操作教程起来瞧瞧...
10. 全球首个AI模型开发管理标准正式发布，九章云极DataCanvas公司助力AI工程化新发展