/** * 获取对象的RowMapper <功能详细描述> * * @return [参数说明] * @return RowMapper [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public RowMapper<T> getSelectRowMapper() { AssertUtils.notNull(this.type, "type is null"); AssertUtils.notNull(this.classReflector, "classReflector is null"); final Class<T> finalType = this.type; final ClassReflector<T> finalClassReflector = this.classReflector; RowMapper<T> rowMapper = new RowMapper<T>() { @Override public T mapRow(ResultSet rs, int rowNum) throws SQLException { T newObjInstance = ObjectUtils.newInstance(finalType); MetaObject metaObject = MetaObjectUtils.forObject(newObjInstance); for (Entry<String, String> entryTemp : getter2columnNameMapping.entrySet()) { String propertyName = entryTemp.getKey(); String columnName = entryTemp.getValue(); if (finalClassReflector.getSetterNames().contains(propertyName)) { Class<?> type = getter2JavaTypeMapping.get(propertyName); Object value = JdbcUtils.getResultSetValueForSimpleType(rs, columnName, type); metaObject.setValue(propertyName, value); } } return newObjInstance; } }; return rowMapper; }
/** * 根据id更新对象 <功能详细描述> * * @param templateTable * @return [参数说明] * @return boolean [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ @Transactional public boolean updateById(TemplateTable templateTable) { // TODO:验证参数是否合法,必填字段是否填写, AssertUtils.notNull(templateTable, "templateTable is null."); AssertUtils.notEmpty(templateTable.getId(), "templateTable.id is empty."); // TODO:生成需要更新字段的hashMap Map<String, Object> updateRowMap = new HashMap<String, Object>(); updateRowMap.put("id", templateTable.getId()); // TODO:需要更新的字段 updateRowMap.put("createOperatorId", templateTable.getCreateOperatorId()); updateRowMap.put("tableStatus", templateTable.getTableStatus()); updateRowMap.put("remark", templateTable.getRemark()); updateRowMap.put("tableName", templateTable.getTableName()); updateRowMap.put("name", templateTable.getName()); // type:java.lang.String updateRowMap.put("tableType", templateTable.getTableType()); updateRowMap.put("systemId", templateTable.getSystemId()); updateRowMap.put("createDate", templateTable.getCreateDate()); updateRowMap.put("lastUpdateDate", templateTable.getLastUpdateDate()); int updateRowCount = this.templateTableDao.updateTemplateTable(updateRowMap); // TODO:如果需要大于1时,抛出异常并回滚,需要在这里修改 return updateRowCount >= 1; }
/** * 获取查询条件的Setter对象 <功能详细描述> * * @param obj * @return [参数说明] * @return PreparedStatementSetter [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public PreparedStatementSetter getUpdateSetter(Object obj) { AssertUtils.notEmpty(obj, "update obj must not empty."); // 获取当前对象中有哪些属性 final MetaObject metaObject = MetaObjectUtils.forObject(obj); final Set<String> keySet = new HashSet<String>(); for (String getterName : metaObject.getGetterNames()) { keySet.add(getterName); } AssertUtils.isTrue( keySet.contains(this.pkName), "obj:{} must contains pk{}.", new Object[] {obj, this.pkName}); final String finalPkName = this.pkName; PreparedStatementSetter res = new PreparedStatementSetter() { @Override public void setValues(PreparedStatement ps) throws SQLException { int i = 1; for (String propertyNameTemp : updateAblePropertyNames) { if (!keySet.contains(propertyNameTemp)) { continue; } Object valueObj = metaObject.getValue(propertyNameTemp); Class<?> setterType = getter2JavaTypeMapping.get(propertyNameTemp); JdbcUtils.setPreparedStatementValueForSimpleType(ps, i++, valueObj, setterType); } Class<?> setterType = getter2JavaTypeMapping.get(finalPkName); JdbcUtils.setPreparedStatementValueForSimpleType( ps, i, metaObject.getValue(finalPkName), setterType); } }; return res; }
/** * 获取查询sql <功能详细描述> * * @return [参数说明] * @return String [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public String updateSql(Object obj) { AssertUtils.notEmpty(obj, "update obj must not empty."); // 获取当前对象中有哪些属性 MetaObject metaObject = MetaObjectUtils.forObject(obj); Set<String> keySet = new HashSet<String>(); for (String getterName : metaObject.getGetterNames()) { keySet.add(getterName); } AssertUtils.isTrue( keySet.contains(this.pkName), "obj:{} must contains pk{}.", new Object[] {obj, this.pkName}); // 构建query语句 SqlBuilder.BEGIN(); SqlBuilder.UPDATE(this.tableName); for (String propertyName : updateAblePropertyNames) { if (!keySet.contains(propertyName)) { continue; } // Object value = metaObject.getValue(propertyName); String columnName = getter2columnNameMapping.get(propertyName); SqlBuilder.SET(columnName + " = ?"); } SqlBuilder.WHERE(this.getter2columnNameMapping.get(this.pkName) + " = ? "); String updateSql = SqlBuilder.SQL(); SqlBuilder.RESET(); return updateSql; }
/** * @param params * @return */ @Override public List<RuleItemByteParam> queryRuleItemByteParamList(final Map<String, Object> params) { AssertUtils.notNull(params, "params is null."); AssertUtils.notEmpty(params.get("ruleKey"), "params.ruleKey is null."); StringBuilder sb = new StringBuilder(TxConstants.INITIAL_STR_LENGTH); sb.append("SELECT "); sb.append("ruleKey,"); sb.append("paramKey,"); sb.append("paramOrder,"); sb.append("paramValue,"); sb.append(" FROM RULE_BYTE_PARAM "); sb.append(" WHERE ruleKey = ?"); List<RuleItemByteParam> resList = this.jdbcTemplate.query( sb.toString(), new PreparedStatementSetter() { @Override public void setValues(PreparedStatement ps) throws SQLException { int parameterIndex = 0; ps.setString(++parameterIndex, (String) params.get("ruleKey")); } }, ruleItemByteParamRowMapper); return resList; }
/** * @param condition * @return */ @Override public int deleteRuleItemByteParam(final RuleItemByteParam condition) { AssertUtils.notNull(condition, "ruleItemByteParam is null."); AssertUtils.notEmpty(condition.getRuleKey(), "ruleItemValueParam.ruleKey is null."); StringBuilder sb = new StringBuilder(TxConstants.INITIAL_STR_LENGTH); sb.append("DELETE FROM RULE_BYTE_PARAM "); sb.append(" WHERE ruleKey = ? "); if (!ObjectUtils.isEmpty(condition.getParamKey())) { sb.append(" AND paramKey = ? "); } int resInt = this.jdbcTemplate.update( sb.toString(), new PreparedStatementSetter() { @Override public void setValues(PreparedStatement ps) throws SQLException { int parameterIndex = 0; ps.setString(++parameterIndex, condition.getRuleKey()); if (!ObjectUtils.isEmpty(condition.getParamKey())) { ps.setString(++parameterIndex, condition.getParamKey()); } } }); return resInt; }
/** * 将templateTable实例插入数据库中保存 1、如果templateTable为空时抛出参数为空异常 2、如果templateTable中部分必要参数为非法值时抛出参数不合法异常 * <功能详细描述> * * @param district [参数说明] * @return void [返回类型说明] * @exception throws * @see [类、类#方法、类#成员] */ @Transactional public void insertTemplateTable(TemplateTable templateTable) { // TODO:验证参数是否合法,必填字段是否填写, AssertUtils.notNull(templateTable, "templateTable is null."); AssertUtils.notEmpty(templateTable.getId(), "templateTable.id is empty."); this.templateTableDao.insertTemplateTable(templateTable); }
/** @param 对property2columnNameMapping进行赋值 */ public void addGetter2columnMapping(String getterName, String columnName, Class<?> type) { AssertUtils.notEmpty(getterName, "getterName is empty."); AssertUtils.notEmpty(columnName, "columnName is empty."); AssertUtils.notNull(type, "type is empty."); this.getter2columnNameMapping.put(getterName.trim(), columnName.trim().toUpperCase()); this.getter2JavaTypeMapping.put(getterName, type); }
/** <默认构造函数> */ public SqlSource(Dialect dialect) { super(); AssertUtils.notEmpty(pkName, "pkName is empty."); AssertUtils.notEmpty(tableName, "tableName is empty."); AssertUtils.notNull(dialect, "dialect is empty."); this.dialect = dialect; }
/** <默认构造函数> */ public SqlSource(Class<T> type, Dialect dialect) { super(); AssertUtils.notNull(type, "type is empty."); AssertUtils.notNull(dialect, "dialect is empty."); this.type = type; this.classReflector = ClassReflector.forClass(type); this.dialect = dialect; }
/** * @param sourceTableDef * @param ddlDialect * @return */ @Override public AlterTableDDLBuilder newInstance(TableDef sourceTable, DDLDialect ddlDialect) { AssertUtils.notNull(ddlDialect, "ddlDialect is null."); AssertUtils.notNull(sourceTable, "sourceTable is null."); AssertUtils.notEmpty(sourceTable.getTableName(), "sourceTable.tableName is empty."); AssertUtils.notEmpty(sourceTable.getColumns(), "sourceTable.columns is empty."); MysqlAlterTableDDLBuilder builder = new MysqlAlterTableDDLBuilder(sourceTable, ddlDialect); return builder; }
/** <默认构造函数> */ public SqlSource(String tableName, String pkName, Dialect dialect) { super(); AssertUtils.notEmpty(pkName, "pkName is empty."); AssertUtils.notEmpty(tableName, "tableName is empty."); AssertUtils.notNull(dialect, "dialect is empty."); this.pkName = pkName.trim(); this.tableName = tableName.trim().toUpperCase(); this.dialect = dialect; }
/** <默认构造函数> */ public SqlSource(Class<T> type, String tableName, String pkName, Dialect dialect) { super(); AssertUtils.notNull(type, "type is empty."); AssertUtils.notEmpty(pkName, "pkName is empty."); AssertUtils.notEmpty(tableName, "tableName is empty."); AssertUtils.notNull(dialect, "dialect is empty."); this.type = type; this.classReflector = ClassReflector.forClass(type); this.pkName = pkName.trim(); this.tableName = tableName.trim().toUpperCase(); this.dialect = dialect; }
/** * 获取删除语句<br> * <功能详细描述> * * @return [参数说明] * @return String [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public String deleteSql() { AssertUtils.notEmpty(this.pkName, "pkName is empty."); AssertUtils.isTrue( this.getter2columnNameMapping.containsKey(this.pkName), "property2columnNameMapping not contains pkName:{}.", this.pkName); // 开始构建sql SqlBuilder.BEGIN(); SqlBuilder.DELETE_FROM(this.tableName); SqlBuilder.WHERE(this.getter2columnNameMapping.get(this.pkName) + " = ? "); String deleteSql = SqlBuilder.SQL(); SqlBuilder.RESET(); return deleteSql; }
/** * 根据Id查询TemplateTable实体 1、当id为empty时抛出异常 <功能详细描述> * * @param id * @return [参数说明] * @return TemplateTable [返回类型说明] * @exception throws 可能存在数据库访问异常DataAccessException * @see [类、类#方法、类#成员] */ public TemplateTable findTemplateTableById(String id) { AssertUtils.notEmpty(id, "id is empty."); TemplateTable condition = new TemplateTable(); condition.setId(id); return this.templateTableDao.findTemplateTable(condition); }
/** * 获取查询单条数据的sql <功能详细描述> * * @return [参数说明] * @return String [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public String findSql() { AssertUtils.notEmpty(this.pkName, "pkName is empty."); AssertUtils.isTrue( this.getter2columnNameMapping.containsKey(this.pkName), "property2columnNameMapping not contains pkName:{}.", this.pkName); SqlBuilder.BEGIN(); for (Entry<String, String> entryTemp : getter2columnNameMapping.entrySet()) { SqlBuilder.SELECT(entryTemp.getValue()); } SqlBuilder.FROM(this.tableName); SqlBuilder.WHERE(this.getter2columnNameMapping.get(this.pkName) + " = ? "); String findSql = SqlBuilder.SQL(); SqlBuilder.RESET(); return findSql; }
/** * 根据id删除templateTable实例 1、如果入参数为空,则抛出异常 2、执行删除后,将返回数据库中被影响的条数 * * @param id * @return 返回删除的数据条数,<br> * 有些业务场景,如果已经被别人删除同样也可以认为是成功的 这里讲通用生成的业务层代码定义为返回影响的条数 * @return int [返回类型说明] * @exception throws * @see [类、类#方法、类#成员] */ @Transactional public int deleteById(String id) { AssertUtils.notEmpty(id, "id is empty."); TemplateTable condition = new TemplateTable(); condition.setId(id); return this.templateTableDao.deleteTemplateTable(condition); }
/** * 解析类型为表定义详细实例<br> * :实例中将含有对应的索引以及字段和索引<br> * <功能详细描述> * * @param type * @return [参数说明] * @return TableDef [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public static TableDef analyzeToTableDefDetail(Class<?> type) { AssertUtils.notNull(type, "type is null."); if (TYPE_2_TABLEDEF_MAP.containsKey(type)) { return TYPE_2_TABLEDEF_MAP.get(type); } JPAEntityTableDef tableDef = doAnalyzeToTableDefDetail(type); TYPE_2_TABLEDEF_MAP.put(type, tableDef); return tableDef; }
/** * 添加属性值与条件的映射关系<br> * <功能详细描述> * * @param propertyName * @param conditionExpression [参数说明] * @return void [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public void addQueryConditionKey2SqlMapping( QueryConditionTypeEnum queryConditionType, String key, String conditionExpression, JdbcType jdbcType, Class<?> javaType) { AssertUtils.notEmpty(key, "key is empty."); AssertUtils.notEmpty(conditionExpression, "conditionExpression is empty."); AssertUtils.notNull(jdbcType, "jdbcType is empty."); this.queryConditionKey2SqlMapping.put(key, conditionExpression); this.queryConditionKey2JdbcTypeMapping.put(key, jdbcType); this.queryConditionKey2JavaTypeMapping.put(key, javaType); if (queryConditionType != null) { this.queryConditionKey2ConditionInfoMapping.put( key, new QueryConditionInfo(queryConditionType, key, javaType, jdbcType)); } }
/** * 获取查询sql <功能详细描述> * * @return [参数说明] * @return String [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public String querySql(Object obj) { AssertUtils.notEmpty(this.pkName, "pkName is empty."); AssertUtils.isTrue( this.getter2columnNameMapping.containsKey(this.pkName), "property2columnNameMapping not contains pkName:{}.", this.pkName); // 构建query语句 SqlBuilder.BEGIN(); for (Entry<String, String> entryTemp : getter2columnNameMapping.entrySet()) { SqlBuilder.SELECT(entryTemp.getValue()); } SqlBuilder.FROM(this.tableName); if (!ObjectUtils.isEmpty(obj)) { MetaObject metaObject = MetaObjectUtils.forObject(obj); for (Entry<String, String> entryTemp : queryConditionKey2SqlMapping.entrySet()) { String queryKeyName = entryTemp.getKey(); Object valueObj = metaObject.getValue(queryKeyName); if (ObjectUtils.isEmpty(valueObj)) { continue; } SqlBuilder.WHERE(entryTemp.getValue()); } } for (String conditionExpressionTemp : otherCondition) { SqlBuilder.WHERE(conditionExpressionTemp); } // 在不存在排序字段时默认使用主键对应字段作为排序字段<br/> if (CollectionUtils.isEmpty(orderList)) { SqlBuilder.ORDER_BY(this.getter2columnNameMapping.get(this.pkName)); } else { for (String order : orderList) { SqlBuilder.ORDER_BY(order); } } String querySql = SqlBuilder.SQL(); SqlBuilder.RESET(); return querySql; }
/** * 获取设置主键的setter对象<br> * <功能详细描述> * * @param obj * @return [参数说明] * @return PreparedStatementSetter [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public PreparedStatementSetter getPKSetter(final Object obj) { AssertUtils.notEmpty(this.pkName, "pkName is empty."); AssertUtils.isTrue( this.getter2columnNameMapping.containsKey(this.pkName), "property2columnNameMapping not contains pkName:{}.", this.pkName); final String finalPkName = this.pkName; final MetaObject metaObject = MetaObjectUtils.forObject(obj); PreparedStatementSetter res = new PreparedStatementSetter() { @Override public void setValues(PreparedStatement ps) throws SQLException { Class<?> setterType = getter2JavaTypeMapping.get(finalPkName); JdbcUtils.setPreparedStatementValueForSimpleType( ps, 1, metaObject.getValue(finalPkName), setterType); } }; return res; }
/** <默认构造函数> */ public RuleItemByteParamDaoImpl(JdbcTemplate jdbcTemplate, LobHandler lobHandler) { super(); AssertUtils.notNull(jdbcTemplate == null, "jdbcTemplate is null."); AssertUtils.notNull(lobHandler == null, "lobHandler is null."); this.jdbcTemplate = jdbcTemplate; this.lobHandler = lobHandler; final LobHandler finalLobHandler = this.lobHandler; this.ruleItemByteParamRowMapper = new RowMapper<RuleItemByteParam>() { @Override public RuleItemByteParam mapRow(ResultSet rs, int rowNum) throws SQLException { RuleItemByteParam ruleItemByteParam = new RuleItemByteParam(); ruleItemByteParam.setParamKey(rs.getString("paramKey")); ruleItemByteParam.setParamOrder(rs.getInt("paramOrder")); byte[] attach = finalLobHandler.getBlobAsBytes(rs, "paramValue"); ruleItemByteParam.setParamValue(attach); ruleItemByteParam.setRuleKey(rs.getString("ruleKey")); return ruleItemByteParam; } }; }
/** * 获取一个设置的callbackHandler实现 <功能详细描述> * * @param newObjInstance * @return [参数说明] * @return RowCallbackHandler [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public RowCallbackHandler getSelectRowCallbackHandler(Object newObjInstance) { AssertUtils.notNull(this.classReflector, "classReflector is null"); final MetaObject metaObject = MetaObjectUtils.forObject(newObjInstance); final ClassReflector<T> finalClassReflector = this.classReflector; RowCallbackHandler res = new RowCallbackHandler() { @Override public void processRow(ResultSet rs) throws SQLException { for (Entry<String, String> entryTemp : getter2columnNameMapping.entrySet()) { String propertyName = entryTemp.getKey(); String columnName = entryTemp.getValue(); if (finalClassReflector.getSetterNames().contains(propertyName)) { Class<?> type = getter2JavaTypeMapping.get(propertyName); Object value = JdbcUtils.getResultSetValueForSimpleType(rs, columnName, type); metaObject.setValue(propertyName, value); } } } }; return res; }
/** * @param newTableDef * @param sourceTableDef * @param ddlDialect * @return */ @Override public AlterTableDDLBuilder newInstance( TableDef newTable, TableDef sourceTable, DDLDialect ddlDialect) { AssertUtils.notNull(ddlDialect, "ddlDialect is null."); AssertUtils.notNull(newTable, "newTable is null."); AssertUtils.notEmpty(newTable.getTableName(), "newTable.tableName is empty."); AssertUtils.notNull(sourceTable, "sourceTable is null."); AssertUtils.notEmpty(sourceTable.getTableName(), "sourceTable.tableName is empty."); AssertUtils.isTrue( newTable.getTableName().equalsIgnoreCase(sourceTable.getTableName()), "newTable.tableName:{} should equalsIgnoreCase sourceTable.tableName:{}", new Object[] {newTable.getTableName(), sourceTable.getTableName()}); MysqlAlterTableDDLBuilder builder = new MysqlAlterTableDDLBuilder(newTable, sourceTable, ddlDialect); this.columns.addAll(newTable.getColumns()); this.indexes.addAll(newTable.getIndexes()); return builder; }
/** @param 对type进行赋值 */ public void setType(Class<T> type) { AssertUtils.notNull(type, "type is empty."); this.type = type; this.classReflector = ClassReflector.forClass(type); }
/** * 添加其他条件例如额外关联等情况 支持在固定表中存在固定条件的查询 <功能详细描述> * * @param conditionExpression [参数说明] * @return void [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public void addOtherCondition(String conditionExpression) { AssertUtils.notEmpty(conditionExpression, "conditionExpression is empty."); this.otherCondition.add(conditionExpression); }
/** @param 对modifyAblePropertyNames进行赋值 */ public void addUpdateAblePropertyNames(String modifyAblePropertyName) { AssertUtils.notEmpty(modifyAblePropertyName, "modifyAblePropertyName is empty."); this.updateAblePropertyNames.add(modifyAblePropertyName.trim()); }
public void addOrder(String order) { AssertUtils.notEmpty(order, "order is empty."); this.orderList.add(order.trim().toUpperCase()); }
/** * 获取到属性映射到的字段名<br> * <功能详细描述> * * @param getterName * @return [参数说明] * @return String [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ public String getColumnNameByGetterName(String getterName) { AssertUtils.notEmpty(getterName, "getterName is empty."); return this.getter2columnNameMapping.get(getterName); }
/** * 获取对象的主键值 * * @param 对pkName进行赋值 */ public Object getValue(Object obj) { AssertUtils.notNull(obj, "obj is null."); MetaObject metaObject = MetaObjectUtils.forObject(obj); return metaObject.getValue(this.pkName); }