文章目录

• • 学习目标
  • 一、Spring简介
  • • 1 Spring课程介绍
    • • 问题导入
      • 1.1 为什么要学
      • 1.2 学什么
      • 1.3 怎么学
    • 2 初识Spring
    • • 问题导入
      • 2.1 Spring家族
      • 2.2 Spring发展史
    • 3 Spring体系结构
    • • 问题导入
      • 3.1 Spring Framework系统架构图
      • 3.2 Spring Framework课程学习路线
    • 4 Spring核心概念
    • • 问题导入
      • 4.1 目前我们代码存在的问题
      • 4.2 核心概念
  • 二、IOC和DI入门案例【重点】
  • • 1 IOC入门案例【重点】
    • • 问题导入
      • 1.1 门案例思路分析
      • 1.2 实现步骤
      • 1.3 实现代码
      • 1.4 运行结果
    • 2 DI入门案例【重点】
    • • 问题导入
      • 2.1 DI入门案例思路分析
      • 2.2 实现步骤
      • 2.3 实现代码
      • 2.4 图解演示
  • 三、Bean的基础配置
  • • 问题导入
    • 1 Bean基础配置【重点】
    • • 配置说明
      • 代码演示
      • 运行结果
    • 2 Bean别名配置
    • • 配置说明
      • 代码演示
      • 打印结果
    • 3 Bean作用范围配置【重点】
    • • 配置说明
      • 代码演示
      • 打印结果
  • 四、Bean的实例化
  • • 问题导入
    • 1 Bean是如何创建的【理解】
    • 2 实例化Bean的三种方式
    • • 2.1 构造方法方式【重点】
      • 2.2 静态工厂方式
      • 2.3 实例工厂方式
      • 2.4 实现FactoryBean\方式【扩展,了解。Spring整合实际大量采用的方式】
  • 五、Bean的生命周期【了解】
  • • 问题导入
    • 1 生命周期相关概念介绍
    • 2 代码演示
    • • 2.1 Bean生命周期控制
      • 2.2 Bean生命周期控制
    • 3 Bean销毁时机
  • 六、依赖注入(DI配置)
  • • 1 依赖注入方式【重点】
    • • 问题导入
      • 1.1 依赖注入的两种方式
      • 1.2 setter方式注入
      • • 问题导入
        • 引用类型 ==(property标签的name和ref属性)==
        • 简单类型 ==(property标签的name和value属性)==
      • 1.3 构造方式注入
      • • 问题导入
        • 引用类型 ==(constructor-arg标签的name和ref属性)==
        • 简单类型 ==(constructor-arg标签的name和value属性)==
        • 参数适配【了解】
      • 1.4 代码演示
      • 1.5 依赖注入方式选择
    • 2 依赖自动装配【理解】
    • • 问题导入
      • 2.1 自动装配概念
      • 2.2 自动装配类型
      • • 依赖自动装配
        • 依赖自动装配特征
        • 代码演示
    • 3 集合注入
    • • 3.1 注入数组类型数据
      • 3.2 注入List类型数据
      • 3.3 注入Set类型数据
      • 3.4 注入Map类型数据
      • 3.5 注入Properties类型数据
  • 7、数据源对象管理(管理第三方bean)
  • • 7.1 创建环境
    • 7.2 核心配置里写druid的bean
    • 7.3 核心配置里写c3p0的bean
    • 7.4 加载properties文件（动态配置连接参数）

学习目标

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

一、Spring简介

1 Spring课程介绍

问题导入

我们为什么要学习Spring框架？

1.1 为什么要学

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

• 专业角度

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

企业级开发：Spring使用率>90%

1.2 学什么

• 简化开发

  • IOC(反转控制)
  • AOP(面向切面编程)
    • 事务处理

• 框架整合

  • MyBatis
  • MyBatis-plus
  • Struts
  • Struts2
  • Hibernate
  • ……

1.3 怎么学

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

2 初识Spring

问题导入

目前我们使用的是Spring几版本？

2.1 Spring家族

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

spring家族：

2.2 Spring发展史

3 Spring体系结构

问题导入

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

3.1 Spring Framework系统架构图

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

4.x架构图趋于成熟

Aspect不是spring原创，是别人的东西spring觉得非常之好，拿过来直接用，所以导包时要单独导Aspect包(依赖)

3.2 Spring Framework课程学习路线

4 Spring核心概念

问题导入

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

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

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

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

4.2 核心概念

• IOC（Inversion of Control）控制反转

  使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。通俗的讲就是“将new对象的权利交给Spring，我们从Spring中获取对象使用即可”

