Mybatis的实现方式

Mybatis的实现方式一共有三种

用纯xml文件的方式
用xml和接口两种的方式（过度方式：从xml过度到注解）
用注解的方式

一、准备工作

添加mybatis依赖

  <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.4</version>
     </dependency>

添加mysql依赖

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
   </dependency>

添加junit依赖（用来测试结果）

<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

使用mybatis的话必须要配置mybatis的xml文件

mybatis.xml

<?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节点
        里面有配置信息 分别是环境和映射
        　其中环境里有datasource，里面有我们熟悉的连接数据库的四个字符串
-->
<configuration>

    <!--
        引入db的配置文件信息，后面用到的四个连接字符串就可以直接使用 ${}的方式来动态引入
    -->
    <properties resource="db.properties">
        <property name="pass" value="123456"></property>
    </properties>

    <!--
        给当前mybatis项目添加日志功能，该STDOUT_LOGGING值的好处是不用添加第三方jar包就可以有日志的输出
    -->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <typeAliases>
        <!--<typeAlias type="com.qfedu.pojo.Order" alias="abc" />-->
        <package name="com.qfedu.pojo" />
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${user}"/>
                <property name="password" value="${pass}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/qfedu/mapper/OrderMapper.xml"/>
        <mapper resource="com/qfedu/mapper/UserMapper.xml"/>
        <mapper resource="com/qfedu/mapper/DetailMapper.xml"/>
        <mapper resource="com/qfedu/mapper/ProductMapper.xml"/>
        <mapper resource="com/qfedu/mapper/TypeMapper.xml"/>
    </mappers>
</configuration>

<properties>标签：用来引入后缀为.properties的文件，其中resource属性的值为存储连接数据库的4个参数的配置文件的文件名。
子标签<property>是属性标签，其中的name的值为属性名，而value表示对应属性的值。
<settings> :设置标签这里是用来为当前的mybatis项目添加一个日志功能，其中的STDOUT_LOGGING表示日志标准的输入
<typeAliases>：用来设置别名
<typeAlias> 标签目地是可以把type中的值用alias中的值来替代（在映射文件中设置类型的时候来使用）
<package> 标签中的name值当设置结果集类型的时可以直接写name之后的内容不需要写全路径
<dataSource> 用来连接数据库的数据资源
<mappers> 标签表示映射
其中的有两个子标签：
1. <mapper>
  <mapper>中的resource里的值为所要映射的xml文件的路径，通过这个路径就可以找到对应的xml文件，url的值表示本地所对应的配置文件的路径，class的值为所要映射的类所在的路径
  2.<package>
  <package> 中的name值为所要映射包的全路径

二、通过xml文件的方式

OrderMapper.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，
    每个方法对应自己的sql语句，每个sql语句对应有一个id
    整个项目中所有的namespace.id必须是唯一的
-->
<mapper namespace="com.qfedu.pojo.OrderMapper">

    <select id="getOrderByOid" resultMap="orderMap">
      select * from orders where oid = #{oid}
    </select>
    
    <!--<resultMap id="orderMap" type="com.qfedu.pojo.Order">-->
    <resultMap id="orderMap" type="order">

        <!--
            id代表主键，分别设置列和属性的对应关系
        -->
        <id property="oid" column="oid" ></id>

        <!--
            result代表普通字段的映射，分别指定列与属性的对应

            如果字段名和属性名一致，可以省略

            属性名叫做payType，字段名pay_type;
            <result column="pay_type" property="payType" />
        -->
        <result column="price" property="price" />
        <result column="addr" property="addr" />
        <result column="payType" property="payType" />

        <!--
            association关联，只要是"对一"的关系都可以使用association，代表关联
            property代表Order类中的属性名u
            column代表Orders表与Users表之间的关联字段
            select代表要使用该查询完成两表的联合查询得出user对象
        -->
        <association property="u" column="uid" select="com.qfedu.pojo.UserMapper.getUserByUid"></association>

        <!--
            collection设置集合，只要是"对多"多关系，都可以使用collection，代表集合
            column代表orders表与details表之间的关联字段
        -->
        <!--<collection property="details" column="oid" select="com.qfedu.pojo.DetailMapper.getDetailsByOid" ofType="com.qfedu.pojo.Detail" />-->
        <collection property="details" column="oid" select="com.qfedu.pojo.DetailMapper.getDetailsByOid" ofType="detail" />
    </resultMap>
