Posted in 清文

为什么要看点正常的书

为什么要看点正常的书
因为两个人的时候
看书的时间就少了

为什么读书呢
这大家都至少读过
讲起来难为情
但要讲也不好讲

所以什么是正常的书
一本对你好的书

什么是一本对你好的书
和你那时候的心境有关
就想想吃什么去吃一样

读什么书
每本书不同时候
看会有不同的感触

但中国旧书
是经不起读的
英文好看看外籍
英文不好看看翻译好的
也不错

没有好书坏书
只有感觉看,又舍不得看完的书
只有感觉看,以后还可能在看的书

因为书中的句子、故事章节
让我思考
很多里面出来的 ideas
是遇到问题
遇到事
处理方式的演变

是自己与自己的沟通
所以要静下心来看

我没看过玄幻
我怕和吸毒一样上瘾
浮躁的时候是不能得到任何的

书中自有千钟粟
书中自有黄金屋
书中自有颜如玉

就是说
读书可以做官发财
读书可以不住茅房
读书可以娶得漂亮年轻妹子

就这样
520
你懂的

顺便撩下
关注的
2500 +
读者

遇见
快乐

Posted in Spring, Spring Boot, 技术

Spring Boot 整合 Elasticsearch,实现 function score query 权重分查询

摘要: 原创出处 www.bysocket.com 「泥瓦匠BYSocket 」欢迎转载,保留摘要,谢谢!

『 预见未来最好的方式就是亲手创造未来 – 《史蒂夫·乔布斯传》 』

运行环境:JDK 7 或 8,Maven 3.0+
技术栈:SpringBoot 1.5+,ElasticSearch 2.3.2

本文提纲
一、ES 的使用场景
二、运行 springboot-elasticsearch 工程
三、springboot-elasticsearch 工程代码详解

一、ES 的使用场景

简单说,ElasticSearch(简称 ES)是搜索引擎,是结构化数据的分布式搜索引擎。在《Elasticsearch 和插件 elasticsearch-head 安装详解》  和 《Elasticsearch 默认配置 IK 及 Java AnalyzeRequestBuilder 使用》 我详细的介绍了如何安装,初步使用了 IK 分词器。这里,我主要讲下 SpringBoot 工程中如何使用 ElasticSearch。

ES 的使用场景大致分为两块
1. 全文检索。加上分词(IK 是其中一个)、拼音插件等可以成为强大的全文搜索引擎。
2. 日志统计分析。可以实时动态分析海量日志数据。

二、运行 springboot-elasticsearch 工程

注意的是这里使用的是 ElasticSearch 2.3.2。是因为版本对应关系

Spring Boot Version (x) Spring Data Elasticsearch Version (y) Elasticsearch Version (z)
x <= 1.3.5 y <= 1.3.4 z <= 1.7.2* x >= 1.4.x 2.0.0 <=y < 5.0.0** 2.0.0 <= z < 5.0.0**
* - 只需要你修改下对应的 pom 文件版本号
** - 下一个 ES 的版本会有重大的更新

git clone 下载工程 springboot-elasticsearch ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example。

1. 后台起守护线程启动 Elasticsearch

cd elasticsearch-2.3.2/
./bin/elasticsearch -d

下面开始运行工程步骤(Quick Start):

2. 项目结构介绍

org.spring.springboot.controller - Controller 层
org.spring.springboot.repository - ES 数据操作层
org.spring.springboot.domain - 实体类
org.spring.springboot.service - ES 业务逻辑层
Application - 应用启动类
application.properties - 应用配置文件,应用启动会自动读取配置

本地启动的 ES ,就不需要改配置文件了。如果连测试 ES 服务地址,需要修改相应配置

3.编译工程
在项目根目录 springboot-elasticsearch,运行 maven 指令:

mvn clean install

4.运行工程
右键运行 Application 应用启动类(位置:/springboot-learning-example/springboot-elasticsearch/src/main/java/org/spring/springboot/Application.java)的 main 函数,这样就成功启动了 springboot-elasticsearch 案例。

用 Postman 工具新增两个城市
新增城市信息

POST http://127.0.0.1:8080/api/city
{
"id":"1",
"provinceid":"1",
"cityname":"温岭",
"description":"温岭是个好城市"
}

POST http://127.0.0.1:8080/api/city
{
"id":"2",
"provinceid":"2",
"cityname":"温州",
"description":"温州是个热城市"
}

可以打开 ES 可视化工具 head 插件:http://localhost:9200/_plugin/head/:
(如果不知道怎么安装,请查阅 《Elasticsearch 和插件 elasticsearch-head 安装详解》 。)
在「数据浏览」tab,可以查阅到 ES 中数据是否被插入,插入后的数据格式如下:

{
"_index": "cityindex",
"_type": "city",
"_id": "1",
"_version": 1,
"_score": 1,
"_source": {
"id": 1,
"provinceid": 1,
"cityname": "温岭",
"description": "温岭是个好城市"
}
}

下面验证下权重分查询搜索接口的实现:
GET http://localhost:8080/api/city/search?pageNumber=0&pageSize=10&searchContent=温岭
数据是会出现

[
{
"id": 1,
"provinceid": 1,
"cityname": "温岭",
"description": "温岭是个好城市"
},
{
"id": 2,
"provinceid": 2,
"cityname": "温州",
"description": "温州是个热城市"
}
]

从启动后台 Console 可以看出,打印出来对应的 DSL 语句:

{
"function_score" : {
"functions" : [ {
"filter" : {
"bool" : {
"should" : {
"match" : {
"cityname" : {
"query" : "温岭",
"type" : "boolean"
}
}
}
}
},
"weight" : 1000.0
}, {
"filter" : {
"bool" : {
"should" : {
"match" : {
"description" : {
"query" : "温岭",
"type" : "boolean"
}
}
}
}
},
"weight" : 100.0
} ]
}
}

为什么会出现 温州 城市呢?因为 function score query 权重分查询,无相关的数据默认分值为 1。如果想除去,设置一个 setMinScore 分值即可。

三、springboot-elasticsearch 工程代码详解

具体代码见 GitHubhttps://github.com/JeffLi1993/springboot-learning-example
1.pom.xml 依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>springboot</groupId>
    <artifactId>springboot-elasticsearch</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-elasticsearch :: 整合 Elasticsearch </name>

    <!-- Spring Boot 启动父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>

    <dependencies>

        <!-- Spring Boot Elasticsearch 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

        <!-- Spring Boot Web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- Junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

这里依赖的 spring-boot-starter-data-elasticsearch 版本是 1.5.1.RELEASE,对应的 spring-data-elasticsearch 版本是 2.1.0.RELEASE。后面数据操作层都是通过该 spring-data-elasticsearch 提供的接口实现。

操作对应官方文档:http://docs.spring.io/spring-data/elasticsearch/docs/2.1.0.RELEASE/reference/html/。

2. application.properties 配置 ES 地址

# ES
spring.data.elasticsearch.repositories.enabled = true
spring.data.elasticsearch.cluster-nodes = 127.0.0.1:9300

默认 9300 是 Java 客户端的端口。9200 是支持 Restful HTTP 的接口。
更多配置:

