来了铁子，看完别说不会了哦，SpringBoot【完结篇】！

大家好，我是小菜，一个巴望在互联网工作做到蔡不菜的小菜。可柔可刚，点赞则柔，白嫖则刚！
死鬼~看完记住给我来个三连哦！

“

本文首要介绍 SprinBoot
如有需求，可以参0 9 W 8阅
如有协助，h ] J ? z * 7 C e不忘 点赞 ❥

一、 缓存

1）JSR107

Java Caching定义了5个中心接口，分别是：

• CachingProvider

  定义了创u o a 8 % v立、配备、获取、处理和控制多个CacheManager。一个运用可以在运行期访问多个CachingProvider。

• CacheManager

  定义了创建、配备、获取、处理和控制多个仅有命名的Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所具有。

• Cacz f t # ; 3 $ = Fhe

  是一个类似Map的数据结构并[ g w x p y R 5 J暂时存储以Key为索引的值。一个Cache仅被一个CacO ~ 8 = jheManager所具有。

• Entry

  是一个存储在Cache中的 P ( Gkey-value对。

• Ep H : R ( n n Expiry

  每一个f Q X o b 1 [ 1存储在Cache中的条目有一个定义的有效期。一旦超过这个时刻，条目为过期的情况。一旦过期，条目将不行访问、更新和删去。缓存有效期可以通过ExpiryPolicy设置。

2）Spring缓存抽象

Spring从32 n Q R 1 5 ` 5.1开端定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统3 M P ; ? W e / 4一不同的缓存技术，并支x ? a H = 7 ^ O撑运用JCache（JSR-107）注解简化我们开发。

• Cache接口为缓存的组件标准定义，包括缓存的各种操作调集
• Cache接口下Spring供应了各种xxxCache的结束；如RedisCache，EhCacheCache ,ConcurrentMapCache等
• 每次调用需求缓存功用的方法时，Spring会检查指定参数的指定的政策方法是否现已被调用过，假设有就4 r * : 0 j直接从缓存中获取方法调用后的效果，假m E Z – 4 + _ o &如没有就调用方法并缓存效果后回来给用户。下次调用直接从缓存中获取。
• 运0 6 m ) % s P用Spring缓存抽象时我们需求关注以下两点：

1. 承认方法需求被缓存以及v X 7 y & T B他们的缓存战略
   2. 从缓存中读取之前缓存存储的数据

3）几个重要缓存注解

4）缓存运用

• 引入spring-boN . vot-starter-cache模块

<dependency>
<groupId>org.springframework.b* d voot</groupId>
<artifactId>spring-boot-starter-cache</artd =  v } : DifactI X N | i @ . 7Id>
</dependency>

• 利用@EnableCaching打开缓存

@MapperScan("cbuc.life.cache.mapper")
@SpringBootApB ! O l *  =plication
@Enable) B / 0Caching
pM k v t 8ublicclassSpringboot01Cac2 & i A L 6 dheApplication{
publicstaticvoidmain(String[]args){
SpringApplication.run(Springboot01CacheApplication.class,args);
}
}

• 注解运用

1. @Cacheable
2. @CacheEvict
3. @CachePut

将数据保存在ConcurrentMap<ObjecF r E O l @ )t, Object>中
开发中运用缓存中间件：redis、mw B { Y Xemcached、ehcach F m q z k 4 xe

5）几大特色

1. cacheNames/value： 指定缓存组件的姓名，将方法的回来效果放在哪个缓存中，是数组的方法，可以指定多个缓存
2. key： 缓存数据运用的key，可以用它来指定。默许是运用方法参数的值
3. keyGenerator： key的生成器，可以自己指定key的生成器的组件id
4. cacheManager：指定缓存处理器，或许 cacheResoD j q +lver 指定获取解析器
5. condition：指定符合条件的情况下才缓存
6. unless：否定缓存，当 unless 指定的条件为true，方法的回来值就不会被缓存
7. sync：是否运用V W M异步方法

• 示例

  1）

  

  注： 我们可以自定义keyGenerator

  @Configuration
  publicclassMyCacheConfig{
  @Bean("myKeyGenerator")
  publicKeyGeneratorkeyGenerator(){
  returnnewKeyGenerator(){
  @Override
  publicObjectgenerate(Objecttarget,Methodmethod,ObjeR S 2 ] g Gct...parw ! U k ` v & $ams){
  ret7 +  zurnmethod.getName()+"["+Arrays.asList(params).toSz G q 1 }tring()+"]";
  }
  };
  }
  }
  

