四(1)spring框架

最新推荐文章于 2024-10-05 11:27:00 发布

sweetcuter

最新推荐文章于 2024-10-05 11:27:00 发布

阅读量61

点赞数

分类专栏：阶段四-常用框架文章标签： spring java mybatis

本文链接：https://blog.csdn.net/sweetcuter/article/details/127033688

版权

阶段四-常用框架专栏收录该内容

5 篇文章 0 订阅

订阅专栏

阶段四热门框架

第一章 spring框架

学习目标

能够说出Spring的体系结构
能够编写IOC入门案例
能够编写DI入门案例
能够配置setter方式注入属性值
能够配置构造方式注入属性值
能够理解什么是自动装配

一. Spring简介

1.1 Spring课程介绍

1. 为什么要学

Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>90%
专业角度
- 简化开发，降低企业级开发的复杂性
- 框架整合，高效整合其他技术，提高企业级应用开发与运行效率

2. 学什么

简化开发
- IOC(反转控制)
- AOP(面向切面编程)
  - 事务处理
框架整合
- MyBatis
- MyBatis-plus
- Struts
- Struts2
- Hibernate
- ……

3. 怎么学

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

1.2 初识Spring

1. Spring家族

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

2. Spring发展史

1.3 Spring体系结构

通过系统架构图，Spring能不能进行数据层开发？Spring能不能进行web层开发？

1. Spring Framework系统架构图

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

2. Spring Framework课程学习路线

1.4 Spring核心概念

问题导入

问题1：目前我们的代码存在什么问题以及怎么解决这些问题？

问题2：请描述什么是IOC，什么是DI？

1. 目前我们代码存在的问题

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

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已经绑定了所有的依赖关系

1.5 IOC和DI入门案例

1. IOC入门案例

问题导入

<bean>标签中id属性和class属性的作用是什么？

入门案例思路分析

管理什么？(Service与Dao)
如何将被管理的对象告知IOC容器？(配置文件)
被管理的对象交给IOC容器，如何获取到IoC容器？(接口)
IOC容器得到后，如何从容器中获取bean？(接口方法)
使用Spring导入哪些坐标？(pom.xml)

实现步骤

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

实现代码

【第一步】导入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 BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.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标签：表示配置bean
    	id属性：表示给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");
        //或BookService bookService= ctx.getBean("bookService",BookService.class);
        
        //3 调用Bean对象(BookService对象)的方法
        bookService.save();
    }
}

运行结果

2. DI入门案例

问题导入

<property>标签中name属性和ref属性的作用是什么？

DI入门案例思路分析

基于IOC管理bean
Service中使用new形式创建的Dao对象是否保留？(否)
Service中需要的Dao对象如何进入到Service中？(提供方法)
Service与Dao间的关系如何描述？(配置)

实现步骤

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

实现代码

【第一步】删除使用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标签：表示配置bean
    	id属性：表示给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>

图解演示

二. Bean实例化

2.1 Bean的基础配置

问题导入

问题1：在<bean>标签上如何配置别名？

问题2：Bean的默认作用范围是什么？如何修改？

1. Bean基础配置

2. Bean别名配置

配置说明

代码演示

打印结果

3. Bean作用范围配置

配置说明

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

代码演示

打印结果

最后给大家说明一下：在我们的实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性。

注:

为什么bean默认为单例？

适合交给容器进行管理的bean

表现层对象
业务层对象
数据层对象
工具对象

不适合交给容器进行管理的bean

封装实体的域对象

2.2 Bean的实例化

问题导入

Bean的实例化方式有几种？

Bean是如何创建的

bean本质上就是对象，创建bean使用构造方法完成, 内部用反射的方式

实例化Bean的三种方式
- 构造方法
- 静态工厂
- 实例工厂
  - FactoryBean

1. bean实例化——构造方法

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

AppForInstanceBook测试类

public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

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

        bookDao.save();
    }
}

运行结果

