开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Spring整合Mybatis之DAO层、Service层开发 -> 正文阅读

[Java知识库]Spring整合Mybatis之DAO层、Service层开发

3. Spring整合Mybatis编程DAO层开发

1. 项目引入相关依赖

	spring   mybatis   mysql   mybatis-spring   druid

2. 编写spring.xml
	
	整合：spring 接管 mybatis 中 SqlSessionFactory对象的创建
	
    <!--创建DataSource-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/lb"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--创建sqlSessionFactory-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <!--依赖数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
3. 建表

4. 实体类
	
5. DAO接口
	public interface UserDAO {
    List<User> findAll();
	}
	
6. 开发Mapper
	<mapper namespace="com.baizhi.dao.UserDAO">

    <select id="findAdd" resultType="com.baizhi.eneity.User">
        select id, name, age, bir from t_user
    </select>
	</mapper>

	注意：开发完mapper文件后一定要在spring.xml中注册
	<!--创建sqlSessionFactory-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <!--依赖数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--注册mapper配置文件-->
        <property name="mapperLocations">
            <array>
                <value>classpath:com/baizhi/mapper/UserDAOMapper.xml</value>
            </array>
        </property>
    </bean>
    
7. 启动工厂获取SqlSessionFactory

    ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    SqlSessionFactory sqlSessionFactory = (SqlSessionFactory) context.getBean("sqlSessionFactory");
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserDAO userDAO = sqlSession.getMapper(UserDAO.class);
    userDAO.findAll().forEach(user -> {System.out.println(user);});
    
    再进一步可以直接在工厂中注册SqlSessionFactory、注册DAO组件类，
    并且在DAO组件里面注入SqlSessionFactory和DAO接口的类型，这样就可以使用spring工厂直接获取UserDAO组件类了
    不用再获取SqlSessionFactory了
    
    ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    UserDAO userDAO = (UserDAO) context.getBean("userDAO");

接下来我们来整合mybatis和spring并一步一步的开发DAO层：

首先，我们新建一个模块，使用标准的包结构

在这里插入图片描述

之后我们要在pom.xml文件中引入依赖

spring mybatis mysql mybatis-spring druid

<!--spring核心及相关依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-expression</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>

<!--mysql-->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.38</version>
</dependency>

<!--mybatis-->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.4</version>
</dependency>

<!--mybatis-spring-->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>2.0.4</version>
</dependency>

<!--druid-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.19</version>
</dependency>

在数据库中建表

在这里插入图片描述

创建实体类

public class User {

    private String id;
    private String name;
    private Integer age;
    private Date bir;

    public User() {
    }

    public User(String id, String name, Integer age, Date bir) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.bir = bir;
    }

    // 成员变量的set、get方法以及类的to_String方法在博客中没有，是为了避免占用太多篇幅，但是这里其实是有的
    // 大家写的时候一定要写上
}

在这里插入图片描述

创建DAO接口

public interface UserDAO {
    List<User> findAll();
}

在这里插入图片描述

写Mapper配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.baizhi.dao.UserDAO">
    
    <!--查询表中所有记录-->
    <select id="findAll" resultType="com.baizhi.eneity.User">
        select id, name, age, bir from t_user
    </select>
    
    
</mapper>

在这里插入图片描述

编写spring.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">


    <!--创建DataSource-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/lb"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--创建sqlSessionFactory-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
    <!--因为使用了mybatis官方的创建SqlSessionFactory对象的工具类，所以不能使用mybatis的主配置文件了，
     主配置文件最重要的是数据源+mapper，所以我们要在这里写上数据源和mapper配置-->
    <!--依赖数据源-->
    <property name="dataSource" ref="dataSource"/>
    <!--注册mapper配置文件-->
    <property name="mapperLocations">
        <array>
            <value>classpath:com/baizhi/mapper/UserDAOMapper.xml</value>
        </array>
    </property>
    </bean>


</beans>

在这里插入图片描述

测试和结果

在这里插入图片描述

最后我们来说一个优化

对于我们来说，我们不关心SqlSessionFactory如何获取SqlSession的，也不关心SqlSession如何获取获取DAO接口的，我们关心能否一步就获得想要的DAO接口呢，这是可以的，我们先在工厂中注册SqlSessionFactory对象，因为SqlSessionFactory可以获取SqlSession对象，然后传入DAO接口类型就获得了DAO接口对象；然后我们可以在工厂中创建一个DAO组件类，注入SqlSessionFactory对象和DAO接口类型就可以直接获得DAO对象了，这个类就是mybatis-spring包中的MapperFactoryBean类

