JeeSite中基本注解以及基本语句的使用
常见的API
@Table
/**
* 指定实体的物理表属性
* @author ThinkGem
*/
public @interface Table {
/**
* 物理表名
*/
String name() default "";
/**
* 当前表别名
*/
String alias() default "a";
/**
* 表列定义
*/
Column[] columns();
/**
* 查询，关联表
*/
JoinTable[] joinTable() default {};
/**
* 指定排序
*/
String orderBy() default "";
/**
* 表说明
*/
String comment() default "";
/**
* 扩展ColumnSQL，在这里指定sqlMap的key。
* 例如：\@Table(extColumnKeys="dataScopeColumn");
* Service里设置：sqlMap.put("extColumn", "column_name AS \"columnName\"");
* 在执行查询的时候，该语句放到自动会加到Select最后并执行。
* 注意：如果设置，必须后台代码中设置，否则可能造成sql注入漏洞
*/
String extColumnKeys() default "";
/**
* 扩展FromSQL，在这里指定sqlMap的key。
* 例如：\@Table(extFromKeys="dataScopeFrom");
* Service里设置：sqlMap.put("dataScopeFrom", "JOIN table_name t on t.pk=a.pk");
* 在执行查询的时候，该语句放到自动会加到From最后并执行。
* 注意：如果设置，必须后台代码中设置，否则可能造成sql注入漏洞
*/
String extFromKeys() default "";
/**
* 扩展WhereSQL，在这里指定sqlMap的key。
* 例如：\@Table(extWhereKeys="dataScopeWhere");
* Service里设置：sqlMap.put("dataScopeWhere", "AND column_name='value'");
* 在执行查询的时候，该语句放到自动会加到Where最后并执行。
* 注意：如果设置，必须后台代码中设置，否则可能造成sql注入漏洞
*/
String extWhereKeys() default "";
}
@Column
/**
* 定义物理表列属性（不继承父类注解）
* @author ThinkGem
*/
public @interface Column {
/**
* 字段名（例如：config_key）
*/
String name() default "";
/**
* java类型 V4.0.6+
*/
Class<?> javaType() default void.class;
/**
* jdbc类型 V4.0.6+
*/
JdbcType jdbcType() default JdbcType.UNDEFINED;
/**
* 类型处理器注册器 V4.0.6+
*/
Class<? extends TypeHandler<?>> typeHandler() default UnknownTypeHandler.class;
/**
* 属性名，若不指定，则根据name()字段名进行驼峰命名法转换（例如：config_key 转换为 configKey）
*/
String attrName() default "";
/**
* 标签名
*/
String label() default "";
/**
* 字段备注
*/
String comment() default "";
/**
* 是否主键（update、delete时的条件）
*/
boolean isPK() default false;
/**
* 是否插入字段
*/
boolean isInsert() default true;
/**
* 是否更新字段
*/
boolean isUpdate() default true;
/**
* 是否更新字段（强制更新）V4.0.5+
*/
boolean isUpdateForce() default false;
/**
* 是否是查询字段
*/
boolean isQuery() default true;
/**
* 查询类型
*/
QueryType queryType() default QueryType.EQ;
/**
* 包含嵌入一个实体
*/
Class<?> includeEntity() default Class.class;
}
@JoinTable
/**
* 指定实体的物理表的关联表属性
* @author ThinkGem
*/
public @interface JoinTable {
/**
* 连接类型
*/
Type type() default Type.JOIN;
public enum Type{
JOIN("JOIN"), // INNER JOIN
LEFT_JOIN("LEFT JOIN"),
RIGHT_JOIN("RIGHT JOIN");
private final String value;
Type(String value) { this.value = value; }
public String value() { return this.value; }
}
/**
* 连接的表，指定实体Class
*/
Class<?> entity();
/**
* 当前表别名
*/
String alias();
/**
* 连接表条件
*/
String on();
/**
* 对应主表中对应的属性名，若不指定，则根据entity()进行首字母小写得到属性名（例如：Config 转换为 config）
*/
String attrName() default "";
/**
* 连接表，返回的列，若不指定，则读取entity()的所有列。
*/
Column[] columns() default {};
}
@QueryType
/**
* 查询类型
* @author ThinkGem
*/
public enum QueryType{
EQ("="),
NE("!="),
GT(">"),
GTE(">="),
LT("<"),
LTE("<="),
IN("IN"), // 接受 Object[] 或 List 参数
NOT_IN("NOT IN"),
LIKE("LIKE", "%", "%"),
LEFT_LIKE("LIKE", "%", ""),
RIGHT_LIKE("LIKE", "", "%"),
IS_NULL("IS NULL"),
IS_NOT_NULL("IS NOT NULL"),
// 强制条件，不管值是不是空字符串都加载这个查询条件
EQ_FORCE("=", true),
NE_FORCE("!=", true),
;
}
在JeeSite中，一些基本语句能够通过配置注解完成，JeeSite本生封装了基本的sql语句，只需要配置好实体类就好，如配好@Table，@column，service层只需要继承JeeSite提供的CrudDao抽象类（该类中封装了具体的增删该差的一些基本方法），在对应的泛型中填写需要进行操作的实体类，然后就能通过注入的方式使用JeeSite提供的基本的一些方法对相应的数据库进行对应的增删改查的操作了。
CrudDao中的一些常见的方法
/**
* DAO实现增删改接口
* @author ThinkGem
*/
public interface CrudDao<T> extends QueryDao<T> {
/**
* 插入数据
*/
public int insert(T entity);
/**
* 批量插入数据
*/
public int insertBatch(List<T> entityList);
/**
* 更新数据 By PK
*/
public int update(T entity);
/**
* 更新数据 By Entity
* 调用此方法前，请务必检查whereEntity的数据准确性，否则可能会造成不想要更新的数据被更新
*/
public int updateByEntity(T entity, T whereEntity);
/**
* 更新状态数据 By PK
*/
public int updateStatus(T entity);
/**
* 更新状态数据 By Entity
* 调用此方法前，请务必检查whereEntity的数据准确性，否则可能会造成不想要更新的数据被更新
*/
public int updateStatusByEntity(T entity, T whereEntity);
/**
* 删除数据 By PK（如果有status字段，则为逻辑删除，更新status字段为1，否则物理删除）
*/
public int delete(T whereEntity);
/**
* 删除数据 By Entity（如果有status字段，则为逻辑删除，更新status字段为1，否则物理删除）
* 调用此方法前，请务必检查whereEntity的数据准确性，否则可能会造成不想要更新的数据被更新
*/
public int deleteByEntity(T whereEntity);
/**
* 物理数据 By PK
*/
public int phyDelete(T whereEntity);
/**
* 物理数据 By Entity
* 调用此方法前，请务必检查whereEntity的数据准确性，否则可能会造成不想要更新的数据被更新
*/
public int phyDeleteByEntity(T whereEntity);
/**
* 获取单条数据
* @param entity
* @return entity
*/
public T get(T entity);
/**
* 获取单条数据
* @param entity
* @return entity
*/
public T getByEntity(T entity);
/**
* 查询数据列表，如果需要分页，请设置分页对象，如：entity.setPage(new Page(pageNo, pageSize));
* @param entity
* @return
*/
public List<T> findList(T entity);
/**
* 查询数据总数
* @param entity
* @return
*/
public long findCount(T entity);
}
JeeSite的日期范围查询
////////// 日期范围查询，gte，lte ////////////////
public Date getCreateDate_gte(){
return sqlMap.getWhere().getValue("create_date", QueryType.GTE);
}
public void setCreateDate_gte(Date createDate){
createDate = DateUtils.getOfDayFirst(createDate); // 将日期的时间改为0点0分0秒
sqlMap.getWhere().and("create_date", QueryType.GTE, createDate);
}
public Date getCreateDate_lte(){
return sqlMap.getWhere().getValue("create_date", QueryType.LTE);
}
public void setCreateDate_lte(Date createDate){
createDate = DateUtils.getOfDayLast(createDate); // 将日期的时间改为23点59分59秒
sqlMap.getWhere().and("create_date", QueryType.LTE, createDate);
}
双重字段查询
///////// 双重字段查询，支持eq，支持like ////////////////
public String getTableName() {
return StringUtils.lowerCase(tableName);
}
public void setTableName(String tableName) {
this.tableName = tableName;
}
public String getTableName_like() {
return sqlMap.getWhere().getValue("table_name", QueryType.LIKE);
}
public void setTableName_like(String tableName) {
sqlMap.getWhere().and("table_name", QueryType.LIKE, tableName);
}
扩展括号查询
////////// 支持 or、is null，括号 ////////////////
public String getParentTableName_isNull() {
return this.getParentTableName();
}
public void setParentTableName_isNull(String parentTableName) {
if (StringUtils.isBlank(parentTableName)){
sqlMap.getWhere().andBracket("parent_table_name", QueryType.IS_NULL, null, 2)
.or("parent_table_name", QueryType.EQ_FORCE, "", 3).endBracket();
this.setParentTableName(null);
}else{
this.setParentTableName(parentTableName);
}
}
支持 IN 条件查询
////////// 支持 in、not in 条件查询 ////////////////
public String[] getCategoryCode_in(){
return sqlMap.getWhere().getValue("category_code", QueryType.IN);
}
public void setCategoryCode_in(String[] codes){
sqlMap.getWhere().and("category_code", QueryType.IN, codes);
}
扩展自定义列
还有一种情况，如所有的配置都配置好了，我只需要在sql返回值里加一个简单的统计数，多返回一列，你可以这样写：
// 实体类定义
@Table(name="${_prefix}gen_table", alias="a", columns={
// @Column 。。。此处省略 。。。
},
// 扩展Column里指定一个Key名字，类里并定义一个需要返回的属性和get set
extColumnKeys="extColumn"
)
public class GenTable extends DataEntity<GenTable> {
private Long childNum; // 子表个数
public Long getChildNum() {
return childNum;
}
public void setChildNum(Long childNum) {
this.childNum = childNum;
}
}
// Service 里，通过sqlMap设置你刚定义的Key即可，如下
public Page<GenTable> findPage(Page<GenTable> page, GenTable genTable) {
// 添加扩展列，查询子表个数（子查询）
String extColumn = "(SELECT count(1) FROM "+MapperHelper.getTableName(genTable)
+" WHERE parent_table_name=a.table_name) AS \"childNum\"";
genTable.getSqlMap().add("extColumn", extColumn);
return super.findPage(page, genTable);
}
多表联合查询
如果你的表里只存储了code编码，未存储name名称，你需要通过code来联合查询出name。 但实体里联合查询的表不是以实体存在的，而定义在了当前实体中，这时候应该指定JoinTable的attrName为this，代表将数据映射到当前实体，举例如下：
@Table(name="${_prefix}test", alias="a", columns={
// 此处省略...
@Column(name="test_code", attrName="testCode", label="编码（外键）"),
},
// 联合查询出外键编码的名称数据（attrName="this"，指定this代表，当前实体）
joinTable={
@JoinTable(type=Type.LEFT_JOIN, entity=Test2.class, attrName="this", alias="b",
on="b.code = a.test_code",
columns={
@Column(name="name", attrName="testName", label="名称"),
}),
},
orderBy="a.update_date DESC"
)
public class Test extends DataEntity<Test> {
private static final long serialVersionUID = 1L;
// 此处省略...
private String testCode; // 编码（外键，Test2关联表的主键）
private String testName; // 名称（改属性是关联表字段，不是本表字段）
/// 省略 get set 方法
}
复杂语句查询
如果以上仍得不到你的满足，怎么办，那你可以写Mapper.xml了，比如EmployeeDao.xml一些通用的字段、条件，你就不需要在xml再写一遍了，你只需要补充SQL即可（相同id,如id=”findList”则会自动覆盖默认设置）：
<select id="findList" resultType="Employee">
SELECT ${sqlMap.column.toSql('a')}
FROM ${_prefix}sys_employee a
<where>
${sqlMap.where.toSql('a')}
</where>
ORDER BY ${sqlMap.order.toSql('a')}
</select>
覆写自带 Mapper 的语句
平台支持 mapper xml 的 select/update/delete 设置 weight 权重属性，指定相同的 key 权重高的优先加载，权重低的将被忽略（4.1.3+）。
例如，你想覆写自带的 UserUtils.getByLoginCode 查询语句如下：
<?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.jeesite.modules.sys.dao.UserDao">
<!-- 根据登录名查询用户（不区分大小写），指定 weight 即可覆写 -->
<select id="getByLoginCode" resultType="User" weight="100">
SELECT ${sqlMap.column.toSql()}
FROM ${sqlMap.table.toSql()}
WHERE a.status != #{STATUS_DELETE}
AND upper(a.login_code) = upper(#{loginCode})
</select>
</mapper>
指定 typeHandler
有些情况可能需要复杂类型，这时候你就用到了 typeHandler 个性化类型：
@Table(name="m_banner", alias="a", columns={
@Column(name="bind_items", attrName="bindItems", label="绑定的数据", isQuery=false,
javaType=java.util.List.class, typeHandler=JsonTypeHandler.class),
}
以上方法适应于 “插入、更新、查询条件” 的参数类型设置，那么，如何给查询结果集指定 typeHeader？
你可以使用扩展 Mapper XML 来实现，如下：
<resultMap type="com.jeesite.modules.banner.entity.Banner" id="bannerDetail">
<result column="bindItems" property="bindItems"
javaType="java.util.List" typeHandler="com.jeesite.common.JsonTypeHandler"/>
</resultMap>
<select id="get" resultMap="bannerDetail">
SELECT ${sqlMap.column.toSql()}
FROM ${sqlMap.table.toSql()}
<where>
${sqlMap.where.toSql()}
</where>
ORDER BY ${sqlMap.order.toSql()}
</select>