spring.data.elasticsearch.cluster-name Elasticsearch 集群名。(默认值: elasticsearch)
spring.data.elasticsearch.cluster-nodes 集群节点地址列表,用逗号分隔。如果没有指定,就启动一个客户端节点。
spring.data.elasticsearch.propertie 用来配置客户端的额外属性。
spring.data.elasticsearch.repositories.enabled 开启 Elasticsearch 仓库。(默认值:true。)

3. ES 数据操作层

@Repository
public interface CityRepository extends ElasticsearchRepository<City,Long> {


}

接口只要继承 ElasticsearchRepository 类即可。默认会提供很多实现,比如 CRUD 和搜索相关的实现。

4. 实体类

@Document(indexName = "cityindex", type = "city")
public class City implements Serializable{

    private static final long serialVersionUID = -1L;

    /**
     * 城市编号
     */
    private Long id;

    /**
     * 省份编号
     */
    private Long provinceid;

    /**
     * 城市名称
     */
    private String cityname;

    /**
     * 描述
     */
    private String description;
}

注意
index 配置必须是全部小写,不然会暴异常。
org.elasticsearch.indices.InvalidIndexNameException: Invalid index name [cityIndex], must be lowercase

5. ES 业务逻辑层

/**
 * 城市 ES 业务逻辑实现类
 *
 * Created by bysocket on 07/02/2017.
 */
@Service
public class CityESServiceImpl implements CityService {

    private static final Logger LOGGER = LoggerFactory.getLogger(CityESServiceImpl.class);

    @Autowired
    CityRepository cityRepository;

    @Override
    public Long saveCity(City city) {

        City cityResult = cityRepository.save(city);
        return cityResult.getId();
    }

    @Override
    public List<City> searchCity(Integer pageNumber,
                                 Integer pageSize,
                                 String searchContent) {
        // 分页参数
        Pageable pageable = new PageRequest(pageNumber, pageSize);

        // Function Score Query
        FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders.functionScoreQuery()
                .add(QueryBuilders.boolQuery().should(QueryBuilders.matchQuery("cityname", searchContent)),
                    ScoreFunctionBuilders.weightFactorFunction(1000))
                .add(QueryBuilders.boolQuery().should(QueryBuilders.matchQuery("description", searchContent)),
                        ScoreFunctionBuilders.weightFactorFunction(100));

        // 创建搜索 DSL 查询
        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withPageable(pageable)
                .withQuery(functionScoreQueryBuilder).build();

        LOGGER.info("\n searchCity(): searchContent [" + searchContent + "] \n DSL  = \n " + searchQuery.getQuery().toString());

        Page<City> searchPageResults = cityRepository.search(searchQuery);
        return searchPageResults.getContent();
    }

}

保存逻辑很简单。

分页 function score query 搜索逻辑如下:

先创建分页参数,然后用 FunctionScoreQueryBuilder 定义 Function Score Query,并设置对应字段的权重分值。城市名称 1000 分,description 100 分。
然后创建该搜索的 DSL 查询,并打印出来。

四、小结

实际场景还会很复杂。这里只是点睛之笔,后续大家优化或者更改下 DSL 语句就可以完成自己想要的搜索规则。

推荐:《Spring Boot 整合 Dubbo/ZooKeeper 详解 SOA 案例
上一篇:《Spring Boot 整合 Mybatis Annotation 注解案例

欢迎扫一扫我的公众号关注 — 及时得到博客订阅哦!
http://www.bysocket.com/
https://github.com/JeffLi1993

Posted in Machine Learning, 技术

带着问题学 Machine Learning:什么是机器学习

机器学习是个难以接受的东西。如果有案例就好了,那就 lets go~

Q:什么是机器学习?

机器学习就是让计算机有像人一样的学习能力的技术,是从数据中寻找有用的知识的数据挖掘技术。
比如呢?运用机器学习技术,类似今日头条给我推我喜欢看的,并看不完的短视频,(害得我卸载了…)。比如说,淘宝知道你喜欢的衣服款式,老是在猜你喜欢那里出现你喜欢的。

Q:那机器学习的数据种类不同吧?

是的,很不一样。根据所学习的数据种类,可以分为监督学习、无监督学习和强化学习等。

Q:什么是监督学习?

监督学习,就是计算机在有结果标记的数据学习后,能预测数据结果的学习过程。
比如,预测数值型数据的回归,预测标称型数据的分类等。太抽象了…
对应的比如,图像处理,垃圾邮件的分类和拦截等

Q:什么是无监督学习?

无监督学习,就是计算机在没有结果标志的数据学习后,能获取有用数据的学习过程。
自然还有个半监督学习,介于两者之间。
比如,预测肿瘤的良性恶性、视频分析等

Q:什么是强化学习?

强化学习,跟无监督学习类似,没有结果标志的数据学习后,又跟监督学习一样,能预测数据结果。
这个’四不像’,被认为人类的主要学习模式之一。
自然也很复杂,涉及到的算法很多。下面聊聊常见的算法。

Q:监督学习和无监督学习中有哪些典型的问题?

在机器学习中有很多典型的问题,比如回归、分类、异常检测、聚类和降维等。自然每个问题,延伸出就是算法,所以也有对应的算法。

Q:什么是回归问题?

回归,都对线性回归有印象吧。回归是数学模型,用于统计的一种方法。是对一组因变量 Yn 和另一组自变量 Xn 之间关系的统计分析。
比如记得以前用 SPSS 的时候,回归统计人的体表面积与身高、体重有关系。从案例看出,回归多半用在监督学习。

Q:什么是分类问题?

分类包括有监督分类和无监督分类。
有监督分类,就是大家一直知道的。术语表达,是指对于指定的模式进行识别的有监督识别问题。这类分类问题,也可以想回归问题那样,被看作是函数近似问题。对,在经过已知样本数据的训练,只能对未知样本估计分类,无法对分类近似分类。
无监督分类,没有任何先验条件,仅仅根据数据,(盲目)的分类。其分类结果肯定是不同纬度的分类,但不能确定分类的类别属性。

Q:什么是异常检测问题?

异常检测,简单说,就是从一堆数据中区分异常值和正常值。术语表达,对数据集中其他项目的项目、事件等识别。比如文本错误问题。

Q:什么是聚类问题?

聚类,和分类问题相似。但属于一种无监督学习。是把相似的样本分成不同的组别或者更多子集。关键词:相似,所以相同组别(子集)的样本具有相似的性质,不同组别(子集)的样本之间具有不同的性质。在聚类问题中,如何计算样本之间的相似度是很重要的。

Q:什么是降维问题?

降维,其目的很直接,提取关键信息。术语表达,是降低样本的个数,得到一组变量的过程。自然,根据样本种类的不同,(我们上面介绍 监督学习 和 无监督学习 ,可以复习下)降维的问题也要分为 监督降维 和 无监督降维。降维有两种方法:特征选择和特征提取。
特征选择,是假定样本数据中包含大量冗余和无关数据,从而找出主要数据的方法。
特征提取,是从高维数据中提取关键信息,转为低维数据进而求解的方法。过程中伴随着除去数据,创建新数据。
广泛用在图像识别领域。

 

Posted in Spring, Spring Boot, 技术

Spring Boot 整合 Mybatis Annotation 注解的完整 Web 案例

摘要: 原创出处 www.bysocket.com 「泥瓦匠BYSocket 」欢迎转载,保留摘要,谢谢!

『 公司需要人、产品、业务和方向,方向又要人、产品、业务和方向,方向… 循环』

