《Mybatis入门到精通》——2.基于XML的CRUD

Day_02

基于XML方式实现CRUD；2种方式：XML和注解，但实际开发中XML用的多；

表结构 user表

表的实体类 User类

/**
 * User表的实体类；
 */
@Data
public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

}

在DAO接口 IUserDao 中声明方法

package com.ming.dao;

import com.ming.domain.QueryVo;
import com.ming.domain.User;

import java.util.List;

/**
 * User的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有User表的记录-操作
     * @return
     */
    List<User> findAll();

    /**
     * 插入一条User记录
     * @void
     */
    void insertOne(User user);

    /**
     * 更新一条User记录
     * @void
     */
    void updateOne(User user);

    /**
     * 删除一条User记录
     * @void
     */
    void deleteOne(Integer id);

    /**
     * 根据id 查询一条User记录
     * @return
     */
    User findOneById(Integer id);

    /**
     * 根据username 模糊查询
     * @return
     */
    List<User> findByName(String likeUsername);

    /**
     * 聚合函数count
     * @return
     */
    int findTotalNum();

    /**
     * 根据 QueryVo对象（一个User成员的某个属性） username 模糊查询
     * @return
     */
    List<User> findByQueryVo(QueryVo vo);

    /**
     * 根据条件判断user的username是否为空，来动态的增加SQL条件语句
     * @param user
     * @return
     */
    List<User> findByCondition(User user);

    /**
     * 根据QueryVo 中提供的id集合，查询用户信息 where id in (...)
     * @param vo
     * @return
     */
    List<User> findByIdGroup(QueryVo vo);

}

DAO接口对应的XML IUserDao.xml 方法名-SQL语句-返回/参数类型

<?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">