注意：Spring创建Bean的时候用的是无参的构造方法, 无参构造方法如果不存在，将抛出异常BeanCreationException

2. bean实例化——静态工厂

OrderDao接口和OrderDaoImpl实现类

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

OrderDaoFatory工厂类

//静态工厂创建对象
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"/>

注: 为什么不直接用第一种方式实例化Bean?

工厂类可能做了其他的配置

这种方式造对象一般为了兼容早期遗留系统

AppForInstanceOrder测试类

public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();
    }
}

运行结果

3. bean实例化-实例工厂

实例工厂里创建对象的方法不是静态的, 需要用到工厂对象的实例去创建对象, 这也是早期系统用的比较多的

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

AppForInstanceUser测试类

public class AppForInstanceUser {
    public static void main(String[] args) {
        //        //创建实例工厂对象
        //        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //        //通过实例工厂对象创建对象
        //        UserDao userDao = userDaoFactory.getUserDao();
        //        userDao.save();
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}

运行结果

4. 实现FactoryBean<T>方式

这种方式就是实例工厂方式的延申, 目的为了简化配置文件

定义UserDaoFactoryBean实现FactoryBean<T>接口

UserDaoFactoryBean中实例化什么类型的对象泛型就是该类型。

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }
    
    //用来设置是否造出的对象是单例的, false: 非单例
    /*public boolean isSingleton(){
        return false;
    }*/
}

applicationContext.xml配置

造出来的对象不是UserDaoFactoryBean对象 , 而是里面方法getObject造出的对象

<!--方式四：使用FactoryBean实例化bean-->
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>

使用之前的AppForInstanceUser测试类去运行看结果就行了。注意配置文件中id="userDao"是否重复。

2.3 Bean的生命周期

问题导入

问题1：多例的Bean能够配置并执行销毁的方法？

问题2：如何做才执行Bean销毁的方法？

生命周期相关概念介绍

生命周期：从创建到消亡的完整过程

bean生命周期：bean从创建到销毁的整体过程

bean生命周期控制：在bean创建后到销毁前做一些事情

1. Bean生命周期控制

提供生命周期控制方法

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

测试类

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.close();
    }
}

2. 实现接口方式控制

实现InitializingBean, DisposableBean接口

这样就不用在配置文件中写init-method和destroy-method了

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");
    }
}

测试类代码同上

配置文件同上

运行结果

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();
    }
}

三. DI: 依赖注入

依赖注入有几种方式？

setter注入
- 简单类型
- 引用类型(很常用)
构造器注入
- 简单类型
- 引用类型

3.1 setter方式注入

问题导入

setter方式注入使用什么子标签？

引用类型

简单类型

3.2 构造方式注入

问题导入

构造方式注入使用什么子标签？

引用类型

简单类型

注: 构造器方式注入又遇到一个问题, 即配置中的name要和构造方法中的参数严格保持一致, 增加了耦合.

参数适配

第一种解决了与形参名耦合的问题

第二种解决了参数类型重复的顺序的问题

3.3 依赖注入方式选择

强制依赖使用构造器进行，因为构造器注入是必写的 , 使用setter注入有概率不进行注入导致null对象出现
可选依赖使用setter注入进行，灵活性强
Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
自己开发的模块推荐使用setter注入

3.4 依赖自动装配

问题导入

如何配置按照类型自动装配？

1. 自动装配概念

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配
自动装配方式
按类型（常用）
按名称
按构造方法
不启用自动装配

2. 自动装配类型

依赖自动装配

配置中使用bean标签autowire属性设置自动装配的类型

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>

依赖自动装配特征

按类型注入需要用到对应Bean类种的setter方法 , 而且可以不指定其引用类型属性Bean的name
自动装配用于引用类型依赖注入，不能对简单类型进行操作
使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

3.5 集合注入

集合中注入引用类型

1. 注入数组类型数据

<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
        <ref bean = "beanId"/>
    </array>
</property>

2. 注入List类型数据

<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>

