Eureka

Spring Cloud Eureka是spring cloud 微服务套件中的一部分，她基于Netflix Eureka做了二次封装，主要负责完成微服务架构中的服务治理功能

在了解Eureka之前，我们先来讲下服务发现的由来

1 服务发现的由来

服务发现及注册中心是与软件开发的架构方式演化而来的，大概归纳如下

1.1 单体架构

最早的开发中，大多使用单体架构，服务自成一体。对于依赖的少数外部服务，会采用配置地址的方式进行访问。比如第三方接口，会使用appId和appKey来进行调用。

1.2 SOA架构

随着SOA架构流行，有些公司的内部开始将单体应用拆分成粒度较为粗的服务化架构。

查看： https://blog.csdn.net/chenleixing/article/details/44926955

1.3 微服务时代

在微服务时代，底层运维方式发生了很大的变化，并且随着docker和kubernetes的流行，业务服务不在部署在固定的虚拟机上，其ip地址也不再固定，这个时候前面的解决方式就显得有点儿吃力了。针对这个问题，提出了一些解决方案，例如

1：以nginx为例，在没有引入服务注册中心的时候，那么需要我们手工或是通过脚本的方式，在部署的受去更新nginx的配置文件，然后reload。或是使用ngx_http_dyups_module通过rest api在运行的受进行更新upstream而不需要reload

2: 将服务中心作为一个标配的分布式服务组件，网管等都从服务注册中心获取相关服务的实例信息，实现动态路由。例如consule-template+nginx方案，然后通过consul监听服务实例变化，再更新nginx的配置文件。

从上面的例子我们可以看出，随着服务架构模式以及底层运维方式的变化，服务注册中心逐步再分布式系统架构中占据了一个重要的地位。

2 Eureka简介

Eureka是Netflix公司开源的一款服务发现组件，该组件提供的服务发现可以为负载均衡、failover等提供了支持。Eureka包括Eureka Server和Eureka Client。Eureka Server提供了RESTFul服务，而Eureka Client则是使用Java编写的客户端，用于简化Eureka Server的交互。

2.1 服务发现技术选型

CAP原则又称CAP定理，指的是在一个分布式系统中，Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性），三者不可兼得 。

查看：http://www.ruanyifeng.com/blog/2018/07/cap.html

从列表中我们可以看出，有很多服务组件可以选择，针对AP及CP这里我们主要选择Eureka来进行讲解

EurekaServer采用P2P（Peer To Peer）模式https://www.cnblogs.com/linsanshu/p/5546948.html，不保证复制操作一定能成功，因此提供的是一个最终一致性的服务实例视图。Client端再Server端的注册信息有一个带期限的租约，一旦Server端再指定期间没有收到Client端发送的心跳，则Server端会认为Client端注册的服务是不健康的，定时任务会将从注册表中删除。

那么我们为什么要选择Eureka呢？主要有以下几点

• Eureka是基于AP而不是CP
• 团队是Java开发，除了问题好排查
• Eureka能和zuul ribbon整合性好

3 Eureka入门

eureka配置参数

3.1 单机版

3.1.1 Eureka Server

3.1.1.1 引入Eureka Server依赖

1
2
3
4
5
6

<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
		</dependency>
	</dependencies>

3.1.1.2 配置启动类

1
2
3
4
5
6
7
8

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

	public static void main(String[] args) {
		SpringApplication.run(EurekaServerApplication.class, args);
	}
}

3.1.1.3 配置properties或yml文件

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

#服务名称
spring.application.name=smartke-cloud-eureka-server
#服务端口
server.port=8761
#eureka设置
eureka.instance.hostname=localhost
# 表示是否注册自身到eureka服务器
eureka.client.register-with-eureka=false
# 是否从eureka上获取注册信息
eureka.client.fetch-registry=false
#关闭eureka自我保护机制
eureka.server.enable-self-preservation=false
#剔除失效服务间隔
eureka.server.eviction-interval-timer-in-ms=2000
#设置访问eureka的时候需要使用用户名和密码进行登录
#security.basic.enabled=true
#spring.security.user.name=smartke
#spring.security.user.password=smartke
#日志设置
logging.level.root=error
logging.level.org.springframework=info
logging.file=${spring.application.name}.log

