SpringCloud 專案搭建 -Eureka

一、Eureka簡介

　　Eureka是Netflix開發的服務發現框架，本身是一個基於REST的服務，主要用於定位執行在AWS域中的中間層服務，以達到負載均衡和中間層服務故障轉移的目的。SpringCloud將它整合在其子專案spring-cloud-netflix中，以實現SpringCloud的服務發現功能。

　　1、Eureka元件

　　Eureka包含兩個元件：Eureka Server和Eureka Client。

　　1.1 Eureka Server

　　Eureka Server提供服務註冊服務，各個節點啟動後，會在Eureka Server中進行註冊，這樣Eureka Server中的服務登錄檔中將會儲存所有可用服務節點的資訊，服務節點的資訊可以在介面中直觀的看到。
　　Eureka Server本身也是一個服務，預設情況下會自動註冊到Eureka註冊中心。
　　如果搭建單機版的Eureka Server註冊中心，則需要配置取消Eureka Server的自動註冊邏輯。

　　2.1 Eureka Client

　　Eureka Client是一個java客戶端，用於簡化與Eureka Server的互動，客戶端同時也具備一個內建的、使用輪詢(round-robin)負載演算法的負載均衡器。在應用啟動後，將會向Eureka Server傳送心跳,預設週期為30秒，如果Eureka Server在多個心跳週期內沒有接收到某個節點的心跳，Eureka Server將會從服務登錄檔中把這個服務節點移除(預設90秒)

　　2.1.1 Application Service

　　服務提供方，是註冊到Eureka Server中的服務。

　　2.1.2 Application Client

　　服務消費方，通過Eureka Server發現服務，並消費。

　　在這裡，Application Service和Application Client不是絕對上的定義，因為Provider在提供服務的同時，也可以消費其他Provider提供的服務；Consumer在消費服務的同時，也可以提供對外服務。

　　2、Eureka Server架構原理簡介

Register(服務註冊)：把自己的IP和埠註冊給Eureka。
Renew(服務續約)：傳送心跳包，每30秒傳送一次。告訴Eureka自己還活著。
Cancel(服務下線)：當provider關閉時會向Eureka傳送訊息，把自己從服務列表中刪除。防止consumer呼叫到不存在的服務。
Get Registry(獲取服務註冊列表)：獲取其他服務列表。
Replicate(叢集中資料同步)：eureka叢集中的資料複製與同步。
Make Remote Call(遠端呼叫)：完成服務的遠端呼叫。

　　Eureka Server
　　Eureka Server既是一個註冊中心，同時也是一個服務。那麼搭建Eureka Server的方式和以往搭建Dubbo註冊中心ZooKeeper的方式必然不同，那麼首先搭建一個單機版的Eureka Server註冊中心。

SpringCloud-Eureka 專案整合搭建