3. 注入Set类型数据

<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>

4. 注入Map类型数据

<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>

5. 注入Properties类型数据

<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签

3.6 第三方资源配置管理

今日目标

能够掌握注解开发定义Bean对象
能够掌握纯注解开发模式
能够配置注解开发依赖注入
能够配置注解开发管理第三方Bean
能够配置注解开发为第三方Bean注入资源
能够使用Spring整合Mybatis
能够使用Spring整合Junit

说明：以管理DataSource连接池对象为例讲解第三方资源配置管理

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>

注意：除了添加以上两个依赖之外，别忘了添加spring-context依赖。

【第二步】配置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);
    }
}

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>

注意：同一个Spring容器中不能有两个id="dataSource"的连接池。

【第三步】在测试类中从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);
    }
}

3.7 加载properties属性文件

目的：将数据库的连接参数抽取到一个单独的文件中，与Spring配置文件解耦。

问题导入

问题1：如何解决使用EL表达式读取属性文件中的值结果读取到了系统属性问题？

问题2：加载properties文件写法标准写法该怎么写？

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属性文件

小技巧：如果同学们觉得上述复制粘贴方式不好改或者容易改错，其实idea是有提示功能的，注意不要选错就行了。有些版本的idea没有这个提示，那么就按照上面复制粘贴的方式改，改完之后可以做成live template模板，后期直接用。

<context:property-placeholder location="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>

配置完成之后，运行之前的获取Druid连接池代码，可以获取到连接池对象就表示配置成功。\

2.设置配置不加载系统属性

问题

如果属性文件中配置的不是jdbc.username，而是username=root666，那么使用${username}获取到的不是root666，而是计算机的名称。

原因

系统属性的优先级比我们属性文件中的高，替换了我们的username=root666。

解决

解决1：换一个名称，例如不叫username，叫jdbc.username。

解决2：使用system-properties-mode="NEVER"属性表示不使用系统属性。

<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>

3. 加载properties文件写法

不加载系统属性

<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>

加载多个properties文件

<context:property-placeholder location="jdbc.properties,msg.properties"/>

加载所有properties文件

<context:property-placeholder location="*.properties"/>

加载properties文件**标准格式**

<context:property-placeholder location="classpath:*.properties"/>

加载properties文件标准格式(代表不仅可以从当前工程读, 还可以从所依赖的jar包中读)

<context:property-placeholder location="classpath*:*.properties"/>

四. Spring容器

4.1 Spring核心容器介绍

问题导入

问题：按照Bean名称获取Bean有什么弊端，按照Bean类型获取Bean有什么弊端？

1. 创建容器

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

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

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

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

加载多个配置文件

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

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);

3. 容器类层次结构

4. BeanFactory

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对象并返回给我们
而ApplicationContext是立即加载Bean, 即启动容器Bean就会直接初始化
- ApplicationContext如何设置延迟加载
```
<bean id="bookDao" class="" lazy-init="true"/>
```

五. 总结

5.1 bean相关

5.2 依赖注入相关

5.3 容器相关

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

六. Spring注解开发

6.1 注解开发定义Bean对象

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

问题导入

问题1：使用什么标签进行Spring注解包扫描？

问题2：@Component注解和@Controller、@Service、@Repository三个衍生注解有什么区别？

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.xsd
        http://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);
        //按类型获取bean
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

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

运行结果

2. @Component三个衍生注解

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

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

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

@Service
public class BookServiceImpl implements BookService {
}

6.2 纯注解开发模式

问题导入

问题1：配置类上使用什么注解表示该类是一个配置类？

问题2：配置类上使用什么注解进行Spring注解包扫描？

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);

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);
        //按类型获取bean
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

6.3 注解开发Bean作用范围和生命周期

问题导入

在类上使用什么注解定义Bean的作用范围？

1. bean作用范围注解配置

使用@Scope定义bean作用范围

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

