工作中经常用的方法

0.045*天数*人数
----------------------------------------------------------mysql 命令--------------------------------------------------
创建用户：
create user 'xy_item_rw'@'%' identified by 'Item@8IwrTO_';
grant SELECT on xiangyangpolicy_policy.policy to 'xy_item_rw'@'%'; 权限有SELECT，INSERT，UPDATE，ALTER，DELETE，DROP，CREATE等 可以吧@'%';去掉

SELECT
COLUMN_NAME
columnName,
COLUMN_TYPE columnType,
DATA_TYPE dataType,
CHARACTER_MAXIMUM_LENGTH characterMaximumLength,
IS_NULLABLE isNullable,
COLUMN_DEFAULT columnDefault,
COLUMN_COMMENT columnComment,
TABLE_NAME tableName
FROM
INFORMATION_SCHEMA.COLUMNS
WHERE
table_schema =
#{dataSourceName}

SELECT
COLUMN_NAME
columnName,
COLUMN_TYPE columnType,
DATA_TYPE dataType,
CHARACTER_MAXIMUM_LENGTH characterMaximumLength,
IS_NULLABLE
isNullable,
COLUMN_DEFAULT columnDefault,
COLUMN_COMMENT
columnComment
FROM
INFORMATION_SCHEMA.COLUMNS
WHERE
table_schema = #{dataSourceName}
AND table_name = #{tableName}

----------------------------------------------------------linux 命令--------------------------------------------------
docker 版本查看
docker -v
nginx 版本查看
cd /usr/local/nginx/sbin/
./nginx -v

----------------------------------------------------------linux 命令-----------END---------------------------------------

/**
* 出生年月
*/
@ApiModelProperty(value = "出生年月", name = "birthDate", dataType = "LocalDate")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
private LocalDateTime birthDate;

@NotNull,@NotBlank和 @NotEmpty使用

@NotNull(message = "来源部门不能为空")
@NotBlank(message = "数据类型不能为空")

"pre": "cnpm install || yarn --registry https://registry.npm.taobao.org || npm install --registry https://registry.npm.taobao.org ",

// list 去重
List<String> matterNameList = matterNameLists.stream().distinct().collect(Collectors.toList());

new DnaInfTables().selectList(Wrappers.<DnaInfTables>query().lambda().eq(DnaInfTables::getDbId, dbId))
qw.lambda().and(wrapper -> wrapper.like(WorkReport::getDeptId,deptId).or().like(WorkReport::getIssueDeptId,"\"id\":"+deptId+","));
DataScope dataScope = new DataScope();
dataScope.setScopeName("org_id");

paramMap.put("bc", "aa");
paramMap.put("a", "bb");
System.out.println(paramMap.containsKey("b"));--返回false
System.out.println(paramMap.containsKey("a"));--返回true

