**************************** ********************

persagy-service-base/src/main/kotlin/com/persagy/service/SBaseService.kt

@@ -40,7 +40,7 @@ import java.lang.reflect.ParameterizedType
 /**
  * 服务类基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 open class SBaseService<ENTITY: Any> {
 
@@ -54,129 +54,129 @@ open class SBaseService<ENTITY: Any> {
     /**
      * 构造函数
      *
-     * @param   entityClazz     实体类
+     * @param entityClazz     实体类
      */
     constructor(entityClazz: Class<ENTITY>) {
         baseDao = daoFactory(entityClazz)
-    } // Constructor()
+    }
 
     /**
      * 构造函数
      *
-     * @param   daoObject       数据访问对象
+     * @param daoObject       数据访问对象
      */
     constructor(daoObject: SAbstractDao<ENTITY>) {
         baseDao = daoObject
-    } // Constructor()
+    }
 
     /**
      * Dao对象工厂类
      *
-     * @param   entityClazz     实体类
-     * @return  访问实体的Dao对象
+     * @param entityClazz     实体类
+     * @return 访问实体的 Dao 对象
      */
     private fun daoFactory(entityClazz: Class<ENTITY>): SAbstractDao<ENTITY> {
         @Suppress("UNCHECKED_CAST")
         val factory = Class.forName("com.persagy.mybatis.SDaoFactory").newInstance() as SAbstractDaoFactory<ENTITY>
         return factory.createDao(entityClazz)
-    } // Fun daoFactory
+    }
 
     /**
      * 在数据库中插入实体
      *
-     * @param   entity      插入数据库的实体
-     * @return  插入是否成功
+     * @param entity      插入数据库的实体
+     * @return 插入是否成功
      */
     open fun insert(entity: ENTITY): Boolean {
         return baseDao.insert(entity)
-    } // Fun insert()
+    }
 
     /**
      * 在数据库中插入实体
      *
-     * @param   entity      插入数据库的实体
-     * @return  插入是否成功
+     * @param entity      插入数据库的实体
+     * @return 插入是否成功
      */
     open fun replace(entity: ENTITY): Boolean {
         return baseDao.replace(entity)
-    } // Fun replace()
+    }
 
     /**
      * 删除实体
      *
-     * @param   entity      被删除的实体
-     * @return  删除是否成功
+     * @param entity      被删除的实体
+     * @return 删除是否成功
      */
     open fun delete(entity: ENTITY): Boolean {
         return baseDao.delete(entity)
-    } // Fun delete()
+    }
 
     /**
      * 根据条件删除
      *
-     * @param   args        删除条件
-     * @return  删除是否成功
+     * @param args        删除条件
+     * @return 删除是否成功
      */
     open fun delete(vararg args: Pair<String, Any>): Boolean {
         return baseDao.delete(*args)
-    } // Fun delete()
+    }
 
     /**
      * 根据条件删除
      *
-     * @param   args        删除条件
-     * @return  删除是否成功
+     * @param args        删除条件
+     * @return 删除是否成功
      */
     open fun delete(vararg args: SFilter): Boolean {
         return baseDao.delete(*args)
-    } // Fun delete()
+    }
 
     /**
      * 根据条件删除
      *
-     * @param   args        删除条件
-     * @return  删除是否成功
+     * @param args        删除条件
+     * @return 删除是否成功
      */
     open fun delete(args: List<SFilter>): Boolean {
         return baseDao.delete(args)
-    } // Fun delete()
+    }
 
     /**
      * 根据条件删除
      *
-     * @param   query        删除条件
-     * @return  删除是否成功
+     * @param query        删除条件
+     * @return 删除是否成功
      */
     open fun delete(query: String): Boolean {
         return baseDao.delete(query)
-    } // Fun delete()
+    }
 
     /**
      * 删除所有记录
      *
-     * @return  删除是否成功
+     * @return 删除是否成功
      */
     open fun deleteAll(): Boolean {
         return baseDao.deleteAll()
-    } // Fun deleteAll()
+    }
 
     /**
      * 更新实体
      *
-     * @param   entity      更新实体
-     * @param   projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
-     * @return  更新是否成功
+     * @param entity      更新实体
+     * @param projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
+     * @return 更新是否成功
      */
     open fun update(entity: ENTITY, projection: ArrayList<String>? = null): Boolean {
         return baseDao.update(entity, projection)
-    } // Fun update()
+    }
 
     /**
      * 根据条件更新
      *
-     * @param   projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
-     * @param   args        更新条件
-     * @return  更新是否成功
+     * @param projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
+     * @param args        更新条件
+     * @return 更新是否成功
      */
     open fun update(entity: ENTITY, projection: ArrayList<String>?, vararg args: Pair<String, Any>): Boolean {
         return baseDao.update(entity, projection, *args)
@@ -185,225 +185,226 @@ open class SBaseService<ENTITY: Any> {
     /**
      * 根据条件更新
      *
-     * @param   projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
-     * @param   args        更新条件
-     * @return  更新是否成功
+     * @param projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
+     * @param args        更新条件
+     * @return 更新是否成功
      */
     open fun update(entity: ENTITY, projection: ArrayList<String>?, vararg args: SFilter): Boolean {
         return baseDao.update(entity, projection, *args)
-    } // Fun update()
+    }
 
     /**
      * 根据条件更新
      *
-     * @param   projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
-     * @param   args        更新条件
-     * @return  更新是否成功
+     * @param projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
+     * @param args        更新条件
+     * @return 更新是否成功
      */
     open fun update(entity: ENTITY, projection: ArrayList<String>?, args: List<SFilter>): Boolean {
         return baseDao.update(entity, projection, args)
-    } // Fun update()
+    }
 
     /**
      * 根据条件更新
      *
-     * @param   projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
-     * @param   query       更新条件
-     * @return  更新是否成功
+     * @param projection  将被更新的字段列表（以逗号分隔），为空表示更新所有非空字段
+     * @param query       更新条件
+     * @return 更新是否成功
      */
     open fun update(entity: ENTITY, projection: ArrayList<String>?, query: String): Boolean {
         return baseDao.update(entity, projection, query)
-    } // Fun update()
+    }
 
     /**
      * 根据条件查询一条记录
      *
-     * @param   args        查询条件
+     * @param args        查询条件
+     * @return 返回对象
      */
     open fun select(vararg args: Pair<String, Any>): SQueryBuilder<ENTITY> {
         return baseDao.select(*args)
-    } // Fun select()
+    }
 
     /**
      * 根据条件查询记录
      *
-     * @param   args        查询条件
-     * @return  查询构造器
+     * @param args        查询条件
+     * @return 查询构造器
      */
     open fun select(vararg args: SFilter): SQueryBuilder<ENTITY> {
         return baseDao.select(*args)
-    } // Fun select()
+    }
 
     /**
      * 根据条件查询记录
      *
-     * @param   args        查询条件
-     * @return  查询构造器
+     * @param args        查询条件
+     * @return 查询构造器
      */
     open fun select(args: List<SFilter>): SQueryBuilder<ENTITY> {
         return baseDao.select(args)
-    } // Fun select()
+    }
 
     /**
      * 根据条件查询记录
      *
-     * @param   query        查询条件
-     * @return  查询构造器
+     * @param query        查询条件
+     * @return 查询构造器
      */
     open fun select(query: String?): SQueryBuilder<ENTITY> {
         return baseDao.select(query)
-    } // Fun select()
+    }
 
     /**
      * 根据条件查询所有记录
      *
-     * @return  查找的记录
+     * @return 查找的记录
      */
     open fun selectAll(): SQueryBuilder<ENTITY> {
         var builder = baseDao.selectAll()
 
         builder.limit(9999999)
         return builder
-    } // Fun selectAll()
+    }
 
     /**
      * 执行查询操作
      *
-     * @param   builder     查询查询构造器
-     * @return  查询到的记录
+     * @param builder     查询查询构造器
+     * @return 查询到的记录
      */
     open fun execQuery(builder: SQueryBuilder<ENTITY>): ArrayList<ENTITY> {
         return baseDao.execQuery(builder)
-    } // Fun execQuery()
+    }
 
     /**
      * 执行查询操作
      *
-     * @param   builder     查询查询构造器
-     * @return  查询到的记录数
+     * @param builder     查询查询构造器
+     * @return 查询到的记录数
      */
     open fun execCount(builder: SQueryBuilder<ENTITY>): Long {
         return baseDao.execCount(builder)
-    } // Fun execQuery()
+    }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     // 回调函数
     /**
      * 创建对象前回调函数
      *
-     * @param   entity      创建前的回调函数
-     * @return  返回true,可以创建对象
+     * @param entity      创建前的回调函数
+     * @return 返回 true ,可以创建对象
      */
     protected open fun onCreateBefore(entity: ENTITY): Boolean  {
         return true
-    } // Fun onCreateBefore()
+    }
 
     /**
      * 创建成功后回调函数
      *
-     * @param   entityList      创建成功对象列表
+     * @param entityList      创建成功对象列表
      */
     protected open fun onCreateSuccess(entityList: ArrayList<ENTITY>) {
-    } // Fun onCreateSuccess()
+    }
 
     /**
      * 创建失败回调函数
      *
-     * @param   entityList      创建失败对象列表
+     * @param entityList      创建失败对象列表
      */
     protected open fun onCreateFailure(entityList: ArrayList<ENTITY>) {
-    } // Fun onCreateFailure()
+    }
 
     /**
      * 删除前回调函数
      *
-     * @param   entity      创建前的回调函数
-     * @return  返回true,可以删除对象
+     * @param entity      创建前的回调函数
+     * @return 返回 true,可以删除对象
      */
     protected open fun onDeleteBefore(entity: ENTITY): Boolean {
         return true
-    } // Fun onCreateEntity()
+    }
 
     /**
      * 删除成功回调函数
      *
-     * @param   entityList      删除成功对象列表
+     * @param entityList      删除成功对象列表
      */
     protected open fun onDeleteSuccess(entityList: ArrayList<ENTITY>) {
-    } // Fun onDeleteSuccess()
+    }
 
     /**
      * 删除失败回调函数
      *
-     * @param   entityList      删除失败对象列表
+     * @param entityList      删除失败对象列表
      */
     protected open fun onDeleteFailure(entityList: ArrayList<ENTITY>) {
-    } // Fun onDeleteFailure()
+    }
 
     /**
      * 更新前回调函数
      *
-     * @param   entity      创建前的回调函数
+     * @param entity      创建前的回调函数
      */
     protected open fun onUpdateBefore(entity: ENTITY): Boolean {
         return true
-    } // Fun onCreateEntity()
+    }
 
     /**
      * 更新成功能回调函数
      *
-     * @param   entityList      更新成功对象列表
+     * @param entityList      更新成功对象列表
      */
     protected open fun onUpdateSuccess(entityList: ArrayList<ENTITY>) {
-    } // Fun onUpdateSuccess()
+    }
 
     /**
      * 更新失败回调函数
      *
-     * @param   entityList      更新失败对象列表
+     * @param entityList      更新失败对象列表
      */
     protected open fun onUpdateFailure(entityList: ArrayList<ENTITY>) {
-    } // Fun onUpdateFailure()
+    }
 
     /**
      * 查询前回调函数
      *
-     * @param   queryBuilder    查询构造器
+     * @param queryBuilder    查询构造器
      */
     protected open fun onQueryBefore(queryBuilder: SQueryBuilder<ENTITY>) {
-    } // Fun onQueryBefore()
+    }
 
     /**
      * 查询成功回调函数
      *
-     * @param   pageInfo   页面信息
+     * @param pageInfo   页面信息
      */
     protected open fun onQuerySuccess(pageInfo: SPageQueryInfo<ENTITY>) {
-    } // Fun onQuerySuccess()
+    }
 
     /**
      * 统计个数前回调函数
      *
-     * @param   queryBuilder    查询构造器
+     * @param queryBuilder    查询构造器
      */
     protected open fun onCountBefore(queryBuilder: SQueryBuilder<ENTITY>) {
-    } // Fun onQueryBefore()
+    }
 
     /**
      * 统计个数成功回调函数
      *
-     * @param   count   统计结果
+     * @param count   统计结果
      */
     protected open fun onCountSuccess(count: Long) {
-    } // Fun onCountSuccess()
+    }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     // 级联操作相关
     /**
      * 进行级联查询处理
      *
-     * @param   entityList      实体列表
-     * @param   cascadeList     级联请求列表
+     * @param entityList      实体列表
+     * @param cascadeList     级联请求列表
      */
     fun processCascadeQuery(entityList: ArrayList<Any>, cascadeList: ArrayList<SCascadeQuery>) {
         val entityMap = entityListToMap(entityList)
@@ -412,7 +413,7 @@ open class SBaseService<ENTITY: Any> {
                 continue
             }
 
-            // 获得级联相关信息。如果信息不完整，则退出
+            /** 获得级联相关信息。如果信息不完整，则退出 */
             val cascadeField = entityClass.getAllDeclaredField(cascade.name!!) ?: continue
             val cascadeQueryAnno = cascadeField.getAnnotation(SCascade::class.java)
             val cascadeCountAnno = cascadeField.getAnnotation(SCascadeCount::class.java)
@@ -423,28 +424,28 @@ open class SBaseService<ENTITY: Any> {
             }
         }
         return