本文提纲
一、前言
二、运行 springboot-mybatis-annotation 工程
三、springboot-mybatis-annotation 工程配置详解
四、小结

运行环境:JDK 7 或 8、Maven 3.0+
技术栈:SpringBoot 1.5+、SpringBoot Mybatis Starter 1.2+ 、MyBatis 3.4+

前言

距离第一篇 Spring Boot 系列的博文 3 个月了。《Springboot 整合 Mybatis 的完整 Web 案例》第一篇出来是 XML 配置 SQL 的形式。虽然 XML 形式是我比较推荐的,但是注解形式也是方便的。尤其一些小系统,快速的 CRUD 轻量级的系统。

这里感谢晓春 http://xchunzhao.tk/ 的 Pull Request,提供了 springboot-mybatis-annotation 的实现。

一、运行 springboot-mybatis-annotation 工程

由于这篇文章和 《Springboot 整合 Mybatis 的完整 Web 案例》 类似,所以运行这块环境配置大家参考另外一篇兄弟文章。

然后Application 应用启动类的 main 函数,然后在浏览器访问:

http://localhost:8080/api/city?cityName=温岭市

可以看到返回的 JSON 结果:

{
"id": 1,
"provinceId": 1,
"cityName": "温岭市",
"description": "我的家在温岭。"
}

 

三、springboot-mybatis-annotation 工程配置详解

1.pom 添加 Mybatis 依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>springboot</groupId>
	<artifactId>springboot-mybatis-annotation</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springboot-mybatis-annotation</name>
	<description>Springboot-mybatis :: 整合Mybatis Annotation Demo</description>

	<!-- Spring Boot 启动父依赖 -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.1.RELEASE</version>
	</parent>

	<properties>
		<mybatis-spring-boot>1.2.0</mybatis-spring-boot>
		<mysql-connector>5.1.39</mysql-connector>
	</properties>

	<dependencies>

		<!-- Spring Boot Web 依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!-- Spring Boot Test 依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<!-- Spring Boot Mybatis 依赖 -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>${mybatis-spring-boot}</version>
		</dependency>

		<!-- MySQL 连接驱动依赖 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql-connector}</version>
		</dependency>

		<!-- Junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>
	</dependencies>


</project>

2.在 CityDao 城市数据操作层接口类添加注解 @Mapper、@Select 和 @Results

/**
* 城市 DAO 接口类
*
* Created by xchunzhao on 02/05/2017.
*/
@Mapper // 标志为 Mybatis 的 Mapper
public interface CityDao {

/**
* 根据城市名称,查询城市信息
*
* @param cityName 城市名
*/
@Select("SELECT * FROM city")
// 返回 Map 结果集
@Results({
@Result(property = "id", column = "id"),
@Result(property = "provinceId", column = "province_id"),
@Result(property = "cityName", column = "city_name"),
@Result(property = "description", column = "description"),
})
City findByName(@Param("cityName") String cityName);
}

@Mapper 标志接口为 MyBatis Mapper 接口
@Select 是 Select 操作语句
@Results 标志结果集,以及与库表字段的映射关系

其他的注解可以看 org.apache.ibatis.annotations 包提供的,如图:

 

可以 git clone 下载工程 springboot-learning-example ,springboot-mybatis-annotation 工程代码注解很详细。 https://github.com/JeffLi1993/springboot-learning-example

四、小结

注解不涉及到配置,更近贴近 0 配置。再次感谢晓春 http://xchunzhao.tk/ 的 Pull Request~

欢迎扫一扫我的公众号关注 — 及时得到博客订阅哦!
— http://www.bysocket.com/ —
— https://github.com/JeffLi1993 —

Posted in Spring, Spring Boot, 技术

Spring Boot Dubbo applications.properties 配置清单

摘要: 原创出处 www.bysocket.com 「泥瓦匠BYSocket 」欢迎转载,保留摘要,谢谢!

『 与其纠结,不如行动学习。Innovate ,And out execute ! 』

本文提纲
一、前言
二、applications.properties 配置清单
三、@Service 服务提供者常用配置
四、@Reference 服务消费者常用配置
五、小结

 

运行环境:JDK 7 或 8、Maven 3.0+
技术栈:SpringBoot 1.5+、、Dubbo 2.5+

一、前言

在泥瓦匠出的
Springboot 整合 Dubbo/ZooKeeper 详解 SOA 案例

Spring Boot 中如何使用 Dubbo Activate 扩展点

两篇文章后,很多人跟我聊 Spring Boot 整合 Dubbo 的细节问题。当然最多的是配置问题,比如
Q:如果一个程序既提供服务又是消费者怎么配置 scan package?
A(群友周波): 就是 com.xxx.provider 生产者,com.xxx.consumer 消费者,那么 scan package 就设置到 com.xxx

 

Q:如何设置消费者调用生产者的超时时间?
A:目前不能通过 application.properties 定义。@Reference timeout

 

Q:consumer 怎么配置接入多个 provider?
A:@Reference 可以指定不同的 register。register (注册中心 like provider container)里面可以对应多个 provider

 

Q: @Service(version = “1.0.0”) 这个 1.0.0 可以从 application.properties 配置文件中读取吗?可以区分不同的环境,可以统一升级管理
A:占时还没有解决… 但是应用环境,如:dev/test/run 可以使用下面的配置,在 application.properties 定义
spring.dubbo.application.environment

Spring Boot 整合 Dubbo 的项目依赖了 spring-boot-starter-dubbo 工程,该项目地址是 https://github.com/teaey/spring-boot-starter-dubbo。 感谢作者~

二、applications.properties 配置清单

根据 starter 工程源码,可以看出 application.properties 对应的 Dubbo 配置类 DubboProperties 。

@ConfigurationProperties(prefix = "spring.dubbo")
public class DubboProperties {

    private String scan;

    private ApplicationConfig application;

    private RegistryConfig registry;

    private ProtocolConfig protocol;
}

包括了扫描路径、应用配置类、注册中心配置类和服务协议类

 

所以具体常用配置下
扫描包路径:指的是 Dubbo 服务注解的服务包路径

## Dubbo 配置
# 扫描包路径
spring.dubbo.scan=org.spring.springboot.dubbo

 

应用配置类:关于 Dubbo 应用级别的配置

## Dubbo 应用配置
# 应用名称
spring.dubbo.application.name=xxx

# 模块版本
spring.dubbo.application.version=xxx

# 应用负责人
spring.dubbo.application.owner=xxx

# 组织名(BU或部门)
spring.dubbo.application.organization=xxx

# 分层
spring.dubbo.application.architecture=xxx

# 环境,如:dev/test/run
spring.dubbo.application.environment=xxx

# Java代码编译器
spring.dubbo.application.compiler=xxx

# 日志输出方式
spring.dubbo.application.logger=xxx

# 注册中心 0
spring.dubbo.application.registries[0].address=zookeeper:#127.0.0.1:2181=xxx
# 注册中心 1
spring.dubbo.application.registries[1].address=zookeeper:#127.0.0.1:2181=xxx

# 服务监控
spring.dubbo.application.monitor.address=xxx

这里注意多个注册中心的配置方式。下面介绍单个注册中心的配置方式。

 

注册中心配置类:常用 ZooKeeper 作为注册中心进行服务注册。

