（续前文）文章来源地址https://www.toymoban.com/news/detail-479767.html
5、Dao类
Dao类提供操作访问数据库表的接口方法。常规的CRUD，将考虑下列接口方法：
1）插入单条对象记录；
2）批量插入对象记录；
3）修改单条对象记录；
4）批量修改对象记录；
5）删除单条对象记录；
6）批量删除对象记录；
7）查询多条对象记录；
8）查询指定key的对象记录；
9）查询记录条数；
10）根据唯一字段（或组合字段）查询单条对象记录。
Dao类使用@Mapper注解，类中代码应仅实现接口方法定义，不建议使用@Select,@Insert等注解直接在Dao类中实现接口（特殊情况除外），考虑的后期接口功能扩展的可能性，在Mybatis xml脚本文件中实现接口书写更容易规范，功能也更强大。
5.1、新增对象
新增对象和批量新增对象的方法名和形式如下所示。其中如果支持自增ID，则返回值为对象ID。
/**
* @methodName : insertItem
* @description : 新增一个XXX对象
* @param item : XXX对象
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int insertItem(XXX item);
/**
* @methodName : insertItems
* @description : 批量新增XXX对象
* @param itemList : XXX对象列表
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int insertItems(List<XXX> itemList);
批量新增对象接口，在数据库表为关系表时，更需要使用；而数据库表为对象表时，往往因为复杂的数据库一致性校验和关联操作，不常使用。
新增对象和批量新增对象的处理性能相差不大，即批量插入100条记录和插入单条记录的时间相差无几。因此需要大量新增对象时，应考虑批量新增对象的接口。
下面分别是新增用户和批量新增用户角色关系的方法示例：
/**
* @methodName : insertItem
* @description : 新增一个用户对象
* @param item : 用户对象
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int insertItem(User item);
/**
* @methodName : insertItems
* @description : 新增一批用户对象
* @param itemList : 用户对象列表
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int insertItems(List<User> itemList);
5.2、修改对象
修改单个对象和批量修改对象的方法名和形式如下所示。
/**
* @methodName : updateItemByKey
* @description : 根据key修改一个XXX对象
* @param params : XXX对象相关属性字段字典，key字段必选，其它字段可选
* {
* "keyPropName1" : 0, // keyPropName1说明，必选
* "keyPropName2" : 0, // keyPropName2说明，必选
* ......
* }
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int updateItemByKey(Map<String, Object> params);
/**
* @methodName : updateItems
* @description : 批量修改XXX对象
* @param params : 请求参数，所有字段可选，但至少需要一个修改字段和一个条件字段
* {
* 修改字段：
* "setPropName1" : 0, // setPropName1字段说明，可选
* ......
* 条件字段：
* "condPropName1" : 0, // condPropName1字段说明，可选
* ......
* }
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int updateItems(Map<String, Object> params);
修改单个对象需要所有的主键属性字段，从而确定唯一的对象。而其它字段都应允许修改，且可选。（记录操作字段中的create_time和update_time字段不在修改字段之列）。
不建议使用下列接口形式来实现单个对象的修改：
public int updateItem(XXX item);
updateItem这种接口形式的问题是参数形式为实体类对象，需要整个实体类对象的属性，对于前端而言，需要将所有属性都赋值，如有遗漏，会造成信息被默认值覆盖；另外可能前端也未必能获取到对象的全部信息。因此，这种接口形式会提高处理的复杂度。
批量修改由于影响多条记录，误操作造成的影响和损失是巨大的，因此，往往要控制至少一个条件字段。另外，此接口如果修改大量记录，与删除大量数据一样，可能会造成数据库死锁。此接口是否需要提供，视业务需求而定。
批量修改，往往对状态字段进行修改，或存在父级对象（如主从表）的冗余字段进行修改，可修改的字段是极为有限的。
另外批量修改，一般情况下，不建议使用多表联结，可以先将外表的条件转为本表字段的值的列表，使用in条件进行单表操作。
下面分别是修改用户和批量修改用户的方法示例：
/**
* @methodName : updateItemByKey
* @description : 根据key修改一个用户对象
* @param params : 用户对象相关属性字段字典，key字段必选，其它字段可选
* {
* "userId" : 0L, // 用户ID，必选
* }
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int updateItemByKey(Map<String, Object> params);
/**
* @methodName : updateItems
* @description : 根据条件批量修改用户对象的相关属性字段的值
* @param params : 用户对象相关字段字典，至少需要一个修改字段和一个条件字段，修改字段和条件字段均可选；
* {
* 修改字段集如下：
* "orgId" : 0, // 组织机构ID，可选
* "userType" : 3, // 用户类型，1-系统管理员、2-公司内部用户、3-外部用户，可选
* "deleteFlag" : 0, // 记录删除标记，0-正常、1-禁用，可选
* "operatorName" : "", // 操作人账号，可选
* 条件字段如下：
* "userIdList" : [], // 用户ID列表，list，可选
* "userName" : "", // 用户名，可选
* "phoneNumber" : "", // 手机号码，可选
* }
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* 2022/05/17 1.0.0 sheng.zheng 初版
*
*/
public int updateItems(Map<String, Object> params);
5.3、条件字段的命名规范
涉及批量记录，往往与条件有关，包括后面的批量删除记录，查询记录等，都需要使用条件。抛开需要使用Mysql内置函数，以及复杂AND和OR组合的个性化条件，大多数情况，多个条件使用AND进行联结。
条件字段有下列可能：等于，不等于，大于，大于等于，小于，小于等于，IS NULL，IS NOT NULL，IN，NOT IN，LIKE（BETWEEN可被大于等于和小于等于替代，不必考虑），NOT BETWEEN AND（内置了OR条件）。
同一个参数名，不能适用不同的条件，否则需要更多接口，增加维护的复杂度，因此需要对条件字段的名称进行规范。
假设属性字段名称为propName，则条件字段的命名规则如下：
/**
等于 : propName
不等于 : propNameNeq
大于等于 : propNameGte
大于 : propNameGt
小于等于 : propNameLte
小于 : propNameLt
IS NULL : propNameNull
IS NOT NULL : propNameNNull
IN : propNameList
NOT IN : propNameNList
LIKE : propNameLike
NOT BETWEEN AND : propNameNBtwl // NOT BETWEEN AND的下边界值
propNameNBtwh // NOT BETWEEN AND的上边界值，上下边界值必须同时出现。
*/
下面是一个条件参数命名示例：
/**
* @param params : 查询参数，形式如下：
* {
* "userType" : 3, // 用户类型，1-系统管理员、2-公司内部用户、3-外部用户，可选
* "userTypeList" : [], // 用户类型列表，in，可选
* "userTypeNList" : [], // 用户类型列表，not in，可选
* "sex" : 1, // 性别，1-无值、2-男、3-女、4-其它，可选
* "deleteFlag" : 0, // 记录删除标记，0-正常、1-禁用，可选
* "userName" : "", // 用户名，精确匹配，可选
* "userNameLike" : "", // 用户名，like，可选
* "phoneNumber" : "", // 手机号码，精确匹配，可选
* "phoneNumberLike": "", // 手机号码，like，可选
* "realNameLike" : "", // 真实姓名，like，可选
* "emailLike" : "", // Email，like，可选
* "birthGte" : "", // 生日起始值，yyyy-MM-dd格式，gte，可选
* "birthLte" : "", // 生日终止值，yyyy-MM-dd格式，lte，可选
* "birthNull" : "", // 生日，is null，任意字符串值，可选
* "orgId" : 1, // 组织ID，可选
* "orgIdList" : [], // 组织ID列表，in，可选
* }
*/
字符串类型字段，对于前端页面，常使用模糊匹配来查询记录，以扩大记录集；而内部调用时，往往使用精确匹配查询，以求缩小搜索记录集合和更高的查询性能。有了条件参数命名规则，同一个查询接口可以支持多种查询业务的需求，从而解除Dao层与Service层的紧耦合。
5.4、删除对象
删除单个对象和批量删除对象的方法名和形式如下所示。
/**
* @methodName : deleteItemByKey
* @description : 根据key删除一个XXX对象
* @param keyPropName1 : 对象xxx的key1属性字段
* .... :
* @param keyPropNameN : 对象xxx的keyn属性字段，如果只有一个key字段，则无此参数,数据类型依据具体key而定
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int deleteItemByKey(@Param("keyPropName1") Integer keyPropName1,...,@Param("keyPropNameN") Integer keyPropNameN);
/**
* @methodName : deleteItems
* @description : 批量删除XXX对象
* @param params : 请求参数，所有字段可选，但至少需要一个条件字段
* {
* 条件字段：
* "condPropName1" : 0, // condPropName1字段说明，可选
* ......
* }
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int deleteItems(Map<String, Object> params);
如果对象表，一般不支持物理删除，就无需提供这两个方法；对于关系表，一般支持物理删除，需要删除方法。
下面分别是删除用户角色关系和批量删除用户角色关系的方法示例：
/**
* @methodName : deleteItemByKey
* @description : 根据key删除一个用户和角色关系对象
* @param userId : 用户ID
* @param roleId : 角色ID
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int deleteItemByKey(@Param("userId") Long userId, @Param("roleId") Integer roleId);
/**
* @methodName : deleteItems
* @description : 批量删除相关用户和角色关系对象
* @param params : 请求参数，要求至少有一个条件参数，形式如下：
* {
* "roleId" : 0, // 角色ID，可选
* "userId" : 0L, // 用户ID，可选
* }
* @return : 受影响的记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public int deleteItems(Map<String, Object> params);
5.5、查询对象
查询是使用最频繁的功能，受业务需求驱动，查询的要求也多种多样。此处仅考虑通用的查询需求，不考虑分组(GROUP)查询和联合(UNION)查询及子查询，这些特殊查询属于定制需求。
建议一般情况使用单表查询，在主从表（Master-Detail）的情况下，子表可以关联主表查询。建议不要超过3个表的关联查询，否则由于搜索记录空间太过庞大（为笛卡尔乘积），即使有索引，性能也不会太好，何况有些查询条件会使得索引失效，如LIKE，大于等于等等。
那么如果一个表的外键比较多，如何处理呢？建议使用分步查询以及缓存来处理，这样可以获取较好的查询性能。
通用查询考虑提供下列4个方法：
/**
* selectItems : 根据条件查询对象列表，此方法适用于API调用和内部调用
* selectItemByKey : 根据key值查询一个对象
* selectCount : 根据条件查询记录数
* selectItemByXXX : 根据唯一键（或组合唯一键）查询一个对象
*/
5.5.1、查询对象列表
查询对象列表的方法名和形式如下所示：
/**
* @methodName : selectItems
* @description : 根据条件查询XXX对象列表
* @param params : 查询条件参数，形式如下：
* {
* 条件字段：
* "condPropName1" : 0, // condPropName1字段说明，可选
* ......
* "condPropNameN" : 0, // condPropNameN字段说明，可选
* "offset" : 0, // limit记录偏移量，可选
* "rows" : 20, // limit最大记录条数，可选
* "sortList" : [], // 排序选项，SortField对象列表，只支持数据表字段属性，可选
* }
* @return : XXX对象列表
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public List<XXX> selectItems(Map<String, Object> params);
```
除了条件字段外，selectItems还有3个可选参数，其中offset和rows参数，一方面为配合单元测试辅助工具，获取一定数目的记录样本，另外也为代替分页插件提供了备选方案。分页插件使用了子查询来查询总记录数，导致有时性能很差，必要时，可以使用selectCount结合selectItems方法，取代分页插件。
sortList，排序选项，支持多个字段的排序，一般的方案是支持一个字段的排序，且有sql注入的风险，不可取。排序选项是SortField对象的列表，SortField定义如下：
```java
package com.abc.example.vo;
import lombok.Data;
/**
* @className : SortField
* @description : 排序字段信息对象
* @summary : 用于SQL查询语句的ORDER BY
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
@Data
public class SortField {
// 字段属性名称
private String fieldName = "";
// 排序次序，0-升序，1-降序
private int sortOrder = 0;
}
```
sortList，可以将多个字段按各自升序或降序要求，顺序设置，从而实现丰富的排序功能。
没有sortList字段，常规的做法是根据业务特点将排序固化，这样处理代码实现简单，但不灵活。当然支持sortList选项，会增加较多的Mybatis的代码，是否需要支持排序选项，视业务需求而定。
下面是查询用户记录的方法示例：
```java
/**
* @methodName : selectItems
* @description : 根据条件查询用户对象列表，用于前端和内部查询记录
* @param params : 查询参数，前端调用至少要有一个条件参数，参数形式如下：
* {
* "userType" : 3, // 用户类型，1-系统管理员、2-公司内部用户、3-外部用户，可选
* "userTypeList" : [], // 用户类型列表，in，可选
* "userTypeNList" : [], // 用户类型列表，not in，可选
* "sex" : 1, // 性别，1-无值、2-男、3-女、4-其它，可选
* "sexList" : [], // 性别列表，in，可选
* "deleteFlag" : 0, // 记录删除标记，0-正常、1-禁用，可选
* "userName" : "", // 用户名，精确匹配，可选
* "userNameLike" : "", // 用户名，like，可选
* "phoneNumber" : "", // 手机号码，精确匹配，可选
* "phoneNumberLike": "", // 手机号码，like，可选
* "realName" : "", // 真实姓名，精确匹配，可选
* "realNameLike" : "", // 真实姓名，like，可选
* "email" : "", // Email，精确匹配，可选
* "emailLike" : "", // Email，like，可选
* "birthGte" : "", // 生日起始值，yyyy-MM-dd格式，gte，可选
* "birthLte" : "", // 生日终止值，yyyy-MM-dd格式，lte，可选
* "birthNull" : "", // 生日，is null，任意字符串值，可选
* "orgId" : 1, // 组织ID，可选
* "orgIdList" : [], // 组织ID列表，in，可选
* "offset" : 0, // limit记录偏移量，可选
* "rows" : 20, // limit最大记录条数，可选
* "sortList" : [], // 排序选项，SortField对象列表，只支持数据表字段属性，可选
* }
* @return : 用户对象列表
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public List<User> selectItems(Map<String, Object> params);
```
对于前端而言，枚举类型如用户类型，可能是单选，也可能是多选，因此提供了userType和userTypeList条件字段，以满足不同场景的查询需求。如果枚举项很多，也可以提供类似userTypeNList的条件字段，相当于反选，以减少用户勾选点击次数。
如phoneNumber字段，前端需要模糊匹配，后端内部调用需要精确匹配，因此同时提供phoneNumber和phoneNumberLike条件字段，以满足不同需求。
简而言之，selectItems的条件选项集是一个大拼盘，提供丰富的条件选项，以满足不同场景的需求。
但是，也没必要所有的字段要按各种条件都给出选项。需要提供哪些条件选项，除了业务需求要求的特殊条件选项外，有以下较为通用的设置原则：
```java
/**
1、如果某属性不给任何条件，即为空集时，其效果相当于全集。
2、对于二值枚举类型，只需要'='条件的选项，不需要'in'条件的选项。
3、对于多值枚举类型，需要'='、'in'条件的选项，枚举项较多时，需要'not in'条件选项。
4、对于字符串类型，如果为不易改变的字段，如name，phoneNumber等，需要'='和'like'条件的选项，必要时，还需要'in'条件选项；对于如desc、remark等容易改变的信息字段，只需提供'like'条件选项。
5、对于本表的记录ID字段，提供'='、'in'条件选项，如果记录ID与时间序列高度相关，则可能还需要'gte'和'lt'条件选项。
6、对于外键ID，提供'='、'in'条件选项。'in'条件选项用于分步查询，如查询：‘组织名称包含xxx的用户记录’，因为用户表没有组织名称字段（orgName），但有组织ID（orgId），因此需要先查询组织表，获取orgIdList，然后就可以在人员表中查询了。
7、对于数值量和日期字段，如有需要，提供'gte'、'lt'条件选项，特殊情况可再提供'gt'和'lte'以及'not between and'条件选项。
8、对于默认值为null的字段，提供'is null'和'is not null'条件选项。
9、与数据权限相关的字段，假设用户表的orgId字段涉及数据权限，用户只能查询本组织或给定组织列表的人员记录，则此字段需要'in'条件选项，以便后端服务层根据通过提供用户的orgId权限列表，过滤查询数据。如果通过其它途径已有了orgIdList集合，后端服务层还需要将数据权限要求的orgIdList与之取交集。
*/
5.5.2、根据key查询对象
根据key查询对象的方法名和形式如下所示：
/**
* @methodName : selectItemByKey
* @description : 根据key查询一个XXX对象
* @param keyPropName1 : 对象xxx的key1属性字段
* .... :
* @param keyPropNameN : 对象xxx的keyn属性字段，如果只有一个key字段，则无此参数,数据类型依据具体key而定
* @return : XXX对象
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public XXX selectItemByKey(@Param("keyPropName1") Integer keyPropName1,...,@Param("keyPropNameN") Integer keyPropNameN);
根据key查询对象，经常用于获取对象，以及存在性检查。
下面是根据key查询用户对象的方法示例：
/**
* @methodName : selectItemByKey
* @description : 根据key查询一个用户对象
* @param userId : 用户ID
* @return : 用户对象
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public User selectItemByKey(@Param("userId") Long userId);
5.5.3、查询对象记录数
查询对象记录数的方法名和形式如下所示：
/**
* @methodName : selectCount
* @description : 根据条件查询XXX对象的记录数
* @param params : 查询条件参数，形式如下：
* {
* 条件字段：
* "condPropName1" : 0, // condPropName1字段说明，可选
* ......
* "condPropNameN" : 0, // condPropNameN字段说明，可选
* }
* @return : XXX对象记录数
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public Integer selectCount(Map<String, Object> params);
查询记录条数，经常用于存在性检查，查询计数的性能要比查询记录列表高得多，且可以减少IO和内存的开销，因此也较为常用。
selectCount的条件选项一般与selectItems保持一致。
如果预见表的记录数规模会很大时，返回值类型可以改为Long型，一般情况，Integer型足够了。
5.5.4、根据唯一键查询对象
根据唯一键（或组合唯一键）查询对象的方法名和形式如下所示：
/**
* @methodName : selectItemByXXX
* @description : 根据XXX查询XXX对象
* @param uniPropName1 : 的唯一键组合属性字段1
* .... :
* @param uniPropNameN : 的唯一键组合属性字段N，如果只有一个字段，则无此参数,数据类型依据具体key而定
* @return : XXX对象
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public XXX selectItemByXXX(@Param("uniPropName1") String uniPropName1,...,@Param("uniPropNameN") String uniPropNameN);
根据唯一键组合查询对象，此方法可以完全被selectItems覆盖，但是由于Map<String, Object>类型的参数构造比较费代码，需要创建Map对象，然后再赋值，查询结果还是一个List类型。对于结果为唯一对象（或为null）的查询，服务层往往希望有简单的接口形式。因此，如果确定某些属性（或组合属性）是唯一时，可以提供此方法。
一个对象，可能有多个唯一字段或唯一组合，因此每个都需要提供类似方法。如用户对象，登录名是唯一的。还有一些属性，有值时是唯一的，如手机号码、email账号、身份证号码、微信小程序openid、微信公众号openid等，这些准唯一字段，也需要提供类似方法，但是调用时，需要判断是否为例外情况，如为空串，则不能调用，否则会抛出异常。另外，由于准唯一字段，数据库层面没有使用uniquekey约束，所有的唯一性约束是通过代码层面控制的，数据库记录层面看，并没有唯一性要求，为避免意外（如记录被人工修改失去唯一性），调用时应加try/catch进行保护。
下面是根据用户名查询用户对象的方法示例：
/**
* @methodName : selectItemByUserName
* @description : 根据用户名（登录）查询用户对象
* @param userName : 用户名
* @return : 用户对象
* @history :
* ------------------------------------------------------------------------------
* date version modifier remarks
* ------------------------------------------------------------------------------
* yyyy/mm/dd 1.0.0 author 初版
*
*/
public User selectItemByUserName(@Param("userName") String userName);
6、Mybatis脚本
Mybatis提供操作访问数据库表的接口方法的实现，文件命名为XXXDaoMapper.xml。代码形式如下：
<?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.abc.example.dao.UserDao">
</mapper>
6.1、新增单条记录
新增单条记录，方法名为insertItem，使用insert标签，参数为实体类对象。分自增ID和非自增ID。非自增ID，ID可以是全局ID，或用户指定ID，需要在调用dao接口前赋值。
由于数据类型可以通过实体类对象反射获取，因此无需表明JDBC数据类型；另外，由于实体类的属性都有默认值，因此，insert语句变得很简单。create_time和update_time字段，由数据库维护，无需新增。
6.1.1、自增ID的新增单条记录
示例代码如下：
<insert id="insertItem" parameterType="com.abc.example.entity.User">
<selectKey keyProperty="userId" order="AFTER" resultType="java.lang.Long">
SELECT LAST_INSERT_ID()
</selectKey>
INSERT INTO exa_users(
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag
)
VALUES(
#{userId},#{userName},#{password},#{salt},#{userType},#{orgId},#{realName},#{email},
#{phoneNumber},#{sex},#{birth},#{idNo},#{openId},#{woaOpenid},#{remark},
#{operatorName},#{deleteFlag}
)
</insert>
6.1.2、非自增ID的新增单条记录
示例代码如下：
<insert id="insertItem" parameterType="com.abc.example.entity.User">
INSERT INTO exa_users(
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag
)
VALUES(
#{userId},#{userName},#{password},#{salt},#{userType},#{orgId},#{realName},#{email},
#{phoneNumber},#{sex},#{birth},#{idNo},#{openId},#{woaOpenid},#{remark},
#{operatorName},#{deleteFlag}
)
</insert>
6.2、批量新增记录
批量单条记录，方法名为insertItems，使用insert标签，参数为实体类对象列表。分自增ID和非自增ID。非自增ID，需要在调用dao接口前赋值。
批量新增语句，使用foreach标签来实现对列表的遍历。
6.2.1、自增ID的批量新增记录
示例代码如下：
<insert id="insertItems" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="userId">
INSERT INTO exa_users(
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag
)
VALUES
<foreach collection ="list" item="item" index= "index" separator =",">
(
#{item.userId},#{item.userName},#{item.password},#{item.salt},#{item.userType},
#{item.orgId},#{item.realName},#{item.email},#{item.phoneNumber},#{item.sex},
#{item.birth},#{item.idNo},#{item.openId},#{item.woaOpenid},#{item.remark},
#{item.operatorName},#{item.deleteFlag}
)
</foreach>
</insert>
6.2.2、非自增ID的批量新增记录
示例代码如下：
<insert id="insertItems" parameterType="java.util.List">
INSERT INTO exa_users(
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag
)
VALUES
<foreach collection ="list" item="item" index= "index" separator =",">
(
#{item.userId},#{item.userName},#{item.password},#{item.salt},#{item.userType},
#{item.orgId},#{item.realName},#{item.email},#{item.phoneNumber},#{item.sex},
#{item.birth},#{item.idNo},#{item.openId},#{item.woaOpenid},#{item.remark},
#{item.operatorName},#{item.deleteFlag}
)
</foreach>
</insert>
6.3、修改单条记录
修改单条记录，方法名为updateItemByKey，使用update标签。参数为Map<String,Object>类型，由于参数项的值的类型为Object，因此需表明JDBC数据类型；另外，允许修改部分字段，即每个修改字段都是可选的，条件字段为对象的key值。create_time和update_time字段，由数据库维护，不允许修改。
示例代码如下：
<update id="updateItemByKey" parameterType="java.util.Map">
UPDATE
exa_users
<set>
<if test='userId != null'>
user_id = #{userId,jdbcType=BIGINT},
</if>
<if test='userName != null'>
user_name = #{userName,jdbcType=VARCHAR},
</if>
<if test='password != null'>
password = #{password,jdbcType=VARCHAR},
</if>
<if test='salt != null'>
salt = #{salt,jdbcType=VARCHAR},
</if>
<if test='userType != null'>
user_type = #{userType,jdbcType=TINYINT},
</if>
<if test='orgId != null'>
org_id = #{orgId,jdbcType=INTEGER},
</if>
<if test='realName != null'>
real_name = #{realName,jdbcType=VARCHAR},
</if>
<if test='email != null'>
email = #{email,jdbcType=VARCHAR},
</if>
<if test='phoneNumber != null'>
phone_number = #{phoneNumber,jdbcType=VARCHAR},
</if>
<if test='sex != null'>
sex = #{sex,jdbcType=TINYINT},
</if>
<if test='birth != null'>
birth = #{birth,jdbcType=TIMESTAMP},
</if>
<if test='idNo != null'>
id_no = #{idNo,jdbcType=VARCHAR},
</if>
<if test='openId != null'>
open_id = #{openId,jdbcType=VARCHAR},
</if>
<if test='woaOpenid != null'>
woa_openid = #{woaOpenid,jdbcType=VARCHAR},
</if>
<if test='remark != null'>
remark = #{remark,jdbcType=VARCHAR},
</if>
<if test='operatorName != null'>
operator_name = #{operatorName,jdbcType=VARCHAR},
</if>
<if test='deleteFlag != null'>
delete_flag = #{deleteFlag,jdbcType=TINYINT},
</if>
</set>
WHERE
user_id = #{userId,jdbcType=BIGINT}
</update>
示例代码中，user_id = #{userId,jdbcType=BIGINT}确保修改字段为空时，语句仍可以正常执行，此时表记录没有任何改动。
6.4、批量修改记录
批量修改记录，方法名为updateItems，使用update标签。参数为Map<String,Object>类型，由于参数项的值的类型为Object，因此需表明JDBC数据类型；批量修改的字段和条件，由业务需求决定。调用前应确保至少有一个修改字段。
示例代码如下：
<update id="updateItems" parameterType="java.util.Map">
UPDATE
exa_users
<set>
<if test='orgId != null'>
org_id = #{orgId,jdbcType=INTEGER},
</if>
<if test='userType != null'>
user_type = #{userType,jdbcType=TINYINT},
</if>
<if test='deleteFlag != null'>
delete_flag = #{deleteFlag,jdbcType=TINYINT},
</if>
<if test='operatorName != null'>
operator_name = #{operatorName,jdbcType=VARCHAR},
</if>
</set>
WHERE
1 = 1
<if test='userIdList != null and userIdList.size != 0'>
AND user_id IN
<foreach collection ="userIdList" item="userId" index= "index" open="(" close=")" separator =",">
#{userId}
</foreach>
</if>
<if test='userName != null'>
AND user_name = #{userName,jdbcType=VARCHAR}
</if>
<if test='phoneNumber != null'>
AND phone_number = #{phoneNumber,jdbcType=VARCHAR}
</if>
</update>
updateItems方法，包含了条件不为key字段的修改方法以及批量修改记录方法。
6.5、删除单条记录
删除单条记录，方法名为deleteItemByKey，使用delete标签。参数为对象的key值，由接口的@Param注解确定，由于数据类型已明确，因此无需表明JDBC数据类型。一般支持物理删除的关系表，需要删除方法，下例为用户角色表的记录删除方法。
示例代码如下：
<delete id="deleteItemByKey">
DELETE FROM
exa_user_roles
WHERE
user_id = #{userId} AND
role_id = #{roleId}
</delete>
6.6、批量删除记录
批量删除记录，方法名为deleteItems，使用delete标签。参数为Map<String,Object>类型，由于参数项的值的类型为Object，因此需表明JDBC数据类型；批量修改的字段和条件，由业务需求决定。调用前应确保至少有一个条件字段（否则为全表删除了）。一般支持物理删除的关系表，需要批量删除方法，下例为用户角色表的批量删除记录方法。
示例代码如下：
<delete id="deleteItems" parameterType="java.util.Map">
DELETE FROM
exa_user_roles
WHERE
1 = 1
<if test='roleId != null'>
AND role_id = #{roleId,jdbcType=INTEGER}
</if>
<if test='userId != null'>
AND user_id = #{userId,jdbcType=BIGINT}
</if>
</delete>
上述示例代码，允许删除指定userId的所有用户角色数据，或指定roleId的所有用户角色数据。
6.7、查询记录
查询记录，使用select标签。CRUD通用查询语句（不包括子查询、分组查询、UNION等特殊查询）包含4个部分：查询字段集、数据表及表的联结关系、查询条件、排序选项。
查询字段集，是实体类字段的一个子集或全集。
数据表及表的联结关系，包括主表和外键参照表，一般使用内联结（INNER JOIN），由于查询语句的执行次序优先执行ON的过滤，以避免庞大的笛卡尔乘积数，因此应使用JOIN..ON形式，而不是FROM table1,table2 WHERE形式。
如果外键数目较多，应考虑分步查询或结合缓存赋值。原则上，除主表外，最多联结3个表。
查询条件，根据5.3节的条件字段命名规范，确定查询条件。
排序选项，使用SortField列表sortList，理论上，所有字段都可以排序。考虑到SQL注入问题，排序选项的代码会显得冗长。
6.7.1、查询单条记录
查询单条记录，方法名为selectItemByKey，使用select标签。参数为对象的key值，由接口的@Param注解确定，由于数据类型已明确，因此无需表明JDBC数据类型。
示例代码如下：
<select id="selectItemByKey" resultType="com.abc.example.entity.User">
SELECT
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag,create_time,update_time
FROM
exa_users
WHERE
user_id = #{userId,jdbcType=BIGINT}
</select>
上述示例代码，为单表查询。但是实体类User还需要对orgName外键引用字段进行赋值（往往前端页面需要），这可根据org_id字段查询exa_orgnizations表获取。由于所有查询都有类似外键引用字段问题需要处理，在下节selectItems方法时进一步讨论。
6.7.2、查询记录列表
查询记录列表，方法名为selectItems，使用select标签。参数为Map<String,Object>类型。
示例代码如下：
<select id="selectItems" resultType="com.abc.example.entity.User">
SELECT
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag,create_time,update_time
FROM
exa_users
WHERE
1 = 1
<if test='userId != null'>
AND user_id = #{userId,jdbcType=BIGINT}
</if>
<if test='userIdList != null and userIdList.size != 0'>
AND user_id IN
<foreach collection ="userIdList" item="userId" index= "index" open="(" close=")" separator =",">
#{userId}
</foreach>
</if>
<if test='userName != null'>
AND user_name = #{userName,jdbcType=VARCHAR}
</if>
<if test='userNameLike != null'>
AND user_name LIKE CONCAT('%',#{userNameLike,jdbcType=VARCHAR},'%')
</if>
<if test='userType != null'>
AND user_type = #{userType,jdbcType=TINYINT}
</if>
<if test='userTypeList != null and userTypeList.size != 0'>
AND user_type IN
<foreach collection ="userTypeList" item="userType" index= "index" open="(" close=")" separator =",">
#{userType}
</foreach>
</if>
<if test='sex != null'>
AND sex = #{sex,jdbcType=TINYINT}
</if>
<if test='deleteFlag != null'>
AND delete_flag = #{deleteFlag,jdbcType=TINYINT}
</if>
<if test='phoneNumber != null'>
AND phone_number = #{phoneNumber,jdbcType=VARCHAR}
</if>
<if test='phoneNumberLike != null'>
AND phone_number LIKE CONCAT('%',#{phoneNumberLike,jdbcType=VARCHAR},'%')
</if>
<if test='realNameLike != null'>
AND real_name LIKE CONCAT('%',#{realNameLike,jdbcType=VARCHAR},'%')
</if>
<if test='email != null'>
AND email = #{email,jdbcType=VARCHAR}
</if>
<if test='emailLike != null'>
AND email LIKE CONCAT('%',#{emailLike,jdbcType=VARCHAR},'%')
</if>
<if test='birthGte != null'>
AND birth >= #{birthGte,jdbcType=TIMESTAMP}
</if>
<if test='birthLte != null'>
AND birth <= #{birthLte,jdbcType=TIMESTAMP}
</if>
<if test='orgId != null'>
AND org_id = #{orgId,jdbcType=INTEGER}
</if>
<if test='orgIdList != null and orgIdList.size != 0'>
AND org_id IN
<foreach collection ="orgIdList" item="orgId" index= "index" open="(" close=")" separator =",">
#{orgId}
</foreach>
</if>
<if test='openId != null'>
AND open_id = #{openId,jdbcType=VARCHAR}
</if>
<if test='woaOpenid != null'>
AND woa_openid = #{woaOpenid,jdbcType=VARCHAR}
</if>
<if test='sortList != null and sortList.size != 0'>
ORDER BY
<foreach collection ="sortList" item="sortItem" index= "index" open="" close="" separator =",">
<choose>
<when test='sortItem.fieldName == "userId"'>
<choose>
<when test='sortItem.sortOrder == 0'>
user_id ASC
</when>
<otherwise>
user_id DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "userName"'>
<choose>
<when test='sortItem.sortOrder == 0'>
user_name ASC
</when>
<otherwise>
user_name DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "password"'>
<choose>
<when test='sortItem.sortOrder == 0'>
password ASC
</when>
<otherwise>
password DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "salt"'>
<choose>
<when test='sortItem.sortOrder == 0'>
salt ASC
</when>
<otherwise>
salt DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "userType"'>
<choose>
<when test='sortItem.sortOrder == 0'>
user_type ASC
</when>
<otherwise>
user_type DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "orgId"'>
<choose>
<when test='sortItem.sortOrder == 0'>
org_id ASC
</when>
<otherwise>
org_id DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "realName"'>
<choose>
<when test='sortItem.sortOrder == 0'>
real_name ASC
</when>
<otherwise>
real_name DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "email"'>
<choose>
<when test='sortItem.sortOrder == 0'>
email ASC
</when>
<otherwise>
email DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "phoneNumber"'>
<choose>
<when test='sortItem.sortOrder == 0'>
phone_number ASC
</when>
<otherwise>
phone_number DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "sex"'>
<choose>
<when test='sortItem.sortOrder == 0'>
sex ASC
</when>
<otherwise>
sex DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "birth"'>
<choose>
<when test='sortItem.sortOrder == 0'>
birth ASC
</when>
<otherwise>
birth DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "idNo"'>
<choose>
<when test='sortItem.sortOrder == 0'>
id_no ASC
</when>
<otherwise>
id_no DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "openId"'>
<choose>
<when test='sortItem.sortOrder == 0'>
open_id ASC
</when>
<otherwise>
open_id DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "woaOpenid"'>
<choose>
<when test='sortItem.sortOrder == 0'>
woa_openid ASC
</when>
<otherwise>
woa_openid DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "remark"'>
<choose>
<when test='sortItem.sortOrder == 0'>
remark ASC
</when>
<otherwise>
remark DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "operatorName"'>
<choose>
<when test='sortItem.sortOrder == 0'>
operator_name ASC
</when>
<otherwise>
operator_name DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "deleteFlag"'>
<choose>
<when test='sortItem.sortOrder == 0'>
delete_flag ASC
</when>
<otherwise>
delete_flag DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "createTime"'>
<choose>
<when test='sortItem.sortOrder == 0'>
create_time ASC
</when>
<otherwise>
create_time DESC
</otherwise>
</choose>
</when>
<when test='sortItem.fieldName == "updateTime"'>
<choose>
<when test='sortItem.sortOrder == 0'>
update_time ASC
</when>
<otherwise>
update_time DESC
</otherwise>
</choose>
</when>
</choose>
</foreach>
</if>
<if test='rows != null'>
<choose>
<when test='offset != null'>
LIMIT #{offset,jdbcType=INTEGER},#{rows,jdbcType=INTEGER}
</when>
<otherwise>
LIMIT #{rows,jdbcType=INTEGER}
</otherwise>
</choose>
</if>
</select>
上述示例代码，为单表查询。
查询条件，使用了5.3节规定的命名规则，从而允许同一个字段的不同查询条件选项。其中对于List条件，空集等于全集，这是由于全集往往是一个很大的数据集，使用空集表示可简化处理，并且sql语句不支持"in ()"的空集形式。列表的无效集（真正的空集），可以使用一个无效的数据，如[-1]来表示。
排序选项，根据sortList列表次序，确定排序字段和排序方法。由于避免使用会引入SQL注入的"${field_name}"形式，因此需要遍历所有可排序的字段。如果sortList列表为空或空集，则使用默认排序（主键字段排序）。
LIMIT选项参数（rows和offset），可用于分页查询。单元测试辅助服务类，使用此参数，获取一定数量的样本记录。
6.7.3、外键引用字段查询
实体类有一些外键引用字段，如User对象的orgName，其根据org_id，查询exa_orgnizations表获取。
有三种处理方法，方法1为联结表查询；方法2为分步查询；方法3为分步查询结合缓存赋值。假设用户表exa_users有10万条记录，组织表exa_orgnizations有1000条记录，下面比较各种处理方法的优劣。
方法1：联结表查询，即联结exa_users和exa_orgnizations表，获取org_name值。代码如下：
<select id="selectItems" resultType="com.abc.example.entity.User">
SELECT
t1.user_id,t1.user_name,t1.password,t1.salt,t1.user_type,t1.org_id,t1.real_name,t1.email,
t1.phone_number,t1.sex,t1.birth,t1.id_no,t1.open_id,t1.woa_openid,t1.remark,
t1.operator_name,t1.delete_flag,t1.create_time,t1.update_time,
t2.org_name
FROM
exa_users t1
INNER JOIN
exa_orgnizations t2
ON
t1.org_id = t2.org_id
WHERE
...
</select>
方法1，联结查询，为了提升查询性能，此时主表应建立外键（如exa_users表的org_id字段）的索引。使用Explain对查询语句进行性能分析，优化查询语句。如果使用"t2.org_name like '%a%'"的查询条件，由于需要全表扫描联结后数据（10万条），大致需要1秒量级完成查询，性能不如方法2（分步单表查询）。
方法1的优点是处理代码比较简单；缺点是可能有性能问题。
方法2：分步查询，即将联结查询拆分为单表查询或更少联结表的查询。为了提升查询性能，此时主表仍应建立外键（如exa_users表的org_id字段）的索引。
如查询用户数据，分两种情况。
情况1：查询条件不包含exa_orgnizations表字段的查询条件，则先查询exa_users表，获取userList，然后获取不重复的orgIdList，再查询exa_orgnizations表，并建立字典(orgId到Orgnization对象的字典)，然后逐个给userList的项设置orgName值。
情况2：查询条件如果包含exa_orgnizations表的查询条件，如"org_name like '%a%'"，则先查询exa_orgnizations表，获取orgList，并建立字典(orgId到Orgnization对象的字典)，然后获取不重复的orgIdList，再根据orgIdList条件和exa_users表的其它条件，查询User记录，获取userList。然后逐个给userList的项设置orgName值。
对于情况1，由于exa_orgnizations表的org_id字段为主键字段，因此orgIdList的查询条件对性能影响可以忽略不计，第二次查询时间消耗很少，主要是代码处理处理复杂度有所增加。由于需要使用外键引用字段，一般为前端，此时往往使用分页查询，假设每页50条记录，则处理orgName属性值的时间一般不超过50ms（在1000条记录中查询orgIdList，大致需要20ms，然后是内存处理）。
对于情况2，由于exa_users表的org_id字段为索引字段，因此orgIdList的查询条件对exa_users表的查询性能影响可以忽略不计。exa_orgnizations表的查询，由于like条件不支持索引，使用全表扫描，在一个较小的数据集中搜索（1000条记录），大致需要50ms，结合内存处理，总时间不超过100ms。
方法2的优点是没有性能问题；缺点是处理代码比较复杂，对于情况1，需要频繁查询exa_orgnizations表。
方法3：分步查询结合缓存赋值。exa_users表的查询，同方法2，也分两种情况，但orgName的赋值，不必每次都查询exa_orgnizations表，而是使用缓存。由于组织Orgnization对象数目相对有限，且被多个实体类对象引用，因此可以使用缓存（单机部署可以直接使用内存，集群部署可使用Redis），关于缓存对象管理，后面将详细讨论。
情况1：查询条件不包含exa_orgnizations表字段的查询条件，则先查询exa_users表，获取userList，然后遍历userList的项，根据orgId，从缓存（一般为orgId到Orgnization对象的字典）中获取Orgnization对象，然后设置orgName值。
情况2：查询条件如果包含exa_orgnizations表的查询条件，如"org_name like '%a%'"，则先查询exa_orgnizations表，获取orgList，然后获取不重复的orgIdList，再根据orgIdList条件和exa_users表的其它条件，查询User记录，获取userList。然后逐个给userList的项设置orgName值。
方法3的优点是没有性能问题，相对于方法2，赋值处理得到简化，并且减少了对外键表的查询，处理性能更高；缺点是需要缓存管理，引入了缓存数据一致性的问题和生命周期管理。
缓存对象管理，需要系统层面进行统一设计。一般使用缓存的对象，是记录数相对较少（不到1万条）或增长非常缓慢的，且被多种实体类对象引用的对象。
在实际处理中，这3种方法都会使用。方法1，用于外键较少，且查询条件字段属于主表字段的情况；方法2，用于外键较多，且外表记录数较多，不适合建立缓存的的情况；方法3，用于外键对象使用缓存管理的。
6.7.4、查询记录数
查询记录数，方法名为selectCount，使用select标签。参数为Map<String,Object>类型，返回值为Integer或Long型。
示例代码如下：
<select id="selectCount" resultType="java.lang.Integer">
SELECT
COUNT(1)
FROM
exa_users
WHERE
1 = 1
<if test='userId != null'>
AND user_id = #{userId,jdbcType=BIGINT}
</if>
<if test='userIdList != null and userIdList.size != 0'>
AND user_id IN
<foreach collection ="userIdList" item="userId" index= "index" open="(" close=")" separator =",">
#{userId}
</foreach>
</if>
<if test='userName != null'>
AND user_name = #{userName,jdbcType=VARCHAR}
</if>
<if test='userNameLike != null'>
AND user_name LIKE CONCAT('%',#{userNameLike,jdbcType=VARCHAR},'%')
</if>
<if test='userType != null'>
AND user_type = #{userType,jdbcType=TINYINT}
</if>
<if test='userTypeList != null and userTypeList.size != 0'>
AND user_type IN
<foreach collection ="userTypeList" item="userType" index= "index" open="(" close=")" separator =",">
#{userType}
</foreach>
</if>
<if test='sex != null'>
AND sex = #{sex,jdbcType=TINYINT}
</if>
<if test='deleteFlag != null'>
AND delete_flag = #{deleteFlag,jdbcType=TINYINT}
</if>
<if test='phoneNumber != null'>
AND phone_number = #{phoneNumber,jdbcType=VARCHAR}
</if>
<if test='phoneNumberLike != null'>
AND phone_number LIKE CONCAT('%',#{phoneNumberLike,jdbcType=VARCHAR},'%')
</if>
<if test='realNameLike != null'>
AND real_name LIKE CONCAT('%',#{realNameLike,jdbcType=VARCHAR},'%')
</if>
<if test='email != null'>
AND email = #{email,jdbcType=VARCHAR}
</if>
<if test='emailLike != null'>
AND email LIKE CONCAT('%',#{emailLike,jdbcType=VARCHAR},'%')
</if>
<if test='birthGte != null'>
AND birth >= #{birthGte,jdbcType=TIMESTAMP}
</if>
<if test='birthLte != null'>
AND birth <= #{birthLte,jdbcType=TIMESTAMP}
</if>
<if test='orgId != null'>
AND org_id = #{orgId,jdbcType=INTEGER}
</if>
<if test='orgIdList != null and orgIdList.size != 0'>
AND org_id IN
<foreach collection ="orgIdList" item="orgId" index= "index" open="(" close=")" separator =",">
#{orgId}
</foreach>
</if>
<if test='openId != null'>
AND open_id = #{openId,jdbcType=VARCHAR}
</if>
<if test='woaOpenid != null'>
AND woa_openid = #{woaOpenid,jdbcType=VARCHAR}
</if>
</select>
6.7.5、根据唯一键或准唯一键查询记录
根据唯一键或准唯一键查询记录，方法名为selectItemByXXX，使用select标签。参数为对象的key值，由接口的@Param注解确定，返回值为对象记录。
示例代码如下：
<select id="selectItemByUserName" resultType="com.abc.example.entity.User">
SELECT
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag,create_time,update_time
FROM
exa_users
WHERE
user_name = #{userName,jdbcType=VARCHAR}
</select>
<select id="selectItemByPhoneNumber" resultType="com.abc.example.entity.User">
SELECT
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag,create_time,update_time
FROM
exa_users
WHERE
phone_number = #{phoneNumber,jdbcType=VARCHAR}
</select>
<select id="selectItemByIdNo" resultType="com.abc.example.entity.User">
SELECT
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag,create_time,update_time
FROM
exa_users
WHERE
id_no = #{idNo,jdbcType=VARCHAR}
</select>
<select id="selectItemByOpenId" resultType="com.abc.example.entity.User">
SELECT
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag,create_time,update_time
FROM
exa_users
WHERE
open_id = #{openId,jdbcType=VARCHAR}
</select>
<select id="selectItemByWoaOpenid" resultType="com.abc.example.entity.User">
SELECT
user_id,user_name,password,salt,user_type,org_id,real_name,email,phone_number,sex,
birth,id_no,open_id,woa_openid,remark,operator_name,delete_flag,create_time,update_time
FROM
exa_users
WHERE
woa_openid = #{woaOpenid,jdbcType=VARCHAR}
</select>
对于准唯一键，调用dao接口前，需排除例外情况（如手机号码允许为空串）。如果查询结果集超过一条记录，会抛出异常，因此调用时，需要用try/catch进行保护。
（未完待续...）
文章来源：https://www.toymoban.com/news/detail-479767.html
到了这里，关于Spring Boot实现高质量的CRUD-2的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
