本篇文章是对这两天所学的内容做一个总结，涵盖我这两天写的所有笔记：

1. 【Spring】 Spring中的IoC（控制反转）
2. 【Spring】Spring中的DI（依赖注入）Dependence Import
3. 【Spring】bean的基础配置
4. 【Spring】bean的实例化
5. 【Spring】bean的生命周期
6. 【Spring】依赖注入方式，DI的方式
7. 【Spring】使用三方包进行数据源对象（数据库）管理
8. 【Spring】加载properties文件
9. 【Spring】IoC容器的一些总结与补充

1. 控制反转与依赖注入的定义

为什么需要控制反转？

我们在传统写业务层的时候，需要给业务层中的属性通过new操作生成对象。

public class BookServiceImpl implements BookService{

	private BookDao bookDao = new BookDaoImpl();
	
	public void save(){
		bookDao.save()
	}
}

假如某一天我不再希望使用BookDaoImpl这个实现类，而是希望使用BookDaoImpl2这个实现类，我们就需要再次修改代码，重新修改BookServiceImpl中bookDao属性的初始化。这样子的修改方式就不是太合理，耦合度较高。
如果我们可以将这种主动式产生对象转换为由外部指定产生对象，就可以减少这种修改，降低耦合度，通俗的说，就是将对象的创建控制权由程序转移到外部，这就是控制反转(IoC, Inversion of Control)。

Spring中怎么做控制反转？

Spring实现了IoC，此处介绍基于配置来写IoC：

第一步：pom.xml引入相关依赖

引入相关依赖，刷新maven：

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
</dependency>

第二步：在Resource文件下创建Spring Config File（也就是配置IoC容器的内容），并配置bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--1. 导入spring的坐标spring-context-->

    <!--2. 配置bean-->
    <!--bean标签标示配置bean
    id属性标示给bean起名字
    class属性标示给bean定义的类型
    -->
    <bean id="bookDao" class="com.example.demo231116.dao.impl.BookDaoImpl" />

    <bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl" />
</beans>

第三步：在代码中调用IoC容器，并获取具体的bean

