版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/joefany/article/details/82693081
前置依赖：mybatis
1.上配置，因为项目中用了多数据源，所以指定了sqlSessionFactoryBeanName，单数据源不用指定。
<bean class="tk.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.joefany.test.dao,com.joefan.dao"/>
<property name="markerInterface" value="com.joefan.BaseDao"/>
<property name = "sqlSessionFactoryBeanName" value = "sqlSessionFactory"/>
<property name="properties" >
<value>
IDENTITY=mysql
</value>
</property>
</bean>2.BaseDao.java，继承了tk一系列增删改查的接口
/**
* basedao 基类
*/
public interface TkBaseDao<T> extends
BaseSelectMapper<T>,
BaseUpdateMapper<T>,
BaseDeleteMapper<T>,
ExampleMapper<T>,
RowBoundsMapper<T>,
Marker,
IdsMapper<T>,
SqlServerMapper<T>{
}3.BaseService.java,基类方法，包含了常用的增删改查方法
public abstract class BaseService<T, PK extends Serializable>{
private final static Logger logger = Logger.getLogger(TkBaseService.class);
/** 查询列表默认最大允许结果数量. */
private final static int LIST_MAX_LIMIT = 1000;
/** 实体类类型 */
private Class<T> entityClass;
private BaseDao<T> tTkBaseDao;
public void setTkBaseDao(BaseDao<T> baseDao) {
this.tTkBaseDao = baseDao;
}
public BaseService() {
Type type = getClass().getGenericSuperclass();
Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
entityClass = (Class<T>) parameterizedType[0];
}
public void save(T entity) {
try {
tTkBaseDao.insert(entity);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("保存对象错误!", e);
}
}
public void saveSelective(T entity) {
try {
tTkBaseDao.insertSelective(entity);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("保存对象错误!", e);
}
}
public void update(T entity) {
try {
tTkBaseDao.updateByPrimaryKey(entity);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("更新对象错误!", e);
}
}
public void updateSelective(T entity) {
try {
tTkBaseDao.updateByPrimaryKeySelective(entity);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("更新对象错误!", e);
}
}
public T find(PK id) {
try {
return tTkBaseDao.selectByPrimaryKey(id);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
public List<T> find(PK[] ids) {
try {
String s = StringUtils.join(ids, ",");
return tTkBaseDao.selectByIds(s);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
// public T find(Filter... filters) {
// try {
// Example example = new Example(entityClass);
// Criteria criteria = example.createCriteria();
// if (null != filters) {
// List<Filter> filterList = new ArrayList<>();
// Collect.addAll(filterList, filters);
// condition(criteria, filterList);
// }
//
// baseDao.select
// } catch (Exception e) {
//
// }
// }
public T find(String property, Object value) {
try {
T entity = entityClass.newInstance();
ReflectionUtils.setFieldValue(entity, property, value);
return tTkBaseDao.selectOne(entity);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
public T find(String[] properties, Object[] values) {
try {
T entity = entityClass.newInstance();
for (int i = 0; i < properties.length; i ++) {
ReflectionUtils.setFieldValue(entity, properties[i], values[i]);
}
return tTkBaseDao.selectOne(entity);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
// public void delete(PK[] ids) {
// try {
// String s = StringUtils.join(ids, ",");
// tTkBaseDao.deleteByIds(s);
// } catch (Exception e) {
// logger.error(e.getMessage(), e);
// throw new MessageException("删除失败!", e);
// }
// }
//
// public void delete(T entity) {
// try {
// tTkBaseDao.delete(entity);
// } catch (Exception e) {
// logger.error(e.getMessage(), e);
// throw new MessageException("删除失败!", e);
// }
// }
//
// public void delete(PK id) {
// try {
// tTkBaseDao.deleteByPrimaryKey(id);
// } catch (Exception e) {
// logger.error(e.getMessage(), e);
// throw new MessageException("删除失败!", e);
// }
// }
public void deleteOfLogical(PK id) {
try {
T entity = entityClass.newInstance();
ReflectionUtils.setFieldValue(entity, "id", id);
ReflectionUtils.setFieldValue(entity, "delFlag", "1");
tTkBaseDao.updateByPrimaryKeySelective(entity);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("删除失败!", e);
}
}
public List findAll() {
return tTkBaseDao.selectAll();
}
public int selectCount() {
try {
return selectCount(entityClass.newInstance());
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
public int selectCount(T entity) {
try {
return tTkBaseDao.selectCount(entity);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
public List<T> findList(String property, Object value) {
try {
Example example = new Example(entityClass);
Example.Criteria criteria = example.createCriteria();
criteria.andEqualTo(property, value);
return tTkBaseDao.selectByExample(example);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
public List<T> findList(String[] properties, Object[] values) {
try {
Example example = new Example(entityClass);
Example.Criteria criteria = example.createCriteria();
for (int i = 0; i < properties.length; i++) {
criteria.andEqualTo(properties[i], values[i]);
}
return tTkBaseDao.selectByExample(example);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
/**
* 查询列表.
* @param offset 开始位置
* @param limit 查询数量
* @param filters 条件
* @param orders 排序
* @return
*/
public List<T> findList(Integer offset, Integer limit, List<Filter> filters, List<Order> orders) {
try {
Example example = new Example(entityClass);
Example.Criteria criteria = example.createCriteria();
if (null != filters) {
condition(criteria, filters);
}
if (null != orders) {
String orderBy = " ";
for (int i = 0; i < orders.size(); i ++) {
Order order = orders.get(i);
if (i > 0) {
orderBy += ",";
}
orderBy += order.getProperty() + " " + order.getDirection().name();
}
example.setOrderByClause(orderBy);
}
if (null == offset) {
offset = 0;
}
if (null == limit) {
limit = LIST_MAX_LIMIT;
}
RowBounds rowBounds = new RowBounds(offset, limit);
return tTkBaseDao.selectByExampleAndRowBounds(example, rowBounds);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
/**
* 查询列表.
* @param filters - 过滤条件
* @param order - 排序
* @return 数据列表
*/
public List<T> findList(List<Filter> filters, Order order) {
try {
Example example = new Example(entityClass);
Example.Criteria criteria = example.createCriteria();
if (null != filters) {
condition(criteria, filters);
}
if (null != order) {
example.setOrderByClause(order.getProperty() + " " + order.getDirection().name());
}
return tTkBaseDao.selectByExample(example);
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new MessageException("查询失败!", e);
}
}
public Page<T> findPage(Page<T> page, final List<Filter> filters, final List<Order> orders) {
Example example = new Example(entityClass);
Example.Criteria criteria = example.createCriteria();
if (null != filters) {
condition(criteria, filters);
}
if (null != orders && !orders.isEmpty()) {
String orderStr = "";
for (int i = 0; i < orders.size(); i++) {
Order order = orders.get(i);
if (i > 0) {
orderStr += " , ";
}
orderStr += order.getProperty() + " " + order.getDirection().name();
}
example.setOrderByClause(orderStr);
}
PageHelper.startPage(page.getPageNo(),page.getPageSize());
PageInfo pageInfo = new PageInfo(tTkBaseDao.selectByExample(example));
page.setList(pageInfo.getList());
page.setTotal(pageInfo.getTotal());
page.setPageNo(pageInfo.getPageNum());
page.setPageSize(pageInfo.getPageSize());
return page;
}
protected void condition(Example.Criteria criteria, List<Filter> filters) {
for (Filter filter : filters) {
switch (filter.getOperator()) {
case eq:
criteria.andEqualTo(filter.getProperty(), filter.getValue());
break;
case like:
criteria.andLike(filter.getProperty(), filter.getValue().toString());
break;
case ne:
criteria.andNotEqualTo(filter.getProperty(), filter.getValue());
break;
case gt:
criteria.andGreaterThan(filter.getProperty(), filter.getValue());
break;
case lt:
criteria.andLessThan(filter.getProperty(), filter.getValue());
break;
case ge:
criteria.andGreaterThanOrEqualTo(filter.getProperty(), filter.getValue());
break;
case le:
criteria.andLessThanOrEqualTo(filter.getProperty(), filter.getValue());
break;
case isNull:
criteria.andIsNull(filter.getProperty());
break;
case isNotNull:
criteria.andIsNotNull(filter.getProperty());
break;
case in:
criteria.andIn(filter.getProperty(), (Iterable) filter.getValue());
break;
default:
break;
}
}
}
}3.Filter.java 条件筛选类
public class Filter implements Serializable {
private static final long serialVersionUID = -8712382358441065075L;
/**
* 运算符
*/
public enum Operator {
/** 等于 */
eq,
/** 不等于 */
ne,
/** 大于 */
gt,
/** 小于 */
lt,
/** 大于等于 */
ge,
/** 小于等于 */
le,
/** 相似 */
like,
/** 包含 */
in,
/** 为Null */
isNull,
/** 不为Null */
isNotNull,
/** 或者. */
or
;
/**
* 从String中获取Operator
*
* @param value
* 值
* @return String对应的operator
*/
public static Operator fromString(String value) {
return Operator.valueOf(value.toLowerCase());
}
}
/** 默认是否忽略大小写 */
private static final boolean DEFAULT_IGNORE_CASE = false;
/** 属性 */
private String property;
/** 运算符 */
private Operator operator;
/** 值 */
private Object value;
/** 是否忽略大小写 */
private Boolean ignoreCase = DEFAULT_IGNORE_CASE;
/**
* 初始化一个新创建的Filter对象
*/
public Filter() {
}
/**
* 初始化一个新创建的Filter对象
*
* @param property
* 属性
* @param operator
* 运算符
* @param value
* 值
*/
public Filter(String property, Operator operator, Object value) {
this.property = property;
this.operator = operator;
this.value = value;
}
/**
* 初始化一个新创建的Filter对象
*
* @param property
* 属性
* @param operator
* 运算符
* @param value
* 值
* @param ignoreCase
* 忽略大小写
*/
public Filter(String property, Operator operator, Object value, boolean ignoreCase) {
this.property = property;
this.operator = operator;
this.value = value;
this.ignoreCase = ignoreCase;
}
/**
* 多个条件进行Or处理.
* @param filters - 或处理哦筛选条件
* @return 筛选条件
*/
public static Filter or(Filter... filters) {
if (null == filters) {
return null;
}
return new Filter(null, Operator.or, filters);
}
/**
* 返回等于筛选
*
* @param property
* 属性
* @param value
* 值
* @return 等于筛选
*/
public static Filter eq(String property, Object value) {
return new Filter(property, Operator.eq, value);
}
/**
* 返回等于筛选
*
* @param property
* 属性
* @param value
* 值
* @param ignoreCase
* 忽略大小写
* @return 等于筛选
*/
public static Filter eq(String property, Object value, boolean ignoreCase) {
return new Filter(property, Operator.eq, value, ignoreCase);
}
/**
* 返回不等于筛选
*
* @param property
* 属性
* @param value
* 值
* @return 不等于筛选
*/
public static Filter ne(String property, Object value) {
return new Filter(property, Operator.ne, value);
}
/**
* 返回不等于筛选
*
* @param property
* 属性
* @param value
* 值
* @param ignoreCase
* 忽略大小写
* @return 不等于筛选
*/
public static Filter ne(String property, Object value, boolean ignoreCase) {
return new Filter(property, Operator.ne, value, ignoreCase);
}
/**
* 返回大于筛选
*
* @param property
* 属性
* @param value
* 值
* @return 大于筛选
*/
public static Filter gt(String property, Object value) {
return new Filter(property, Operator.gt, value);
}
/**
* 返回小于筛选
*
* @param property
* 属性
* @param value
* 值
* @return 小于筛选
*/
public static Filter lt(String property, Object value) {
return new Filter(property, Operator.lt, value);
}
/**
* 返回大于等于筛选
*
* @param property
* 属性
* @param value
* 值
* @return 大于等于筛选
*/
public static Filter ge(String property, Object value) {
return new Filter(property, Operator.ge, value);
}
/**
* 返回小于等于筛选
*
* @param property
* 属性
* @param value
* 值
* @return 小于等于筛选
*/
public static Filter le(String property, Object value) {
return new Filter(property, Operator.le, value);
}
/**
* 返回相似筛选
*
* @param property
* 属性
* @param value
* 值
* @return 相似筛选
*/
public static Filter like(String property, Object value) {
return new Filter(property, Operator.like, value);
}
/**
* 返回包含筛选
*
* @param property
* 属性
* @param value
* 值
* @return 包含筛选
*/
public static Filter in(String property, Object value) {
return new Filter(property, Operator.in, value);
}
/**
* 返回为Null筛选
*
* @param property
* 属性
* @return 为Null筛选
*/
public static Filter isNull(String property) {
return new Filter(property, Operator.isNull, null);
}
/**
* 返回不为Null筛选
*
* @param property
* 属性
* @return 不为Null筛选
*/
public static Filter isNotNull(String property) {
return new Filter(property, Operator.isNotNull, null);
}
/**
* 返回忽略大小写筛选
*
* @return 忽略大小写筛选
*/
public Filter ignoreCase() {
this.ignoreCase = true;
return this;
}
/**
* 获取属性
*
* @return 属性
*/
public String getProperty() {
return property;
}
/**
* 设置属性
*
* @param property
* 属性
*/
public void setProperty(String property) {
this.property = property;
}
/**
* 获取运算符
*
* @return 运算符
*/
public Operator getOperator() {
return operator;
}
/**
* 设置运算符
*
* @param operator
* 运算符
*/
public void setOperator(Operator operator) {
this.operator = operator;
}
/**
* 获取值
*
* @return 值
*/
public Object getValue() {
if (null != value) {
if (value instanceof Boolean) {
return (Boolean) value ? 1 : 0;
}
}
return value;
}
/**
* 设置值
*
* @param value
* 值
*/
public void setValue(Object value) {
this.value = value;
}
/**
* 获取是否忽略大小写
*
* @return 是否忽略大小写
*/
public Boolean getIgnoreCase() {
return ignoreCase;
}
/**
* 设置是否忽略大小写
*
* @param ignoreCase
* 是否忽略大小写
*/
public void setIgnoreCase(Boolean ignoreCase) {
this.ignoreCase = ignoreCase;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
if (this == obj) {
return true;
}
Filter other = (Filter) obj;
return new EqualsBuilder().append(getProperty(), other.getProperty()).append(getOperator(), other.getOperator()).append(getValue(), other.getValue()).isEquals();
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37).append(getProperty()).append(getOperator()).append(getValue()).toHashCode();
}
}4.Order.java,排序类
public class Order implements Serializable {
private static final long serialVersionUID = -3078342809727773232L;
/**
* 方向
*/
public enum Direction {
/** 递增 */
asc,
/** 递减 */
desc;
/**
* 从String中获取Direction
*
* @param value
* 值
* @return String对应的Direction
*/
public static Direction fromString(String value) {
return Direction.valueOf(value.toLowerCase());
}
}
/** 默认方向 */
private static final Direction DEFAULT_DIRECTION = Direction.desc;
/** 属性 */
private String property;
/** 方向 */
private Direction direction = DEFAULT_DIRECTION;
/**
* 初始化一个新创建的Order对象
*/
public Order() {
}
/**
* @param property
* 属性
* @param direction
* 方向
*/
public Order(String property, Direction direction) {
this.property = property;
this.direction = direction;
}
/**
* 返回递增排序
*
* @param property
* 属性
* @return 递增排序
*/
public static Order asc(String property) {
return new Order(property, Direction.asc);
}
/**
* 返回递减排序
*
* @param property
* 属性
* @return 递减排序
*/
public static Order desc(String property) {
return new Order(property, Direction.desc);
}
/**
* 获取属性
*
* @return 属性
*/
public String getProperty() {
return property;
}
/**
* 设置属性
*
* @param property
* 属性
*/
public void setProperty(String property) {
this.property = property;
}
/**
* 获取方向
*
* @return 方向
*/
public Direction getDirection() {
return direction;
}
/**
* 设置方向
*
* @param direction
* 方向
*/
public void setDirection(Direction direction) {
this.direction = direction;
}
/**
* 获取排序字符串.
*/
public String getOrderBy() {
return property + " " + direction;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
if (this == obj) {
return true;
}
Order other = (Order) obj;
return new EqualsBuilder().append(getProperty(), other.getProperty()).append(getDirection(), other.getDirection()).isEquals();
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37).append(getProperty()).append(getDirection()).toHashCode();
}
}5.BaseEntity 实体基类
@MappedSuperclass
public class BaseEntity implements Serializable {
@Id
protected Long id;
/** 创建时间. */
@Column(name = "create_date")
protected Date createTime;
/** 更新时间. */
@Column(name = "update_date")
protected Date updateTime;
protected String remarks; // 备注
@Column(name = "del_flag")
protected String delFlag; // 删除标记（0：正常；1：删除；2：审核）
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TKBaseEntity that = (TKBaseEntity) o;
return id != null ? id.equals(that.id) : that.id == null;
}
@Override
public int hashCode() {
return id != null ? id.hashCode() : 0;
}
}