-    } // Fun cascadeQuery()
+    }
 
     /**
      * 进行级联查询
      *
-     * @param   entityMap       实体Map
-     * @param   cascadeAnno     级联查询注解
-     * @param   cascadeField    级联查询对应的属性
-     * @param   cascade         级联请求
+     * @param entityMap       实体 Map
+     * @param cascadeAnno     级联查询注解
+     * @param cascadeField    级联查询对应的属性
+     * @param cascade         级联请求
      */
     private fun cascadeQuery(entityMap: HashMap<Any, Any>, cascadeAnno: SCascade, cascadeField: Field, cascade: SCascadeQuery) {
         val cascadeClass = if (List::class.java.isAssignableFrom(cascadeField.type)) {
-            // 如果是1对多，或多对多。取列表的泛型
+            /** 如果是 1 对多，或多对多。取列表的泛型 */
             (cascadeField.genericType as ParameterizedType).actualTypeArguments[0] as Class<*>
         } else {
-            // 如果为1对1，直接取对象类型
+            /** 如果为 1 对 1，直接取对象类型 */
             cascadeField.type
         }
 
         val idList = entityIdList(entityMap)
         val relationList = baseDao.relationQuery(cascadeAnno.table, cascadeAnno.idColumn, cascadeAnno.childIdColumn, cascadeAnno.self, cascadeAnno.filter, idList)
-        // 如果未取到关联数据，则开始取下一个关联对象
+        /** 如果未取到关联数据，则开始取下一个关联对象 */
         if (relationList.size <= 0) {
             return
         }
@@ -452,7 +453,7 @@ open class SBaseService<ENTITY: Any> {
         val relationMap = relationListToMap(relationList)
 
         /////////////////////////////////
-        // 开始构造级联查询
+        /** 开始构造级联查询 */
         val service = SBaseService(cascadeClass)
         val sqlBuilder = service.select(cascade.filters)
         sqlBuilder.filter(SFilter.inList(cascadeClass.keyFieldList()[0].name, relationMap.keys.toList()))
@@ -474,23 +475,23 @@ open class SBaseService<ENTITY: Any> {
 
         /** 分组统计 */
         if (null != cascade.group && !cascade.group!!.nameList.isNullOrEmpty()) {
-            // 分组属性名列表
+            /** 分组属性名列表 */
             sqlBuilder.group(*cascade.group!!.nameList.toArray(emptyArray<String>()))
-            // 是否统计个数
+            /** 是否统计个数 */
             sqlBuilder.count(cascade.group!!.count ?: false)
-            // 求和
+            /** 求和 */
             if (!cascade.group!!.sumList.isNullOrEmpty()) {
                 sqlBuilder.sum(*cascade.group!!.sumList.toArray(emptyArray<String>()))
             }
-            // 求平均值
+            /** 求平均值 */
             if (!cascade.group!!.avgList.isNullOrEmpty()) {
                 sqlBuilder.avg(*cascade.group!!.avgList.toArray(emptyArray<String>()))
             }
-            // 取最大值
+            /** 取最大值 */
             if (!cascade.group!!.maxList.isNullOrEmpty()) {
                 sqlBuilder.max(*cascade.group!!.maxList.toArray(emptyArray<String>()))
             }
-            // 取最小值
+            /** 取最小值 */
             if (!cascade.group!!.minList.isNullOrEmpty()) {
                 sqlBuilder.min(*cascade.group!!.minList.toArray(emptyArray<String>()))
             }
@@ -517,20 +518,20 @@ open class SBaseService<ENTITY: Any> {
             service.processCascadeQuery(childrenList as ArrayList<Any>, cascade.cascade!!)
         }
         return
-    } // Fun cascadeQuery()
+    }
 
     /**
      * 进行级联查询
      *
-     * @param   entityMap       实体Map
-     * @param   cascadeAnno     级联查询注解
-     * @param   cascadeField    级联查询对应的属性
-     * @param   cascade         级联请求
+     * @param entityMap       实体 Map
+     * @param cascadeAnno     级联查询注解
+     * @param cascadeField    级联查询对应的属性
+     * @param cascade         级联请求
      */
     private fun cascadeCount(entityMap: HashMap<Any, Any>, cascadeAnno: SCascadeCount, cascadeField: Field, cascade: SCascadeQuery) {
         val idList = entityIdList(entityMap)
         val relationList = baseDao.relationQuery(cascadeAnno.table, cascadeAnno.idColumn, cascadeAnno.childIdColumn, cascadeAnno.self, cascadeAnno.filter, idList)
-        // 如果未取到关联数据，则开始取下一个关联对象
+        /** 如果未取到关联数据，则开始取下一个关联对象 */
         if (relationList.size <= 0) {
             return
         }
@@ -538,7 +539,7 @@ open class SBaseService<ENTITY: Any> {
         val relationMap = relationListToMap(relationList)
 
         /////////////////////////////////
-        // 开始构造级联查询
+        /** 开始构造级联查询 */
         val service = SBaseService(cascadeAnno.childClass.java)
         val sqlBuilder = service.select(cascade.filters)
         sqlBuilder.filter(SFilter.inList(cascadeAnno.childClass.java.keyFieldList()[0].name, relationMap.keys.toList()))
@@ -560,23 +561,23 @@ open class SBaseService<ENTITY: Any> {
 
         /** 分组统计 */
         if (null != cascade.group && !cascade.group!!.nameList.isNullOrEmpty()) {
-            // 分组属性名列表
+            /** 分组属性名列表 */
             sqlBuilder.group(*cascade.group!!.nameList.toArray(emptyArray<String>()))
-            // 是否统计个数
+            /** 是否统计个数 */
             sqlBuilder.count(cascade.group!!.count ?: false)
-            // 求和
+            /** 求和 */
             if (!cascade.group!!.sumList.isNullOrEmpty()) {
                 sqlBuilder.sum(*cascade.group!!.sumList.toArray(emptyArray<String>()))
             }
-            // 求平均值
+            /** 求平均值 */
             if (!cascade.group!!.avgList.isNullOrEmpty()) {
                 sqlBuilder.avg(*cascade.group!!.avgList.toArray(emptyArray<String>()))
             }
-            // 取最大值
+            /** 取最大值 */
             if (!cascade.group!!.maxList.isNullOrEmpty()) {
                 sqlBuilder.max(*cascade.group!!.maxList.toArray(emptyArray<String>()))
             }
-            // 取最小值
+            /** 取最小值 */
             if (!cascade.group!!.minList.isNullOrEmpty()) {
                 sqlBuilder.min(*cascade.group!!.minList.toArray(emptyArray<String>()))
             }
@@ -597,13 +598,13 @@ open class SBaseService<ENTITY: Any> {
         }
 
         return
-    } // Fun cascadeCount()
+    }
 
     /**
-     * 为加速填充级联对象，将实体列表转换为map。
+     * 为加速填充级联对象，将实体列表转换为 map。
      *
-     * @param   entityList      实体列表
-     * @return  以Map形式存储的实体
+     * @param entityList      实体列表
+     * @return 以 Map 形式存储的实体
      */
     private fun entityListToMap(entityList: ArrayList<Any>): HashMap<Any, Any> {
         val map = HashMap<Any, Any>()
@@ -612,13 +613,13 @@ open class SBaseService<ENTITY: Any> {
             map[entity.keyValue(key.name)!!] = entity
         }
         return map
-    } // Fun entityMap()
+    }
 
     /**
-     * 获得实体的Id列表
+     * 获得实体的 Id 列表
      *
-     * @param   entityMap   实体Map
-     * @return  ID列表
+     * @param entityMap   实体 Map
+     * @return ID 列表
      */
     private fun entityIdList(entityMap: HashMap<Any, Any>): ArrayList<Any> {
         val idList = ArrayList<Any>()
@@ -630,13 +631,13 @@ open class SBaseService<ENTITY: Any> {
             idList.add(keyValue)
         }
         return idList
-    } // Fun entityIdList()
+    }
 
     /**
-     * 将关系列表转换为Map
+     * 将关系列表转换为 Map
      *
-     * @param   cascadeList     被转换的列表
-     * @return  转换后的Map
+     * @param cascadeList     被转换的列表
+     * @return 转换后的 Map
      */
     private fun relationListToMap(cascadeList: List<HashMap<String, Any>>): HashMap<Any, ArrayList<Any>> {
         val map = HashMap<Any, ArrayList<Any>>()
@@ -651,24 +652,24 @@ open class SBaseService<ENTITY: Any> {
             map[item["id2"]!!] = list
         }
         return map
-    } // Fun cascadeToMap()
+    }
 
     /**
      * 填级联对象
      *
-     * @param   entity      实体
-     * @param   child       填入的对象
-     * @param   field       填入的对象对应的实体类属性
+     * @param entity      实体
+     * @param child       填入的对象
+     * @param field       填入的对象对应的实体类属性
      */
     private fun fillCascadeObject(entity: Any, child: Any?, field: Field) {
-        // 如果child为空，则返回
+        /** 如果child为空，则返回 */
         child ?: return
 
-        // 保存访问权限
+        /** 保存访问权限 */
         val accessible = field.isAccessible
         field.isAccessible = true
 
-        // 如果field是列表
+        /** 如果field是列表 */
         if (List::class.java.isAssignableFrom(field.type)) {
             @Suppress("UNCHECKED_CAST")
             var children = field.get(entity) as ArrayList<Any>?
@@ -678,29 +679,29 @@ open class SBaseService<ENTITY: Any> {
             children.add(child)
             field.set(entity, children)
         } else {
-            // 如果field是对象
+            /** 如果field是对象 */
             if (field.get(entity) == null) {
                 field.set(entity, child)
             }
         }
 
-        // 恢复访问权限
+        /** 恢复访问权限 */
         field.isAccessible = accessible
         return
-    } // Fun fillCascadeObject()
+    }
 
     /**
      * 填级联对象
      *
-     * @param   entity      实体
-     * @param   child       填入的对象
-     * @param   field       填入的对象对应的实体类属性
+     * @param entity      实体
+     * @param child       填入的对象
+     * @param field       填入的对象对应的实体类属性
      */
     private fun fillCascadeCount(entity: Any, child: Any?, field: Field) {
-        // 如果child为空，则返回
+        /**  如果 child 为空，则返回 */
         child ?: return
 
-        // 保存访问权限
+        /** 保存访问权限 */
         val accessible = field.isAccessible
         field.isAccessible = true
 
@@ -712,8 +713,8 @@ open class SBaseService<ENTITY: Any> {
         count++
         field.set(entity, count)
 
-        // 恢复访问权限
+        /** 恢复访问权限 */
         field.isAccessible = accessible
         return
-    } // Fun fillCascadeCount()
-} // Class SBaseService
+    }
+}

