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

发布于：2023-01-22 ⋅ 阅读:(373) ⋅ 点赞:(0)

目录

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

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布