paramMap.put("1", "b");
paramMap.put("2", "b");
paramMap.put("3", "ab");
paramMap.put("4", "cc");
System.out.println(paramMap.containsValue("b"));--返回true
System.out.println(paramMap.containsValue("a"));--返回false
System.out.println(paramMap.containsValue("cc"));--返回true
按；返回string字符串
msgList.stream().map(v -> String.valueOf(v)).collect(Collectors.joining("；"))
-------------------------------------------配置微服务sql打印--------------------------------------------
# mybatis-plus 配置
mybatis-plus:
tenant-enable: ture
mapper-locations: classpath:/mapper/*Mapper.xml
global-config:
banner: false
db-config:
id-type: auto
field-strategy: NOT_EMPTY
type-handlers-package: com.govmade.govmade.common.data.handler
# spring boot集成mybatis的方式打印sql
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

-----------------------------------------docker部署-----------------------------------------
docker部署
0. 先启动docker

1. 本地idea先打包成jar包

2. 打好包后，把需要部署的模块放到项目docker---->jar目录下，需要先新建jar目录，

3. 编译jar包
cd docker
docker-compose build gds-policy
docker-compose build gds-upms
docker-compose build gds-cbs
docker-compose build -f .\Dockerfile.dockerfile . -t gds-cbs
4. 启动
启动命令：
docker-compose up gds-policy
docker-compose up gds-gateway
docker-compose up gds-upms
docker-compose up gds-cbs

启动之后，再开一个窗口，执行下面的命令：
docker ps
得到第一个值

然后把第一个窗口的停止
Ctrl + c 停止

5. 通过docker提交第四步获取的值
docker commit -a "gds" -m "gds-policy" b8d4c1e26ec1
docker commit -a "gds" -m "gds-gateway" cdd3f42aaa6e
docker commit -a "gds" -m "gds-upms" f8d7c645e38a
docker commit -a "gds" -m "gds-cbs" 28d22bfa9628

6. 通过docker将jar包转换成tar包
6.1. 在项目中的docker目录下新建tar目录
6.2 通过下面命令，生成tar包
docker save -o D:/IdeaProjects/DeZhouZhengCeTong/docker/tar/gds-policy.tar gds-policy
docker save -o D:/IdeaProjects/DeZhouZhengCeTong/docker/tar/gds-cbs.tar gds-cbs

docker save -o D:/guomai/code/xyzct/gds/docker/tar/gds-gateway.tar gds-gateway
docker save -o D:/guomai/code/xyzct/gds/docker/tar/gds-upms.tar gds-upms

docker save -o D:/IdeaProjects/xiangyang_20220321/docker/tar/gds-upms.tar gds-upms

7. 启动项目
将tar包放到tar目录；cd /data/docker/tar
cd /data/docker
停止服务：docker-compose stop gds-policy
docker-compose stop gds-upms
删除镜像：docker-compose rm gds-policy
docker-compose rm gds-upms
彻底删除镜像：docker rmi gds-policy
docker rmi gds-upms
查看镜像是否删掉：docker images
cd tar
加载镜像：docker load -i gds-policy.tar
docker load -i gds-upms.tar
cd ..
启动项目：docker-compose up gds-policy
docker-compose up gds-upms

注意：如何停止和启动所有项目
docker-compose stop
docker-compose up

8. docker redis缓存清理
1、仓库容器id: docker ps
2、进入容器：docker exec -it 容器id redis-cli
3、清除所有缓存：flushall

9. docker logs查看日志
https://blog.csdn.net/SwTesting/article/details/112546442
1、仓库容器id: docker ps -a
2. docker ps -a --filter name=policy
3. docker logs [options] container

docker logs 6d0ea3755c51 |grep 请求浪潮办件服务入参

docker logs -f container
OPTIONS说明：
-f : 跟踪日志输出
-t : 显示时间戳
--tail :仅列出最新N条容器日志
--since：显示某个日期后的所有日志
CONTAINER 代表容器ID或容器名称

10 sftp
登录命令：sftp ftpuser@10.180.178.19
sftp -oPort=98888 ftpuser@10.180.178.19
搜索端口：ss -an | grep 9906
查看sftp端口：netstat -utlpn | grep vsftp

修改端口
https://blog.csdn.net/caihuashen/article/details/80306131
重启SSH
systemctl restart sshd.service
https://blog.csdn.net/zhichao_qzc/article/details/80301994

-----------------------------------------codegen生成表对象-----------------------------------------
先项目连接上数据库
命令：
如果多张
gen 表名;表名
如果单张
gen 表名

查数据库版本：select version();
查docker版本：docker --version
查docker中redis的版本：
docker ps 查看容器中redis的名称
docker exec -it 你容器中redis的名称 redis-server -v

------------------------------------修改redis密码--------------------------------------------------
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
5d6687e29390 nmg-khpg "/bin/sh -c 'java -D…" 23 hours ago Up 23 hours 0.0.0.0:8084->8084/tcp nmg-khpg
34d0c5772a40 party-mini "/bin/sh -c 'java -D…" 28 hours ago Up 28 hours 0.0.0.0:8080->8080/tcp party-mini
d8dd9e4d7543 hainan-rwdc "/bin/sh -c 'java -D…" 28 hours ago Up 28 hours 0.0.0.0:8083->8083/tcp hainan-rwdc
04a5fe0ba3e1 city-sign "/bin/sh -c 'java -D…" 47 hours ago Up 47 hours 0.0.0.0:8086->8086/tcp city-sign
0cd6d0460ab7 city-khpg "/bin/sh -c 'java -D…" 5 weeks ago Up 5 weeks 0.0.0.0:8085->8085/tcp city-khpg
fc8f03fc931e gds-zlys "/bin/sh -c 'java -D…" 2 months ago Up 2 months 0.0.0.0:8082->8082/tcp gds-zlys
fda2f837cf5d gds-szdh "/bin/sh -c 'java -D…" 3 months ago Up 3 months 0.0.0.0:8081->8081/tcp gds-szdh
115d49110511 minio/minio "/usr/bin/docker-ent…" 3 months ago Up 3 months 0.0.0.0:9000->9000/tcp gds-minio
63bce71d7df2 redis:5.0.7 "docker-entrypoint.s…" 3 months ago Up 3 months 0.0.0.0:6379->6379/tcp gds-redis

docker exec -it 63bce bash

/data# redis-cli
redis-cli
进入redis容器，并运行redis-cli
docker exec -it redis容器名字 /bin/bash
1.进入Redis容器内部

docker exec -it myredis redis-cli
2.设置密码

CONFIG SET requirepass secret_password # 将密码设置为 secret_password
QUIT # 退出再连接，让新密码对客户端生效
3.清空密码
查看有无权限，无权限有密码
keys *
//输入密码
auth gov20130528
重新查看有权限
keys *

CONFIG SET requirepass "" # 通过将密码设为空字符来清空密码
QUIT # 退出再连接，让新密码对客户端生效

查看内蒙古考核评估环境变量
docker inspect 5d6687

 

本地设置redis密码
cmd到redis根目录
输入 redis-cli.exe
config get requirepass 验证有无密码
config set requirepass gov20130528 设置redis密码
-------------------------------------------nginx------------------------------------
cd /usr/local/nginx/sbin
1、验证nginx配置文件是否正确
方法一：进入nginx安装目录sbin下，输入命令./nginx -t
看到如下显示nginx.conf syntax is ok

nginx.conf test is successful

说明配置文件正确！
在启动命令-c前加-t
方法一：进入nginx可执行目录sbin下，输入命令./nginx -s reload 即可

方法二：查找当前nginx进程号，然后输入命令：kill -HUP 进程号 实现重启nginx服务

-------------------------------------------前端地址------------------------------------

var basePath = "<%=basePath%>";
basePath+
basePath+'sys/getInterfaceParam'
//获取主机地址之后的目录，如： uimcardprj/share/meun.jsp
　　　　　　　　　　var pathName = window.document.location.pathname;
　　　　　　　　　　var pos = curWwwPath.indexOf(pathName);
　　　　　　　　　　//获取主机地址，如： http://localhost:8083
　　　　　　　　　　var localhostPaht = curWwwPath.substring(0, pos);
　　　　　　　　　　//获取带"/"的项目名，如：/uimcardprj
　　　　　　　　　　var projectName = pathName.substring(0, pathName.substr(1).indexOf('/') + 1);

var pathName = window.document.location.pathname;
var domain = document.location.origin+pathName.substring(0, pathName.substr(1).indexOf('/') + 1);

<%
String path = request.getContextPath();
String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
%>

<%=request.getContextPath()%>
<%=basePath%>

--------------------------------------------发布中：--------------------------------------------
yarn build 前端打包
git clone -b fillout http://115.233.227.46:8066/root/gds-mini-ui git克隆

git pull origin dev git拉取

git pull origin fillout
yarn install 前端下包

cd /khpg
docker-compose logs -f gds-data-transfer 查看打印

启动服务器 ./auto.sh gds-mini-second

 

--------------------------------------------excel中：--------------------------------------------
所有的文本连接
=TEXTJOIN("','",,A1:A262)

excel中新增公式
=CONCATENATE("insert into index_entity (index_name,type) VALUES ('",A1,"','",IF(C1="正向",1,IF(C1="负向",2,3)),"');")

=CONCATENATE("insert into index_rule_entity (name,description,type,apply_level,index_basis,dept_name) VALUES ('",A1,"-",B1,"','",E1,"',",IF(C1="",1,2),",",3,",'",G1,"','",IF(F1="","",F1),"');")

=CONCATENATE("insert into formula_entity (formula_name,formula_source,status,index_type) VALUES ('",A1,"-",B1,"','",IF(D1="","",D1),"',",0,",",1,");")
--------------------------------------------git中：--------------------------------------------
git pull origin master git拉取

--------------------------------------------mysql中：--------------------------------------------
CREATE TABLE `sys_user` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`branch_name` varchar(64) DEFAULT NULL COMMENT '党支部名称',
`create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
`del_flag` char(1) DEFAULT '0' COMMENT '删除标记（0正常，1删除）',
`title_pic` varchar(500) DEFAULT NULL COMMENT '标题图',
`dept_id` int(11) DEFAULT NULL COMMENT '部门ID',
`branch_content` text COMMENT '支部内容',
`sort` varchar(255) DEFAULT '999' COMMENT '排序号',
PRIMARY KEY (`id`) USING BTREE,
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='支部管理表表';

<if test="ids != null and ids.size() &gt;0">
AND u.user_id IN
<foreach item="item" index="index" collection="ids" open="(" separator="," close=")">
#{item}
</foreach>
</if>

<if test="query.isSearchWxUser != null and query.isSearchWxUser == 4">
AND FIND_IN_SET('3',u.source_from)
</if>
删除表中的所有行，而不记录单个行删除操作。并且自增id变为0
如果曾经的数据都不需要的话，可以直接清空所有数据，并将自增字段恢复从1开始计数：
truncate table table_name;

----规则和公式关联
INSERT INTO index_rule_formula (rule_id,formula_name,formula_source)
SELECT r.id rule_id,IFNULL(f.formula_name,'') formula_name,IFNULL(f.formula_source,'') formula_source FROM index_rule_entity r LEFT JOIN formula_entity f on r.name = f.formula_name
WHERE r.id not in (select rule_id from index_rule_formula) and f.formula_name is not null;

UPDATE index_rule_entity r , index_rule_formula f SET r.formula_id=f.id WHERE r.id = f.rule_id;

----规则和指标关联
INSERT INTO index_rule_relation (index_id,rule_id)
SELECT DISTINCT i.id index_id,r.id rule_id FROM index_rule_entity r LEFT JOIN index_entity i on r.name like CONCAT('%',i.index_name)
WHERE 1=1 and r.id not in (select rule_id from index_rule_relation) and i.id not in (select index_id from index_rule_relation)

---查询重复的关系
SELECT r.index_id,r.rule_id FROM index_rule_relation r WHERE 1=1 and rule_id=266;

select * from index_entity t where 1=1
and (id =222 or id = 355);

select * from index_rule_entity where 1=1
#and id =253
and name like '%社区居民电子健康档案建档率（%）%'

SELECT r.index_id,r.rule_id,count(1) FROM index_rule_relation r GROUP BY r.rule_id HAVING count(1)>1;

DELETE from index_rule_relation where 1=1 and index_id =355 and rule_id = 135;

SELECT e.id,e.index_name,r.index_id,r.rule_id FROM index_entity e LEFT JOIN index_rule_relation r on e.id=r.index_id WHERE 1=1 ORDER BY r.rule_id

INSERT INTO index_system_relation (system_id,parent_id,index_id,rule_id)
select 1 system_id,IFNULL((select r.id FROM index_entity e left JOIN index_system_relation r on e.id=r.index_id WHERE 1=1 and e.index_name='概况' limit 1),0) parent_id
,t.id index_id,IFNULL(r.rule_id,0) rule_id
from index_entity t LEFT JOIN index_rule_relation r on t.id=r.index_id where 1=1 and t.index_name in ('概况','经济','文化','民生','生态')
--------------------------------------------浏览器中：--------------------------------------------
打开浏览器点击F12或右键打开审查元素，点击Console，粘贴以下代码
$('div.ie-fix').text()
然后回车。此方法仅限文字类的文档。

font-family: "Microsoft Yahei";
line-height: 55px;
font-size: 20px;
font-weight: 600;

checkBox.attr("checked", "checked");
--------------------------------------------配置中：--------------------------------------------
连接数据库时allowMultiQueries=true的作用

MySQL连接数据库时，添加语句：“allowMultiQueries=true”的作用：
1.可以在sql语句后携带分号，实现多语句执行。
2.可以执行批处理，同时发出多个SQL语句。

#正式服务器
jdbc.mysql.driver=com.mysql.jdbc.Driver
jdbc.mysql.url=jdbc:mysql://rdsuh0g7uh8v2lbh556l.mysql.hzegc.cn:3306/hangzhou?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
jdbc.mysql.username=gov_hangzhou
jdbc.mysql.password=Gov20130528
#测试服务器
jdbc.mysql.driver=com.mysql.jdbc.Driver
jdbc.mysql.url=jdbc:mysql://rm-bp1hokax3bt61ghopo.mysql.rds.aliyuncs.com:3306/citysystem_c?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
jdbc.mysql.username=xmgl
jdbc.mysql.password=XMgL@2020Due!Gov=

<!-- https://mvnrepository.com/artifact/org.xhtmlrenderer/core-renderer -->
<dependency>
<groupId>org.xhtmlrenderer</groupId>
<artifactId>core-renderer</artifactId>
<version>8.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.xhtmlrenderer/core-renderer -->
<dependency>
    <groupId>org.xhtmlrenderer</groupId>
    <artifactId>core-renderer</artifactId>
    <version>R8</version>

</dependency>
--------------------------------------------yml配置：--------------------------------------------
# 开发环境配置
spring:
thymeleaf:
cache: false
datasource:
dynamic:
primary: master #设置默认的数据源或者数据源组,默认值即为master
datasource:
sqlServer:
username: root
password: root
driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
url: jdbc:sqlserver://localhost:3306;databaseName=gds_mini
redis:
host: ${REDIS-HOST:localhost} # Redis服务器地址
database: ${REDIS-DATABASE:0} # Redis数据库索引（默认为0）
port: ${REDIS-PORT:6379} # Redis服务器连接端口
password: ${REDIS-PASSWORD:} # Redis服务器连接密码（默认为空）

--------------------------------------------IDEA中：--------------------------------------------
如果IDEA vpn请求不到地址 配置
配置中VM options -Djava.net.preferIPv4Stack=true

相当于eclipse的ctrl+shift+R，输入类名可以定位到这个类文件

Ctrl+Shift+N按文件名搜索文件

Ctrl+H
查看类的继承关系，例如HashMap的父类是AbstractMap，子类则有一大堆

Ctrl+Alt+B查看子类方法实现
Ctrl+B可以查看父类或父方法定义，但是不如ctrl+鼠标左键方便。
但是在这里，Ctrl+B或ctrl+鼠标左键只能看见Map接口的抽象方法put的定义，不是我们想要的，这时候Ctrl+Alt+B就可以查看HashMap的put方法。

Alt+F7查找类或方法在哪被使用
相当于eclipse的ctrl+shif+H,但是速度快得多。

Ctrl+F/Ctrl+Shift+F按照文本的内容查找
相当于eclipse的ctrl+H，速度优势更加明显。其中Ctrl+F是在本页查找，Ctrl+Shift+F是全局查找

Shift+Shift搜索任何東西
shift+shift非常强大，可搜索类、资源、配置项、方法等，还能搜索路径。其中搜索路径非常实用，例如你写了一个功能叫hello，
在java，js，css，jsp中都有hello的文件夹，那我们可以搜索"hello/"找到路径中包含hello的文件夹。

--------------------------------------------服务器中：--------------------------------------------
1.cd ../usr/local/src/tomcat8-18088/bin
2.ps -ef|grep java
或
ps -ef|grep tomcat
启动服务器
3.杀死进程
kill -9 600606 看tomcat是不是tomcat8-18088
4.ps -ef|grep tomcat 再看下有没有杀掉进程
5. ./startup.sh 启动进程
或nohup java -jar hangzhou.jar >/dev/null 2>&1 &
或nohup java -jar grade.jar >logs/consoleMsg.log 2>&1 &
查看日志
tail -f catalina.out
Ctrl+c 是退出tail命令。

删除文件夹实例：
rm -rf /var/log/httpd/access
将会删除/var/log/httpd/access目录以及其下所有文件、文件夹

删除文件使用实例：
rm -f /var/log/httpd/access.log
将会强制删除/var/log/httpd/access.log这个文件

 

--------------------------------------------java中：--------------------------------------------
Arrays.stream(policyDTO.getAthletsOrgId().split(","))

activityPublishService.count(new LambdaQueryWrapper<ActivityPublish>()
.eq(ActivityPublish::getDelFlag, "0")
.eq(ActivityPublish::getDeptId, entity.getDeptId())
.select(ActivityPublish::getId));

 

Arrays.asList(matMatterPageDTO.getEnterpriseNature().split(",")).stream().map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());
Arrays.asList(matMatterPageDTO.getEnterpriseNature().split(",")).stream().collect(Collectors.toList());

List<Long> updateIds = CollUtil.newArrayList();

1 String类型有一个方法：contains（）,该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false。
如：if(map_string.contains("name")){
System.out.println("找到了name的key");
}
if(map_string.contains("password")){
System.out.println("找到了password的key");
}

2 将map类型直接转化为String类型。
如：String map_string="";
Iterator iterator=map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry entry=(Map.Entry)iterator.next();
String key=entry.getKey().toString();
String value=entry.getValue().toString();
map_string=map_string+key+":"+value+",";
}

contains就是包含(abc中包含a)
equals就是相等(完全一样).
<![CDATA[<=]]>

jav8特性：
Map<String, SysDept> sysDeptMap=sysDeptList.stream().collect(Collectors.toMap(SysDept::getName, v -> v));
List<SysRoleMenu> roleMenuList = Arrays.stream(menuIds.split(",")).map(menuId -> {
SysRoleMenu roleMenu = new SysRoleMenu();
roleMenu.setRoleId(roleId);
roleMenu.setMenuId(Integer.valueOf(menuId));
return roleMenu;
}).collect(Collectors.toList());

List<Integer> dataType = StringUtils.isNotBlank(quotaLibrary.getDataType()) ? JSONArray.parseArray(quotaLibrary.getDataType(), Integer.TYPE) : new ArrayList<>();
list拼接字符串逗号拼接
String join = CollectionUtil.join(deptIds, ",");
String rules = StringUtils.join(ruleList, ",");
String.join(",", newFunctionStrs)
String转list
String[] split = rules.split(",");
List<String> ruleList = Arrays.asList(split);

String[] functionStrs = StrUtil.split(f.getFieldFunction(), ",");
List<String> functionStrs = CollUtil.toList(StrUtil.split(functionField.getFieldFunction(), ","));

//list转map
List<SysDept> sysDeptList = new SysDept().selectList(sysDeptQueryWrapper);
Map<String, SysDept> sysDeptMap = new HashMap<>();
if(CollUtil.isNotEmpty(sysDeptList)){
sysDeptMap=sysDeptList.stream().collect(Collectors.toMap(SysDept::getName, v -> v));
}
Map<Long, Long> interfaceDataMap = new HashMap<>();
interfaceDataMap = interfaceData.stream().collect(Collectors.toMap(GradeInterfaceData::getInterfaceId,GradeInterfaceData::getInterfaceId));

使用java8的lambda将list转为map（转）
常用方式
代码如下：

public Map<Long, String> getIdNameMap(List<Account> accounts) {
return accounts.stream().collect(Collectors.toMap(Account::getId, Account::getUsername));
}
收集成实体本身map
代码如下：

public Map<Long, Account> getIdAccountMap(List<Account> accounts) {
return accounts.stream().collect(Collectors.toMap(Account::getId, account -> account));
}
account -> account是一个返回本身的lambda表达式，其实还可以使用Function接口中的一个默认方法代替，使整个方法更简洁优雅：

public Map<Long, Account> getIdAccountMap(List<Account> accounts) {
return accounts.stream().collect(Collectors.toMap(Account::getId, Function.identity()));
}
重复key的情况
代码如下：

public Map<String, Account> getNameAccountMap(List<Account> accounts) {
return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity()));
}
这个方法可能报错（java.lang.IllegalStateException: Duplicate key），因为name是有可能重复的。toMap有个重载方法，可以传入一个合并的函数来解决key冲突问题：

public Map<String, Account> getNameAccountMap(List<Account> accounts) {
return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity(), (key1, key2) -> key2));
}
这里只是简单的使用后者覆盖前者来解决key重复问题。还有一种分组的方法：

Map<Long, List<ActivityUserMissionDO>> map = activityUserMissionDos.stream().collect(Collectors.groupingBy(ActivityUserMissionDO::getParentModuleId));

returnRemindList.stream().collect(Collectors.groupingBy(TopicRemindSettingBO::getRemindPhone, LinkedHashMap::new, Collectors.toCollection(ArrayList::new)));
returnRemindList 是已经排序好序的集合，groupingBy 分组后map是不保持有序， 加入如下2个参数可以保持原来的顺序输出
LinkedHashMap::new, Collectors.toCollection(ArrayList::new))

指定具体收集的map
toMap还有另一个重载方法，可以指定一个Map的具体实现，来收集数据：

public Map<String, Account> getNameAccountMap(List<Account> accounts) {
return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity(), (key1, key2) -> key2, LinkedHashMap::new));
}

---------------------------------------直接执行当前方法-------------------------------------------------
List<TaskBaseMaterial> taskBaseMaterialList = new ArrayList<>();
newMaterialList.forEach(matMaterial -> {
TaskBaseMaterial taskBaseMaterial = new TaskBaseMaterial();
taskBaseMaterial.setTaskId(guideId);
taskBaseMaterial.setMaterialId(matMaterial.getId());
taskBaseMaterialList.add(taskBaseMaterial);
});

private static Map<String, String> map = new HashMap<>();
@Resource
private HttpSessionService httpSessionService;
static {
map.put("1", "getRadioMap");
map.put("2", "getRadioMap");
map.put("3", "getRadioMap");
map.put("4", "getRadioMap");
map.put("5", "getRadioMap");
// 获得填空类型的统计
map.put("6", "getFillMap");
// 获得多项填空类型的统计
map.put("7", "getMultiFillMap");
// 获得打分统计
map.put("8", "getGradeMap");
// 获得上传类型的统计
map.put("9", "getUploadMap");
}

@Override
@SuppressWarnings("unchecked")
public Map getStatistics(Long questionId) {
Map<String, Object> resultMap = new HashMap<>(16);
QuesQuestion quesQuestion = new QuesQuestion().selectById(questionId);
try {
if (map.containsKey(quesQuestion.getType())) {

resultMap = (Map<String, Object>) this.getClass()
.getDeclaredMethod(map.get(quesQuestion.getType()), Long.class).invoke(this, questionId);
}
} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
e.printStackTrace();
}
resultMap.put("questionId", questionId);
resultMap.put("type", quesQuestion.getType());
resultMap.put("title", quesQuestion.getTitle());
resultMap.put("orderNumber", quesQuestion.getOrderNumber());
return resultMap;
}

 

菜单权限
@PreAuthorize("@pms.hasPermission('sys_dept_edit')")

and prcsTime!='0000-00-00 00:00:00'
//string转jsonobject 阿里转换
JSONObject jsonObject=new JSONObject();
jsonObject=JSONObject.parseObject(JSON.toJSONString(bean));
//string转list
List<GradeQuotaVO> quotaList=new ArrayList<>();
quotaList=JSONArray.parseArray(jsonObject.getJSONArray("quotaList").toJSONString(),GradeQuotaVO.class);

List<Integer> dataType = StringUtils.isNotBlank(quotaLibrary.getDataType()) ? JSONArray.parseArray(quotaLibrary.getDataType(), Integer.TYPE) : new ArrayList<>();

hutool转换jsonobject
String jsonStr = "{\"b\":\"value2\",\"c\":\"value3\",\"a\":\"value1\"}";
//方法一：使用工具类转换
JSONObject jsonObject = JSONUtil.parseObj(jsonStr);
//方法二：new的方式转换
JSONObject jsonObject2 = new JSONObject(jsonStr);
//对象转换成json字符串
JSONUtil.toJsonStr()

//如果我们想获得格式化后的JSON
JSONUtil.toJsonPrettyStr(sortedMap);
//JSON字符串解析
String html = "{\"name\":\"Something must have been changed since you leave\"}";
JSONObject jsonObject = JSONUtil.parseObj(html);
jsonObject.getStr("name");
//XML字符串转换为JSON
String s = "<sfzh>123</sfzh><sfz>456</sfz><name>aa</name><gender>1</gender>";
JSONObject json = JSONUtil.parseFromXml(s);

json.get("sfzh");
json.get("name");
Copy to clipboardErrorCopied
//JSON转换为XML
final JSONObject put = JSONUtil.createObj()
.set("aaa", "你好")
.set("键2", "test");

// <aaa>你好</aaa><键2>test</键2>
final String s = JSONUtil.toXmlStr(put);
Copy to clipboardErrorCopied
//hutool转list
List<GradeInterfaceItem> interfaceItem = JSONUtil.toList(jsonArray.getJSONObject(i).getJSONArray("interfaceItem"), GradeInterfaceItem.class);
JSONUtil.toList(JSONUtil.parseArray(fmt),String.class)

// String转Integer和数据库id类型匹配，数据库in才会走索引
List<Integer> ids = list1.stream().filter(StrUtil::isNotBlank).mapToInt(Integer::valueOf).boxed().distinct().collect(Collectors.toList());
dataBases.stream().filter(StrUtil::isNotBlank).forEach(names -> dataBaseList.addAll(Arrays.asList(names.split(","))));

//JSON转Bean
我们先定义两个较为复杂的Bean（包含泛型）

@Data
public class ADT {
private List<String> BookingCode;
}

@Data
public class Price {
private List<List<ADT>> ADT;
}
Copy to clipboardErrorCopied
String json = "{\"ADT\":[[{\"BookingCode\":[\"N\",\"N\"]}]]}";

Price price = JSONUtil.toBean(json, Price.class);

//
price.getADT().get(0).get(0).getBookingCode().get(0);

SysDept sysDept = new SysDept();
BeanUtils.copyProperties(dept, sysDept);

//判断是否为空
ObjectUtil.isNotNull
//判断集合是否为空
CollUtil.isNotEmpty()

 

List<GradeInterfaceDTO> dtoList = new ArrayList<>();
list=new GradeInterface().selectList(queryWrapper);
if(list!=null&&!list.isEmpty()){
list.forEach(q -> {
//查询问题选项
GradeInterfaceDTO interfaceDTO = new GradeInterfaceDTO();
BeanUtils.copyProperties(q, interfaceDTO);
dtoList.add(interfaceDTO);
});
}
//去不掉的空格
str=str.trim().replaceAll("\\u00A0","");

 

handleChooseByLib() {
// // @ts-ignore
exportGradeSystem(this.row.form.id).then(data=> {
let balo = data.data;
let url = window.URL.createObjectURL(new Blob([balo]))
let link = document.createElement('a')
link.style.display = 'none'
link.href = url
const filename = decodeURI(data.headers['content-disposition'].split(';')[1].split('=')[1])
link.setAttribute('download', filename)
document.body.appendChild(link)
link.click()
});
},

if(CollUtil.isNotEmpty(quesAnswerList)){
如果曾经的数据都不需要的话，可以直接清空所有数据，并将自增字段恢复从1开始计数：

 

wrapper.apply("start_time <= '" + now + "' and '" + now + "' < end_time");

eq.last(" group by DATE_FORMAT(benchmark_date,'%Y-%m')");
QueryWrapper<AssessmentDeptTask> wrapper = new QueryWrapper<>();
LambdaQueryWrapper<QuesAnswer> wrapper = new LambdaQueryWrapper<>();
UpdateWrapper<QuesAnswer> uw = new UpdateWrapper<>();
uw.lambda().set(QuesAnswer::getDelFlag,1);
if(StringNullUtil.isNotBlankLong(String.valueOf(quesAnswer.getQuestionnaireId()))){
uw.lambda().eq(QuesAnswer::getId,quesAnswer.getQuestionnaireId());
// 转Set集合
Set<Integer> deptIds = records.stream().map(DnaDirResrc::getDeptId).collect(Collectors.toSet());
list转单个stirng数组
List<Long> oldIds = list.stream().map(QuesQuestionTask::getId).collect(Collectors.toList());
list转JSONARRAY
dnaAnswerList.stream().map(QuesAnswer::getContent).map(JSON::parseArray).toArray()
//?:0或1个, *:0或多个, +:1或多个
Boolean strResult = str.matches("^[-\\+]?([0-9]+\\.?)?[0-9]+$");
//获取最大的部门id
Integer parentId = deptAllList.stream().max(Comparator.comparing(SysDept::getParentId)).get().getParentId();
// 获取最大值
Optional<GradeQuota> userOp = gradeQuotaList.stream().max(Comparator.comparingInt(GradeQuota::getQuotaLevel));
gradeQuotaList.stream().filter(gradeQuota -> gradeQuota.getHasSon() == 0).map(GradeQuota::getId).collect(Collectors.toSet()));
tableData = tableData.stream().sorted(Comparator.comparing(jsonObject -> StringNullUtil.isNotBlank((jsonObject).getString("id1Sort"))?(jsonObject).getInteger("id1Sort"):0)).collect(Collectors.toList());

List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
tableData=tableData.stream().sorted(Comparator.comparing(jsonObject -> ((JSONObject) jsonObject).getInteger("id1"))).collect(Collectors.toList());

List<SysDept> deptAllList = deptMapper.selectList(Wrappers.<SysDept>query().lambda().eq(SysDept::getCityId,sysDept.getCityId()));
// 查询全部部门
// List<DeptTree> deptList = deptMapper.selectList(Wrappers.emptyWrapper()).stream().filter(dept -> dept.getDeptId().intValue() != dept.getParentId())
// .sorted(Comparator.comparingInt(SysDept::getSort)).map(dept -> {
// DeptTree node = new DeptTree();
// node.setId(dept.getDeptId());
// node.setParentId(dept.getParentId());
// node.setName(dept.getName());
// return node;
// }).collect(Collectors.toList());
// 权限内部门
List<DeptTree> collect = deptAllList.stream().filter(dept -> dept.getDeptId().intValue() != dept.getParentId())
.sorted(Comparator.comparingInt(SysDept::getSort)).map(dept -> {
DeptTree node = new DeptTree();
node.setId(dept.getDeptId());
node.setParentId(dept.getParentId());
node.setName(dept.getName());
return node;
}).collect(Collectors.toList());

//java8 filter 用法
1.输出符合表达式的每一个对象
employees.stream().filter(p -> p.getAge() > 21).forEach(System.out::println);
//输出每一个对象
1
2
2.返回一个符合表达式的集合
Stream<Person> personStream = collection.stream().filter(new Predicate<Person>() {
@Override
public boolean test(Person person) {
return "男".equals(person.getGender());//只保留男性
}
});
collection = personStream.collect(Collectors.toList());//将Stream转化为List
System.out.println(collection.toString());//查看结果

String str = Joiner.on(",").join(ids);

UpdateWrapper<GradeSystem> uw = new UpdateWrapper<GradeSystem>();
uw.lambda().set(GradeSystem::getDelFlag,1);
uw.lambda().in(GradeSystem::getId,ids);
this.update(uw);

int num=1;
if(list.size()>0){
// 获取最大值
Optional<GradeQuotaRuleCustom> gradeVersions = list.stream().max(Comparator.comparingDouble(GradeQuotaRuleCustom::getRuleSort));
GradeQuotaRuleCustom gq = gradeVersions.get();
num = gq.getRuleSort()+1;
}
前面有数据 后面为空

这是权限 加上注解后前端判断
@PreAuthorize("@pms.hasPermission('sys_user_del')")

如何控制菜单权限控制
在后台菜单管理中给指定菜单添加 按钮节点 需要指定 权限标志

例如： sys_file_add、sys_file_del、sys_file_edit
前端CRUD 会自定生成关联按钮，只需要在 computed 生命周期注入对应的权限标识。
若扩展菜单 （非增删改查），则使用vuex保存用户的权限信息，然后通过v-if 判断是否有权限，如果有权限就渲染这个dom元素。 例如:ext_btn

public void doGet(HttpServletRequest request, HttpServletResponse response)
15 throws ServletException, IOException {
16 /**
17 * 1.获得客户机信息
18 */
19 String requestUrl = request.getRequestURL().toString();//得到请求的URL地址
20 String requestUri = request.getRequestURI();//得到请求的资源
21 String queryString = request.getQueryString();//得到请求的URL地址中附带的参数
22 String remoteAddr = request.getRemoteAddr();//得到来访者的IP地址
23 String remoteHost = request.getRemoteHost();
24 int remotePort = request.getRemotePort();
25 String remoteUser = request.getRemoteUser();
26 String method = request.getMethod();//得到请求URL地址时使用的方法
27 String pathInfo = request.getPathInfo();
28 String localAddr = request.getLocalAddr();//获取WEB服务器的IP地址
29 String localName = request.getLocalName();//获取WEB服务器的主机名
30 response.setCharacterEncoding("UTF-8");//设置将字符以"UTF-8"编码输出到客户端浏览器
31 //通过设置响应头控制浏览器以UTF-8的编码显示数据，如果不加这句话，那么浏览器显示的将是乱码
32 response.setHeader("content-type", "text/html;charset=UTF-8");
33 PrintWriter out = response.getWriter();
!<%=AccountShiroUtil.getCurrentUser().getId()%>==scope.row.dutyPerson