persagy-service-base/src/main/kotlin/com/persagy/service/SGlobalDefaultExceptionHandler.kt

@@ -34,22 +34,22 @@ import javax.servlet.http.HttpServletRequest
 /**
  * 全局默认异常处理句柄
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 // @ControllerAdvice
 class SGlobalDefaultExceptionHandler {
     /**
      * 默认异常处理句柄
-     * 如果返回的是View -- 方法的返回值是ModelAndView
-     * 如果返回的是String或者是Json数据，那么需要在方法上添加@ResponseBody注解
+     * 如果返回的是 View -- 方法的返回值是 ModelAndView
+     * 如果返回的是 String 或者是 Json 数据，那么需要在方法上添加 @ResponseBody 注解
      *
-     * @param   request     Http请求
-     * @param   e           异常
-     * @return  数据
+     * @param request     Http 请求
+     * @param e           异常
+     * @return 数据
      */
     @ExceptionHandler(Exception::class)
     @ResponseBody
     fun defaultExceptionHandler(request: HttpServletRequest, e: Exception): String {
         return "对不起，服务器繁忙，请稍后再试！"
-    } // Fun defaultExceptionHandler()
-} // Class GlobalDefaultExceptionHandler
+    }
+}

persagy-service-base/src/main/kotlin/com/persagy/service/SObjectService.kt

@@ -41,7 +41,7 @@ import kotlin.collections.ArrayList
 /**
  * 对象访问服务类基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 open class SObjectService<ENTITY: Any>
     : SBaseService<ENTITY> {
@@ -49,27 +49,27 @@ open class SObjectService<ENTITY: Any>
     companion object {
         /** 日志记录器 */
         private val logger = LoggerFactory.getLogger(SObjectService::class.java)
-    } // Companion object
+    }
 
     /**
      * 构造函数
      *
-     * @param   entityClazz     实体类
+     * @param entityClazz     实体类
      */
     constructor(entityClazz: Class<ENTITY>): super(entityClazz)
 
     /**
      * 构造函数
      *
-     * @param   daoObject       数据访问对象
+     * @param daoObject       数据访问对象
      */
     constructor(daoObject: SAbstractDao<ENTITY>): super(daoObject)
 
     /**
      * 创建对象
      *
-     * @param   request         请求对象
-     * @return  创建结果应答信息
+     * @param request         请求对象
+     * @return 创建结果应答信息
      */
     fun createList(@RequestBody request: SCreateRequest<ENTITY>): SCreateResponse<ENTITY> {
         return try {
@@ -91,14 +91,14 @@ open class SObjectService<ENTITY: Any>
             e.printStackTrace()
             SCreateResponse(SResponseType.failure, e.message!!)
         }
-    } // Fun createList()
+    }
 
     /**
      * 删除对象
      *
-     * @param   entityList       对象ID列表
-     * @param   withFilterList   公共过滤条件
-     * @return  删除结果应答信息
+     * @param entityList       对象 ID 列表
+     * @param withFilterList   公共过滤条件
+     * @return 删除结果应答信息
      */
     fun deleteByKeysList(@RequestBody entityList: ArrayList<ENTITY>, withFilterList: ArrayList<SFilter>? = null): SBaseResponse {
          try {
@@ -129,13 +129,13 @@ open class SObjectService<ENTITY: Any>
             e.printStackTrace()
              return SBaseResponse(SResponseType.failure, e.message!!)
         }
-    } // Fun deleteByKeysList()
+    }
 
     /**
      * 根据条件删除对象
      *
-     * @param   filterList  删除条件
-     * @return  删除结果应答信息
+     * @param filterList  删除条件
+     * @return 删除结果应答信息
      */
     fun batchDelete(@RequestBody filterList: ArrayList<SFilter>): SBaseResponse {
         return if (delete(filterList)) {
@@ -143,14 +143,14 @@ open class SObjectService<ENTITY: Any>
         } else {
             SBaseResponse(SResponseType.failure, "删除失败！")
         }
-    } // Fun batchDelete()
+    }
 
     /**
      * 更新对象
      *
-     * @param   request         更新请求
-     * @param   withFilterList  公共过滤条件
-     * @return  更新结果应答信息
+     * @param request         更新请求
+     * @param withFilterList  公共过滤条件
+     * @return 更新结果应答信息
      */
     fun updateList(@RequestBody request: SUpdateRequest<ENTITY>, withFilterList: ArrayList<SFilter>? = null): SBaseResponse {
         val entityList = request.content
@@ -178,38 +178,14 @@ open class SObjectService<ENTITY: Any>
             e.printStackTrace()
             SBaseResponse(SResponseType.failure, e.message!!)
         }