2. bean生命周期注解配置

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

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor ...");
    }
    @PostConstruct
    public void init(){
        System.out.println("book init ...");
    }
    @PreDestroy
    public 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>

6.4 注解开发依赖注入

问题导入

问题1：请描述@Autowired注解是如何进行自动装配的？

问题2：请描述@Qualifier注解的作用

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

@Service
public class BookServiceImpl implements BookService {
    //@Autowired：注入引用类型，自动装配模式，默认按类型装配
    @Autowired
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

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

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

注意：自动装配建议使用无参构造方法创建对象（默认），如果不提供对应构造方法，请提供唯一的构造方法

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注解使用

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"}) //{}可以省略不写, classpath也可以省略
public class SpringConfig {
}

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

6.5 注解开发管理第三方Bean

问题导入

导入自己定义的配置类有几种方式？

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

public class JdbcConfig {
    //@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @Bean
    public 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注解导入式

@Import, 只允许写一次, 如果有多个, 以数组的形式写

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

方式2：@ComponentScan扫描式

不推荐 : 因为要写的东西隐藏性太强, 容易不清楚用过哪些

@Configuration
public class JdbcConfig {

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

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

问题导入

配置类中如何注入简单类型数据，如何注入引用类型数据？

第三方bean管理
- @Bean
第三方bean依赖注入
- 引用类型：方法形参
- 简单类型：成员变量

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容器中
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

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

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定义方法设置形参即可，容器会根据类型自动装配对象

3. 配置文件属性注入

@Component
@Data
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {
    private String dateformat;
}

springboot :

@ConfigurationProperties : 约定大于配置, 只要前缀名和变量名和配置文件一直, 就能完成属性的自动注入

6.7 注解开发总结

七. Spring整合其他技术

7.1 Spring整合mybatis

1. 思路分析

问题导入

mybatis进行数据层操作的核心对象是谁？

MyBatis程序核心对象分析

整合MyBatis

使用SqlSessionFactoryBean封装SqlSessionFactory需要的环境信息

使用MapperScannerConfigurer加载Dao接口，创建代理对象保存到IOC容器中

2. 代码实现

问题导入

问题1：Spring整合mybatis的依赖叫什么？

问题2：Spring整合mybatis需要管理配置哪两个Bean，这两个Bean作用分别是什么？

【前置工作】

在pom.xml中添加spring-context、druid、mybatis、mysql-connector-java等基础依赖。
准备service和dao层基础代码

public interface AccountService {

    void save(Account account);

    void delete(Integer id);

    void update(Account account);

    List<Account> findAll();

    Account findById(Integer id);

}
@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void save(Account account) {
        accountDao.save(account);
    }

    public void update(Account account){
        accountDao.update(account);
    }

    public void delete(Integer id) {
        accountDao.delete(id);
    }

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    public List<Account> findAll() {
        return accountDao.findAll();
    }
}
public interface AccountDao {

    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);

    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id);

    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);

    @Select("select * from tbl_account")
    List<Account> findAll();

    @Select("select * from tbl_account where id = #{id} ")
    Account findById(Integer id);
}

【第一步】导入Spring整合Mybatis依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>

【第二步】创建JdbcConfig配置DataSource数据源

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

【第三步】创建MybatisConfig整合mybatis

public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

【第四步】创建SpringConfig主配置类进行包扫描和加载其他配置类

@Configuration
@ComponentScan("com.itheima")
//@PropertySource：加载类路径jdbc.properties文件
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

【第五步】定义测试类进行测试

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

        AccountService accountService = ctx.getBean(AccountService.class);

        Account ac = accountService.findById(1);
        System.out.println(ac);
    }
}

7.2 Spring整合Junit单元测试

问题导入

Spring整合Junit的两个注解作用分别是什么？

1.【第一步】导入整合的依赖坐标spring-test

<!--junit-->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
</dependency>
<!--spring整合junit-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.1.9.RELEASE</version>
</dependency>

2.【第二步】使用Spring整合Junit专用的类加载器

