目的：

　　1.springcloud简介

　　　　入门案例

　　2.注册中心eureka

springcloud简介

　　　推荐一个springcloud讲解详细的博客：https://blog.csdn.net/qq32933432/article/details/89918264

  • 简介

Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

详细介绍： https://baike.so.com/doc/25751000-26884657.html

配套参考资料：

https://projects.spring.io/spring-cloud/    springcloud项目官方主页

https://springcloud.cc/  springcloud中文网 有很详细的翻译文档

http://springcloud.cn/  springcloud中文论坛

Springcloud版本pom文件生成可借助网站：

https://start.spring.io/

原有的单体项目最终会被演化成下面

这样的架构解决了单体项目几点问题：

1、zuul网关解决了服务调用安全性的问题

2、服务注册与发现（注册中心）eureka解决了各层服务耦合问题，它是微服务架构的核心，有它才能将单体项目拆解成微服务架构

3、Eureka集群解决了微服务中，注册中心宕机产生的问题

4、Ribbon负载均衡及Feign消费者调用服务，减小了各微服务服务器的访问压力，默认采用了经典的轮询机制

5、熔断器Hystrix解决了，微服务架构中服务器雪崩现象

6、服务监控（单机Dashboard与集群turbine），方便运维人员查看微服务架构项目运行时，各个服务器的运行状态

7、服务配置中心（springcloud config），用来通过github统一管理各个微服务的配置文件（yml文件）

入门案例　　

最简单的微服务架构会有四个工程

　　父工程：htSpringCloud

　　通用模块（M）：microservice-common

　　服务提供者（C）：microservice-student-provider-1001

　　服务消费者（C）：microservice-student-consumer-80

微服务架构注意点：

1、springboot、springcloud版本在父工程定义；

2、由于通用模块无需操作数据库，springboot启动默认会读取数据库，所以得添加以下注解 @SpringBootApplication(exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})；

3、分布式jpa需要在启动类上添加@EntityScan("com.javaxl.*.*")；

4、消费者需要添加配置类获取org.springframework.web.client.RestTemplate，springcloud底层是通过RestTemplate来调用提供者的服务的。

传统项目拆分成微服务架构图：

创建父工程htSpringCloud

　　父工程是一个maven项目，一般创建方式即可，父工程的主要用途是锁定pom依赖包版本。由于springcloud2X停止更新，这里我们采用稳定的低版本，配套的springboot版本为1x版本。

Pom.xml配置如下

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>com.ht</groupId>

  <artifactId>htSpringCloud</artifactId>

  <version>1.0-SNAPSHOT</version>

  <name>htSpringCloud</name>

  <url>http://www.example.com</url>

  <properties>

  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

  <maven.compiler.source>1.8</maven.compiler.source>

  <maven.compiler.target>1.8</maven.compiler.target>

  <druid.version>1.1.10</druid.version>

  </properties>

  <dependencyManagement>

    <dependencies>

      <dependency>

        <groupId>org.springframework.cloud</groupId>

        <artifactId>spring-cloud-dependencies</artifactId>

        <version>Edgware.SR4</version>

        <type>pom</type>

        <scope>import</scope>

      </dependency>

      <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-dependencies</artifactId>

        <version>1.5.13.RELEASE</version>

        <type>pom</type>

        <scope>import</scope>

      </dependency>

      <!--  连接池  -->

      <dependency>

        <groupId>com.alibaba</groupId>

        <artifactId>druid-spring-boot-starter</artifactId>

        <version>${druid.version}</version>

      </dependency>

    </dependencies>

  </dependencyManagement>

</project>

创建通用模块microservice-common

通用模块主要存放实体类、工具包等被整个微服务框架所使用的代码。创建一个简单的springboot模块即可。

相关代码如下

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>com.ht</groupId>

        <artifactId>htSpringCloud</artifactId>

        <version>1.0-SNAPSHOT</version>

    </parent>

    <artifactId>microservice-common</artifactId>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <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>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

        </dependency>

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

                <configuration>

                    <!--被依赖的公共模块必须加上这个，打包之后启动，

                    选择后面带EXE的启动，依赖该模块的其他模块就不会因为找不到依赖而打包出错-->

                    <classifier>exe</classifier>

                </configuration>

            </plugin>

        </plugins>

    </build>

</project>

MicroserviceCommonApplication.java

package com.ht.microservicestudentconsumer80;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;

@SpringBootApplication(exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})

public class MicroserviceStudentConsumer80Application {

