Mybatis学习2-基本的CRUD

发表于
字数统计 2.4k | 阅读时长 11

最终代码

1.完整接口类代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package com.gsynf.dao;

import com.gsynf.domain.QueryVo;
import com.gsynf.domain.User;

import java.util.List;

/**
 * 用户的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有用户
     * @return
     */
    List<User> findAll();

    /**
     * 保存方法
     * @param user
     */
    void saveUser(User user);

    /**
     * 更新操作
     * @param user
     */
    void updateUser(User user);

    /**
     * 根据Id删除用户
     * @param userId
     */
    void deleteUser(Integer userId);

    /**
     * 根据Id查询用户信息
     * @param userId
     * @return
     */
    User findById(Integer userId);

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

    /**
     * 查询总用户数（聚合函数，返回一行一列）
     * @return
     */
    int findTotal();

    /**
     * 根据queryVo中的条件查询用户
     * @param vo
     * @return
     */
    List<User> findUserByVo(QueryVo vo);
}

2.完整配置文件代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?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>
    <!--配置properties
        可以在标签内部配置连接数据库的属性，也可以通过属性引用外部配置文件的信息
    -->
    <properties resource="jdbcConfig.properties">

<!--        <property name="driver" value="com.mysql.jdbc.Driver"/>-->
<!--        <property name="url" value="jdbc:mysql://192.168.1.107:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8"/>-->
<!--        <property name="username" value="root"/>-->
<!--        <property name="password" value="root"/>-->
    </properties>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--配置映射文件的位置-->
    <mappers>
        <mapper resource="com/gsynf/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

3.完整映射文件代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
<?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.gsynf.dao.IUserDao">
    <!--配置查询结果的列名和实体类的属性名的对应关系-->
    <resultMap id="userMap" type="com.gsynf.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="birthday"></result>

    </resultMap>

    <!--查询所有-->
    <select id="findAll" resultType="com.gsynf.domain.User" resultMap="userMap">
--         select id as userId,username as userName, address as userAddress,sex as userSex,birthday as userBirthday from user
        select * from user
    </select>
    <!--保存用户-->
    <insert id="saveUser" parameterType="com.gsynf.domain.User">