</mapper>

每个mapper文件都将有一个自己的映射的namespace，每个方法对应自己的sql语句，每个sql语句对应有一个id,整个项目中所有的namespace.id必须是唯一的。

<select>标签中的 id在纯xml实现方式中可以随便写 resultMap为查询出的结果集的类型（使用路径的形式来表示）当查询出中出现对象类型的数据时使用，如果没有一个是对象类型就用resultType。
在写sql语句时，如果所需写查询条件，我们用#{}的形式来的占位符。
<resultMap>标签中的 id对应着上面的值，type为查询数据类型的路径
<id>代表数据库主键的值，分别设置列和属性的对应关系。
<result>代表普通字段的映射，分别指定列与属性的对应。如果数据库的字段名和属性一样的话可以省略不写。
<association>只要是"对一"的关系都可以使用association，代表关联。property代表Order类中的属性名，column代表Orders表与Users表之间的关联字段。select代表要使用该查询完成两表的联合查询得出user对象，是用来关联其他xml文件所查询出的结果，值为namespace+id
<collection>设置集合，只要是"对多"多关系，都可以使用collection，代表集合column代表orders表与details表之间的关联字段,ofType表示查询出来的list集合中存放的类型。

测试结果

package com.qfedu.test;

import com.qfedu.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.sql.Connection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestUser {

    private SqlSessionFactory sf = null;
    private SqlSession session = null;

    @Before
    public void setUp(){

        try {
            sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));

            session = sf.openSession(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @After
    public void tearDown(){
        if(session != null){
            session.close();
            session = null;
        }
    }

    @Test
    public void testGetAllUsers(){

        /**
         *  1.  使用mybatis的配置文件以及SqlSessionFactoryBuilder建造者模式创建SqlSessionFactory对象
         *  2.  使用SqlSessionFactory对象的openSession（）方法来得到一个SqlSession对象，用该对象即可完成对象的所有的crud操作
         *  3.  使用SqlSession对象来完成crud操作
         *  4.  关闭资源
         *
         */

        /**
         * session的crud方法（"namespace.id"）;整个项目中的namespace.id必须唯一
         */
        List<User> users = session.selectList("com.qfedu.pojo.UserMapper.selectUser");

        for (User u : users) {
            System.out.println(u);
        }
    }

在测试代码中
@Before注解表示在测试之前的准备工作
@After注解表示在测试之后的后续工作

在查询之前我们需要使用mybatis的配置文件以及SqlSessionFactoryBuilder建造者模式创建SqlSessionFactory对象，通过该对象来创建SqlSession对象来完成数据库的操作。
通过 session中对应的方法来查询出结果。
查询之后我们需要关闭SqlSession对象的资源

二、通过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="com.qc.dao.IUser">
    <select id="getAllUsers" resultType="User">
        select * from teacher;
    </select>
    <insert id="saveUser" >
        insert into teacher values (null ,#{name} ,#{age} ,#{addr});
    </insert>
    <update id="updateUser">
        update teacher set name = #{name} where id = #{id};
    </update>
</mapper>

其中namespace要对应与接口类的全路径，id对应于每个抽象方法的方法名，因此我们不能在接口中定义重载的方法，因为namespace+id是唯一的。

此xml对应的接口

package com.qc.dao;

import com.qc.pojo.User;

import java.util.List;
import java.util.Map;

public interface IUser {
    List<User> getAllUsers();

    int saveUser(User user);

    int updateUser(User user);
}

SqlSession工具类来创建SqlSession对象

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;

public class SessionUtils {
    private static SqlSessionFactory ssf = null;
    private static SqlSession session = null;

    static{
        try {
            ssf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSession() {
         session = ssf.openSession(true);
        return session;
    }

    public static void cloesSession(SqlSession  session) {
        if (session != null) {
            session.close();
            session = null;
        }
    }
}

测试类


import com.qc.dao.IUser;
import com.qc.pojo.User;
import com.qc.util.SessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestUsers {
    SqlSession session = null;
    @Before
    public void setUp() {
         session = SessionUtils.getSession();
    }
@After
    public void tearDown() {
        SessionUtils.cloesSession(session);
    }
@Test
    public void getAllUser() {
    IUser u = session.getMapper(IUser.class);
    List<User> allUsers = u.getAllUsers();
    for (User user : allUsers) {
        System.out.println(user);
    }
}
@Test
    public void saveUser() {
    IUser mapper = session.getMapper(IUser.class);
    User u = new User(2,"qicheng",18,"liuhe");
    int i = mapper.saveUser(u);
    System.out.println(i);
}

    @Test
    public void updateUser() {
        IUser mapper = session.getMapper(IUser.class);
        User u = new User(1, "lisi", 32, "dhfa");
        int i = mapper.updateUser(u);
        System.out.println(i);
    }
}

通过session的getMapper方法来获取接口类型的对象，该对象来调用里面的方法从而实现crud操作。

三、通过纯注解的方式

import com.qc.pojo.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface IUserDao {

@Select("select * from teacher")
    List<User> getAllUser();

@Select("select * from teacher where id = #{id}")
    User getUserById(int id);

@Insert("insert into teacher values(null , #{name} , #{age} , #{addr}) ")
    int addUser(User user);

@Delete("delete from teacher where id = #{id}")
    int deleteUserById(int id);
@Select("select * from teacher where id = #{arg0} and name = #{arg1}")  /*param1 param2*/
    User getUserByIdAndName(int id , String name);
}

注意：在接口方法的参数出现两个或以上的参数时，为了让服务器知道对应的关系时，我们需要在注解的语句中用arg0，arg1或者param1，param2来表明方法参数的对应关系，arg0或param1表示对应的第一个参数，arg1param2或对应的是第二个参数，两者不可以混用。

测试类

import com.qc.dao.IUserDao;
import com.qc.pojo.User;
import com.qc.util.SessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

public class TestUserDao {
    SqlSession session = null;
    @Before
    public void setUp() {
        session = SessionUtils.getSession();
    }
    @After
    public void tearDown() {
        SessionUtils.cloesSession(session);
    }
    @Test
    public void TestUser() {
        IUserDao mapper = session.getMapper(IUserDao.class);
        List<User> allUser = mapper.getAllUser();
        for (User user : allUser) {
            System.out.println(user);
        }
    }

    @Test
    public void getUserById() {
        IUserDao mapper = session.getMapper(IUserDao.class);
        User userById = mapper.getUserById(1);
        System.out.println(userById);
    }

    @Test
    public void addUser() {
        IUserDao mapper = session.getMapper(IUserDao.class);
        User user = new User(3,"dandan" ,22,"nanjing");
        int i = mapper.addUser(user);
        System.out.println(i);
    }

    @Test
    public void deleteUser() {
        IUserDao mapper = session.getMapper(IUserDao.class);
        int i = mapper.deleteUserById(8);
        System.out.println(i);
    }

    @Test
    public void getUserBy() {
        IUserDao mapper = session.getMapper(IUserDao.class);
        User user = new User(2,"王五",32,"hsuif");
        User userByIdAndName = mapper.getUserByIdAndName(2,"王五");
        System.out.println(userByIdAndName);
    }
}