MyBatis和Spring框架整合

 Spring 集成 MyBatis 

将 MyBatis与 Spring 进行整合，主要解决的问题就是将 SqlSessionFactory对象交由 Spring 来管理。所以，该整合，只需要将SqlSessionFactory的对象生成器 SqlSessionFactoryBean 注册在Spring容器中，再将其注入给 Dao 的实现类即可完成整合

先大概的说一下完成需要的步骤

 1.  创建maven项目

 2. 加入maven依赖

    1）spring依赖

    2）mybatis依赖

    3）mysql驱动

    4）spring事务的依赖

    5）mybatis和spring集成的依赖

3. 创建实体类

4. 创建dao接口和mapper文件

5. 创建mybatis主配置文件、

6. 创建service接口和实现类，属性dao

7. 创建spring的配置文件：声明mybatis的对象交给spring创建

      1）数据源

      2）SqlsessionFactory

      3）Dao对象

      4）声明自定义的service

8. 创建测试类，获取service对象，通过service调用dao完成数据库的访问

要使用dao对象，需要使用getMapper()方法，

1. 获取SqlSession对象， 需要使用SqlSessionFactory的openSession()方法

2. 创建SqlSessionFactory对象。 通过读取mybatis的主配置文件，能创建SqlSessionFactory对象

在mybatis的主配置文件

1. 数据库信息

<transactionManager type="JDBC"/>
<dataSource type="POOLED">
    <!--数据库的驱动类名-->
    <property name="driver" value="com.mysql.jdbc.Driver"/>
    <!--连接数据库的url字符串-->
    <property name="url" value="jdbc:mysql://localhost:3306/springdb"/>
    <!--访问数据库的用户名-->
    <property name="username" value="root"/>
    <!--密码-->
    <property name="password" value="123456"/>
</dataSource>

2. mapper文件的位置

<mappers>
    <mapper resource="com/bjpowernode/dao/StudentDao.xml"/>
</mappers>

通过以上的说明，我们需要让spring创建以下对象

1. 独立的连接池类的对象， 使用阿里的druid连接池

2. SqlSessionFactory对象

3. 创建出dao对象

上面三个对象的创建语法，使用xml的bean标签

数据库创建

对应数据库字段的实体类：

public class user {
    private int id;
    private String username;
    private String password;

    public user() {
    }

