具体安装参考：hotswap-agent-intellij-plugin。

安装好 DCEVM 之后，选在去 idea 中下载 HotSwapAgent 插件方式安装，而不必使用下载 hotswap-agent.jar 安装的方式。

安装好 HotSwapAgent 插件之后，按照文中的方式去配置，然后启动项目即可。

当修改了代码，然后重新编译（Ctrl+Shift+F9/Ctrl+F9）项目就可以使修改生效。

kompasim/atom-plugins

some awesome atom-plugins !

一般来说，Comparable 是为了对某个类的集合进行排序，所以此时一般都是这个需要排序的类本身去实现 Comparable 接口。换句话说，如果某个类实现了 Comparable 接口，那么这个类的数组或者说 List 就可以进行排序了。很多时候我们无法对类进行修改，或者说此类修改的成本太高，但是又希望对其进行排序。那怎么办？这个时候 Comparator 接口就排上了用场。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public final class Employee  {

    private String name;
    private int salary;

    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "name is: " + name + ", salary is: " + salary;
    }

    // ...此处省略 get/set
}

Employee 类没有实现 Comparable 接口，并且加上了 final 关键字，但是还是需要对其排序，怎么办？

创建 Optional 对象

of()

为非 null 的值创建一个 Optional。

of 方法通过工厂方法创建 Optional 类。需要注意的是，创建对象时传入的参数不能为 null。如果传入参数为 null，则抛出 NullPointerException。

1
2
3
4
5

// 调用工厂方法创建 Optional 实例
Optional<String> name = Optional.of("Java8");

// 传入参数为 null，抛出 NullPointerException.
Optional<String> name = Optional.of(null);

ofNullable()

为指定的值创建一个 Optional，如果指定的值为 null，则返回一个空的 (empty)Optional。

ofNullable 与 of 方法相似，唯一的区别是可以接受参数为 null 的情况。示例如下：

1
2

// 下面创建了一个不包含任何值的 Optional 实例
Optional empty = Optional.ofNullable(null);

查询 SQL SERVER 中某张表的表结构，sql 语句如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

SELECT
	tb.name AS tableName,
	col.name AS columnName,
	col.max_length AS length,
	col.is_nullable AS isNullable,
	t.name AS type,
	(
	SELECT
		TOP 1 ind.is_primary_key
	FROM
		sys.index_columns ic
		LEFT JOIN sys.indexes ind ON ic.object_id = ind.object_id AND ic.index_id= ind.index_id AND ind.name LIKE 'PK_%'
	WHERE
		ic.object_id = tb.object_id AND ic.column_id= col.column_id
	) AS isPrimaryKey,
	com.value AS comment
FROM
	sys.TABLES tb
	INNER JOIN sys.columns col ON col.object_id = tb.object_id
	LEFT JOIN sys.types t ON t.user_type_id = col.user_type_id
	LEFT JOIN sys.extended_properties com ON com.major_id = col.object_id
	AND com.minor_id = col.column_id
WHERE
	tb.name = '表名'

该 sql 可以正常执行，但是当把 sql 放到 jdbcTemplate 中执行时报一下错误：

1

Caused by: com.microsoft.sqlserver.jdbc.SQLServerException: The "variant" data type is not supported.

项目中有个查询使用了很多 left join 语句，查询出来的总记录数有二十几万条，而每次查询时就只要查询某一天的数据，及时这样分页查询时依旧很慢。
优化时把条件一个一个删掉，发现日期条件比较那里消耗了很多时间。sql 里面的日期比较是使用大小比较的，改成 DATEDIFF 函数后速度明显提升了。

项目查询时使用的是 Spring-Data-JPA Criteria，其中 DATEDIFF 查询代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