配置文件

<!--创建DataSource-->
<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/lb"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

<!--创建sqlSessionFactory-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
    <!--因为使用了mybatis官方的创建SqlSessionFactory对象的工具类，所以不能使用mybatis的主配置文件了，
     主配置文件最重要的是数据源+mapper，所以我们要在这里写上数据源和mapper配置-->
    <!--依赖数据源-->
    <property name="dataSource" ref="dataSource"/>
    <!--注册mapper配置文件-->
    <property name="mapperLocations">
        <array>
            <value>classpath:com/baizhi/mapper/UserDAOMapper.xml</value>
        </array>
    </property>
</bean>

<!--创建DAO组件类-->
<bean class="org.mybatis.spring.mapper.MapperFactoryBean" name="userDAO">
    <!--注入SqlSessionFactory-->
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    <!--注入创建的DAO接口的类型  注入接口的全限定名  包.接口名-->
    <property name="mapperInterface" value="com.baizhi.dao.UserDAO"/>
</bean>

在这里插入图片描述

测试和结果

public class TestUserDAO {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

        UserDAO userDAO = (UserDAO) context.getBean("userDAO");

        userDAO.findAll().forEach(user -> System.out.println("user = " + user));
    }
}

在这里插入图片描述

总结：

在这里插入图片描述

4. Spring整合Mybatis编程Service层开发

# spring、mybatis整合Service层开发时如何加入事务控制

1. Mybatis框架中事务控制

	SqlSession		提交：sqlSession.commit();		回滚：sqlSession.rollback()
	
	// 无论用的是哪个简化数据库的框架，它的底层一定是jdbc，sqlSession底层调的也是Connection的commit()、rollback()
	Mybatis 是对 原始jdbc技术的封装  ===> Connection(数据库其实只认java.sql.Connection commit() | rollback())
	
	项目中真正负责数据库事务控制的对象：Connection 对象
	
2. 用来实现事务控制的核心对象是

	Connection 连接对象的 commit() rollback()
	
3. 如何在现有的项目中获取Connection对象
	
	注意：在现有项目中DruidDataSource是一个连接池  在连接池里面装的就是一个一个的Connection连接
	Connection conn = DruidDataSource.getConnection();
	
4. 给现有业务层加入事务
	UserServiceImpl
	
	private DataSource dataSource; // 提供公开的set方法
	save(){
		try{
         // 控制事务
         druidDataSource.getConnection().setAutoCommit(false)	// 将事务提交方式改为手动
         // 处理业务
         // 调用DAO
         druidDataSource.getConnection().commit();
        }catch(...){
         druidDataSource.getConnection().rollback();
        }
	}
	
	连接控制事务得保证是同一个连接对象，在业务层拿到的连接对象得和DAO真正执行时打开的数据库连接对象保持一致
	DAO真正执行是由框架内部的jar包创建出来的，不受控制，与业务层拿到的连接不是同一个，所以利用上面的代码控制
	事务是不行的
	
4. 在Spring和Mybatis框架中提供了一个类

	DataSourceTransactionManager	数据源事务管理器
	
	作用
	
		1. 在全局创建一个事务管理器，用来统一调度 业务层当前线程使用的连接对象和DAO层使用的连接对象一致
           由它来决定哪个线程在执行业务层时用的是这个连接，在执行DAO时同样用这个连接
	
	创建
     <!--数据源管理器-->
     <!--它是用来控制数据源的线程安全问题，它不生产数据源，所以要告诉它控制哪个数据源的线程安全问题，所以要注入数据源-->
     <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
         <!--注入数据源对象-->
         <property name="dataSource" ref="dataSource"/>
     </bean>		
	
5. 给现有的业务层加入事务控制

public class UserServiceImpl implements UserService{

