Posted in Spring, Spring Boot, Spring Cloud, 技术

SpringCloud 中文社区 转型 Spring4All 欢迎您的加入

相信关注我们Spring Cloud中文社区(bbs.springcloud.com.cn)的朋友们最近已经在最新的横幅中发现了一个全新的社区:spring4all.com,相信从名字大家也能猜到该域名寓意Spring For All,那么我们为什么要重新创建这样一个社区呢?

关于 Spring For All

截止至今天,我们的论坛注册用户也已经有 1000+ 名了,在维护 Spring Cloud 中文社区的过程中,我们收到了各种各样关于 Spring Boot 和 Spring Cloud 的不同问题。虽然我们论坛的核心定位在 Spring Cloud,但是很多问题并非由 Spring Cloud 本身负责的,而是其他 Spring 项目所负责。那么为了说清楚这些内容,还是需要用户对Spring的其他相关项目有一定的了解之后才能弄明白其基本原理。

事实上,我们在实战过程中,就算采用了 Spring Boot 和 Spring Cloud 来构建微服务系统,其实我们的开发人员和架构师要学习的远不止这两个框架内容。就从 Spring Boot 而言,它虽然提供了快速构建微服务的能力,但是当开发具体业务功能时,我们还是需要 Spring 的其他框架,比如 Spring MVC, Spring Data 等。所以,我们为了用好 Spring Boot 和 Spring Cloud,对于 Spring 的其他项目根据自身的业务需要,不得不去深入了解它们的使用方法,才能帮助我们构建起可靠的微服务系统。

Spring 社区提供的框架从最初的 Spring Framework 发展至今已经形成了一套非常强大而复杂的技术体系。我们现在使用 Spring 与以往使用 Spring 的方式也有所不同了,以往我们需要整合各种不同的第三方框架来实现我们的业务,在 Spring Boot 和其他一些 Spring 项目的帮助下,我们通过 Spring 的封装可以非常方便的使用其他框架提供的功能。方便的同时也带了其他的问题,我们需要学习Spring封装后的这些框架如何来使用。而目前国内Spring技术非常缺乏这方面的分享内容,所以Spring For All社区的萌芽想法就出现了。

由于一些变故,算是促成了该社区的诞生,Spring For All,这里分享关于Spring的一切,我们旨在做最纯粹的技术交流社区,不夸大、不装逼,最中国最大的Spring知识集中地。

由于Spring For All社区的建立,我们将减少对 bbs.springcloud.com.cn的维护精力。原有用户可以至spring4all.com来分享内容和交流疑惑,这里除了我(程序猿DD)之外,还有《Spring Cloud与Docker微服务架构实战》作者周立等诸多技术大牛和开源爱好者为大家答疑解惑。所以,Spring Cloud的关注用户,请看过来吧,你千万不能错过的技术交流平台:spring4all.com

目前社区已初具规模,QQ群交流总人数达 9000 左右 人,更多内容会不断进行完善(免费教程、免费视频),有兴趣的用户可以加下面的QQ群参与讨论和学习:

Spring For All 社区 ① 365234583(满)
Spring For All 社区 ② 123013854(满)
Spring For All 社区 ③ 290714704
Spring For All 社区 ④ 112133511
Spring For All 社区 ⑤ 157525002(满)
Spring For All 社区 ⑥ 564840207
Spring For All 社区 ⑦ 470962790(满)
Spring For All 社区 ⑧ 613456104(满)
Spring For All 社区 ⑨ 534583667
Spring For All 社区 ⑩ 210742970(满)

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 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 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 缓存时,一个是缓存对象需要序列化,二个是缓存更新策略是如何的。

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

Spring Boot 整合 Mybatis 实现 Druid 多数据源详解

摘要: 原创出处:www.bysocket.com 泥瓦匠BYSocket 希望转载,保留摘要,谢谢!

“清醒时做事,糊涂时跑步,大怒时睡觉,独处时思考”

本文提纲
一、多数据源的应用场景
二、运行 springboot-mybatis-mutil-datasource 工程案例
三、springboot-mybatis-mutil-datasource 工程代码配置详解

一、多数据源的应用场景

目前,业界流行的数据操作框架是 Mybatis,那 Druid 是什么呢?
Druid 是 Java 的数据库连接池组件。Druid 能够提供强大的监控和扩展功能。比如可以监控 SQL ,在监控业务可以查询慢查询 SQL 列表等。Druid 核心主要包括三部分:
1. DruidDriver 代理 Driver,能够提供基于 Filter-Chain 模式的插件体系。
2. DruidDataSource 高效可管理的数据库连接池
3. SQLParser