Specification<Xxx> specification = (root, query, cb) -> {
    List<Predicate> predicates = new ArrayList<>();
    ...
    Expression<String> day = new MyFunctionExpression(null, String.class, "DAY");
    Expression<Integer> diff = cb.function("DATEDIFF", Integer.class, day, cb.literal(paramDTO.getReportDate()), root.get("createdDate"));
    predicates.add(cb.equal(diff, 0));
    ...
    if (predicates.size() > 0) {
        Predicate[] pre = new Predicate[predicates.size()];
        return query.where(predicates.toArray(pre)).getRestriction();
    }
    return null;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import org.hibernate.query.criteria.internal.CriteriaBuilderImpl;
import org.hibernate.query.criteria.internal.compile.RenderingContext;
import org.hibernate.query.criteria.internal.expression.function.BasicFunctionExpression;

public class MyFunctionExpression extends BasicFunctionExpression {
    public MyFunctionExpression(CriteriaBuilderImpl criteriaBuilder, Class javaType, String functionName) {
        super(criteriaBuilder, javaType, functionName);
    }

    @Override
    public String render(RenderingContext renderingContext) {
        return getFunctionName();
    }

}

刚开始参考网上写成：

1
2
3

Expression<String> day = cb.literal("day");
Expression<Integer> diff = cb.function("DATEDIFF", Integer.class, day, cb.literal(paramDTO.getReportDate()), root.get("createdDate"));
predicates.add(cb.equal(diff, 0));

运行时会报：

1

为 datediff 指定的参数 1 无效。

原因是上面的写法，sql 解析时会把 "day" 字符串放到 DATEDIFF 函数的第一个参数位置上，即 DATEDIFF(‘day’, x, y)，而不是 DATEDIFF(day, x, y) 这种形式。

Redis 常用命令

• redis-cli -h localhost -p 6379 [-a 密码] : 连接 Redis 服务器。

• keys * ：查询所有缓存键。

• keys pattern : 根据 pattern 筛选出所有符合的缓存键。

  1	keys *pattern*

• flushall : 清空所有缓存。

• 删除指定 key 的缓存

  1

  del key

• 删除模糊匹配 key 的缓存

  使用 lua 脚本:

  1 2 3 4 5 6 7

  eval "redis.call('del',unpack(redis.call('keys','*pattern*')))" 0 或 eval "return redis.call('del', unpack(redis.call('keys', ARGV[1])))" 0 *pattern* 或 eval "for _,k in ipairs(redis.call('keys','*pattern*')) do redis.call('del',k) end" 0 或 eval "for _,k in ipairs(redis.call('keys',KEYS[1])) do redis.call('del',k) end" 1 "*pattern*"

  Redis 3.2 – Query Keys and Delete Caches by Key Prefix/Pattern

  使用 shell 命令：

  1	redis-cli KEYS "*pattern*" | xargs redis-cli DEL

• databases 16 : 配置数据库总数。

• select db_index : 切换数据库。

  1

  select 1

将 Java 对象序列化为二进制文件的 Java 序列化技术是 Java 系列技术中一个较为重要的技术点，在大部分情况下，开发人员只需要了解被序列化的类需要实现 Serializable 接口，使用 ObjectInputStream 和 ObjectOutputStream 进行对象的读写。然而在有些情况下，光知道这些还远远不够，文章列举了笔者遇到的一些真实情境，它们与 Java 序列化相关，通过分析情境出现的原因，使读者轻松牢记 Java 序列化中的一些高级认识。

本文将逐一的介绍几个情境，顺序如下面的列表。

序列化 ID 的问题
静态变量序列化
父类的序列化与 Transient 关键字
对敏感字段加密
序列化存储规则

从几种现象，理解缓存与快照的运行机制

//@1 缓存与快照机制

hibernate通过缓存和快照机制，实现对修改内容批量提交。
当查询DB时，会将数据保存到session缓存中，同时在内存中存储一份快照副本。
当我修改数据时，其实修改的是session缓存中的实体内容，并不立即提交DB执行。
当我们主动flush或提交事物时，会对比session缓存与快照中的内容是否一致，将不一致的内容更新到DB中。

Hibernate 缓存机制

什么是缓存？

　　缓存是介于应用程序和物理数据源之间，其作用是为了降低应用程序对物理数据源访问的频次，从而提高了应用的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。　

缓存有什么好处？

　　缓存的好处是降低了数据库的访问次数，提高应用性能，减少了读写数据的时间。

什么时候适合用缓存？

　　程序中经常用到一些不变的数据内容，从数据库查出来以后不会去经常修改它而又经常要用到的就可以考虑做一个缓存，以后读取就从缓存来读取，而不必每次都去查询数据库。因为硬盘的速度比内存的速度慢的多。从而提高了程序的性能，缓存的出现就会为了解决这个问题。

Hibernate中的缓存包括一级缓存（Session缓存）、二级缓存（SessionFactory缓存）和查询缓存。