2）

3）

4）

6）整合redis

1. 引入spring-boot-s/ ( x w +tarter-data-redis

<depenj N o p k _ g ;dency>
<groupId>org.sprin d 6gframework.b} [ z z 7 ] Moot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. apply ) @ l = vication.yml配备 redis 联接地址

spI / c Mring.red] ` 9is.hoE - A A s {st=118.24m A x o p K 8.44.169

3. 运用ReditTemplate操作redis
   常用方法：

   redisTemplate.ops{ s E n ( ~ ForValue() f l p S;//操作字符串
   redisTemplate.opsForHash();//操作hash
   redisTemplate.opsForList();//操作? 1 Z # J { Clist
   re1 W V t I M q gdisTemplate.opsForSet();//操作set
   redisTemplate.opsForZSet();//操作有序set
   

4. 配备缓存

   

5. 自定义redisTemplate

   

6. 将自定义的redisT^ b D / 3 ^ }emplate注册进RedisCacheManager

   

二、消息

*大多运用中，可通过消息服务中间件来进步系统异步通讯、扩展解耦才能 *

消息服务中两个重要概念：

• 消息署理（message brokerL $ – n R P）
• 目的地（destination）

当消息发送者发送消息今后，将由消息署理接纳，消息署理保证消息传递到指定目的地。

消息队伍^ – { 7首要有两种方法的目的地

• 队伍（, N r r } `qu[ # [ k . 2 Ceue）：点: D t对点消息o f t 8 l d F o通讯a N X ] 6 X r g ?（point-to-point）J B p W J i ~
• 主题（topic）：发布（publish）/订阅（subscribe）消息通讯

点对% ( k 0 3 4 7点式

• 消息发送者发送消息，消息署理将其放入一个队伍中，消息接纳者从队伍中R o ` #获取消息内容，消息读取后被移出队伍
• 消息只要仅有的发送者和接受者，但并不是说只能有一个接纳者

发布订阅式

• 发送者（发布者）发送消息到主题，多个接纳者（订阅者o ? a N）监听（订阅）这个主题，那么就会在消息抵达时一起收到消息

JMS（Java Message Service）JAVA消息服6 Z E ` l n D务

• 依据JVMT r ( p o #消息M g y x f署理的标准。ActiveMQ、HornetMQ是JMS结束

AMQP（Advanced Message Queuing Protocol）

• 高级u e 9 C l &消息队伍协议，也是一个消息署理的8 T l H % ? n标准} { b z 2 _ I，兼容JMS
• RabbitMQ是AMQP的结束

Spring支撑

• spring-jms供应了对JMS的支撑
• spring-rabbit供应了对AMQP的j G [ r Z q s N #支撑
• 需求ConnectionFactory的结束来联接消息署理H . g t N . z
• 供应JmsTemplr ~ B ) M p P !ate、RabbitTemplate来发送消息
• @JmsListener（JMS）、@RabbitListener（AMQP）注解在方法上监听消息署理发布的消息
• @EnableJms、@EnableRabbit打开支撑

Spring Boot自动配备

• JmsAutoConfiguration
• RabbitAutoConfiguration

RabbitMQ

简介：
RabbiM X a / + M P tMQ是一个由erlang开发的AMQP(Advanved MessagO E x ; ke Queue Protocol)的开源结束。
中心概念：

• Message：
  消息，消息是不签字的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选特色组成，这些特色包括routing-key（路由键）、priority（相关于其他消息的优先权）、delivery-mode（指出该消息或许需求持久性存储）等。
• Publis F W v k f d P @her：
  消息的生产者，也是一个向交换器发布消息的客户端运用程序。
• Consumer：
  消息的顾客，w a Y f i 9 R :标明一个从消息队伍中取得消息的客户端运用程序。
• Exchange：
  交换器，用来接纳生产者发送的消息并将这些消息路由给服务器中的队伍。
  不同类; – w f z ! : m型的Exch/ X K J q | 7 )ange转发消息的战略有所差异M T N F Z
• direct(默许)
• fanout
• topic
• headers
• Queue：
  消息队伍，用来保存消息直到发送给顾客。它是消息的容器，也是消息N b F 1 / R c Q的终点。一个消息可G ` 2投入一个或T U S多个队伍。消息一直在队伍里面，等候顾客联接到这个队伍将其取走。
• Binding：
  绑定，用于消息队伍和交换器之间的相关。一个绑定就是依据路由键将交换器和消息队伍联接起来的路由规则，所: @ _ H ! 7 { K以可以将交换器了解成一个由绑定构成的路由表。
  Exchange 和Queue的绑定可以是多对多的联系。
• Connection：
  网络联接，比方一个TCPj } + ,联接。
• Channel：
  信道，多路复用联接中的一条独立的双向数据流通道。信道是E m建立在实在的TCP联接内的虚拟联接，AMQP 指令都是通过信道发出去的，不管是发布消息、订阅队伍仍是接纳消息，这些动作都是通过信道结束。因为关于操作系统来说建立和毁掉 TCP 都@ u V 2 V b / ~是十分贵重的开支，) a g C : u + m N所以引入了信道的$ % * K 3 O f概念，以复用一条 TCP0 f c . 4 y 联接。
• Virtual Host：
  虚拟主机，标明一批交换器、消息队伍和相关对象。虚拟主机* m o Q ~ C + J是共享相同的身份认证和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQJ [ z G 服务器，具有自己的队伍、交换器f r v、绑定和权限机制。vhost 是 AMQP 概念的根底，K 7 P n y v必须在联接时指定，RabbitMQ 默许的 vhost 是 / 。
• BroM i v v Jker：
  标明消息队伍服务器实体

运行机制：J u ? X

• AMQP 中的消息路由

  AMQP 中消息的路由过程和 Java 开发者熟悉的 JMS[ I W % y v s 存在一些差别，AMQP 中增加了 Exchange 和Binding 的人物。生产者把消息发布到 Exchange 上，消息终究抵达队伍并被顾客接纳% ~ ~ l H O M X，而 Binding 决定交换器的消息应该发送到那个队伍。

  

• Exchange 类型

Exchange分发消息时依据类型的不同分发战略有差异，目前共四种类型：direct、fanout、topic、headers 。headers 匹配 AMQP 消息的* header 而不是路由键*， *headers 交换器和 direct 交换器完全S ; Z e共同*，但功能差许多，目前几乎用不到q F g $ 2 ) y了，所以直接看其他三种类型：

1. direct

   

   消息中的路由键（routing key）假设和 Binding 中的 binding key 共同， 交换器就将消息发到对应的队伍中。路由键与S r d Y 8 a M g 6队伍名完全匹配，假设一个队伍绑定到交换机要求路由键为“dog”，则只转发 routim E x * $ X :ng key 标记为“dog”的消息，不会转发“dog.puppy”，也不会转发“dog.guard”等等。它是完全匹配、单) & . u播的方法。

2. fanout

   

   每个发到 fanout 类型交换器的消息都会分到全部绑定的队伍上去。fanout 交换器不处理路由键，仅仅简略的将e 2 M , y T % _ v队伍绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的全部队伍上。很像子网广播，每台O # ] + U子网内的主机都取得了一份仿制的消息。fanout 类型转! J $发消息o 8 u是最快的。

3. topic

   

   topic 交换器通过l ] .方法匹配分配消息的路由键特色，将路由键和某个方法进行匹配，此时队伍需求绑定到一个方法上。它将路由键和绑定键的字符串切分成单词，这些单词之4 V @ } l E M间用点离隔。它相同也会辨认两个通配符：符号“#”和符号“*”。#匹配0个或多个单词，*匹s ] – 2配一1 ! | v R L b 4 }个单词。

整合Rab| 9 3 Y x wbitMQ

• 引入 spring-boot= w ~ O z z 7 M-starter-amqp

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>sprinK @ _ 4g-boot-starter-amqp&ltl H p d x S;/artifactId>
</dependencyw b V g B (>

• application.yml配备

spring.rabbir D u V S wtmq.host=118.24.44.169
spr/ ? K r F ding.rabbitmq.username=guest
spring.rabbitmq.password=guest

• 发起类
  

  

示例：

• 自定义消息转化器，以Jackson的方法转化

@Config! ; q / o e S furation
publicclassMyAMQPConfig{
@Bean
publicMessageConvertermessageConverter(){
returnnewJackson2JsonMessageConverter();
}
}

• 注入Bean

/**
*注入我们需求的两个bean
*/
@Autowired
Ra= 0 l U t GbbitTemplaterabbitTemplate;y 2 $
@Autowired
AmqpAdminamqpAdmin;

• 不同7 F ! u + l方法发送

• Service 中接纳消息示例
  留心要在发起类中打开依据注解的RabbitMQ方法 ：@EnableRabbK o 3 ] ) l cit
  

  

三、检索

我们的运用常常需求添L = i D加检索功用，开源的 ElasticS+ w l 0 o d ) 4earch是目前全文查找引擎的首选。他可以快速的存储、查找和剖析# K g . l海量数据。Spring Boot通过整合Spring Data E3 ; 8 M [ {lasticSearch为我们供应了十分方便的检索功用支撑；

Elasticsearch是一个分布式查找服务，供应Restful API，底层依据Luc3 q 1 3ene，选用多shard（分片）的方法保证数据安全，并且供应自动resharding的功用，github等大型的站点也是选用了ElasticSearch作为其查找服务

概念

以 员工文档 的方法存储为例：一个文档代表一个员工数据。存储数据到 ElasticSearch 的行为叫做索引，但在索引一个文档之前，需求承认将文档存储在哪里。
一个 ElasticSearch 集群可以 包括多个 索引，相应的每个索引可以包括多个 类型 。 这些不同的类型存储着多个 文档 ，每个文档又有 多个 特色 。

类似联系：

• 索引 ==== 数据库
• 类型 ==== 表
• 文档 ==== 表中的记载
• 特色 ==== 列

整合ElasticS( x ~ [ T E kearch

SpringBoot 默许支撑两种技术来和 ES 交互

• Jest（默许不收效）

导入jest的东西包% z q u {

<dependency>
<groupId>io.searchbox</gr: S CoupId>
<artifactId>jest</artifactId>
<version>5.3.3</version>
</dependency>

• SpringData ElasticSearch

1. 版别适配问题

   • 晋级SpringBoot版别
   • 装置对应版其他ES

2. 导入东西包

<!--SpringBoot默许运用Sg t J } ;pringDataElasticSearch模块进~ K { / ; @ 4 y行操作-r 0 /->
<dependency>
<groupId&gtY I 1 L L;org.springframework.boot</groupId>
<artifacz  % L : *tId>spring-boh g .  Xot-starter-data-elasticsearch</artifactId>
</dependency>

3. 装置Spring Data 对应版` 其他ElasticSearch
4. application.properties配备

spring.data.elasticsearcR # g ? 8 f 1h.cluster-name=elasticsearch
spring.data.elasticsearch.cluster-nodes=118.24.44.169:9301

5. 检验

• 注入Bean：

@Document(indexName=| % L @ 5"cbuc",type="book")
publicclassBook{
privateIntegerid;
privateStringbB p ( L u 8 a * =ookName;
privatl F I w A beStringauthor;
//省掉get/set方法
}

publicclassArticle{
@JestId
privaz . wteIntegerid B 3 { ud;
privateStringauthor;
privateStringtitle;
p_ 3 ) : / : I 1rivateStringcontent;
//省掉get/set方法
}

• 编写 ElasticsearchRepository：

publicinterfaceBookRepositor- Q d | e } ^yextendsElasticsearchRepository<Book,Integer>{
//参照https://docs.spring.io/spring-data/elasticsearch/docs/3.0.6.RELEASE/reference/html/
publicList<Book>findByBookNameLike(StringbookName);
}

• 引入所需求的Bean：

@Autowired
JestClientjestClient;
@Autowired
Book; h j * . v S t JRepositorybow e ? D M ` 4 wokRepository;

法1：
存入index：

Bookb3 Q = -ook=newN , n . t w w jBook();
book.setId(1);
book.setBookName("西游记");
book.seH o tAuthor("吴承恩");
bookRepository.l * ( J U } r 3index(book);

取：

for(Bookbook:bookRepository8 X m X Z ^.findByBookNameLi[ ] 6 ^ 6ke("游R @ , q u u")){
System.out.priR ) - X - d a &ntln(book);
}

法2：

//给EU 3 V g ^s中索引（保存）一个文档：
Articlearticle=newArticle()f - ! M z G;
article.setId(1);a : A V
article.setTit0 k E = ? ? & i Dle("检验");
article.setAuthor("cbuc");
article.setContent("检验检索");
//构7 ! ` W e ~ I 5建一个索引功用
Indexindex=newIndex.Builder(article).index("cbuc").type("news").build();
//履行
jestClient.execute(9 n sindex);

检验查找：

//查询表达式
@Test
publicvoidsearch(){
//查询表达式
Stringjson="{n"+6 B A | = K 0
""query":{n"+
""match":{n"+d 6 { W n 1 m
""content":"hello"n"+
"}n"+
"}n"+
"}";
//更多操作：https://github.com/searchbox-io/Jest/tree/master/jest
//7 q M ;构建查找功用
Searchsearch=newSearch.Builder(json).addIndex("cbuc").addType("news").build();
//履行
try{
SearchResultresult=jestClient.execute(search);
System.out.println(result.getK ` @ ) 4  { IJsonString());
}catch(IOExceptione){
e.printStac4 S (kT- l [ [ = | ( ]racp * fe();
}
}

四、任务

异步任务

在Jy 4 + iava运用中，绝大多数情况下都是通过同步的方法来结束交互处理的。但是在处理与第三方系统交互的时分，容易形成照应缓慢的情况，之前大部分都是运用多线程来结束此类任务，其实，在Spring 3.x之后，就现已内E A – c置了@Async! E = +来完美处理这个问题。
两个注解：

• @EnableAysnc
• @Aysnc

运用：

1. 发起类打开异步注解功用

@EnableAsync//打开异步注解功用
@SpringBootApplicati4 o } ` +on
publicclassSpringboot04TaskApplication{
publicstaticvoidmain(String[]args){
SpringApplication.run(Springboot04TaskApplication.class,args)Z 4 } 9 F B;
}
}

2. Service:

@S* t = $ # * L lervice
publicclassAsyncService{
//奉告Spring这是一个异步方法
@Asyn 3 1 - /c
pub_ H n O @ { +licvoidtest(){
try{
//当前线程睡眠3秒页面也能及时照应
Thread.sleep(3000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println("处理数据中...");
}
}

3. Controller:

@RestController
puby [ l P M jlicclassAsyncController{
@Autowired
AsyncServiceasyncService;
@GB : L Z W 1etMapa 8 1 O X w p t 4ping(* 4 1 F"/hello")
publicStringhello(){
asyncServicj B w je.test();
return"success";
}
}

守时任务

项目开发中n 0 j O常常需求履行一 ^ K ( C些守时任务，比方需求在每天凌晨时分，剖析一次前一天的日志信息( 5 8 b W。Spring为我们供应了异步履行任务调度的方法，供应TaP E o , u } x CskExecutor、TaskScheduler接口。
两个注解：

• @EnableScheduling
• @Scheduled

cr: C D d k ? I n Pon表达式：

运用：

1. 发起类打开依据注解的守时任务? j | g B N V F s:

@EnableSched& X . } +uling/: x - E L/打开依据注解的守时任务
@SpringBootApplication
publicclr v Q & ! 1assSpringboot04TaskApplication{
publicstaticvoidmain(String[]args){
SpringApplication.run(Springboot04TaskApplication.class,args);
}
}

2. Service：
   

   

邮件任务

运用：

1. 邮件发送需求引入spring-boot-starter-mail

<dependency>
<groupId>orp I Kg.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</C i l L Y - t E .artifactId>
</dependency>

2. 定义MailProperties内容，配备在application.proM $ C 7perties中

spring.m5 Q L I j M 8 } Cail.username=（发送人qq账号）
spring.mail.password=（发送人qt + s xq暗码）
spring.mail.host=smtA x - 3 p _ |p.qq.com
spring.mail.properties! [ d %.mail.smtp.sa ] s n } 3 2sl.enable=true

3. 自动装置JavaMailSender
   

   

五、分布式系统

单一运用架构
当网站流量很小时，只需一个运用，将全部功用都安置在一起，以削减安置节点和成本。此时，用于简化增修正查工作量的数据访问结构(ORM)是要害。
垂直运用架构
当访问量逐渐增大，单一运用增加机器带来的加快度越来越小，将运用拆成互不相干的几个运用，以进步效率。此时，用于加快前端页面开发的Web结构(MVC)P ; z h –是要害。
活动核算架构
当服务越来越多，容量的评价，小服务资源的糟蹋等问题逐渐闪现，此时需增加一个调度中心依据访问压力实时处理集群容量，进步集群利用率。此时，用于进步机器利用率的资源调度和管理中心(SOA)是要害
分布式服务架构
当L # D [垂直运用越来越多，运用之间交互不行避免，将中心业务抽取出来，作为d r n o )独立的服务，逐渐构成稳定的服务中心，使前端运用能更快速的照应多变的市场需求。此时，用于进步业务复w U b E u q用及整合的分布式服务结构(Rr O j ; 6 e z PC)是要害。

Zookeeper和Dubbo% F O A = , c

ZooKeeper：
是一j = v I t a个分布式的，开放源码的分布c 8 w / e j式运用程序和谐服务。它是一个为分布式运用供应共同性服务的软件，供应的功用包括：配备维护、域名服务、分布式同步、组服务等。
Dubbo：
是Alibaba开源的分布式服务结构，它最大的特色是依照分层的方法来架构，运用这种方法可以使各个层之间解耦合（或许最大极限地松耦合）。从服务模型的角度来看，Dubbo选用的是一种十分简略的模型，要么是供应方供应服务，要么是消费方消费服e Y p u ( ( M务，所以依据这一点可以抽象出服务供应方（Provider）和服务消费方（Consumer）两个人物。

运用：

• 装置zookeeper作为注册中心
• 编写服务供应者

引入dubbo和zkclient相关依托v 8 f { y ;

<dependency>
<groupId>com.L f # C f a Lalibaba.boot</groupId>
<artifactId>dubbo-spring-boo` R d @ = {t-starter</artifactId&g, I ? P o a g *t;
<version>0.1.0</versi? f  E z : n 5 Won>
</dependency>

<!--引入zookeeper的客户端东西-->
<!--https://m0 % 0 W 4vnrepository.com/artifact/com.github.sgroschupf/zkclient-->
<dependency>
<groupId>com.githuz j {  Y B % ~b.k 2 Ksgroschu [ ` / u ) % + `pf</groupId>
<artifactId&gt0 k 5 L $ i 2 w ];zkclient</artifact~ / ~ T y uId>
<version>0.1</va ~ Wersion>
</dep i E o w 9pej } 7 N w I N H endency>

配备dubbo的扫描包和注册中心地址

dubbo.F s | p , N Fapplication.naL [ 4 u , 8 0 |me=provider-tickW t ] / 7 @ 0et
dubbo.registry.address=zookeeper://118.24.44.169:2181
dubbo.scan.base-package R m R C u Ss=cbuc.life.ticket.service

运用@Service发布服务

@Componev X Lnt
@S| 3 - U ( T terviM v B n /ce//将服务发布出去留心注解Service是dubbo包下的
publicclassTicketServD e 2 ? YiceImplimplementsTicketService{
@Override
publicStringgetTicket(){
return"《我和我的祖国》";
}
}

• 编写服务顾客

引入dubbo和zkclient相关依托

<dependency>
<groupId>com.ali8 8 Q l y ) } g fbaba.boot</groupId>
<artifactId>dubbo-spring-b= { S #o) 9 Zot-star } w Jter</artifactId>X O  * T E
<j L   ; f $ 7versio* C , + 0 @n>0.1.0<B s e N & b/version>
</dependency>

<!--引入zook0 N | !  H s |eeper的客户端东西--F y { 7 # N>
<!--https://mvnreposi) @ )tory.com/artifact/com.github.sgrosg u  2 ?chupf/zkclient-->
<dependency>
<groupId>com.github.sgroschupf</groupId&. N 2 N _ m % % bgt;
<artifactId>zkclient</artifactId>
<verse 0 3 I . 9ion>0.1</version>
</dependency>

引用服务

@Service
publiccl{ Q . 6 assUserServiM V t & _ce{
@Reference//运用Re* 9 a ; u . #ference引入服务
TicketServi] Z vceticketService;
publicvoidhello(){
Stringticket=tiG z # H = - rcketService.getTicket();
System.out.println("调用买票服务："+tickE 2 +et);
}
}

Spring Boot和Spring Cloud

Spring Cloud是一个分布式的整体处理方案。Spring Cloud 为开发者供应了在分布式系统（配备处理，服务发现，熔断，路由，微署理，控制总线，一次性token，全局琐，leader推举，分布式session，集群情况）中快速构建的东西，运用Spring Cloud的开{ ( ? F f M t P发者可以快速的发起服务或构建运用、一起可以快速和云渠道资源进4 ! r 2 B 1 G行对接。
SpringCloud分布式开发五大常用组件：

• 服务发现 —— Netflix Eureka

• 客服端负载均衡 —— Netflix Ribbon

• 断路器 —— Netflix Hystrix

• 服务网关 —— Netflix Zuul

• 分布式配备 —! = c Z C 9 %— Spring Cloud Config

运用：

• 引入Eureka注册中心

<dependencyManagement>
<dependencies>

<depq n [ P . o 3 9endency>
&l= [ v ht;groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter5 , S t-eureka-server</artifactId&gth V *;
</dependency>

<dependency>
<groupId>org.sY o : v 0pringframework.cloud</groupId>
<artifactId>spring-cloud-dependencies<x l % ` U [/artifactIl ) _ F # ^ Od>
<version>Edgware.SR3</version>
<type>pom</td + ! R n ) [ype>
<scope>import</scope>
</dependen9 L `cy&gt~ 4 ^ Q b ! e f r;

</dep4 I ^ b d Y $endencies>
</dependencyManagement>

• 配备application

server:
port:8761
eureka:
instanC P e ; oce:
hostname:eureka-server#eureka实1 : f h  ? Z S例的主机名
client:
register-with-eureka:false#不把自己注册到eureka上
fety + / - M y a - Ich-registry:~ M ! ` 8 z P lfalse#不从eureka上来获取服务的注册信息
sM } Rervice-url:
defaultZone:http://E 9 x m Alocalhost:8761/eureka/

• 发起类：

@En s - $ 7 v TableEurekaServer
@Spri. r D Z angBootApplication
publicclassEurekaServerApplication{
publicstaticvoidmain(String[]args){
SpringApplicaW 0 /tion.ru4 ? ~n(EurekaServerAD  : J # Y spplication.class,args);
}
}

• 创建provider

  引入依托

  <dependencyMan) ; Xagement>
  <dependencies>
  &lt;dependency&gt;
  &lt;groupId&gt;org.springframework.cloud&lt;/grou] z { = +pId&gt;
  &amn { P ] ? y p;lt;artifactId&gt;H / @ f  uspring-cloud-starter-eureka-server&lt;/artifactId&gt;
  &lt;/dependency&gt;
  
  &lt;dependency&gt;
  &lt;grouf e b (pId&gt;org.springfra|  | , bmework.cloud&lt;/groupId&gt;
  &lt;artifactId&gt;springV Y c-cloud-dependencieu 1 7 a Ds&lt;/artifactId&gt;
  &lt;version&gt;EdgwV ~ G u p Yare.SR3&lt;/version&gt;
  &lt;type&gt;pomS b 6 b C x w 5&lt;/type&gt;
  &lt;scope&gt;import&lt;/scope&gt;
  &lt;/d a Idependency&gt;
  
  </dependencies>
  </dependencyManagement>
  
  配备application
  seG ! h 5 } W c 9 ,rver:
  port:8002
  spring:
  appB * h O n glication:
  name:provider-ticket
  eureka:
  instance:
  prefn 6 U M ( ` u 0 ner-ip-address:true#注册服务的时分运用服务的ip地址e ^ q W a & m
  cM Y - | . blient:
  service-url:
  defaultZone:http://loca+ % B [ 9lhost:8761/eureka/
  
  发起类
  @SpringBootApplication
  pug M ]  5blicclassProviderTicketApplication{
  publicstaticvoidmain(SN v x H r Z r b ktring[]args){
  SpringApplicatiE F 2on.runK Y l _(ProviderTicketApplication.class,args);
  }
  }
  
  service
  @ServiceI . i
  public) e 5 T g S ~ NclassTicketService{
  
  publicStringgetTicket(){
  return"《我和w - h Z i我的祖国》";
  }
  }
  
  controller
  @RestController
  publicclassTicketController{
  @AutowiredO d 0 G v f P
  TicketServiceticketSerd u 2vicR r 9 J K g ae;
  @GetMapping("/ticket")
  publicStringgetTicket(){
  returnticketService.getTicket();
  }
  }
  
  

• 创建consumer

  引入依托

  <dependencyManagement>
  <dependencies>
  &lt;dependenct : / $y&gt;
  &lt;groupId&gt;org.spr= 1 K c V & T U Fingframework.cloud&lt;/groupId&gt;
  &lt;artifactQ P . % rId&ampb ^ * + ` (;gt;spring-cloud-dependencies&lt;/artifactId&T p : h | c e d {amp;gt;
  &lt;version&gt;Edgware.SR3&lt;/version&gt;
  &lt;type&gt;pom&lt;/ty8 3 C Z Wpe&gW F F T R Gt;
  &lt;scope&gt;import&lt;/scope&gt;
  &lt;/dependency&gt;
  
  &l3 : { A ; ( . dt;dependency2 y e&gt;W 6 ^ { 9 { n
  &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt;
  &lt;artifactId&gt;spring-cloud-starter-eureka-server&lt;/artifactIw & $ m Dd&gt;
  &lt;/dependency&gA - $ l : Pt;
  
  </dependencies>
  &k 9 C x u f slt;/dependencyManagement>
  
  配备application
  sprib 1 $ k 6ng:
  application:
  name:consT + D L q , bumer-user
  server:
  port:8200
  eureka:
  instance:
  prefer-ip-address:true#注册服务的时分运用服务的ip地址i S c x
  client:
  service-url:
  defaultZone:http://localhost:8761/eureka/
  
  发起类
  @EnableDiscoveryClient//打开发现服务功用
  @SpringBootApplication
  publicclassConsumerUserApplicaX w # s a )tion{
  
  publicstaticvoidmain(String[]args){
  SpringApplication.run(ConsumerUserApplication.class,args);
  }
  
  @LoadBalanced//运用负载均衡机制
  @Bean
  publicRestTemplaterestTemplate(){m } 6 S ] $ | . X
  returnnewRestTemplate();
  }
  }
  
  controlleh U I Gr (通过运用RestTemplate调用服务)
  @Res* 6 D ! S W F I PtController
  publicclassUserController{
  
  @Autowired
  RestTemplaterestTemplate;
  
  @GetMapping("/buy")
  publicStringbuy  X 2 jyTicket(Stringname){
  Strings=restTemplate.getForObject("http://PROVIDER-TICKET/ticket",Stringp Y % p ) x f.class);
  returnname+"购买了"+s;
  }
  }
  
  

“

今日的你多尽力一点，明日的你就I ( 9能少说一句求人的话！

我是小菜，一个和你一起学习的男人。