public class Demo231116Application2 {
    public static void main(String[] args) {
        // 3. 获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 4. 获取bean
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

为什么需要依赖注入？

在上面给出的BookServiceImpl.java代码中，有一个bookDao的属性，我们定义为：

private BookDao bookDao = new BookDaoImpl();

我们想要通过IoC去管理bean，为了真正实现解耦，我们不再保留new形式创建的Dao对象，这时候我们就需要使用依赖注入来完成这一点

如何进行依赖注入？

思考两个问题：

1. Service中需要的Dao对象如何进入到Service中？（提供方法，使得我们可以修改Service中的Dao对象）
2. Service与Dao间的关系如何描述？（通过配置的形式来描述）
   基于以上两个问题及答案，我们总结了不同的注入方式

Setter注入引用类型和简单类型

第一步：删除ServiceImpl中的new创建方式，建立set方法，使得可以对ServiceImpl中的属性做修改

public class BookServiceImpl implements BookService {
	// 删除原本的new方法，给bookDao设置一个setter方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    private BookDao bookDao;
	private String bookName;

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

}

第二步：在配置文件中写明使用什么类别给bookDao属性做注入

在配置文件中，在bookService的bean内部配置property，该标签表示配置当前bean的属性，其中name表示配置哪一个具体属性，ref表示引用类型参照的具体bean，value则是简单类型的对应值

<?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="com.example.demo231116.dao.impl.BookDaoImpl" />

    <bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
        <property name="bookName" value="bkName!!!" />
    </bean>
</beans>

第三步：测试

运行如下代码：

public class Demo231116Application2 {
    public static void main(String[] args) {
        // 获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

结果为：

book service save... bookName:bkName!!!
book dao save...

构造器注入简单类型和引用类型

第一步：删除ServiceImpl中的new创建方式，无需set方法，通过构造方法对ServiceImpl中的属性做修改

public class BookServiceImpl implements BookService {

    private BookDao bookDao;
	private String bookName;

	// 删除原本的new方法，给bookDao设置一个setter方法
	public BookServiceImpl(BookDao bookDao, String bookName){
		this.bookDao = bookDao;
		this.bookName = bookName;
	}

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

第二步：在配置文件中写明使用什么类别给构造方法

在配置文件中，在bookService的bean内部配置constructor-arg，该标签表示构造方法的参数，其中name表示配置哪一个具体属性，ref表示引用类型参照的具体bean，value则是简单类型的对应值

<?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="com.example.demo231116.dao.impl.BookDaoImpl" />

    <bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="bookName" value="bkName!!!" />
    </bean>
</beans>

第三步：测试

运行如下代码：

public class Demo231116Application2 {
    public static void main(String[] args) {
        // 获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

结果为：

book service save... bookName:bkName!!!
book dao save...

构造器注入的参数适配（了解，通常不用这些方法）

• 配置中使用constructor-arg的标签type属性按形参类型注入（为了解耦，避免配置和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="com.example.demo231116.dao.impl.BookDaoImpl" />

    <bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl">
        <constructor-arg type="com.example.demo231116.dao.bookDao" ref="bookDao"/>
        <constructor-arg type="java.lang.String" value="bkName!!!" />
    </bean>
</beans>

• 配置中使用constructor-arg的标签index属性按形参位置注入（为了解决有同样类型的参数的问题）

<?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="com.example.demo231116.dao.impl.BookDaoImpl" />

    <bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl">
        <constructor-arg index="0" ref="bookDao"/>
        <constructor-arg index="1" value="bkName!!!" />
    </bean>
</beans>

依赖注入方式选择

建议使用setter注入
第三方技术根据情况选择

依赖自动装配，通过autowire属性指定类型

根据bean所依赖的资源在容器中自动查找并注入到bean的过程为自动装配
自动装配的方式通过autowire指定，有四种类型：

• 按类型（常用）
• 按名称
• 按构造方法
• 不启用自动装配

注意，想要让IoC容器实现自动装配，必须给这些属性配置setter方法！

按类型注入：autowire="byType"

此时配置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 id="bookDao" class="com.example.demo231116.dao.impl.BookDaoImpl" />
    <bean id="userDao" class="com.example.demo231116.dao.impl.UserDaoImpl" />

    <bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl" autowire="byType" />
</beans>

bean的类型指向必须唯一！，推荐使用。
假如配置了两个指向同一类型，id不同的bean，执行报错会提示找到了两个bean，不知道匹配哪一个。

按名称注入：autowire="byName"

此时配置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 id="bookDao" class="com.example.demo231116.dao.impl.BookDaoImpl" />
    <bean id="userDao" class="com.example.demo231116.dao.impl.UserDaoImpl" />

    <bean id="bookService" class="com.example.demo231116.service.impl.BookServiceImpl" autowire="byName" />
</beans>

属性的名称要能够在配置的bean中的id对应的上。此方式因变量名与配置耦合，不推荐使用。

自动装配注意事项

• 自动装配用于引用类型依赖注入，不能对简单类型操作（因为简单类型你可以有很多不同的值，除非一个一个写）
• 自动装配优先级低于setter注入和构造器注入，同时出现时自动装配无效

集合注入

关于array、list、set、map、properties的注入
假如BookDaoImpl.java代码如下：

package com.example.demo.dao.impl;

import com.example.demo.dao.BookDao;

import java.util.*;

public class BookDaoImpl implements BookDao {

    private int[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String, String> map;
    private Properties properties;

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

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setArray(int[] array) {
        this.array = array;
    }
}

在集合中注入简单类型——value

配置文件需要如下配置：

<bean id="bookDao" class="com.example.demo.dao.impl.BookDaoImpl">
    <property name="array">
        <array>
            <value>100</value>
            <value>200</value>
            <value>300</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>a</value>
            <value>b</value>
            <value>c</value>
        </list>
    </property>
    <property name="set">
        <set>
            <value>c</value>
            <value>c</value>
            <value>d</value>
        </set>
    </property>
    <property name="map">
        <map>
            <entry key="country" value="china" />
            <entry key="province" value="guangdong" />
            <entry key="city" value="shenzhen" />
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="country">china</prop>
            <prop key="province">henan</prop>
            <prop key="city">kaifeng</prop>
        </props>
    </property>
</bean>

其中，set属性自动过滤元素，如果执行以下java代码：

public class Demo231116Application2 {
    public static void main(String[] args) {
        // 获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

则结果如下：

book service save...
book dao save...
遍历数组：[100, 200, 300]
遍历List：[a, b, c]
遍历set：[c, d]
遍历Map：{country=china, province=guangdong, city=shenzhen}
遍历properties：{country=china, province=henan, city=kaifeng}

在集合中注入引用类型——ref

只需去掉简单类型的value属性，使用ref属性

<bean id="bookDao" class="com.example.demo.dao.impl.BookDaoImpl">
    <property name="array">
        <array>
            <ref bean="beanId" />
            <ref bean="beanId" />
            <ref bean="beanId" />
        </array>
    </property>
</bean>

控制反转与依赖注入的关系

这部分我也思考了一下，认为网上有句话说的很对：简单地说，控制反转是一种设计思想，而依赖注入是控制反转思想的一种实现方式。
我认为，实际上控制反转就是我们将已有的类别放置到IoC容器中，便于让外部进行处理。而依赖注入是真正将具体的类别给属性完成注入的方式。

2. bean的配置

bean的别名配置——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" name="dao" class="com.example.demo231116.dao.impl.BookDaoImpl" />
    
</beans>

这样，当我们在主代码里调用ctx.getBean("bookDao")和ctx.getBean("dao")，起到的效果是相同的：

package com.example.demo231116;

import com.example.demo231116.dao.BookDao;
import com.example.demo231116.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo231116Application2 {
    public static void main(String[] args) {
        // 获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao = (BookDao) ctx.getBean("dao");
        bookDao.save();
    }
}

bean的单例多例——scope属性配置

若保持别名配置里那样的bean配置，我们生成出来的bean是单例的，当我们执行以下代码：

BookDao bookDao = (BookDao) ctx.getBean("dao");
BookDao bookDao1 = (BookDao) ctx.getBean("dao");
System.out.println(bookDao);
System.out.println(bookDao1);

会得到结果：

com.example.demo231116.dao.impl.BookDaoImpl@309e345f
com.example.demo231116.dao.impl.BookDaoImpl@309e345f

两个对象出自同一个实例，但如果我们不希望它是以单例形式创建，而是以多例形式创建的时候，我们需要配置scope属性：

<?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" name="dao" class="com.example.demo231116.dao.impl.BookDaoImpl" scope="prototype" />
    
</beans>

scope有两个属性：singleton单例(默认)，prototype非单例
配置scope属性后再执行上面的代码，会得到结果：

com.example.demo231116.dao.impl.BookDaoImpl@309e345f
com.example.demo231116.dao.impl.BookDaoImpl@56a6d5a6

两个对象不出自同一个实例

bean为什么默认为单例？

如果每创建一个对象，都是不同的实例，那么对内存的消耗会很大

bean的作用范围说明

适合交给容器管理的bean：表现层对象、业务层对象、数据层对象、工具对象
不适合交给容器管理的bean：封装实体的域对象

bean的实例化

构造方法

当我们在Spring Config文件中配置：

<bean id="bookDao" name="dao" class="com.example.demo231116.dao.impl.BookDaoImpl" />

这种bean的实例化默认调用无参构造方法，对于写有参构造，对有参构造中参数的注入则是上面依赖注入的部分

静态工厂

假如写了一个BookDao工厂BookDaoFactory.java：

package com.example.demo231116.factory;

import com.example.demo231116.dao.BookDao;
import com.example.demo231116.dao.impl.BookDaoImpl;

public class BookDaoFactory {
    public static BookDao getBookDao(){
        System.out.println("Factory method....");
        return new BookDaoImpl();
    }
}

我们想让bean通过调用这个工厂方法返回里面的BookDaoImpl，则需要如下配置：

<bean id="bookDaoFactory" class="com.example.demo231116.factory.BookDaoFactory" factory-method="getBookDao" />

id属性和class属性与之前差异不大，分别为bean名称和bean类别，而factory-method指定具体地工厂方法

实例工厂

注意：实例工厂与静态工厂的区别是，实例工厂中的方法不是静态方法！
静态方法和非静态方法的区别是：

• 静态方法可以在不建立该类对象的情况下，通过类名.方法进行调用
• 非静态方法需要建立该类对象后，通过对象名.方法进行调用

详细可以看第4个笔记中的实验

假如写了一个BookDao工厂BookDaoFactory.java：

package com.example.demo231116.factory;

import com.example.demo231116.dao.BookDao;
import com.example.demo231116.dao.impl.BookDaoImpl;

public class BookDaoFactory {
    public BookDao getBookDao(){
        System.out.println("Factory method....");
        return new BookDaoImpl();
    }
}

在配置文件中需要如下写：

<bean id="bookDaoFactory2" class="com.example.demo231116.factory.BookDaoFactory" />
<bean id="bd" factory-method="getBookDaoUnstatic" factory-bean="bookDaoFactory2"  />

即先建立出工厂类的bean，再建立下面这个使用该工厂方法的bean。factory-method指定其中具体的工厂方法，factory-bean指定工厂方法所属的父类，在最后调用的时候，直接调用bd就可以完成初始化：

BookDao bookDao3 = (BookDao) ctx.getBean("bd");
System.out.println(bookDao3);

在这种方法里，实际上我们创建出的bookFactory2这个bean没有被用到，所以还有如下的方法FactoryBean

FactoryBean

直接写一个工厂方法，implement FactoryBean。FactoryBean是一个泛型方法，指定其中的类型，实现其方法：
第一个getObject()返回具体地对象
第二个getObjectType()返回对象的类型

package com.example.demo231116.factory;

import com.example.demo231116.dao.BookDao;
import com.example.demo231116.dao.impl.BookDaoImpl;
import org.springframework.beans.factory.FactoryBean;

public class BookDaoFactoryBean implements FactoryBean<BookDao>{
    @Override
    public BookDao getObject() throws Exception {
        return new BookDaoImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return BookDao.class;
    }
}

如此，在bean配置中，只需要像原本普通的一行即可：

<bean id="bookDaoFactoryMethod" class="com.example.demo231116.factory.BookDaoFactoryBean" />

注意，当我们执行以下代码后，会发现打印出来的结果相同，说明这是单例模式创建的。

BookDao bookDao4 = (BookDao) ctx.getBean("bookDaoFactoryMethod");
BookDao bookDao5 = (BookDao) ctx.getBean("bookDaoFactoryMethod");
System.out.println(bookDao4);
System.out.println(bookDao5);

如果我们想要该工厂方法返回的不是单例模式，而是不同的实例，则我们需要补充FactoryBean中的isSingleton()方法，当这个方法设置为True时，就是用单例模式创建的对象，如果这个方法返回为False，就不会使用单例模式，每一次构造都会创建出新的对象：

@Override
public boolean isSingleton() {
    return true;
}

bean的生命周期

假如我们希望在建立bean时候执行一些资源的初始化，在bean销毁之前执行一些资源的销毁，我们就会需要考虑到bean的声明周期，通过以下方式进行生命周期的控制。

在类中提供生命周期控制方法，并在配置文件中配置init-method&destroy-method（配置）

定义实现类如下：

package com.example.demo231116.dao.impl;

import com.example.demo231116.dao.BookDao;

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

    public void init(){
        System.out.println("book dao init...");
    }

    public void destroy(){
        System.out.println("book dao destroy...");
    }
}

配置时，我们只需要指定具体的初始化方法init-method和销毁方法destroy-method即可：

<bean id="bookDaoCycle" class="com.example.demo231116.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy" />

这样，当我们在主函数中执行：

// IoC容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

BookDao bookDao = (BookDao) ctx.getBean("bookDaoCycle");
System.out.println(bookDao);

结果是：

book dao init...
com.example.demo231116.dao.impl.BookDaoImpl@5dd6264

这时候的疑问可能是，为什么destroy方法没有被执行？
答案是：在程序执行结束之后，IoC容器还没有执行关闭操作，java虚拟机就已经强行关闭了。那么应该如何在java虚拟机关闭之前执行IoC容器关闭呢？如下有两种方法

通过ctx.close()执行IoC容器关闭

ApplicationContext并没有close方法，ApplicationContext下的一个接口ClassPathXmlApplicationContext才有定义close方法，所以这里想要使用close方法，需要修改IoC容器定义，然后在末尾调用ctx.close()

// IoC容器
ClassPathXmlApplicationContextctx = new ClassPathXmlApplicationContext("applicationContext.xml");

BookDao bookDao = (BookDao) ctx.getBean("bookDaoCycle");
System.out.println(bookDao);

ctx.close()

输出结果为：

book dao init...
com.example.demo231116.dao.impl.BookDaoImpl@5dd6264
book dao destroy...

但是如果是这样的话，ctx.close()只能在程序的末尾写，因为在开头定义结束就写的话，这个IoC容器就被销毁了，也不可能执行一些getBean的操作，还有一个方法是通过注册钩子关闭IoC容器

通过注册关闭钩子执行IoC容器关闭

注册一个关闭钩子，在不用强行关闭IoC容器的情况下，设置在java虚拟机关闭之前让程序执行销毁的方法：

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

BookDao bookDao = (BookDao) ctx.getBean("bookDaoCycle");
System.out.println(bookDao);

这样就不再需要强硬地执行ctx.close()方法了

实现接口来做和init和destroy（接口）

只需要在bean类下多实现InitializingBean和DisposableBean这两个接口，并实现其中的afterPropertiesSet和destroy方法：

package com.example.demo231116.dao.impl;

import com.example.demo231116.dao.BookDao;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

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

    @Override
    public void destroy() throws Exception {
        System.out.println("接口destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("接口init");
    }
}

然后配置bean只需要简单地配置如下：

<bean id="bookDaoCycle" class="com.example.demo231116.dao.impl.BookDaoImpl" />

这个afterPropertiesSet的init方法，是在先执行属性设置后再执行init方法

bean的生命周期执行顺序

• 初始化容器：
  创建对象（内存分配）
  执行构造方法
  执行属性注入（setter注入）
  执行bean的初始化方法
• 使用bean
  执行业务操作
• 关闭/销毁容器
  执行bean的销毁方法

3. 使用第三方包进行数据源的管理（例子：使用com.alibaba.druid进行数据库连接）

第一步：在pom.xml中导入坐标

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.21</version>
</dependency>

第二步：在bean中配置连接

在这里，首先应该查看这个Druid包给我们提供了一些什么方法。
先查看构造方法能否让我们通过构造注入写入一些配置信息，但在具体查看后发现是没有的（详细可见笔记7）。
但观察到可以通过setter注入来写一些配置信息，所以这里就使用setter注入：

<?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="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="jdbc:mysql://localhost:3306/ecommercedb"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>
</beans>

4. 在配置文件中读取properties文件中的属性

第一步：建立jdbc.properties文件，内容如下

jdbc.url=jdbc:mysql://localhost:3306/ecommercedb
jdbc.username=root
jdbc.password=123456
jdbc.driverClassName=com.mysql.jdbc.Driver

第二步：开启context命名空间

我理解需要开辟新的命名空间，是读取非工程文件中的内容，而是读取外部文件中的内容

第三步：使用context命名空间加载指定properties文件

在这一步中需要通过location写清楚加载properties文件的位置

第四步：使用${}读取加载的属性值

第二——第四步具体代码如下，最终只需要通过${}读取加载的属性值即可：

<?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="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.url}" />
    </bean>
</beans>

其他问题

1. 假如在配置文件中写的是username=root，而不是jdbc.username=root，则可能使用${username}得到的结果并不会是root
   是因为系统环境变量里面有和properties里面定义的变量重名，则properties里面的变量不会被加载，也就是说系统环境变量的优先级会比properties里面的变量优先级高。
   为了使用properties里面面的变量，而不是系统环境变量，我们可以对xml配置文件，让系统环境变量不被使用：

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

2. 加载多个properties文件可以用逗号分隔

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

3. 加载所有properties文件可以用正则*.properties

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

4. 以上写法不够标准，标准的是classpath:*.properties

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

5. 如果不止要从工程中加载properties文件，还要从jar包等中加载，则写classpath*:*properties

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

第4、5种根据不同的需求来写

5. 关于IoC容器其他内容的总结与补充

创建容器的两种方式

相对路径导入

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

绝对路径导入

ApplicationContext ctx = new FileSystemXmlApplicationContext("E:\\Code\\Java\\SpringStudy\\project1\\src\\main\\resources\\applicationContext.xml");

获取Bean的三种方式

获取后强转类型

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

在获取时指定类型

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

通过类型获取Bean

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

容器类层次结构图

BeanFactory

这是最早的加载IoC容器的方法，使用BeanFactory的方法如下：

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

BeanFactory与我们现在ApplicationContext的区别在于：
BeanFactory是延迟加载bean，ApplicationContext是立即加载bean
即前者在没有getBean的时候是不会提前执行类的构造方法的，而Application就算没有getBean也会执行构造方法
如果想在ApplicationContext上实现延迟加载bean，只需要加参数：lazy-init="true"：

<bean id="bookDao" class="com.example.project1.dao.impl.BookDaoImpl" lazy-init="true"/>

6. 复习内容