MyBatis框架入門小案例（關於用mybatis框架對數據庫的增刪改查）

（1）新建好maven基本項目，引入mabatis的依賴

　　說明：在以前的dao層我們通常是直接用一個dao方法來操作數據庫的，這里我們要將dao的類改成一個接口類，在impl文件用另一個類來實現它的所有的抽象方法。

resources目錄建一個mybatis-config.xml文件，這個是配置mybatis框架的主要配置，mapper下的UsersMapper.xml是用來配置mysql的映射語句

（2）、新建一個MyBatisUtil工具類：

package edu.nf.mybatis.tools;

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;
import java.io.InputStream;

/**
 * 描述:
 * mybatis工具類，這個工具類主要 是解析mybatis-config.xml，
 * 並初始化一個SqlSessionFactory工廠，然后通過這個工廠來創建SqlSession實例。
 * 一個SqlSessionr實例其實就是一個變相的Connection對象
 * @author lance
 * @create 2018-09-10 10:38
 */
public class MyBatisUtil {
   /**聲明ggwhSqlSessionFactory*/
    private static SqlSessionFactory sqlSessionFactory;
   /* 在靜態代碼塊中初始化SqlSessionFactory*/
    static{
        //找到mybatis-config.xml配置文件，並構建一個輸入流
       //由於配置文件放在resources目錄中，編譯后會存放在classpath中
       try {
           //通過Resources類從classpath中找到xml文件並讀取，返回一個InputStream的對象
           InputStream is =Resources.getResourceAsStream("mybatis-config.xml");
           //通過這個輸入流來構建一個SqlSessionFactory對象
           //通過上面的輸入流傳遞給builder對象進行解析
           sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
       } catch (IOException e) {
           throw new RuntimeException(e.getMessage());
       }
   }

   /**
    * 提供一個獲取SqlSession的方法
    *
    * */
   public static SqlSession getSqlSession(){
       //openSession方法構建一個sqlSession對象
        return sqlSessionFactory.openSession();
   }
    public static SqlSession getSqlSession(Boolean falg){
        //openSession方法構建一個sqlSession對象
        return sqlSessionFactory.openSession(falg);
    }

}

 

（3）新建dao接口類與實現類具體如下：

UserDaoInf接口類：

package edu.nf.mybatis.dao;

import edu.nf.mybatis.entity.Users;

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

/**
 * @Author lance
 * */
public interface UserDaoInf {
    /**
     * 添加用戶
     */
     void saveUser(Users users);

    /**
     * 修改用戶
     */
     void updateUser(Users users);

    /**
     * 刪除用戶
     */
    void deleteUser(String uid);

    /**
     * 根據ID查詢某條用戶數據
     */
    Users findUsersById(String uid);

    /**
     * 查詢所有的用戶信息，保存在一個集合中
     */
    List<Users> findAll();
    /**
     * 統計查詢
     */
    int userCount();
    /**
     * 模糊查詢
     */
    List<Users> likeUsers(String name);
    /**
     * 查詢所有的用戶信息
     */
    List<Users> findAll2();
    /**
     * 查詢單條的用戶信息
     */
    Map<String ,Object> findUserMap(String uid);
    /**
     * 查詢多條的用戶信息
     */
    List<Map<String,Object>> findUserListMap();

　　/**
　　 * 多條記錄封裝一個map，Map<Integer,Material> :鍵是這條記錄的主鍵，值是封裝實體的對象
 　　* @return
 　　*/
　　@MapKey("mid")
　　Map<Integer,Material> getMateialMap();

　　
}

UserDaoImpl實現類：

package edu.nf.mybatis.dao.impl;

import edu.nf.mybatis.dao.UserDaoInf;
import edu.nf.mybatis.entity.Users;
import edu.nf.mybatis.tools.MyBatisUtil;
import javafx.beans.property.adapter.ReadOnlyJavaBeanBooleanProperty;
import org.apache.ibatis.session.SqlSession;

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

/**
 * 描述:
 * 接口實現類
 * @author lance
 * @create 2018-09-10 14:13
 */
public class UserDaoImpl implements UserDaoInf {

    @Override
    public int userCount() {
        SqlSession session = MyBatisUtil.getSqlSession();
        int count = 0;
        try {
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            count= dao.userCount();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            session.close();
        }
        return count;
    }

    @Override
    public List<Users> likeUsers(String name) {
        SqlSession session = MyBatisUtil.getSqlSession();
        List<Users> list = null;
        try {
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            list= dao.likeUsers(name);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            session.close();
        }
        return list;
    }