@PostMapping("reset")
public R reset(@Valid @RequestBody DemResetSdeptVo demResetSdept) {

let mainOrgName = this.orgName(mainOrg);
if (mainOrgName.length > 5) {
return mainOrgName.slice(0,5) + '...'
}

UserVO user=com.gov.dna.common.util.shiro.ShiroUtils.getCurrentUser();
/*if(permissionScopeService.hasPermission(GovStringUtils.removeBothEndsComma(user.getRoles()),"/view/grade/quotaManage/index","100")){
if (temp.getId().equals(user.getMainOrg())) {
deptTableList.add(tempObj);
}
} else {
deptTableList.add(tempObj);
}*/

搜大数据
else if("1".equals(AccountShiroUtil.getCurrentUser().getAuditManagement())&&isSelect&&isPerson){
//管理员权限只有全部才能查他部门下的
if(o.getSearchScope()!=null&&o.getSearchScope().intValue()==0){

}else{
o.setDutyCompanys(companyService.companyChildren(AccountShiroUtil.getCurrentUser().getCompanyId()));
if(o.getSearchScope()!=null&&(o.getSearchScope().intValue()==3||o.getSearchScope().intValue()==2)){
o.setDutyPerson(String.valueOf(AccountShiroUtil.getCurrentUser().getId()));
}
}
}

-------------------------------------------------------导出--------------------------------------------------------
public void excelExportCardingDemand(SupDemandVO vo,HttpServletRequest request, HttpServletResponse response) {
String dataName = vo.getDataName();
String matterName = vo.getMatterName();
String basis = vo.getBasis();
Integer status = vo.getStatus();
Integer deptId = vo.getDeptId();
String demandType=vo.getDemandType();
Set<Integer> excelIds=vo.getExcelIds();
if(CollUtil.isEmpty(excelIds)){
excelIds=null;
}
List<SupDemandVO> list=baseMapper.getExcelCardingList(dataName, matterName, basis, status,deptId,demandType,excelIds,new DataScope());

ExcelWriter writer=ExcelUtil.getWriter(true);
StyleSet style = writer.getStyleSet();
style.setBorder(BorderStyle.THIN, IndexedColors.BLACK);
writer.merge(0, 1, 0, 0, "序号", true);
writer.merge(0, 0, 1, 9, "需求信息", true);
writer.merge(0, 0, 10, 18, "供给信息", true);
writer.merge(0, 0, 19, 21, "其他信息", true);
writer.merge(0, 1, 22, 22, "状态", true);
List<List<Object>> rows=new ArrayList<>();
if(CollUtil.isNotEmpty(list)){
Set<Integer> deptIds=new HashSet<>();
Set<Integer> cityIds=new HashSet<>();
list.forEach(x ->{
if(StrUtil.equals("1", x.getDemandKind())){
deptIds.add(NumberUtil.parseInt(x.getDataDeptId()));
}
deptIds.add(x.getDeptId());
cityIds.add(x.getCityId());
x.addItemNameConcat();
});
Map<Integer, String> deptMap=remoteDeptService.getDeptName(deptIds);
Map<Integer, String> cityMap=remoteCityService.getCityNames(cityIds);
List<String> types=new ArrayList<>();
types.add("DIGITAL_SOURCEUNIT_NATIONAL");
types.add("basis");
types.add("shareMode");
types.add("updateCycle");
Map<String, Map<String, String>> dictMap=remoteDictService.getDictItemLabels(types);
for(int i = 0;i<list.size();i++){
SupDemandVO demand=list.get(i);
List<Object> row=new ArrayList<>();
row.add(i+1);
row.add(cityMap.getOrDefault(demand.getCityId(), ""));
row.add(deptMap.getOrDefault(demand.getDeptId(), ""));
row.add(demand.getMatterName());
row.add(dictMap.get("basis").getOrDefault(demand.getBasis(), ""));
row.add(demand.getMatterMaterial());
row.add(isMap.getOrDefault(demand.getIsPlatefile(), "否"));
row.add(demand.getSystemName());
row.add(isMap.getOrDefault(demand.getIsShare(), "否"));
row.add(demand.getRejectReason());
if(StrUtil.equals("1", demand.getDemandKind())){
row.add(deptMap.getOrDefault(NumberUtil.parseInt(demand.getDataDeptId()), ""));
}else{
row.add(dictMap.get("DIGITAL_SOURCEUNIT_NATIONAL").getOrDefault(demand.getDataDeptId(), ""));
}
row.add(demand.getCatalogName());
row.add(demand.getItemNameConcat());
row.add(demand.getDataName());
row.add(demand.getDataSource());
row.add(isMap.getOrDefault(demand.getIsDuty(), "否"));
row.add( dictMap.get("shareMode").getOrDefault(demand.getShareMode(), ""));
row.add( dictMap.get("updateCycle").getOrDefault(demand.getUpdateCycle(), ""));
row.add(demand.getOtherCycle());
row.add(demand.getContacts());
row.add(demand.getContactNumber());
row.add(demand.getContactEmail());
row.add(statusMap.getOrDefault(demand.getStatus(), ""));
rows.add(row);
}
}
List<String> head=new ArrayList<>();
head.add("序号");
head.add("地区/部门");
head.add("需求单位/司局（数据使用部门）");
head.add("事项名称");
head.add("应用场景/相关依据");
head.add("事项材料名称");
head.add("是否需要版式文件");
head.add("用数系统名称");
head.add("是否已提交共享申请");
head.add("驳回理由");
head.add("数据提供单位");
head.add("目录名称");
head.add("信息项");
head.add("数据名称");
head.add("数据来源依据");
head.add("是否在共享责任清单中");
head.add("共享方式（调用方式/使用方式）");
head.add("更新周期");
head.add("其他更新周期");
head.add("联系人");
head.add("联系电话");
head.add("联系邮箱");
head.add("状态");
writer.setCurrentRow(1);
writer.writeHeadRow(head);
writer.write(rows, false);
try {
//response为HttpServletResponse对象
response.setContentType("application/vnd.ms-excel;charset=utf-8");
//test.xls是弹出下载对话框的文件名，不能为中文，中文请自行编码
response.setHeader("Content-Disposition","attachment;filename=test.xls");
ServletOutputStream out = response.getOutputStream();
writer.flush(out, true);
// 关闭writer，释放内存
writer.close();
//此处记得关闭输出Servlet流
IoUtil.close(out);
} catch (IOException e) {
e.printStackTrace();
}
}

 

 

 

//////其他导出

public void excelAllExport(HttpServletRequest request, HttpServletResponse response, Integer resultId,Integer projectId) {
ResultMain bean = this.baseMapper.selectById(resultId);
if (bean != null) {
String assessBody = bean.getAssessBody();
List<List<String>> rows = new ArrayList<>();

List<List<String>> rowIds = new ArrayList<>();
List<String> header = new ArrayList<>();
//表头
Map<Integer, List<String>> headerNameMap = new HashMap<>();
Map<Integer, List<String>> headerIdMap = new HashMap<>();

JSONObject gradeQuotaObject = gradeQuotaService.scoringTreeList(resultId,projectId);

List<JSONObject> gradeQuotaList = JSONUtil.toList(gradeQuotaObject.getJSONArray("tableData"), JSONObject.class);
Integer leve = gradeQuotaObject.getInt("leve");

List<String> headerLevelOneId = new ArrayList<>();
List<String> headerLevelOne = new ArrayList<>();
headerLevelOne.add("一级指标");
headerLevelOneId.add("一级指标");
headerNameMap.put(1, headerLevelOne);
headerIdMap.put(1, headerLevelOneId);
//二级表头
List<String> headerLevelTwoId = new ArrayList<>();
List<String> headerLevelTwo = new ArrayList<>();
headerLevelTwo.add("二级指标");
headerLevelTwoId.add("二级指标");
headerNameMap.put(2, headerLevelTwo);
headerIdMap.put(2, headerLevelTwoId);
//三级表头
List<String> headerLevelThreeId = new ArrayList<>();
List<String> headerLevelThree = new ArrayList<>();
headerLevelThree.add("三级指标");
headerLevelThreeId.add("三级指标");
headerNameMap.put(3, headerLevelThree);
headerIdMap.put(3, headerLevelThreeId);

//部门集合
Map<Integer, List<String>> deptNumMap = new HashMap<>();

ResultContent resultContent = new ResultContent();
resultContent.setResultId(resultId);
List<ResultContentVO> pageListSort = contentService.getPageListSort(resultContent, null, assessBody);

// 通过工具类创建writer
ExcelWriter writer = ExcelUtil.getWriter();
if(CollUtil.isNotEmpty(gradeQuotaList)){
int deptNum = 1;
for(JSONObject quotaObject:gradeQuotaList){
if(quotaObject != null){
//一级指标id
for (int i = 1; i <= leve; i++) {
if(StrUtil.isNotBlank(quotaObject.getStr("id"+i))){
headerIdMap.get(i).add(quotaObject.getStr("id"+i));
headerNameMap.get(i).add(quotaObject.getStr("name"+i));
}
}

if(CollUtil.isNotEmpty(pageListSort)){
for(int j = 0;j < pageListSort.size();j++){
//第一次先增对象名称
if(deptNum == 1){
List<String> deptStringList = new ArrayList<>();
if(StrUtil.equals(assessBody, "1")){
deptStringList.add(pageListSort.get(j).getUserName());
}else{
deptStringList.add(pageListSort.get(j).getDeptName());
}
deptNumMap.put(j+1, deptStringList);
}
List<String> deptStringList = deptNumMap.get(j+1);
if(CollUtil.isEmpty(deptStringList)){
deptStringList = new ArrayList<>();
}
String content = pageListSort.get(j).getContent();
JSONObject jsonData = new JSONObject();
if(StrUtil.isNotBlank(content)){
jsonData = JSONUtil.parseObj(content);
}
String dataStr = jsonData.getStr(quotaObject.getStr("fieldUuid"));
//判断是否为数字类型
if(StrUtil.isNotBlank(dataStr) && dataStr.matches("^[-\\+]?([0-9]+\\.?)?[0-9]+$")){
BigDecimal bg = new BigDecimal(dataStr).setScale(2, BigDecimal.ROUND_HALF_UP);
deptStringList.add(String.valueOf(bg.doubleValue()));
}else{
deptStringList.add("");
}
}
}
}
deptNum++;
}

}

rows.add(headerLevelOne);
rowIds.add(headerLevelOneId);

rows.add(headerLevelTwo);
rowIds.add(headerLevelTwoId);

rows.add(headerLevelThree);

if(deptNumMap != null && !deptNumMap.isEmpty()){
for(Integer integer:deptNumMap.keySet()){
rows.add(deptNumMap.get(integer));
}

}
//合并单元格
if(CollUtil.isNotEmpty(rowIds)){
for (int i = 0; i < rowIds.size(); i++) {
List<String> stringList = rowIds.get(i);
//合并列的值
int firstColum = 0;
//上一列的值
int firstColumLast = 0;
String firstColumName = "";
String firstColumIdName = "";

for(int y = 0;y<stringList.size();y++){
//最后一列之前合并
if(StrUtil.isNotBlank(firstColumIdName)&&!StrUtil.equals(firstColumIdName,stringList.get(y))){
if(firstColumLast-firstColum>0){
writer.merge(i, i, firstColum, firstColumLast, firstColumName, false);
}
firstColum = y;
}else if(y == stringList.size()-1&&StrUtil.equals(firstColumIdName,stringList.get(y))){
//处理最后一列合并
if(firstColumLast-firstColum>0){
writer.merge(i, i, firstColum, y, firstColumName, false);
}
}

firstColumLast = y;
firstColumIdName = stringList.get(y);
firstColumName = rows.get(i).get(y);

}
}
}

 

// 一次性写出内容，强制输出标题
writer.write(rows, true);

//三级表头
List<String> styleList = new ArrayList<>();
if(CollUtil.isNotEmpty(headerLevelThree)&&headerLevelThree.size()>1){
styleList = headerLevelThree;
}else if(CollUtil.isNotEmpty(headerLevelTwo)&&headerLevelTwo.size()>1){
styleList = headerLevelTwo;
}else if(CollUtil.isNotEmpty(headerLevelOne)&&headerLevelOne.size()>1){
styleList = headerLevelOne;
}

for(int y = 0;y<3;y++){
////设置行高
writer.setRowHeight(y,30);
for(int x=0;x<styleList.size();x++){
CellStyle cellStyle = writer.createCellStyle();
Font font = writer.createFont();
font.setBold(Boolean.TRUE);
font.setFontName("宋体");
font.setFontHeightInPoints((short)11);
cellStyle.setFont(font);
HSSFWorkbook hssfworkbook = (HSSFWorkbook) writer.getWorkbook();

HSSFPalette palette = hssfworkbook.getCustomPalette();

//把预填充的HSSFColor.HSSFColorPredefined.LIME.getIndex()替换为期望RGB颜色
if(x == 0){
//预定义填充样式
cellStyle.setFillForegroundColor(HSSFColor.HSSFColorPredefined.GREY_25_PERCENT.getIndex());
//拿到palette颜色板
palette.setColorAtIndex(HSSFColor.HSSFColorPredefined.GREY_25_PERCENT.getIndex(), (byte) 231, (byte) 230, (byte) 230);
}else{
//预定义填充样式
cellStyle.setFillForegroundColor(HSSFColor.HSSFColorPredefined.LIME.getIndex());
//拿到palette颜色板
palette.setColorAtIndex(HSSFColor.HSSFColorPredefined.LIME.getIndex(), (byte) 217, (byte) 225, (byte) 242);
}
cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
// 设置底边框;
cellStyle.setBorderBottom(BorderStyle.THIN);
// 设置底边框颜色;
cellStyle.setBottomBorderColor(IndexedColors.BLACK.getIndex());
// 设置左边框;
cellStyle.setBorderLeft(BorderStyle.THIN);
// 设置左边框颜色;
cellStyle.setLeftBorderColor(IndexedColors.BLACK.getIndex());
// 设置右边框;
cellStyle.setBorderRight(BorderStyle.THIN);
// 设置右边框颜色;
cellStyle.setRightBorderColor(IndexedColors.BLACK.getIndex());
// 设置顶边框;
cellStyle.setBorderTop(BorderStyle.THIN);
// 设置顶边框颜色;
cellStyle.setTopBorderColor(IndexedColors.BLACK.getIndex());

// 设置垂直对齐的样式为居中对齐;
cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
if(y==2){
//设置列宽
if(StrUtil.isNotBlank(headerLevelOne.get(x))){
if(x == 0){
writer.setColumnWidth(x,headerLevelOne.get(x).length()+20);
}else{
writer.setColumnWidth(x,headerLevelOne.get(x).length()*2);
}

}
}
if(x == 0){
// 设置水平对齐的样式为左对齐;
cellStyle.setAlignment(HorizontalAlignment.LEFT);
}else{
// 设置水平对齐的样式为居中对齐;
cellStyle.setAlignment(HorizontalAlignment.CENTER);
}
writer.setStyle(cellStyle,x,y);
}

}

 

 

StyleSet style = writer.getStyleSet();
style.setBorder(BorderStyle.THIN, IndexedColors.BLACK);
try {
// response为HttpServletResponse对象
response.setContentType("application/vnd.ms-excel;charset=utf-8");
// test.xls是弹出下载对话框的文件名，不能为中文，中文请自行编码
response.setHeader("Content-Disposition", "attachment;filename="+bean.getResultName()+".xls");
ServletOutputStream out = response.getOutputStream();
writer.flush(out, true);
// 关闭writer，释放内存
writer.close();
// 此处记得关闭输出Servlet流
IoUtil.close(out);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

 

----------------------------------------导出2---------------------
public void excelExportConfirmed(HttpServletRequest request, HttpServletResponse response,@RequestBody CatalogDataDTO o){
Page<CatalogData> page=new Page<>();
if(o.getCurrent()!=null){
page.setCurrent(o.getCurrent());
}
if(o.getSize()!=null){
page.setSize(o.getSize());
}
QueryWrapper<CatalogData> query = Wrappers.query(o);
List<Long> excelIds=o.getExcelIds();
if(CollUtil.isNotEmpty(excelIds)){
query.lambda().in(CatalogData::getCataId, excelIds);
}
query.lambda().select(CatalogData::getCataId);
query.lambda().orderByDesc(CatalogData::getUpdateTime);
DataScope dataScope = new DataScope();
dataScope.setScopeName("provider_id");
List<CatalogData> list=catalogDataMapper.selectPage(page, query,dataScope).getRecords();
if (CollUtil.isNotEmpty(list)) {
ExcelWriter writer=ExcelUtil.getWriter(true);
StyleSet style = writer.getStyleSet();
style.setBorder(BorderStyle.THIN, IndexedColors.BLACK);
List<String> header = new ArrayList<>();
header.add("目录编码");
header.add("目录类型");
header.add("办理事项产生的结果名称/政务数据目录名称");
header.add("是否电子证照");
header.add("目录来源系统");
header.add("政务数据提供方");
header.add("提供方代码");
header.add("行政区划编码");
header.add("政务服务数据摘要");
header.add("应用场景");
header.add("其他应用场景描述");
header.add("提供渠道");
header.add("所属领域");
header.add("其他所属领域");
header.add("更新周期");
header.add("其他更新周期");
header.add("是否已注册数据资源");
header.add("数据资源所注册的平台");
header.add("目录发布日期");
header.add("目录状态");
header.add("目录来源");
header.add("信息项名称");
header.add("英文名称");
header.add("数据类型");
header.add("数据敏感级别");
header.add("来源系统名称");
header.add("共享类型");
header.add("不予共享原因");
header.add("共享条件");
header.add("开放属性");
header.add("开放条件");
header.add("数据长度");
header.add("是否字典项");
header.add("是否可为空");
header.add("是否主键");
header.add("是否归集");
header.add("来源");
writer.writeHeadRow(header);

//获取字典项
List<String> listDictType = Arrays.asList("YES_NO", "CATA_LOG_TYPE", "CATA_CHANNEL", "CATA_UPDATE_TIME", "CATA_SENCE ", "CATA_SOURCE", "CATA_STATUS",
"CATA_FIELD","INFO_LEVEL","INFO_SHARE_TYPE","INFO_OPEN_OPTION","CATALOG_AUDIT_STATUS","INFORMATION_ITEM_TYPE","UN_RANGE");
Map<String, Map<String, String>> mapDictItemLabels = remoteDictService.getDictItemLabels(listDictType);

List<List<String>> rows = new ArrayList<>();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
for (CatalogData c:list) {
c=catalogDataService.getDetail(c.getCataId());
List<CatalogItem> itemList=c.getItemList();
if(CollUtil.isNotEmpty(itemList)){
for(CatalogItem i:itemList){
List<String> content = new ArrayList<>();
content.add(c.getCataCode());
content.add(mapDictItemLabels.getOrDefault("CATA_LOG_TYPE", new HashMap<>(1)).getOrDefault(c.getCataType(), ""));
content.add(c.getResultsName());
content.add(mapDictItemLabels.getOrDefault("YES_NO", new HashMap<>(1)).getOrDefault(c.getIsLicense(), ""));
if(CollUtil.isNotEmpty(c.getSysList())){
List<String> names = c.getSysList().stream().map(x ->x.getName()).collect(Collectors.toList());
content.add(StrUtil.join("|", names));
}else{
content.add("");
}
content.add(c.getProviderName());
content.add(c.getProviderCode());
content.add(c.getProviderCityCode());
content.add(c.getNote());
content.add(mapDictItemLabels.getOrDefault("CATA_SENCE", new HashMap<>(1)).getOrDefault(c.getScene(), ""));
content.add(c.getSceneDesc());
content.add(mapDictItemLabels.getOrDefault("CATA_CHANNEL", new HashMap<>(1)).getOrDefault(c.getDitch(), ""));
content.add(mapDictItemLabels.getOrDefault("CATA_FIELD", new HashMap<>(1)).getOrDefault(c.getTerritory(), ""));
content.add(c.getTerritoryDesc());
content.add(mapDictItemLabels.getOrDefault("CATA_UPDATE_TIME", new HashMap<>(1)).getOrDefault(c.getPeriod(), ""));
content.add(c.getPeriodDesc());
content.add(mapDictItemLabels.getOrDefault("YES_NO", new HashMap<>(1)).getOrDefault(c.getIsResRegistered(), ""));
content.add(c.getResPlatform());
if(c.getPublishedTime()!=null){
content.add(c.getPublishedTime().format(dtf));
}else{
content.add("");
}
content.add(mapDictItemLabels.getOrDefault("CATA_STATUS", new HashMap<>(1)).getOrDefault(c.getStatus(), ""));
content.add(mapDictItemLabels.getOrDefault("CATA_SOURCE", new HashMap<>(1)).getOrDefault(c.getSourceType(), ""));
//------------信息项--------------------
content.add(i.getNameCn());
content.add(i.getNameEn());
content.add(mapDictItemLabels.getOrDefault("INFORMATION_ITEM_TYPE", new HashMap<>(1)).getOrDefault(i.getDataFormat(), ""));
content.add(mapDictItemLabels.getOrDefault("INFO_LEVEL", new HashMap<>(1)).getOrDefault(i.getSensitiveLevel(), ""));
content.add(i.getSystemName());
content.add(mapDictItemLabels.getOrDefault("INFO_SHARE_TYPE", new HashMap<>(1)).getOrDefault(i.getShareConditionType(), ""));
content.add(i.getShareConditionReason());
content.add(i.getShareCondition());
content.add(mapDictItemLabels.getOrDefault("INFO_OPEN_OPTION ", new HashMap<>(1)).getOrDefault(i.getIsOpen(), ""));
content.add(i.getOpenCond());
content.add(i.getDataLength());
content.add(mapDictItemLabels.getOrDefault("YES_NO ", new HashMap<>(1)).getOrDefault(i.getIsDict(), ""));
content.add(mapDictItemLabels.getOrDefault("YES_NO ", new HashMap<>(1)).getOrDefault(i.getIsNull(), ""));
content.add(mapDictItemLabels.getOrDefault("YES_NO ", new HashMap<>(1)).getOrDefault(i.getIsPk(), ""));
content.add(mapDictItemLabels.getOrDefault("YES_NO ", new HashMap<>(1)).getOrDefault(i.getIsCollect(), ""));
content.add(mapDictItemLabels.getOrDefault("CATA_SOURCE ", new HashMap<>(1)).getOrDefault(i.getSourceType(), ""));
rows.add(content);
}
}else{
List<String> content = new ArrayList<>();
content.add(c.getCataCode());
content.add(mapDictItemLabels.getOrDefault("CATA_LOG_TYPE", new HashMap<>(1)).getOrDefault(c.getCataType(), ""));
content.add(c.getResultsName());
content.add(mapDictItemLabels.getOrDefault("YES_NO", new HashMap<>(1)).getOrDefault(c.getIsLicense(), ""));
if(CollUtil.isNotEmpty(c.getSysList())){
List<String> names = c.getSysList().stream().map(x ->x.getName()).collect(Collectors.toList());
content.add(StrUtil.join("|", names));
}else{
content.add("");
}
content.add(c.getProviderName());
content.add(c.getProviderCode());
content.add(c.getProviderCityCode());
content.add(c.getNote());
content.add(mapDictItemLabels.getOrDefault("CATA_SENCE", new HashMap<>(1)).getOrDefault(c.getScene(), ""));
content.add(c.getSceneDesc());
content.add(mapDictItemLabels.getOrDefault("CATA_CHANNEL", new HashMap<>(1)).getOrDefault(c.getDitch(), ""));
content.add(mapDictItemLabels.getOrDefault("CATA_FIELD", new HashMap<>(1)).getOrDefault(c.getTerritory(), ""));
content.add(c.getTerritoryDesc());
content.add(mapDictItemLabels.getOrDefault("CATA_UPDATE_TIME", new HashMap<>(1)).getOrDefault(c.getPeriod(), ""));
content.add(c.getPeriodDesc());
content.add(mapDictItemLabels.getOrDefault("YES_NO", new HashMap<>(1)).getOrDefault(c.getIsResRegistered(), ""));
content.add(c.getResPlatform());
if(c.getPublishedTime()!=null){
content.add(c.getPublishedTime().format(dtf));
}else{
content.add("");
}
content.add(mapDictItemLabels.getOrDefault("CATA_STATUS", new HashMap<>(1)).getOrDefault(c.getStatus(), ""));
content.add(mapDictItemLabels.getOrDefault("CATA_SOURCE", new HashMap<>(1)).getOrDefault(c.getSourceType(), ""));
rows.add(content);
}
}
writer.write(rows, false);
try {
// response为HttpServletResponse对象
response.setContentType("application/vnd.ms-excel;charset=utf-8");
// test.xls是弹出下载对话框的文件名，不能为中文，中文请自行编码
response.setHeader("Content-Disposition", "attachment;filename=export.xls");
ServletOutputStream out = response.getOutputStream();
writer.flush(out, true);
// 关闭writer，释放内存
writer.close();
// 此处记得关闭输出Servlet流
IoUtil.close(out);
} catch (IOException e) {
e.printStackTrace();
}
}
}