当业务数据量达到了一定程度,DBA 需要合理配置数据库资源。即配置主库的机器高配置,把核心高频的数据放在主库上;把次要的数据放在从库,低配置。开源节流嘛,就这个意思。把数据放在不同的数据库里,就需要通过不同的数据源进行操作数据。这里我们举个 springboot-mybatis-mutil-datasource 工程案例:
user 用户表在主库 master 上,地址表 city 在从库 cluster 上。下面实现获取 根据用户名获取用户信息,包括从库的地址信息 REST API,那么需要从主库和从库中分别获取数据,并在业务逻辑层组装返回。逻辑如图:

下面就运行这个案例。

 

二、运行 springboot-mybatis-mutil-datasource 工程案例

git clone 下载工程 springboot-learning-example ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example。下面开始运行工程步骤(Quick Start):
1.数据库准备
a.创建 cluster 数据库 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 的家在温岭。');

然后,再创建一个 master 数据库
a.创建数据库 springbootdb_cluster:

CREATE DATABASE springbootdb_cluster;

b.创建表 user :

DROP TABLE IF EXISTS `city`;
CREATE TABLE user
(
id INT(10) unsigned PRIMARY KEY NOT NULL COMMENT '用户编号' AUTO_INCREMENT,
user_name VARCHAR(25) COMMENT '用户名称',
description VARCHAR(25) COMMENT '描述'
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

c.插入数据

INSERT user VALUES (1 ,'泥瓦匠','他有一个小网站 bysocket.com');

(以上数据库创建无先后顺序)

2. 项目结构介绍
项目结构如下图所示:
org.spring.springboot.config.ds – 配置层,这里是数据源的配置,包括 master 和 cluster 的数据源配置
org.spring.springboot.controller – Controller 层
org.spring.springboot.dao – 数据操作层 DAO,细分了 master 和 cluster 包下的 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.运行工程
右键运行 Application 应用启动类(位置:/springboot-learning-example/springboot-mybatis-mutil-datasource/src/main/java/org/spring/springboot/Application.java)的 main 函数,这样就成功启动了 springboot-mybatis-mutil-datasource 案例。

在浏览器打开:
http://localhost:8080/api/user?userName=泥瓦匠
浏览器返回 JSON 结果:

{
    "id": 1,
    "userName": "泥瓦匠",
    "description": "他有一个小网站 bysocket.com",
    "city": {
        "id": 1,
        "provinceId": 1,
        "cityName": "温岭市",
        "description": "BYSocket 的家在温岭。"
    }
}

这里 city 结果体来自 cluster 库,user 结果体来自 master 库。

 

三、springboot-mybatis-mutil-datasource 工程代码配置详解

代码共享在我的 GitHub 上:
https://github.com/JeffLi1993/springboot-learning-example/tree/master/springboot-mybatis-mutil-datasource

首先代码工程结构如下:
org.spring.springboot.config.ds 包包含了多数据源的配置,同样有第三个数据源,按照前几个复制即可
resources/mapper 下面有两个模块,分别是 Mybatis 不同数据源需要扫描的 mapper xml 目录

├── pom.xml
└── src
    └── main
        ├── java
        │   └── org
        │       └── spring
        │           └── springboot
        │               ├── Application.java
        │               ├── config
        │               │   └── ds
        │               │       ├── ClusterDataSourceConfig.java
        │               │       └── MasterDataSourceConfig.java
        │               ├── controller
        │               │   └── UserRestController.java
        │               ├── dao
        │               │   ├── cluster
        │               │   │   └── CityDao.java
        │               │   └── master
        │               │       └── UserDao.java
        │               ├── domain
        │               │   ├── City.java
        │               │   └── User.java
        │               └── service
        │                   ├── UserService.java
        │                   └── impl
        │                       └── UserServiceImpl.java
        └── resources
            ├── application.properties
            └── mapper
                ├── cluster
                │   └── CityMapper.xml
                └── master
                    └── UserMapper.xml

 

1. 依赖 pom.xml
Mybatis 通过 Spring Boot Mybatis Starter 依赖
Druid 是数据库连接池依赖

<?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-mutil-datasource</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-mybatis-mutil-datasource :: Spring Boot 实现 Mybatis 多数据源配置</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>
        <druid>1.0.18</druid>
    </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>

        <!-- Druid 数据连接池依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid}</version>
        </dependency>

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

2. application.properties 配置两个数据源配置
数据源配置会被数据源数据源配置如下

## master 数据源配置
master.datasource.url=jdbc:mysql://localhost:3306/springbootdb?useUnicode=true&characterEncoding=utf8
master.datasource.username=root
master.datasource.password=123456
master.datasource.driverClassName=com.mysql.jdbc.Driver