3.1.2 Eureka Client

3.1.2.1 引入依赖

1
2
3
4
5
6

<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
	</dependencies>

3.1.2.2 配置启动类

1
2
3
4
5
6
7
8

@SpringBootApplication
@EnableDiscoveryClient
public class EurekaClientApplication {

	public static void main(String[] args) {
		SpringApplication.run(EurekaClientApplication.class, args);
	}
}

3.1.2.3 配置properties或yml文件

1
2
3
4
5
6
7
8
9
10

#port
server.port=8002
###application name
spring.application.name=smartke-portal
###eureka
eureka.client.serviceUrl.defaultZone=http://admin:admin@localhost:8761/eureka/
#Eureka客户端向服务端发送心跳的时间间隔，单位为秒（客户端告诉服务端自己会按照该规则）默认为30
eureka.instance.lease-renewal-interval-in-seconds=1
#Eureka服务端在收到最后一次心跳之后等待的时间上限，单位为秒，超过则剔除（客户端告诉服务端按照此规则等待自己）默认为90
eureka.instance.lease-expiration-duration-in-seconds=2

说明一下，这里需要指定spring.application.name不然会再Eureka Server界面显示为UNKNOW

eureka错误解释

自我保护机制

当我们再本地调式基于eureka的程序时，基本上都会碰到这样一个问题，再服务注册中心的信息面板中出现以下红色的警告信息

EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY’RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.

实际上，该警告触发了eureka server的自我保护机制。服务注册到eureka server之后，会维护一个心跳连接，告诉eureka server自己还活着。eureka server再运行期间，会统计心跳失败比例再15分钟之内是否低于85%，如果出现低于的情况(在本地单机调试的时候十分容易满足，生产环境的情况下，通常是由于网络不稳定导致)，eureka server 会将当前的实例注册信息保护起来，让这些实例不会过期，尽可能保护这些注册信息(这就是为什么选择Eureka，因为eureka是AP的)但是，在这段时间之内实例若出现问题，那么客户端很容易拿到实际上已经不存在的服务实例，会出现调用失败的情况，所以客户端必须要有容错机制，比如可以使用请求重试、断路器等机制。

那么出现上面的情况，我们该怎么解决呢？可以在本地配置文件中加入eureka.server.enable-self-preservation=false参数来关闭，以确保注册中心可以将不可用的实例及时剔除。

关闭自我保护之后，启动eureka server会出现以下提示，可以忽略。

THE SELF PRESERVATION MODE IS TURNED OFF. THIS MAY NOT PROTECT INSTANCE EXPIRY IN CASE OF NETWORK/OTHER PROBLEMS

3.2 Peer to Peer架构

一般而言，分布式系统的数据在多个副本之间的复制方式，可以分为主从复制和对等复制

3.2.1 主从复制

主从复制就是我们熟知的Master-Slave模式，即有一个主副本，其他副本为从副本。所有对数据的写操作都提交到主副本，最后再由主副本更新到其他从副本。具体更新的方式，还可以细分为同步更新、异步更新、同步及异步混合。

对于主从复制模式来讲，写操作的压力都在主副本上面，她是整个系统的瓶颈，但是从副本可以帮主副本分担读请求。

3.2.2 对等复制

即P2P的模式，副本之间部分主从，任何副本都可以接受写操作，然后每个副本之间相互进行数据更i性能。对于对等复制模式来讲，由于任何副本都可以进行写操作，各个副本之间的数据哦同步及冲突处理是一个比较棘手的问题。

Eureka Server就是采用的Peer to Peer 模式。

Eureka Server从一开始设计就考虑了高可用的问题，在Eureka的服务治理设计中，所有的节点即是服务提供方，又是服务消费方，服务注册中心也不例外。Eureka Server的高可用实际上就是将自己作为服务向其他服务注册中心注册自己，这样就可以形成一组互相注册的服务注册中心，以实现服务清单的互相同步。达到高可用的效果。

