Spring01-入门、IOC、DI、bean对象的创建、各种类型的注入。案例

文章目录

• 学习目标
• 一、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\<T>方式【扩展,了解。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简介

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入门案例【重点】

问题导入

<bean>标签中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坐标

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

第一次导入直接复制，然后刷新一下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根目录下右键创建

<?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">
 
    <!--
        1、配置实现类 因为要创建对象的  通过class的全路径名IoC就可以帮你创建对象了
        2、对象有了我拿的时候得有名字才行, 通过id给创建的对象取名

        bean标签：表示配置bean
    	id属性：表示给bean起名字
    	class属性：表示给bean定义类型
    -->
    <bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="cn.whu.service.impl.BookServiceImpl"/>

</beans>

注意事项：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 拿dao
        BookDao bookDao = (BookDao) ioc.getBean("bookDao");
        bookDao.save(); // 正常执行方法

        //2.2 拿service
        BookService bookService = (BookService) ioc.getBean("bookService");
        bookService.save(); // 正常执行方法
    }
}

1.4 运行结果

2 DI入门案例【重点】

问题导入

<property>标签中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中配置

<?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">
    <!--
        1、配置实现类 因为要创建对象的  通过class的全路径名IoC就可以帮你创建对象了
        2、对象有了我拿的时候得有名字才行, 通过id给创建的对象取名

        bean标签：表示配置bean
    	id属性：表示给bean起名字
    	class属性：表示给bean定义类型
    -->
    <bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="cn.whu.service.impl.BookServiceImpl">
        <!--配置server与dao的关系
           property标签：表示配置当前bean的属性
           name属性：表示配置哪一个具体的(BookServiceImpl类的)属性
           ref属性：表示参照哪一个bean(配置的id)
       -->
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

2.4 图解演示

DI注入两个bookDao都指的啥

三、Bean的基础配置

问题导入

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

问题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配置

<!--方式一：构造方法实例化bean-->
<bean id="bookDao" class="cn.whu.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();
    }
}

• 运行结果

注意：无参构造方法如果不存在，将抛出异常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配置

<!--方式二：使用静态工厂实例化bean
要是不写factory-method,造出来的就是OrderDaoFactory对象了
（这样配置就是先加载工厂类，再调用工厂类静态方法造OrderDao对象放到bean里）
-->
<bean id="orderDao" class="cn.whu.factory.OrderDaoFactory" factory-method="getOrderDao"/>

• 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对象就会被创建

<bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl" />

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

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

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

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

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

• 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<T>方式【扩展,了解。Spring整合实际大量采用的方式】

• 定义UserDaoFactoryBean实现FactoryBean<UserDao>

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

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {

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

    //对象Class类型
    public Class<?> getObjectType() {
        return UserDao.class;
    }
}

• applicationContext.xml配置

其他配置都注释了

<!-- 方式四: 使用FactoryBean实例化bean
     有了约定,配置就简单多了
-->
<bean id="userDao" class="cn.whu.factory.UserDaoFactoryBean"/>

使用之前的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配置

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

• 测试类

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

<bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>

<!--不需要手动配置init-method和destroy-method，根据约定来自动就有了-->
<bean id="bookService" class="cn.whu.service.impl.BookServiceImpl">
    <property name="bookDao" ref="bookDao"/>
</bean>

• 测试代码

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方法

<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.18.26</version>
</dependency>

• 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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl"/>
    <bean id="userDao" class="cn.whu.dao.impl.UserDaoImpl"/>

    <bean id="bookService" class="cn.whu.service.impl.BookServiceImpl">
        <!--注入两个引用类型-->
        <property name="bookDao" ref="bookDao"/>
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

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

<!-- value="xx" Spring会自动帮你转类型-->
<bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl">
    <property name="connectionNum" value="10"/>
    <property name="databaseName" value="mysql"/>
</bean>

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl"/>
    <bean id="userDao" class="cn.whu.dao.impl.UserDaoImpl"/>

    <bean id="bookService" class="cn.whu.service.impl.BookServiceImpl">
        <!--也是直接配置多个 虽然构造函数只有一个，而且一起传的  (name是字段名，ref是bean的id) -->
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
</beans>

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

<bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl">
	<!-- value属性自动进行类型转换 -->
    <constructor-arg name="connectionNum" value="20"/>
    <constructor-arg name="databaseName" value="oracle"/>
</bean>

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匹配，但有时候这个适配还真的挺好用的