3.【第三步】加载配置文件或者配置类

//【第二步】使用Spring整合Junit专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
//【第三步】加载配置文件或者配置类
@ContextConfiguration(classes = {SpringConfig.class}) //加载配置类
//@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加载配置文件
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;

    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));
    }

    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }
}

注意：junit的依赖至少要是4.12版本,可以是4.13等版本,否则出现如下异常：

今日目标

能够理解AOP的作用
能够完成AOP的入门案例
能够理解AOP的工作流程
能够说出AOP的五种通知类型
能够完成"测量业务层接口万次执行效率"案例
能够掌握Spring事务配置

八. AOP

8.1 AOP简介

问题导入

问题1：AOP的作用是什么？

问题2：连接点和切入点有什么区别，二者谁的范围大？

问题3：请描述什么是切面？

1. AOP简介和作用

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

2. AOP中的核心概念

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

8.2 AOP入门案例

问题导入

问题1：在通知方法中如何定义切入点表达式？

问题2：如何配置切面？

问题3：在配置类上如何开启AOP注解功能？

1. AOP入门案例思路分析

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

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 {
}

测试类和运行结果

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

3. 总结:

流程下来, 原有的dao和service层代码不发生改变, 改变的有:
Spring配置类中加上@EnableAspectJAutoProxy注解, 表明要用注解开发AOP
在通知类中:
- @Component注解 : 配置成Spring管理的bean , 让Spring来加载
- @Aspect注解 : 设置当前类为切面类类 , 告诉Spring这个类是做AOP的
- @Pointcut注解 : 定义好切入点
- 定义好通知
- 用@Before注解或其他, 绑定好切入点和通知

8.3 AOP工作流程

问题导入

什么是目标对象？什么是代理对象？

1. AOP工作流程

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

2. AOP核心概念

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

SPringAOP本质: 代理模式, 整个AOP的实现过程就是用代理模式来进行的

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());
    }
}

8.4 AOP切入点表达式

问题导入

在切入点表达式中如何简化包名和参数类型书写？

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等，可以省略
- 返回值：写返回值类型
- 包名：多级包使用点连接
- 类/接口名：
- 方法名：
- 参数：直接写参数的类型，多个类型用逗号隔开
- 异常名：方法定义中抛出指定异常，可以省略

2. 通配符

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

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

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

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

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

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

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

+：专用于匹配子类类型

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

例:

execution(* *..u*(..)) //任意包下 , 任意返回值 , 任意参数的 , 以u开头的方法
execution(* *..*e(..)) //任意包下 , 任意返回值 , 任意参数的 , 以e结尾的方法

@Pointcut("execution(* com.itheima.*.*Service.find*(..))")//给所有业务层的查询方法加AOP

3. 书写技巧

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

8.5 AOP通知类型

问题导入

请描述一下如何定义环绕通知方法？

5.1 AOP通知分类

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

2. 前置通知

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

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

3. 后置通知

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

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

4. 返回后通知

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

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

5. 抛出异常后通知

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

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

6. 环绕通知

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

如果原始方法无返回值, 则返回的object为null

@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;
}

环绕通知注意事项

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

@Around注意事项
- 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
- 通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行
- 对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，必须设定为Object类型
- 原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void，也可以设置成Object
- 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须抛出Throwable对象

8.6 AOP案例-测量业务层接口万次执行效率

问题导入

能不能描述一下环绕通知里面的实现步骤？

1. 需求和分析

需求：任意业务层接口执行均可显示其执行效率（执行时长）

分析：

①：业务功能：业务层接口执行前后分别记录时间，求差值得到执行效率
②：通知类型选择前后均可以增强的类型——环绕通知

2. 代码实现

【前置工作】环境准备

Spring整合mybatis对spring_db数据库中的Account进行CRUD操作
Spring整合Junit测试CRUD是否OK。
在pom.xml中添加aspectjweaver切入点表达式依赖
… …