    public static void main(String[] args) {

        SpringApplication.run(MicroserviceStudentConsumer80Application.class, args);

    }

}

Student

package com.ht.microservicecommon.entity;

import javax.persistence.*;

import java.io.Serializable;

@Entity

@Table(name="t_springcloud_student")

public class Student implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id

    @GeneratedValue

    private Integer id;

    @Column(length=50)

    private String name;

    @Column(length=50)

    private String grade;

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getGrade() {

        return grade;

    }

    public void setGrade(String grade) {

        this.grade = grade;

    }

}

创建服务提供者microservice-student-provider-1001

创建一个简单的springboot模块，这里服务提供者需要操作数据库并且被浏览器所访问，固需要添加相关配置如下

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>com.ht</groupId>

        <artifactId>htSpringCloud</artifactId>

        <version>1.0-SNAPSHOT</version>

    </parent>

    <artifactId>microservice-student-provider-1001</artifactId>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <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>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

        </dependency>

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-tomcat</artifactId>

        </dependency>

        <dependency>

            <groupId>com.alibaba</groupId>

            <artifactId>druid-spring-boot-starter</artifactId>

        </dependency>

        <!--  修改后立即生效，热部署  -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>springloaded</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-devtools</artifactId>

        </dependency>

        <dependency>

            <groupId>com.ht</groupId>

            <artifactId>microservice-common</artifactId>

            <version>1.0-SNAPSHOT</version>

            <scope>compile</scope>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

application.yml

server:

  port: 1001

  context-path: /

spring:

  datasource:

    type: com.alibaba.druid.pool.DruidDataSource

    driver-class-name: com.mysql.jdbc.Driver

    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8

    username: root

    password: root

  jpa:

    hibernate:

      ddl-auto: update

    show-sql: true

MicroserviceStudentProvider1001Application.java

package com.ht.microservicestudentprovider1001;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.autoconfigure.domain.EntityScan;

@EntityScan("com.ht.*.*")

@SpringBootApplication

public class MicroserviceStudentProvider1001Application {

    public static void main(String[] args) {

        SpringApplication.run(MicroserviceStudentProvider1001Application.class, args);

    }

}

StudentRepository.java

package com.ht.microservicestudentprovider1001.repository;

import com.ht.microservicecommon.entity.Student;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface StudentRepository extends JpaRepository<Student, Integer>, JpaSpecificationExecutor<Student> {

}

StudentService

package com.ht.microservicestudentprovider1001.service;

import com.ht.microservicecommon.entity.Student;

import java.util.List;

public interface StudentService {

    public void save(Student student);

    public Student findById(Integer id);

    public List<Student> list();

    public void delete(Integer id);

}

StudentServiceImpl.java

package com.ht.microservicestudentprovider1001.service.impl;

import com.ht.microservicecommon.entity.Student;

import com.ht.microservicestudentprovider1001.repository.StudentRepository;

import com.ht.microservicestudentprovider1001.service.StudentService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.util.List;

@Service

public class StudentServiceImpl implements StudentService {

    @Autowired

    private StudentRepository studentRepository;

    @Override

    public void save(Student student) {

        studentRepository.save(student);

    }

    @Override

    public Student findById(Integer id) {

        return studentRepository.findOne(id);

    }

    @Override

    public List<Student> list() {

        return studentRepository.findAll();

    }

    @Override

    public void delete(Integer id) {

        studentRepository.delete(id);

    }

}

StudentProviderController.java

package com.ht.microservicestudentprovider1001.controller;

import com.ht.microservicecommon.entity.Student;

import com.ht.microservicestudentprovider1001.service.StudentService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController

@RequestMapping("/student")

public class StudentProviderController {

    @Autowired

    private StudentService studentService;

    @PostMapping(value="/save")

    public boolean save(Student student){

        try{

            studentService.save(student);

            return true;

        }catch(Exception e){

            return false;

        }

    }

    @GetMapping(value="/list")

    public List<Student> list(){

        return studentService.list();

    }

    @GetMapping(value="/get/{id}")

    public Student get(@PathVariable("id") Integer id){

        return studentService.findById(id);

    }

    @GetMapping(value="/delete/{id}")

    public boolean delete(@PathVariable("id") Integer id){

        try{

            studentService.delete(id);

            return true;

        }catch(Exception e){

            return false;

        }

    }

}

创建服务消费者microservice-student-consumer-80

