Map之一个Key存多个Value的MultiValueMap(一个键多个值) java Stream的Collectors.groupingBy分组后的排序问题 mysql的group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])使用 大数据报表查询-文章传送们 Spring异步方法注解 @Async,@Async标记的方法，可返回AsyncResult结果 RabbitMQ中的basicNack、basicReject都是拒绝一条消息，有啥区别？ Maven的optional的作用 Maven的scope属性 left关联的on后面跟条件与where跟条件的区别 INSERT-ON-DUPLICATE-KEY-UPDATE有可能锁表慎用 ThreadLocal可能引起的内存泄露的一些知识 怎么验数据一致性 maven指定setting.xml配置文件 mvn设置打特定的包 nginx使用reload配置无效(缓存大小) java8两个List集合取交集、并集、差集、去重并集
— Redis 批量删除Redis的key 正则匹配删除
Map之一个Key存多个Value的MultiValueMap(一个键多个值) MultiValueMap<String, String> stringMultiValueMap = new LinkedMultiValueMap<>();
// 添加Key为name的
stringMultiValueMap.add("name", "yolanda");
stringMultiValueMap.add("name", "yanzhenjie");
java Stream的Collectors.groupingBy分组后的排序问题 private List<ExportAllOrder> constructDetailData(List<ExportAllOrder> listOrder) {
final Map<Long, OrderAllGoodsSpecVo> integerOrderAllGoodsSpecVoMap = orderMapper.listAllBossOrderGoodsSpec();
List<ExportAllOrder> groupList = new ArrayList<ExportAllOrder>();
//主要看下面这一行，设置LinkedHashMap（有序的map），不在使用默认的HashMap（无序）
listOrder.stream().collect(Collectors.groupingBy(ExportAllOrder::getOrderCode, LinkedHashMap::new, Collectors.toList())).forEach((orderCode, orderListByorderCode) -> {
final int[] i = {0};
orderListByorderCode.stream().forEach(o -> {
//保留父订单的数据，清空子订单数据
if (i[0] != 0) {
o.setOrderCode("");
o.setCustomerNickName("");
o.setShippingPerson("");
o.setShippingPhone("");
o.setShippingMobile("");
o.setShippingProvince("");
o.setShippingCity("");
o.setShippingCounty("");
o.setShippingAddress("");
o.setShippingPostcode("");
o.setExpressPrice(null);
o.setOrderPrice(null);
o.setCustomerRemark("");
o.setRemark("");
o.setOrderLinePay(null);
o.setInfoRealname("");
o.setWxNo("");
o.setOrderStatus("");
o.setOrderLinePayStr("");
o.setIsExamine("");
o.setAgainBuy("");
o.setBackOrderStatus("");
}
if (integerOrderAllGoodsSpecVoMap.containsKey(o.getGoodsInfoId())) {
o.setSpecInfo(integerOrderAllGoodsSpecVoMap.get(o.getGoodsInfoId()).getSpecInfo());
}
i[0]++;
groupList.add(o);
});
});
return groupList;
}
mysql的group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])使用 SELECT
goods_info.goods_info_id,
GROUP_CONCAT(goods_spec.spec_name,":",goods_info_rele_spec_detail.spec_value_remark) specInfo
FROM
np_goods_info goods_info
INNER JOIN np_goods goods ON goods_info.goods_id = goods.goods_id
INNER JOIN np_goods_info_rele_spec_detail goods_info_rele_spec_detail ON goods_info.goods_info_id = goods_info_rele_spec_detail.goods_info_id
INNER JOIN np_goods_spec goods_spec ON goods_info_rele_spec_detail.spec_id = goods_spec.spec_id
GROUP BY goods_info.goods_info_id;
大数据报表查询-文章传送们 - 先查询数据在处理数据，不要查询数据之后，数据不够时在处理数据中（循环中）再次查询
Spring异步方法注解 @Async,@Async标记的方法，可返回AsyncResult结果 @Component
public class AsyncTask {
@Async
public Future<String> exec() throws Exception{
System.out.println("准备睡觉" + System.currentTimeMillis());
Thread.sleep(10);
System.out.println("醒了");
return new AsyncResult<String>("有力气了");
}
}
public class AsyncTaskTest extends AbstractTest {
@Autowired
private AsyncTask asyncTask;
@Test
public void testExec() throws Exception {
String asyncResult1 = asyncTask.exec().get();
String asyncResult2 = asyncTask.exec().get();
String asyncResult3 = asyncTask.exec().get();
String asyncResult4 = asyncTask.exec().get(50, TimeUnit.MILLISECONDS);
String asyncResult5 = asyncTask.exec().get(50, TimeUnit.MILLISECONDS);
System.out.println("result1:" + asyncResult1);
System.out.println("result2:" + asyncResult2);
System.out.println("result3:" + asyncResult3);
System.out.println("result4:" + asyncResult4);
System.out.println("result5:" + asyncResult5);
}
}
准备睡觉1511883563474
醒了
准备睡觉1511883563487
醒了
准备睡觉1511883563498
醒了
准备睡觉1511883563510
醒了
准备睡觉1511883563521
醒了
result1:有力气了
result2:有力气了
result3:有力气了
result4:有力气了
result5:有力气了
RabbitMQ中的basicNack、basicReject都是拒绝一条消息，有啥区别？ basicReject一次只能拒绝接收一个消息，
而basicNack方法可以支持一次0个或多个消息的拒收，并且也可以设置是否requeue。
[Maven的optional的作用] <dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<!--optional为true的话作用是让新项目依赖本项目的时候，不去依赖此jar包，设置false，新项目就会能引用到此jar包-->
<optional>false</optional>
<scope>true</scope>
</dependency>
</dependencies>
[Maven的scope属性] * compile，缺省值，适用于所有阶段，会随着项目一起发布。 编译范围依赖在所有的classpath 中可用，同时它们也会被打包。
* provided，类似compile，期望JDK、容器或使用者会提供这个依赖。如servlet.jar。
例如:provided 依赖只有在当JDK 或者一个容器已提供该依赖之后才使用。例如， 如果你开发了一个web 应用，你可能在编译 classpath 中需要可用的Servlet API 来编译一个servlet，但是你不会想要在打包好的WAR 中包含这个Servlet API；这个Servlet API JAR 由你的应用服务器或者servlet 容器提供。已提供范围的依赖在编译classpath （不是运行时）可用。它们不是传递性的，也不会被打包。
* runtime，只在运行时使用，如JDBC驱动，适用运行和测试阶段。
例如:runtime 依赖在运行和测试系统的时候需要，但在编译的时候不需要。比如，你可能在编译的时候只需要JDBC API JAR，而只有在运行的时候才需要JDBC驱动实现。
* test，只在测试时使用，用于编译和运行测试代码。不会随项目发布。
例如:test范围依赖 在一般的编译和运行时都不需要，它们只有在测试编译和测试运行阶段可用。
* system，类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。
例如:system范围依赖与provided 类似，但是你必须显式的提供一个对于本地系统中JAR 文件的路径。这么做是为了允许基于本地对象编译，而这些对象是系统类库的一部分。这样的构件应该是一直可用的，Maven 也不会在仓库中去寻找它。如果你将一个依赖范围设置成系统范围，你必须同时提供一个 systemPath 元素。注意该范围是不推荐使用的（你应该一直尽量去从公共或定制的 Maven 仓库中引用依赖）。
[left关联的on后面跟条件与where跟条件的区别] left join中关于where和on条件的几个知识点：
1.多表left join是会生成一张临时表，并返回给用户
2.where条件是针对最后生成的这张临时表进行过滤，过滤掉不符合where条件的记录，是真正的不符合就过滤掉。
3.on条件是对left join的右表进行条件过滤，但依然返回左表的所有行，右表中没有的补为NULL
4.on条件中如果有对左表的限制条件，无论条件真假，依然返回左表的所有行,但是会影响右表的匹配值。也就是说on中左表的限制条件只影响右表的匹配内容，不影响返回行数。
结论：
1.where条件中对左表限制，不能放到on后面
2.where条件中对右表限制，放到on后面，会有数据行数差异，比原来行数要多
[INSERT-ON-DUPLICATE-KEY-UPDATE有可能锁表慎用] INSERT-ON-DUPLICATE-KEY-UPDATE有可能锁表慎用
[ThreadLocal可能引起的内存泄露的一些知识] 1:每个thread中都存在一个map, map的类型是ThreadLocal.ThreadLocalMap. Map中的key为一个threadlocal实例. 这个Map的确使用了弱引用,不过弱引用只是针对key. 每个key都弱引用指向threadlocal. 当把threadlocal实例置为null以后,没有任何强引用指向threadlocal实例,所以threadlocal将会被gc回收. 但是,我们的value却不能回收,因为存在一条从current thread连接过来的强引用. 只有当前thread结束以后, current thread就不会存在栈中,强引用断开, Current Thread, Map, value将全部被GC回收.
2:所以得出一个结论就是只要这个线程对象被gc回收，就不会出现内存泄露，但在threadLocal设为null和线程结束这段时间不会被回收的，就发生了我们认为的内存泄露。其实这是一个对概念理解的不一致，也没什么好争论的。最要命的是线程对象不被回收的情况，这就发生了真正意义上的内存泄露。比如使用线程池的时候，线程结束是不会销毁的，会再次使用的。就可能出现内存泄露。
3:Java为了最小化减少内存泄露的可能性和影响，在ThreadLocal的get,set的时候都会清除线程Map里所有key为null的value。所以最怕的情况就是，threadLocal对象设null了，开始发生“内存泄露”，然后使用线程池，这个线程结束，线程放回线程池中不销毁，这个线程一直不被使用，或者分配使用了又不再调用get,set方法，那么这个期间就会发生真正的内存泄露。
[怎么验数据一致性] 这里大概介绍一下吧，这篇的篇幅太长了，大家心里有底就行。
(1)先验数量是否一致，因为验数量比较快。
至于验具体的字段，有两种方法:
(2.1)有一种方法是，只验关键性的几个字段是否一致。
(2.2)还有一种是 ，一次取50条(不一定50条，具体自己定，我只是举例),然后像拼字符串一样，拼在一起。用md5进行加密，得到一串数值。新库一样如法炮制，也得到一串数值，比较两串数值是否一致。如果一致，继续比较下50条数据。如果发现不一致，用二分法确定不一致的数据在0-25条，还是26条-50条。以此类推，找出不一致的数据，进行记录即可。
[maven指定setting.xml配置文件] -s 是setting文件路径”
mvn -s "c://alimavensetting.xml" clean deploy -DskipTests
mvn设置打特定的包 penguin-support
penguin-support-business-log
penguin-support-cat
penguin-support-dynamic-datasource
penguin-support-lock
penguin-support-msg-notify
penguin-support-retry-rabbitmq
penguin-support-ssh
E:\MyWorkSpace\cloud\penguin-support>mvn clean install -pl penguin-support-msg-notify -am -DskipTests
[nginx使用reload配置无效(缓存大小)] 更开始配置的nginx的一些转发请求,然后一直没生效,使用nginx -t检测配置出现以下错误,或者也可以重启
[root@tjz-ecs sbin]# ./nginx -t
nginx: the configuration file /opt/tengine/conf/nginx.conf syntax is ok
nginx: [crit] ngx_slab_alloc() failed: no memory
nginx: [emerg] http upstream check_shm_size is too small, you should specify a larger size.
nginx: configuration file /opt/tengine/conf/nginx.conf test failed
显示: http upstream check_shm_size is too small, you should specify a larger size.
解决办法:
解决办法：在nginx.conf的http块中增加一条配置：
check_shm_size 50m;
故障原因未知，该参数设置的缓存大小，用于存储所有的后端服务器健康检查状态，Nginx默认是1m
网上有人说如果有1千台以上的服务器并在配置的时候出现了错误，才需要扩大该内存的大小，我后端服务器没超过20台...
java8两个List集合取交集、并集、差集、去重并集 public static void main(String[] args) {
List<String> list1 = new ArrayList<String>();
list1.add("1");
list1.add("2");
list1.add("3");
list1.add("5");
list1.add("6");
List<String> list2 = new ArrayList<String>();
list2.add("2");
list2.add("3");
list2.add("7");
list2.add("8");
// 交集
List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
System.out.println("---交集 intersection---");
intersection.parallelStream().forEach(System.out :: println);
// 差集 (list1 - list2)
List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
System.out.println("---差集 reduce1 (list1 - list2)---");
reduce1.parallelStream().forEach(System.out :: println);
// 差集 (list2 - list1)
List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
System.out.println("---差集 reduce2 (list2 - list1)---");
reduce2.parallelStream().forEach(System.out :: println);
// 并集
List<String> listAll = list1.parallelStream().collect(toList());
List<String> listAll2 = list2.parallelStream().collect(toList());
listAll.addAll(listAll2);
System.out.println("---并集 listAll---");
listAll.parallelStream().forEachOrdered(System.out :: println);
// 去重并集
List<String> listAllDistinct = listAll.stream().distinct().collect(toList());
System.out.println("---得到去重并集 listAllDistinct---");
listAllDistinct.parallelStream().forEachOrdered(System.out :: println);
System.out.println("---原来的List1---");
list1.parallelStream().forEachOrdered(System.out :: println);
System.out.println("---原来的List2---");
list2.parallelStream().forEachOrdered(System.out :: println);
}
1854
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
