mapper层配置

发表于 | 分类于

和数据库直接联系的，重要的mapper层的配置。

依赖

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
<!-- mybatis -->
<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>2.1.1</version>
</dependency>
<!-- druid 数据库连接池 -->
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.21</version>
</dependency>
<!-- jdbc -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- mysql -->
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<scope>runtime</scope>
</dependency>

<build>
	<plugins>
		<!-- 正常一定会有的 maven plugin -->
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
		<!-- mybatis -->
		<plugin>
			<groupId>org.mybatis.generator</groupId>
			<artifactId>mybatis-generator-maven-plugin</artifactId>
			<version>1.3.7</version>
			<configuration>
				<configurationFile>mybatis-generator/generatorConfig.xml</configurationFile>
				<overwrite>true</overwrite>
				<verbose>true</verbose>
			</configuration>
		</plugin>
	</plugins>
</build>

application.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
spring:
  application:
    name: USER-SERVICE
  profiles:
    # 为了便于管理，将具体的 datasource 配置放在另一个文件中
    # 下方 active 属性名，设为dev，则spring会自动寻找和 application.yaml同一目录下的 application-dev.yaml
    # 也就是说，设为x，则会自动寻找application-x.yaml
    # 效果等同于将目标文件内的 datasource 配置直接写在当前文件中
    active: dev

mybatis:
  # domain对象的包
  type-aliases-package: xmu.oomall.user.domain
  # mapper.xml所在的位置
  # 本项目的mapper放在 /resource/xmu.oomall.mapper 目录下
  # 如果配置时索引不到mapper，可能是前置名称有问题
  # 如该项目，mapper.xml所在的文件夹可以试试 /xmu.oomall.mapper 或者 /xmu/oomall/mapper
  mapper-locations: classpath:xmu.oomall.mapper/*.xml
  configuration:
    # 自动将SQL中查出来的带下划线的字段，转换为驼峰标志，再去匹配类中的属性
    mapUnderscoreToCamelCase: true
    map-underscore-to-camel-case: true

application-dev.yaml

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
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 目标数据库地址
    # jdbc开头，接数据库类型，接ip地址，接数据库名
    url: jdbc:mysql://106.14.83.157:3306/oomall
    # 登录数据库
    username: ooadUser
    password: ooad
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 初始化时建立物理连接的个数
      initial-size: 3
      # 最小连接池数量
      min-idle: 3
      # 最大连接池数量
      max-active: 10
      # 获取连接时最大等待时间
      max-wait: 60000
      filter:
        stat:
          # 是否开启慢sql查询监控
          log-slow-sql: true
          # 慢SQL执行时间
          slow-sql-millis: 100
      validation-query: select 1

到这里，配置基本完成了，接下来开始写mapper

UserMapper.java

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
package xmu.oomall.user.mapper;

import org.apache.ibatis.annotations.Mapper;
import xmu.oomall.user.domain.User;

import java.util.List;

/**
 * @author Ringoer
 * 必须是接口类型
 * 必须有 @Mapper 注解
 */
@Mapper
public interface UserMapper {
    /**
     * 根据id返回用户信息
     * @param id 用户id
     * @return 用户对象
     */
    User findUserById(Integer id);

    /**
     * 根据id返回用户信息
     * @param name 用户名
     * @return 用户对象
     */
    User findUserByName(String name);

    /**
     * 注册一个用户
     * @param user 用户信息
     * @return 行数
     */
    int addUser(User user);

    /**
     * 修改一个用户
     * @param user 用户对象
     * @return 修改影响的行数
     */
    int editUser(User user);

    /**
     * 返回用户列表
     * @return 用户列表
     */
    List<User> findUsers();
}