3.2.3 代码示例

依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

<?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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>cn.com.bmsmart</groupId>
	<artifactId>eureka-server</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>eureka-server</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Finchley.SR2</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

• 创建application-peer1.properties，作为peer1服务中心的配置，并将serviceUrl指向peer2:

1
2
3
4
5

spring.application.name=eureka-server
server.port=8761

eureka.instance.hostname=peer1
eureka.client.serviceUrl.defaultZone=http://peer2:8762/eureka/

• 创建 application-peer2.properties，作为peer2服务中心的配置，并将serviceUrl指向peer1

1
2
3
4
5
6

spring.application.name=eureka-server
server.port=8762

eureka.instance.hostname=peer2

eureka.client.serviceUrl.defaultZone=http://peer1:8761/eureka/

• 启动类

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

package cn.com.bmsmart.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }

}

• 通过spring.profiles.active属性来分别启动peer1和peer2

1
2

java -jar eureka-server-0.0.1-SNAPSHOT.jar --spring.profiles.active=peer1
java -jar eureka-server-0.0.1-SNAPSHOT.jar --spring.profiles.active=peer2

此时访问peer1的注册中心http://localhost:8761，我们可以看到`registered-replicas`中有peer2的节点`http://peer2:8762/eureka/` 同样访问peer2 http://lcoalhost:8762也能看到`registered-replicas`中有peer1的节点`http://peer1:8761/eureka/`

eureka-client

依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

<?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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>cn.com.bmsmart</groupId>
	<artifactId>eureka-client</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>eureka-client</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Finchley.SR2</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</repository>
	</repositories>

</project>

• 配置文件

1
2
3
4
5
6
7
8
9
10
11

spring.application.name=eureka-client
server.port=8080
eureka.client.serviceUrl.defaultZone=http://peer1:8761/eureka/,http://peer2:8762/eureka/
logging.file=${spring.application.name}.log
eureka.instance.prefer-ip-address=true
# 健康检查
#eureka.client.healthcheck.enabled=true
# 随机端口配置
#eureka.instance.instance-id=${spring.application.name}:${random.int}
#server.port=0
#server.port=${random.int[10000,19999]}

• 启动类

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

package cn.com.bmsmart.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class EurekaClientApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaClientApplication.class, args);
    }
}

jdk1.8新特性之lambda 表达式

1.使用()->{} 代替匿名内部类

允许把函数作为一个方法参数传入，使得代码变得更加简洁。强大的函数式编程。

减少代码冗余量，可读性强。

语法

lambda 表达式的语法格式如下：

(parameters) -> expression 或 (parameters) ->{ statements; }

2.方法引用

通过方法的名字来指向一个方法 ：：

3.函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

1

@FunctionalInterface----  主要用于编译级错误检查

　定义：“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。jdk1.8提供了一个@FunctionalInterface注解来定义函数式接口，如果我们定义的接口不符合函数式的规范便会报错。

若一个接口中包含多个抽象方法，是没有办法通过表达式左侧的参数列表来定位到对应的方法。

类型推断机制的加入，java编译器可以根据上下文在后台推断出参数的类型，故无需再参数列表中制定参数类型。

函数式编程可以友好的进行

Predicate 接口是函数式接口，它接受一个输入参数T,返回一个布尔值结果

4.默认方法

jdk1.8新增默认方法，就是接口中可以有实现方法，而且不需要实现类去实现其方法。

只需要在方法前加上default关键字即可实现默认方法。

静态默认方法

Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法

为什么要有这个特性？

首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

5.Stream 特性

新的抽象称为Stream ,可以以一种声明方式处理数据。

理解：

1.Stream是元素的集合，看起来类似Iterator

2.可以支持顺序和并行的对原Stream进行汇聚的操作；

Stream API 可以极大的提高java程序员的生产力，让程序员写出高效率，干净，简洁的代码。

