package com.lunhan.xxx.repository;
|
|
import com.lunhan.xxx.common.ConstantFactory;
|
import com.lunhan.xxx.common.PagerResult;
|
import com.lunhan.xxx.common.config.SysConfig;
|
import com.lunhan.xxx.common.enums.ELogger;
|
import com.lunhan.xxx.common.enums.EResultCode;
|
import com.lunhan.xxx.common.exceptions.BusinessException;
|
import com.lunhan.xxx.common.orm2.SqlBuilder;
|
import com.lunhan.xxx.common.orm2.enums.ColumnBasic;
|
import com.lunhan.xxx.common.orm2.models.SqlCondition;
|
import com.lunhan.xxx.common.orm2.models.SqlParameter;
|
import com.lunhan.xxx.common.util.*;
|
import com.lunhan.xxx.repository.columns.ETestInfo;
|
import org.apache.commons.lang3.BooleanUtils;
|
import org.slf4j.Logger;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.dao.EmptyResultDataAccessException;
|
import org.springframework.jdbc.core.JdbcTemplate;
|
import org.springframework.jdbc.core.PreparedStatementCreator;
|
import org.springframework.jdbc.support.GeneratedKeyHolder;
|
import org.springframework.jdbc.support.KeyHolder;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.persistence.Column;
|
import javax.persistence.Id;
|
import javax.persistence.Table;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.ParameterizedType;
|
import java.sql.*;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 数据访问 实现类
|
*
|
* @param <T> 数据实体
|
*/
|
public class BasicDao<T> {
|
@Autowired
|
protected JdbcTemplate db;
|
private Class<T> clazz;
|
private String tableName;
|
private ColumnBasic[] columns;
|
protected List<String> listColumnsName;
|
protected String allColumnsStr;
|
|
protected static final Logger logger = LoggerUtil.get(ELogger.SQL_LOG);
|
protected static final Logger sysLogger = LoggerUtil.get(ELogger.SYS_ERROR);
|
|
/**
|
* 构造方法
|
*
|
* @param columns 数据实体对应的所有列枚举
|
*/
|
public BasicDao(ColumnBasic[] columns) {
|
this.clazz = (Class<T>) (
|
(ParameterizedType) getClass().getGenericSuperclass()
|
).getActualTypeArguments()[0];
|
this.columns = columns;
|
this.listColumnsName = Arrays.stream(columns).map(ColumnBasic::getColumnName).collect(Collectors.toList());
|
this.allColumnsStr = StringUtil.join(listColumnsName, ",");
|
|
Table annotation = clazz.getAnnotation(Table.class);
|
if (null == annotation) {
|
return;
|
}
|
this.tableName = annotation.name();
|
}
|
|
/**
|
* 获取数据实体class类型
|
*
|
* @return 数据实体class类型
|
*/
|
public Class<T> getClazz() {
|
return clazz;
|
}
|
|
/**
|
* 获取数据实体对应的所有列枚举
|
*
|
* @return 数据实体对应的所有列枚举
|
*/
|
public ColumnBasic[] getColumns() {
|
return columns;
|
}
|
|
/**
|
* 获取数据库表名
|
*
|
* @return 数据库表名
|
*/
|
public String getTableName() {
|
return tableName;
|
}
|
|
/**
|
* 根据条件获取数据实体列表(不传条件，默认只获取前500条数据)
|
*
|
* @return 数据实体列表
|
*/
|
@Transactional(readOnly = true)
|
protected List<T> getList(SqlBuilder... builder) {
|
StringBuilder sbSql = new StringBuilder(String.format("SELECT %s FROM %s", allColumnsStr, tableName));
|
Object[] params = new Object[0];
|
int[] paramTypes = new int[0];
|
if (builder.length == 1) {
|
SqlCondition condition = builder[0].build();
|
String where = condition.getSql();
|
List<SqlParameter> listParam = condition.getParamList();
|
params = new Object[listParam.size()];
|
paramTypes = new int[listParam.size()];
|
for (int i = 0; i < listParam.size(); i++) {
|
SqlParameter parameter = listParam.get(i);
|
params[i] = parameter.getValue();
|
paramTypes[i] = parameter.getType();
|
}
|
if (StringUtil.isNotNullOrEmpty(where) && BooleanUtils.isFalse(where.contains("WHERE"))) {
|
sbSql.append(" WHERE ");
|
}
|
sbSql.append(where);
|
}
|
sbSql.append(";");
|
String sql = sbSql.toString();
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + StringUtil.join(Arrays.stream(params).map(Object::toString).collect(Collectors.toList()), ConstantFactory.SQL_STR_COMMA) + "]");
|
}
|
List<Map<String, Object>> list = db.queryForList(sql, params, paramTypes);
|
if (ListUtil.isNullOrEmpty(list)) {
|
return new ArrayList<>();
|
}
|
List<T> result = new ArrayList<>();
|
Field[] fields = clazz.getDeclaredFields();
|
for (Map<String, Object> row : list) {
|
T item = this.fillEntity(fields, row);
|
if (Objects.isNull(item)) {
|
continue;
|
}
|
result.add(item);
|
}
|
return result;
|
}
|
|
/**
|
* 根据主键获取数据实体
|
*
|
* @param id 主键id
|
* @return 数据实体
|
*/
|
@Transactional(readOnly = true)
|
public T getById(Long id) {
|
try {
|
String sql = String.format("SELECT %s FROM %s WHERE id=?", allColumnsStr, tableName);
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + id + "(LONG)" + "]");
|
}
|
Map<String, Object> row = db.queryForMap(sql, new Object[]{id}, new int[]{Types.BIGINT});
|
return this.fillEntity(clazz.getDeclaredFields(), row);
|
} catch (EmptyResultDataAccessException e) {
|
return null;
|
} catch (Exception e) {
|
logger.error("BasicDao.get(Long id)发生异常", e);
|
throw new BusinessException(EResultCode.ERROR, "BasicDao.get(Long id)发生异常." + e.getMessage());
|
}
|
}
|
|
/**
|
* 条件查询单个数据实体
|
*
|
* @param builder
|
* @return
|
*/
|
@Transactional(readOnly = true)
|
protected T get(SqlBuilder builder) {
|
try {
|
builder.from(tableName);
|
StringBuilder sbSql = new StringBuilder();
|
SqlCondition conditionFull = builder.build();
|
String sqlFull = conditionFull.getSql();
|
if (BooleanUtils.isFalse(sqlFull.contains("SELECT"))) {
|
sbSql.append("SELECT ");
|
sbSql.append(allColumnsStr);
|
}
|
sbSql.append(sqlFull);
|
List<SqlParameter> listParam = conditionFull.getParamList();
|
Object[] params = new Object[listParam.size()];
|
int[] paramTypes = new int[listParam.size()];
|
for (int i = 0; i < listParam.size(); i++) {
|
SqlParameter parameter = listParam.get(i);
|
params[i] = parameter.getValue();
|
paramTypes[i] = parameter.getType();
|
}
|
sbSql.append(";");
|
String sql = sbSql.toString();
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + StringUtil.join(Arrays.stream(params).map(Object::toString).collect(Collectors.toList()), ConstantFactory.SQL_STR_COMMA) + "]");
|
}
|
Map<String, Object> row = db.queryForMap(sql, params, paramTypes);
|
return this.fillEntity(clazz.getDeclaredFields(), row);
|
} catch (EmptyResultDataAccessException e) {
|
logger.error("BasicDao.get(SqlBuilder builder)", e);
|
return null;
|
} catch (Exception e) {
|
logger.error("BasicDao.get(SqlBuilder builder)发生异常", e);
|
throw new BusinessException(EResultCode.ERROR, "BasicDao.get(SqlBuilder builder)发生异常." + e.getMessage());
|
}
|
}
|
|
/**
|
* 根据传入sql查询数据
|
*
|
* @param sql
|
* @return
|
*/
|
public List<Map<String, Object>> getSql(String sql) {
|
List<Map<String, Object>> list = db.queryForList(sql);
|
return list;
|
}
|
public Map<String, Object> querySql(String sql){
|
Map<String, Object> stringObjectMap = db.queryForMap(sql);
|
return stringObjectMap;
|
}
|
|
|
/**
|
* 根据传入sql查询数据
|
*
|
* @param builder sql语句构建器
|
*/
|
public List<Map<String, Object>> getSql(SqlBuilder builder) {
|
SqlCondition conditionFull = builder.build();
|
String sql = conditionFull.getSql();
|
|
List<SqlParameter> listParam = conditionFull.getParamList();
|
Object[] params = new Object[listParam.size()];
|
int[] paramTypes = new int[listParam.size()];
|
for (int i = 0; i < listParam.size(); i++) {
|
SqlParameter parameter = listParam.get(i);
|
params[i] = parameter.getValue();
|
paramTypes[i] = parameter.getType();
|
}
|
List<Map<String, Object>> list = db.queryForList(sql, params, paramTypes);
|
return list;
|
}
|
|
/**
|
* 查询总数
|
*
|
* @param sql
|
* @return
|
*/
|
public Integer getCount(String sql) {
|
return db.queryForObject(sql, Integer.class);
|
}
|
|
/**
|
* 根据条件获取数据实体列表(不传条件，默认只获取前500条数据)
|
*
|
* @return 数据实体列表
|
*/
|
@Transactional(readOnly = true)
|
protected PagerResult<T> getPageList(SqlBuilder builder) {
|
builder.from(tableName);
|
|
StringBuilder sbSql = new StringBuilder();
|
Integer pageSize = builder.getPageSize();
|
Integer pageIndex = builder.getPageIndex();
|
|
SqlCondition conditionFull = builder.build();
|
String sqlFull = conditionFull.getSql();
|
if (BooleanUtils.isFalse(sqlFull.contains("SELECT"))) {
|
sbSql.append("SELECT ");
|
sbSql.append(allColumnsStr);
|
}
|
sbSql.append(sqlFull);
|
|
List<SqlParameter> listParam = conditionFull.getParamList();
|
Object[] params = new Object[listParam.size()];
|
int[] paramTypes = new int[listParam.size()];
|
for (int i = 0; i < listParam.size(); i++) {
|
SqlParameter parameter = listParam.get(i);
|
params[i] = parameter.getValue();
|
paramTypes[i] = parameter.getType();
|
}
|
|
SqlCondition conditionCount = builder.count();
|
String sqlCount = conditionCount.getSql();
|
Integer rowCount = db.queryForObject(sqlCount, params, Integer.class);
|
if (Objects.isNull(rowCount) || rowCount.compareTo(0) < 1) {
|
return new PagerResult<>(pageSize, pageIndex, 0L, new ArrayList<>());
|
}
|
|
sbSql.append(";");
|
String sql = sbSql.toString();
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + StringUtil.join(Arrays.stream(params).map(Object::toString).collect(Collectors.toList()), ConstantFactory.SQL_STR_COMMA) + "]");
|
}
|
List<Map<String, Object>> list = db.queryForList(sql, params, paramTypes);
|
if (ListUtil.isNullOrEmpty(list)) {
|
return new PagerResult<>(pageSize, pageIndex, rowCount, new ArrayList<>());
|
}
|
List<T> result = new ArrayList<>();
|
Field[] fields = clazz.getDeclaredFields();
|
for (Map<String, Object> row : list) {
|
T item = this.fillEntity(fields, row);
|
if (Objects.isNull(item)) {
|
continue;
|
}
|
result.add(item);
|
}
|
return new PagerResult<>(pageSize, pageIndex, rowCount, result);
|
}
|
|
/**
|
* 新增一个数据实体
|
*
|
* @param model 数据实体对象
|
* @return 是否成功
|
*/
|
public Boolean add(T model) {
|
KeyHolder holder = new GeneratedKeyHolder();
|
|
int rowCount = db.update(new PreparedStatementCreator() {
|
@Override
|
public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
|
List<Object> listValue = new ArrayList<>();
|
List<String> listCol = new ArrayList<>();
|
Field[] fields = clazz.getDeclaredFields();
|
for (Field field : fields) {
|
// 要设置属性可达，不然会抛出IllegalAccessException异常
|
field.setAccessible(true);
|
Object value = null;
|
try {
|
value = field.get(model);
|
} catch (IllegalAccessException e) {
|
continue;
|
}
|
if (Objects.isNull(value)) {
|
continue;
|
}
|
Column annotation = field.getAnnotation(Column.class);
|
if (Objects.isNull(annotation)) {
|
continue;
|
}
|
if (Objects.equals(Boolean.FALSE, annotation.insertable())) {
|
continue;
|
}
|
Id annotationId = field.getAnnotation(Id.class);
|
if (Objects.nonNull(annotationId)) {
|
continue;
|
}
|
listValue.add(value);
|
listCol.add(annotation.name());
|
}
|
if (ListUtil.isNullOrEmpty(listValue)) {
|
throw new RuntimeException("At BasicDao.add, there is no data be insert.The model json: " + SerializeUtil.toJson(model));
|
}
|
String insertColumns = StringUtil.join(listCol, ",");
|
String valuesPlaceholder = StringUtil.join(listValue.stream().map(c -> "?").collect(Collectors.toList()));
|
String sql = String.format("INSERT INTO %s(%s) VALUES(%s);", tableName, insertColumns, valuesPlaceholder);
|
PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
|
|
for (int i = 0; i < listValue.size(); i++) {
|
//setValue(ps, i + 1, listValue.get(i));
|
ps.setObject(i + 1, listValue.get(i), Types.VARCHAR);
|
}
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + StringUtil.join(listValue.stream().map(c -> c.toString()).collect(Collectors.toList()), ConstantFactory.SQL_STR_COMMA) + "]");
|
}
|
return ps;
|
}
|
}, holder);
|
if (rowCount > 0) {
|
long id = holder.getKey().longValue();
|
Field field = null;
|
try {
|
field = clazz.getDeclaredField("id");
|
} catch (NoSuchFieldException e) {
|
sysLogger.error("BasicDao.add(T model)", e);
|
}
|
if (Objects.nonNull(field)) {
|
try {
|
// 要设置属性可达，不然会抛出IllegalAccessException异常
|
field.setAccessible(true);
|
field.set(model, id);
|
} catch (IllegalAccessException e) {
|
sysLogger.error("BasicDao.add(T model)", e);
|
}
|
}
|
return Boolean.TRUE;
|
}
|
return Boolean.FALSE;
|
}
|
|
/**
|
* 新增一个数据实体(主键非自增列)
|
*
|
* @param model 数据实体对象
|
* @return 是否成功
|
*/
|
public Boolean addNotIncrement(T model) {
|
List<Object> listValue = new ArrayList<>();
|
List<String> listCol = new ArrayList<>();
|
Field[] fields = clazz.getDeclaredFields();
|
for (Field field : fields) {
|
// 要设置属性可达，不然会抛出IllegalAccessException异常
|
field.setAccessible(true);
|
Object value = null;
|
try {
|
value = field.get(model);
|
} catch (IllegalAccessException e) {
|
continue;
|
}
|
if (Objects.isNull(value)) {
|
continue;
|
}
|
Column annotation = field.getAnnotation(Column.class);
|
if (Objects.isNull(annotation)) {
|
continue;
|
}
|
if (Objects.equals(Boolean.FALSE, annotation.insertable())) {
|
continue;
|
}
|
listValue.add(value);
|
listCol.add(annotation.name());
|
}
|
if (ListUtil.isNullOrEmpty(listValue)) {
|
throw new RuntimeException("At BasicDao.addNotIncrement, there is no data be insert.The model json: " + SerializeUtil.toJson(model));
|
}
|
String insertColumns = StringUtil.join(listCol, ",");
|
String valuesPlaceholder = StringUtil.join(listValue.stream().map(c -> "?").collect(Collectors.toList()));
|
String sql = String.format("INSERT INTO %s(%s) VALUES(%s);", tableName, insertColumns, valuesPlaceholder);
|
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + StringUtil.join(listValue.stream().map(Object::toString).collect(Collectors.toList()), ConstantFactory.SQL_STR_COMMA) + "]");
|
}
|
|
try {
|
int rowCount = db.update(sql, listValue.toArray());
|
if (rowCount > 0) {
|
return Boolean.TRUE;
|
}
|
return Boolean.FALSE;
|
} catch (Exception e) {
|
logger.error("BasicDao.addNotIncrement(T model)", e);
|
return Boolean.FALSE;
|
}
|
}
|
|
/**
|
* 根据主键id删除数据实体
|
*
|
* @param id 主键id
|
* @return 是否成功
|
*/
|
public Boolean remove(Long id) {
|
String sql = String.format("DELETE FROM %s WHERE id=?;", tableName);
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + id + "(LONG)" + "]");
|
}
|
int rowCount = db.update(sql, id);
|
if (rowCount > 0) {
|
return Boolean.TRUE;
|
}
|
return Boolean.FALSE;
|
}
|
|
/**
|
* 根据条件删除数据实体
|
*
|
* @param builder 条件
|
* @return 是否成功
|
*/
|
protected Boolean remove(SqlBuilder builder) {
|
SqlCondition build = builder.build();
|
String where = build.getSql();
|
List<SqlParameter> listParam = build.getParamList();
|
String sql = String.format("DELETE FROM %s %s;", tableName, where);
|
Object[] values = new Object[listParam.size()];
|
for (int i = 0; i < listParam.size(); i++) {
|
SqlParameter p = listParam.get(i);
|
values[i] = p.getValue();
|
}
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + Arrays.toString(values) + "]");
|
}
|
int rowCount = db.update(sql, values);
|
if (rowCount > 0) {
|
return Boolean.TRUE;
|
}
|
return Boolean.FALSE;
|
}
|
|
/**
|
* 根据主键id逻辑删除数据
|
*
|
* @param id 主键id
|
* @return 是否成功
|
*/
|
public Boolean deleteLogic(Long id) {
|
String sql = String.format("UPDATE %s SET is_delete=1 WHERE id=?;", tableName);
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + id + "(INTEGER)" + "]");
|
}
|
int rowCount = db.update(sql, id);
|
if (rowCount > 0) {
|
return Boolean.TRUE;
|
}
|
return Boolean.FALSE;
|
}
|
|
/**
|
* 根据条件逻辑删除数据
|
*
|
* @param listId id列表
|
* @return 是否成功
|
*/
|
public Boolean deleteLogic(List<Long> listId) {
|
SqlCondition build = new SqlBuilder().where(ETestInfo.ID.in(listId)).build();
|
String where = build.getSql();
|
List<SqlParameter> listParam = build.getParamList();
|
String sql = String.format("UPDATE %s SET is_delete=1 %s;", tableName, where);
|
Object[] values = new Object[listParam.size()];
|
for (int i = 0; i < listParam.size(); i++) {
|
SqlParameter p = listParam.get(i);
|
values[i] = p.getValue();
|
}
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + Arrays.toString(values) + "]");
|
}
|
int rowCount = db.update(sql, values);
|
if (rowCount > 0) {
|
return Boolean.TRUE;
|
}
|
return Boolean.FALSE;
|
}
|
|
/**
|
* 修改一个数据实体
|
*
|
* @param model 数据实体对象
|
* @return 是否成功
|
*/
|
public Boolean modify(T model) {
|
List<Object> listValue = new ArrayList<>();
|
List<String> listSet = new ArrayList<>();
|
Field[] fields = clazz.getDeclaredFields();
|
|
String idColumnName = "";
|
Object idValue = null;
|
for (Field field : fields) {
|
// 要设置属性可达，不然会抛出IllegalAccessException异常
|
field.setAccessible(true);
|
Object value = null;
|
try {
|
value = field.get(model);
|
} catch (IllegalAccessException e) {
|
continue;
|
}
|
if (Objects.isNull(value)) {
|
continue;
|
}
|
Column annotation = field.getAnnotation(Column.class);
|
if (Objects.isNull(annotation)) {
|
continue;
|
}
|
if (Objects.equals(Boolean.FALSE, annotation.updatable())) {
|
continue;
|
}
|
Id annotationId = field.getAnnotation(Id.class);
|
if (Objects.nonNull(annotationId)) {
|
idColumnName = annotation.name();
|
idValue = value;
|
if (NumericUtil.tryParseLong(idValue).compareTo(0L) < 1) {
|
throw new RuntimeException("At BasicDao.modify, the value of “id” is must.The model json: " + SerializeUtil.toJson(model));
|
}
|
continue;
|
}
|
listValue.add(value);
|
listSet.add(annotation.name() + "=?");
|
}
|
if (ListUtil.isNullOrEmpty(listValue)) {
|
throw new RuntimeException("At BasicDao.modify, there is no data be update.The model json: " + SerializeUtil.toJson(model));
|
}
|
String sql = String.format("UPDATE %s SET %s WHERE %s =?;", tableName, StringUtil.join(listSet, ","), idColumnName);
|
// 添加sql参数 id的值
|
listValue.add(idValue);
|
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + StringUtil.join(listValue.stream().map(Object::toString).collect(Collectors.toList()), ConstantFactory.SQL_STR_COMMA) + "]");
|
}
|
int rowCount = db.update(sql, listValue.toArray());
|
if (rowCount > 0) {
|
return Boolean.TRUE;
|
}
|
return Boolean.FALSE;
|
}
|
|
/**
|
* 批量新增数据实体
|
*
|
* @param list 数据实体对象列表
|
* @return 是否成功
|
*/
|
public Boolean addList(List<T> list) {
|
if (ListUtil.isNullOrEmpty(list)) {
|
return Boolean.TRUE;
|
}
|
|
List<Object[]> listValue = new ArrayList<>();
|
List<String> listCol = new ArrayList<>();
|
Field[] fields = clazz.getDeclaredFields();
|
for (int i = 0; i < list.size(); i++) {
|
T model = list.get(i);
|
List<Object> values = new ArrayList<>();
|
for (int j = 0; j < fields.length; j++) {
|
Field field = fields[j];
|
// 要设置属性可达，不然会抛出IllegalAccessException异常
|
field.setAccessible(true);
|
Object value = null;
|
try {
|
value = field.get(model);
|
} catch (IllegalAccessException e) {
|
continue;
|
}
|
if (Objects.isNull(value)) {
|
continue;
|
}
|
Column annotation = field.getAnnotation(Column.class);
|
if (Objects.isNull(annotation)) {
|
continue;
|
}
|
if (Objects.equals(Boolean.FALSE, annotation.insertable())) {
|
continue;
|
}
|
if (0 == i) {
|
listCol.add(annotation.name());
|
}
|
values.add(value);
|
}
|
listValue.add(values.toArray());
|
}
|
if (ListUtil.isNullOrEmpty(listCol)) {
|
throw new RuntimeException("At BasicDao.addList, there is no data be update.The list json: " + SerializeUtil.toJson(list));
|
}
|
String valuesPlaceholder = StringUtil.join(listCol.stream().map(c -> "?").collect(Collectors.toList()));
|
String sql = String.format("INSERT INTO %s(%s) VALUES(%s);", tableName, StringUtil.join(listCol, ","), valuesPlaceholder);
|
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + StringUtil.join(listValue.stream().map(Object::toString).collect(Collectors.toList()), ConstantFactory.SQL_STR_COMMA) + "]");
|
}
|
int[] batchUpdate = db.batchUpdate(sql, listValue);
|
if (batchUpdate.length > 0) {
|
return Boolean.TRUE;
|
}
|
return Boolean.FALSE;
|
}
|
|
/**
|
* 批量新增数据实体
|
*
|
* @param list 数据实体对象列表
|
* @return 是否成功
|
*/
|
public Boolean modifyList(List<T> list) {
|
if (ListUtil.isNullOrEmpty(list)) {
|
return Boolean.TRUE;
|
}
|
|
List<Object[]> listValue = new ArrayList<>();
|
List<String> listSet = new ArrayList<>();
|
Field[] fields = clazz.getDeclaredFields();
|
for (int i = 0; i < list.size(); i++) {
|
T model = list.get(i);
|
List<Object> values = new ArrayList<>();
|
|
Field idField = null;
|
for (int j = 0; j < fields.length; j++) {
|
Field field = fields[j];
|
// 要设置属性可达，不然会抛出IllegalAccessException异常
|
field.setAccessible(true);
|
Object value = null;
|
try {
|
value = field.get(model);
|
} catch (IllegalAccessException e) {
|
continue;
|
}
|
if (Objects.isNull(value)) {
|
continue;
|
}
|
Column annotation = field.getAnnotation(Column.class);
|
if (Objects.isNull(annotation)) {
|
continue;
|
}
|
if (Objects.equals(Boolean.FALSE, annotation.updatable())) {
|
continue;
|
}
|
Id annotationId = field.getAnnotation(Id.class);
|
if (Objects.nonNull(annotationId)) {
|
idField = field;
|
continue;
|
}
|
if (0 == i) {
|
listSet.add(annotation.name() + "=?");
|
}
|
values.add(value);
|
}
|
if (Objects.isNull(idField)) {
|
throw new RuntimeException("At BasicDao.modifyList, the value of “id” is must.The model json: " + SerializeUtil.toJson(model));
|
}
|
try {
|
// 要设置属性可达，不然会抛出IllegalAccessException异常
|
idField.setAccessible(true);
|
// 设置参数“id”的值
|
Object id = idField.get(model);
|
if (NumericUtil.tryParseLong(id).compareTo(0L) < 1) {
|
throw new RuntimeException("At BasicDao.modifyList, the value of “id” is must.The model json: " + SerializeUtil.toJson(model));
|
}
|
values.add(id);
|
} catch (IllegalAccessException e) {
|
sysLogger.error("BasicDao.modifyList", e);
|
}
|
listValue.add(values.toArray());
|
}
|
if (ListUtil.isNullOrEmpty(listSet)) {
|
throw new RuntimeException("At BasicDao.addList, there is no data be update.The list json: " + SerializeUtil.toJson(list));
|
}
|
String valuesPlaceholder = StringUtil.join(listSet.stream().map(c -> "?").collect(Collectors.toList()));
|
String sql = String.format("UPDATE %s SET %s WHERE id=?;", tableName, StringUtil.join(listSet, ","));
|
|
if (SysConfig.isSqlLog()) {
|
logger.info(sql + "\n[" + StringUtil.join(listValue.stream().map(Object::toString).collect(Collectors.toList()), ConstantFactory.SQL_STR_COMMA) + "]");
|
}
|
int[] batchUpdate = db.batchUpdate(sql, listValue);
|
if (batchUpdate.length > 0) {
|
return Boolean.TRUE;
|
}
|
return Boolean.FALSE;
|
}
|
|
|
/**
|
* 将查询得到的字段键值对封装为数据实体
|
*
|
* @param fields 数据实体的字段列表
|
* @param row 查询得到的字段键值对
|
* @return 数据实体
|
*/
|
protected T fillEntity(Field[] fields, Map<String, Object> row) {
|
T item = null;
|
try {
|
item = clazz.newInstance();
|
} catch (Exception e) {
|
sysLogger.error("BasicDao.fillEntity", e);
|
}
|
if (null == item) {
|
return null;
|
}
|
for (Map.Entry<String, Object> column : row.entrySet()) {
|
String columnName = column.getKey();
|
Field field = Arrays.stream(fields)
|
.filter(c -> {
|
Column annotation = c.getAnnotation(Column.class);
|
if (null == annotation) {
|
return Boolean.FALSE;
|
}
|
return Objects.equals(annotation.name(), columnName);
|
})
|
.findAny().orElse(null);
|
if (null == field) {
|
continue;
|
}
|
// 要设置属性可达，不然会抛出IllegalAccessException异常
|
field.setAccessible(true);
|
try {
|
field.set(item, column.getValue());
|
} catch (IllegalAccessException e) {
|
sysLogger.error("BasicDao.fillEntity(Field[] fields, Map<String, Object> row)", e);
|
}
|
}
|
return item;
|
}
|
|
/**
|
* 将查询得到的字段键值对封装为数据实体
|
*
|
* @param clazz 数据实体的class类型
|
* @param row 查询得到的字段键值对
|
* @return 数据实体
|
*/
|
protected <M> M fillEntity(Class<M> clazz, Map<String, Object> row) {
|
M item = null;
|
try {
|
item = clazz.newInstance();
|
} catch (Exception e) {
|
sysLogger.error("BasicDao.fillEntity", e);
|
}
|
if (null == item) {
|
return null;
|
}
|
Field[] fields = clazz.getDeclaredFields();
|
for (Map.Entry<String, Object> column : row.entrySet()) {
|
String columnName = column.getKey();
|
Field field = Arrays.stream(fields)
|
.filter(c -> {
|
Column annotation = c.getAnnotation(Column.class);
|
if (null == annotation) {
|
return Boolean.FALSE;
|
}
|
return Objects.equals(annotation.name(), columnName);
|
})
|
.findAny().orElse(null);
|
if (null == field) {
|
continue;
|
}
|
// 要设置属性可达，不然会抛出IllegalAccessException异常
|
field.setAccessible(true);
|
try {
|
field.set(item, column.getValue());
|
} catch (IllegalAccessException e) {
|
sysLogger.error("BasicDao.fillEntity(Class<M> clazz, Map<String, Object> row)", e);
|
}
|
}
|
return item;
|
}
|
}
|