--         配置插入操作后获取插入数据的id
--         keyProperty表示要返回的值的名称；order取值为AFTER表示插入后的行为；resultType表示返回值的类型
        <selectKey keyProperty="userId" keyColumn="id" order="AFTER" resultType="java.lang.Integer">
            select last_insert_id()
        </selectKey>
        insert into user(username,address,sex,birthday)values(#{userName},#{userAddress},#{userSex},#{userBirthday})
    </insert>
    <!--更新用户-->
    <update id="updateUser" parameterType="com.gsynf.domain.User">
        update user set username=#{userName},address=#{userAddress},sex=#{userSex},birthday=#{userBirthday} where id=#{userId}
    </update>
    <!--根据Id删除用户-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id=#{uid}
    </delete>
    <!--根据Id查询用户-->
    <select id="findById" parameterType="int" resultType="com.gsynf.domain.User">
        select * from user where id = #{uid}
    </select>
    <!--根据用户名模糊查询-->
    <select id="findByName" parameterType="string" resultType="com.gsynf.domain.User">
         select * from user where username like #{uname}
--         select * from user where username like '%${value}%'
    </select>
    <!--查询总用户数-->
    <select id="findTotal" resultType="int">
        select count(id) from user
    </select>
    <!--根据queryVo中的条件查询用户-->
    <select id="findUserByVo" parameterType="com.gsynf.domain.QueryVo" resultType="com.gsynf.domain.User">
        select * from user where username like #{user.userName}
    </select>
</mapper>

4.完整测试类代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package com.gsynf.test;

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

/**
 * Copyright (C), 2019, NSSC
 *
 * @ClassName: MybatisTest
 * @Description: 测试Mybatis的CRUD操作
 * @author: gsynf
 * @date: 2019/11/7 15:17
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
public class MybatisTest {
    private  InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;

    @Before//用于在测试方法执行之前执行
    public void init() throws Exception{
        // 1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        // 3.获取SqlSession对象
        sqlSession = factory.openSession();
        // 4.获取dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    @After//用于在测试方法执行之后执行
    public void destroy() throws Exception{
        // 提交事务
        sqlSession.commit();
        // 6.释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll() {
        // 5.执行查询所有方法
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
    @Test
    public void testSave() {
        User user = new User();
        user.setUserName("mybatis saveuser insertid");
        user.setUserAddress("北京市海淀区");
        user.setUserSex("男");
        user.setUserBirthday(new Date());

        System.out.println("保存操作之前："+user);
        // 5.执行保存方法
        userDao.saveUser(user);

        System.out.println("保存操作之后："+user);
    }
    @Test
    public void testUpdate() {
        User user = new User();
        user.setUserId(54);
        user.setUserName("mybatis updateuser");
        user.setUserAddress("北京市海淀区");
        user.setUserSex("女");
        user.setUserBirthday(new Date());

        // 5.执行更新方法
        userDao.updateUser(user);
    }
    @Test
    public void testDelete() {
        // 5.执行删除方法
        userDao.deleteUser(54);
    }
    @Test
    public void testFindById() {
        // 5.执行查询一个方法
        User user = userDao.findById(41);
        System.out.println(user);
    }
    @Test
    public void testFindByName() {
        // 5.执行根据姓名模糊查询
        List<User> users = userDao.findByName("%王%");
//        List<User> users = userDao.findByName("王");
        for (User user : users) {
            System.out.println(user);
        }
    }
    @Test
    public void testFindTotal() {
        // 5.执行查询总用户数
        int count = userDao.findTotal();
        System.out.println(count);
    }
    @Test
    public void testFindUserByVo() {
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUserName("%王%");
        vo.setUser(user);
        // 5.执行根据queryVo中的条件查询用户
        List<User> users = userDao.findUserByVo(vo);
        for (User u : users) {
            System.out.println(u);
        }
    }


}

一些注意点

1.OGNL表达式

Object Graphic Navigation Language
对象 　　 图　　　 导航 　　　 语言
它是通过对象的取值方法来获取数据。在写法上把get给省略了。
比如:我们获取用户的名称
　　　　类中的写法:user.getUsername,
　　　　OGNL表达式写法:user.username
mybatis映射文件中为什么能直接写username,而不用user.:因为在parameterType中已经提供了属性所属的类, 所以此时不需要写对象名

2.数据库表的元素名与实体类的属性名不对应的解决

1.起别名：

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 <!--配置查询结果的列名和实体类的属性名的对应关系-->
<resultMap id="userMap" type="com.gsynf.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>

3.配置文件中的属性标签

3.1使用properties配置数据库连接信息

可以在标签内部配置数据库连接信息，也可以通过外部文件来配置数据库连接信息。

第一种url属性(不常用)

URL属性：
　　URL:Uniform Resource Locator　统一资源定位符 可以唯一标志一个资源的位置
　　写法必须是

​ 协议　　主机　　端口　 URI　　　　

​ http://localhost:8080/mybatisserver/demo1Servlet
URI:

​ Uniform Resource Identifier 统一资源标识符 是在应用中可以可以唯一标志一个资源的位置
　　URL>URI（精准性）

1
2
<properties url="file:///C:/Users/jdbcConfig.properties">
</properties>

第二种resource属性（常用）
用于指定配置文件的位置，是按照类路径来写的，必须存在于类路径下

1
2
<properties resource="jdbcConfig.properties">
</properties>

2.使用typeAliases配置别名

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

3.使用package配置别名

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

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

1
2
3
4
5
<mappers>
    <!--        <mapper resource="top/zoick/dao/IUserDao.xml"/>-->
    <!--package标签是用于指定dao接口所在的包，当指定了之后就不需要再写mapepr以及resource或者class了-->
    <package name="top.zoick.dao"/>
</mappers>

注：转载文章请注明出处，谢谢~