筛选 排序 聚合等操作

常用方法：

1.生成流

stream() - 为集合创建串行流

parallelStream() - 为集合创建并行流

2.forEach()

迭代流中的每个元素

3.map

map 方法用于映射每个元素到对应的结果，

4.filter

filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：

5.limit

limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据

6.sorted

sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：

7.Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串

6.base64

7.java api 新的日期时间API

什么是Spring-boot

设计目的是为了简化新spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，而使开发人员不需要定义样板化的配置。只是默认配置了很多框架的使用方式，类似maven整合了所有的jar包。

使用spring-boot的优势

1. 简化编码：可以快速开启一个web容器

2. 简化配置：java ee轻量级框架，但是其配置比较繁琐。spring boot 更多的采用java config的方式，对spring进行配置。

3. 简化部署：spring boot 内嵌tomcat，只需要将项目打成jar包，使用java -jar xxx.jar 一键启动项目即可。

4. 简化监控：使用spring-boot-start-actuator依赖，直接使用REST方式来获取进程的运行期性能参数，从而达到监控的目的。

5. 但是spring -boot只是微架构，没有提供相应的服务发现和注册的配套功能，没有外围监控集成方案，没有外围的安全管理方案，所以在微服务架构中，还需要spring cloud配套使用。

   未来的发展趋势

   微服务是未来发展的趋势，项目会从传统架构慢慢转向微服务架构，使用独立的技术，更安全更频繁的部署。

spring-boot的三种启动方式

Spring: the source for modern java

摘自官网https://spring.io/

Spring Boot可以让我们轻松的创建独立的，生产级的应用程序，使程序变得更加轻量化。你可以 “just run”。你可以依靠一个Java的main函数来运行一个Spring应用。你也可以把你的应用打包为一个jar文件，通过java -jar来运行你的Spring程序。大多数Spring Boot应用程序只需要很少的Spring配置。

特点：

• 创建独立的Spring应用程序
• 内嵌Tomcat、Jetty或者Undertow（无需单独部署war文件）
• 开箱即用，提供各种默认配置来简化项目配置
• 没有冗余的代码生成也不需要XML配置
• 尽可能的自动化配置Spring以及第三方库
• 提供生产监控功能，例如metrics（指标）、health checks（运行状况检查）和externalized configuration（外部配置）

快速入门

先决条件

jdk 1.8

spring framework 5.x以上

使用maven构建项目

1 访问https://start.spring.io/

2 选择Maven Project、Spring Boot版本2.0.7选择依赖，这里选择web，可参考下图所示

3 点击Generate Project下载demo压缩包

将zip包解压缩导入IntelliJ IDEA中

项目结构解析

通过上面一系列的操作，我们已经成功的创建了一个Spring Boot程序。Spring Boot的基础结构共三个文件

• src/main/java程序入口：DemoApplicatio
• src/main/resources下的配置文件：application.properties
• src/test/测试入口：DemoApplicationTests

生成的DemoApplicatio和DemoApplicationTests类可以直接运行来启动当前创建的项目，由于目前该项目未配合Web模块，所以程序会在加载完Spring之后结束运行。

添加web模块以及单元测试模块的maven依赖

在pom.xml文件中仅需要引入两个模块就行

• spring-boot-starter-web：核心模块，包括自动配置支持、日志和YAML
• spring-boot-starter-test：测试模块，包括JUnit、Hamcrest、Mockito

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

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

编写controller

• 创建cn.com.bmsmart.controller包
• 创建HelloController类

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

package cn.com.bmsmart.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * <p>Description: </p>
 * Created by wusong on 2019-01-07 6:55.
 */
@RestController
public class HelloController {

    @GetMapping(value = "/")
    public String sayHello() {
        return "Hello Spring Boot";
    }
}

右键DemoApplication启动main方法，然后打开浏览器，输入http://localhost:8080/可以看到输出了Hello Spring Boot

编写单元测试