## Dubbo 注册中心配置类
# 注册中心地址
spring.dubbo.application.registries.address=xxx

# 注册中心登录用户名
spring.dubbo.application.registries.username=xxx

# 注册中心登录密码
spring.dubbo.application.registries.password=xxx

# 注册中心缺省端口
spring.dubbo.application.registries.port=xxx

# 注册中心协议
spring.dubbo.application.registries.protocol=xxx

# 客户端实现
spring.dubbo.application.registries.transporter=xxx

spring.dubbo.application.registries.server=xxx

spring.dubbo.application.registries.client=xxx

spring.dubbo.application.registries.cluster=xxx

spring.dubbo.application.registries.group=xxx

spring.dubbo.application.registries.version=xxx

# 注册中心请求超时时间(毫秒)
spring.dubbo.application.registries.timeout=xxx

# 注册中心会话超时时间(毫秒)
spring.dubbo.application.registries.session=xxx

# 动态注册中心列表存储文件
spring.dubbo.application.registries.file=xxx

# 停止时等候完成通知时间
spring.dubbo.application.registries.wait=xxx

# 启动时检查注册中心是否存在
spring.dubbo.application.registries.check=xxx

# 在该注册中心上注册是动态的还是静态的服务
spring.dubbo.application.registries.dynamic=xxx

# 在该注册中心上服务是否暴露
spring.dubbo.application.registries.register=xxx

# 在该注册中心上服务是否引用
spring.dubbo.application.registries.subscribe=xxx

 

服务协议配置类:

## Dubbo 服务协议配置


# 服务协议
spring.dubbo.application.protocol.name=xxx

# 服务IP地址(多网卡时使用)
spring.dubbo.application.protocol.host=xxx

# 服务端口
spring.dubbo.application.protocol.port=xxx

# 上下文路径
spring.dubbo.application.protocol.contextpath=xxx

# 线程池类型
spring.dubbo.application.protocol.threadpool=xxx

# 线程池大小(固定大小)
spring.dubbo.application.protocol.threads=xxx

# IO线程池大小(固定大小)
spring.dubbo.application.protocol.iothreads=xxx

# 线程池队列大小
spring.dubbo.application.protocol.queues=xxx

# 最大接收连接数
spring.dubbo.application.protocol.accepts=xxx

# 协议编码
spring.dubbo.application.protocol.codec=xxx

# 序列化方式
spring.dubbo.application.protocol.serialization=xxx

# 字符集
spring.dubbo.application.protocol.charset=xxx

# 最大请求数据长度
spring.dubbo.application.protocol.payload=xxx

# 缓存区大小
spring.dubbo.application.protocol.buffer=xxx

# 心跳间隔
spring.dubbo.application.protocol.heartbeat=xxx

# 访问日志
spring.dubbo.application.protocol.accesslog=xxx

# 网络传输方式
spring.dubbo.application.protocol.transporter=xxx

# 信息交换方式
spring.dubbo.application.protocol.exchanger=xxx

# 信息线程模型派发方式
spring.dubbo.application.protocol.dispatcher=xxx

# 对称网络组网方式
spring.dubbo.application.protocol.networker=xxx

# 服务器端实现
spring.dubbo.application.protocol.server=xxx

# 客户端实现
spring.dubbo.application.protocol.client=xxx

# 支持的telnet命令,多个命令用逗号分隔
spring.dubbo.application.protocol.telnet=xxx

# 命令行提示符
spring.dubbo.application.protocol.prompt=xxx

# status检查
spring.dubbo.application.protocol.status=xxx

# 是否注册
spring.dubbo.application.protocol.status=xxx

三、@Service 服务提供者常用配置

常用 @Service 配置的如下

version 版本
group 分组
provider 提供者
protocol 服务协议
monitor 服务监控
registry 服务注册
…

 

四、@Reference 服务消费者常用配置

常用 @Reference 配置的如下

version 版本
group 分组
timeout 消费者调用提供者的超时时间
consumer 服务消费者
monitor 服务监控
registry 服务注册

 

五、小结

主要介绍了 Spring Boot Dubbo 整合中的细节问题大集合。

推荐:《Springboot 整合 Dubbo/ZooKeeper 详解 SOA 案例

 

欢迎扫一扫我的公众号关注 — 及时得到博客订阅哦!
— http://www.bysocket.com/ —
— https://github.com/JeffLi1993 —

Posted in Working Skills, 技术

Elasticsearch 默认配置 IK 及 Java AnalyzeRequestBuilder 使用

摘要: 原创出处 www.bysocket.com 「泥瓦匠BYSocket 」欢迎转载,保留摘要,谢谢!
『 春夏秋冬失去了你,我怎么过一年四季- 民谣歌词 』
本文提纲
一、什么是 Elasticsearch-analysis-ik
二、默认配置 IK
三、使用 AnalyzeRequestBuilder 获取分词结果
四、小结

运行环境:JDK 7 或 8、Maven 3.0+、ElasticSearch 2.3.2、Elasticsearch-analysis-ik 1.9.2
技术栈:SpringBoot 1.5+、Spring-data-elasticsearch 2.1.0

前言

在 Elasticsearch 和插件 elasticsearch-head 安装详解 http://www.bysocket.com/?p=1744 文章中,我使用的是  Elasticsearch 5.3.x。这里我改成了 ElasticSearch 2.3.2。是因为版本对应关系 https://github.com/spring-projects/spring-data-elasticsearch/wiki/Spring-Data-Elasticsearch—Spring-Boot—version-matrix

Spring Boot Version (x)    Spring Data Elasticsearch Version (y)    Elasticsearch Version (z)
x <= 1.3.5    y <= 1.3.4    z <= 1.7.2*
x >= 1.4.x    2.0.0 <=y < 5.0.0**    2.0.0 <= z < 5.0.0**
*  – 只需要你修改下对应的 pom 文件版本号
** – 下一个 ES 的版本会有重大的更新
这里可以看出,5.3.x 不在第二行范围内。因此这里我讲下,如何在 ElasticSearch 2.3.2 中默认配置 IK。

一、什么是 Elasticsearch-analysis-ik

了解什么是 Elasticsearch-analysis-ik,首先了解什么是 IK Analyzer。 IK Analyzer 是基于 lucene 实现的分词开源框架。官方地址:https://code.google.com/p/ik-analyzer/ 。
Elasticsearch-analysis-ik 则是将 IK Analyzer 集成 Elasticsearch 的插件,并支持自定义词典。GitHub 地址:https://github.com/medcl/elasticsearch-analysis-ik。特性支持:
分析器 Analyzer: ik_smart 或 ik_max_word
分词器 Tokenizer: ik_smart 或 ik_max_word

二、默认配置 IK

在 Elasticsearch-analysis-ik  官网中可以看到,其中版本需要对应:
IK版    ES版本
主 5.x -> master
5.3.2    5.3.2
5.2.2    5.2.2
5.1.2    5.1.2
1.10.1    2.4.1
1.9.5    2.3.5
1.8.1    2.2.1
1.7.0    2.1.1
1.5.0    2.0.0
1.2.6    1.0.0
1.2.5    0.90.x
1.1.3    0.20.x
1.0.0    0.16.2 -> 0.19.0

这里使用的是 Elasticsearch-analysis-ik 1.9.2,支持 ElasticSearch 2.3.2。下载地址:https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v1.9.2/elasticsearch-analysis-ik-1.9.2.zip,下载成功后进行安装。

