Mybatis教程

mybatis的使用:

1.新建maven项目

2.配置pom.xml文件

<dependencies>
        <!-- Mysql 数据库连接工具 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
        </dependency>
        <!-- mybatis orm映射工具 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>
        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

3. 在resources文件夹下新建db.properties,mybatis-config.xml和Mapper.xml

1.配置db.properties文件

#数据库驱动
driver=com.mysql.cj.jdbc.Driver
#数据库url
url=jdbc:mysql://localhost:3306/smbms
#用户名
username=root
#密码
password=Sjx12345678

2. 配置mybatis文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.5.3//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--引入外部配置文件  引入外部配置文件的优先级要高于内部配置-->
    <!--方法一：<properties resource="db.properties"/>-->
    <!--方法二：-->
    <properties>
        <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/smbms"/>
        <property name="username" value="root"/>
        <property name="password" value="Sjx12345678"/>
    </properties>
    <settings>
        <!--自动映射关闭 partial默认匹配所有-->
        <setting name="autoMappingBehavior" value="NONE"/>
    </settings>
    <!--给实体类其别名-->
    <typeAliases>
        <!---给指定的类起别名，alias 起一个名字-->
        <typeAlias type="pojo.User" alias="User"/>
        <!--给指定包下面的所有类起别名，默认名称是类的名称-->
        <package name="pojo"/>
    </typeAliases>
    <!--配置环境变量 在mybatis种可以设置多个环境变量
        比如开发环境，生产环境，和测试环境都可以创建一个自己独有的环境变量
        通过default来指定当前项目使用什么环境变量-->
    <environments default="development">
        <!--这里的变量id是唯一的-->
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <!--将配置文件的属性读取出来 通过属性名-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--mappers是用来配置和注册映射文件的-->
    <mappers>
        <mapper resource="userMapper.xml"></mapper>
    </mappers>
</configuration>