打开的工程的src/test/下的测试入口DemoApplicationTests类。然后编写一个单元测试来mock http请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package cn.com.bmsmart.demo;

import cn.com.bmsmart.demo.controller.HelloController;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = DemoApplication.class)
public class DemoApplicationTests {

    @Autowired
    private HelloController helloController;

    private MockMvc mvc;


    @Before
    public void setUp() throws Exception {
        mvc = MockMvcBuilders.standaloneSetup(helloController).build();
    }

    @Test
    public void contextLoads() throws Exception {
        mvc.perform(MockMvcRequestBuilders.get("/").accept(MediaType.APPLICATION_JSON))
           .andExpect(status().isOk())
           .andExpect(content().string(equalTo("Hello Spring Boot")));
    }

}

通过注入HelloController然后在@Before函数中把mock的对象HelloController传递到MockMvcBuilders.standaloneSetup(helloController).build()中，这样就可以构建我们的单元测试了。

• 注意引入静态类，让status、content、equalTo函数可用

1
2
3

import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

测试结果

另外一种用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

package cn.com.bmsmart.demo;

import cn.com.bmsmart.demo.controller.HelloController;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = DemoApplication.class)
public class DemoApplicationTests {

    @Autowired
    private HelloController helloController;

    private MockMvc mvc;


    @Before
    public void setUp() throws Exception {
        mvc = MockMvcBuilders.standaloneSetup(helloController).build();
    }

    @Test
    public void contextLoads() throws Exception {
//        mvc.perform(MockMvcRequestBuilders.get("/").accept(MediaType.APPLICATION_JSON))
//           .andExpect(status().isOk())
//           .andExpect(content().string(equalTo("Hello Spring Boot")));

        MvcResult mvcResult = mvc.perform(
                MockMvcRequestBuilders.get("/")
                                      .accept(MediaType.APPLICATION_JSON)
        )
                                     .andExpect(MockMvcResultMatchers.status().isOk())
                                     .andDo(MockMvcResultHandlers.print())
                                     .andReturn();
        String content = mvcResult.getResponse().getContentAsString();
        System.out.println(content);
    }
}