【第一步】编写通知类

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}

    //设置环绕通知，在原始操作的运行前后记录执行时间
    @Around("ProjectAdvice.servicePt()") //本类类名可以省略不写
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行的签名对象
        Signature signature = pjp.getSignature();
        //获取接口/类全限定名
        String className = signature.getDeclaringTypeName();
        //获取方法名
        String methodName = signature.getName();
        //记录开始时间
        long start = System.currentTimeMillis();
        //执行万次操作
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        //记录结束时间
        long end = System.currentTimeMillis();
        //打印执行结果
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    }
}

【第二步】在SpringConfig配置类上开启AOP注解功能

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableAspectJAutoProxy //开启AOP注解功能
public class SpringConfig {
}

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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        Account account = accountService.findById(2);
    }
    @Test
    public void testFindAll(){
        List<Account> list = accountService.findAll();
    }
}

8.7 AOP切入点数据获取

问题导入

在环绕通知中可以获取到哪些数据？

AOP通知获取数据

获取切入点方法的参数
- JoinPoint：适用于前置、后置、返回后、抛出异常后通知
- ProceedJointPoint：适用于环绕通知
获取切入点方法返回值
- 返回后通知
- 环绕通知
获取切入点方法运行异常信息
- 抛出异常后通知
- 环绕通知

1. 获取参数

说明：在前置通知和环绕通知中都可以获取到连接点方法的参数们

使用getArgs方法获取参数

JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数

@Before("pt()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
}

ProccedJointPoint是JoinPoint的子类

proceed方法还可以给原始方法传递参数, 从而实现对原始方法参数处理的功能

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) {
    Object[] args = pjp.getArgs();
    System.out.println(Arrays.toString(args));
    args[0] = 666;
    Object ret = null;
    try {
        ret = pjp.proceed(args);
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return ret;
}

2. 获取返回值

说明：在返回后通知和环绕通知中都可以获取到连接点方法的返回值

抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

注 : 如果方法中既需要获取返回值也需要获取原始方法的参数 , 那么JoinPoint必须放在参数的第一个位置

@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(String ret) { //变量名要和returning="ret"的属性值一致
    System.out.println("afterReturning advice ..."+ret);
}

环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    // 手动调用连接点方法，返回值就是连接点方法的返回值
    Object ret = pjp.proceed();
    return ret;
}

3. 获取异常

说明：在抛出异常后通知和环绕通知中都可以获取到连接点方法中出现的异常

抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {//变量名要和throwing = "t"的属性值一致
    System.out.println("afterThrowing advice ..."+ t);
}

抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象

@Around("pt()")
public Object around(ProceedingJoinPoint pjp)  {
    Object ret = null;
    //此处需要try...catch处理，catch中捕获到的异常就是连接点方法中抛出的异常
    try {
        ret = pjp.proceed();
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return ret;
}

8.8 AOP案例-百度网盘密码数据兼容处理

1. 需求和分析

需求：对百度网盘分享链接输入密码时尾部多输入的空格做兼容处理

分析：
①：在业务方法执行之前对所有的输入参数进行格式处理——trim()
②：使用处理后的参数调用原始方法——环绕通知中存在对原始方法的调用

2. 代码实现

【前置工作】环境准备

//-------------service层代码-----------------------
public interface ResourcesService {
    public boolean openURL(String url ,String password);
}
@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;

    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}
//-------------dao层代码-----------------------
public interface ResourcesDao {
    boolean readResources(String url, String password);
}
@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}

【第一步】编写通知类

@Component
@Aspect
public class DataAdvice {
    
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}

    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }
}

【第二步】在SpringConfig配置类上开启AOP注解功能

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

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

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

8.9 AOP开发总结

1. AOP的核心概念

概念：AOP(Aspect Oriented Programming)面向切面编程，一种编程范式
作用：在不惊动原始设计的基础上为方法进行功能增强
核心概念
- 代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的
- 连接点（JoinPoint）：在SpringAOP中，理解为任意方法的执行
- 切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
- 通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
- 切面（Aspect）：描述通知与切入点的对应关系
- 目标对象（Target）：被代理的原始对象成为目标对象