• Spring技术对IoC思想进行了实现

  • Spring提供了一个容器，称为IOC容器，用来充当IoC思想中的“外部”

  • IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean

    IOC容器也叫Spring容器，就是上图中的Core Container
    IoC容器充当Ioc思想中的“外部”就是说：主动new对象改成由IoC容器提供对象

• DI（Dependency Injection）依赖注入

  • 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入。

    service和bean都在IoC容器中被管理，他们之间又有关系，那么IoC容器不妨直接将他们之间关系绑定好，这个过程成为:DI

• 目标：充分解耦
  • 使用IoC容器管理bean（IOC)
  • 在IoC容器内将有依赖关系的bean进行关系绑定（DI）
• 最终效果
  • 使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

高内聚，低耦合，一切的一切就是要减少类与类(代码与代码)之间的关系，但是类与类之间又有着不可分割的关系，那么全部不能写死，全部关系变成动态的有关，代码都抽象到接口层面，都不写死，就充分解耦了。最后维护时改了A不影响B，改了B不影响C…

二、IOC和DI入门案例【重点】

1 IOC入门案例【重点】

问题导入

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

1.1 门案例思路分析

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

1.2 实现步骤

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

先创建module

创建目录结构如下:

最终目录结构：

注意新项目maven可能变了，需要修改下配置：

1.3 实现代码

【第一步】导入Spring坐标

org.springframeworkspring-context5.2.10.RELEASE

第一次导入直接复制，然后刷新一下maven让其下载，然后下次就会有代码提示了

【第二步】定义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

先导spring坐标,然后resources根目录下右键创建

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

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

public class App {public static void main(String[] args) {//1. 创建IoC容器对象，加载spring核心配置文件ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");//2. 在IoC容器里获取Bean对象//2.1 拿daoBookDao bookDao = (BookDao) ioc.getBean("bookDao");bookDao.save(); // 正常执行方法//2.2 拿serviceBookService bookService = (BookService) ioc.getBean("bookService");bookService.save(); // 正常执行方法}
}

1.4 运行结果

2 DI入门案例【重点】

问题导入

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

2.1 DI入门案例思路分析

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

2.2 实现步骤

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

2.3 实现代码

【第一步】删除使用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中配置

2.4 图解演示

DI注入两个bookDao都指的啥

三、Bean的基础配置

问题导入

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

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

1 Bean基础配置【重点】

配置说明

代码演示

见上面《IOC入门案例》applicationContext.xml配置

运行结果

见上面《IOC入门案例》运行结果

下面图片中的com.itheima我都换成了cn.whu

2 Bean别名配置

配置说明

代码演示

打印结果

name作用域范围很大，甚至可以取代id作为ref值

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

配置说明

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

代码演示

打印结果

不修改配置，默认情况下单例，打印的对象地址值完全一样

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

比如dao，之前new一次调用一个方法，下次再new再调用方法，完全不必要，复用一个对象就行了的，有参数也可以一个对象方法传递不同参数，springIOC帮我们管理的就是这类可以复用的对象 都是单例模式，很轻量化

四、Bean的实例化

问题导入

Bean的实例化方式有几种？

1 Bean是如何创建的【理解】

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

2 实例化Bean的三种方式

之前的module复制一份，然后稍作修改(service直接删除 这个知识点不需要)

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

构造方法private也都能正常创建，说明内部是用反射实现的

• applicationContext.xml配置

• AppForInstanceBook测试类

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

• 运行结果

注意：无参构造方法如果不存在，将抛出异常BeanCreationException (比如给上面构造方法加个参数，再执行就会报错)

2.2 静态工厂方式

• OrderDao接口和OrderDaoImpl实现类

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

• OrderDaoFatory工厂类

cn.whu.factory.OrderDaoFactory

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

• applicationContext.xml配置

• AppForInstanceOrder测试类

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

• 运行结果

• 只要加载了配置文件，Bean对象就会被创建

public class AppForInstanceOrder {public static void main(String[] args) {ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");//OrderDao orderDao = (OrderDao) ioc.getBean("orderDao");//orderDao.save();}
}

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(){System.out.println("UserDaoFactory ....");return new UserDaoImpl();}
}

• applicationContext.xml配置

前面的配置都注释了
区别：

静态工厂直接写类名
实例工厂得先创建工厂对象

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

• 运行结果

2.4 实现FactoryBean方式【扩展,了解。Spring整合实际大量采用的方式】

• 定义UserDaoFactoryBean实现FactoryBean

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

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean {//代替原始实例工厂中创建对象的方法//好处：以后工厂获取对象的方法定死了，统统都叫getObject,不需要变了public UserDao getObject() throws Exception {return new UserDaoImpl();}//对象Class类型public Class getObjectType() {return UserDao.class;}
}

• applicationContext.xml配置

其他配置都注释了

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

• FactoryBean默认创建也是单例★(接口设计时干了好多事儿)

public class AppForInstanceUser {public static void main(String[] args) {ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");UserDao userDao1 = (UserDao) ioc.getBean("userDao");UserDao userDao2 = (UserDao) ioc.getBean("userDao");System.out.println(userDao1);System.out.println(userDao2);}
}

如何改成多例：继续重写一个方法isSingleton()

public boolean isSingleton() {return false;//多例//return true;//单例
}

五、Bean的生命周期【了解】

问题导入

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

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

1 生命周期相关概念介绍

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

2 代码演示

复制一下之前的module，修改成如下形式：

2.1 Bean生命周期控制

• 提供生命周期控制方法

public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save~");}//自定义两个无参方法，用来监视生命周期（applicationContext.xml中配置下即可）//表示bean初始化对应的操作public void init(){System.out.println("init...");}//表示bean销毁前对应的操作public void destroy(){System.out.println("destroy...");}
}

• applicationContext.xml配置

• 测试类

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

还有一种温和的关闭虚拟机的方式，为IoC容器注册关闭钩子registerShutdownHook，也就是让虚拟机在IoC容器彻底关闭了之后才关闭：

public static void main(String[] args) {ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");ioc.registerShutdownHook();BookDao bookDao = (BookDao) ioc.getBean("bookDao");bookDao.save();//ioc.close();
}

执行结果同上~

2.2 Bean生命周期控制

约定优于配置: 按照人家的约定来写代码，就不用配置了(不用配置init-method和destroy-method了)

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

• applicationContext.xml

• 测试代码

ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
ioc.registerShutdownHook();
//容器加载就会创建对象 方法执不执行无所谓

分析：销毁方法也叫destroy,很正常，但是初始化方法叫afterPropertiesSet，有点奇怪。
仔细分析，发现after Properties Set =》属性设置之后，集合运行结果"service init"正好在"set …"之后，这就明白了，该方法执行时机为,该类所有属性设置(注入)完毕之后

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配置)

