Spring——IOC（Spring程序开发步骤）

目录

1、Spring程序开发步骤

1.1、导入Spring开发的基本包坐标

1.2、编写Dao接口和实现类

1.3、创建Spring核心配置文件

1.4、测试程序

2、Bean标签范围配置

2.1、scope属性

2.2、Bean实例化时机 

2.3、Bean生命周期配置

2.4、实例化Bean的三种方式

3、Spring依赖注入

3.1、依赖注入第一种方式（set方法）

3.2、依赖注入第二种方式定义命名空间

3.3、依赖注入的第三种方式（有参构造方法）

3.4、Spring注入的数据类型

3.5、引入其他配置文件(分模块开发)

4、Spring相关API

4.1、ApplicationContext的实现类

4.2、getBean()方法的使用

5、Spring配置数据源(连接池)

5.1、数据源（连接池）的作用

5.2、数据源开发步骤

5.3、抽取jdbc.properties文件

5.4、使用Spring创建数据源对象

---

前言：本次整理内容为黑马视频课程，进行笔记整理。 

1、Spring程序开发步骤

1、导入Spring开发的基本包坐标。

2、编写Dao接口和实现类。

3、创建Spring核心配置文件。

1.1、导入Spring开发的基本包坐标

首先我们需要创建一个Maven工程，在pom文件中导入Spring的坐标

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itssl</groupId>
    <artifactId>spring_01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>

</project>

1.2、编写Dao接口和实现类

在包路径下创建dao层和实现类，并编写一个方法show()用来测试

UserDao接口

public interface UserDao {
    void show();
}

UserDaoImpl类

public class UserDaoImpl implements UserDao {
    //重写show()方法
    public void show() {
        System.out.println("show running....");
    }
    //无参构造
    UserDaoImpl(){
        System.out.println("无参构造...");
    }
    
}

1.3、创建Spring核心配置文件

用于配置对象交由Spring来创建。

默认情况下它调用的是类中无参构造函数，如果没有无参构造函数则不能创建成功。

在resources文件中创建一个xml文件，命名为ApplicationContext（推荐命名，可以自定义）

<?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="UserDao" class="cn.itssl.dao.Impl.UserDaoImpl"></bean>
</beans>

<bean>标签中的属性介绍： 

id：Bean实例在Spring容器中的唯一标识。

class：Bean的全限定名称。 

注意：这里的bean标签里id名可以随意起，这里是为了方便测试直接起成UserDao，class里填写的就是UserDaoImpl的路径，为了避免书写错误，可以右键UserDaoImpl点击Copy Reference，直接粘贴过去。

1.4、测试程序

我们在测试包下创建一个测试类，用来测试。

 

利用多态进行创建ApplicationContext对象，ClassPathXmlApplicationContext中填入xml配置文件。获取到app对象，通过app的方法getBean方法创建UserDao对象。 

public class userDaoTest {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("UserDao");
        System.out.println(userDao); 
    }
}

2、Bean标签范围配置

2.1、scope属性

在实际开发中，可能需要用到的对象有不同的模式，其中就有单例模式和多例模式，在之前我们都是通过工厂创建单例或者多例，那么在Spring中如何控制单例和多例呢？

在bean标签中，有一个属性可以控制scope，有两个关键词，一个为singleton（单例）、prototype（多例）。

scope属性中关键词：

取值范围	说明
singleton	默认值，单例模式
prototype	多例模式

单例模式演示

<?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="UserDao" class="cn.itssl.dao.Impl.UserDaoImpl" scope="singleton"></bean> 
   

 测试类我们通过getBean获取两个userDao对象，看看地址值是否一样

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

可以看出，地址值是一模一样的，说明这就是单例模式。

多例模式演示

<?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="UserDao" class="cn.itssl.dao.Impl.UserDaoImpl" scope="prototype"></bean> 
   

可以发现这次的地址值不一样了，那么说明就是多例模式了。

2.2、Bean实例化时机 

1、当scope的取值为singleton时

Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

Bean的生命周期：

对象创建：当应用加载，创建容器时，对象就被创建了。