-    } // Fun update()
-
-//    /**
-//     * 批量更新对象
-//     *
-//     * @param   request         批量更新请求
-//     * @param   withFilterList  公共过滤条件
-//     * @return  更新结果应答信息
-//     */
-//    fun batchUpdate(@RequestBody request: SBatchUpdateRequest<ENTITY>, withFilterList: ArrayList<SFilter>? = null): SBaseResponse {
-//        val filterList = ArrayList<SFilter>()
-//        if (withFilterList != null) {
-//            filterList.addAll(withFilterList)
-//        }
-//
-//        if (request.filters != null) {
-//            filterList.addAll(request.filters!!)
-//        }
-//
-//        return if (update(request.content!!, request.projection!!, filterList)) {
-//            SBaseResponse(SResponseType.success)
-//        } else {
-//            SBaseResponse(SResponseType.failure, "更新失败！")
-//        }
-//    } // Fun batchUpdate()
+    }
 
     /**
      * 根据条件分页查询
      *
-     * @param   request         查询请求
-     * @param   withFilterList  公共过滤条件
-     * @return  查询结果应答信息
+     * @param request         查询请求
+     * @param withFilterList  公共过滤条件
+     * @return 查询结果应答信息
      */
     fun pageQuery(@RequestBody request: SQueryRequest, withFilterList: ArrayList<SFilter>? = null): SQueryResponse<ENTITY> {
         return try {
@@ -236,23 +212,23 @@ open class SObjectService<ENTITY: Any>
 
             /** 分组统计 */
             if (null != request.group && !request.group!!.nameList.isNullOrEmpty()) {
-                // 分组属性名列表
+                /** 分组属性名列表 */
                 queryBuilder.group(*request.group!!.nameList.toArray(emptyArray<String>()))
-                // 是否统计个数
+                /** 是否统计个数 */
                 queryBuilder.count(request.group!!.count ?: false)
-                // 求和
+                /** 求和 */
                 if (!request.group!!.sumList.isNullOrEmpty()) {
                     queryBuilder.sum(*request.group!!.sumList.toArray(emptyArray<String>()))
                 }
-                // 求平均值
+                /** 求平均值 */
                 if (!request.group!!.avgList.isNullOrEmpty()) {
                     queryBuilder.avg(*request.group!!.avgList.toArray(emptyArray<String>()))
                 }
-                // 取最大值
+                /** 取最大值 */
                 if (!request.group!!.maxList.isNullOrEmpty()) {
                     queryBuilder.max(*request.group!!.maxList.toArray(emptyArray<String>()))
                 }
-                // 取最小值
+                /** 取最小值 */
                 if (!request.group!!.minList.isNullOrEmpty()) {
                     queryBuilder.min(*request.group!!.minList.toArray(emptyArray<String>()))
                 }
@@ -273,14 +249,14 @@ open class SObjectService<ENTITY: Any>
             e.printStackTrace()
             SQueryResponse(SResponseType.failure, e.rootCause()?.message ?: e.message ?: "未知异常！")
         }
-    } // Fun pageQuery()
+    }
 
     /**
      * 根据条件统计
      *
-     * @param   request         查询条件请求
-     * @param   withFilterList  公共过滤条件
-     * @return  查询结果应答信息
+     * @param request         查询条件请求
+     * @param withFilterList  公共过滤条件
+     * @return 查询结果应答信息
      */
     fun count(@RequestBody request: SCountRequest, withFilterList: ArrayList<SFilter>? = null): SCountResponse {
         return try {
@@ -298,5 +274,5 @@ open class SObjectService<ENTITY: Any>
             e.printStackTrace()
             SCountResponse(0, SResponseType.failure, e.rootCause()?.message ?: e.message ?: "未知异常！")
         }
-    } // Fun count()
-} // Class SObjectService
+    }
+}

persagy-service-base/src/main/kotlin/com/persagy/service/SPageContext.kt

@@ -38,11 +38,11 @@ import javax.servlet.http.HttpSession
  * @author 庞利祥 <sybotan@126.com>
  */
 object SPageContext {
-    // 日志记录器
+    /** 日志记录器 */
     private val logger = LoggerFactory.getLogger(SPageContext::class.java)
-    // 客户端请求对象")
+    /** 客户端请求对象 */
     private val request = ThreadLocal<HttpServletRequest>()
-    // 服务器应答对象")
+    /** 服务器应答对象 */
     private val response = ThreadLocal<HttpServletResponse>()
 
     var domain = "sybotan"
@@ -54,7 +54,7 @@ object SPageContext {
      */
     fun getRequest(): HttpServletRequest {
         return request.get()
-    } // Fun getRequest()
+    }
 
     /**
      * 设置客户端请求对象
@@ -64,7 +64,7 @@ object SPageContext {
     fun setRequest(req: HttpServletRequest) {
         request.set(req)
         return
-    } // Fun setRequest()
+    }
 
     /**
      * 释放保存客户端请求对象的变量
@@ -72,7 +72,7 @@ object SPageContext {
     fun removeRequest() {
         request.remove()
         return
-    } // Fun removeRequest()
+    }
 
     /**
      * 获得服务器应答对象
@@ -81,7 +81,7 @@ object SPageContext {
      */
     fun getResponse(): HttpServletResponse {
         return response.get()
-    } // Fun getRequest()
+    }
 
     /**
      * 设置服务器应答对象
@@ -91,7 +91,7 @@ object SPageContext {
     fun setResponse(resp: HttpServletResponse) {
         response.set(resp)
         return
-    } // Fun setRequest()
+    }
 
     /**
      * 释放保存服务器应答对象的变量
@@ -99,7 +99,7 @@ object SPageContext {
     fun removeResponse() {
         response.remove()
         return
-    } // Fun removeRequest()
+    }
 
     /**
      * 获得客户端会话对象
@@ -109,7 +109,7 @@ object SPageContext {
     fun getSession(): HttpSession? {
         val req = request.get()
         return req?.session
-    } // Fun getSession()
+    }
 
     /**
      * 获得保存在客户端会话中的指定属性
@@ -120,7 +120,7 @@ object SPageContext {
     fun getAttribute(name: String): Any? {
         val session = getSession()
         return session?.getAttribute(name)
-    } // Fun getAttribute()
+    }
 
     /**
      * 设置保存在客户端会话中的指定属性
@@ -132,7 +132,7 @@ object SPageContext {
         val session = getSession()
         session?.setAttribute(name, `object`)
         return
-    } // Fun setAttribute()
+    })
 
     /**
      * 移除保存在客户端会话中的指定属性
@@ -143,7 +143,7 @@ object SPageContext {
         val session = getSession()
         session?.removeAttribute(name)
         return
-    } // Fun removeAttribute()
+    }
 
     /**
      * 移除保存在客户端会话中的所有属性
@@ -157,7 +157,7 @@ object SPageContext {
             session.removeAttribute(name)
         }
         return
-    } // Fun removeAllAttribute()
+    }
 
     /**
      * 获得cookie
@@ -178,7 +178,7 @@ object SPageContext {
         }
 
         return null
-    } // Fun getCookie()
+    }
 
     /**
      * 添加cookie
@@ -196,7 +196,7 @@ object SPageContext {
 
         response.addCookie(cookie)
         return
-    } // Fun setCookie()
+    }
 
     /**
      * 删除cookie
@@ -213,7 +213,7 @@ object SPageContext {
         response.addCookie(cookie)
 
         return
-    } // Fun addCookie()
+    }
 
     /**
      * 获得请求头
@@ -224,7 +224,7 @@ object SPageContext {
     fun getHeader(name: String): String? {
         val request = getRequest()
         return request.getHeader(name)
-    } // Fun getHeader()
+    }
 
     /**
      * 获得客户端的IP地址
@@ -238,21 +238,26 @@ object SPageContext {
         if (null == ip || ip.isEmpty() || ip.equals("unknown", ignoreCase = true)) {
             ip = request.getHeader("Proxy-Client-IP")
         }
+
         if (null == ip || ip.isEmpty() || ip.equals("unknown", ignoreCase = true)) {
             ip = request.getHeader("WL-Proxy-Client-IP")
         }
+
         if (null == ip || ip.isEmpty() || ip.equals("unknown", ignoreCase = true)) {
             ip = request.getHeader("HTTP_CLIENT_IP")
         }
+
         if (null == ip || ip.isEmpty() || ip.equals("unknown", ignoreCase = true)) {
             ip = request.getHeader("HTTP_X_FORWARDED_FOR")
         }
+
         if (null == ip || ip.isEmpty() || ip.equals("unknown", ignoreCase = true)) {
             ip = request.remoteAddr
             if (ip!!.contains(":")) {
                 ip = "127.0.0.1"
             }
         }
+
         return ip
-    } // Fun getRequestIp()
-} // Object SPageContext
+    }
+}

persagy-service-base/src/main/kotlin/com/persagy/service/config/SAsyncConfig.kt

@@ -36,10 +36,10 @@ import java.util.concurrent.Executor
 /**
  * 异步线程池配置文件
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
-@Configuration  //表明该类是一个配置类
-@EnableAsync    //开启异步事件的支持
+@Configuration  /** 表明该类是一个配置类 */
+@EnableAsync    /** 开启异步事件的支持 */
 @PropertySource(value = ["classpath:application.properties"], ignoreResourceNotFound = true)
 open class SAsyncConfig {
 
@@ -66,5 +66,5 @@ open class SAsyncConfig {
         executor.setQueueCapacity(queueCapacity)
         executor.initialize();
         return executor
-    } // Function
-} // Class SAsyncConfig
+    }
+}

persagy-service-base/src/main/kotlin/com/persagy/service/interceptors/SAccessControlAllowOriginInterceptor.kt

@@ -36,14 +36,14 @@ import javax.servlet.http.HttpServletResponse
 /**
  * 允许跨域访问拦截器
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 class SAccessControlAllowOriginInterceptor : HandlerInterceptorAdapter() {
-    // 定义类对象
+    /** 定义类对象 */
     companion object {
-        // 日志
+        /** 日志 */
         private val logger = LoggerFactory.getLogger(SAccessControlAllowOriginInterceptor::class.java)
-    } // companion object
+    }
 
     /**
      *
@@ -54,7 +54,7 @@ class SAccessControlAllowOriginInterceptor : HandlerInterceptorAdapter() {
         response.addHeader("Access-Control-Allow-Headers", "cache-control,content-type,hash-referer,x-requested-with")
 
         return true
-    } // Fun preHandle
+    }
 
     /**
      *
@@ -68,6 +68,6 @@ class SAccessControlAllowOriginInterceptor : HandlerInterceptorAdapter() {
      */
     override fun afterCompletion(request: HttpServletRequest?, response: HttpServletResponse?, handler: Any?, ex: Exception?) {
         return
-    } // Fun afterCompletion()
+    }
 
-} // Class SPageInterceptor
+}

persagy-service-base/src/main/kotlin/com/persagy/service/interceptors/SPageInterceptor.kt