服务消费者主要是通过restful api来调用提供者的接口，固不需要不需要操作数据库，相关配置如下

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>com.ht</groupId>

        <artifactId>htSpringCloud</artifactId>

        <version>1.0-SNAPSHOT</version>

    </parent>

    <artifactId>microservice-student-consumer-80</artifactId>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <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>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

        </dependency>

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-tomcat</artifactId>

        </dependency>

        <!--  修改后立即生效，热部署  -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>springloaded</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-devtools</artifactId>

        </dependency>

        <dependency>

            <groupId>com.ht</groupId>

            <artifactId>microservice-common</artifactId>

            <version>1.0-SNAPSHOT</version>

            <scope>compile</scope>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

application.yml

server:

  port: 80

  context-path: /

MicroserviceStudentConsumer80Application.java

package com.ht.microservicestudentconsumer80;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;

@SpringBootApplication(exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})

public class MicroserviceStudentConsumer80Application {

    public static void main(String[] args) {

        SpringApplication.run(MicroserviceStudentConsumer80Application.class, args);

    }

}

SpringCloudConfig.java

package com.ht.microservicestudentconsumer80.config;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.web.client.RestTemplate;

@Configuration

public class SpringCloudConfig {

    @Bean

    public RestTemplate getRestTemplate(){

        return new RestTemplate();

    }

}

StudentConsumerController.java

package com.ht.microservicestudentconsumer80.controller;

import com.ht.microservicecommon.entity.Student;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController

@RequestMapping("/student")

public class StudentConsumerController {

    private final static String SERVER_IP_PORT = "http://localhost:1001";

     @Autowired

     private RestTemplate restTemplate;

     @PostMapping(value="/save")

     private boolean save(Student student){

         return restTemplate.postForObject(SERVER_IP_PORT+"/student/save", student, Boolean.class);

     }

    @GetMapping(value="/list")

    public List<Student> list(){

        return restTemplate.getForObject(SERVER_IP_PORT+"/student/list", List.class);

    }

    @GetMapping(value="/get/{id}")

    public Student get(@PathVariable("id") Integer id){

        return restTemplate.getForObject(SERVER_IP_PORT+"/student/get/"+id, Student.class);

    }

    @GetMapping(value="/delete/{id}")

    public boolean delete(@PathVariable("id") Integer id){

        try{

            restTemplate.getForObject(SERVER_IP_PORT+"/student/delete/"+id, Boolean.class);

            return true;

        }catch(Exception e){

            return false;

        }

    }

}

关于如何配置RunDashboard

https://www.cnblogs.com/yangtianle/p/8818255.html

成功结果图如下

http://localhost:1001/student/list

http://localhost/student/list

注册中心eureka

Eureka简介：

Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务发现功能。

Eureka包含两个组件：Eureka Server和Eureka Client。

Eureka Server提供服务注册服务，各个节点启动后，会在Eureka Server中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。

Eureka Client是一个java客户端，用于简化与Eureka Server的交互，客户端同时也就别一个内置的、使用轮询(round-robin)负载算法的负载均衡器。

在应用启动后，将会向Eureka Server发送心跳,默认周期为30秒，如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)。

Eureka Server之间通过复制的方式完成数据的同步，Eureka还提供了客户端缓存机制，即使所有的Eureka Server都挂掉，客户端依然可以利用缓存中的信息消费其他服务的API。综上，Eureka通过心跳检查、客户端缓存等机制，确保了系统的高可用性、灵活性和可伸缩性

类似zookeeper，Eureka也是一个服务注册和发现组件，是SpringCloud的一个优秀子项目，不过比较坑的是，Eureka2版本已经停止更新了。但是Eureka1版本还是很稳定，功能足够用，所以还是有必要学习下。

但是这里有几个常用的服务注册与发现组件比对；

服务注册与发现原理：

Eureka的使用

　　前面说过eureka是c/s模式的  server服务端就是服务注册中心，其他的都是client客户端，服务端用来管理所有服务，客户端通过注册中心，来调用具体的服务；

我们先来搭建下服务端，也就是服务注册中心；

新建 module   microservice-eureka-server-2001；

在pom文件中加入eureka-server依赖；

在yml文件中添加Eureka服务端相关信息；

在启动类中添加@EnableEurekaServer注解；

导入相关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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>com.ht</groupId>

        <artifactId>htSpringCloud</artifactId>

        <version>1.0-SNAPSHOT</version>

    </parent>

    <artifactId>microservice-eureka-server-2001</artifactId>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-eureka-server</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

        <!--  修改后立即生效，热部署  -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>springloaded</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-devtools</artifactId>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>