    public user(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "user{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

数据访问层  userDao

public interface userDao {
    //插入数据
    int insertUser(user user);
    //查询数据
    List<user> selectUsers();
}

userDao.xml

<?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="cn.com.Ycy.spring_aspectJ.dao.userDao">
    <select id="selectUsers" resultType="cn.com.Ycy.spring_aspectJ.domain.user">
        select * from user_table
    </select>

    <insert id="insertUser">
        insert into user_table values (#{id},#{username},#{password})
    </insert>
</mapper>

业务逻辑层 service

这个接口完成对数据库的操作，对应着数据访问层的userDao的方法，在通过普通类实现这个接口，把userDao作为属性引入

再在实现userService接口的类中的方法，List<user> users = userdao.selectUsers();，在这里userDao是由spring创建

public interface userService {
//    插入user
    int addUser(user user);
//    查询
    List<user> selectAll();
}

业务逻辑的接口实现类

 使用实现方法访问dao数据库的操作，对应的方法访问dao数据库不同的操作，这里addUser对应着数据访问层的insertUser

import cn.com.Ycy.spring_aspectJ.dao.userDao;
import cn.com.Ycy.spring_aspectJ.domain.user;
import cn.com.Ycy.spring_aspectJ.service.userService;

import java.util.List;


public class userServiceImpl implements userService {

        private userDao userdao;
        //为了使用set注入
        public void setUserdao(userDao userdao) {
            this.userdao = userdao;
        }


        /**
         * 我们需要使用这个方法访问dao数据库的操作，
         * 就把这个userDao依赖进来
         * @param user
         * @return
         */
        @Override
        public int addUser(user user) {
            int num = 0;
            num = userdao.insertUser(user);
            return num;
        }

    /**
     * 我们需要使用这个方法访问dao数据库的操作
     * 就把这个userDao依赖进来
     * @return
     */
    @Override
    public List<user> selectAll() {
        List<user> users = userdao.selectUsers();
        return users;
    }
}

Mybatis主配置文件

感觉这个配置文件完成被spring替代了，都可以不要了

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- settings 控制mybatis全局行为 日志 -->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
</configuration>

spring主配置文件：重头戏

1. 独立的连接池类的对象， 使用阿里的druid连接池

声明数据源DataSource ,作用是连接数据库的（就类似给非自定义的属性赋值），这个是写好的，只需要set注入属性

<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--set注入给druidDatasource 提供连接数据信息-->
        <property name="url" value="jdbc:mysql:///users"/>
        <property name="username" value="root"/>
        <property name="password" value="ye0401"/>
        <!--    最多默认多少数量连接数据库    -->
        <property name="maxActive" value="20"/>
</bean>

2. SqlSessionFactory对象

声明是mybatis中提供的SqlsessionFactoryBean类，这个类内部创建SqlsessionFactory的，它会内部创建Sqlsession

<bean id="sqlsessionfactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource"/>
        <!--  这个不加也是不会报错，大部分的功能被spring替代  -->
        <property name="configLocation" value="classpath:mybatis.xml"/>
</bean>

在mybatis创建SqlsessionFactory对象是需要读取mybatis主配置文件，这个主配置文件中就有数据库信息，如下：

<environments default="mysql">
<!--  配置mysql环境 default 和id 的命名一样 -->
<environment id="mysql">
    <!--配置事务的类型  -->
    <transactionManager type="JDBC"></transactionManager>
    <!--  配置数据源 （连接池） -->
    <dataSource type="POOLED">
        <!-- 配置数据库的四个基本信息 -->
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <!--
        数据库路径写错
        java.sql.SQLException: No suitable driver found for
     -->
        <property name="url" value="jdbc:mysql:///mybatisdb"/>
        <property name="username" value="root"/>
        <property name="password" value="ye0401"/>
    </dataSource>
</environment>
</environments>

3. 创建出dao对象

创建dao对象，使用Sqlsession的getMapper(userDao.class)

userDao users = sqlSession.getMapper(userDao.class);

      1、sqlSession

      2、userDao.class

MapperScannerConfigurer:在内部调用getMapper()生成每个接口的代理对象

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
   <!-- 指定SqlsessionFactory的id-->
   <property name="sqlSessionFactoryBeanName" value="sqlsessionfactory"/>
    <!--指定userDao.clas -->
   <property name="basePackage" value="cn.com.Ycy.spring_aspectJ.dao"/>
</bean>

指定userDao.class：

MapperScannerConfigurer会扫描这个包中所有的接口，cn.com.Ycy.spring_aspectJ.dao这个是dao层的包名

把每一接口执行一次getMapper()方法，得到每一个接口的dao对象

创建好的对象放在spring的容器中的

value:可以写多个包名,逗号分开

dao对象是接口名的首字母小写

最后就是创建service层的实现类的对象

<!-- 声明service接口实现类对象   -->
<bean id="service" class="cn.com.Ycy.spring_aspectJ.service.imp.userServiceImpl">
     <!-- set注入 -->
     <property name="userdao" ref="userDao"/>
</bean>

这个ref的值是由spring创建的Dao对象的名称，就是上面的，对象名默认是首字母小写的名称

sqlSession创建的userDao users = sqlSession.getMapper(userDao.class);

测试方法

 @Test
 public void test06(){
     String config = "ApplicationContext.xml";
     ApplicationContext ac = new ClassPathXmlApplicationContext(config);
     userService service = (userService) ac.getBean("service");
     List<user> users = service.selectAll();
     for (user user : users) {
         System.out.println(user);
       }
}