@@ -37,14 +37,14 @@ import javax.servlet.http.HttpServletResponse
 /**
  * 页面拦截器
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 class SPageInterceptor(val accessControlAllowOrigin: Boolean = true) : HandlerInterceptor {
-    // 定义类对象
+    /** 定义类对象 */
     companion object {
-        // 日志
+        /** 日志 */
         private val logger = LoggerFactory.getLogger(SPageInterceptor::class.java)
-    } // companion object
+    }
 
     /**
      *
@@ -76,6 +76,6 @@ class SPageInterceptor(val accessControlAllowOrigin: Boolean = true) : HandlerIn
         SPageContext.removeRequest()
         SPageContext.removeResponse()
         return
-    } // Fun afterCompletion()
+    }
 
-} // Class SPageInterceptor
+}

persagy-service-base/src/main/kotlin/com/persagy/service/json/SFastjsonAnnotationIntrospector.kt

@@ -33,17 +33,17 @@ import com.fasterxml.jackson.databind.introspect.Annotated
 import com.persagy.base.extensions.toJson
 
 /**
- * swagger使用的json注解拦截器
+ * swagger 使用的 json 注解拦截器
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 class SFastjsonAnnotationIntrospector : JacksonAnnotationIntrospector() {
 
     /**
-     * 判断注解是否为JSONField类型
+     * 判断注解是否为 JSONField 类型
      *
-     * @param   ann         注解
-     * @return  如果有JSONField注解，则返回true；否则false.
+     * @param ann         注解
+     * @return 如果有 JSONField 注解，则返回 true；否则 false.
      */
     override fun isAnnotationBundle(ann: Annotation): Boolean {
         println("ann = ${ann.toJson()}")
@@ -54,13 +54,13 @@ class SFastjsonAnnotationIntrospector : JacksonAnnotationIntrospector() {
             println("ann = -------")
             super.isAnnotationBundle(ann)
         }
-    } // Fun isAnnotationBundle()
+    }
 
     /**
      * 为序列为操作查找属性名
      *
-     * @param   a           注解
-     * @return  属性名
+     * @param a           注解
+     * @return 属性名
      */
     override fun findNameForSerialization(a: Annotated): PropertyName? {
         val nameForSerialization = super.findNameForSerialization(a)
@@ -71,13 +71,13 @@ class SFastjsonAnnotationIntrospector : JacksonAnnotationIntrospector() {
             }
         }
         return nameForSerialization
-    } // Fun findNameForSerialization()
+    }
 
     /**
      * 为反序列为操作查找属性名
      *
-     * @param   a           注解
-     * @return  属性名
+     * @param a           注解
+     * @return 属性名
      */
     override fun findNameForDeserialization(a: Annotated): PropertyName? {
         val nameForDeserialization = super.findNameForDeserialization(a)
@@ -88,5 +88,5 @@ class SFastjsonAnnotationIntrospector : JacksonAnnotationIntrospector() {
             }
         }
         return nameForDeserialization
-    } // Fun findNameForDeserialization()
-} // Class SFastjsonAnnotationIntrospector
+    }
+}

persagy-service-base/src/main/kotlin/com/persagy/service/utils/SBeanUtil.kt

@@ -31,18 +31,18 @@ import org.springframework.beans.factory.support.DefaultListableBeanFactory
 import org.springframework.context.ApplicationContext
 
 /**
- * Bean工具类
+ * Bean 工具类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 object SBeanUtil {
 
     /**
      * 动态注册Bean
      *
-     * @param   ctx     应用上下文
-     * @param   clz     Bean对应的类
-     * @param   name    Bean名称
+     * @param ctx     应用上下文
+     * @param clz     Bean 对应的类
+     * @param name    Bean 名称
      */
     fun registBeanDefinition(ctx: ApplicationContext, clz: Class<*>, name: String) {
         val defaultBeanFactory = ctx.autowireCapableBeanFactory as (DefaultListableBeanFactory)
@@ -51,17 +51,17 @@ object SBeanUtil {
         defaultBeanFactory.registerBeanDefinition(name, beanDefinitionBuilder.beanDefinition)
         defaultBeanFactory.removeBeanDefinition(name)
         return
-    } // Fun registBeanDefinition()
+    }
 
     /**
-     * 动态删除注册的Bean
+     * 动态删除注册的 Bean
      *
-     * @param   ctx     应用上下文
-     * @param   name    Bean名称
+     * @param ctx     应用上下文
+     * @param name    Bean 名称
      */
     fun removeBeanDefinition(ctx: ApplicationContext, name: String) {
         val defaultBeanFactory = ctx.autowireCapableBeanFactory as (DefaultListableBeanFactory)
         defaultBeanFactory.removeBeanDefinition(name)
         return
-    } // Fun removeBeanDefinition()
-} // Class SBeanUtil()
+    }
+}

persagy-service-base/src/main/kotlin/com/persagy/service/utils/SJsonUtil.kt

@@ -38,11 +38,11 @@ object SJsonUtil {
     val serializeConfig = SerializeConfig()
 
     /**
-     * 转换对象到json格式字符串
+     * 转换对象到 json 格式字符串
      *
-     * @param   obj                     被转换对象
-     * @param   namingStrategy          命名规则
-     * @return  json格式字符串
+     * @param obj                     被转换对象
+     * @param namingStrategy          命名规则
+     * @return json 格式字符串
      */
     fun toJson(obj: Any, namingStrategy: PropertyNamingStrategy? = null): String {
         return if (null == namingStrategy) {
@@ -52,14 +52,14 @@ object SJsonUtil {
             config.propertyNamingStrategy = namingStrategy
             JSON.toJSONString(obj, config, SerializerFeature.DisableCircularReferenceDetect)
         }
-    } // Fun toJson()
+    }
 
     /**
-     * 转换对象到json格式字符串，包含空字符串
+     * 转换对象到 json 格式字符串，包含空字符串
      *
-     * @param   obj                     被转换对象
-     * @param   namingStrategy          首字母是否大写
-     * @return  json格式字符串
+     * @param obj                     被转换对象
+     * @param namingStrategy          首字母是否大写
+     * @return json 格式字符串
      */
     fun toJsonAll(obj: Any, namingStrategy: PropertyNamingStrategy? = null): String {
         return if (null == namingStrategy) {
@@ -77,39 +77,39 @@ object SJsonUtil {
                     SerializerFeature.WriteNullListAsEmpty,
                     SerializerFeature.DisableCircularReferenceDetect)
         }
-    } // Fun toJsonAll()
+    }
 
     /**
-     * 将Json数据解析成相应的映射对象
+     * 将 Json 数据解析成相应的映射对象
      *
-     * @param   jsonData                要解析的JSON数据
-     * @param   type                    Java类型
-     * @return  解析结果
+     * @param jsonData                要解析的 JSON 数据
+     * @param type                    Java 类型
+     * @return 解析结果
      */
     @Throws(Exception::class)
     fun <T> fromJson(jsonData: String, type: Class<T>): T? {
         return JSON.parseObject(jsonData, type)
-    } // Fun fromJson()
+    }
 
     /**
-     * 将Json数据解析成相应的映射对象
+     * 将 Json 数据解析成相应的映射对象
      *
-     * @param   jsonData                要解析的JSON数据
-     * @param   type                    Java类型
-     * @return  解析结果
+     * @param jsonData                要解析的 JSON 数据
+     * @param type                    Java 类型
+     * @return 解析结果
      */
     @Throws(Exception::class)
     fun fromJson(jsonData: String, type: Type): Any? {
         return JSON.parseObject(jsonData, type)
-    } // Fun fromJson()
+    }
 
     /**
-     * 将Json数据解析成相应的映射对象
+     * 将 Json 数据解析成相应的映射对象
      *
-     * @param   input                   要解析的JSON数据输入流
-     * @param   type                    Java类型
-     * @param   namingStrategy          命名规则
-     * @return  解析结果
+     * @param input                   要解析的 JSON 数据输入流
+     * @param type                    Java 类型
+     * @param namingStrategy          命名规则
+     * @return 解析结果
      */
     @Throws(Exception::class)
     fun <T> fromJson(input: InputStream, type: Class<T>): T? {
@@ -121,27 +121,27 @@ object SJsonUtil {
         }
 
         return fromJson(String(buf), type)
-    } // Fun fromJson()
+    }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     /**
-     * 将Json数据解析成相应的映射对象
+     * 将 Json 数据解析成相应的映射对象
      *
-     * @param   jsonData                要解析的JSON数据
-     * @param   namingStrategy          命名规则
-     * @return  解析结果
+     * @param jsonData                要解析的 JSON 数据
+     * @param namingStrategy          命名规则
+     * @return 解析结果
      */
     @Throws(Exception::class)
     inline fun <reified T> fromJson(jsonData: String, namingStrategy: PropertyNamingStrategy? = null): T {
         return JSON.parseObject(jsonData, T::class.java)
-    } // Fun parseJson()
+    }
 
     /**
-     * 将Json数据解析成相应的映射对象
+     * 将 Json 数据解析成相应的映射对象
      *
-     * @param   input                   要解析的JSON数据输入流
-     * @param   namingStrategy          命名规则
-     * @return  解析结果
+     * @param input                   要解析的 JSON 数据输入流
+     * @param namingStrategy          命名规则
+     * @return 解析结果
      */
     @Throws(Exception::class)
     inline fun <reified T> fromJson(input: InputStream, namingStrategy: PropertyNamingStrategy? = null): T {
@@ -153,5 +153,5 @@ object SJsonUtil {
         }
 
         return fromJson(String(buf), namingStrategy)
-    } // Fun fromJson()
-} // Object SJsonUtil
+    }
+}

persagy-service-base/src/main/kotlin/com/persagy/service/utils/SQrCodeUtil.kt

