SpringCloud 项目搭建 --Eureka

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的自动注册逻辑。毕竟当前服务注册到当前服务代表的注册中心中是一个说不通的逻辑。
　　Eureka Server通过Register、Get、Renew等接口提供服务的注册、发现和心跳检测等服务。

　　2.1 Eureka Client

　　Eureka Client是一个java客户端，用于简化与Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳,默认周期为30秒，如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)。
　　Eureka Client分为两个角色，分别是：Application Service(Service Provider)和Application Client(Service Consumer)

　　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 }