对象运行：只要容器在，对象一直活着。

对象销毁：当应用卸载，销毁容器时，对象就销毁了。

2、当scope的取值为prototype时

Bean的实例化时机：当调用getBean()方法时实例化Bean

对象创建：当使用对象时，创建新的对象实例。

对象运行：只要对象在使用中，就会一直活着。

对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了。

2.3、Bean生命周期配置

为了方便看到bean何时被创建，何时被销毁，我们在实现类中写两个方法，分别是initialization方法和destroy方法，这两个方法命名随意。

userDaoImpl实现类

    public void show() {
        System.out.println("show running....");
    }
    public UserDaoImpl(){
        System.out.println("无参构造...");
    }
    //初始化方法
    public void initialization(){
        System.out.println("初始化...");
    }
    //销毁方法
    public void destroy(){
        System.out.println("销毁");
    }

 那么如何让这两个方法生效呢，就用bean去管理它，配置xml中bean标签中的属性init-method（初始化方法）和destory-method（销毁方法）。属性中填写的就是你写的方法名

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="userDao" class="cn.itssl.dao.Impl.UserDaoImpl" init-method="initialization" destroy-method="destroy"></bean>
</beans>

测试类 

public class userDaoTest2 {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
    }
}

可以看到无参构造先被执行，然后运行初始化方法，最后输出对象。那么销毁方法怎么没有输出呢？因为 ApplicationContext没有close方法，而它的子类ClassPathXmlApplicationContext有close关闭方法，所以我们需要手动去关闭bean，我们直接创建ApplicationContext的子类对象，最后调用ClassPathApplication的close方法。

public class userDaoTest2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
        app.close();
    }
}

 可以看到最后执行了销毁方法。

2.4、实例化Bean的三种方式

1、无参构造方法实例化（上面代码已演示）

2、工厂静态方法实例化

3、工厂实例方法实例化

4、FactoryBean方式实例化

1、工厂静态方法实例化

我们需要再创建一个包为factory的工厂包，用来存放工厂类

创建StaticFactory类 

public class StaticFactory {
    //静态方法
    public static UserDao getUserDao(){
        //返回userDao的实现类对象
        return new UserDaoImpl();
    }
}

配置ApplicationContext.xml文件

class路径选择工厂类，然后添加属性factory-method，书写静态实例化方法名，因为静态方法是属于类的，所以可以写工厂类路径，通过factory-method获取方法。

<?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="userDao" class="cn.itssl.factory.StaticFactory" factory-method="getUserDao"></bean>
</beans>

测试类

public class userDaoTest3 {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext1.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
    }
}

工厂静态实例化成功运行！

2、工厂实例方法实例化

我们再在factory包下创建一个DynamicFactory类

DynamicFactory类

public class DynamicFactory {
    //非静态方法
    public UserDao getUserDao() {
        return new UserDaoImpl();
    }
}

ApplicationContext.xml配置文件 

因为getUserDao现在不属于类了，所以我们需要先配置一个bean来获取工厂类对象，class里书写的是DynamicFactory类的路径，然后再创建一个bean使用factory-bean来接收工厂类对象factory，然后通过factory-method属性获取getUserDao方法，这里可能会有点绕，反复理解一下，静态是属于类，非静态是不属于类，所以非静态需要多做一步操作，就是用一个bean先去创建类对象，再由另一个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">

    <bean id="factory" class="cn.itssl.factory.DynamicFactory"></bean>
    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>

</beans>

测试类

public class userDaoTest4 {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext2.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
    }
}

3、 FactoryBean方式实例化

首先创建一个类FactoryBeanTest，去实现FactoryBean接口，重写getObject()方法和getObjectType()方法，在getObject方法中返回UserDaoImpl对象

public class FactoryBeanTest implements FactoryBean<UserDao> {
    //返回bean对象
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return null;
    }
}

配置xml文件，路径选择factory包下的FactoryBeanTest类，注意：此地不用再创建另一个bean去接收这个userDao2的bean，因为FactoryBean接口会自动为我们实现 

    <!--FactoryBean方式-->
    <bean id="userDao2" class="cn.itssl.factory.FactoryBeanTest"/>