## cluster 数据源配置
cluster.datasource.url=jdbc:mysql://localhost:3306/springbootdb_cluster?useUnicode=true&characterEncoding=utf8
cluster.datasource.username=root
cluster.datasource.password=123456
cluster.datasource.driverClassName=com.mysql.jdbc.Driver

3. 数据源配置
多数据源配置的时候注意,必须要有一个主数据源,即 MasterDataSourceConfig 配置:

@Configuration
// 扫描 Mapper 接口并容器管理
@MapperScan(basePackages = MasterDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "masterSqlSessionFactory")
public class MasterDataSourceConfig {

    // 精确到 master 目录,以便跟其他数据源隔离
    static final String PACKAGE = "org.spring.springboot.dao.master";
    static final String MAPPER_LOCATION = "classpath:mapper/master/*.xml";

    @Value("${master.datasource.url}")
    private String url;

    @Value("${master.datasource.username}")
    private String user;

    @Value("${master.datasource.password}")
    private String password;

    @Value("${master.datasource.driverClassName}")
    private String driverClass;

    @Bean(name = "masterDataSource")
    @Primary
    public DataSource masterDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClass);
        dataSource.setUrl(url);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean(name = "masterTransactionManager")
    @Primary
    public DataSourceTransactionManager masterTransactionManager() {
        return new DataSourceTransactionManager(masterDataSource());
    }

    @Bean(name = "masterSqlSessionFactory")
    @Primary
    public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource masterDataSource)
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(masterDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(MasterDataSourceConfig.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }
}

@Primary 标志这个 Bean 如果在多个同类 Bean 候选时,该 Bean 优先被考虑。「多数据源配置的时候注意,必须要有一个主数据源,用 @Primary 标志该 Bean」
@MapperScan 扫描 Mapper 接口并容器管理,包路径精确到 master,为了和下面 cluster 数据源做到精确区分
@Value 获取全局配置文件 application.properties 的 kv 配置,并自动装配
sqlSessionFactoryRef 表示定义了 key ,表示一个唯一 SqlSessionFactory 实例

同理可得,从数据源 ClusterDataSourceConfig 配置如下:

@Configuration
// 扫描 Mapper 接口并容器管理
@MapperScan(basePackages = ClusterDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "clusterSqlSessionFactory")
public class ClusterDataSourceConfig {

    // 精确到 cluster 目录,以便跟其他数据源隔离
    static final String PACKAGE = "org.spring.springboot.dao.cluster";
    static final String MAPPER_LOCATION = "classpath:mapper/cluster/*.xml";

    @Value("${cluster.datasource.url}")
    private String url;

    @Value("${cluster.datasource.username}")
    private String user;

    @Value("${cluster.datasource.password}")
    private String password;

    @Value("${cluster.datasource.driverClassName}")
    private String driverClass;

    @Bean(name = "clusterDataSource")
    public DataSource clusterDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClass);
        dataSource.setUrl(url);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean(name = "clusterTransactionManager")
    public DataSourceTransactionManager clusterTransactionManager() {
        return new DataSourceTransactionManager(clusterDataSource());
    }

    @Bean(name = "clusterSqlSessionFactory")
    public SqlSessionFactory clusterSqlSessionFactory(@Qualifier("clusterDataSource") DataSource clusterDataSource)
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(clusterDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(ClusterDataSourceConfig.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }
}

上面数据配置分别扫描 Mapper 接口,org.spring.springboot.dao.master(对应 xml classpath:mapper/master ) 和 org.spring.springboot.dao.cluster(对应 xml classpath:mapper/cluster ) 包中对应的 UserDAO 和 CityDAO 。
都有 @Mapper 标志为 Mybatis 的并通过容器管理的 Bean。Mybatis 内部会使用反射机制运行去解析相应 SQL。

3.业务层 biz
biz 照常注入了两个 DAO,如同以前一样正常工作。不用关心和指定到具体说明数据源。