测试结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2019-01-07 07:29:31.555  INFO 7284 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/],methods=[GET]}" onto public java.lang.String cn.com.bmsmart.demo.controller.HelloController.sayHello()
2019-01-07 07:29:31.595  INFO 7284 --- [           main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.test.web.servlet.setup.StubWebApplicationContext@623ebac7
2019-01-07 07:29:31.616  INFO 7284 --- [           main] o.s.mock.web.MockServletContext          : Initializing Spring FrameworkServlet ''
2019-01-07 07:29:31.616  INFO 7284 --- [           main] o.s.t.web.servlet.TestDispatcherServlet  : FrameworkServlet '': initialization started
2019-01-07 07:29:31.617  INFO 7284 --- [           main] o.s.t.web.servlet.TestDispatcherServlet  : FrameworkServlet '': initialization completed in 1 ms

MockHttpServletRequest:
      HTTP Method = GET
      Request URI = /
       Parameters = {}
          Headers = {Accept=[application/json]}
             Body = <no character encoding set>
    Session Attrs = {}

Handler:
             Type = cn.com.bmsmart.demo.controller.HelloController
           Method = public java.lang.String cn.com.bmsmart.demo.controller.HelloController.sayHello()

Async:
    Async started = false
     Async result = null

Resolved Exception:
             Type = null

ModelAndView:
        View name = null
             View = null
            Model = null

FlashMap:
       Attributes = null

MockHttpServletResponse:
           Status = 200
    Error message = null
          Headers = {Content-Type=[application/json;charset=ISO-8859-1], Content-Length=[17]}
     Content type = application/json;charset=ISO-8859-1
             Body = Hello Spring Boot
    Forwarded URL = null
   Redirected URL = null
          Cookies = []
Hello Spring Boot

1.什么是Spring Cloud

Spring Cloud是一个中间件，有Spring官方开发维护，基于Spring Boot开发，提供一套完整的微服务解决方案。在Spring Cloud中对微服务基础框架Netflix的多个开源组件进行了封装。Spring Cloud为微服务架构开发涉及的配置管理，服务治理，熔断机制，智能路由，微代理，控制总线，一次性token，全局一致性锁，leader选举，分布式session，集群状态管理等操作提供了一种简单的开发方式。

github地址：https://github.com/spring-cloud

官网地址：https://spring.io/projects/spring-cloud

初学者视频：https://www.youtube.com/watch?v=aO3W-lYnw-o

微服务架构风格是一种将单个应用程序作为一套小型服务开发的方法，每种应用程序都在自己的进程中运行，并与轻量级机制（通常是HTTP资源API）进行通信。 这些服务是围绕业务功能构建的，可以通过全自动部署机制独立部署。 这些服务的集中管理最少，可以用不同的编程语言编写，并使用不同的数据存储技术。

说了这么多概念，微服务有什么样的具体特点呢？

1.独立部署，灵活扩展

传统的单体架构是以整个系统为单位进行部署，而微服务则是以每一个独立组件（例如用户服务，商品服务）为单位进行部署。

用一张经典的图来表现，就是下面这个样子：

图中左边是单体架构的集群，右边是微服务集群。

什么意思呢？比如根据每个服务的吞吐量不同，支付服务需要部署20台机器，用户服务需要部署30台机器，而商品服务只需要部署10台机器。这种灵活部署只有微服务架构才能实现。

而近几年流行的Docker，为微服务架构提供了有效的容器。

2.资源的有效隔离

微服务设计的原则之一，就是每一个微服务拥有独立的数据源，假如微服务A想要读写微服务B的数据库，只能调用微服务B对外暴露的接口来完成。这样有效避免了服务之间争用数据库和缓存资源所带来的问题。

同时，由于每一个微服务实例在Docker容器上运行，实现了服务器资源（内存、CPU资源等）的有效隔离。

3.团队组织架构的调整

微服务设计的思想也改变了原有的企业研发团队组织架构。传统的研发组织架构是水平架构，前端有前端的团队，后端有后端的团队，DBA有DBA的团队，测试有测试的团队。

而微服务的设计思想对团队的划分有着一定的影响，使得团队组织架构的划分更倾向于垂直架构，比如用户业务是一个团队来负责，支付业务是一个团队来负责。

当然，这种垂直划分只是一个理想的架构，实际在企业中并不会把团队组织架构拆分得这么绝对。

微服务与面向服务架构SOA的区别

SOA是什么样子呢？可以是下面这样的Web Service：

也可以是下面这样的ESB企业服务总线：

总之，SOA架构强调的是异构系统之间的通信和解耦合，而微服务架构强调的是系统按业务边界做细粒度的拆分和部署。

微服务架构的不足

1. == 与equals()的区别

2. 遍历map的几种方法

3.Map与Set的区别

4.java 中常用的集合类型

5.java访问修饰符

6.hashmap 实现的原理

1.接口绑定：两种方法，基于注解或者基于xml文档mapper，但要注意mapper的namespace要与接口路径完全一致。

2.orm格式转换：通过设置resultMap和ResultType，将数据库中的记录转换为代码的bean对象。得到list或者对象。

3.通过parameterType接收参数，进行动态sql生成。运用ognl表达式

4.走缓存，设置二级缓存。设置二级缓存源。

5.为什么要通过orm框架来走缓存呢？因为自己配置缓存策略相对复杂，比如当insert/update/delete时，要清除相应的缓存。当某些情况select又要添加进缓存。

6.orm框架，orm框架，它是怎么进行对象和数据库中表的转换的呢？答：数据库中的表要与代码中的类一一对应，包括属性。这样不就能进行匹配转换了嘛。

5.返回list，必须要配置resultMAp

6.insert操作时，要注意主键 主键生成策略，要设置useGeneraterKey = true,和 keyProperty=”id”，指定哪个是主键

1
2
3
4
5

<insert id="addUser" parameterType="User" 
        useGeneratedKeys="true" keyProperty="id"> 
        insert into user(userName,userAge,userAddress)  
             values(#{userName},#{userAge},#{userAddress})  
    </insert>

7.spring在于mybatis集成时，spring负责什么呢？谁来维护datasource，谁来建立sqlSessionFactory?

答:spring作为多个框架的粘合剂，spring负责建立datasource,sqlsessionFactpry。充分利用spring的ioc和aop功能。

;)

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

spring 配置文件：applicationContext.xml 


 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">//spring管理配置datasource
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/> 
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8"/>
    <property name="username" value="root"/> 
    <property name="password" value="password"/> 
 </bean> 

 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> //spring管理配置sqlsessionFactory
    <!--dataSource属性指定要用到的连接池--> 
    <property name="dataSource" ref="dataSource"/> 
    <!--configLocation属性指定mybatis的核心配置文件--> 
    <property name="configLocation" value="config/Configuration.xml"/> 
 </bean>

;)