测试类 

public class userDaoTest3 {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext1.xml");
        //FactoryBean实例化bean
        UserDao userDao2 = (UserDao) app.getBean("userDao2");
        System.out.println(userDao2);
    }
}

3、Spring依赖注入

在MVC三层架构中，当我们的userDao和userService以及web层的Controller层进行调用方法时，每次都必须在Service层手动创建一个userDao对象，为了让Spring容器去管理userDao对象，就需要依赖注入的方式来实现。

3.1、依赖注入第一种方式（set方法）

创建service包，里面创建一个接口UserService和一个实现类UserServiceImpl类

UserService接口

public interface UserService {
    void show();
}

UserServiceImpl实现类 

public class UserServieImpl implements UserService {
    private UserDao userDao;
    //注入方式  通过set方法注入到bean
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void show() {
        userDao.show();
    }
}

创建一个web包，并且创建一个Controller类，用来模拟web业务。 

 

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext3.xml");
        UserService userService = (UserService) app.getBean("userService");
        userService.show();
    }
}

这里我们运行会成功创建userDao对象吗？还是不能的，因为我们通过set方法注入还没有告诉Spring，Spring不知道要进行注入，所以我们需要在ApplicationContext配置文件中进行配置。

<?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="user_Dao" class="cn.itssl.dao.Impl.UserDaoImpl"></bean>
    <bean id="userService" class="cn.itssl.service.Impl.UserServieImpl">
        <property name="userDao" ref="user_Dao"></property>
    </bean>
</beans>

注意：这里的userService的bean中注入userDao，property里面填写的是属性名，也就是说set方法后面首字母小写的名称，比如set方法名为setUserDao，所以这里就填userDao（去掉set，并且把User中的U小写，所以就写userDao），而ref填写的是就是userDao的bean，也就是第一个bean(这里我是为了区分故意把userDao改为了user_Dao)。

现在，我们就启动userController，可以看到启动成功。

3.2、依赖注入第二种方式定义命名空间

上面在配置文件时在注入userDao时需要在userService的bean下注入property，这样写有点麻烦，所以有简单的方式

我们在配置文件上面beans中加入一行约束，

xmlns:p="http://www.springframework.org/schema/p"

然后在userService的bean中直接写p:userDao-ref，填写userDao的id名就可以了，ref代表对象的引用。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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="user_Dao" class="cn.itssl.dao.Impl.UserDaoImpl"></bean>
    <!--<bean id="userService" class="cn.itssl.service.Impl.UserServieImpl">-->
        <!--<property name="userDao" ref="user_Dao"></property>-->
    <!--</bean>-->
    <bean id="userService" class="cn.itssl.service.Impl.UserServieImpl" p:userDao-ref="user_Dao"></bean>
</beans>

3.3、依赖注入的第三种方式（有参构造方法）

在userServiceImpl中把set方法注释，加入有参和无参构造方法

public class UserServieImpl implements UserService {
    private UserDao userDao;
    //注入方式  通过set方法注入到bean
    // public void setUserDao(UserDao userDao) {
    //     this.userDao = userDao;
    // }

    public UserServieImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    public UserServieImpl() {
    }

    public void show() {
        userDao.show();
    }
}

然后在ApplicationContext配置文件中进行配置bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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="user_Dao" class="cn.itssl.dao.Impl.UserDaoImpl"></bean>
    <!--<bean id="userService" class="cn.itssl.service.Impl.UserServieImpl">-->
        <!--<property name="userDao" ref="user_Dao"></property>-->
    <!--</bean>-->
    <!--<bean id="userService" class="cn.itssl.service.Impl.UserServieImpl" p:userDao-ref="user_Dao"></bean>-->
    <bean id="userService" class="cn.itssl.service.Impl.UserServieImpl">
       <constructor-arg name="userDao" ref="user_Dao"></constructor-arg>
    </bean>
</beans>