@@ -40,7 +40,7 @@ import javax.servlet.http.HttpServletResponse
 /**
  * 二维码生成工具
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 object SQrCodeUtil {
 
@@ -50,22 +50,22 @@ object SQrCodeUtil {
     /**
      * 生成并返回二维码到 Web 客户端
      *
-     * @param   response        web 请求应答体
-     * @param   contents        二维码存储的内容
-     * @param   size            二维码大小
-     * @param   logo            二维码中间的logo图像
-     * @return  二维码图像
+     * @param response        web 请求应答体
+     * @param contents        二维码存储的内容
+     * @param size            二维码大小
+     * @param logo            二维码中间的 logo 图像
+     * @return 二维码图像
      */
     fun outQrCode(response: HttpServletResponse, contents: String, size: Int, logo: BufferedImage? = null) {
         val buffImg = createQrCode(contents, size, logo)
 
-        // 禁止图像缓存
+        /** 禁止图像缓存 */
         response.setHeader("Pragma", "no-cache")
         response.setHeader("Cache-Control", "no-cache")
         response.setDateHeader("Expires", 0)
         response.contentType = "image/jpeg"
 
-        // 将图像输出到Servlet输出流中
+        /** 将图像输出到Servlet输出流中 */
         val sos: ServletOutputStream
         try {
             sos = response.outputStream
@@ -76,14 +76,14 @@ object SQrCodeUtil {
         }
 
         return
-    } // Fun outQrCode()
+    }
 
     /**
      * 创建二维码图像
      *
-     * @param   contents        二维码存储的内容
-     * @param   size            二维码大小
-     * @return  二维码图像
+     * @param contents        二维码存储的内容
+     * @param size            二维码大小
+     * @return 二维码图像
      */
     fun createQrCode(contents: String, size: Int, logo: BufferedImage? = null): BufferedImage? {
         try {
@@ -112,14 +112,14 @@ object SQrCodeUtil {
             e.printStackTrace()
         }
         return null
-    } // Fun createQrCode()
+    }
 
     /**
-     * 为二维码图片增加Logo
+     * 为二维码图片增加 Logo
      *
-     * @param   src         二维码图片
-     * @param   logo        Logol图片
-     * @return  添加过Logo的二维码图片
+     * @param src         二维码图片
+     * @param logo        Logol 图片
+     * @return 添加过 Logo 的二维码图片
      */
     private fun addLogo(src: BufferedImage, logo: BufferedImage): BufferedImage {
         val srcWidth = src.width
@@ -133,5 +133,5 @@ object SQrCodeUtil {
         gd.drawImage(logo,srcWidth * 2 / 5, srcHeight * 2 / 5, srcWidth * 3 / 5, srcHeight / 5, null)
 
         return image
-    } // Fun addLogo()
-} // Object SQrCodeUtil
+    }
+}

persagy-service-base/src/main/kotlin/com/persagy/service/utils/SRandCodeUtil.kt

@@ -42,7 +42,7 @@ import java.util.Random
  * @author 庞利祥 <sybotan@126.com>
  */
 object SRandCodeUtil {
-    // 日志
+    /** 日志 */
     private val logger = LoggerFactory.getLogger(SRandCodeUtil::class.java)
 
     /**
@@ -52,34 +52,34 @@ object SRandCodeUtil {
      * @param response 服务器应答对象
      */
     fun checkCode(request: HttpServletRequest, response: HttpServletResponse) {
-        val width = 195// 验证码图片的宽度
-        val height = 26// 验证码图片的高度
-        val codeCount = 4// 验证码字符个
+        val width = 195         /** 验证码图片的宽度 */
+        val height = 26         /** 验证码图片的高度 */
+        val codeCount = 4       /** 验证码字符个 */
         val xx: Int
-        val fontHeight: Int// 字体高度
+        val fontHeight: Int     /** 字体高度 */
         val codeY: Int
         val codeSequence = charArrayOf('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6', '7', '8', '9')
         xx = width / (codeCount + 1)
         fontHeight = height - 2
         codeY = height - 5
 
-        // 定义图像buffer
+        /** 定义图像buffer */
         val buffImg = BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
         val gd = buffImg.createGraphics()
 
-        // 创建随机数生成器
+        /** 创建随机数生成器 */
         val random = Random()
 
-        // 将图像填充为白色
+        /** 将图像填充为白色 */
         gd.color = Color.WHITE
         gd.fillRect(0, 0, width, height)
 
-        // 创建字体，字体的大小应该根据图片的高度来定
-        // 字体
+        /** 创建字体，字体的大小应该根据图片的高度来定 */
+        /** 字体 */
         val fontTypes = arrayOf("tahoma", "Atlantic Inline", "fantasy", "Times New Roman", "Georgia", "Arial", "Helvetica", "sans-serif", "System")
         val fontTypesLength = fontTypes.size
         val font = Font(fontTypes[random.nextInt(fontTypesLength)], Font.BOLD, fontHeight)
-        // 设置字体
+        /** 设置字体 */
         gd.font = font
 
         gd.color = Color.red
@@ -89,41 +89,41 @@ object SRandCodeUtil {
             gd.drawOval(x, y, 0, 0)
         }
 
-        // randomCode用于保存随机产生的验证码，以便用户登录后进行验证
+        /** randomCode用于保存随机产生的验证码，以便用户登录后进行验证 */
         val randomCode = StringBuffer()
         var red: Int
         var green: Int
         var blue: Int
 
-        // 随机产生codeCount数字的验证码
+        /** 随机产生codeCount数字的验证码 */
         for (i in 0 until codeCount) {
-            // 得到随机产生的验证码数字
+            /** 得到随机产生的验证码数字 */
             val strRand = codeSequence[random.nextInt(34)].toString()
-            // 产生随机的颜色分量来构建颜色值，这样输出的每位数字的颜色值都将不同
+            /** 产生随机的颜色分量来构建颜色值，这样输出的每位数字的颜色值都将不同 */
             red = random.nextInt(200)
             green = random.nextInt(200)
             blue = random.nextInt(200)
 
-            // 用随机产生的颜色将验证码绘制到图像中
+            /** 用随机产生的颜色将验证码绘制到图像中 */
             gd.color = Color(red, green, blue)
             gd.drawString(strRand, (i + 1) * xx, codeY)
 
-            // 将产生的四个随机数组合在
+            /** 将产生的四个随机数组合在 */
             randomCode.append(strRand)
         }
 
-        // 将四位数字的验证码保存到Session中
+        /** 将四位数字的验证码保存到 Session 中 */
         logger.debug("verifyCode = $randomCode")
         val session = request.session
         session.setAttribute("verifyCode", randomCode.toString())
 
-        // 禁止图像缓存
+        /** 禁止图像缓存 */
         response.setHeader("Pragma", "no-cache")
         response.setHeader("Cache-Control", "no-cache")
         response.setDateHeader("Expires", 0)
         response.contentType = "image/jpeg"
 
-        // 将图像输出到Servlet输出流中
+        /** 将图像输出到Servlet输出流中 */
         val sos: ServletOutputStream
         try {
             sos = response.outputStream
@@ -133,6 +133,6 @@ object SRandCodeUtil {
             e.printStackTrace()
         }
         return
-    } // Fun checkCode()
+    }
 
-} // Class RandCOdeUtil
+}

persagy-service-base/src/main/kotlin/com/persagy/service/utils/SSpringContextUtil.kt

@@ -31,9 +31,9 @@ import org.springframework.context.ApplicationContextAware
 import org.springframework.stereotype.Component
 
 /**
- * Spring上下文环境工具
+ * Spring 上下文环境工具
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Component
 class SSpringContextUtil : ApplicationContextAware{
@@ -42,34 +42,34 @@ class SSpringContextUtil : ApplicationContextAware{
         lateinit var applicationContext: ApplicationContext
 
         /**
-         * 根据名称获得Bean
+         * 根据名称获得 Bean
          *
-         * @param   name    bean名称
-         * @return  对应的bean对象
+         * @param name    bea名称
+         * @return 对应的 bean 对象
          */
         fun getBean(name: String) : Any? {
             return applicationContext.getBean(name)
-        } // Fun getBean()
+        }
 
         /**
-         * 根据类型获得Bean
+         * 根据类型获得 Bean
          *
-         * @param   requiredType    类型
-         * @return  对应的bean对象
+         * @param requiredType    类型
+         * @return 对应的 bean 对象
          */
         fun getBean(requiredType: Class<*>) : Any? {
             return applicationContext.getBean(requiredType)
-        } // Fun getBean()
+        }
     }
 
     /**
-     * 实现ApplicationContextAware接口的回调方法。设置上下文环境
+     * 实现 ApplicationContextAware 接口的回调方法。设置上下文环境
      *
-     * @param   context     应用上下文对象
+     * @param context     应用上下文对象
      */
     override fun setApplicationContext(context: ApplicationContext) {
         applicationContext = context
         return
-    } // Fun setApplicationContext()
+    }
 
-} // SSpringContextUtil
+}

persagy-service-base/src/main/kotlin/com/persagy/service/utils/crypt/SAESCoderUtil.kt

@@ -36,7 +36,7 @@ import java.security.SecureRandom
 import java.util.*
 
 /**
- * AES安全编码组件
+ * AES 安全编码组件
  *
  * @author Andy
  */
@@ -47,8 +47,8 @@ abstract class SAESCoderUtil : SCoderUtil() {
         /**
          * 转换密钥
          *
-         * @param key
-         * @return
+         * @param key 字节数组
+         * @return key
          * @throws Exception
          */
         @Throws(Exception::class)
@@ -114,7 +114,7 @@ abstract class SAESCoderUtil : SCoderUtil() {
             val secretKey = kg.generateKey()
 
             return Base64.getEncoder().encodeToString(secretKey.encoded)
-        } // Fun initKey()
-    } // companion object
-} // Class SAESCoderUtil
+        }
+    }
+}
 

persagy-service-base/src/main/kotlin/com/persagy/service/utils/crypt/SCoderUtil.kt

@@ -82,7 +82,7 @@ abstract class SCoderUtil {
             val sha = MessageDigest.getInstance(KEY_SHA)
             sha.update(data)
             return sha.digest()
-        } // Fun encryptSHA()
+        }
     }
 
-} // Class SCoderUtil
+}

persagy-service-kafka/src/main/kotlin/com/persagy/service/kafka/SBaseNotice.kt

@@ -29,6 +29,6 @@ package com.persagy.service.kafka
 /**
  * 通知基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 open class SBaseNotice(val type: String, val ops: String)

persagy-service-kafka/src/main/kotlin/com/persagy/service/kafka/SKafkaService.kt

@@ -36,7 +36,7 @@ import java.util.*
 /**
  * Kafka 服务。用于连接 kafka, 收发 kafka 消息
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 open class SKafkaService {
     /** 延迟发送时间 */