2. 切入点表达式语法

切入点表达式标准格式：动作关键字(访问修饰符返回值包名.类/接口名.方法名（参数）异常名)
- execution(* com.itheima.service.Service.(…))
切入点表达式描述通配符：
- 作用：用于快速描述，范围描述
- *：匹配任意符号（常用）
- … ：匹配多个连续的任意符号（常用）
- +：匹配子类类型
切入点表达式书写技巧

1.按标准规范开发
2.查询操作的返回值建议使用*匹配
3.减少使用…的形式描述包
4.对接口进行描述，使用*表示模块名，例如UserService的匹配描述为*Service
5.方法名书写保留动词，例如get，使用*表示名词，例如getById匹配描述为getBy*
6.参数根据实际情况灵活调整

3. 五种通知类型

前置通知
后置通知
环绕通知（重点）
- 环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
- 环绕通知可以隔离原始方法的调用执行
- 环绕通知返回值设置为Object类型
- 环绕通知中可以对原始方法调用过程中出现的异常进行处理
返回后通知
抛出异常后通知

4. 通知获取数据

获取切入点方法的参数
- JoinPoint：适用于前置、后置、返回后、抛出异常后通知，设置为方法的第一个形参
- ProceedJointPoint：适用于环绕通知
获取切入点方法返回值
- 返回后通知
- 环绕通知
获取切入点方法运行异常信息
- 抛出异常后通知
- 环绕通知

九. Spring事务管理

9.1 Spring事务简介

问题导入

Spring提供的事务管理是数据层的事务还是业务层的事务?

1. Spring事务作用

事务作用：事务就是保障数据层操作的一致性的 , 在数据层保障一系列的数据库操作同成功同失败
Spring事务作用：在数据层或**业务层**保障一系列的数据库操作同成功同失败

2. 需求和分析

需求：实现任意两个账户间转账操作
需求微缩：A账户减钱，B账户加钱
分析：
①：数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）
②：业务层提供转账操作（transfer），调用减钱与加钱的操作
③：提供2个账号和操作金额执行转账操作
④：基于Spring整合MyBatis环境搭建上述操作
结果分析：
①：程序正常执行时，账户金额A减B加，没有问题
②：程序出现异常后，转账失败，但是异常之前操作成功，异常之后操作失败，整体业务失败

3. 代码实现

【前置工作】环境准备

Spring整合Mybatis相关代码(依赖、JdbcConfig、MybatisConfig、SpringConfig)省略。

public interface AccountDao {

    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money);

    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money);
}

public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    public void transfer(String out,String in ,Double money) ;
}

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }
}

【第一步】在业务层接口上添加Spring事务管理

public interface AccountService {
    //配置当前接口方法具有事务
    @Transactional
    public void transfer(String out,String in ,Double money) ;
}

注意事项

Spring注解式事务通常添加在业务层接口中而不会添加到业务层实现类中，降低耦合
注解式事务可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务

【第二步】设置事务管理器 ( 将事务管理器添加到IOC容器中 )

说明：可以在JdbcConfig中配置事务管理器

//配置事务管理器，mybatis使用的是jdbc事务
//
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSourceTransactionManager dtm = new DataSourceTransactionManager();
    transactionManager.setDataSource(dataSource);
    return transactionManager;
}

注意事项

事务管理器要根据实现技术进行选择
MyBatis框架使用的是JDBC事务

【第三步】开启注解式事务驱动

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}

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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",100D);
    }
}

9.2 Spring事务角色

问题导入

什么是事务管理员，什么是事务协调员？

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

Spring事务的原理
- Spring用的是JDBC的事务 , 而Mybatis用的也是JDBC的事务
- 在配置类中 , 也可以看出 , JDBC的事务管理器和MyBatis中的sqlSessionFactoryBean中注入的是同一个DateSource