注意：constructor-arg标签中的name指的是有参构造中的参数userDao，而ref指的是userDao的bean中的属性id名。

3.4、Spring注入的数据类型

1、普通数据类型

我们在userDaoImpl加入两个普通数据类型变量，username和age，并创建它们的set方法

public class UserDaoImpl implements UserDao {
    private String username;
    private int age;

    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show() {
        System.out.println(username+":"+age);
        System.out.println("show running....");
    }

    public UserDaoImpl(){
        System.out.println("无参构造...");
    }
    public void initialization(){
        System.out.println("初始化...");
    }
    public void destroy(){
        System.out.println("销毁");
    }
}

配置ApplicationContext文件，在userDao的bean标签中注入两个property，因为username和age都是普通变量，所以不用写ref（ref是对象的引用）这里写value对它们进行赋值。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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="user_Dao" class="cn.itssl.dao.Impl.UserDaoImpl">
        <property name="username" value="zhangsan"></property>
        <property name="age" value="20"></property>
    </bean>
    <!--<bean id="userService" class="cn.itssl.service.Impl.UserServieImpl">-->
        <!--<property name="userDao" ref="user_Dao"></property>-->
    <!--</bean>-->
    <!--<bean id="userService" class="cn.itssl.service.Impl.UserServieImpl" p:userDao-ref="user_Dao"></bean>-->
    <bean id="userService" class="cn.itssl.service.Impl.UserServieImpl">
        <constructor-arg name="userDao" ref="user_Dao"></constructor-arg>
    </bean>
</beans>

 运行Controller类

2、引用数据类型（3.2已经演示过，这里就不再演示）

3、集合数据类型

我们需要在userDaoImpl中加入三个集合，分别是List、Map、Properties，这也是Java基础中最常用的三个集合类型。

public class UserDaoImpl implements UserDao {
    private List<String> strList;
    private Map<String, User> userMap;
    private Properties properties;

    public void setStrList(List<String> strList) {
        this.strList = strList;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

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

   
    public void show() {
        System.out.println(strList);
        System.out.println(userMap);
        System.out.println(properties);
        System.out.println("show running....");
    }

    public UserDaoImpl(){
        System.out.println("无参构造...");
    }
    public void initialization(){
        System.out.println("初始化...");
    }
    public void destroy(){
        System.out.println("销毁");
    }
}

配置ApplicationContext文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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="user_Dao" class="cn.itssl.dao.Impl.UserDaoImpl">
        <property name="strList">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
        <property name="userMap">
            <map>
                <entry key="user1" value-ref="u1"></entry>
                <entry key="user2" value-ref="u2"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="p1">111</prop>
                <prop key="p2">222</prop>
                <prop key="p3">333</prop>
            </props>
        </property>
    </bean>
    <bean id="u1" class="cn.itssl.domain.User">
        <property name="name" value="jack"/>
        <property name="addr" value="zhengzhou"/>
    </bean>
    <bean id="u2" class="cn.itssl.domain.User">
        <property name="name" value="rose"/>
        <property name="addr" value="shanghai"/>
    </bean>
   