    private UserDAO userDAO;
    private PlatformTransactionManager transactionManager; //setTransactionManager方法

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    @Override
    public void save(User user) {
        try{
        // 创建事务配置对象
        // 接口，后面new的用实现类
        TransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
        // 获取事务状态
                                                                    //传入事务配置
        TransactionStatus status = platformTransactionManager.getTransaction(transactionDefinition);
        //
        try {
            // 控制事务
            // 处理业务
            userDAO.save(user);
            int i = 1 / 0;
            // 需要传入事务状态
            platformTransactionManager.commit(status);
        } catch (Exception e) {
            e.printStackTrace();
            platformTransactionManager.rollback(status);
        }
    }
}

在具体讲解Spring整合Mybatis编程Service层开发之前，我们先来补充一个小的知识点

<!--一次性创建项目中所有DAO对象 MapperScannerConfigurer
    MapperScannerConfigurer：
        默认创建对象在工厂中唯一标识：接口的首字母小写的名字
        UserDAO=====> userDAO   Userdao====> userdao
        OrderDAO====> orderDAO  Orderdao====> orderdao
        EmpDAO====> empDAO
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!--注入SqlSessionFactory-->
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    <!--扫描DAO接口所在的包-->
    <property name="basePackage" value="com.baizhi.dao"/>
</bean>

使用MapperScannerConfigurer，一次性创建包中所有的接口

<!--创建sqlSessionFactory-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
    <!--因为使用了mybatis官方的创建SqlSessionFactory对象的工具类，所以不能使用mybatis的主配置文件了，
     主配置文件最重要的是数据源+mapper，所以我们要在这里写上数据源和mapper配置-->
    <!--依赖数据源-->
    <property name="dataSource" ref="dataSource"/>
    <!--注册mapper配置文件-->
    <property name="mapperLocations">
        <array>
            <value>classpath:com/baizhi/mapper/UserDAOMapper.xml</value>
        </array>
    </property>
    <!--注入别名相关配置 typeAliasesPackage：用来给指定包中所有类起别名 默认的别名：类名|类名首字母小写-->
    <property name="typeAliasesPackage" value="com.baizhi.eneity"/>
</bean>

typeAliasesPackage：用来给指定包中所有类起别名 默认的别名：类名|类名首字母小写

在这里插入图片描述

之后我们正式进入Spring整合Mybatis编程Service层开发

因为在前面开发DAO层时已经在pom.xml中导入依赖了，所以在开发Service时就不需要再导入依赖了，我们直接开发Service接口

public interface UserService {
    List<User> findAll();

    void save(User user);
}

在这里插入图片描述

这里我们先不管事务操作，创建UserService接口的实现类，UserService的实现类里面有一个userDAO接口对象

package com.baizhi.service;

import com.baizhi.dao.UserDAO;
import com.baizhi.eneity.User;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import java.util.List;
import java.util.UUID;

public class UserServiceImpl implements UserService{

    private UserDAO userDAO;


    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    @Override
    public List<User> findAll() {
        // 查询操作不需要事务控制
        // 调用userDAO的方法
        return userDAO.findAll();
    }

    @Override
    public void save(User user) {
        // 控制事务
        // 处理业务
        // 调用DAO
        // userDAO 方法上有一个小事务，仅限于DAO的方法，DAO的方法结束后会做一个提交，这个小事务仅是为了方便测试DAO
        // 当外部（Service方法内）存在事务时，小事务（仅限于DAO的方法中的事务）自动消失（小事务不生效）
        // // 调用userDAO的方法
        userDAO.save(user);
        //int i = 1 / 0;
    }
}

编写spring.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">


    <!--创建DataSource-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/lb"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--创建sqlSessionFactory-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <!--因为使用了mybatis官方的创建SqlSessionFactory对象的工具类，所以不能使用mybatis的主配置文件了，
         主配置文件最重要的是数据源+mapper，所以我们要在这里写上数据源和mapper配置-->
        <!--依赖数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--注册mapper配置文件-->
        <property name="mapperLocations">
            <array>
                <value>classpath:com/baizhi/mapper/UserDAOMapper.xml</value>
            </array>
        </property>
        <!--注入别名相关配置 typeAliasesPackage：用来给指定包中所有类起别名 默认的别名：类名|类名首字母小写-->
        <property name="typeAliasesPackage" value="com.baizhi.eneity"/>
    </bean>

    <!--一次性创建项目中所有DAO对象 MapperScannerConfigurer
        MapperScannerConfigurer：
            默认创建对象在工厂中唯一标识：接口的首字母小写的名字
            UserDAO=====> userDAO   Userdao====> userdao
            OrderDAO====> orderDAO  Orderdao====> orderdao
            EmpDAO====> empDAO
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入SqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--扫描DAO接口所在的包-->
        <property name="basePackage" value="com.baizhi.dao"/>
    </bean>