1 依赖注入方式【重点】

问题导入

依赖注入有几种方式？

1.1 依赖注入的两种方式

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

1.2 setter方式注入

问题导入

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

引用类型 (property标签的name和ref属性)

简单类型 (property标签的name和value属性)

1.3 构造方式注入

问题导入

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

引用类型 (constructor-arg标签的name和ref属性)

简单类型 (constructor-arg标签的name和value属性)

参数适配【了解】

名称不必一致了，有时候真的挺好用的

1.4 代码演示

复制一份代码，修改为如下形式：

具体代码很简单，都是打印一句话，没有复杂逻辑

pom.xml引入lombok依赖，省得老是写set方法

org.projectlomboklombok1.18.26

• set注入引用类型 (property标签的name和ref属性)
  BookServiceImpl.java

@Data
public class BookServiceImpl implements BookService {private BookDao bookDao;private UserDao userDao;public void save() {System.out.println("book service save ...");bookDao.save();userDao.save();}//有lombok 所以这里其实提供了所有的Get/Set方法
}

其中:

//BookDao接口
public interface BookDao {public void save();
}
//BookDaoImpl实现类
public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save~");}
}//UserDao接口
public interface UserDao {public void save();
}
//UserDaoImpl实现类
public class UserDaoImpl implements UserDao {public void save() {System.out.println("user dao save ...");}
}

applicationContext.xml

AppForDISet 测试方法

public class AppForDISet {public static void main(String[] args) {//1. 创建IoC容器对象，加载spring核心配置文件ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");//2. 在IoC容器里获取Bean对象(BookServiceImpl)BookService bookService = (BookService) ioc.getBean("bookService");bookService.save(); // 正常执行方法}
}

可以注入多个

• set注入简单类型 (property标签的name和value属性)
  BookDaoImpl

@Data
public class BookDaoImpl implements BookDao {private int connectionNum;private String databaseName;public void save() {System.out.println("book dao save~  "+connectionNum+"  "+databaseName);}//有lombok @Data 这里其实有了所有属性的get/set
}

applicationContext.xml

AppForDISet_Simple 测试方法

public class AppForDISet_Simple {public static void main(String[] args) {ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ioc.getBean("bookDao");bookDao.save();}
}

先复制一份还原环境

• 构造器注入引用类型 (constructor-arg标签的name和ref属性)
  BookServiceImpl