@@ -50,9 +50,9 @@ open class SKafkaService {
     /**
      * 发送通知
      *
-     * @param   topic       发送标题
-     * @param   notice      通知
-     * @param   delaySend   是否启动延迟发送，默认延迟发送
+     * @param topic       发送标题
+     * @param notice      通知
+     * @param delaySend   是否启动延迟发送，默认延迟发送
      */
     fun sendNotice(topic: String, notice: SBaseNotice, delaySend: Boolean = true) {
         val delayData = delayMap[topic] ?: SDelayData()
@@ -60,7 +60,7 @@ open class SKafkaService {
             delayMap[topic] = delayData
         }
 
-        // 合并请求
+        /** 合并请求 */
         if (!mergeNotice(topic, notice)) {
             if (delayData.lastNotice != null) {
                 sendTopic(topic, delayData.lastNotice!!.toJson())
@@ -68,7 +68,7 @@ open class SKafkaService {
             delayData.lastNotice = notice
         }
 
-        // 是否延迟发送
+        /** 是否延迟发送 */
         if (delaySend) {
             delaySend(topic)
         } else {
@@ -76,13 +76,13 @@ open class SKafkaService {
         }
 
         return
-    } // Fun sendNotice()
+    }
 
     /**
      * 发送 topic 消息
      *
-     * @param   topic       发送标题
-     * @param   data        消息数据
+     * @param topic       发送标题
+     * @param data        消息数据
      */
     fun sendTopic(topic: String, data: String) {
         val future: ListenableFuture<SendResult<Int, String>> = kafkaTemplate.send(topic, data).also {
@@ -101,54 +101,54 @@ open class SKafkaService {
         }
 
         kafkaTemplate.flush()
-    } // Fun sendTopic()
+    }
 
     /**
      * 合并通知
      *
-     * @param   lastNotice          缓存的通知
-     * @param   notice              新的通知
-     * @return  成功返回true，否则返回false
+     * @param lastNotice          缓存的通知
+     * @param  notice              新的通知
+     * @return 成功返回 true，否则返回 false
      */
     open fun mergeNotice(lastNotice: SBaseNotice, notice: SBaseNotice): Boolean {
         return false
-    } // Function mergeNotice()
+    }
 
     /**
      * 延迟发送缓存的消息
      *
-     * @param   topic       发送标题
+     * @param topic       发送标题
      */
     private fun delaySend(topic: String) {
         val delayData = delayMap[topic] ?: return
 
-        // 如果延迟任务不为空，则取消之前的延迟任务。保证延迟任务在最后一次发送后执行。
+        /** 如果延迟任务不为空，则取消之前的延迟任务。保证延迟任务在最后一次发送后执行。 */
         if (delayData.delayTask != null) {
             delayData.delayTask!!.cancel()
         }
 
-        // 创建延迟任务
+        /** 创建延迟任务 */
         delayData.delayTask = object : TimerTask() {
             override fun run() {
-                // 发送缓存的任务
+                /** 发送缓存的任务 */
                 flush(topic)
             }
         }
 
-        // 启动延迟发送任务
+        /** 启动延迟发送任务 */
         delayData.delayTimer.schedule(delayData.delayTask, delaySendTime)
 
         return
-    } // Fun delaySend()
+    }
 
     /**
      * 发送缓存的消息
      *
-     * @param   topic       发送标题
+     * @param topic       发送标题
      */
     fun flush(topic: String) {
         val delayData = delayMap[topic] ?: return
-        // 如果没有缓存通知
+        /** 如果没有缓存通知 */
         if (delayData.lastNotice == null) {
             return
         }
@@ -157,26 +157,26 @@ open class SKafkaService {
         delayData.lastNotice = null
 
         return
-    } // Fun flush()
+    }
 
     /**
      * 合并通知
      *
-     * @param   topic       发送标题
-     * @param   notice      要合并的通知
-     * @return  成功返回true，否则返回false
+     * @param topic       发送标题
+     * @param notice      要合并的通知
+     * @return 成功返回 true，否则返回 false
      */
     private fun mergeNotice(topic: String, notice: SBaseNotice): Boolean {
         val delayData = delayMap[topic] ?: return false
 
-        // 如果最后发送的通知为空
+        /** 如果最后发送的通知为空 */
         if (delayData.lastNotice == null) {
             delayData.lastNotice = notice
             return true
         }
 
         return mergeNotice(delayData.lastNotice!!, notice)
-    } // Fun mergeNotice()
+    }
 
     /**
      * 延迟处理数据
@@ -188,5 +188,5 @@ open class SKafkaService {
         val delayTimer = Timer()
         /** 延迟发送通知定时任务 */
         var delayTask: TimerTask? = null
-    } // Class SDelayData
-} // Class SKafkaService
+    }
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/SBaseEntity.kt

@@ -34,7 +34,7 @@ import kotlin.collections.HashMap
 /**
  * 实体类基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 open class SBaseEntity {
     /** 统计信息 */
@@ -50,4 +50,4 @@ open class SBaseEntity {
     @Schema(description = "创建时间", example = "2017-10-15 08:30:00")
     @Column(name = "create_time", updatable = false, insertable = false)
     var createTime: Date? = null
-} // Class SBaseEntity
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/SCascadeQuery.kt

@@ -33,7 +33,7 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 级联查询对象
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 class SCascadeQuery {
     /** 级联对象属性名 */
@@ -63,4 +63,4 @@ class SCascadeQuery {
     /** 分组统计 */
     @Schema(description = "分组")
     var group: SGroup? = null
-} // Class SCascadeQuery
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/SCascadeUpdate.kt

@@ -33,7 +33,7 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 级联更新对象
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 class SCascadeUpdate {
     /** 级联对象属性名 */
@@ -47,4 +47,4 @@ class SCascadeUpdate {
     /** 更新模式 */
     @Schema(description = "更新模式")
     var mode: SCascadeUpdateMode = SCascadeUpdateMode.Override
-} // Class SCascadeQuery
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/SJoinQuery.kt

@@ -30,9 +30,9 @@ import io.swagger.v3.oas.annotations.media.Schema
 
 
 /**
- * Join查询对象
+ * Join 查询对象
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 class SJoinQuery {
     /** 级联对象属性名 */
@@ -42,4 +42,4 @@ class SJoinQuery {
     /** 字段影射，空为查询所有字段 */
     @Schema(description = "字段影射，空为查询所有字段")
     var projection = ArrayList<String>()
-} // Class SJoinQuery
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/annotations/SCascade.kt

@@ -31,7 +31,7 @@ import java.lang.annotation.Inherited
 /**
  * 数据库访问框架级联注解
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Target(AnnotationTarget.FIELD)
 @MustBeDocumented
@@ -47,4 +47,4 @@ annotation class SCascade (
         val self: Boolean = false,
         /** 过滤条件 */
         val filter: String = ""
-) // Annotation SCascade
+)

persagy-service-models/src/main/kotlin/com/persagy/service/models/annotations/SCascadeCount.kt

@@ -32,7 +32,7 @@ import kotlin.reflect.KClass
 /**
  * 数据库访问框架级联注解
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Target(AnnotationTarget.FIELD)
 @MustBeDocumented
@@ -50,4 +50,4 @@ annotation class SCascadeCount (
         val self: Boolean = false,
         /** 过滤条件 */
         val filter: String = ""
-) // Annotation SCascade
+)

persagy-service-models/src/main/kotlin/com/persagy/service/models/enums/SCascadeUpdateMode.kt

@@ -29,11 +29,11 @@ package com.persagy.service.models.enums
 /**
  * 更新模式
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 enum class SCascadeUpdateMode {
     /** 将原来的级联数据删除，更新新的级联数据 */
     Override,
     /** 不删除原来的级联数据，将新的级联数据合并 */
     Merge
-} // Enum SCascadeUpdateMode
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/enums/SResponseType.kt

@@ -32,8 +32,8 @@ package com.persagy.service.models.enums
  * @author 庞利祥 <sybotan@126.com>
  */
 enum class SResponseType {
-    success,            // 成功
-    failure,            // 失败
-    exception,          // 异常
-    notFound            // 未找到
-} // Enum Class SResponseType
+    success,            /** 成功 */
+    failure,            /** 失败 */
+    exception,          /** 异常 */
+    notFound            /** 未找到 */
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/requests/SCountRequest.kt

@@ -32,11 +32,11 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 统计请求对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "统计请求对象基类")
 open class SCountRequest {
     /** 查询条件 */
     @Schema(description = "查询条件")
     var filters: String? = null
-} // Class SCountRequest
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/requests/SCreateRequest.kt

@@ -33,7 +33,7 @@ import javax.validation.Valid
 /**
  * 创建请求对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "创建请求对象基类")
 open class SCreateRequest<ENTITY: Any> {
@@ -49,4 +49,4 @@ open class SCreateRequest<ENTITY: Any> {
     /** 级联对象列表 */
     @Schema(description = "级联对象列表")
     var cascade: ArrayList<SCascadeUpdate>? = null
-} // Class SCreateRequest
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/requests/SDeleteRequest.kt

@@ -31,11 +31,11 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 删除请求对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "删除请求对象基类")
 open class SDeleteRequest<KEY: Any> {
     /** 删除内容 */
     @Schema(description = "删除内容", required = true)
     lateinit var keyList: ArrayList<KEY>
-}  // Class SDeleteRequest
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/requests/SQueryRequest.kt

@@ -34,14 +34,14 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 查询请求对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "查询请求对象基类")
 open class SQueryRequest {
     companion object {
         /** 设置接口一次可取得的最大记录数 */
         var maxRow = 1000
-    } // Companion object
+    }
 
     /** 第几页 */
     @Schema(description = "第几页(从1开始)", example = "1")
@@ -91,4 +91,4 @@ open class SQueryRequest {
     /** 分组统计 */
     @Schema(description = "分组")
     var group: SGroup? = null
-} // Class SQueryRequest
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/requests/SUpdateRequest.kt

@@ -33,7 +33,7 @@ import javax.validation.Valid
 /**
  * 更新请求对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "更新请求对象基类")
 open class SUpdateRequest<ENTITY: Any> {
@@ -49,4 +49,4 @@ open class SUpdateRequest<ENTITY: Any> {
     /** 字段影射，空为查询所有字段 */
     @Schema(description = "字段影射，空为更新所有字段")
     var projection: ArrayList<String>? = null
