Merge branch 'develop' into 'master'

Develop See merge request doc/ldp-docs!11

Merge branch 'develop' into 'master'
Develop See merge request doc/ldp-docs!11
dd598b4c · 马超 · ebe23b7f · 1327dcbc · dd598b4c · dd598b4c
Commit dd598b4c authored Jul 19, 2021 by 马超
13 changed files
--- a/LDP框架ChangeLog&升级方式.md
+++ b/LDP框架ChangeLog&升级方式.md
@@ -20,6 +20,89 @@
 6. uaa资料库拷贝对应认证域的模板
+更多详情可参照升级说明文档：[LDP框架升级参考文档.md](安装文档/LDP框架升级参考文档.md)
+## 2021-07-19
+版本号： **1.2.47**
+**base-service**
+`Feat`：
+1. 新版自动填充注解、默认填充方法
+2. HqlWhereHelper支持多级条件查询
+3. storage接口部分实现下载功能、删除（minio）
+`fix`：
+1. 修复RestResult，mybatis-plus转换接口默认实现
+**mcs-service**
+`feat`：
+1. 修改字典page接口查询条件，添加typeCode参数
+`fix`：
+1. 修复菜单保存报错的问题
+**mcs-ui**
+`feat`：
+1. 重构模型设计页面
+2. 重构视图设计页面
+3. 新增`ldp-components`组件，用于在线预览设计的视图页面
+`fix`:
+1. 修改字典项编码只能输入数字、字母、下划线 校验规则。
+**gen-service**
+`feat`：
+1. 代码生成2.0
+2. 元数据从xml保存修改为DB保存
+3. 重构代码生成接口
+4. 重构生成代码模板（新增保存方法、保存单据方法)
+5. 默认添加swagger注解
+6. 支持mybatis版本和hibernate版本
+**bpm-service**
+版本：**1.0.24**
+`Fix`：
+1. 跳过时参与人设置为空
+### 本次更新方式
+1. 替换ldp-manage/fatjar 目录下对应的jar包
+2. 替换nginx中mcs、bpm的前端代码
+3. 脚手架更新到`1.2.47`
+- 下载gen-service配置文件：[gen-service配置文件](http://devdown.shxrtech.com/nacos_config_genservice_2021-07-15.zip)，并导入Nacos。
+  - 新建sinra-ldp-generator数据库，并在Nacos修改`gen-service-dev.yml`或`gen-service-prod.yml` 数据库连接配置及redis配置
+- 新版代码生成使用说明文档：[LDP代码生成功能操作说明v2.0.docx](操作文档/LDP代码生成功能操作说明v2.0.docx)
+- 新版hibernate自动填充文档：[LDP框架自定义注解.md](开发文档/LDP框架自定义注解.md) 第一章
 ## 2021-06-15

--- a/LDP集中式安装部署说明.md
+++ b/LDP集中式安装部署说明.md
@@ -219,6 +219,9 @@ DEPLOY_ENV=prod
 #### 新建数据库
 - 在mysql内创建ldp数据库: sinra_ldp_db ，字符集：utf8mb4
+- 在mysql内创建代码生成数据库: sinra_ldp_generator，字符集：utf8mb4（可选，不创建则代码生成服务无法使用）
+- 在mysql内创建流程系统数据库: sinra_bpm_db，字符集：utf8mb4（可选，不安装流程系统则可以不创建）
+- 在mysql内创建代码生成数据库: sinra_ldp_report，字符集：utf8mb4（可选，不使用报表服务则可以不创建）
 ####  nacos 启动 & 访问
@@ -268,6 +271,16 @@ cd nacos/bin
 * 修改后保存即可
+#### ***代码生成服务配置（1.2.45及以上版本）
+- 修改 gen-service-dev.yml或gen-service-prod.yml配置文件，包含**数据库配置、redis配置**
+  修改方式，和上述方式一致
+------
 ### 启动 ldp 服务
 ```shell
@@ -286,6 +299,13 @@ cd tool/
 ./ldp-boot.sh status
 ```
+PS：如果需要使用`报表服务`，则需要单独启动
+```shell
+# 启动报表服务
+./report-boot.sh start
+```
 也可以访问地址：http://nacos-server0:8018/nacos
 点击服务列表，即可看到以启动并注册的服务信息。如下图：
@@ -399,3 +419,8 @@ http://服务域名或ip:9080/mcs
 初始用户名：admin
 初始密码：1234561
+PS：如果需用部署流程系统，则参照[BPM安装部署文档.md](流程系统集成/BPM安装部署文档.md)
+		如果需要部署报表系统，则参照[报表系统安装部署文档.md](报表系统集成/报表系统安装部署文档.md)
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
 	2、[LDP-MCS新建一个管理员账号](操作文档/LDP-MCS新建一个管理员账号.md)
-    3、[LDP代码生成功能操作说明v1.3.docx](操作文档/LDP代码生成功能操作说明v1.3.docx)
+    3、[LDP代码生成功能操作说明v2.0.docx](操作文档/LDP代码生成功能操作说明v2.0.docx)
    4、[LDP中应用统一认证及权限配](操作文档/LDP中应用统一认证及权限配置.md)

--- a/imgs/UAA登录配置.png
+++ b/imgs/UAA登录配置.png
--- a/安装文档/LDP框架升级参考文档.md
+++ b/安装文档/LDP框架升级参考文档.md
+# LDP框架升级参考文档
+此文档为框架升级一份参考文档，根据情况判断升级时需要做哪些操作。
+## 一、升级前准备工作
+升级前，请先打开chanlog文档：[LDP框架ChangeLog&升级方式.md](../LDP框架ChangeLog&升级方式.md)
+### 1.1、关闭服务
+```shell
+# 关闭主要的服务
+./ldp-boot.sh stop
+# 关闭bpm服务
+./bpm-boot.sh stop
+# 关闭报表服务
+./report-boot.sh stop
+```
+### 1.2、 备份DB
+虽然一般升级不会对已有的数据造成影响，但是建议先备份一份数据。
+### 1.2、 UAA资源库备份（登录界面有自定义变更）
+查看changelog文档，检查UAA是否有变更，如果有，则需要先备份UAA资源库，然后删除掉UAA资源库
+```shell
+# 创建uaa字员文件备份文件夹
+mkdir -p bak/uaaui
+# 备份uaaui自定义变更
+cp -r ~/.ldp/uaaui/* bak/uaaui
+# 删除资源库中的文件
+rm -rf ~/.ldp/uaaui
+```
+ 等新版UAA重新启动后，再根据变更进行修改或者直接拷贝回去。
+### 1.3、备份jar包
+将老版本jar包进行备份，新版升级失败可以紧急回滚，如果新版正常运行一段时间后，可以删除掉备份文件
+```shell
+# 创建fatjar备份文件夹
+mkdir -p bak/fatjar
+# 备份fatjar
+mv ldp-manage/fatjar/* bak/fatjar/
+```
+## 二、升级
+### 2.1、解压新版tar包
+解压新版tar的方式可以有很多，这里建议新建一个当前日期的目录文件夹，方便和旧版本的做区分，也方便拷贝文件
+```shell
+# 创建新版目录与之前的ldp-manage目录平级
+mkdir ldp-20210716
+# 将新版tar包移到刚才新建的目录下，这里的版本号不一定一致
+mv ldp-manage-1.2.46.tar.gz ldp-20210716
+# 切到新版目录下，并执行解压
+cd ldp-20210716
+tar -zxvf ldp-manage-1.2.46.tar.gz
+```
+### 2.2、将新版jar包拷贝到fatjar目录
+```shell
+# 当前目录在ldp-20210716下,
+cp ldp-manage/fatjar/* ../ldp-mange/fatjar
+```
+### 2.3、拷贝新版ui文件到nginx/html目录下
+```shell
+# 拷贝mcs前端
+cp -r ldp-manage/ui/mcs /usr/share/nginx/html
+```
+### 2.3、新增、修改配置文件
+查看changelog文档，在`本次更新方式`中，是否有配置文件的变更，如果有则打开NACOS按照描述添加及修改配置文件。
+### 2.4、拷贝启动脚本到tool目录（启动脚本有变更、新服务启动脚本）
+```shell
+cp ldp-manage/tool/* ../ldp-manage/tool/
+```
+### 2.5、启动新版服务
+```shell
+# 切到tool目录下
+cd ../ldp-manage/tool
+# 启动服务
+./ldp-boot.sh start
+```
+### 2.6、测试
+服务启动成功后，打开mcs地址验证是否OK。
+**PS：BPM升级方式和上面类似，这里就不展开叙述**
--- a/开发文档/Example样例工程开发文档.md
+++ b/开发文档/Example样例工程开发文档.md
@@ -378,6 +378,8 @@ UUID：生成32位随机字符串。
 PINYIN：将ref字段的拼音填充到此字段中。
+**PS：旧版自动填充在1.2.45版本废弃，新版请查看文档[LDP框架自定义注解.md](LDP框架自定义注解.md)**
 ```java
 // AutoService注解在新增时会对实体类中配置了@AutoComputed字段根据规则进行填充
    @Override

--- a/开发文档/Hibernate条件查询工具类使用.md
+++ b/开发文档/Hibernate条件查询工具类使用.md
@@ -414,6 +414,34 @@ HqlWhereHelper conditions = HqlWhereHelper.getInstance()
                .and("a.name", "浦东新区");
 ```
+#### 多级级联的样例
+员工实体中有组织关联属性org，组织实体中有职位关联属性positions，下面样例则是通过职位过滤员工信息
+```java
+// 不指定class 
+LinkedList<Condition> conditions = HqlWhereHelper.getInstance()
+                .join("org", "org")
+                .join("org.positions", "post")
+                .and("post.id", "bd5b28b7ccd74ba28708c95db54230f0")
+                .buildConditions();
+List list = genericDaoService.findByConditions(LdpMcsEmployeeInfo.class, conditions);
+```
+另外一种写法需要指定class，这两种写法查询结果一致
+```java
+// 指定class
+LinkedList<Condition> conditions = HqlWhereHelper.getInstance()
+    .join("org", LdpMcsOrganization.class,"org")
+    .join("org.positions", LdpMcsPosition.class,"position")
+    .and("position.id", "bd5b28b7ccd74ba28708c95db54230f0")
+    .buildConditions();
+List list = genericDaoService.findByConditions(LdpMcsEmployeeInfo.class, conditions);
+```

--- a/开发文档/LDP Mybatis-Plus脚手架使用.md
+++ b/开发文档/LDP Mybatis-Plus脚手架使用.md
@@ -135,13 +135,20 @@ LDP IEDA代码生成插件使用文档：[LDP代码生成IDEA插件安装和使
 默认生成代码接口方法：
 ```java
-/**
+	/**
     * 新增地区
     *
     * @param area
     */
    public String add(LdpArea area);
+    /**
+    * 保存地区
+    *
+    * @param ldpArea
+    */
+    public boolean saveEntity(LdpArea ldpArea);
    /**
     * 批量新增地区
     *
@@ -233,6 +240,16 @@ LDP IEDA代码生成插件使用文档：[LDP代码生成IDEA插件安装和使
     * @return
     */
    public Page<LdpArea> findPage(Page paramPage, LdpArea area);
+	/**
+    * 将新数据集合与通过外键查询出的数据库数据集合进行差异化处理
+    *
+    * @param fpkFieldName  属性名
+    * @param fpkColumnName 表字段名
+    * @param fpkValue      外键值
+    * @param newList       新数据集合
+    */
+    void saveOrDeleteByCollection(String fpkFieldName, String fpkColumnName, Object fpkValue, Collection<LdpArea> newList);
 ```
 ## 五、增删改查样例
@@ -278,7 +295,7 @@ page(page);
    public List<LdpArea> ldpAreas;
 ```
-关联查询，在mapper.xml中先声明一个resultMap，再写查询语句，返回指定为对应的resultMap，由于这里是一堆多，所以使用`collection`作为关联填充，如果是一对一，则使用`association`
+关联查询，在mapper.xml中先声明一个resultMap，再写查询语句，返回指定为对应的resultMap，由于这里是一对多，所以使用`collection`作为关联填充，如果是一对一，则使用`association`
 ```xml
 <resultMap id="BaseResultMapToOne" type="com.sinra.ldp.example.entity.LdpCity">

--- a/开发文档/LDP框架自定义注解.md
+++ b/开发文档/LDP框架自定义注解.md
@@ -4,632 +4,439 @@
 ## 一、自动填充注解
-### 1.1. @AutoComputed
+### 1.1. @AutoFilled（1.2.45及以上）
-依赖：base-api。
+依赖：base-api
 #### 1.1.1 注解介绍
-**@AutoComputed**是一个字段注解，标识**实体类**字段为自动填充的注解，需要配合服务层的 **@AutoService** 使用，拥有四个属性，command、ref、refs、format。注解可以通过command标识字段自动装配的方式，根据字段名查找对应计算方法，或根据command类型查找对应系统计算方法。command默认值为 **ComputedCommand.AUTO** ，以下是内置command每个值的解释：
+**@AutoComputed**是一个字段注解，标识**实体类**字段为自动填充的注解，拥有三个属性，value、strategy、scope。
-**AUTO**：根据字段名进行填充。
-**MD5**：将字段值进行一次md5加密。
+**strategy**：`FillStrategy.BEAN_NAME`、`FillStrategy.CLASS_NAME` strategy标识value填充实现是bean还是带包名的类名。默认值是`FillStrategy.BEAN_NAME`。
-**DATETIME**：当前时间。
+**scope**：`FillScope.INSERT`、`FillScope.UPDATE`、`FillScope.INSERT_UPDATE` 标识什么时候执行填充，INSERT插入时填充、UPDATE更新时填充，INSERT_UPDATE插入及更新时都会填充。默认值是`FillScope.INSERT`。
-**USERID**：当前登录用户。
+**value**：自动填充实现值，当strategy是`FillStrategy.BEAN_NAME`时，则获取bean实现，如果是`FillStrategy.CLASS_NAME`则通过反射获取实现。有几个默认实现如下：
-**UUID**：生成32位随机字符串。
+| 默认填充                          | 填充值             | 替换方式                                                     |
+| --------------------------------- | ------------------ | ------------------------------------------------------------ |
+| DefaultFillType.FILL_DATE         | 填充当前时间       | 实现AutoFillHandler接口，并注册Bean，Bean名称为DefaultFillType.FILL_DATE |
+| DefaultFillType.FILL_USER_ACCOUNT | 填充用户账号       | 实现AutoFillHandler接口，并注册Bean，Bean名称为DefaultFillType.FILL_USER_ACCOUNT |
+| DefaultFillType.FILL_USER_ID      | 填充用户ID         | 实现AutoFillHandler接口，并注册Bean，Bean名称为DefaultFillType.FILL_USER_ID |
+| DefaultFillType.FILL_MD5          | 填充原字段md5值    | 实现AutoFillHandler接口，并注册Bean，Bean名称为DefaultFillType.FILL_MD5 |
+| DefaultFillType.FILL_PINYIN       | 填充原字段pinyin值 | 实现AutoFillHandler接口，并注册Bean，Bean名称为DefaultFillType.FILL_PINYIN |
+| DefaultFillType.FILL_VERSION      | 填充version值      | 实现AutoFillHandler接口，并注册Bean，Bean名称为DefaultFillType.FILL_VERSION |
-**PINYIN**：将ref字段的拼音填充到此字段中
+默认实现需要依赖`common-autofilled`包
-**REFERENCE**：将refs字段的值通过format规则填充到此字段
+```xml
+        <dependency>
+            <groupId>com.sinra.ldp</groupId>
+            <artifactId>common-autofilled</artifactId>
+            <version>${ldp.version}</version>
+        </dependency>
+```
 #### 1.1.2 使用案例
 ```java
-// 值为AUTO，通过属性名查找计算方式，这里的计算方式就是createId
+    /**
-@AutoComputed
+    * 创建人，scope为INSERT，新增时填充，填充值为用户account
-private String createId;
+    */
+    @ApiModelProperty(value = "创建人")
+    @Column(name = "create_id")
+    @AutoFilled(scope = FillScope.INSERT, value = DefaultFillType.FILL_USER_ACCOUNT)
+    private String createId;
-// 值为MD5，将原本的明文做一次md5加密并重新赋值到字段中
+    /**
-@AutoComputed(command = ComputedCommand.MD5)
+    * 创建时间，scope为INSERT，新增时填充，填充值为当前时间
-private String userPassword;
+    */
+    @ApiModelProperty(value = "创建时间")
+    @Column(name = "create_time")
+    @AutoFilled(scope = FillScope.INSERT, value = DefaultFillType.FILL_DATE)
+    private Date createTime;
-// 值为DATETIME，将当前时间填充到字段中
+    /**
-@AutoComputed(command = ComputedCommand.DATETIME)
+    * 更新人，scope为INSERT_UPDATE，新增和更新都会填充，填充值为用户account
-private Date createTime;
+    */
+    @ApiModelProperty(value = "更新人")
+    @Column(name = "update_id")
+    @AutoFilled(scope = FillScope.INSERT_UPDATE, value = DefaultFillType.FILL_USER_ACCOUNT)
+    private String updateId;
-// 值为USERID，将当前登录用户ID填充到字段中
+    /**
-@AutoComputed(command = ComputedCommand.USERID)
+    * 更新时间，scope为INSERT_UPDATE，新增和更新都会填充，填充值为当前时间
-private String updateId;
+    */
+    @ApiModelProperty(value = "更新时间")
+    @Column(name = "update_time")
+    @AutoFilled(scope = FillScope.INSERT_UPDATE, value = DefaultFillType.FILL_DATE)
+    private Date updateTime;
+```
-// 值为UUID，将随机生成的UUID填充到字段中
+#### 1.1.3 扩展填充算法
-@AutoComputed(command = ComputedCommand.UUID)
-private String uuId;
-// 值为PINYIN，ref为userName，将userName字段的中文拼音自动填充到字段中
+扩展填充算法的方式，新建一个类，并实现AutoFillHandler，根据业务判断需要 填充的值，这里举例，例如需要填充一个随机数，新建一个RandomFillHandler类，实现AutoFillHandler接口，并填入返回值的泛型，这里是一个整形随机数，所以填入整形的包装类Integer：
-@AutoComputed(command = ComputedCommand.PINYIN, ref = "userName")
-private String sortName;
-// 值为REFERENCE,refs是一个数组, 将数组中的字段值按照format的规则填充到字段中
+```java
-@AutoComputed(command = ComputedCommand.REFERENCE, refs = {"name", "age", "gender"}, format = "%s-%s-%s")
+/**
-private String referenceValue;
+ * 随机数填充实现
+ */
+public class RandomFillHandler implements AutoFillHandler<Integer> {
+    /**
+    * 自动填充方法
+    * 部分自动填充需要使用实体的其它字段值或者当前字段值，例如MD5填充，需要先获取到当前字段值，再进行md5编码。
+    *
+    * entity		为当前实体
+    * currentValue  为注解字段值
+    */
+    @Override
+    public Integer getFillValue(Object entity, Object currentValue) {
+        // 返回随机数
+        return new Random().nextInt();
+    }
+}
 ```
-#### 1.1.3 自定义填充算法
+这样一个自动填充算法就是实现了，下面写如何使用。
-当command值为 **ComputedCommand.AUTO** 时，会通过字段名查找计算方式，这里介绍一下如何自定义填充算法。自动填充算法分为三种：
- 第一种是有参算法，例如MD5算法需要使用到原字段中的值作为参数：
+指定策略为CLASS_NAME，value值为带全包名的实现类。
 ```java
-// 值为MD5，将原本的明文做一次md5加密并重新赋值到字段中
+    // 执行插入时自动填充
-@AutoComputed(command = ComputedCommand.MD5)
+	@AutoFilled(strategy = FillStrategy.CLASS_NAME, scope = FillScope.INSERT, value = "com.sinra.ldp.demo.RandomFillHandler")
-private String userPassword;
+    private int randomNum;
 ```
-需要实现 **ComputerArgs** 接口，将自动填充算法写到computed中。例如Md5填充算法代码如下：
+**另一种写法**则是先注册为bean，再使用
 ```java
-public class ComputerMd5 implements ComputerArgs {
+	// 注册bean
-    @Override
+	@Bean("fill_random")
-    public String computed(Object plain) {
+    public AutoFillHandler randomFillHandler() {
-        //这里进行处理，并返回自动填充内容
+        return new RandomFillHandler();
-        return DigestUtils.md5Hex(plain.toString());
    }
-}
 ```
- 第二种也是有参算法，主要是为了按照format进行自动填充，例如：
+使用时，在实体类字段标记：
 ```java
-// 值为REFERENCE,refs是一个数组, 将数组中的字段值按照format的规则填充到字段中
+	// 执行插入时自动填充
-@AutoComputed(command = ComputedCommand.REFERENCE, refs = {"name", "age", "gender"}, format = "%s-%s-%s")
+	@AutoFilled(scope = FillScope.INSERT, value = "fill_random")
-private String referenceValue;
+    private int randomNum;
 ```
-需要实现 **ComputerFormatArgs** 接口，将自动填充算法写到computed中。例如REFERENCE填充算法如下：
+## 二 、缓存注解
+### 2.1. @ApplicationCacheable
+依赖：common-cache
+#### 2.1.1 注解介绍
+ **@ApplicationCacheable** 注解是方法注解，将注解添加到方法上，会自动将方法结果缓存下来，之后再次调用此接口，会直接从缓存中获取结果。缓存key是自动生成的，生成算法为application:+包名+类名+方法名+:参数长度。其它属性字段与Spring cache 注解 **@Cacheable** 属性字段一致。
+#### 2.1.2 使用案例
+一般此注解在REST层使用，需要注意的是Application缓存不会过期，会一直存在，如果需要刷新，需要另外写刷新方法，建议在数据变化较小，数据量大的接口使用。
 ```java
-public class ComputerReference implements ComputerFormatArgs {
+/**
-    @Override
+* rest获取用户分页数据
-    public String computed(Object target, String format) {
+*
-        String result = "";
+* @return
- 		//核心代码如下，如果format为空则默认以下划线拼接，否则按fromat格式化
+*/
-        if (StringUtils.isEmpty(format)) {
+@GetMapping("/rest/page")
-            result = StringUtils.joinWith("_", objects);
+@ApplicationCacheable
-        } else {
+public RestResult getListByRest() {
-            result = String.format(format, objects);
+    return new RestResult(ResultMsg.SUCCESS, exampleService.getUserListByRest());
-        }
-        return result;
-    }
 }
 ```
- 第三种是无参算法，例如DATETIME算法就是一个无参算法，只需要获取当前时间：
+### 2.2. @SessionCacheable
-```java
+依赖：common-cache
-// 值为DATETIME，将当前时间填充到字段中
-@AutoComputed(command = ComputedCommand.DATETIME)
-private Date createTime;
-```
-无参算法与有参类似，只是没有参数，需要实现 **ComputerNoArgs** 接口
+#### 2.2.1 注解介绍
+ **@SessionCacheable** 注解是方法注解，用法与 **@ApplicationCacheable** 注解基本一致，不一致的地方有两点：1、SessionCache生命周期是跟随登录的，也就是退出登录后失效； 2、缓存key生成规则不一致，生成算法：token:+包名+类名+方法名+:参数长度。
+#### 2.2.2 使用案例
+退出登录后，Session缓存失效
 ```java
-public class ComputerDate implements ComputerNoArgs<Date> {
+/**
-    @Override
+* jdbc 获取用户list
-    public Date computed() {
+*
-        return new Date();
+* @param paramMap
-    }
+* @return
+* @throws Exception
+*/
+@GetMapping("/jdbc/list")
+@SessionCacheable
+public RestResult getListByJdbc(@RequestParamMap(typeCovertMapping = ExampleUserInfo.class) Map<String, Object> paramMap) throws Exception {
+    List<ExampleUserInfo> userInfoList = exampleService.getUserListByJDBC(StringUtils.EMPTY, paramMap);
+    return new RestResult(ResultMsg.SUCCESS, userInfoList);
 }
 ```
- 完成算法编写后，还需要将计算类与字段名对应起来。
+## 三、日志注解
-在service包中新建computed包（推荐），新建一个类，加上 **@Configuration** 注解，在 **@Bean** 注解中的name属性填上字段名。例如字段createId的填充算法是一个无参算法，方法返回类型为 **ComputerNoArgs** ，如果为有参算法，则应该返回 **ComputerArgs** 或者 **ComputerFormatArgs**。
+### 3.1. @AvoidRepeatableSubmit
-```java
+#### 3.1.1 注解介绍
-@Configuration
-public class ComputedResolver {
-    @Bean(name = "createId")
+此注解配合定时任务进行使用，在被需要定时任务调用的服务接口上，添加此注解防止接口由于网络波动或其他原因重复调用。
-    public ComputerNoArgs getCreateId() {
-        return new ComputerUser();
+#### 3.2.2 使用案例
+```java 
+    @PostMapping(value = "/testExampleJob")
+    @AvoidRepeatableSubmit
+    public RestResult testJob(@RequestParam String taskJobId, @RequestBody ExampleUserInfo userInfo){
+        exampleService.add(userInfo);
+        return new RestResult(ResultMsg.SUCCESS,"");
    }
-}
 ```
+**使用时仅需要在被定时任务调用的接口上添加@AvoidRepeatableSubmit即可**
-当AOP在处理自动填充时，这个字段就会根据上面编辑的算法进行自动填充。
+### 3.2. @SysAuditLog
-### 1.2. @AutoService
-依赖：mcs-common
+#### 3.2.1 注解介绍
+@SysAuditLog 是一个方法注解，需要放在controller方法上。 会拦截包裹的方法，会根据登陆信息自动获取当前用户。此注解进行被请求方法拦截，获取请求地址、请求参数、请求内容、请求方法（GET OR POST）、客户端浏览器信息。
+ 根据请求状态，判断是异常请求还是正常请求。
-#### 1.2.1 注解介绍
+#### 3.2.2 使用案例
-**@AutoService**是一个方法注解，被 **@AutoService** 注解的方法，都会被AOP拦截，并根据实体类字段中的 **@AutoComputed** 规则对字段自动填充。拥有两个属性 mode、init，mode为填充方式，默认为     **ComputedMode.COMPUTED** ，init为是否初始化，初始化则全部填充，否则只填充updateId、updateTime、sortName。
+```java 
+    /**
+     * 用户列表（非分页）
+     *
+     * @param paramMap 字段条件
+     * @return
+     */
+    @GetMapping("/get/list")
+    @SysAuditLog(moduleKey = "example",subKey = "test")
+    public RestResult findList(@RequestParamMap(typeCovertMapping = ExampleUserInfo.class) Map<String, Object> paramMap) throws Exception {
+        List<ExampleUserInfo> userInfoList = exampleService.findList(paramMap);
+        return new RestResult(ResultMsg.SUCCESS, userInfoList);
+    }
+```
-默认取方法的第一个参数进行填充，支持单个实体，也支持List集合。
+  **使用时需传递  moduleKey(模块名称,如果是新模块需提前建立表，以ldp_audit_log_  开头+ modulekey 录入的值结尾的表 如ldp_audit_log_example , 表结构可参考 ldp_audit_log_sys), subKey 子模块名称最终会保存在日志中作为二级子模块**;
-#### 1.2.2 使用案例
+### 3.3. @SysJobLog
-一般@AutoService用于新增方法，以及更新方法
+#### 3.3.1 注解介绍
-```java
+由于系统架构为微服务，服务与服务之间解耦合。因此定时任务设计之初，考虑为定时接口任务调用。  
-// 新增方法
+定时任务执行接口调用， 在被调用接口引用的Service具体业务方法添加此@SysJobLog 注解。 
-@AutoService
+注解包含两大功能，1 异步执行，防止接口执行时间过长，否则定时任务调用机器一直连接被占用； 2 更新定时任务执行情况。 
-public void add(LdpMcsElementInfo elementInfo) {
+定时任务执行流程：
-    genericDaoService.insert(elementInfo);
+   1 定时任务调度服务启动后，满足定时条件自动执行任务调度。 根据后台配置好的服务名称、接口信息调用其他服务接口。
-}
+   2 被调用接口，必须添加@RequestParam String taskJobId 作为接收参数，此参数后续作为更新任务执行状态使用。由于在业务方法上添加@SysJobLog， 业务方法与Controller不在同一个线程中，无法
+   获取上一个线程中的信息。因此具体业务Service也必须添加名称为String taskJobId 的参数，后续会自动获取参数的值进行更新任务执行情况。
+   3 被调用接口也必须添加 @AvoidRepeatableSubmit 防止重复执行
-// 更新方法
-@AutoService(init = false)
-public void update(LdpMcsElementInfo elementInfo) {
-    genericDaoService.dynamicUpdate(elementInfo);
-}
-```
-### 1.3. @AutoRelativeComputed
-依赖：mcs-common
-#### 1.3.1 注解介绍
+#### 3.3.2 使用案例
-**@AutoRelativeComputed** 是一个方法注解，对使用JPA配置了关联关系实体类进行自动填充，主要作用于Service层，对新增关联和移除关联方法参数进行自动填充。
-@AutoRelativeComputed字段详解：
+Controller 
-**mode**：关联类型，目前支持RelativeMode.MTM（多对多）、RelativeMode.OTM（一对多）、RelativeMode.MTO（多对一）。**PS：一对多、多对一暂时不建议使用**
+```java
-**inverse**：是否为逆向，false为单向绑定，true为双向绑定，默认为false。
+    @PostMapping(value = "/testExampleJob")
+    @AvoidRepeatableSubmit
+    public RestResult testJob(@RequestBody ExampleUserInfo userInfo, @RequestParam String taskJobId){
+	        exampleService.doJob (userInfo, taskJobId);
+        return new RestResult(ResultMsg.SUCCESS,"");
+    }
+```
-**source**：参数源类型。
+具体Service
-**target**：参数目标类型。
+```java
-**joinField**：关联字段。
+    @Override
+    @AutoService
+    @SysJobLog
+    public void doJob(ExampleUserInfo exampleUserInfo, String taskJobId) {
+        genericDaoService.insert(exampleUserInfo);
+    }
+```
-**inverseField**：逆向关联字段。
+**具体业务方法上添加@SysJobLog 进行异步任务及String taskJobId 参数，名称需要保持一致，系统会自动进行更新执行状态**``
-**exComputed**：扩展的填充字段。
+## 四、数据库查询注解
-#### 1.3.2 使用案例
+### 4.1. @QueryBind
-##### 1). 多对多关系
+依赖：common-query
-这里举例为用户和角色的多对多关系。
+#### 4.1.1 注解介绍
-用户表（user）：
+@QueryBind是一个方法注解，将 **xxxxservice-query.xml** 中的参数SQL语句绑定到方法中的第一个参数中。需要先在 **xxxxservice-query.xml** 中将ref属性指向绑定的xxxServiceImpl类中。
-| 字段名称  | 类型   | 备注             |
+#### 4.1.2 使用案例
-| --------- | ------ | ---------------- |
-| id        | String | 用户ID，唯一标识 |
-| user_name | String | 用户名           |
-角色表（role）：
+**Service层代码：**
-| 字段名称  | 类型   | 备注             |
+```java
-| --------- | ------ | ---------------- |
+/**
-| id        | String | 角色ID，唯一标识 |
+* jdbc查询， QueryBind所对应的sql语句在resource/query/exampleservice中
-| role_name | String | 角色名称         |
+* 调用时 getUserListByJDBC(StringUtils.EMPTY); 注解会将sql语句自动注入到参数中
+*
-用户角色关联表（user_role）：
+* @param sql
+* @return
-| 字段名称 | 类型   | 备注         |
+*/
-| -------- | ------ | ------------ |
+@QueryBind("examplelist")
-| id       | String | ID，唯一标识 |
+@Override
-| user_id  | String | 用户ID       |
+public List<ExampleUserInfo> getUserListByJDBC(String sql, Map<String, Object> param) {
-| role_id  | String | 角色ID       |
+    List<ExampleUserInfo> exampleUserInfos = jdbcDaoService.queryForList(sql, ExampleUserInfo.class, param);
+    return exampleUserInfos;
+}
+```
-1. 使用JPA配置实体类关联关系
+**REST层代码：**调用时 **getUserListByJDBC(StringUtils.EMPTY)**; 注解会将sql语句自动注入到参数中
-   **User.java**
+```java
+Map<String, Object> param = new HashMap<>(1);
-   ```java
+param.put("userType", 0);
-   /**
+List<ExampleUserInfo> exampleUserInfos = exampleService.getUserListByJDBC(StringUtils.EMPTY, param);
-   * 与角色的多对多关联
+```
-   */
-   @JsonIgnoreProperties("userInfos")//避免互相关联死循环
-   @ManyToMany(fetch = FetchType.EAGER)
-   @JoinTable(name = "user_role", //中间表的名称
-              joinColumns = {@JoinColumn(name = "user_id", referencedColumnName = "id")},
-              inverseJoinColumns = {@JoinColumn(name = "role_id", referencedColumnName = "id")})
-   private Set<Role> roleInfos = new HashSet<>();
-   ```
-   **Role.java**
-   ```java
-   @JsonIgnoreProperties("roleInfos")
-   @ManyToMany(mappedBy = "roleInfos", fetch = FetchType.EAGER, targetEntity = User.class)
-   private Set<User> userInfos = new HashSet<>(0);
-   ```
-2. 在**UserServiceImpl**中添加方法和注解
-   ```java
+### 4.2. @QueryContextComponent与 @QueryParams
-   /**
-   * 添加角色关联
-   *
-   * @param id    用户ID
-   * @param list  通过注解将List<Role>转换为List<UserRole>
-   * @param param 作为删除条件，避免重复数据
-   */
-   @AutoRelativeComputed(mode = RelativeMode.MTM, source = Role.class, target = UserRole.class, joinField = "userId", inverseField = "roleId")
-   public void addRoleToUser(String id, List list, Map<String, Object> param) {
-       LinkedList<TranscationEntity> entityList = new LinkedList<>();
-       // 删除重复数据
-       entityList.add(new TranscationEntity(TransItemExeType.DELETE_ENTITY, UserRole.class, param));
-       // 新增
-       entityList.add(new TranscationEntity(TransItemExeType.INSERT_ENTITY, list));
-       genericDaoService.executeTrans(entityList);
-   }
+依赖：common-query
-   /**
-   * 移除角色关联
-   *
-   * @param id    用户ID
-   * @param list  通过注解将List<Role>转换为List<UserRole>
-   * @param param 作为删除条件，避免重复数据
-   */
-   @AutoRelativeComputed(mode = RelativeMode.MTM, source = Role.class, target = UserRole.class,joinField = "userId", inverseField = "roleId")
-   public void removeRoleFromUser(String id, List list, Map<String, Object> param) {
-       genericDaoService.deleteList(UserRole.class, param);
-   }
-   ```
-#### 1.3.3 扩展填充算法
+#### 4.2.1 注解介绍
- **@AutoRelativeComputed** 注解主要填充中间关联数据，有部分数据和关联无关，但是又必须填充，这种时候就需要 **exComputed** 来扩展填充算法，可以通过算法来填充其它字段。例如，岗位和组织多对多关联自动填充， exComputed字段值为**orgPosition** ：
+**@QueryContextComponent**是一个类注解， **@QueryParams** 是一个方法注解。除了使用 **@QueryBind** 注解注入sql到参数中，还可以使用 **@QueryContextComponent** 结合 **@QueryParams** 注解将xml中的sql全部注入到一个Map对象中。
-```java
+#### 4.2.2 使用案例
-@AutoRelativeComputed(mode = RelativeMode.MTM, source = LdpMcsOrganization.class, target = LdpMcsPositionOrganization.class,joinField = "postId", inverseField = "orgId", exComputed = "orgPosition")
-```
-编写扩展算法需要实现 **CustomComputer** 接口，并在computed方法中编写自动填充逻辑。computed方法有一个参数，这个参数是注解中target类的对象，可以在方法中拿到对象，并对对象中的其它字段进行填充。这里对manager字段进行填充：
+首先在类名上添加 **@QueryContextComponent** 注解，定义一个sqlMap字段，加上 **@QueryParams** 注解，由于 **@QueryParams** 是一个方法注解，所以需要在字段上加上 **@Setter** ，这样会自动生成set方法，注解也会添加到自动生成的方法上
 ```java
-public class ComputerOrgPosition implements CustomComputer {
+@QueryContextComponent
-    @Override
+public class UserBizService   {
-    public void computed(Object target) {
-        LdpMcsPositionOrganization positionOrganization = (LdpMcsPositionOrganization) target;
-        positionOrganization.setManager(false);
-    }
-}
-```
-在有 **@Configuration** 注解类中完成Bean的装配：
-```java
+    // 由于@QueryParams是一个方法注解，所以此处需要加上@Setter注解
-@Configuration
+    @Setter
-public class ExtraComputer {
+    @QueryParams
-    /**
+    public Map<String,String> sqlMap;
-     * 关联表其它业务数据填充
-     *
+    public void getSqlKey() {
-     * @return
+        sqlMap.forEach((k,v)->{
-     */
+            log.info("id:{} {} {} ",k,String.format("%n"),v);
-    @Bean(name = "orgPosition")
+        });
-    public CustomComputer getUserPositionComputer() {
-        return new ComputerOrgPosition();
    }
 }
 ```
-## 二 、缓存注解
+## 五、REST层参数解析注解
-### 2.1. @ApplicationCacheable
+### 5.1. @RequestParamMap
-依赖：common-cache
+依赖：mcs-common
-#### 2.1.1 注解介绍
+#### 5.1.1 注解介绍
- **@ApplicationCacheable** 注解是方法注解，将注解添加到方法上，会自动将方法结果缓存下来，之后再次调用此接口，会直接从缓存中获取结果。缓存key是自动生成的，生成算法为application:+包名+类名+方法名+:参数长度。其它属性字段与Spring cache 注解 **@Cacheable** 属性字段一致。
+**@RequestParamMap**是一个参数注解，主要用于在REST层接收GET参数时保持参数类型与实体类一致，可以直接将GET参数接收到的map作为查询条件，另外也是为了将分页参数从查询参数中区分开来。
-#### 2.1.2 使用案例
+#### 5.1.2 使用案例
-一般此注解在REST层使用，需要注意的是Application缓存不会过期，会一直存在，如果需要刷新，需要另外写刷新方法，建议在数据变化较小，数据量大的接口使用。
+直接在Map参数前使用**@RequestParamMap(typeCovertMapping = XXXX.class)**，这里的XXX指实体类类型。
 ```java
 /**
-* rest获取用户分页数据
+* 用户列表（非分页）
 *
+* @param paramMap 字段条件
 * @return
 */