  有构造方法，不需要set方法了

public class BookServiceImpl implements BookService {private BookDao bookDao;private UserDao userDao;//构造器注入 不需要set方法了public BookServiceImpl(BookDao bookDao,UserDao userDao){this.bookDao = bookDao;this.userDao = userDao;}public void save() {System.out.println("book service save ...");bookDao.save();userDao.save();}
}

其中:

//BookService接口
public interface BookService {public void save();
}//BookDao 接口
public interface BookDao {public void save();
}
//BookDaoImpl实现类
public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save~");}
}//UserDao 接口
public interface UserDao {public void save();
}
//UserDaoImpl 实现类
public class UserDaoImpl implements UserDao {public void save() {System.out.println("user dao save ...");}
}

applicationContext.xml

AppForDIConstructor测试类

public class AppForDIConstructor {public static void main(String[] args) {ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");BookService bookService = (BookService) ioc.getBean("bookService");bookService.save();}
}

• 构造器注入简单类型 (constructor-arg标签的name和value属性)
  BookDaoImpl

public class BookDaoImpl implements BookDao {private String databaseName;private int connectionNum;//同样，有构造方法就不需要set方法了 (这里用不着lombok了)public BookDaoImpl(String databaseName, int connectionNum) {this.databaseName = databaseName;this.connectionNum = connectionNum;}public void save() {System.out.println("book dao save ... " + databaseName+"  "+connectionNum);}
}

其中：

//BookDao 接口
public interface BookDao {public void save();
}

applicationContext.xml

AppForDIConstructor_Simple 测试方法

public class AppForDIConstructor_Simple {public static void main(String[] args) {ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ioc.getBean("bookDao");bookDao.save();}
}

【参数适配 了解】

前面的问题在于配置文件里的name和字段名或属性名name必须一直，属性名改了配置文件里也要改
参数适配就没有这个问题了，常用的还是上面name匹配，但有时候这个适配还真的挺好用的

上面配置最终结果如下：

下面直接在此基础上修改，其他代码不必动

其中：

//BookDaoImpl构造器
public BookDaoImpl(String databaseName, int connectionNum) {this.databaseName = databaseName;this.connectionNum = connectionNum;
}//BookServiceImpl构造器
public BookServiceImpl(BookDao bookDao,UserDao userDao){this.bookDao = bookDao;this.userDao = userDao;
}

• constructor-arg按参数类型注入 【type=“int,String,…形参类型”】

  等价修改为：

  个人猜想：肯定有取别名简化全全类名的方式，但是其实写简单类名，IDEA自动帮你变成了全类名
  弊端： 万一两个相同类型(eg：两个String类型) 就没办法用了

• constructor-arg按参数位置注入 【index=“0,1,2…参数位置”】
  等价修改为：

1.5 依赖注入方式选择

1. 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
2. 可选依赖使用setter注入进行，灵活性强
3. Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
   (其实因为人家做框架的，需要严谨，我们并不需要那么严谨，该用set就用set)
4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
5. 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
6. 自己开发的模块推荐使用setter注入（我们基本以set注入为主，结合lombok简直不要太爽）

小结：

2 依赖自动装配【理解】

问题导入

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

2.1 自动装配概念

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

2.2 自动装配类型

依赖自动装配

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

依赖自动装配特征

1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

总得来说一句话: 只能对引用类型自动装配且该引用类型在bean中有且只有一个对象(其实以后配置实现类不可能写两个的，springIOC管理的都是单例对象呀)
(推荐的按类型装配)

代码演示

// BookDao 接口
public interface BookDao {public void save();
}
// BookDaoImpl 实现类
public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ... ");}
}// UserDao 接口
public interface UserDao {public void save();
}
// UserDaoImpl 实现类
public class UserDaoImpl implements UserDao {public void save() {System.out.println("user dao save ...");}
}// BookService 接口
public interface BookService {public void save();
}// BookServiceImpl 实现类
@Data //set方法还是要给的
public class BookServiceImpl implements BookService {private BookDao bookDao;private UserDao userDao;public void save() {System.out.println("book service save ...");bookDao.save();userDao.save();}
}

applicationContext.xml 使用自动装配 (按类型装配)

测试方法仍然正常执行：

public static void main(String[] args) {ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");BookService bookService = (BookService) ioc.getBean("bookService");bookService.save();
}

3 集合注入

环境很简单：一个BookDao(Impl),一个测试方法AppForDICollection
applicationContext.xml也只是配置了1个dao:
pom.xml 里有lombok依赖

BookDaoImpl.java

import java.util.*;
@Data
public class BookDaoImpl implements BookDao {private int[] array;private List list;private Set set;private Map map;private Properties properties;public void save() {System.out.println("book dao save ...");System.out.println("遍历数组: "+ Arrays.toString(array));System.out.println("遍历List: "+list);System.out.println("遍历Set: "+set);System.out.println("遍历Map: "+map);System.out.println("遍历Properties: "+properties);}//这里有所有的get/set
}