/**
 * 用户业务实现层
 *
 * Created by bysocket on 07/02/2017.
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao; // 主数据源

    @Autowired
    private CityDao cityDao; // 从数据源

    @Override
    public User findByName(String userName) {
        User user = userDao.findByName(userName);
        City city = cityDao.findByName("温岭市");
        user.setCity(city);
        return user;
    }
}

四、小结

多数据源适合的场景很多。不同的 DataSource ,不同的 SqlSessionFactory 和 不同的 DAO 层,在业务逻辑层做 整合。总结的架构图如下:

同样,如果实战中,大家遇到什么,或者建议《Spring boot 那些事》还需要一起交流的。请点击留言。

推荐书《奥黛丽·赫本》一本讲女神的故事。

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

Posted in Spring, Spring Boot, 技术

Spring Boot HTTP over JSON 的错误码异常处理

摘要: 原创出处:www.bysocket.com 泥瓦匠BYSocket 希望转载,保留摘要,谢谢!

“年轻人不要怕表现,要敢于出来表现,但还是那句话,要有正确的度,你的表现是分析问题和解决问题的能力。”

– 《你凭什么做好互联网》

本文提纲
一、异常统一处理的使用场景
二、运行 springboot-validation-over-json 工程
三、springboot-validation-over-json 工程代码详解

一、异常统一处理的使用场景

在前后端分离开发中,经常用 HTTP over JSON 作为服务进行前后端联调对接。这里简单介绍下为啥前后端分离开发?我想到如下:

1.低耦合,责权分离,模块化。前后端之间利用轻量级协议对接耦合。
2.便于敏捷开发:后端给出 api 文档 -> 前端根据文档,mock出数据开发 ;同时,后端实现业务逻辑。
3.微服务尤其适用

这时候 HTTP over JSON 形式中很多涉及到返回码,错误码相关的处理。比如xxx参数不完整,权限不足,用户不存在等。

怎么统一处理认为是异常的场景呢?
利用的是 Spring 4.x 提供的 RestControllerAdvice。这里做下说明,也可以根据 ControllerAdvice 去实现。这里案例是 HTTP over JSON 模式,所以直接利用
RestControllerAdvice ,控制层通知器,这里用于统一拦截异常,进行响应处理。工作模式,如图:

二、运行 springboot-validation-over-json 工程

运行环境:JDK 7 或 8,Maven 3.0+
技术栈:SpringBoot 1.5+(内涵 Spring 4.x)

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

git clone git@github.com:JeffLi1993/springboot-learning-example.git

然后,Maven 编译安装这个工程:

cd springboot-learning-example
mvn clean install

2.运行 springboot-validation-over-json 工程
右键运行 springboot-validation-over-json 工程 Application 应用启动类的 main 函数。默认端口 8080

3.访问案例
a. 参数不完整案例:
访问浏览器打开下面链接,可得到以下 JSON 返回
http://localhost:8080/api/city?cityName=

{
    "code": "000001",
    "message": "params no complete",
    "result": null
}

b. 成功案例:
访问浏览器打开下面链接,可得到以下 JSON 返回
http://localhost:8080/api/city?cityName=%E6%B8%A9%E5%B2%AD%E5%B8%82

{
    "code": "0",
    "message": "success",
    "result": {
        "id": 1,
        "provinceId": 2,
        "cityName": "温岭",
        "description": "是我的故乡"
    }
}

三、springboot-validation-over-json 工程代码详解

代码详解提纲:
a.控制层通知器
b.响应码设计

同样,代码共享在我的 GitHub 上:
https://github.com/JeffLi1993/springboot-learning-example/tree/master/springboot-validation-over-json

首先,工程代码目录如下:

├── pom.xml
└── src
    └── main
        └── java
            └── org
                └── spring
                    └── springboot
                        ├── Application.java
                        ├── constant
                        │   └── CityErrorInfoEnum.java
                        ├── result
                        │   ├── ErrorInfoInterface.java
                        │   ├── GlobalErrorInfoEnum.java
                        │   ├── GlobalErrorInfoException.java
                        │   ├── GlobalErrorInfoHandler.java
                        │   └── ResultBody.java
                        └── web
                            ├── City.java
                            └── ErrorJsonController.java

a.控制层通知器
GlobalErrorInfoHandler.java 代码如下:

@RestControllerAdvice
public class GlobalErrorInfoHandler {

@ExceptionHandler(value = GlobalErrorInfoException.class)
public ResultBody errorHandlerOverJson(HttpServletRequest request,
GlobalErrorInfoException exception) {
    ErrorInfoInterface errorInfo = exception.getErrorInfo();
    ResultBody result = new ResultBody(errorInfo);
    return result;
}
}

@ExceptionHandler 注解,标记了使用 errorHandlerOverJson() 方法来处理 GlobalErrorInfoException 异常。
@RestControllerAdvice 是 @ControllerAdvice 和 @ResponseBody 的语义结合。是控制器增强,直接返回对象。这里用于统一拦截异常,然后返回错误码对象体。
@ResponseBody 作用: 该注解用于将 Controller 的方法返回的对象,通过适当的 HttpMessageConverter 转换为指定格式后,写入到 Response 对象的 body 数据区。

b.响应码设计
简单讲讲,这里定义了一个错误码接口,全局错误码枚举和各个业务错误码枚举去实现接口,并用枚举值枚举出错误码及错误码消息列表。如图:

四、小结

如果实战中,大家遇到什么,或者建议《Spring boot 那些事》还需要一起交流的。请点击留言。

推荐书《腾讯传》,其中几章写的很不错。

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