9.3 Spring事务相关配置

问题导入

什么样的异常，Spring事务默认是不进行回滚的？

1. 事务配置

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

@Transactional(rollbackFor = IOException.class)
//在接口中配置

2. 案例：转账业务追加日志

需求和分析

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

【准备工作】环境整备

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

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

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private 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 {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private 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 {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",50D);
    }
}

3. 事务传播行为

用propagation属性设置

@Transactional(propagation = Propagation.REQUIRES_NEW)

十. Spring-自己总结

1.1 IOC入门(XML)

导入Spring坐标
```
spring-context  5.2.10.RELEASE
```
定义Spring管理的类（接口）

创建Spring配置文件，配置对应类作为Spring管理的bean对象

<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl"></bean>

初始化IOC容器（Spring核心容器/Spring容器），通过容器获取bean对象

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

1.2 DI入门(XML)

【第一步】删除使用new的形式创建对象的代码
【第二步】提供依赖对象对应的setter方法

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

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <property name="bookDao" ref="bookDao"/>
</bean>

1.3 Bean

1. Bean的基础配置

scope的取值有singleton和prototype等, 分别代表单例和非单例

2.Bean的实例化

bean实例化——构造方法
bean实例化——静态工厂
bean实例化-实例工厂实现FactoryBean<T>方式

3. Bean的生命周期

Bean生命周期控制

XML控制

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>

实现InitializingBean, DisposableBean接口控制

public void afterPropertiesSet() throws Exception {
public void destroy() throws Exception {

4. Bean销毁时机

关闭容器方式
- 手工关闭容器 : 暴力关闭方式
```
ctx.close//此处需要使用实现类类型，接口类型没有close方法
```
- 注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机
```
ctx.registerShutdownHook();
```

sweetcuter

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

四(1)spring框架

阶段四 热门框架

第一章 spring框架

一. Spring简介

1.1 Spring课程介绍

1. 为什么要学

2. 学什么

3. 怎么学

1.2 初识Spring

1. Spring家族

2. Spring发展史

1.3 Spring体系结构

1. Spring Framework系统架构图

2. Spring Framework课程学习路线

1.4 Spring核心概念

1. 目前我们代码存在的问题

2. 核心概念

1.5 IOC和DI入门案例

1. IOC入门案例

2. DI入门案例

二. Bean实例化

2.1 Bean的基础配置

1. Bean基础配置

2. Bean别名配置

3. Bean作用范围配置

2.2 Bean的实例化

1. bean实例化——构造方法

2. bean实例化——静态工厂

3. bean实例化-实例工厂

4. 实现FactoryBean<T>方式

2.3 Bean的生命周期

1. Bean生命周期控制

2. 实现接口方式控制

3. Bean销毁时机

三. DI: 依赖注入

3.1 setter方式注入

问题导入

引用类型

简单类型

3.2 构造方式注入

问题导入

引用类型

简单类型

参数适配

3.3 依赖注入方式选择

3.4 依赖自动装配

1. 自动装配概念

2. 自动装配类型

依赖自动装配

依赖自动装配特征

3.5 集合注入

集合中注入引用类型

1. 注入数组类型数据

2. 注入List类型数据

3. 注入Set类型数据

4. 注入Map类型数据

5. 注入Properties类型数据

3.6 第三方资源配置管理

1. 管理Druid连接池

2. 管理c3p0连接池

3.7 加载properties属性文件

1. 基本用法

2.设置配置不加载系统属性

3. 加载properties文件写法

四. Spring容器

4.1 Spring核心容器介绍

1. 创建容器

2. 获取bean对象

3. 容器类层次结构

4. BeanFactory

五. 总结

5.1 bean相关

5.2 依赖注入相关

5.3 容器相关

六. Spring注解开发

6.1 注解开发定义Bean对象

1. 基本使用

2. @Component三个衍生注解

6.2 纯注解开发模式

1. 纯注解开发模式介绍

阶段四热门框架