解压 zip 文件,复制里面的内容到 elasticsearch-2.3.2/plugins/ik。
cd  elasticsearch-2.3.2/plugins
mkdir ik
cp ...

在 elasticsearch-2.3.2/config/elasticsearch.yml 增加配置:
index.analysis.analyzer.default.tokenizer : "ik_max_word"
index.analysis.analyzer.default.type: "ik"
配置默认分词器为 ik,并指定分词器为 ik_max_word。

然后重启 ES 即可。验证 IK 是否成功安装,访问下
localhost:9200/_analyze?analyzer=ik&pretty=true&text=泥瓦匠的博客是bysocket.com

可以得到下面的结果集:

{
    "tokens": [
        {
            "token": "泥瓦匠",
            "start_offset": 0,
            "end_offset": 3,
            "type": "CN_WORD",
            "position": 0
        },
        {
            "token": "泥",
            "start_offset": 0,
            "end_offset": 1,
            "type": "CN_WORD",
            "position": 1
        },
        {
            "token": "瓦匠",
            "start_offset": 1,
            "end_offset": 3,
            "type": "CN_WORD",
            "position": 2
        },
        {
            "token": "匠",
            "start_offset": 2,
            "end_offset": 3,
            "type": "CN_WORD",
            "position": 3
        },
        {
            "token": "博客",
            "start_offset": 4,
            "end_offset": 6,
            "type": "CN_WORD",
            "position": 4
        },
        {
            "token": "bysocket.com",
            "start_offset": 8,
            "end_offset": 20,
            "type": "LETTER",
            "position": 5
        },
        {
            "token": "bysocket",
            "start_offset": 8,
            "end_offset": 16,
            "type": "ENGLISH",
            "position": 6
        },
        {
            "token": "com",
            "start_offset": 17,
            "end_offset": 20,
            "type": "ENGLISH",
            "position": 7
        }
    ]
}

记得在Docker 容器安装时,需要对应的端口开发。

三、使用 AnalyzeRequestBuilder 获取分词结果

ES 中默认配置 IK 后,通过 Rest HTTP 的方式我们可以进行得到分词结果。那么在 Spring Boot 和提供的客户端依赖 spring-data-elasticsearch 中如何获取到分词结果。

加入依赖 pom.xml

<!-- Spring Boot Elasticsearch 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

在 application.properties 配置 ES 的地址:
# ES
spring.data.elasticsearch.repositories.enabled = true
spring.data.elasticsearch.cluster-nodes = 127.0.0.1:9300

然后创建一个方法,入参是搜索词,返回的是分词结果列表。
    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;

    /**
     * 调用 ES 获取 IK 分词后结果
     *
     * @param searchContent
     * @return
     */
    private List<String> getIkAnalyzeSearchTerms(String searchContent) {
        // 调用 IK 分词分词
        AnalyzeRequestBuilder ikRequest = new AnalyzeRequestBuilder(elasticsearchTemplate.getClient(),
                AnalyzeAction.INSTANCE,"indexName",searchContent);
        ikRequest.setTokenizer("ik");
        List<AnalyzeResponse.AnalyzeToken> ikTokenList = ikRequest.execute().actionGet().getTokens();

        // 循环赋值
        List<String> searchTermList = new ArrayList<>();
        ikTokenList.forEach(ikToken -> { searchTermList.add(ikToken.getTerm()); });

        return searchTermList;
    }
indexName 这里是指在 ES 设置的索引名称。
从容器注入的 ElasticsearchTemplate Bean 中获取 Client ,再通过 AnalyzeRequestBuilder 分析请求类型中进行分词并获取分词结果 AnalyzeResponse.AnalyzeToken 列表。

四、小结

默认配置了 IK 分词器,则 DSL 去 ES 查询时会自动调用 IK 分词。
如果想要自定义词库,比如比较偏的领域性。可以参考 Elasticsearch-analysis-ik GiHub 地址去具体查阅。

推荐开源项目:《springboot-learning-example

spring boot 实践学习案例,是 spring boot 初学者及核心技术巩固的最佳实践

欢迎扫一扫我的公众号关注 — 及时得到博客订阅哦!
Posted in Spring, Spring Boot, 技术

Spring Boot 配置文件 – 在坑中实践

摘要: 原创出处 www.bysocket.com 「泥瓦匠BYSocket 」欢迎转载,保留摘要,谢谢!
『 仓廪实而知礼节,衣食足而知荣辱 – 管仲 』

本文提纲
一、自动配置
二、自定义属性
三、random.* 属性
四、多环境配置

运行环境:JDK 7 或 8,Maven 3.0+

技术栈:SpringBoot 1.5+

一、自动配置

Spring Boot 提供了对应用进行自动化配置。相比以前 XML 配置方式,很多显式方式申明是不需要的。二者,大多数默认的配置足够实现开发功能,从而更快速开发。
什么是自动配置
Spring Boot 提供了默认的配置,如默认的 Bean ,去运行 Spring 应用。它是非侵入式的,只提供一个默认实现。
大多数情况下,自动配置的 Bean 满足了现有的业务场景,不需要去覆盖。但如果自动配置做的不够好,需要覆盖配置。比如通过命令行动态指定某个 jar ,按不同环境启动(这个例子在第 4 小节介绍)。那怎么办?这里先要考虑到配置的优先级。

Spring Boot 不单单从 application.properties 获取配置,所以我们可以在程序中多种设置配置属性。按照以下列表的优先级排列:
1.命令行参数
2.java:comp/env 里的 JNDI 属性
3.JVM 系统属性
4.操作系统环境变量
5.RandomValuePropertySource 属性类生成的 random.* 属性
6.应用以外的 application.properties(或 yml)文件
7.打包在应用内的 application.properties(或 yml)文件
8.在应用 @Configuration 配置类中,用 @PropertySource 注解声明的属性文件
9.SpringApplication.setDefaultProperties 声明的默认属性

可见,命令行参数优先级最高。这个可以根据这个优先级,可以在测试或生产环境中快速地修改配置参数值,而不需要重新打包和部署应用。
还有第 6 点,根据这个在多 moudle 的项目中,比如常见的项目分 api 、service、dao 等 moudles,往往会加一个 deploy moudle 去打包该业务各个子 moudle,应用以外的配置优先。

二、自定义属性

泥瓦匠喜欢按着代码工程来讲解知识。git clone 下载工程 springboot-learning-example ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example

a. 编译工程
在项目根目录 springboot-learning-example,运行 maven 指令:
cd springboot-learning-example
mvn clean install

b. 运行工程 test 方法

运行 springboot-properties 工程 org.spring.springboot.property.PropertiesTest 测试类的 getHomeProperties 方法。可以在控制台看到输出,这是通过自定义属性获取的值:

HomeProperties{province='ZheJiang', city='WenLing', desc='dev: I'm living in ZheJiang WenLing.'}

怎么定义自定义属性呢?

首先项目结构如下:

├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── org
    │   │       └── spring
    │   │           └── springboot
    │   │               ├── Application.java
    │   │               └── property
    │   │                   ├── HomeProperties.java
    │   │                   └── UserProperties.java
    │   └── resources
    │       ├── application-dev.properties
    │       ├── application-prod.properties
    │       └── application.properties
    └── test
        ├── java
        │   └── org
        │       └── spring
        │           └── springboot
        │               └── property
        │                   ├── HomeProperties1.java
        │                   └── PropertiesTest.java
        └── resouorces
            └── application.yml

在 application.properties 中对应 HomeProperties 对象字段编写属性的 KV 值:
## 家乡属性 Dev
home.province=ZheJiang
home.city=WenLing
home.desc=dev: I'm living in ${home.province} ${home.city}.
这里也可以通过占位符,进行属性之间的引用。

然后,编写对应的 HomeProperties Java 对象:

/**
 * 家乡属性
 *
 * Created by bysocket on 17/04/2017.
 */
@Component
@ConfigurationProperties(prefix = "home")
public class HomeProperties {

    /**
     * 省份
     */
    private String province;

    /**
     * 城市
     */
    private String city;

    /**
     * 描述
     */
    private String desc;

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "HomeProperties{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

通过 @ConfigurationProperties(prefix = “home”) 注解,将配置文件中以 home 前缀的属性值自动绑定到对应的字段中。同是用 @Component 作为 Bean 注入到 Spring 容器中。

如果不是用 application.properties 文件,而是用 application.yml 的文件,对应配置如下:
## 家乡属性
home:
  province: 浙江省
  city: 温岭松门
  desc: 我家住在${home.province}的${home.city}
键值对冒号后面,必须空一格。

注意这里,就有一个坑了:
application.properties 配置中文值的时候,读取出来的属性值会出现乱码问题。但是 application.yml 不会出现乱码问题。原因是,Spring Boot 是以 iso-8859 的编码方式读取 application.properties 配置文件。

注意这里,还有一个坑:
如果定义一个键值对 user.name=xxx ,这里会读取不到对应写的属性值。为什么呢?Spring Boot 的默认 StandardEnvironment 首先将会加载 “systemEnvironment” 作为首个PropertySource. 而 source 即为System.getProperties().当 getProperty时,按照读取顺序,返回 “systemEnvironment” 的值.即 System.getProperty(“user.name“)
(Mac 机子会读自己的登录账号,这里感谢我的死党 http://rapharino.com/

三、random.* 属性

Spring Boot 通过 RandomValuePropertySource 提供了很多关于随机数的工具类。概括可以生成随机字符串、随机 int 、随机 long、某范围的随机数。
运行 springboot-properties 工程 org.spring.springboot.property.PropertiesTest 测试类的 randomTestUser 方法。多次运行,可以发现每次输出不同 User 属性值:
UserProperties{id=-3135706105861091890, age=41, desc='泥瓦匠叫做3cf8fb2507f64e361f62700bcbd17770', uuid='582bcc01-bb7f-41db-94d5-c22aae186cb4'}

application.yml 方式的配置如下( application.properties 形式这里不写了):
## 随机属性
user:
  id: ${random.long}
  age: ${random.int[1,200]}
  desc: 泥瓦匠叫做${random.value}
  uuid: ${random.uuid}

四、多环境配置

很多场景的配置,比如数据库配置、Redis 配置、注册中心和日志配置等。在不同的环境,我们需要不同的包去运行项目。所以看项目结构,有两个环境的配置:
application-dev.properties:开发环境
application-prod.properties:生产环境

Spring Boot 是通过 application.properties 文件中,设置 spring.profiles.active 属性,比如 ,配置了 dev ,则加载的是 application-dev.properties :
# Spring Profiles Active
spring.profiles.active=dev

那运行 springboot-properties 工程中 Application 应用启动类,从控制台中可以看出,是加载了 application-dev.properties 的属性输出:
HomeProperties{province='ZheJiang', city='WenLing', desc='dev: I'm living in ZheJiang WenLing.'}

将 spring.profiles.active 设置成 prod,重新运行,可得到 application-prod.properties的属性输出:
HomeProperties{province='ZheJiang', city='WenLing', desc='prod: I'm living in ZheJiang WenLing.'}

根据优先级,顺便介绍下 jar 运行的方式,通过设置 -Dspring.profiles.active=prod 去指定相应的配置:
mvn package
java -jar -Dspring.profiles.active=prod springboot-properties-0.0.1-SNAPSHOT.jar

五、小结

常用的样板配置在 Spring Boot 官方文档给出,我们常在 application.properties(或 yml)去配置各种常用配置:

感谢资料:

欢迎扫一扫我的公众号关注 — 及时得到博客订阅哦!
Posted in Spring, Spring Boot, 技术

Spring Boot 中如何使用 Dubbo Activate 扩展点

摘要: 原创出处 www.bysocket.com 「泥瓦匠BYSocket 」欢迎转载,保留摘要,谢谢!

『 公司的核心竞争力在于创新 – 《启示录》 』

继续上一篇:《 Springboot 整合 Dubbo/ZooKeeper 》,在 Spring Boot 使用 Dubbo Activate 扩展点。这是一个群友问的,我总结下,分享给更多人。

本文提纲
一、什么是 Dubbo Activate 注解
二、使用 Dubbo Activate
三、小结

 

运行环境:JDK 7 或 8,Maven 3.0+
技术栈:SpringBoot 1.5+、Dubbo 2.5+、ZooKeeper 3.3+

 

一、什么是 Dubbo Activate 注解

@Activate 是一个 Duboo 框架提供的注解。在 Dubbo 官方文档上有记载:
对于集合类扩展点,比如:Filter, InvokerListener, ExportListener, TelnetHandler, StatusChecker等, 可以同时加载多个实现,此时,可以用自动激活来简化配置。

 

用 @Activate 来实现一些 Filter ,可以具体如下:
1. 无条件自动激活
直接使用默认的注解即可

import com.alibaba.dubbo.common.extension.Activate;
import com.alibaba.dubbo.rpc.Filter;
 
@Activate // 无条件自动激活
public class XxxFilter implements Filter {
    // ...
}

 

2. 配置 xxx 参数,并且参数为有效值时激活,比如配了cache=”lru”,自动激活 CacheFilter

import com.alibaba.dubbo.common.extension.Activate;
import com.alibaba.dubbo.rpc.Filter;
 
@Activate("xxx") // 当配置了xxx参数,并且参数为有效值时激活,比如配了cache="lru",自动激活CacheFilter。
public class XxxFilter implements Filter {
    // ...
}

 

3. 只对提供方激活,group 可选 provider 或 consumer

import com.alibaba.dubbo.common.extension.Activate;
import com.alibaba.dubbo.rpc.Filter;
 
@Activate(group = "provider", value = "xxx") 
// 只对提供方激活,group可选"provider"或"consumer"
public class XxxFilter implements Filter {
    // ...
}

 

二、使用 Dubbo Activate 注解

基于以前的 springboot-dubbo-server 和 springboot-dubbo-client 工程,GitHub 地址:https://github.com/JeffLi1993/springboot-learning-example 。

这里我们在消费端,既 springboot-dubbo-client 工程上添加一个 Filter。代码如下:

package com.xxx;
 
import com.alibaba.dubbo.rpc.Filter;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Invocation;
import com.alibaba.dubbo.rpc.Result;
import com.alibaba.dubbo.rpc.RpcException;
 
 
public class XxxFilter implements Filter {
    public Result invoke(Invoker<?> invoker, 
Invocation invocation) throws RpcException {
        // before filter ...
        Result result = invoker.invoke(invocation);
        // after filter ...
        return result;
    }
}

 

启动 client 工程发现,Console 报错,出现:

Caused by: java.lang.IllegalStateException: No such extension dubboConsumerFilter for filter/com.alibaba.dubbo.rpc.Filter

发现这个 Filter 初始化时,报错了。证明没有配置成功。

 

原来根据官方文档中描述,我们需要配置扩展点配置文件。

在 META-INF 中配置:

xxx=com.xxx.XxxFilter

Maven 项目目录结构

src
 |-main
    |-java
        |-com
            |-xxx
                |-XxxFilter.java (实现Filter接口)
    |-resources
        |-META-INF
            |-dubbo
                |-com.alibaba.dubbo.rpc.Filter (纯文本文件,内容为:xxx=com.xxx.XxxFilter)

三、小结

调用拦截扩展的应用场景很多,比如黑白名单,比如 IP 等。

 

欢迎扫一扫我的公众号关注 — 及时得到博客订阅哦!
http://www.bysocket.com/
https://github.com/JeffLi1993

Posted in 清文

为你写了一首歌叫 《工作》

一个人这座城市
弥漫着不想要有的焦虑

 

为了更好去面试
为了收入而工作

 

那曾是诱惑学生的美梦
梦醒后
又来一趟挤不上的地铁

 

三号线
像是在空中行驶

 

你用余光进了车厢
并用余光找到座位

 

工作就把我丢在陌生的人潮
只有耳机让单曲循环伴随

 

下班路上
走在盲道的自己
看霓虹闪烁

 

就像太阳东起西落
我坐上往西的列车
像是追赶着时间
日不落
人未眠

 

列车和谐号
就像一条温柔的蛇
蛇想家了

 

醒来却知是梦
未止梦的甜
继续工作

 

循环
Posted in Spring, Spring Boot, 技术

Spring Boot 整合 Redis 实现缓存操作

摘要: 原创出处 www.bysocket.com 「泥瓦匠BYSocket 」欢迎转载,保留摘要,谢谢!
『 产品没有价值,开发团队再优秀也无济于事 – 《启示录》 』

本文提纲
一、缓存的应用场景
二、更新缓存的策略
三、运行 springboot-mybatis-redis 工程案例
四、springboot-mybatis-redis 工程代码配置详解

运行环境
Mac OS 10.12.x
JDK 8 +
Redis 3.2.8
Spring Boot 1.5.1.RELEASE

一、缓存的应用场景

什么是缓存?
在互联网场景下,尤其 2C 端大流量场景下,需要将一些经常展现和不会频繁变更的数据,存放在存取速率更快的地方。缓存就是一个存储器,在技术选型中,常用 Redis 作为缓存数据库。缓存主要是在获取资源方便性能优化的关键方面。

Redis 是一个高性能的 key-value 数据库。GitHub 地址:https://github.com/antirez/redis 。Github 是这么描述的:
Redis is an in-memory database that persists on disk. The data model is key-value, but many different kind of values are supported: Strings, Lists, Sets, Sorted Sets, Hashes, HyperLogLogs, Bitmaps.

缓存的应用场景有哪些呢?
比如常见的电商场景,根据商品 ID 获取商品信息时,店铺信息和商品详情信息就可以缓存在 Redis,直接从 Redis 获取。减少了去数据库查询的次数。但会出现新的问题,就是如何对缓存进行更新?这就是下面要讲的。

二、更新缓存的策略

参考《缓存更新的套路》http://coolshell.cn/articles/17416.html,缓存更新的模式有四种:Cache aside, Read through, Write through, Write behind caching。

这里我们使用的是 Cache Aside 策略,从三个维度:(摘自 耗子叔叔博客)
失效:应用程序先从cache取数据,没有得到,则从数据库中取数据,成功后,放到缓存中。
命中:应用程序从cache中取数据,取到后返回。
更新:先把数据存到数据库中,成功后,再让缓存失效。

大致流程如下:
获取商品详情举例
a. 从商品 Cache 中获取商品详情,如果存在,则返回获取 Cache 数据返回。
b. 如果不存在,则从商品 DB 中获取。获取成功后,将数据存到 Cache 中。则下次获取商品详情,就可以从 Cache 就可以得到商品详情数据。
c. 从商品 DB 中更新或者删除商品详情成功后,则从缓存中删除对应商品的详情缓存

三、运行 springboot-mybatis-redis 工程案例

git clone 下载工程 springboot-learning-example ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example
下面开始运行工程步骤(Quick Start):

1.数据库和 Redis 准备
a.创建数据库 springbootdb:
CREATE DATABASE springbootdb;

b.创建表 city :(因为我喜欢徒步)
DROP TABLE IF EXISTS  `city`;
CREATE TABLE `city` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号',
  `province_id` int(10) unsigned  NOT NULL COMMENT '省份编号',
  `city_name` varchar(25) DEFAULT NULL COMMENT '城市名称',
  `description` varchar(25) DEFAULT NULL COMMENT '描述',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

c.插入数据
INSERT city VALUES (1 ,1,'温岭市','BYSocket 的家在温岭。');

d.本地安装 Redis
详见写过的文章《 Redis 安装 》http://www.bysocket.com/?p=917

2. springboot-mybatis-redis 工程项目结构介绍
springboot-mybatis-redis 工程项目结构如下图所示:
org.spring.springboot.controller - Controller 层
org.spring.springboot.dao - 数据操作层 DAO
org.spring.springboot.domain - 实体类
org.spring.springboot.service - 业务逻辑层
Application - 应用启动类
application.properties - 应用配置文件,应用启动会自动读取配置

3.改数据库配置
打开 application.properties 文件, 修改相应的数据源配置,比如数据源地址、账号、密码等。
(如果不是用 MySQL,自行添加连接驱动 pom,然后修改驱动名配置。)

4.编译工程
在项目根目录 springboot-learning-example,运行 maven 指令:
mvn clean install

5.运行工程
右键运行 springboot-mybatis-redis 工程 Application 应用启动类的 main 函数。
项目运行成功后,这是个 HTTP OVER JSON 服务项目。所以用 postman 工具可以如下操作
根据 ID,获取城市信息
GET http://127.0.0.1:8080/api/city/1
再请求一次,获取城市信息会发现数据获取的耗时快了很多。服务端 Console 输出的日志:
2017-04-13 18:29:00.273  INFO 13038 --- [nio-8080-exec-1] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.findCityById() : 城市插入缓存 >> City{id=12, provinceId=3, cityName='三亚', description='水好,天蓝'}
2017-04-13 18:29:03.145  INFO 13038 --- [nio-8080-exec-2] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.findCityById() : 从缓存中获取了城市 >> City{id=12, provinceId=3, cityName='三亚', description='水好,天蓝'}
可见,第一次是从数据库 DB 获取数据,并插入缓存,第二次直接从缓存中取。

更新城市信息
PUT http://127.0.0.1:8080/api/city
删除城市信息
DELETE http://127.0.0.1:8080/api/city/2
这两种操作中,如果缓存有对应的数据,则删除缓存。服务端 Console 输出的日志:
2017-04-13 18:29:52.248  INFO 13038 --- [nio-8080-exec-9] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.deleteCity() : 从缓存中删除城市 ID >> 12

四、springboot-mybatis-redis 工程代码配置详解

这里,我强烈推荐 注解 的方式实现对象的缓存。但是这里为了更好说明缓存更新策略。下面讲讲工程代码的实现。

pom.xml 依赖配置:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>springboot</groupId>
    <artifactId>springboot-mybatis-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-mybatis-redis :: 整合 Mybatis 并使用 Redis 作为缓存</name>

    <!-- Spring Boot 启动父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>

    <properties>
        <mybatis-spring-boot>1.2.0</mybatis-spring-boot>
        <mysql-connector>5.1.39</mysql-connector>
        <spring-boot-starter-redis-version>1.3.2.RELEASE</spring-boot-starter-redis-version>
    </properties>

    <dependencies>

        <!-- Spring Boot Reids 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-redis</artifactId>
            <version>${spring-boot-starter-redis-version}</version>
        </dependency>

        <!-- Spring Boot Web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- Spring Boot Test 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- Spring Boot Mybatis 依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis-spring-boot}</version>
        </dependency>

        <!-- MySQL 连接驱动依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connector}</version>
        </dependency>

        <!-- Junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>
包括了 Spring Boot Reids 依赖、 MySQL 依赖和 Mybatis 依赖。

在 application.properties 应用配置文件,增加 Redis 相关配置
## 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/springbootdb?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

## Mybatis 配置
mybatis.typeAliasesPackage=org.spring.springboot.domain
mybatis.mapperLocations=classpath:mapper/*.xml

## Redis 配置
## Redis数据库索引(默认为0)
spring.redis.database=0
## Redis服务器地址
spring.redis.host=127.0.0.1
## Redis服务器连接端口
spring.redis.port=6379
## Redis服务器连接密码(默认为空)
spring.redis.password=
## 连接池最大连接数(使用负值表示没有限制)
spring.redis.pool.max-active=8
## 连接池最大阻塞等待时间(使用负值表示没有限制)
spring.redis.pool.max-wait=-1
## 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
## 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
## 连接超时时间(毫秒)
spring.redis.timeout=0
详细解释可以参考注释。对应的配置类:org.springframework.boot.autoconfigure.data.redis.RedisProperties

CityRestController 控制层依旧是 Restful 风格的,详情可以参考《Springboot 实现 Restful 服务,基于 HTTP / JSON 传输》。 http://www.bysocket.com/?p=1627 domain 对象 City 必须实现序列化,因为需要将对象序列化后存储到 Redis。如果没实现 Serializable ,控制台会爆出以下异常:
Serializable
java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type

City.java 城市对象:
package org.spring.springboot.domain;

import java.io.Serializable;

/**
 * 城市实体类
 *
 * Created by bysocket on 07/02/2017.
 */
public class City implements Serializable {

    private static final long serialVersionUID = -1L;

    /**
     * 城市编号
     */
    private Long id;

    /**
     * 省份编号
     */
    private Long provinceId;

    /**
     * 城市名称
     */
    private String cityName;

    /**
     * 描述
     */
    private String description;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getProvinceId() {
        return provinceId;
    }

    public void setProvinceId(Long provinceId) {
        this.provinceId = provinceId;
    }

    public String getCityName() {
        return cityName;
    }

    public void setCityName(String cityName) {
        this.cityName = cityName;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @Override
    public String toString() {
        return "City{" +
                "id=" + id +
                ", provinceId=" + provinceId +
                ", cityName='" + cityName + '\'' +
                ", description='" + description + '\'' +
                '}';
    }
}
如果需要自定义序列化实现,只要实现 RedisSerializer 接口去实现即可,然后在使用 RedisTemplate.setValueSerializer 方法去设置你实现的序列化实现。

主要还是城市业务逻辑实现类 CityServiceImpl.java:
package org.spring.springboot.service.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.spring.springboot.dao.CityDao;
import org.spring.springboot.domain.City;
import org.spring.springboot.service.CityService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 城市业务逻辑实现类
 * <p>
 * Created by bysocket on 07/02/2017.
 */
@Service
public class CityServiceImpl implements CityService {

    private static final Logger LOGGER = LoggerFactory.getLogger(CityServiceImpl.class);

    @Autowired
    private CityDao cityDao;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 获取城市逻辑:
     * 如果缓存存在,从缓存中获取城市信息
     * 如果缓存不存在,从 DB 中获取城市信息,然后插入缓存
     */
    public City findCityById(Long id) {
        // 从缓存中获取城市信息
        String key = "city_" + id;
        ValueOperations<String, City> operations = redisTemplate.opsForValue();

        // 缓存存在
        boolean hasKey = redisTemplate.hasKey(key);
        if (hasKey) {
            City city = operations.get(key);

            LOGGER.info("CityServiceImpl.findCityById() : 从缓存中获取了城市 >> " + city.toString());
            return city;
        }

        // 从 DB 中获取城市信息
        City city = cityDao.findById(id);

        // 插入缓存
        operations.set(key, city, 10, TimeUnit.SECONDS);
        LOGGER.info("CityServiceImpl.findCityById() : 城市插入缓存 >> " + city.toString());

        return city;
    }

    @Override
    public Long saveCity(City city) {
        return cityDao.saveCity(city);
    }

    /**
     * 更新城市逻辑:
     * 如果缓存存在,删除
     * 如果缓存不存在,不操作
     */
    @Override
    public Long updateCity(City city) {
        Long ret = cityDao.updateCity(city);

        // 缓存存在,删除缓存
        String key = "city_" + city.getId();
        boolean hasKey = redisTemplate.hasKey(key);
        if (hasKey) {
            redisTemplate.delete(key);

            LOGGER.info("CityServiceImpl.updateCity() : 从缓存中删除城市 >> " + city.toString());
        }

        return ret;
    }

    @Override
    public Long deleteCity(Long id) {

        Long ret = cityDao.deleteCity(id);

        // 缓存存在,删除缓存
        String key = "city_" + id;
        boolean hasKey = redisTemplate.hasKey(key);
        if (hasKey) {
            redisTemplate.delete(key);

            LOGGER.info("CityServiceImpl.deleteCity() : 从缓存中删除城市 ID >> " + id);
        }
        return ret;
    }

}

首先这里注入了 RedisTemplate 对象。联想到 Spring 的 JdbcTemplate ,RedisTemplate 封装了 RedisConnection,具有连接管理,序列化和 Redis 操作等功能。还有针对 String 的支持对象 StringRedisTemplate。

Redis 操作视图接口类用的是 ValueOperations,对应的是 Redis String/Value 操作。还有其他的操作视图,ListOperations、SetOperations、ZSetOperations 和 HashOperations 。ValueOperations 插入缓存是可以设置失效时间,这里设置的失效时间是 10 s。

回到更新缓存的逻辑
a. findCityById 获取城市逻辑:
如果缓存存在,从缓存中获取城市信息
如果缓存不存在,从 DB 中获取城市信息,然后插入缓存

b. deleteCity 删除 / updateCity 更新城市逻辑:
如果缓存存在,删除
如果缓存不存在,不操作

其他不明白的,可以 git clone 下载工程 springboot-learning-example ,工程代码注解很详细。 https://github.com/JeffLi1993/springboot-learning-example。

五、小结

本文涉及到 Spring Boot 在使用 Redis 缓存时,一个是缓存对象需要序列化,二个是缓存更新策略是如何的。

欢迎扫一扫我的公众号关注 — 及时得到博客订阅哦!