3.1 注入数组类型数据

100200300

3.2 注入List类型数据

itcastitheimaboxueguchuanzhihui

3.3 注入Set类型数据

itcastitheimaboxueguboxuegu

3.4 注入Map类型数据

3.5 注入Properties类型数据

chinahenankaifeng

说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写、、、

最终配置：

100200300wwwwhueducnwhueducn青鸾峰天墉城幻溟界

测试方法

public class AppForDICollection {public static void main(String[] args) {//1. 创建IoC容器对象，加载spring核心配置文件ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ioc.getBean("bookDao");bookDao.save();}
}

• 简单了解：
  1、和可以相互混用
  
  2、可以注入bean类型写法如下
  
  但是所有的集合注入，以后开发极少极少用到，不必太在意这个，到时候回来看看即可。

7、数据源对象管理(管理第三方bean)

第三方资源配置管理

7.1 创建环境

还是复制一份之前的修改吧

App.java

public class App {public static void main(String[] args) {//1. 创建IoC容器对象，加载spring核心配置文件ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");}
}

applicationContext.xml

pom.xml

4.0.0cn.whuspring_09_datasourcewar1.0-SNAPSHOTorg.springframeworkspring-context5.2.10.RELEASEcom.alibabadruid1.1.16

7.2 核心配置里写druid的bean

测试druid

public static void main(String[] args) {//1. 创建IoC容器对象，加载spring核心配置文件ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");DataSource dataSource = (DataSource) ioc.getBean("dataSource");System.out.println(dataSource);
}

获取到了就OK

7.3 核心配置里写c3p0的bean

先pom.xml中引入依赖:

c3p0c3p00.9.1.2


mysqlmysql-connector-java5.1.16

不知道坐标，可以百度或者maven仓库搜索
https://mvnrepository.com/search?q=mysql

applicationContext.xml 核心配置里写管理

测试方法：

public class TestC3P0 {public static void main(String[] args) {//1. 创建IoC容器对象，加载spring核心配置文件ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");DataSource dataSource = (DataSource) ioc.getBean("comboPooledDataSource");System.out.println(dataSource);}
}

运行结果：

com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 3, acquireRetryAttempts -> 30, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 0, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, dataSourceName -> 2zr8rdau1tyh71w1bihje8|bd8db5a, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> com.mysql.jdbc.Driver, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, identityToken -> 2zr8rdau1tyh71w1bihje8|bd8db5a, idleConnectionTestPeriod -> 0, initialPoolSize -> 3, jdbcUrl -> jdbc:mysql://localhost:3306/spring_db, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 0, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 15, maxStatements -> 0, maxStatementsPerConnection -> 0, minPoolSize -> 3, numHelperThreads -> 3, numThreadsAwaitingCheckoutDefaultUser -> 0, preferredTestQuery -> null, properties -> {user=******, password=******}, propertyCycle -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, usesTraditionalReflectiveProxies -> false ]

7.4 加载properties文件（动态配置连接参数）

• 创建jdbc.properties文件，放在resources根目录下

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

创建一个模板文件，一件生成文件, 文件名都不用写的

• 加载properties文件
  先要开启一个新的命名空间context，需要在头文件里加3行
  

最终配置：

• 测试效果
  1）直接运行上面的测试方法，输出结果完全一样。
  2）下面将数据注入到BookDaoImpl看看效果
  BookDaoImpl.java

  public class BookDaoImpl implements BookDao {private String name;public void save() {System.out.println("book dao save ...  " + name);}public void setName(String name) {this.name = name;}
  }
  

  applicationContext.xml 里最下面加入一行配置

  TestC3P0DI.java 测试方法

  public class TestC3P0DI {public static void main(String[] args) {//1. 创建IoC容器对象，加载spring核心配置文件ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ioc.getBean("bookDao");bookDao.save();}
  }
  

  

  这就简单试了一下参数的注入

• 加载properties文件注意点：

1. 为什么写jdbc.username而不直接写username？系统有环境变量username了，优先级比我写的高，自己写的username就被屏蔽了
   除非引入properties文件时手动将系统环境变量给屏蔽了：

2. 可以导入多个properties配置文件，location里逗号隔开就行了

3. 最好的方式：一次性加载所有的配置文件: location="classpath*:*.properties"
classpath*:能省略，但是不建议
   加上classpath*: 就不仅可以从当前项目读properties文件，还可以读导入的jar包里的properties文件了

小结：