<!--namespace指的是你的dao接口-->
<mapper namespace="com.ming.dao.IUserDao">
    <!--配置查询所有  其中id不能乱写必须是dao接口中的方法  resultType写的是实体类的全路径-->

    <!--查询所有-->
    <select id="findAll" resultType="com.ming.domain.User">
        SELECT * FROM user
    </select>


    <!--插入一个User    parameterType 说明带参-->
    <!--
    <insert id="saveUser" parameterType="com.daniel.domain.User">
          insert into user(username,address,sex,birthday)
           value(#{username},#{address},#{sex},#{birthday});
      </insert>
      -->
    <!--插入一个User 使用 #{User.属性} 传递User对象的值  -->
    <insert id="insertOne" parameterType="com.ming.domain.User">
        <!--怎么获得这个自增的主键呢？在<insert 里面加上<selectKey 标签 和一条SQL语句 select last_insert_id()-->
        <selectKey keyProperty="id" keyColumn="id" resultType="java.lang.Integer" order="AFTER">
            SELECT LAST_INSERT_ID()
        </selectKey>
        INSERT INTO user(username,birthday,sex,address) VALUES (#{username},#{birthday},#{sex},#{address})
    </insert>

    <!--更新一个User 使用 #{User.属性} 传递User对象的值  -->
    <update id="updateOne" parameterType="com.ming.domain.User">
        UPDATE user SET username = #{username},birthday = #{birthday},sex = #{sex},address = #{address} WHERE id = #{id}
    </update>

    <!--删除一个User 根据 #{User.id}   -->
    <delete id="deleteOne" parameterType="java.lang.Integer">
        DELETE FROM user WHERE id = #{id}
    </delete>

    <!--根据id查询一条-->
    <select id="findOneById" parameterType="java.lang.Integer" resultType="com.ming.domain.User">
        SELECT * FROM user WHERE id = #{id}
    </select>

    <!--根据username模糊查询-->
    <select id="findByName" parameterType="java.lang.String" resultType="com.ming.domain.User">
        <!--这里需要自己写 like % % 百分号 实际上是执行preparedStatement 推荐使用 -->
        SELECT * FROM user WHERE username LIKE #{username}

        <!--另一种方式 先写好百分号 % % 必须用value  实际上是执行statement 实际开发中使用上一种-->
        <!--SELECT * FROM user WHERE username LIKE '%${value}%' -->
    </select>

    <!--聚合函数 查询-->
    <select id="findTotalNum" resultType="java.lang.Integer">
        SELECT COUNT(1) FROM user
    </select>

    <!--根据QueryVo的user成员的属性 模糊查询-->
    <select id="findByQueryVo" parameterType="com.ming.domain.QueryVo" resultType="com.ming.domain.User">
        <!--这里的user指QueryVo的属性，直接使用user.username取出user的属性-->
        SELECT * FROM user WHERE username LIKE #{user.username}
    </select>

    <!-- 根据条件判断user的username是否为空，来动态的增加SQL条件语句 -->
    <select id="findByCondition" resultType="com.ming.domain.User" parameterType="com.ming.domain.User">
        <!-- 这里有个where1=1
        select * from user where 1=1
        <if test="username!=null">
            and username=#{username}
        </if>
        <if test="sex!=null">
            and sex=#{sex}
        </if>
        -->
        <!-- 写到<where>里面 不需要 where1=1 -->
        select * from user
        <where>
            <if test="username!=null">
                and username=#{username}
            </if>
            <if test="sex!=null">
                and sex=#{sex}
            </if>
        </where>
    </select>

    <sql id="selectFrUser">
        select * from user
    </sql>
    <!-- 条件查询的sql select * from user where id in(41,42,46) 条件：满足id在(...)中 通过一个 QueryVo类 传入集合的方法 -->
    <select id="findByIdGroup" resultType="com.ming.domain.User" parameterType="com.ming.domain.QueryVo">
        <!--下面这句话经常用 可以作为一个<sql>标签 作为引用导入 有点像JSP/HTML-->
        -- select * from user
        <include refid="selectFrUser"></include>

        <where>
            <if test="ids != null and ids.size()>0">
                <!-- 这里有5个标签 collections open close item separator 注意 item要和下面的#{user.id}相对应 -->
                <foreach collection="ids" open="and id in (" close=")" item="user.id" separator=",">
                    #{user.id}
                </foreach>
            </if>
        </where>

    </select>

</mapper>

测试类代码：

package com.ming.test;

import com.ming.dao.IUserDao;
import com.ming.domain.QueryVo;
import com.ming.domain.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.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


public class Test_User_CRUD {

    private InputStream inputStream;
    private SqlSession session;
    private IUserDao userDao;

    @Before
    public void init() throws IOException {
        //1.读取配置文件
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(inputStream);
        //3.使用工厂创建SqlSession
        session = factory.openSession();
        //4.使用SqlSession创建dao接口的代理对象
        userDao = session.getMapper(IUserDao.class);
    }

    @After
    public void destroy() throws IOException {
        //释放资源
        session.close();
        inputStream.close();
    }

    @Test
    public void testSelectAll() {
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

    @Test
    public void testInsertOne() {
        User user = new User();
        //这里没有插入id,因为id为主键非空自增
        user.setUsername("小明");
        user.setSex("男");
        user.setBirthday(new Date());
        user.setAddress("杭州");
        //！怎么获得这个自增的主键呢？在<insert 里面加上<selectKey 标签 和一条SQL语句 select last_insert_id()
        System.out.println("before:" + user);
        userDao.insertOne(user);
        //手动提交事务
        session.commit();
        System.out.println("after:" + user);
    }

    @Test
    public void testUpdateOne() {
        User user = new User();
        //加一条id，指定更新哪一个
        user.setId(48);

        user.setUsername("小明_update");
        user.setSex("男");
        user.setBirthday(new Date());
        user.setAddress("杭州");
        userDao.updateOne(user);
        //手动提交事务
        session.commit();
    }

    @Test
    public void testDeleteOne() {
        userDao.deleteOne(48);
        //手动提交事务
        session.commit();
    }

    @Test
    public void testSelectOne() {
        User user = userDao.findOneById(45);
        System.out.println(user);
    }

    @Test
    public void testSelectLike() {
        List<User> users = userDao.findByName("%王%");//推荐使用这一种
//        List<User> users = userDao.findByName("王");
        users.stream().forEach(System.out::println);
    }

    @Test
    public void testFindTotalNum() {
        System.out.println(userDao.findTotalNum());
    }

    //测试OGLN，即使用 对象.属性 的方式，而不用写成 对象.getter属性 来调用对象的属性，如模糊查询里面传参，这里传递一个QueryVo对象，查询语句需要他的user成员的属性
    @Test
    public void testfindByQueryVo() {
        User user = new User();
        QueryVo vo = new QueryVo();
        user.setUsername("%王%");//加%..%
        vo.setUser(user);
        List<User> users = userDao.findByQueryVo(vo);
//        List<User> users = userDao.findByName("王");
        users.stream().forEach(System.out::println);
    }

    @Test
    public void findByCondition() {
        User u = new User();
        User u0 = new User();
        User u1 = new User();
        //username为空，会查询所有
        List<User> users0 = userDao.findByCondition(u0);
        users0.stream().forEach(System.out::println);

        //username不为空，会查询username=#{username}
        u.setUsername("老王");
        List<User> users = userDao.findByCondition(u);
        users.stream().forEach(System.out::println);

        //username和sex不为空，会查询username=#{username} sex=#{sex}
        u1.setUsername("老王");
        u1.setSex("女");
        List<User> users1 = userDao.findByCondition(u1);
        users1.stream().forEach(System.out::println);

        session.commit();
    }

    @Test
    public void findByIds(){
        QueryVo queryVo = new QueryVo();
        List<Integer> list = new ArrayList<Integer>();
        list.add(41);
        list.add(42);
        list.add(46);
        queryVo.setIds(list);
        List<User> users = userDao.findByIdGroup(queryVo);
        users.stream().forEach(System.out::println);
        //session.commit();
    }

}

注意点：

1、数据库表的元素名与实体类的属性名不对应的解决：

（1）起别名：select ... as ...

 <!--配置查询所有  其中id不能乱写必须是dao接口中的方法  resultType写的是实体类的全路径-->
    <select id="findAll" resultType="top.zoick.domain.User">
        <!--实体类中的属性名和数据库表中元素名字匹配不上时，使用别名即可匹配。id为数据库中表的列名，userId为实体类中属性名-->
        select id as userId,username as userName,address as userAddress ,sex as userSex, birthday as userBirthday from user
    </select>

（2）配置查询结果的列名和实体类的属性名的对应关系：

 <!--配置查询结果的列名和实体类的属性名的对应关系 <resultMap>-->
    <resultMap id="userMap" type="top.zoick.domain.User">
        <!--主键字段的对应-->
        <id property="userId" column="id"></id>
        <!--非主键字段的对应-->
        <result property="userName" column="username"></result>
        <result property="userAddress" column="address"></result>
        <result property="userSex" column="sex"></result>
        <result property="userBirthday" column="bithday"></result>
    </resultMap>

再在查询的sql语句的xml中加入配置

  <select id="findAll" resultMap="userMap">
        select * from user
  </select>

2、配置xml中的属性标签

(1) 使用properties配置数据库连接信息，即使用外部的JDBCconfig.propoerties文件对其解析，而不在xml中写数据库的配置；

(2) 使用typeAliases配置别名

<!--使用typeAliases配置别名，他只能配置domain中类的别名-->
<typeAliases>
        <!--typeAlias用于配置别名，type属性指定的是实体类中的全限定类名。alias属性指定别名，当指定了别名后不在区分大小写-->
        <typeAlias type="top.zoick.domain.User" alias="user"></typeAlias>
</typeAliases>

或者（推荐）使用<package>标签而不是<typeAlias>

<typeAliases>
        <!--用于指定要配置别名的包，当指定后，该包下的实体类都会注册别名，并且类名就是别名，不再区分大小写-->
        <package name="top.zoick.domain"/>
 </typeAliases>

(3) 其中，配置映射文件位置的中也有package这个标签

DAO接口对应的.xml很多，一一配置则很麻烦，可以使用<package>，导入接口的包，则不需要再一个个导入<mapper resource>了；

小结
1、回顾MyBatis的自定义再分析和环境搭建+完善基于注解的MyBatis；
2、MyBatis的CRUD（基于代理dao的方式）；
3、MyBatis中的参数深入及结果集的深入；
4、MyBatis中的配置(主配置文件：SqlMapConfig.xml)

• properties标签
• typeAliases标签
• mappers标签

OGNL表达式:

Object Graphic Navigation Language
对象 　　图　　　导航 　　　语言

它是通过对象的取值方法来获取数据。在写法上把get给省略了；

比如:
我们获取用户的名称 username={#username}
类中的写法:user.getUsername,
OGNL表达式写法:user.username

mybatis中为什么能直接写username,而不用user.username 呢?
——因为在parameterType中已经提供了属性所属的类, 所以此时不需要写对象名;