建立dept資料庫 sql 檔案

 1 /*
 2  Navicat Premium Data Transfer
 3 
 4  Source Server         : localhost_3306
 5  Source Server Type    : MySQL
 6  Source Server Version : 50527
 7  Source Host           : localhost:3306
 8  Source Schema         : db01
 9 
10  Target Server Type    : MySQL
11  Target Server Version : 50527
12  File Encoding         : 65001
13 
14  Date: 04/11/2020 23:03:17
15 */
16 
17 SET NAMES utf8mb4;
18 SET FOREIGN_KEY_CHECKS = 0;
19 
20 -- ----------------------------
21 -- Table structure for dept
22 -- ----------------------------
23 DROP TABLE IF EXISTS `dept`;
24 CREATE TABLE `dept`  (
25   `deptno` int(11) NOT NULL AUTO_INCREMENT,
26   `dname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
27   `db_source` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
28   PRIMARY KEY (`deptno`) USING BTREE
29 ) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
30 
31 -- ----------------------------
32 -- Records of dept
33 -- ----------------------------
34 INSERT INTO `dept` VALUES (1, '開發部', 'db01');
35 INSERT INTO `dept` VALUES (2, '人事部', 'db01');
36 INSERT INTO `dept` VALUES (3, '財務部', 'db01');
37 INSERT INTO `dept` VALUES (4, '市場部', 'db01');
38 INSERT INTO `dept` VALUES (5, '運維部', 'db01');
39 INSERT INTO `dept` VALUES (6, '遊戲部', 'db01');
40 INSERT INTO `dept` VALUES (7, NULL, 'db01');
41 
42 SET FOREIGN_KEY_CHECKS = 1;

1.建立maven專案

Springcloud Maven 總專案統一管理maven依賴以及依賴版本

新增springcloud所需要的pom依賴

pom檔案裡的 <modules>標籤可以先註釋起來。搭建到哪裡再開啟

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <project xmlns="http://maven.apache.org/POM/4.0.0"
  3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5     <modelVersion>4.0.0</modelVersion>
  6 
  7     <groupId>com.puyu</groupId>
  8     <artifactId>springcloud</artifactId>
  9     <version>1.0-SNAPSHOT</version>
 10     <modules>
 11         <module>springcloud-api</module>
 12         <module>springcloud-provider-dept-8001</module>
 13         <module>springcloud-provider-dept-8002</module>
 14         <module>springcloud-provider-dept-8003</module>
 15         <module>springcloud-consumer-dept-81</module>
 16         <module>springcloud-eureka-7001</module>
 17         <module>springcloud-eureka-7002</module>
 18         <module>springcloud-eureka-7003</module>
 19         <module>springcloud-consumer-dept-feign</module>
 20         <module>springcloud-provider-dept-hystrix-8001</module>
 21         <module>springcloud-consumer-hystrix-dashboard</module>
 22         <module>springcloud-zuul</module>
 23         
 24     </modules>
 25 
 26     <!-- 打包方式 pom-->
 27     <packaging>pom</packaging>
 28     <properties>
 29         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 30         <maven.compiler.source>1.8</maven.compiler.source>
 31         <maven.compiler.target>1.8</maven.compiler.target>
 32         <junit.version>4.12</junit.version>
 33         <lombok.version>1.18.12</lombok.version>
 34         <log4j.version>1.2.17</log4j.version>
 35     </properties>
 36 
 37     <dependencyManagement>
 38         <dependencies>
 39             <!--  springcloud 依賴    -->
 40             <dependency>
 41                 <groupId>org.springframework.cloud</groupId>
 42                 <artifactId>spring-cloud-dependencies</artifactId>
 43                 <version>Greenwich.SR1</version>
 44                 <type>pom</type>
 45                 <scope>import</scope>
 46             </dependency>
 47             <!--  springboot 依賴     -->
 48             <dependency>
 49                 <groupId>org.springframework.boot</groupId>
 50                 <artifactId>spring-boot-dependencies</artifactId>
 51                 <version>2.1.4.RELEASE</version>
 52                 <type>pom</type>
 53                 <scope>import</scope>
 54             </dependency>
 55             <!--  資料庫依賴      -->
 56             <dependency>
 57                 <groupId>mysql</groupId>
 58                 <artifactId>mysql-connector-java</artifactId>
 59                 <version>5.1.47</version>
 60             </dependency>
 61             <dependency>
 62                 <groupId>com.alibaba</groupId>
 63                 <artifactId>druid</artifactId>
 64                 <version>1.1.10</version>
 65             </dependency>
 66             <!--  springboot 啟動器 依賴      -->
 67             <dependency>
 68                 <groupId>org.mybatis.spring.boot</groupId>
 69                 <artifactId>mybatis-spring-boot-starter</artifactId>
 70                 <version>1.3.2</version>
 71             </dependency>
 72             <!--  主要用於日誌和測試 -->
 73             <!--    junit      -->
 74             <dependency>
 75                 <groupId>junit</groupId>
 76                 <artifactId>junit</artifactId>
 77                 <version>${junit.version}</version>
 78             </dependency>
 79             <!--     lombok       -->
 80             <dependency>
 81                 <groupId>org.projectlombok</groupId>
 82                 <artifactId>lombok</artifactId>
 83                 <version>${lombok.version}</version>
 84             </dependency>
 85             <!--    log4j      -->
 86             <dependency>
 87                 <groupId>log4j</groupId>
 88                 <artifactId>log4j</artifactId>
 89                 <version>${log4j.version}</version>
 90             </dependency>
 91             <dependency>
 92                 <groupId>ch.qos.logback</groupId>
 93                 <artifactId>logback-core</artifactId>
 94                 <version>1.2.3</version>
 95             </dependency>
 96             <!--      test      -->
 97             <dependency>
 98                 <groupId>org.springframework.boot</groupId>
 99                 <artifactId>spring-boot-test</artifactId>
100             </dependency>
101             <dependency>
102                 <groupId>org.springframework.boot</groupId>
103                 <artifactId>spring-boot-wen</artifactId>
104             </dependency>
105             <!--    jetty        -->
106             <dependency>
107                 <groupId>org.springframework.boot</groupId>
108                 <artifactId>spring-boot-jetty</artifactId>
109             </dependency>
110             <!--     熱部署       -->
111             <dependency>
112                 <groupId>org.springframework.boot</groupId>
113                 <artifactId>spring-boot-devtools</artifactId>
114             </dependency>
115         </dependencies>
116     </dependencyManagement>
117 
118 
119 </project>

2.新建子專案springcloud-api

實體類存放的專案，此專案先只建立一個Dept專案

新增pom依賴

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.puyu</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-api</artifactId>
<!--當前的module自己需要的依賴，如果父依賴中已經配置了版本，這裡的不用寫版本號-->
    <dependencies>
        <!-- lombok依賴-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>

        <!--  Feign依賴  -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

    </dependencies>

</project>

建立Dept 實體類

 1 package com.puyu.springcloud.pojo;
 2 
 3 import lombok.Data;
 4 import lombok.NoArgsConstructor;
 5 import lombok.experimental.Accessors;
 6 
 7 import java.io.Serializable;
 8 
 9 @Data//lombok
10 @NoArgsConstructor
11 @Accessors(chain = true) //鏈式寫法
12 public class Dept implements Serializable {
13     private Long deptno;
14     private String dname;
15     private String db_source;
16 
17     public Dept(String dname) {
18         this.dname = dname;
19     }
20 }

3.新建子專案springcloud-consumer-dept-81

springcloud-consumer-dept-81 -------------為消費者

新增pom依賴

(1).pom裡匯入springcloud-api 依賴 拿到Dept類的例項

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <parent>
 6         <artifactId>springcloud</artifactId>
 7         <groupId>com.puyu</groupId>
 8         <version>1.0-SNAPSHOT</version>
 9     </parent>
10     <modelVersion>4.0.0</modelVersion>
11 
12     <artifactId>spingcloud-consumer-dept-81</artifactId>
13 
14     <!--  實體類+web依賴   -->
15     <dependencies>
16         <!--   新增ribbon需要的依賴 完成負載均衡    -->
17         <dependency>
18             <groupId>org.springframework.cloud</groupId>
19             <artifactId>spring-cloud-starter-ribbon</artifactId>
20             <version>1.4.6.RELEASE</version>
21         </dependency>
22         <!--  因為要從服務中心 判斷拿那些東西 所以需要eureka依賴  client 客戶端依賴    -->
23         <dependency>
24             <groupId>org.springframework.cloud</groupId>
25             <artifactId>spring-cloud-starter-eureka</artifactId>
26             <version>1.4.6.RELEASE</version>
27         </dependency>
28         <!-- 匯入springcloud-api 以便獲取到Dept例項-->
29         <dependency>
30             <groupId>com.puyu</groupId>
31             <artifactId>springcloud-api</artifactId>
32             <version>1.0-SNAPSHOT</version>
33         </dependency>
34         <dependency>
35             <groupId>org.springframework.boot</groupId>
36             <artifactId>spring-boot-starter-web</artifactId>
37         </dependency>
38         <!--   熱部署依賴     -->
39         <!--  <dependency>
40               <groupId>org.springframework.boot</groupId>
41               <artifactId>spring-boot-devtools</artifactId>
42           </dependency>-->
43     </dependencies>
44 </project>

建立application.yml 配置檔案

 1 server:
 2   port: 81  #訪問埠號
 3 
 4 #客戶端消費端 eureka配置
 5 eureka:
 6   client:
 7     register-with-eureka: false #先宣告不向eureka中註冊自己
 8     serviceUrl:
 9       defaultZone: http://localhost:7001/eureka
10   #    defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
11       #客戶端 隨機向defaultzone中隨機選擇一個去訪問 實現負載均衡

建立ConfigBean　　

什麼是RestTemplate

RestTemplate 是從 Spring3.0 開始支援的一個 HTTP 請求工具，它提供了常見的REST請求方案的模版，例如 GET 請求、POST 請求、PUT 請求、DELETE 請求以及一些通用的請求執行方法 exchange 以及 execute。RestTemplate 繼承自 InterceptingHttpAccessor 並且實現了 RestOperations 介面，其中 RestOperations 介面定義了基本的 RESTful 操作，這些操作在 RestTemplate 中都得到了實現。接下來我們就來看看這些操作方法的使用

 1 package com.puyu.springcloud.config;
 2 
 3 import com.netflix.loadbalancer.IRule;
 4 import com.netflix.loadbalancer.RandomRule;
 5 import org.springframework.cloud.client.loadbalancer.LoadBalanced;
 6 import org.springframework.context.annotation.Bean;
 7 import org.springframework.context.annotation.Configuration;
 8 import org.springframework.web.client.RestTemplate;
 9 
10 @Configuration
11 public class ConfigBean {
12 
13     //配置賦值均衡實現RestTemlate
14     //IRule
15     //RoundRobinRule 輪詢
16     //RandomRule 隨機
17     //AvailbiliryFilteringRule  :會過濾掉 跳閘，訪問故障的服務，對剩下的進行；輪詢S
18     //RetryRule 會先按輪詢的策略獲取服務，如果服務獲取失敗，則會在指定的時間內進行重試
19 
20     @Bean
21     @LoadBalanced //Ribbon 實現負載均衡
22     public RestTemplate getRestTemplate() {
23         return new RestTemplate();
24     }
25 
26 
27 }

建立Controller層

 1 package com.puyu.springcloud.controller;
 2 
 3 import com.puyu.springcloud.pojo.Dept;
 4 import org.springframework.beans.factory.annotation.Autowired;
 5 import org.springframework.web.bind.annotation.PathVariable;
 6 import org.springframework.web.bind.annotation.RequestMapping;
 7 import org.springframework.web.bind.annotation.RestController;
 8 import org.springframework.web.client.RestTemplate;
 9 
10 import java.util.List;
11 
12 @RestController
13 public class DeptConsumerController {
14 
15 
16     /*消費者 不應擁有service層*/
17     /*RestTemplate  供我們直接呼叫*/
18     /*(url,實體 :map,class<t> restTemplate)*/
19     @Autowired
20     private RestTemplate restTemplate; //提供多種便捷訪問遠端http服務的方法，簡單的restful服務模板
21 
22     //Ribbon 我們在這裡的地址應該是一個變數 ，通過服務名來訪問
23 
24    private static final String REST_URL_PREFIX = "http://localhost:8001";
25   //  private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";
26 
27     @RequestMapping("/test/ad")
28     public String aa(){
29     return "老子弄死你";
30     }
31 
32     @RequestMapping("/consumer/dept/add")
33     public boolean add(Dept dept) {
34         return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
35     }
36 
37     @RequestMapping("/consumer/dept/get/{id}")
38     public Dept get(@PathVariable("id") Long id) {
39         return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
40     }
41 
42     @RequestMapping("/consumer/dept/list")
43     public List<Dept> list() {
44         return  restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
45     }
46 }

建立springcloud-consumer-dept-81 啟動類

 1 package com.puyu.springcloud;
 2 
 3 import com.puyu.myrule.PuYuRule;
 4 import org.springframework.boot.SpringApplication;
 5 import org.springframework.boot.autoconfigure.SpringBootApplication;
 6 import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
 7 import org.springframework.cloud.netflix.ribbon.RibbonClient;
 8 
 9 
10 //Ribbon 和Eureka 整合以後客戶端可以直接呼叫服務端，不用關心埠號和ip地址
11 @SpringBootApplication
12 @EnableEurekaClient // Eureka Client  註冊到Eureka 註冊中心中
13 //在微服務啟動的時候就能去載入 自定義的Ribbon類 ---指定ribbon自定義類  name為 服務名
14 //@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = PuYuRule.class)
15 public class DeptConsumer_81 {
16     public static void main(String[] args) {
17         SpringApplication.run(DeptConsumer_81.class,args);
18     }
19 }

4.新建子專案 springcloud-provider-dept-8001
springcloud-provider-dept-8001---------------服務提供者

新增pom依賴

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <parent>
 6         <artifactId>springcloud</artifactId>
 7         <groupId>com.puyu</groupId>
 8         <version>1.0-SNAPSHOT</version>
 9     </parent>
10     <modelVersion>4.0.0</modelVersion>
11 
12     <artifactId>springcloud-provider-dept-8001</artifactId>
13     <!-- 我們需要拿到實體類，所以需要配置api module-->
14     <dependencies>
15         <!--Hystrix 依賴-->
16         <!--<dependency>
17             <groupId>org.springframework.cloud</groupId>
18             <artifactId>spring-cloud-starter-hystrix</artifactId>
19             <version>1.4.6.RELEASE</version>
20         </dependency>-->
21         <!--   eureka依賴     -->
22         <dependency>
23             <groupId>org.springframework.cloud</groupId>
24             <artifactId>spring-cloud-starter-eureka</artifactId>
25             <version>1.4.6.RELEASE</version>
26         </dependency>
27         <!--actuator完善監控資訊 Hystrid 流監控所需要的jar依賴-->
28         <dependency>
29             <groupId>org.springframework.boot</groupId>
30             <artifactId>spring-boot-starter-actuator</artifactId>
31         </dependency>
32 
33         <dependency>
34             <groupId>com.puyu</groupId>
35             <artifactId>springcloud-api</artifactId>
36             <version>1.0-SNAPSHOT</version>
37         </dependency>
38         <dependency>
39             <groupId>junit</groupId>
40             <artifactId>junit</artifactId>
41             <scope>test</scope>
42         </dependency>
43         <dependency>
44             <groupId>mysql</groupId>
45             <artifactId>mysql-connector-java</artifactId>
46         </dependency>
47         <dependency>
48             <groupId>com.alibaba</groupId>
49             <artifactId>druid</artifactId>
50         </dependency>
51         <dependency>
52             <groupId>ch.qos.logback</groupId>
53             <artifactId>logback-core</artifactId>
54         </dependency>
55         <dependency>
56             <groupId>org.mybatis.spring.boot</groupId>
57             <artifactId>mybatis-spring-boot-starter</artifactId>
58         </dependency>
59         <dependency>
60             <groupId>org.springframework.boot</groupId>
61             <artifactId>spring-boot-starter-web</artifactId>
62             <version>RELEASE</version>
63             <scope>compile</scope>
64         </dependency>
65     </dependencies>
66 
67 </project>

建立application.yml配置檔案

 1 server:
 2   port: 8001
 3 
 4   #mybatis 配置以及制定mapper檔案所在位置
 5 mybatis:
 6   type-aliases-package: com.puyu.springcloud.pojo
 7   config-location: classpath:mybatis/mybatis-config.xml
 8   mapper-locations: classpath:mybatis/mapper/*.xml
 9 
10   #spring配置 
11 spring:
12   application:
13     name: springcloud-provider-dept # 3個服務名字一致
14   datasource:
15     type: com.alibaba.druid.pool.DruidDataSource #阿里巴巴德魯伊
16     driver-class-name: org.gjt.mm.mysql.Driver
17     url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8
18     username: root
19     password: root
20 
21 #eureka 配置   #defaultZone ---釋出到那個註冊中心
22 eureka:
23   client:
24     serviceUrl:
25       defaultZone: http://localhost:7001/eureka/
26   instance:
27     instance-id: springcloud-provider-dept8001 #修改eureka 上的預設描述資訊
28 
29 #info 自定義配置資訊
30 info:
31   app.name: huangpuyu-springcloud # 顯示與springcloud-provider-dept8001 預設描述資訊  點選後項目描述
32   company.name: big.pig.com

resources包下建立 mybatis包存放mybatis-config.xml

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE configuration
 3         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 <configuration>
 6     <settings>
 7 <!--   開啟二級快取   -->
 8         <setting name="cacheEnabled" value="true"/>
 9     </settings>
10 </configuration>

resources包下建立 mybatis包>mapper包 存放DeptDao.xml

Sql操作語句存放位置

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE mapper
 3         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 <mapper namespace="com.puyu.springcloud.dao.DeptDao">
 6     <insert id="addDept" parameterType="Dept">
 7         insert into dept (dname,db_source)
 8         values (#{dname},DATABASE());
 9     </insert>
10 
11     <select id="queryById" resultType="Dept" parameterType="Long">
12         select * from dept where deptno = #{deptno};
13     </select>
14 
15     <select id="queryAll" resultType="Dept" >
16         select * from dept;
17     </select>
18 
19 </mapper>

建立DeptDao層

 1 package com.puyu.springcloud.dao;
 2 
 3 //匯入springcloud專案中的Dept實體類
 4 import com.puyu.springcloud.pojo.Dept;
 5 import org.apache.ibatis.annotations.Mapper;
 6 import org.springframework.stereotype.Repository;
 7 
 8 import java.util.List;
 9 
10 @Mapper
11 @Repository
12 public interface DeptDao {
13 
14     public boolean addDept(Dept dept);
15 
16     public Dept queryById(Long id);
17 
18     public List<Dept> queryAll();
19 }

建立service層

 1 package com.puyu.springcloud.service;
 2 
 3 import com.puyu.springcloud.pojo.Dept;
 4 
 5 import java.util.List;
 6 
 7 public interface DeptService {
 8     public boolean addDept(Dept dept);
 9 
10     public Dept queryById(Long id);
11 
12     public List<Dept> queryAll();
13 }

 1 package com.puyu.springcloud.service;
 2 
 3 import com.puyu.springcloud.dao.DeptDao;
 4 import com.puyu.springcloud.pojo.Dept;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.stereotype.Service;
 7 
 8 import javax.xml.ws.ServiceMode;
 9 import java.util.List;
10 
11 @Service
12 public class DeptServiceImpl implements DeptService {
13 
14     @Autowired
15     private DeptDao deptDao;
16 
17     @Override
18     public boolean addDept(Dept dept) {
19         return deptDao.addDept(dept);
20     }
21 
22     @Override
23     public Dept queryById(Long id) {
24         return deptDao.queryById(id);
25     }
26 
27     @Override
28     public List<Dept> queryAll() {
29         return deptDao.queryAll();
30     }
31 }

建立controller層

 1 package com.puyu.springcloud.DeptController;
 2 
 3 import org.springframework.cloud.client.ServiceInstance;
 4 import org.springframework.cloud.client.discovery.DiscoveryClient;
 5 import com.puyu.springcloud.pojo.Dept;
 6 import com.puyu.springcloud.service.DeptService;
 7 import org.springframework.beans.factory.annotation.Autowired;
 8 import org.springframework.web.bind.annotation.*;
 9 
10 import java.util.List;
11 
12 //提供resetful服務
13 @RestController
14 public class DeptController {
15     @Autowired
16     private DeptService deptService;
17 
18     //獲取一些配置的資訊，得到具體微服務
19     @Autowired
20     private DiscoveryClient client;
21 
22     @PostMapping("/dept/add")
23     public boolean addDept(Dept dept) {
24         return deptService.addDept(dept);
25     }
26 
27     @GetMapping("/dept/get/{id}")
28     public Dept get(@PathVariable("id") Long id) {
29         return deptService.queryById(id);
30     }
31 
32     @GetMapping("/dept/list")
33     public List<Dept> queryAll() {
34         return deptService.queryAll();
35     }
36 
37     //註冊進來的微服務，獲取到一些訊息
38     //獲取微服務列表的一些清單資訊 微服務描述資訊
39     @GetMapping("/dept/discovery")
40     public Object discover(){
41         //獲取微服務的列表清單
42         List<String> services = client.getServices();
43         System.out.println("discovery=>services:"+services);
44         //得到一個具體的微服務資訊,通過具體的微服務id apolicationName
45         List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");
46         for (ServiceInstance instance:instances) {
47             System.out.println(
48                     instance.getHost()+"\t"+
49                     instance.getPort()+"\t"+
50                     instance.getUri()+"\t"+
51                     instance.getServiceId()+"\t"
52             );
53         }
54         return this.client;
55     }
56 
57 
58 }

建立springcloud-provider-dept-8001 專案啟動類

 1 package com.puyu.springcloud;
 2 
 3 import org.springframework.boot.SpringApplication;
 4 import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 import org.springframework.boot.web.servlet.ServletRegistrationBean;
 6 import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 7 import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
 8 import org.springframework.context.annotation.Bean;
 9 
10 import javax.servlet.ServletRegistration;
11 
12 
13 @SpringBootApplication
14 @EnableEurekaClient //配置完@EnableEurekaClient 在服務啟動後會自動註冊到eureka中 （客戶端自動註冊到服務端）
15 @EnableDiscoveryClient //discovery 服務發現
16 public class DeptProvider_8001 {
17     public static void main(String[] args) {
18         SpringApplication.run(DeptProvider_8001.class, args);
19     }
20 
21     //增加 一個servelt(hystrix流監控)
22    /* @Bean
23     public ServletRegistration hystrixMetricsStreamServlet(){
24         ServletRegistrationBean registrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
25         registrationBean.addUrlMappings("/actuator/hystrix.stream");
26         return registrationBean;
27     }*/
28 }

5.新建子專案springcloud-eureka-7001

Eureka 註冊中心

新增pom依賴

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <parent>
 6         <artifactId>springcloud</artifactId>
 7         <groupId>com.puyu</groupId>
 8         <version>1.0-SNAPSHOT</version>
 9     </parent>
10     <modelVersion>4.0.0</modelVersion>
11 
12     <artifactId>springcloud-eureka-7001</artifactId>
13     <!--eureka導依賴-->
14     <dependencies>
15         <dependency>
16             <groupId>org.springframework.cloud</groupId>
17             <artifactId>spring-cloud-starter-eureka-server</artifactId>
18             <version>1.4.6.RELEASE</version>
19         </dependency>
20         <dependency>
21             <groupId>org.springframework.boot</groupId>
22             <artifactId>spring-boot-devtools</artifactId>
23         </dependency>
24     </dependencies>
25 
26 </project>

建立application.yml

 1 server:
 2   port: 7001
 3 
 4 #eureka
 5 eureka:
 6   instance:
 7     hostname: eureka7001.com #eureka 服務端例項名字
 8   client:
 9     register-with-eureka: false #表示是否向eureka註冊中心註冊自己
10     fetch-registry: false #如果為false 表示自己是註冊中心
11     serviceUrl:
12       #defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
13       單機 defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
14       #叢集關聯
15       #defaultZone: http://7002的伺服器ip地址:7002/eureka/,http://7003的伺服器ip地址:7003/eureka/  （7001——關聯7002.7003 註冊中心叢集）

建立springcloud-eureka-7001 啟動類

 1 package com.puyu.springcloud;
 2 
 3 
 4 import org.springframework.boot.SpringApplication;
 5 import org.springframework.boot.autoconfigure.SpringBootApplication;
 6 import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
 7 
 8 @SpringBootApplication
 9 //EnableEurekaServer 服務端啟動類，可以接受別人註冊進來
10 @EnableEurekaServer
11 public class EurekaService_7001 {
12 
13     public static void main(String[] args) {
14         SpringApplication.run(EurekaService_7001.class,args);
15     }
16 }

至此springcloud 專案最簡單的 服務消費者 服務提供者 服務註冊中心 搭建完成，後面還有 eureka的叢集、Ribbon、Feign、Hystrix、zuul、springcloud-config配置管理

要理解springcloud的中心思想，是服務個體獨立，經由Eureka註冊中心管理各個服務。

下面看下執行結果

首先執行Eureka註冊中心，在執行provider服務提供者，再執行consumer服務消費者

資料訪問結果