-} // Class SUpdateRequest
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/responses/SBaseResponse.kt

@@ -33,7 +33,7 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 应答对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "应答对象基类")
 open class SBaseResponse(result: SResponseType = SResponseType.failure, message: String = "") {
@@ -48,5 +48,5 @@ open class SBaseResponse(result: SResponseType = SResponseType.failure, message:
     init {
         this.result = result
         this.message = message
-    } // init()
-} // Class SBaseResponse
+    }
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/responses/SCountResponse.kt

@@ -32,7 +32,7 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 统计请求应答对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "统计请求应答对象基类")
 open class SCountResponse(
@@ -40,4 +40,4 @@ open class SCountResponse(
         @Schema(description = "符合条件的记录数")
         val count: Long = 0,
         result: SResponseType = SResponseType.success, message: String = ""
-) : SBaseResponse(result, message)  // Class SCountResponse
+) : SBaseResponse(result, message)

persagy-service-models/src/main/kotlin/com/persagy/service/models/responses/SCreateResponse.kt

@@ -32,7 +32,7 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 创建对象请求应答对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "查询请求应答对象基类")
 open class SCreateResponse<ENTITY: Any>(result: SResponseType = SResponseType.failure, message: String = "")
@@ -49,6 +49,6 @@ open class SCreateResponse<ENTITY: Any>(result: SResponseType = SResponseType.fa
      */
     constructor(entity: ArrayList<ENTITY>) : this(SResponseType.success, "") {
         this.entityList = entity
-    } // Fun constructor()
+    }
 
-} // Class SCreateResponse
+}

persagy-service-models/src/main/kotlin/com/persagy/service/models/responses/SDeleteResponse.kt

@@ -32,10 +32,10 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 统计请求应答对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "删除请求应答对象基类")
 open class SDeleteResponse(
         result: SResponseType = SResponseType.failure,
         message: String = ""
-) : SBaseResponse(result, message) // Class SDeleteResponse
+) : SBaseResponse(result, message)

persagy-service-models/src/main/kotlin/com/persagy/service/models/responses/SQueryResponse.kt

@@ -33,7 +33,7 @@ import io.swagger.v3.oas.annotations.media.Schema
 /**
  * 查询请求应答对象基类
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "查询请求应答对象基类")
 open class SQueryResponse<ENTITY: Any>(result: SResponseType = SResponseType.success, message: String = "")
@@ -64,5 +64,5 @@ open class SQueryResponse<ENTITY: Any>(result: SResponseType = SResponseType.suc
         this.pageNumber = info.pageNumber
         this.pageSize = info.pageSize
         this.content = info.content
-    } // Fun constructor()
-} // Class SQueryResponse
+    }
+}

persagy-service-mybatis/src/main/kotlin/com/persagy/mybatis/SDaoFactory.kt

@@ -30,19 +30,19 @@ import com.persagy.database.SAbstractDao
 import com.persagy.database.SAbstractDaoFactory
 
 /**
- * Dao工厂
+ * Dao 工厂
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 class SDaoFactory<ENTITY: Any> : SAbstractDaoFactory<ENTITY>() {
     /**
-     * 创建DAO对象
+     * 创建 DAO 对象
      *
-     * @param   entityClazz     实体类
-     * @return  实体类的数据访问对象
+     * @param entityClazz     实体类
+     * @return 实体类的数据访问对象
      */
     override fun createDao(entityClazz: Class<ENTITY>): SAbstractDao<ENTITY> {
         return SMybatisDao(entityClazz)
-    } // Fun createDao()
+    }
 
-} // Class SDaoFactory
+}

persagy-service-mybatis/src/main/kotlin/com/persagy/mybatis/SMybatisDao.kt

@@ -32,7 +32,7 @@ import org.mybatis.spring.SqlSessionTemplate
 import javax.sql.DataSource
 
 /**
- * Mybatis基础Dao操作
+ * Mybatis 基础 Dao 操作
  *
  * @author 庞利祥 <sybotan@126.com>
  */
@@ -62,4 +62,4 @@ open class SMybatisDao<ENTITY: Any>(entityClazz: Class<ENTITY>, val mapperClass:
         val map = sqlSession.getMapper(clz as Class<IBaseMapper<ENTITY>>)
         map
     }
-} // Class SMybatisDao
+}

persagy-service-mysql/src/main/kotlin/com/persagy/service/mysql/controllers/SDatabaseDocController.kt

@@ -36,7 +36,7 @@ import org.springframework.web.bind.annotation.*
 /**
  * 数据库设计接口
  *
- * @author  庞利祥(sybotan@126.com)
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Tag(name = "数据库设计接口")
 @RestController
@@ -51,21 +51,21 @@ class SDatabaseDocController {
     /**
      * 查询表信息
      *
-     * @param   schema      数据库
-     * @return  字段列表
+     * @param schema      数据库
+     * @return 字段列表
      */
     @Operation(summary="查询表信息",description = "")
     @RequestMapping(value = ["/table-list"], method = [RequestMethod.GET, RequestMethod.POST])
     fun tableList(schema: String): List<Any> {
         return tableService.select("schemaName" to schema).exec()
-    } // Function tableList()
+    }
 
     /**
      * 查询字段信息
      *
-     * @param   schema      数据库
-     * @param   table       表名
-     * @return  字段列表
+     * @param schema      数据库
+     * @param table       表名
+     * @return 字段列表
      */
     @Operation(summary="查询字段信息", description="")
     @RequestMapping(value = ["/column-list"], method = [RequestMethod.GET, RequestMethod.POST])
@@ -80,11 +80,15 @@ class SDatabaseDocController {
                 "FROM \"information_schema\".\"columns\" t) ct"
         return builder.exec()
         //return mapper.columnList(schema, table)
-    } // Function columnList()
+    }
 
 
     /**
-     *  查询表、字段信息
+     * 查询表、字段信息
+     *
+     * @param schema    字段
+     * @param table     表名
+     * @return
      */
     @Operation(summary="查询字段信息", description="")
     @RequestMapping(value = ["/table-info"], method = [RequestMethod.GET, RequestMethod.POST])
@@ -94,9 +98,6 @@ class SDatabaseDocController {
         sTable.tableName = table
         sTable.columnList = columnList(schema, table)
         return sTable
-    } // Function
-
-
-
+    }
 
-} // Class SDatabaseDocController
+}

persagy-service-mysql/src/main/kotlin/com/persagy/service/mysql/models/SColumn.kt

@@ -33,7 +33,7 @@ import javax.persistence.Table
 /**
  * 数据库设计-表结构
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "数据库设计-表结构")
 @Table(name = "information_schema.columns")
@@ -78,4 +78,4 @@ open class SColumn {
     @Column(name = "COLUMN_COMMENT")
     var description: String? = null
 
-} // Class SColumn
+}

persagy-service-mysql/src/main/kotlin/com/persagy/service/mysql/models/STable.kt

@@ -34,7 +34,7 @@ import javax.persistence.Table
 /**
  * 数据库设计-表结构
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "数据库设计-表结构")
 @Table(name = "information_schema.tables")
@@ -57,4 +57,4 @@ open class STable {
     @Schema(description = "字段列表")
     var columnList: ArrayList<SColumn>? = null
 
-} // Class STable
+}

persagy-service-postgresql/src/main/kotlin/com/persagy/service/postgresql/controllers/SDatabaseDocController.kt

@@ -38,7 +38,7 @@ import org.springframework.web.bind.annotation.*
 /**
  * 数据库设计接口
  *
- * @author  庞利祥(sybotan@126.com)
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Tag(name= "数据库设计接口")
 @Hidden
@@ -54,21 +54,21 @@ class SDatabaseDocController {
     /**
      * 查询表信息
      *
-     * @param   schema      模式
-     * @return  字段列表
+     * @param schema      模式
+     * @return 字段列表
      */
     @Operation(summary="查询表信息", description="")
     @RequestMapping(value = ["/table-list"], method = [RequestMethod.GET, RequestMethod.POST])
     fun tableList(schema: String): List<Any> {
         return tableService.select("schemaName" to schema).exec()
-    } // Function tableList()
+    }
 
     /**
      * 查询字段信息
      *
-     * @param   schema      模式
-     * @param   table       表名
-     * @return  字段列表
+     * @param schema      模式
+     * @param table       表名
+     * @return 字段列表
      */
     @Operation(summary="查询字段信息", description="")
     @RequestMapping(value = ["/column-list"], method = [RequestMethod.GET, RequestMethod.POST])
@@ -83,7 +83,7 @@ class SDatabaseDocController {
                 "FROM \"information_schema\".\"columns\" t) ct"
         return builder.exec()
         //return mapper.columnList(schema, table)
-    } // Function columnList()
+    }
 
     /**
      * 查询表、字段信息
@@ -96,8 +96,8 @@ class SDatabaseDocController {
         sTable.tableName = table
         sTable.columnList = columnList(schema,table)
         return sTable
-    } // Function tableInfo()
+    }
 
 
 
-} // Class SDatabaseDocController
+}

persagy-service-postgresql/src/main/kotlin/com/persagy/service/postgresql/models/SColumn.kt

@@ -33,7 +33,7 @@ import javax.persistence.Table
 /**
  * 数据库设计-表结构
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "数据库设计-表结构")
 @Table(name = "information_schema.columns")
@@ -78,4 +78,4 @@ open class SColumn {
     @Column(name = "description")
     var description: String? = null
 
-} // Class SColumn
+}

persagy-service-postgresql/src/main/kotlin/com/persagy/service/postgresql/models/STable.kt

@@ -33,7 +33,7 @@ import javax.persistence.Table
 /**
  * 数据库设计-表结构
  *
- * @author  庞利祥 <sybotan@126.com>
+ * @author 庞利祥 <sybotan@126.com>
  */
 @Schema(description = "数据库设计-表结构")
 @Table(name = "information_schema.tables")
@@ -57,4 +57,4 @@ open class STable {
     @Schema(description = "注释")
     var columnList : ArrayList<SColumn>? = null
 
-} // Class STable
+}