上面配置最终结果如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl">
        <constructor-arg name="connectionNum" value="20"/>
        <constructor-arg name="databaseName" value="oracle"/>
    </bean>
    <bean id="userDao" class="cn.whu.dao.impl.UserDaoImpl"/>

    <bean id="bookService" class="cn.whu.service.impl.BookServiceImpl">
        <!--也是直接配置多个 虽然构造函数只有一个，而且一起传的-->
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
</beans>

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

其中：

//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,…形参类型”】
  等价修改为：

<bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl">
    <constructor-arg type="int" value="20"/>
    <constructor-arg type="java.lang.String" value="oracle"/>
</bean>
<bean id="userDao" class="cn.whu.dao.impl.UserDaoImpl"/>

<bean id="bookService" class="cn.whu.service.impl.BookServiceImpl">
    <!--也是直接配置多个 虽然构造函数只有一个，而且一起传的-->
    <constructor-arg type="cn.whu.dao.BookDao" ref="bookDao"/>
    <constructor-arg type="cn.whu.dao.UserDao" ref="userDao"/>
</bean>

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

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

<bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl">
      <constructor-arg index="1" value="20"/>
      <constructor-arg index="0" value="oracle"/>
  </bean>
  <bean id="userDao" class="cn.whu.dao.impl.UserDaoImpl"/>

  <bean id="bookService" class="cn.whu.service.impl.BookServiceImpl">
      <!--也是直接配置多个 虽然构造函数只有一个，而且一起传的-->
      <constructor-arg index="0" ref="bookDao"/>
      <constructor-arg index="1" ref="userDao"/>
  </bean>

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属性设置自动装配的类型

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

依赖自动装配特征

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 使用自动装配 (按类型装配)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl"/>
    <bean id="userDao" class="cn.whu.dao.impl.UserDaoImpl"/>
	<!-- 这里名称一致, autowire="byName" 也行 但是不建议 因为名称耦合了-->
    <bean id="bookService" class="cn.whu.service.impl.BookServiceImpl" autowire="byType"/>
</beans>

测试方法仍然正常执行：

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: <bean id=“bookDao” class=“cn.whu.dao.impl.BookDaoImpl”/>
pom.xml 里有lombok依赖

BookDaoImpl.java

import java.util.*;
@Data
public class BookDaoImpl implements BookDao {
    private int[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> 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 注入数组类型数据

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

3.2 注入List类型数据

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

3.3 注入Set类型数据

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

3.4 注入Map类型数据

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

3.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>标签

最终配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl">
        <!--注意下 name 跟类型无关，都是自己取的属性名字,恰好就是类型名称而已-->
        <property name="array">
            <array>
                <value>100</value>
                <value>200</value>
                <value>300</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>www</value>
                <value>whu</value>
                <value>edu</value>
                <value>cn</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>whu</value>
                <value>edu</value>
                <value>cn</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="天河" value="青鸾峰"/>
                <entry key="紫英" value="天墉城"/>
                <entry key="梦璃" value="幻溟界"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="天河">青鸾峰</prop>
                <prop key="紫英">天墉城</prop>
                <prop key="梦璃">幻溟界</prop>
            </props>
        </property>
    </bean>

</beans>

测试方法

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、<array>和<list>可以相互混用
  
  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

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

</beans>

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>cn.whu</groupId>
  <artifactId>spring_09_datasource</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <!-- druid数据源 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
    </dependency>
  </dependencies>
</project>

7.2 核心配置里写druid的bean

<!-- 管理DruidDataSource对象 -->
    <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="1234"/>
    </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中引入依赖:

<!-- c3p0连接池 -->
<dependency>
  <groupId>c3p0</groupId>
  <artifactId>c3p0</artifactId>
  <version>0.9.1.2</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.16</version>
</dependency>

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

applicationContext.xml 核心配置里写管理

<!-- c3p0
    c3p0连接池对象: ComboPooledDataSource
        1)知道数据源对象名称（让Spring创建）  百度或者记得
        2)知道四大属性名称 (注入进去 才能连上数据库)  可以根据代码提示猜到
        [和druid相比，数据源名称和属性名都不大相同]
-->
<bean id="comboPooledDataSource" 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="1234"/>
</bean>

测试方法：

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行

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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
            ">

最终配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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
            ">
    <!--
        1、先在头里面开启context命名空间
        2、再在下面引入文件：使用context空间加载properties文件
    -->
    <context:property-placeholder location="jdbc.properties" />
    <!-- 3、直接使用属性占位符${}读取properties文件中的属性 -->
    <bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
</beans>

• 测试效果
  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 里最下面加入一行配置

<bean id="bookDao" class="cn.whu.dao.impl.BookDaoImpl">
   <property name="name" value="${jdbc.driver}"/>
</bean>

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文件时手动将系统环境变量给屏蔽了：

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

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

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

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

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

小结：