    <bean id="userService" class="cn.itssl.service.Impl.UserServieImpl">
        <constructor-arg name="userDao" ref="user_Dao"></constructor-arg>
    </bean>
</beans>

运行Controller类

3.5、引入其他配置文件(分模块开发)

创建一个user和product的配置文件，那么如何让ApplicationContext主配置文件也可以生效user和product配置的内容呢？需要用到import标签进行导入。

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

<import resource="ApplicationContext-user.xml"/>
<import resource="ApplicationContext-product.xml"/>
</beans>

4、Spring相关API

4.1、ApplicationContext的实现类

ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件推荐使用这种。

FileSystemXmlApplicatioinContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

AnnotationConfigApplicationContext：当使用注解配置容器对象时，需要使用此类来创建Spring容器，它用来读取注解。

ClassPathXmlApplicationContext就不再演示了，之前都是用这个进行加载的

如果用到FileSystemApplicationContext来进行加载，就需要填写配置文件的全路径，这里建议直接进行复制，如下图。

public class UserController {
    public static void main(String[] args) {
        // ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext3.xml");
        ApplicationContext app=new FileSystemXmlApplicationContext("E:\\java\\Sping\\spring_01\\src\\main\\resources\\ApplicationContext3.xml");
        UserService userService = (UserService) app.getBean("userService");
        userService.show();
    }
}

4.2、getBean()方法的使用

之前我们通过getBean方法都是传递一个bean标签id值获取对象，但是这种方式有一点麻烦就是还要进行强制转换为我们想要的类型，而getBean还可以传递类型.class的形式。

public class UserController {
    public static void main(String[] args) {
        // ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext3.xml");
        ApplicationContext app=new FileSystemXmlApplicationContext("E:\\java\\Sping\\spring_01\\src\\main\\resources\\ApplicationContext3.xml");
        // UserService userService = (UserService) app.getBean("userService");
        UserService userService = app.getBean(UserService.class);
        userService.show();
    }
}

注意事项：

虽然这两种方式都可以从Spring容器获取对象，但是这两种方式还是有区别的：

当参数的数据类型是字符串时，表示根据Bean的id从容器中获取Bean实例，返回的是Object类型，需要进行强制转换。

当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的bean有多个时，则此方法就会报错。

5、Spring配置数据源(连接池)

5.1、数据源（连接池）的作用

1、数据源（连接池）是提高程序性能出现的。

2、事先实例化数据源，初始化部分连接资源。

3、使用连接资源时从数据源中获取。

4、使用完毕后将连接资源归还给数据源。

常见的数据源（连接池）有：DBCP、C3P0、BoneCP、Druid等 。

5.2、数据源开发步骤

1、导入数据源的坐标和数据库驱动坐标。

2、创建数据源对象。

3、设置数据源的基本连接数据。

4、使用数据源获取连接资源和归还连接资源。

<dependencies>
        <!--mysql连接依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--c3p0的依赖-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.1</version>
        </dependency>
        <!--druid依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <!--junit测试依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
    </dependencies>

在测试模块包下创建一个测试类

c3p0的测试 

注意：这里的用户密码根据自己的mysql用户密码进行更改，以及数据库这里我写的是test1，是在mysql数据库里已经存在的。 

public class DataSourceTest {
    @Test
    public void test() throws Exception {
        //测试手动创建c3p0数据源
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test1?useSSL=false");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
}

druid测试

@Test
    public void test2() throws Exception{
        //测试手动创建Druid数据源
        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test1?useSSL=false");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

5.3、抽取jdbc.properties文件

上面的开发步骤存在一些问题，就是耦合性太高，为了方便以后的维护管理，我们需要把配置信息抽取到一个配置文件中去，这样可以方便我们管理。

在resources包下创建一个jdbc.propertes文件，填写自己的数据库信息。

jdbc.Driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test1?useSSL=false
jdbc.user=root
jdbc.password=root

通过ResourceBundle类获取文件信息 

@Test
    public void test3() throws Exception{
        //测试手动创建Druid数据源（读取properties文件）
        ResourceBundle rb=ResourceBundle.getBundle("jdbc");
        String driver = rb.getString("jdbc.Driver");
        String url = rb.getString("jdbc.url");
        String username = rb.getString("jdbc.user");
        String password = rb.getString("jdbc.password");
        //创建数据源对象  设置连接参数
        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

5.4、使用Spring创建数据源对象

1、导入spring坐标

 <!--spring容器依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

2、创建配置文件

<?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="driverClassName" value="com.mysql.jdbc.Driver"></property>
           <property name="url" value="jdbc:mysql://localhost:3306/test1?useSSL=false"></property>
           <property name="username" value="root"></property>
           <property name="password" value="root"></property>
       </bean>
</beans>

注意：这里的class以及其下的property属性标签里面用到的是测试类里druid的数据源。

3、测试类进行测试

  @Test
    public void test4() throws Exception{
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) app.getBean("dataSource");
        Connection con = dataSource.getConnection();
        System.out.println(con);
        con.close();
    }