3.配置Mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.5.3//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="dao.UserMapper">
    <!--id一定要和接口的方法名相同-->
    <select id="queryUser" resultType="pojo.User">select * from smbms_user</select>
    <!--
    在mybatis中方法注入有两种方式，一种是#{使用的是占位符进行替换}
    另一个是${使用的是字符串拼接}请使用#{}
    -->
    <!--
    id：唯一标识，要与接口中的方法名相同
    resultType：指定当前方法返回的数据类型
    parameterType：指定参数类型
    concat ：进行字符串的拼接
    -->
    <select id="queryUserByUserName" resultType="pojo.User" parameterType="String">
        SELECT id,userCode,userPassword,userName FROM smbms_user Where userName like concat('%',#{userName},'%');
    </select>
    <sql id="user_base_sql">
        id,userCode,userPassword,userName
    </sql>
    <!--
    参数为对象时，#{}中的参数名必须和对象中的属性名字相同
    resultType和resultMap不能在同一个标签里面
    -->
    <select id="queryUserByObject" resultMap="userRoleMap">
        select smbms_user.id,userCode,userPassword,userName,smbms_role.roleName from smbms_user,smbms_role where smbms_user.userRole = smbms_role.id and userName like concat('%',#{userName},'%') and userRole = #{userRole};
    </select>
    <!--
    手动映射字段 id在当前的配置文件必须是唯一的 type是你要手动映射的类型
    当数据库中返回的字段和java中的属性不能一一对应时，就要使用resultMap手动映射
    -->
    <resultMap id="userRoleMap" type="User">
        <!--id是这个类中的主键，可以提高一定的查询效率-->
        <id property="id" column="id"/>
        <!--property是java中的属性名 column是数据库返回的字段名-->
        <result property="userName" column="userName"/>
        <result property="userRoleName" column="roleName"/>
    </resultMap>
</mapper>

4.新建实体类(用来规定从数据库返回的值的类型):

package pojo;

import dao.UserMapper;

import java.util.List;
/**
	*此处以User为例
	*/
public class User {
    private Long id;
    private String userCode;
    private String userPassword;
    private String userName;
    private Integer userRole;
    private String userRoleName;

    public String getUserRoleName() {
        return userRoleName;
    }

    public void setUserRoleName(String userRoleName) {
        this.userRoleName = userRoleName;
    }

    public Integer getUserRole() {
        return userRole;
    }

    public void setUserRole(Integer userRole) {
        this.userRole = userRole;
    }

    public Long getId() {
        return id;
    }

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

    public String getUserCode() {
        return userCode;
    }

    public void setUserCode(String userCode) {
        this.userCode = userCode;
    }

    public String getUserPassword() {
        return userPassword;
    }

    public void setUserPassword(String userPassword) {
        this.userPassword = userPassword;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userCode='" + userCode + '\'' +
                ", userPassword='" + userPassword + '\'' +
                ", userName='" + userName + '\'' +
                ", userRole=" + userRole +
                ", roleName='" + userRoleName + '\'' +
                '}';
    }
}

5.创建接口,用来接收返回值;

package dao;

import org.apache.ibatis.annotations.Param;
import pojo.User;

import java.util.List;

public interface UserMapper {
    /**
     * 查询所有用户的信息
     * @return list
     * <strong>
     *     用户列表
     * </strong>
     */
    List<User> queryUser();

    /**
     * 根据用户名模糊查询用户列表
     * @param userName 用户名
     * @return 返回集合
     */
    List<User> queryUserByUserName(String userName);

    /**
     * 根据用户名和用户角色来查询用户信息
     * todo
     * mybatis中传递对象参数时 如果需要传递多个参数，需要进行判断
     * 如果参数在五个以下，一个一个传递（如果mybatis中的接口传递参数的个数大于等于两个，请使用@param来进行标识）
     * 如果在五个以上，使用对象传递
     * 原则上来说不建议使用map传递，因为会降低团队效率
     * @param userName 用户名
     * @param roleId 角色Id
     * @return 返回User对象
     */
    List<User> queryUserByUserNameAndRoleId(@Param("userName") String userName,@Param("roleId") Integer roleId);
    List<User> queryUserByObject(User user);
}

6.创建工具类(此工具类需要记忆):

package util;

import dao.UserMapper;
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;
import java.util.List;

/**
 * 单例模式 懒汉模式
 */
public class SqlSessionFactoryUtil {
    private static SqlSessionFactory sqlSessionFactory = null;
    /**
     * 因为涉及到可能会有多个线程同时加入一个方法，所以使用这个当线程锁
     */
    private static final Class   CLASS_BLOCK = SqlSessionFactoryUtil.class;
    /**
     *  因为是单例模式所以不能允许外部的类随意new，因此这个类为私有类
     */
    private SqlSessionFactoryUtil(){}

    /**
     * 创建会话工厂，因为当前类不能实例化，所以使用静态方法，外部可以直接调用
     * 为防止同时调用，创建多个工厂，使用线程锁来进行把控
     * @return
     */
    public static SqlSessionFactory createSqlSessionFactory(){
        //先判断工厂的状态，如果工厂以及被创建那么工厂中会有数据
        if (sqlSessionFactory == null){
            //第一次访问 创建工厂
            String resource = "mybatis-config.xml";
            try {
                InputStream is = Resources.getResourceAsStream(resource);
                //线程锁
                synchronized (CLASS_BLOCK){
                    //创建工厂的核心
                    sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
                }
            } catch (IOException e) {
                System.out.println("文件读取失败。。。。。");
                e.printStackTrace();
            }
            //返回数据
            return sqlSessionFactory;
        }else{
            //不是第一次访问，直接返回工厂
            return sqlSessionFactory;
        }
    }

    /**
     * 获取sql会话
     * @param openAutoCommit 是否开启自动提交 为以后做扩展 TODO 暂时不用
     * @return
     */
    public static SqlSession getSqlSession(boolean openAutoCommit){
        sqlSessionFactory = createSqlSessionFactory();
        //开启会话
        return sqlSessionFactory.openSession(openAutoCommit);
    }

}

7.创建测试类

package dao;

import junit.framework.TestCase;
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 pojo.User;
import util.SqlSessionFactoryUtil;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;


public class UserMapperTest{

      private SqlSession sqlSession;
    private UserMapper userMapper;
    @After
    public void after(){
        //在测试方法完成后执行
        if (sqlSession != null){
            sqlSession.close();
        }
    }
    @Before
    public void before(){
        //在测试方法完成后执行
        sqlSession = SqlSessionFactoryUtil.getSqlSession(false);
        userMapper = sqlSession.getMapper(UserMapper.class);
    }
  	//以下为测试类
    @Test
    public void testQueryUser() {
        String  resources = "mybatis-config.xml";
        try{
            InputStream is = Resources.getResourceAsStream(resources);
            //创建者通过配置文件创建会话工厂（会话工厂类似于basedao的connection对象，这里的会话工厂是全局的）
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //会话工厂负责生产 sql会话
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //sql 会话是最小的操作数据库单位，里面存放着操作数据库需要用到的所有方法
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            List<User> users = userMapper.queryUser();
            for (User user : users) {
                System.out.println(user);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    @Test
    public void utilTest(){
        SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSession(false);
        List<Object> objects = sqlSession.selectList("queryUser");
        System.out.println(objects);
        UserMapper userMapper= sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.queryUser();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }
    @Test
    public void util2(){
        List<User> users = userMapper.queryUser();
        for (User user : users) {
            System.out.println(user);
        }
    }
    @Test
    public void testQueryUserByUserName() {
        List<User> users = userMapper.queryUserByUserName("孙");
        for (User user : users) {
            System.out.println(user);
        }
    }
    @Test
    public void queryUserByUserNameAndRoleId() {
        List<User> users = userMapper.queryUserByUserNameAndRoleId("孙",3);
        for (User user : users) {
            System.out.println(user);
        }
    }
    @Test
    public void testqueryUserByObject() {
        User test = new User();
        test.setUserName("孙");
        test.setUserRole(3);
        List<User> users = userMapper.queryUserByObject(test);
        for (User user : users) {
            System.out.println(user);
        }

    }
}