UserMapper.xml

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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
<?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中填写对应的mapper接口位置及名称-->
<mapper namespace="xmu.oomall.user.mapper.UserMapper">

    <!--sql语句之select-->
    <!-- id 填写在接口中对应的方法名 -->
    <!-- parameterType 填写传入参数的类型，类型名称与java类型相同 -->
    <!-- resultType 填写返回参数的名称，类型名称与java类型相同，返回时会自动组装 -->
    <!-- 对于数据库保留字段，如 name ，不能直接查询，要使用 `` 包裹住才行（不是单引号） -->
    <!-- 对于传入参数，使用 #{变量名} 方式来取值，其中变量名与java中相同 -->
    <select id="findUserById" parameterType="Integer" resultType="User">
            select id,
                   password,
                    `name`,
                    gender,
                    birthday,
                    mobile,
                    nickname,
                    rebate,
                    avatar,
                    role_id,
                    last_login_time,
                    last_login_ip,
                    user_level,
                    wx_open_id,
                    session_key,
                    gmt_create,
                    gmt_modified,
                    is_deleted as beDeleted
                    from `oomall_user` where id = #{id};
    </select>

    <!--sql语句之select-->
    <!-- resultType 填写返回参数的名称，类型名称与java类型相同，返回时会自动组装 -->
    <!-- 对于返回类型是List的情况，resultType中只需要填List中的单体的类型即可 -->
    <!-- 如该方法返回值是 List<User> ，但 resultType 只需要填写 User -->
    <select id="findUsers" resultType="User">
        select  id,
                password,
                `name`,
                gender,
                birthday,
                mobile,
                nickname,
                rebate,
                avatar,
                role_id,
                last_login_time,
                last_login_ip,
                user_level,
                wx_open_id,
                session_key,
                gmt_create,
                gmt_modified,
                is_deleted as beDeleted
        from `oomall_user`;
    </select>

    <!--sql语句之select-->
    <select id="findUserByName" parameterType="String" resultType="User">
            select id,
                   password,
                    `name`,
                    gender,
                    birthday,
                    mobile,
                    nickname,
                    rebate,
                    avatar,
                    role_id,
                    last_login_time,
                    last_login_ip,
                    user_level,
                    wx_open_id,
                    session_key,
                    gmt_create,
                    gmt_modified,
                    is_deleted as beDeleted
            from `oomall_user` where `name` = #{name};
    </select>

    <!--sql语句之insert-->
    <!-- id 填写在接口中对应的方法名 -->
    <!-- parameterType 填写传入参数的类型，类型名称与java类型相同 -->
    <!-- useGeneratedKeys 表示在数据库中插入时是否使用自增主键。需要与 keyProperty 配合使用 -->
    <!-- 无 resultType ，因为sql中insert方法一定返回此次更新影响的行数，即resultType一定是Integer -->
    <!-- keyProperty 表示在数据库中的主键是哪个字段，字段名称与java中的相同。需要与 useGeneratedKeys 配合使用 -->
    <!-- 如果使用了 useGeneratedKeys 和 keyProperty ，则插入成功后jdbc会自动将生成的主键装配进传入的变量中，可以在java中直接获取 -->
    <!-- 对于传入参数，使用 #{变量名} 方式来取值，其中变量名与java中相同 -->
    <!-- 如果传入参数类型是一个包含多个字段的类，则依然使用 #{变量名} 方式来取值，此时变量名直接与类中字段名相同，不需要再次声明类名 -->
    <insert id="addUser" parameterType="User" useGeneratedKeys="true" keyProperty="id">
        insert into `oomall_user`(
            password,
            `name`,
            gender,
            birthday,
            mobile,
            nickname,
            rebate,
            avatar,
            role_id,
            last_login_time,
            last_login_ip,
            user_level,
            wx_open_id,
            session_key,
            gmt_create,
            gmt_modified,
            is_deleted)
        values (
            #{password},
            #{name},
            #{gender},
            #{birthday},
            #{mobile},
            #{nickname},
            #{rebate},
            #{avatar},
            #{roleId},
            #{lastLoginTime},
            #{lastLoginIp},
            #{userLevel},
            #{wxOpenId},
            #{sessionKey},
            #{gmtCreate},
            #{gmtModified},
            #{beDeleted});
    </insert>

    <!--sql语句之update-->
    <!-- id 填写在接口中对应的方法名 -->
    <!-- parameterType 填写传入参数的类型，类型名称与java类型相同 -->
    <!-- 无 resultType ，因为sql中update方法一定返回此次更新影响的行数，即resultType一定是Integer -->
    <!-- 本文章未提及delete操作，实际上delete操作的返回值也是行数 -->
    <update id="editUser" parameterType="User" >
        update `oomall_user`
        set password=#{password},
            `name`=#{name},
            gender=#{gender},
            birthday=#{birthday},
            mobile=#{mobile},
            nickname=#{nickname},
            rebate=#{rebate},
            avatar=#{avatar},
            role_id=#{roleId},
            last_login_time=#{lastLoginTime},
            last_login_ip=#{lastLoginIp},
            user_level=#{userLevel},
            wx_open_id=#{wxOpenId},
            session_key=#{sessionKey},
            gmt_create=#{gmtCreate},
            gmt_modified=#{gmtModified},
            is_deleted=#{beDeleted}
        where id=#{id};
    </update>

</mapper>

使用mapper

到这里，mapper的声明工作已经全部完成了，接下来需要在dao层调用mapper。

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
package xmu.oomall.user.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import xmu.oomall.user.domain.User;
import xmu.oomall.user.mapper.UserMapper;

import java.util.List;

/**
 * @author Ringoer
 */
@Repository
public class UserDao {
    @Autowired
    private UserMapper userMapper;

    /**
     * 根据id返回用户信息
     * @param id 用户id
     * @return 用户对象
     */
    public User findUserById(Integer id){return userMapper.findUserById(id);}

    /**
     * 根据id返回用户信息
     * @param name 用户名
     * @return 用户对象
     */
    public User findUserByName(String name){return userMapper.findUserByName(name);}

    /**
     * 注册一个用户
     * @param user 用户信息
     * @return 行数
     */
    public int addUser(User user){return userMapper.addUser(user);}

    /**
     * 修改一个用户
     * @param user 用户对象
     * @return 行数
     */
    public int editUser(User user){return userMapper.editUser(user);}

    /**
     * 返回用户列表
     * @return 用户列表
     */
    public List<User> findUsers() {
        return userMapper.findUsers();
    }
}

调用代码如上。

实际上只需要两行代码，就可以无缝使用mapper：

1
2
@Autowired
private UserMapper userMapper;

以上即为通过jdbc的java与数据库连接方式。

--It's the end.Thanks for your read.--