    @Override
    public void saveUser(Users user) {
        //獲取SqlSession實例
        SqlSession session = MyBatisUtil.getSqlSession();
        try {
            //方式一：
            //獲取相應的Mapper,getMapper方法需要傳遞一個接口的對象
            //並且返回的這個Mapper對象同樣是實現了UserDao接口
            //這個Mapper對象最核心的作用就是和mybatis的mapper映射配置文件進行關聯
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            //調用這個實現類的saveUser方法將數據保存在數據庫中
            dao.saveUser(user);
            //方式二：
            //bint row = session.insert("edu.nf.mybatis.entity.saveUser",user);
            //手動提交事務
            session.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //在異常加回滾事務
            session.rollback();
        }finally {
            session.close();
        }
    }

    @Override
    public void updateUser(Users users) {
        SqlSession session = MyBatisUtil.getSqlSession();
        try{
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            dao.updateUser(users);
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
            session.rollback();
        }finally {
            session.close();
        }
    }

    @Override
    public void deleteUser(String uid) {
        SqlSession session = MyBatisUtil.getSqlSession();
        try{
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            dao.deleteUser(uid);
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
            session.rollback();
        }finally {
            session.close();
        }
    }

    @Override
    public Users findUsersById(String uid) {
        SqlSession session = MyBatisUtil.getSqlSession();
        Users user=null;
        try {
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            user = dao.findUsersById(uid);
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }finally {
            session.close();
        }
        return user;
    }

    @Override
    public List<Users> findAll() {
        List<Users> list = null;
        SqlSession session = MyBatisUtil.getSqlSession();
        try {
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            list = dao.findAll();
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }
        return list;
    }

    @Override
    public List<Users> findAll2() {
        SqlSession session = MyBatisUtil.getSqlSession();
        List<Users> list = null;
        try{
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            list = dao.findAll2();
        }catch (Exception e){
            throw new RuntimeException(e.getMessage());
        }finally {
            session.close();
        }
        return  list;
    }

    @Override
    public Map<String, Object> findUserMap(String uid) {
        SqlSession session = MyBatisUtil.getSqlSession();
        Map<String,Object> map = null;
        try {
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            map = dao.findUserMap(uid);
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }finally {
            session.close();
        }
        return map;
    }

    @Override
    public List<Map<String, Object>> findUserListMap() {
        SqlSession session = MyBatisUtil.getSqlSession();
        List<Map<String, Object>> list = null;
        try {
            UserDaoInf dao = session.getMapper(UserDaoInf.class);
            list = dao.findUserListMap();
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }finally {
            session.close();
        }
        return list;
    }
}

（4）配置XML配置

  mybatis-config.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>
    <!--typeAliases用於給類型指定別名-->
    <typeAliases>
        <!--方式一：type屬性是使用完整的類名，alias屬性是別名-->
        <!--<typeAlias type="edu.nf.mybatis.entity.Users" alias="Users"/>-->
       <!-- 方式二：直接給整個實體包定義別名，name屬性指定實體類所在的包名，這樣會為每一個實體類自動
        生成一個別名，而這個 別名就是實體類的類名並且首字母小寫-->
        <package name="edu.nf.mybatis.entity"/>
    </typeAliases>

    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mydb?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--將所有的mapper映射配置文件加入到mapper配置中-->
    <mappers>
        <mapper resource="mapper/UsersMapper.xml"/>
    </mappers>
</configuration>

UserMapper.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指定Dao接口的完整類名
    mybatis會依據這個接口動態創建一個實現類去實現這個接口
    而這個實現類是一個Mapper對象-->
<mapper namespace="edu.nf.mybatis.dao.UserDaoInf">
    <!--在mapper里面就可以配置基於mybatis的增刪查改的sql映射配置-->
    <!--插入操作,id指定UserDao接口中的方法名,
    parameterType為指定方法參數的類型,。也可以定義為TypeAlias中定義的別名
    useGeneratedKeys屬性設置為true表示使用主鍵自增長
    keyProperty屬性指定實體中需要自增長的字段名稱

    sql設置參數的時候使用#{}，#{}是一個ognl表達式,(對象圖導航語言)
    而這里的#{}中指定的實體中的字段名
    -->
    <resultMap id="userMap" type="edu.nf.mybatis.entity.Users">
        <id property="uid" column="u_id"></id>
        <result property="userName" column="u_name"></result>
    </resultMap>