8.Mybatis的dao实现接口（接口绑定），是由mybatis来实现的，那又怎么来使用这个实现类呢？

答：当然是注册到spring里了，作为一个bean使用。

即：mybatis的dao实现类，也都要注册到spring的ioc容器中，以便利用spring的ioc和aop功能。

注意此时dao实现类，的具体类是mybatis固定的org.mybatis.spring.mapper.MapperFactoryBean类，这个类专门用来生成具体的dao实现类。

但要记住，一切的增删改查都是通过session来进行的，所以dao实现类要di依赖注入sqlSessionFactory这个属性。

再利用mapperInterface指定具体的mapper接口类。

;)

1
2
3
4
5
6
7

spring 配置文件：applicationContext.xml 
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"> 
     <!--sqlSessionFactory属性指定要用到的SqlSessionFactory实例--> 
     <property name="sqlSessionFactory" ref="sqlSessionFactory" /> 
     <!--mapperInterface属性指定映射器接口，用于实现此接口并生成映射器对象--> 
     <property name="mapperInterface" value="com.yihaomen.mybatis.inter.IUserOperation" />
  </bean>

;)

9.即：mybatis的dao实现类，也都要注册到spring的ioc容器中，以便利用spring的ioc和aop功能。

10.spring的配置文件applicationContext.XML负责配置与数据库相关，与mybatis sqlSessionFaction 整合，扫描所有mybatis mapper 文件等相关内容。

事务管理器也在spring的配置文件中配置，同时要依赖注入datasource属性

1
2
3

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSource" />
   </bean>

11.mybatis的分页功能，可以自己利用mysql代码实现，也可以利用mybatis分页插件,如pageHelper

12.mybatis的传入参数只能是一个，只能有1个。可以是各种Java的基本数据类型：包含int,String,Date等。基本数据类型作为传参，只能传入一个。通过#{参数名} 即可获取传入的值 ，复杂数据类型：包含JAVA实体类、Map。通过#{属性名}或#{map的KeyName}即可获取传入的值，但是如果想传入一个collection怎么办呢？

经查找后发现可以使用mapper配置文件中的foreach语句，借用别人写的文章：

\13. foreach

对于动态SQL 非常必须的，主是要迭代一个集合，通常是用于IN 条件。List 实例将使用“list”做为键，数组实例以“array” 做为键。

foreach元素是非常强大的，它允许你指定一个集合，声明集合项和索引变量，它们可以用在元素体内。它也允许你指定开放和关闭的字符串，在迭代之间放置分隔符。这个元素是很智能的，它不会偶然地附加多余的分隔符。

\14. 在Java实体对象对中，一对多可以根据List和Set来实现，两者在mybitis中都是通过collection标签来配合使用

15.

一对一关联

1
2
3

根据班级id查询班级信息(带老师的信息)
10         ##1. 联表查询
11         SELECT * FROM class c,teacher t WHERE c.teacher_id=t.t_id AND c.c_id=1;

;)

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