    <!--管理Service组件-->
    <bean class="com.baizhi.service.UserServiceImpl" name="userService">
        <property name="userDAO" ref="userDAO"/>
    </bean>

</beans>

在这里插入图片描述

测试和结果

测试之前t_user表中记录：

在这里插入图片描述

运行代码：

在这里插入图片描述

运行之后t_user表中记录：

在这里插入图片描述

上面表记录说明执行成功了。

接下来我们尝试使用事务进行管理

我们先看一下是否有事务自动提交

在这里插入图片描述

为什么有异常却仍然插入了数据呢，这时因为userDAO 方法上有一个小事务，仅限于DAO的方法，DAO的方法结束后会做一个提交，这个小事务仅是为了方便测试DAO，当外部（Service方法内）存在事务时，小事务（仅限于DAO的方法中的事务）自动消失（小事务不生效）。所以我们就需要手动进行管理了，我们知道，无论什么框架与数据库打交道时，底层都是Connection对象与数据库打交道，所以我们尝试用Connection进行事务管理，但是这确实不行的，因为Connection管理事务的前提是相同的Connection对象，当调用userDAO管理事务的Connection对象和userService管理事务的Connection对象不是同一个，那怎么办呢？官方提供了事务管理器类platformTransactionManager，它是用来控制数据源的线程安全问题，它不生产数据源，我们把它声明为成员变量，并声明公开的set方法，让spring工厂管理，所以UserServiceImpl实现类代码如下：

UserServiceImpl实现类

public class UserServiceImpl implements UserService{

    private UserDAO userDAO;
    // 声明事务管理器
    // PlatformTransactionManager是一个接口
    // DataSourceTransactionManager是PlatformTransactionManage的子类
    private PlatformTransactionManager platformTransactionManager;

    public void setPlatformTransactionManager(PlatformTransactionManager platformTransactionManager) {
        this.platformTransactionManager = platformTransactionManager;
    }

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    @Override
    public List<User> findAll() {
        // 查询操作不需要事务控制
        return userDAO.findAll();
    }

    @Override
    public void save(User user) {
        // 创建事务配置对象
        // 接口，后面new的用实现类
        TransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
        // 获取事务状态
                                                                    //创建事务配置
        TransactionStatus status = platformTransactionManager.getTransaction(transactionDefinition);
        //
        try {
            // 控制事务
            // 处理业务
            // 调用DAO
            // userDAO 方法上有一个小事务，仅限于DAO的方法，DAO的方法结束后会做一个提交，这个小事务仅是为了方便测试DAO
            // 当外部（Service方法内）存在事务时，小事务（仅限于DAO的方法中的事务）自动消失（小事务不生效）
            userDAO.save(user);
            int i = 1 / 0;
            // 需要传入事务状态
            platformTransactionManager.commit(status);
        } catch (Exception e) {
            e.printStackTrace();
            platformTransactionManager.rollback(status);
        }
    }
}

mapper配置文件

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


    <!--创建DataSource-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/lb"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--创建sqlSessionFactory-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <!--因为使用了mybatis官方的创建SqlSessionFactory对象的工具类，所以不能使用mybatis的主配置文件了，
         主配置文件最重要的是数据源+mapper，所以我们要在这里写上数据源和mapper配置-->
        <!--依赖数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--注册mapper配置文件-->
        <property name="mapperLocations">
            <array>
                <value>classpath:com/baizhi/mapper/UserDAOMapper.xml</value>
            </array>
        </property>
        <!--注入别名相关配置 typeAliasesPackage：用来给指定包中所有类起别名 默认的别名：类名|类名首字母小写-->
        <property name="typeAliasesPackage" value="com.baizhi.eneity"/>
    </bean>

    <!--一次性创建项目中所有DAO对象 MapperScannerConfigurer
        MapperScannerConfigurer：
            默认创建对象在工厂中唯一标识：接口的首字母小写的名字
            UserDAO=====> userDAO   Userdao====> userdao
            OrderDAO====> orderDAO  Orderdao====> orderdao
            EmpDAO====> empDAO
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入SqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--扫描DAO接口所在的包-->
        <property name="basePackage" value="com.baizhi.dao"/>
    </bean>

    <!--管理Service组件-->
    <bean class="com.baizhi.service.UserServiceImpl" name="userService">
        <property name="userDAO" ref="userDAO"/>
        <property name="platformTransactionManager" ref="transactionManager"/>
    </bean>

    <!--数据源管理器-->
    <!--它是用来控制数据源的线程安全问题，它不生产数据源，所以要告诉它控制哪个数据源的线程安全问题，所以要注入数据源-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
        <!--注入数据源对象-->
        <property name="dataSource" ref="dataSource"/>

    </bean>

</beans>