application.yml




server:

  port: 2001

  context-path: /

eureka:

  instance:

    hostname: localhost #eureka注册中心实例名称

  client:

    register-with-eureka: false     #false 由于该应用为注册中心，所以设置为false,代表不向注册中心注册自己。

    fetch-registry: false     #false 由于注册中心的职责就是维护服务实例，它并不需要去检索服务，所以也设置为false

    service-url:

      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/       #设置与Eureka注册中心交互的地址，查询服务和注册服务用到





启动类MicroserviceEurekaServer2001Application




package com.ht.microserviceeurekaserver2001;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@EnableEurekaServer

@SpringBootApplication

public class MicroserviceEurekaServer2001Application {

    public static void main(String[] args) {

        SpringApplication.run(MicroserviceEurekaServer2001Application.class, args);

    }

}




测试连接


http://localhost:2001/




向Eureka中注册服务提供者


这里我们在原来的服务提供者项目 microservice-student-provider-1001  上面直接修改：


首先pom.xml修改，加上eureka客户端依赖：






<!--添加注册中心Eureka相关配置-->

<dependency>

    <groupId>org.springframework.cloud</groupId>

    <artifactId>spring-cloud-starter-eureka</artifactId>

</dependency>

<dependency>

    <groupId>org.springframework.cloud</groupId>

    <artifactId>spring-cloud-starter-config</artifactId>

</dependency>




然后application.yml上加上配置：




eureka:

  instance:

    hostname: localhost

    appname: microservice-student

    instance-id: microservice-student:1001

    prefer-ip-address: true

  client:

    service-url:

      defaultZone: http://localhost:2001/eureka




这里的defaultZone要和前面服务注册中心的暴露地址一致；


最后 启动类加上一个注解 @EnableEurekaClient；




然后我们测试下，先启动服务注册中心，再启动这个服务提供者；


然后运行：http://localhost:2001/


服务提供者成功注册截图如下




点击实例状态结果如下是看不到内容的所以我们需要导入actuator监控依赖




解决方案如下


1、首先在服务提供者项目pom.xml里加入actuator监控依赖：


2、最后服务提供者项目application.yml加上info配置：


pom依赖中添加：




<!-- actuator监控引入 -->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-actuator</artifactId>

        </dependency>




yml文件中添加




info:

  groupId: com.ht.htSpringCloud

  artifactId: microservice-student-provider-1001

  version: 1.0-SNAPSHOT

  userName: http://ht.com

  phone: 123456




效果如下：




谢谢观看！
												


											
SpringCloud入门使用的更多相关文章
	

    
						
  1. SpringCloud(2)---SpringCloud入门篇
		
    SpringCloud理解篇 一.微服务概述 1.什么是微服务 目前的微服务并没有一个统一的标准,一般是以业务来划分将传统的一站式应用,拆分成一个个的服务,彻底去耦合,一个微服务就是单功能业务,只做一 ...
    
		
    2. 
						
  2. SpringCloud入门之常用的配置文件 application.yml和 bootstrap.yml区别
		
    作者其他技术文章 1) Spring Boot 简介 2)SpringCloud入门之YAML格式文件规范学习 3)SpringCloud入门之Spring Boot多环境配置切换指南 4) Elas ...
    
		
    3. 
						
  3. SpringCloud入门(一)
		
    一.微服务概述 1.什么是微服务 目前的微服务并没有一个统一的标准,一般是以业务来划分将传统的一站式应用,拆分成一个个的服务,彻底去耦合,一个微服务就是单功能业务,只做一件事. 与微服务相对的叫巨石  ...
    
		
    4. 
						
  4. SpringCloud入门之应用程序上下文服务（Spring Cloud Context）详解
		
    构建分布式系统非常复杂且容易出错.Spring Cloud为最常见的分布式系统模式提供了简单易用的编程模型,帮助开发人员构建弹性,可靠和协调的应用程序.Spring Cloud构建于Spring Bo ...
    
		
    5. 
						
  5. springcloud 入门 11 (Hystrix Dashboard)
		
    hystrix: 断路器我在前面已经介绍,不了解的可以参考 :springcloud 入门 6 (断路器hystrix)  关于搭建,测试我都在这里面进行说明了,这章介绍的是  Hystrix Das ...
    
		
    6. 
						
  6. springcloud 入门 10 (eureka高可用)
		
    eureka高可用: 说白了,就是加一个实例作为原实例的备份,然后一起对外提供服务.这样可以保证在一台机器宕机的时候,整个系统不会死掉.保证其继续对外服务. eureka的集群化: 服务注册中心Eur ...
    
		
    7. 
						
  7. springcloud 入门 5 （feign源码分析）
		
    feign:(推荐使用) Feign是受到Retrofit,JAXRS-2.0和WebSocket的影响,它是一个jav的到http客户端绑定的开源项目. Feign的主要目标是将Java Http  ...
    
		
    8. 
						
  8. SpringCloud 入门
		
    1. 入门概述 SpringBoot专注于快速方便的开发单个个体微服务; SpringCloud:关注全局的微服务协调治理框架,它将SpringBoot开发的一个个单体微服务整合并管理起来, 为各个微 ...
    
		
    9. 
						
  9. SpringCloud入门概述
		
    SpringCloud入门概述 Spring的三大模块:SpringBoot(构建),Spring Cloud(协调),Spring Cloud Data Flow(连接)注意:Spring Boot ...
    
		
    10. 
						
  10. SpringCloud 入门知识篇
		
    SpringCloud 入门 springcloud 学习 7天学会springcloud 教程 https://www.cnblogs.com/skyblog/category/738524.htm ...
    
		
    11. 
		

	