<select id="getClass" parameterType="int" resultMap="ClassResultMap">
24         select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=#{id}
25     </select>
26     <!-- 使用resultMap映射实体类和字段之间的一一对应关系 -->
27     <resultMap type="me.gacl.domain.Classes" id="ClassResultMap">
28         <id property="id" column="c_id"/>
29         <result property="name" column="c_name"/>
30         <association property="teacher" javaType="me.gacl.domain.Teacher">
31             <id property="id" column="t_id"/>
32             <result property="name" column="t_name"/>
33         </association>
34     </resultMap>

;)

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

<!-- 
37     方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型
38         SELECT * FROM class WHERE c_id=1;
39         SELECT * FROM teacher WHERE t_id=1   //1 是上一个查询得到的teacher_id的值
40     -->
41      <select id="getClass2" parameterType="int" resultMap="ClassResultMap2">
42         select * from class where c_id=#{id}
43      </select>
44      <!-- 使用resultMap映射实体类和字段之间的一一对应关系 -->
45      <resultMap type="me.gacl.domain.Classes" id="ClassResultMap2">
46         <id property="id" column="c_id"/>
47         <result property="name" column="c_name"/>
48         <association property="teacher" column="teacher_id" select="getTeacher"/>
49      </resultMap>
50      
51      <select id="getTeacher" parameterType="int" resultType="me.gacl.domain.Teacher">
52         SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
53      </select>

　MyBatis中使用association标签来解决一对一的关联查询，association标签可用的属性如下：

• property:对象属性的名称
• javaType:对象属性的类型
• column:所对应的外键字段名称
• select:使用另一个查询封装的结果

15.

2.6、MyBatis一对多关联查询总结

　　MyBatis中使用collection标签来解决一对多的关联查询，ofType属性指定集合中元素的对象类型。

本文部分转自http://www.cnblogs.com/xdp-gacl/p/4264440.html

16.mybatis调用存储过程

;)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

三、编辑userMapper.xml

　　编辑userMapper.xml文件，添加如下的配置项

复制代码
 1 <!-- 
 2         查询得到男性或女性的数量, 如果传入的是0就女性否则是男性
 3      -->
 4     <select id="getUserCount" parameterMap="getUserCountMap" statementType="CALLABLE">
 5         CALL mybatis.ges_user_count(?,?)
 6     </select>
 7     
 8     <!--
 9         parameterMap.put("sexid", 0);
10         parameterMap.put("usercount", -1);
11      -->
12     <parameterMap type="java.util.Map" id="getUserCountMap">
13         <parameter property="sexid" mode="IN" jdbcType="INTEGER"/>
14         <parameter property="usercount" mode="OUT" jdbcType="INTEGER"/>
15     </parameterMap>
复制代码
四、编写单元测试代码

复制代码
 1 package me.gacl.test;
 2 
 3 import java.util.HashMap;
 4 import java.util.List;
 5 import java.util.Map;
 6 
 7 import me.gacl.custom.model.ConditionUser;
 8 import me.gacl.domain.User;
 9 import me.gacl.util.MyBatisUtil;
10 import org.apache.ibatis.session.SqlSession;
11 import org.junit.Test;
12 
13 /**
14  * @author gacl
15  * 测试调用存储过程
16  */
17 public class Test6 {
18     
19     @Test
20     public void testGetUserCount(){
21         SqlSession sqlSession = MyBatisUtil.getSqlSession();
22         /**
23          * 映射sql的标识字符串，
24          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值，
25          * getUserCount是select标签的id属性值，通过select标签的id属性值就可以找到要执行的SQL
26          */
27         String statement = "me.gacl.mapping.userMapper.getUserCount";//映射sql的标识字符串
28         Map<String, Integer> parameterMap = new HashMap<String, Integer>();
29         parameterMap.put("sexid", 1);
30         parameterMap.put("usercount", -1);
31         sqlSession.selectOne(statement, parameterMap);
32         Integer result = parameterMap.get("usercount");
33         System.out.println(result);
34         sqlSession.close();
35     }
36 }
复制代码

;)