-@GetMapping("/rest/page")
+@GetMapping("/get/list")
-@ApplicationCacheable
+public List<LdpMcsUserInfo> findList(@RequestParamMap(typeCovertMapping = LdpMcsUserInfo.class) Map<String, Object> paramMap) throws Exception {
-public RestResult getListByRest() {
+    return userService.findList(paramMap);
-    return new RestResult(ResultMsg.SUCCESS, exampleService.getUserListByRest());
 }
 ```
-### 2.2. @SessionCacheable
+### 5.2 @RequestParamPage
-依赖：common-cache
+依赖：mcs-common
-#### 2.2.1 注解介绍
+#### 5.2.1 注解介绍
- **@SessionCacheable** 注解是方法注解，用法与 **@ApplicationCacheable** 注解基本一致，不一致的地方有两点：1、SessionCache生命周期是跟随登录的，也就是退出登录后失效； 2、缓存key生成规则不一致，生成算法：token:+包名+类名+方法名+:参数长度。
+**@RequestParamPage**是一个参数注解，主要用于GET请求时接收分页参数。
-#### 2.2.2 使用案例
+#### 5.2.2 使用案例
-退出登录后，Session缓存失效
+使用封装好的分页类 **Pagination** 来接收分页参数，在分页参数前添加 **@RequestParamPage** 即可。这里是将分页参数和查询参数进行拆分的案例：
 ```java
 /**
-* jdbc 获取用户list
+* 用户列表(分页)
 *
-* @param paramMap
+* @param paramPage 分页参数为pageIndex,pageSize
+* @param paramMap  字段条件
 * @return
-* @throws Exception
 */
-@GetMapping("/jdbc/list")
+@GetMapping("/get/page")
-@SessionCacheable
+public Pagination findPage(@RequestParamPage Pagination paramPage,
-public RestResult getListByJdbc(@RequestParamMap(typeCovertMapping = ExampleUserInfo.class) Map<String, Object> paramMap) throws Exception {
+                           @RequestParamMap(typeCovertMapping = LdpMcsUserInfo.class) Map<String, Object> paramMap)
-    List<ExampleUserInfo> userInfoList = exampleService.getUserListByJDBC(StringUtils.EMPTY, paramMap);
+    throws Exception {
-    return new RestResult(ResultMsg.SUCCESS, userInfoList);
+    return userService.findPage(paramPage, paramMap);
 }
 ```
-## 三、日志注解
+## 六、Excel导入导出注解
-### 3.1. @AvoidRepeatableSubmit
-#### 3.1.1 注解介绍
+### 6.1. @ExcelImport
-此注解配合定时任务进行使用，在被需要定时任务调用的服务接口上，添加此注解防止接口由于网络波动或其他原因重复调用。
+依赖：common-biz-annotation
-#### 3.2.2 使用案例
+#### 6.1.1 注解介绍
-```java 
-    @PostMapping(value = "/testExampleJob")
-    @AvoidRepeatableSubmit
-    public RestResult testJob(@RequestParam String taskJobId, @RequestBody ExampleUserInfo userInfo){
-        exampleService.add(userInfo);
-        return new RestResult(ResultMsg.SUCCESS,"");
-    }
-```
-**使用时仅需要在被定时任务调用的接口上添加@AvoidRepeatableSubmit即可**
-### 3.2. @SysAuditLog
+**@ExcelImport** 是一个方法注解，主要用于实现Excel导入逻辑。
-#### 3.2.1 注解介绍
+#### 6.1.2 使用案例
-@SysAuditLog 是一个方法注解，需要放在controller方法上。 会拦截包裹的方法，会根据登陆信息自动获取当前用户。此注解进行被请求方法拦截，获取请求地址、请求参数、请求内容、请求方法（GET OR POST）、客户端浏览器信息。
- 根据请求状态，判断是异常请求还是正常请求。
-#### 3.2.2 使用案例
+将注解直接加到导入方法上，会自动构建ExcelOptions参数。
-```java 
+```java
+ /**
-    /**
+  * 通过注解导入Excel，注解完成三件事情：
-     * 用户列表（非分页）
+  * 1、上传文件
-     *
+  * 2、读取Excel数据
-     * @param paramMap 字段条件
+  * 3、根据实体类导入到指定的表中
-     * @return
+  *
-     */
+  * @param file
-    @GetMapping("/get/list")
+  * @param excelOptions
-    @SysAuditLog(moduleKey = "example",subKey = "test")
+  */
-    public RestResult findList(@RequestParamMap(typeCovertMapping = ExampleUserInfo.class) Map<String, Object> paramMap) throws Exception {
+@ExcelImport(targetClass = ExampleUserInfo.class)
-        List<ExampleUserInfo> userInfoList = exampleService.findList(paramMap);
+public void importExcelByAnnotation(MultipartFile file, ExcelOptions excelOptions) {
-        return new RestResult(ResultMsg.SUCCESS, userInfoList);
+    excelService.importExcel(excelOptions);
-    }
+}
 ```
-  **使用时需传递  moduleKey(模块名称,如果是新模块需提前建立表，以ldp_audit_log_  开头+ modulekey 录入的值结尾的表 如ldp_audit_log_example , 表结构可参考 ldp_audit_log_sys), subKey 子模块名称最终会保存在日志中作为二级子模块**;
+### 6.2. @ExcelExport
-### 3.3. @SysJobLog
+依赖：common-biz-annotation
-#### 3.3.1 注解介绍
+#### 6.2.1 注解介绍
-由于系统架构为微服务，服务与服务之间解耦合。因此定时任务设计之初，考虑为定时接口任务调用。  
+**@ExcelExport** 是一个方法注解，主要用于实现Excel导入逻辑。
-定时任务执行接口调用， 在被调用接口引用的Service具体业务方法添加此@SysJobLog 注解。 
-注解包含两大功能，1 异步执行，防止接口执行时间过长，否则定时任务调用机器一直连接被占用； 2 更新定时任务执行情况。 
-定时任务执行流程：
-   1 定时任务调度服务启动后，满足定时条件自动执行任务调度。 根据后台配置好的服务名称、接口信息调用其他服务接口。
-   2 被调用接口，必须添加@RequestParam String taskJobId 作为接收参数，此参数后续作为更新任务执行状态使用。由于在业务方法上添加@SysJobLog， 业务方法与Controller不在同一个线程中，无法
-   获取上一个线程中的信息。因此具体业务Service也必须添加名称为String taskJobId 的参数，后续会自动获取参数的值进行更新任务执行情况。
-   3 被调用接口也必须添加 @AvoidRepeatableSubmit 防止重复执行
-#### 3.3.2 使用案例
-Controller 
-```java
-    @PostMapping(value = "/testExampleJob")
-    @AvoidRepeatableSubmit
-    public RestResult testJob(@RequestBody ExampleUserInfo userInfo, @RequestParam String taskJobId){
-	        exampleService.doJob (userInfo, taskJobId);
-        return new RestResult(ResultMsg.SUCCESS,"");
-    }
-```
-具体Service
-```java
-    @Override
-    @AutoService
-    @SysJobLog
-    public void doJob(ExampleUserInfo exampleUserInfo, String taskJobId) {
-        genericDaoService.insert(exampleUserInfo);
-    }
-```
-**具体业务方法上添加@SysJobLog 进行异步任务及String taskJobId 参数，名称需要保持一致，系统会自动进行更新执行状态**``
-## 四、数据库查询注解
-### 4.1. @QueryBind
-依赖：common-query
-#### 4.1.1 注解介绍
-@QueryBind是一个方法注解，将 **xxxxservice-query.xml** 中的参数SQL语句绑定到方法中的第一个参数中。需要先在 **xxxxservice-query.xml** 中将ref属性指向绑定的xxxServiceImpl类中。
-#### 4.1.2 使用案例
-**Service层代码：**
-```java
-/**
-* jdbc查询， QueryBind所对应的sql语句在resource/query/exampleservice中
-* 调用时 getUserListByJDBC(StringUtils.EMPTY); 注解会将sql语句自动注入到参数中
-*
-* @param sql
-* @return
-*/
-@QueryBind("examplelist")
-@Override
-public List<ExampleUserInfo> getUserListByJDBC(String sql, Map<String, Object> param) {
-    List<ExampleUserInfo> exampleUserInfos = jdbcDaoService.queryForList(sql, ExampleUserInfo.class, param);
-    return exampleUserInfos;
-}
-```
-**REST层代码：**调用时 **getUserListByJDBC(StringUtils.EMPTY)**; 注解会将sql语句自动注入到参数中
-```java
-Map<String, Object> param = new HashMap<>(1);
-param.put("userType", 0);
-List<ExampleUserInfo> exampleUserInfos = exampleService.getUserListByJDBC(StringUtils.EMPTY, param);
-```
-### 4.2. @QueryContextComponent与 @QueryParams
-依赖：common-query
-#### 4.2.1 注解介绍
-**@QueryContextComponent**是一个类注解， **@QueryParams** 是一个方法注解。除了使用 **@QueryBind** 注解注入sql到参数中，还可以使用 **@QueryContextComponent** 结合 **@QueryParams** 注解将xml中的sql全部注入到一个Map对象中。
-#### 4.2.2 使用案例
-首先在类名上添加 **@QueryContextComponent** 注解，定义一个sqlMap字段，加上 **@QueryParams** 注解，由于 **@QueryParams** 是一个方法注解，所以需要在字段上加上 **@Setter** ，这样会自动生成set方法，注解也会添加到自动生成的方法上
-```java
-@QueryContextComponent
-public class UserBizService   {
-    // 由于@QueryParams是一个方法注解，所以此处需要加上@Setter注解
-    @Setter
-    @QueryParams
-    public Map<String,String> sqlMap;
-    public void getSqlKey() {
-        sqlMap.forEach((k,v)->{
-            log.info("id:{} {} {} ",k,String.format("%n"),v);
-        });
-    }
-}
-```
-## 五、REST层参数解析注解
-### 5.1. @RequestParamMap
-依赖：mcs-common
-#### 5.1.1 注解介绍
-**@RequestParamMap**是一个参数注解，主要用于在REST层接收GET参数时保持参数类型与实体类一致，可以直接将GET参数接收到的map作为查询条件，另外也是为了将分页参数从查询参数中区分开来。
-#### 5.1.2 使用案例
-直接在Map参数前使用**@RequestParamMap(typeCovertMapping = XXXX.class)**，这里的XXX指实体类类型。
-```java
-/**
-* 用户列表（非分页）
-*
-* @param paramMap 字段条件
-* @return
-*/
-@GetMapping("/get/list")
-public List<LdpMcsUserInfo> findList(@RequestParamMap(typeCovertMapping = LdpMcsUserInfo.class) Map<String, Object> paramMap) throws Exception {
-    return userService.findList(paramMap);
-}
-```
-### 5.2 @RequestParamPage
-依赖：mcs-common
-#### 5.2.1 注解介绍
-**@RequestParamPage**是一个参数注解，主要用于GET请求时接收分页参数。
-#### 5.2.2 使用案例
-使用封装好的分页类 **Pagination** 来接收分页参数，在分页参数前添加 **@RequestParamPage** 即可。这里是将分页参数和查询参数进行拆分的案例：
-```java
-/**
-* 用户列表(分页)
-*
-* @param paramPage 分页参数为pageIndex,pageSize
-* @param paramMap  字段条件
-* @return
-*/
-@GetMapping("/get/page")
-public Pagination findPage(@RequestParamPage Pagination paramPage,
-                           @RequestParamMap(typeCovertMapping = LdpMcsUserInfo.class) Map<String, Object> paramMap)
-    throws Exception {
-    return userService.findPage(paramPage, paramMap);
-}
-```
-## 六、Excel导入导出注解
-### 6.1. @ExcelImport
-依赖：common-biz-annotation
-#### 6.1.1 注解介绍
-**@ExcelImport** 是一个方法注解，主要用于实现Excel导入逻辑。
-#### 6.1.2 使用案例
-将注解直接加到导入方法上，会自动构建ExcelOptions参数。
-```java
- /**
-  * 通过注解导入Excel，注解完成三件事情：
-  * 1、上传文件
-  * 2、读取Excel数据
-  * 3、根据实体类导入到指定的表中
-  *
-  * @param file
-  * @param excelOptions
-  */
-@ExcelImport(targetClass = ExampleUserInfo.class)
-public void importExcelByAnnotation(MultipartFile file, ExcelOptions excelOptions) {
-    excelService.importExcel(excelOptions);
-}
-```
-### 6.2. @ExcelExport
-依赖：common-biz-annotation
-#### 6.2.1 注解介绍
-**@ExcelExport** 是一个方法注解，主要用于实现Excel导入逻辑。
 #### 6.2.2 使用案例
@@ -775,3 +582,328 @@ public class RootCodeDTO {
 第二步与8.1.2中的填充方式一致。
+## 老版本注解
+### 一、自动填充
+### 1.1. ~~@AutoComputed（1.2.45版已弃用）~~
+依赖：base-api。
+#### 1.1.1 注解介绍
+**@AutoComputed**是一个字段注解，标识**实体类**字段为自动填充的注解，需要配合服务层的 **@AutoService** 使用，拥有四个属性，command、ref、refs、format。注解可以通过command标识字段自动装配的方式，根据字段名查找对应计算方法，或根据command类型查找对应系统计算方法。command默认值为 **ComputedCommand.AUTO** ，以下是内置command每个值的解释：
+**AUTO**：根据字段名进行填充。
+**MD5**：将字段值进行一次md5加密。
+**DATETIME**：当前时间。
+**USERID**：当前登录用户。
+**UUID**：生成32位随机字符串。
+**PINYIN**：将ref字段的拼音填充到此字段中
+**REFERENCE**：将refs字段的值通过format规则填充到此字段
+#### 1.1.2 使用案例
+```java
+// 值为AUTO，通过属性名查找计算方式，这里的计算方式就是createId
+@AutoComputed
+private String createId;
+// 值为MD5，将原本的明文做一次md5加密并重新赋值到字段中
+@AutoComputed(command = ComputedCommand.MD5)
+private String userPassword;
+// 值为DATETIME，将当前时间填充到字段中
+@AutoComputed(command = ComputedCommand.DATETIME)
+private Date createTime;
+// 值为USERID，将当前登录用户ID填充到字段中
+@AutoComputed(command = ComputedCommand.USERID)
+private String updateId;
+// 值为UUID，将随机生成的UUID填充到字段中
+@AutoComputed(command = ComputedCommand.UUID)
+private String uuId;
+// 值为PINYIN，ref为userName，将userName字段的中文拼音自动填充到字段中
+@AutoComputed(command = ComputedCommand.PINYIN, ref = "userName")
+private String sortName;
+// 值为REFERENCE,refs是一个数组, 将数组中的字段值按照format的规则填充到字段中
+@AutoComputed(command = ComputedCommand.REFERENCE, refs = {"name", "age", "gender"}, format = "%s-%s-%s")
+private String referenceValue;
+```
+#### 1.1.3 自定义填充算法
+当command值为 **ComputedCommand.AUTO** 时，会通过字段名查找计算方式，这里介绍一下如何自定义填充算法。自动填充算法分为三种：
+- 第一种是有参算法，例如MD5算法需要使用到原字段中的值作为参数：
+```java
+// 值为MD5，将原本的明文做一次md5加密并重新赋值到字段中
+@AutoComputed(command = ComputedCommand.MD5)
+private String userPassword;
+```
+需要实现 **ComputerArgs** 接口，将自动填充算法写到computed中。例如Md5填充算法代码如下：
+```java
+public class ComputerMd5 implements ComputerArgs {
+    @Override
+    public String computed(Object plain) {
+        //这里进行处理，并返回自动填充内容
+        return DigestUtils.md5Hex(plain.toString());
+    }
+}
+```
+- 第二种也是有参算法，主要是为了按照format进行自动填充，例如：
+```java
+// 值为REFERENCE,refs是一个数组, 将数组中的字段值按照format的规则填充到字段中
+@AutoComputed(command = ComputedCommand.REFERENCE, refs = {"name", "age", "gender"}, format = "%s-%s-%s")
+private String referenceValue;
+```
+需要实现 **ComputerFormatArgs** 接口，将自动填充算法写到computed中。例如REFERENCE填充算法如下：
+```java
+public class ComputerReference implements ComputerFormatArgs {
+    @Override
+    public String computed(Object target, String format) {
+        String result = "";
+ 		//核心代码如下，如果format为空则默认以下划线拼接，否则按fromat格式化
+        if (StringUtils.isEmpty(format)) {
+            result = StringUtils.joinWith("_", objects);
+        } else {
+            result = String.format(format, objects);
+        }
+        return result;
+    }
+}
+```
+- 第三种是无参算法，例如DATETIME算法就是一个无参算法，只需要获取当前时间：
+```java
+// 值为DATETIME，将当前时间填充到字段中
+@AutoComputed(command = ComputedCommand.DATETIME)
+private Date createTime;
+```
+无参算法与有参类似，只是没有参数，需要实现 **ComputerNoArgs** 接口
+```java
+public class ComputerDate implements ComputerNoArgs<Date> {
+    @Override
+    public Date computed() {
+        return new Date();
+    }
+}
+```
+- 完成算法编写后，还需要将计算类与字段名对应起来。
+在service包中新建computed包（推荐），新建一个类，加上 **@Configuration** 注解，在 **@Bean** 注解中的name属性填上字段名。例如字段createId的填充算法是一个无参算法，方法返回类型为 **ComputerNoArgs** ，如果为有参算法，则应该返回 **ComputerArgs** 或者 **ComputerFormatArgs**。
+```java
+@Configuration
+public class ComputedResolver {
+    @Bean(name = "createId")
+    public ComputerNoArgs getCreateId() {
+        return new ComputerUser();
+    }
+}
+```
+当AOP在处理自动填充时，这个字段就会根据上面编辑的算法进行自动填充。
+### 1.2. ~~@AutoService（1.2.45版已弃用）~~
+依赖：mcs-common
+#### 1.2.1 注解介绍
+**@AutoService**是一个方法注解，被 **@AutoService** 注解的方法，都会被AOP拦截，并根据实体类字段中的 **@AutoComputed** 规则对字段自动填充。拥有两个属性 mode、init，mode为填充方式，默认为     **ComputedMode.COMPUTED** ，init为是否初始化，初始化则全部填充，否则只填充updateId、updateTime、sortName。
+默认取方法的第一个参数进行填充，支持单个实体，也支持List集合。
+#### 1.2.2 使用案例
+一般@AutoService用于新增方法，以及更新方法
+```java
+// 新增方法
+@AutoService
+public void add(LdpMcsElementInfo elementInfo) {
+    genericDaoService.insert(elementInfo);
+}
+// 更新方法
+@AutoService(init = false)
+public void update(LdpMcsElementInfo elementInfo) {
+    genericDaoService.dynamicUpdate(elementInfo);
+}
+```
+### 1.3. ~~@AutoRelativeComputed（1.2.45版已弃用）~~
+依赖：mcs-common
+#### 1.3.1 注解介绍
+**@AutoRelativeComputed** 是一个方法注解，对使用JPA配置了关联关系实体类进行自动填充，主要作用于Service层，对新增关联和移除关联方法参数进行自动填充。
+@AutoRelativeComputed字段详解：
+**mode**：关联类型，目前支持RelativeMode.MTM（多对多）、RelativeMode.OTM（一对多）、RelativeMode.MTO（多对一）。**PS：一对多、多对一暂时不建议使用**
+**inverse**：是否为逆向，false为单向绑定，true为双向绑定，默认为false。
+**source**：参数源类型。
+**target**：参数目标类型。
+**joinField**：关联字段。
+**inverseField**：逆向关联字段。
+**exComputed**：扩展的填充字段。
+#### 1.3.2 使用案例
+##### 1). 多对多关系
+这里举例为用户和角色的多对多关系。
+用户表（user）：
+| 字段名称  | 类型   | 备注             |
+| --------- | ------ | ---------------- |
+| id        | String | 用户ID，唯一标识 |
+| user_name | String | 用户名           |
+角色表（role）：
+| 字段名称  | 类型   | 备注             |
+| --------- | ------ | ---------------- |
+| id        | String | 角色ID，唯一标识 |
+| role_name | String | 角色名称         |
+用户角色关联表（user_role）：
+| 字段名称 | 类型   | 备注         |
+| -------- | ------ | ------------ |
+| id       | String | ID，唯一标识 |
+| user_id  | String | 用户ID       |
+| role_id  | String | 角色ID       |
+1. 使用JPA配置实体类关联关系
+   **User.java**
+   ```java
+   /**
+   * 与角色的多对多关联
+   */
+   @JsonIgnoreProperties("userInfos")//避免互相关联死循环
+   @ManyToMany(fetch = FetchType.EAGER)
+   @JoinTable(name = "user_role", //中间表的名称
+              joinColumns = {@JoinColumn(name = "user_id", referencedColumnName = "id")},
+              inverseJoinColumns = {@JoinColumn(name = "role_id", referencedColumnName = "id")})
+   private Set<Role> roleInfos = new HashSet<>();
+   ```
+   **Role.java**
+   ```java
+   @JsonIgnoreProperties("roleInfos")
+   @ManyToMany(mappedBy = "roleInfos", fetch = FetchType.EAGER, targetEntity = User.class)
+   private Set<User> userInfos = new HashSet<>(0);
+   ```
+2. 在**UserServiceImpl**中添加方法和注解
+   ```java
+   /**
+   * 添加角色关联
+   *
+   * @param id    用户ID
+   * @param list  通过注解将List<Role>转换为List<UserRole>
+   * @param param 作为删除条件，避免重复数据
+   */
+   @AutoRelativeComputed(mode = RelativeMode.MTM, source = Role.class, target = UserRole.class, joinField = "userId", inverseField = "roleId")
+   public void addRoleToUser(String id, List list, Map<String, Object> param) {
+       LinkedList<TranscationEntity> entityList = new LinkedList<>();
+       // 删除重复数据
+       entityList.add(new TranscationEntity(TransItemExeType.DELETE_ENTITY, UserRole.class, param));
+       // 新增
+       entityList.add(new TranscationEntity(TransItemExeType.INSERT_ENTITY, list));
+       genericDaoService.executeTrans(entityList);
+   }
+   /**
+   * 移除角色关联
+   *
+   * @param id    用户ID
+   * @param list  通过注解将List<Role>转换为List<UserRole>
+   * @param param 作为删除条件，避免重复数据
+   */
+   @AutoRelativeComputed(mode = RelativeMode.MTM, source = Role.class, target = UserRole.class,joinField = "userId", inverseField = "roleId")
+   public void removeRoleFromUser(String id, List list, Map<String, Object> param) {
+       genericDaoService.deleteList(UserRole.class, param);
+   }
+   ```
+#### 1.3.3 扩展填充算法
+ **@AutoRelativeComputed** 注解主要填充中间关联数据，有部分数据和关联无关，但是又必须填充，这种时候就需要 **exComputed** 来扩展填充算法，可以通过算法来填充其它字段。例如，岗位和组织多对多关联自动填充， exComputed字段值为**orgPosition** ：
+```java
+@AutoRelativeComputed(mode = RelativeMode.MTM, source = LdpMcsOrganization.class, target = LdpMcsPositionOrganization.class,joinField = "postId", inverseField = "orgId", exComputed = "orgPosition")
+```
+编写扩展算法需要实现 **CustomComputer** 接口，并在computed方法中编写自动填充逻辑。computed方法有一个参数，这个参数是注解中target类的对象，可以在方法中拿到对象，并对对象中的其它字段进行填充。这里对manager字段进行填充：
+```java
+public class ComputerOrgPosition implements CustomComputer {
+    @Override
+    public void computed(Object target) {
+        LdpMcsPositionOrganization positionOrganization = (LdpMcsPositionOrganization) target;
+        positionOrganization.setManager(false);
+    }
+}
+```
+在有 **@Configuration** 注解类中完成Bean的装配：
+```java
+@Configuration
+public class ExtraComputer {
+    /**
+     * 关联表其它业务数据填充
+     *
+     * @return
+     */
+    @Bean(name = "orgPosition")
+    public CustomComputer getUserPositionComputer() {
+        return new ComputerOrgPosition();
+    }
+}
+```
--- a/报表系统集成/image/90预览打印报表.png
+++ b/报表系统集成/image/90预览打印报表.png
--- a/报表系统集成/报表系统打印模板使用.md
+++ b/报表系统集成/报表系统打印模板使用.md
@@ -94,3 +94,8 @@ export default {
 ```
+调用预览接口，进行打开报表预览页面
+![image-20210610155659161](./image/90预览打印报表.png)
\ No newline at end of file
--- a/操作文档/LDP代码生成功能操作说明v2.0.docx
+++ b/操作文档/LDP代码生成功能操作说明v2.0.docx
--- a/操作文档/LDP统一认证登录配置.md
+++ b/操作文档/LDP统一认证登录配置.md
+# LDP统一认证登录配置
+在mcs中对应用配置统一认证时，根据配置的不同，能达到不同的登录控制效果。
+### 一、样例数据
+**应用**
+- 应用系统A：认证领域编码 demo
+**用户**
+- 用户1： 类型-管理，系统标识-无
+- 用户2： 类型-应用，系统标识-无
+- 用户3： 类型-应用，系统标识-demo
+- 用户4： 类型-应用，系统标识-example
+### 二、认证服务接口地址配置
+在mcs中，打开左侧菜单`应用认证管理`->`认证服务`，找到认证领域demo的认证服务，点击修改，登录配置只需要修改下图圈中的接口地址即可：
+![](../imgs/UAA登录配置.png)
+#### 2.1 不做限制，所有用户均可登录
+将接口地址设置为user/alllogin
+```java
+// 所有用户均可登录
+user/alllogin
+```
+#### 2.2 管理用户、应用用户（无系统标识或相同系统标识）均可登录
+将接口地址设置为user/applogin，配置相关参数用户类型usertype=0，系统标识sysid=demo
+```java
+// 除了用户4由于系统标识不一致不能登录，用户1、用户2、用户3均可登录
+user/applogin?usertype=0&sysid=demo
+```
+#### 2.3 仅应用用户（不检查系统标识）可登录
+将接口地址设置为user/login，并设置应用类型usertype=0
+```java
+// 除用户1是管理用户不能登录，用户2、用户3、用户4均可登录
+user/login?usertype=0
+```
+#### 2.4 仅应用用户（相同系统标识）可登录
+将接口地址设置为user/login，并设置应用类型usertype=0，系统标识sysid=demo
+```java
+// 仅用户3满足条件，可以登录，其它用户均不可登录
+user/login?usertype=0&sysid=demo
+```
\ No newline at end of file