　　<!--id中要指定接口的方法-->
    <insert id="saveUser" parameterType="users" >
        insert into user_info(u_id,u_name) values(#{uid},#{userName})
    </insert>
    <update id="updateUser" parameterType="users">
        update user_info set u_name=#{userName} where u_id=#{uid}
    </update>
    <delete id="deleteUser" parameterType="java.lang.String">
        delete from user_info where u_id=#{uid}
    </delete>

    <!--根據ID來查詢某條用戶的信息，有參數類型的話要指定參數的類型，在parameterType屬性中指定-->
    <select id="findUsersById" parameterType="java.lang.String" resultType="users">
        select u_id as uid, u_name as userName from user_info where u_id=#{uid}
    </select>
    <!--查詢所有的用戶信息-->
    <select id="findAll" parameterType="users" resultType="users">
        select u_id as uid ,u_name as userName from user_info
    </select>

    <!--模糊查詢,參數為字符串類型-->
    <select id="likeUsers" parameterType="java.lang.String" resultType="users">
        select u_id as uid,u_name as userName from user_info where u_name like #{userName}"%"
    </select>

    <!--統計查詢，返回int類型的數據（指定返回值的類型）-->
    <select id="userCount" resultType="int">
        select count(*) from user_info
    </select>

    <!--將數據存放在一個resultMap集合中，用resultMap集合來映射-->
    <select id="findAll2" parameterType="users" resultMap="userMap">
        select * from user_info
    </select>

    <!--使用map集合映射，映射單條信息-->
    <select id="findUserMap"  resultType="java.util.Map">
        select * from user_info where u_id = #{uid}
    </select>

    <!--使用map映射多條信息-->
    <select id="findUserListMap" resultType="java.util.Map">
        select * from user_info
    </select>
　　

<!--使用Map來映射一個實體的對象，實體的ID作為主鍵-->

　　<select id="getMateialMap" resultMap="helpMap">
   　　 select * from Material
　　</select>

</mapper>

（5）測試：

package eud.nf.mybatis.dao.test;

import edu.nf.mybatis.dao.UserDaoInf;
import edu.nf.mybatis.dao.impl.UserDaoImpl;
import edu.nf.mybatis.entity.Users;
import edu.nf.mybatis.tools.UUIDUtils;
import org.junit.Test;

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

/**
 * 描述:
 *
 * @author lance
 * @create 2018-09-10 15:15
 */
public class UserDaoImplTest {
    @Test
    public void testSaveUsers(){
        Users users = new Users();
        //users.setUid(UUIDUtils.createUUID());
        users.setUid("1007");
        users.setUserName("test6");
        UserDaoInf dao = new UserDaoImpl();
        dao.saveUser(users);
    }
    @Test
    public void testUpdateUsers(){
        Users users = new Users();
        users.setUid("1006");
        users.setUserName("admin");
        UserDaoInf dao = new UserDaoImpl();
        dao.updateUser(users);
    }
    @Test
    public void testDeleteUsers(){
        UserDaoInf dao = new UserDaoImpl();
        dao.deleteUser("1010");
    }
    @Test
    public void testFindUsersById(){
        UserDaoInf dao = new UserDaoImpl();
        Users user = dao.findUsersById("1001");
        System.out.println(user.getUid());
        System.out.println(user.getUserName());
    }
    @Test
    public  void testFindAll(){
        UserDaoInf dao = new UserDaoImpl();
        List<Users> list = dao.findAll();
        for (Users users : list) {
            System.out.println(users);
        }
    }
    @Test
    public void testUserCount(){
        UserDaoInf dao = new UserDaoImpl();
        int count = dao.userCount();
        System.out.println(count);
    }

    @Test
    public void testLikeUser(){
        UserDaoInf dao = new UserDaoImpl();
        List<Users> list = dao.likeUsers("test6");
        for (Users users : list) {
            System.out.println(users.getUid());
            System.out.println(users.getUserName());
        }
    }

    @Test
    public void testFindAll2(){
        UserDaoInf dao = new UserDaoImpl();
        List<Users> list = dao.findAll2();
        for (Users users : list) {
            System.out.println(users.getUid());
            System.out.println(users.getUserName());
        }
    }

    @Test
    public void testFindUsersMap(){
        UserDaoInf dao = new UserDaoImpl();
        Map<String,Object> map = dao.findUserMap("1001");
        for (String s : map.keySet()) {
            System.out.println(s +":"+ map.get(s));
        }
    }
    @Test
    public void testFindUsersListMap(){
        UserDaoInf dao = new UserDaoImpl();
        List<Map<String,Object>> list = dao.findUserListMap();
        for (Map<String, Object> map : list) {
            for (String s : map.keySet()) {
                System.out.println(s+":"+map.get(s));
            }
            System.out.println("---------");
        }
    }

}