6.mybatis中单表基本操作

6.单表基本操作

6.1 CURD操作

package com.itany.ms.dao;
import com.itany.ms.entity.User;
import java.util.List;
public interface UserMapper {
    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(User user);
    List<User> selectAll();
}

<?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.itany.ms.dao.UserMapper">
    <insert id="insertUser">
        insert into t_user
        (name, pwd, age)
        values
        (#{name}, #{pwd}, #{age})
    </insert>
    <update id="updateUser">
        update t_user
        set
        age = #{age}
        where id = #{id}
    </update>
    <delete id="deleteUser">
        delete from t_user
        where id = #{id}
    </delete>
    <select id="selectAll" resultType="com.itany.ms.entity.User">
        select
        id, name, pwd, age
        from t_user
    </select>
</mapper>

<!-- 在mybatis-config.xml 的mappers标签中追加 -->
<mapper resource="com/itany/ms/mapper/UserMapper2.xml"></mapper>

package com.itany.ms;
import com.itany.ms.dao.UserDao;
import com.itany.ms.dao.UserMapper;
import com.itany.ms.entity.User;
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.util.List;

public class Test01 {
    SqlSession sqlSession;
    @Before
    public void before(){
        // 1.创建SqlSessionFactory构建器, 用来加载mybatis-config.xml配置文件
        SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
        // 2.加载mybatis-config.xml配置文件, 创建SqlSession工厂，用来获取sqlSession
        SqlSessionFactory factory = ssfb.build(Test01.class
                .getClassLoader()
                .getResourceAsStream("mybatis-config.xml"));
        // 3.获取sqlSession
        // 默认会开启事务，不自动提交事务，且不手动提交时，默认结束时执行回滚。
        sqlSession = factory.openSession();
        // 参数为true: 表示自动提交事务, 为false: 表示不自动提交事务(开启事务)
//        sqlSession = factory.openSession(false);
        System.out.println("init");
    }
    @After
    public void after(){
        // 关闭
        sqlSession.close();
        System.out.println("end");
    }
    @Test
    public void test4(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User u = new User(null, "t11", "123", 33);
        mapper.insertUser(u);

        // 检查表中主键的下一个值
        u.setId(9);
        u.setAge(100);//修改age值
        mapper.updateUser(u);

        // 设置删除的用户id
        u.setId(1);
        mapper.deleteUser(u);

        List<User> users = mapper.selectAll();
        for(User user : users){
            System.out.println(user);
        }
        // 提交事务
        sqlSession.commit();
    }
}

6.2 保存并返回主键

// 接口中新增的方法
void insertReturnId(User user);

<!-- 添加并返回主键,需要加的属性
    useGeneratedKeys="true" 表示启用 保存并返回主键功能
    keyColumn的值 是 表中的主键列名
    keyProperty的值 是 参数对象中的属性名
    最终会把 添加后获得的主键值存入参数对象的 keyProperty的值表示的 属性中
    -->
<insert id="insertReturnId" useGeneratedKeys="true" keyColumn="id" keyProperty="id">
    insert into t_user
    (name, pwd, age)
    values
    (#{name}, #{pwd}, #{age})
</insert>

// 其他代码省略
@Test
public void test5() {
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User u = new User(null, "q111", "123", 33);
    mapper.insertReturnId(u);
    System.out.println("id="+u.getId());
    sqlSession.commit();
}

6.3 对象关系映射

必须配置resultType或resultMap，否则无法使用。

resultType设定的值为 HashMap 时，会把一条数据封装成一个HashMap。

key相当于属性名,value相当于属性的值。

1.默认情况

会把查询的结果封装成 resultType 配置的类的对象，对应关系是 将列的值放入同名的属性中。

即查询到的数据中 列名 必须 和返回值类型中的 属性名相同。

2.给列取别名

// 新增方法, 返回值 User2 类型
List<User2> selectAll2();

package com.itany.ms.entity;
public class User2 {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    // 省略 getter/setter toString 等方法
}

<!-- 不取别名时, 返回的user对象中的username、password
属性将获取不到值 -->
<select id="selectAll2" resultType="com.itany.ms.entity.User2">
    select
    id, name username, pwd password, age
    from t_user
</select>

@Test
public void test6() {
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User2> user2s = mapper.selectAll2();
    System.out.println(user2s);
}

3.使用resultMap

<!--
    resultMap 标签: 用于定义映射关系
    id属性是 其唯一标识符(该文件中不能重复)
    type属性值是 最终封装的对象类型
    -->
<resultMap id="user2Map" type="com.itany.ms.entity.User2">
    <!-- id标签 映射 主键列 与 类中主键属性 -->
    <id column="id" property="id" ></id>
    <!-- result标签 映射 普通列 与 类中的普通属性  -->
    <result column="name" property="username" ></result>
    <result column="pwd" property="password" ></result>
    <result column="age" property="age" ></result>
    <!-- 没有再此映射的属性将没有对应的值 -->
</resultMap>
<!-- select 中 resultMap属性的值 是 resultMap标签的id值 -->
<select id="selectAll3" resultMap="user2Map" >
    select
    id, name, pwd, age
    from t_user
</select>

// 新增方法
List<User2> selectAll3();

@Test
public void test7() {
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User2> user2s = mapper.selectAll3();
    for(User2 user : user2s){
        System.out.println(user);
    }
}

6.4 方法参数

mybatis dao接口方法支持写 0 或者 多个参数的，但是官方建议最多写一个参数。

1.对象类型参数

// 一个对象类型的参数
void updateUser(User user);

<!--
通常 通过 #{xx} 的方式获取 参数对象的 xx属性的值。
	此方式 会 对sql进行预编译。
也可以 通过 ${xx} 的方式获取 参数对象的 xx属性的值。
	此方式 不会 对sql进行预编译，会出现sql注入问题。
-->
<update id="updateUser">
    update t_user
    set
    age = #{age}
    where id = #{id}
</update>

2.Map类型参数

// 根据条件查询
List<User> selectByCondition(Map<String, Object> map);

<!-- 方法参数是 Map, #{}中的内容就是 key, 通过 该key获取对应的value -->
<select id="selectByCondition" resultType="com.itany.ms.entity.User">
    select
    id, name, pwd, age
    from t_user
    where
    name like #{nameLike}
    and age between #{beginAge} and #{endAge}
</select>

@Test
public void test8() {
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    Map<String, Object> map = new HashMap<String, Object>();
    // 设置参数内容 key值要和 mapper.xml中的一致，否则获取的值为null
    map.put("nameLike", "%a%");
    map.put("beginAge", 20);
    map.put("endAge", 22);
    List<User> users = mapper.selectByCondition(map);
    for(User user : users){
        System.out.println(user);
    }
}

3.简单类型参数

主要有 基本数据类型、包装类、字符串。

// 新增方法 根据id查询
User selectById(Integer id);

// 修改后的方法
// @Param 给参数取别名
// org.apache.ibatis.annotations.Param;
User selectById(@Param("userId") Integer id);

<!-- 方法参数是一个的时候：
     1. #{} 中的内容 可以随便写
     2. 建议使用参数名
     3. (建议写法) 使用 mybatis的参数注解 给参数取别名
-->
<select id="selectById" resultType="com.itany.ms.entity.User" >
    select
    id, name, pwd, age
    from t_user
    where id = #{userId}
</select>

@Test
public void test9() {
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.selectById(8);
    System.out.println(user);
}

4.多个参数

不建议方法中定义多个参数

1.默认方案

List<User> selectByNameAndPwd(String name, String pwd);

<!-- 默认取值
1. 通过参数的下标 取值, 在下标前 加上 arg
  例如 此处的取值代码
  where pwd = #{arg1} and name = #{arg0}
2. 通过参数的序号 取值, 在下标前 加上 param
  例如 此处的取值代码
  where pwd = #{param2} and name = #{param1}
-->
<select id="selectByNameAndPwd" resultType="com.itany.ms.entity.User" >
    select
    id, name, pwd, age
    from t_user
    where pwd = #{param2} and name = #{param1}
</select>

2.通用方案(常用)

// 给所有参数添加注解 @Param, 取别名
List<User> selectByNameAndPwd(@Param("name") String name, 
    @Param("pwd") String pwd,
    @Param("user") User u);

<select id="selectByNameAndPwd" resultType="com.itany.ms.entity.User" >
    select
    id, name, pwd, age
    from t_user
    where pwd = #{pwd} and name = #{name}
    and age = #{user.age}
</select>

@Test
public void test10() {
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User u = new User();
    u.setAge(20);
    Map<String, Object> map = new HashMap<>();
    map.put("id", 6);
    List<User> users = mapper.selectByNameAndPwd("test", "111", u, map);
    System.out.println(users);
}