随机推荐
	

    
									
  1. NVIDIA vGPU License服务器搭建详解
			
    当配置有vGPU虚拟机发起License授权请求,授权服务器会根据License中所包含的GRID License版本,加载不同的vGPU驱动(普通驱动和专业Quodra卡驱动).目前vPC和vApp ...
    
			
    2. 
						
  2. 【JZOJ6225】【20190618】计数
			
    题目 对于一个01串,定义\(f(s)\)为\(f(s) = \sum_{i=0}^{\lfloor \frac{|s|}{2} \rfloor -1 }[s_i=s_{|s|-1-i}]\) 定义\ ...
    
			
    3. 
						
  3. 算法：贪心、回溯（su）、分治、动态规划，思想简要
			
    贪心算法: 只做出当前看来最好的选择,而不从整体考虑最优,他所作出的是局部最优解.使用该算法的前提是必须具备无后效性,即某个状态以前的选择不会影响以后的状态的选择,只与当前状态有关. 回溯算法: 本质 ...
    
			
    4. 
						
  4. (4.1)打造简单OS-小实验[图形显示]
			
    主要是实现<简单打造OS>第四小节说到的一个图形界面的实验项目 1.mbr boot.inc ;------------- loader和kernel ---------- LOADER_ ...
    
			
    5. 
						
  5. D3.js的v5版本入门教程（第十二章）—— D3.js中各种精美的图形
			
    D3.js的v5版本入门教程(第十二章) D3中提供了各种制作常见图形的函数,在d3的v3版本中叫布局,通过d3.layout.xxx,来新建,但是到了v5,新建一个d3中基本的图形的方式变了(我也并 ...
    
			
    6. 
						
  6. NoSql数据库Redis系列（5）——Redis主从复制
			
    前面介绍Redis,我们都在一台服务器上进行操作的,也就是说读和写以及备份操作都是在一台Redis服务器上进行的,那么随着项目访问量的增加,对Redis服务器的操作也越加频繁,虽然Redis读写速度都 ...
    
			
    7. 
						
  7. nacos-server安装、运行 (docker)
			
    https://nacos.io/en-us/docs/quick-start-docker.htmlhttps://github.com/nacos-group/nacos-docker mkdir ...
    
			
    8. 
						
  8. SQL优化-如何分析性能瓶颈
			
    MySQL优化一览图 笔者将优化分为了两大类:软优化和硬优化.软优化一般是操作数据库即可:而硬优化则是操作服务器硬件及参数设置. 1.软优化 1)查询语句优化 首先我们可以用EXPLAIN或DESCR ...
    
			
    9. 
						
  9. DOM 是什么，Document Object Model，文档对像模型
			
    #为什么会想起来写这个 在写dynaTrace Ajax的时候,写到这个是个前端性能测试工具,这个工具能记录请求时间,前端页面渲染时间,DOM方法执行时间,以及JavaScript代码解析和执行时间. ...
    
			
    10. 
						
  10. BDD介绍
			
    TDD: TDD(Test-Drivern Development)测试驱动开发,是敏捷开发中的一项核心实践和技术,也是一种设计方法论.TDD的原理是在开发功能代码之前,先编写单元测试用例代码,测试代 ...
    
			
    11.