粤嵌打卡第45天（SpringCloud学习之路二（亲手搭建一套微服务系统、Eureka服务注册、信息配置、自我保护机制））

最新推荐文章于 2021-12-27 20:08:03 发布

qq_41986840

最新推荐文章于 2021-12-27 20:08:03 发布

阅读量328

点赞数

文章标签：微服务

本文链接：https://blog.csdn.net/qq_41986840/article/details/106773270

版权

今天我带领大家模拟一个微服务项目，将平常的ALL IN ONE项目拆分成多个子服务,实现消息提供者发送消息，消息接收者消费消息，最后会以Eureka进行服务注册与发现，让多个服务通过注册中心服务器来实现消费消息。

1、创建springcloud主服务（普通Maven项目）

pom文件的配置：

springcloud依赖、springboot依赖、数据库mysql依赖、连接池Druid依赖、mybatis整合springboot依赖、junit单元测试依赖、lombak依赖、log4j日志依赖等

<?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.baoji</groupId>
    <artifactId>springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springcloud-api</module>
        <module>springcloud-provider-8001</module>
        <module>springcloud-consumer-80</module>
        <module>springcloud-eureka-7001</module>
    </modules>
    <!-- 打包方式 -->
    <packaging>pom</packaging>
    <!--版本-->
    <properties>
        <junit.version>4.12</junit.version>
        <lombok.version>1.16.16</lombok.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <!--springcloud依赖-->
           <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--SpringBoot依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.1.4.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--数据库mysql-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.20</version>
            </dependency>
            <!--数据库连接池-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.14</version>
            </dependency>
            <!--springboot mybatis启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.0.0</version>
            </dependency>
            <!--Junit-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <!--log4j-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
            <!--日志门面-->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

2、使用IDEA工具连接mysql,创建dept表

建表语句：

insert into dept(deptname,dept_source) values ('开发部',DATABASE());
insert into dept(deptname,dept_source) values ('产品部',DATABASE());
insert into dept(deptname,dept_source) values ('营销部',DATABASE());
insert into dept(deptname,dept_source) values ('宣传部',DATABASE());
insert into dept(deptname,dept_source) values ('运维部',DATABASE());

select * from dept;

3、创建springcloude-api子服务（普通maven项目）

springcloud-api子服务：此自服务只负责创建pojo对象，供其他服务使用。

1.1、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.baoji</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-api</artifactId>
    <!--为自己的model配置依赖,如果父类中已经配置了该依赖，这里就不用写了-->
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

2、创建pojo类(使用lombak快速创建)

package com.baoji.springcloud.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

/**
 * 网络传输必须将实体类进行序列化
 */
@Data
@NoArgsConstructor //无参构造
@Accessors(chain = true) //链式写法
public class Dept implements Serializable {   //Dept实体类  orm实体关系映射
    private Long deptno;
    private String deptname;
    //数据存放在哪个数据库  微服务，一个服务对应一个数据库，同一个信息可能存在不同的数据库
    private String db_source;

    public Dept(String deptname) {
        this.deptname = deptname;
    }
}

4、创建springcloud-provider-8001子服务（设置消息提供者端口：8001）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PvdkskXv-1592233612476)(https://user-gold-cdn.xitu.io/2020/6/15/172b79eef0f62ca2?w=468&h=785&f=png&s=53045)]

1、配置pom文件

生产者服务调用pojo服务创建实例是通过pom文件引入dependency来使用

<?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.baoji</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-provider-8001</artifactId>
    <dependencies>
    <!--我们要拿到实体类，所以要配置api model-->
        <dependency>
            <groupId>com.baoji</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jetty  充当服务器，相当于tomcat-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-jetty -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
</project>

2、配置mybatis-config.xml文件（mybatis配置二级缓存）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
   <settings>
       <!--开启二级缓存-->
       <setting name="cacheEnabled" value="true"/>
   </settings>
</configuration>

3、配置application.yml文件(服务端口号、mybatis配置、mapper配置、spring配置、连接数据库)

server:
  port: 8080
# mybatis 配置
mybatis:
  type-aliases-package: com.baoji.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml  #config-location 为mybatis配置文件
  mapper-locations: classpath:mybatis/mapper/*.xml  #mapper-locations  为mapper配置
#spring配置
spring:
  application:
    name: springcloud-provider
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true
    username: root
    password: root

4、编写Dao层(按编号查询员工、添加员工、查询所有员工)

package com.baoji.springcloud.dao;

import com.baoji.springcloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
@Repository
public interface DeptDao {
    //添加员工
    public boolean addDept(Dept dept);
    //按编号查询员工
    public Dept getDeptById(long id);
    //查询所有员工
    public List<Dept> findAll();
}

4、编写DeptMapper.xml文件（实体类和数据库映射）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.baoji.springcloud.dao.DeptDao">
    <insert id="addDept" parameterType="Dept">
        insert into dept(deptname, dept_source) values (#{deptname},DATABASE());
    </insert>
    <select id="getDeptById" resultType="Dept" parameterType="Long">
        select * from dept where deptno = #{deptno};
    </select>
    <select id="findAll" resultType="Dept">
        select * from dept;
    </select>
</mapper>

5、编写业务接口层

package com.baoji.springcloud.service;

import com.baoji.springcloud.pojo.Dept;

import java.util.List;

public interface DeptService {
    //添加员工
    public boolean addDept(Dept dept);
    //按编号查询员工
    public Dept getDeptById(long id);
    //查询所有员工
    public List<Dept> findAll();
}

6、编写业务实现层（属性注入dao层获取数据）

package com.baoji.springcloud.service;

import com.baoji.springcloud.dao.DeptDao;
import com.baoji.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptDao deptDao;
    public boolean addDept(Dept dept) {
        return deptDao.addDept(dept);
    }

    public Dept getDeptById(long id) {
        return deptDao.getDeptById(id);
    }

    public List<Dept> findAll() {
        return deptDao.findAll();
    }
}

7、编写控制层

package com.baoji.springcloud.controller;

import com.baoji.springcloud.pojo.Dept;
import com.baoji.springcloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

//提供ResultFul服务，以resuFul方式返回
@RestController
public class DeptController {
    @Autowired
    private DeptService deptService;
    @PostMapping("/dept/add")
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }
    @GetMapping("/dept/get/{id}")
    public Dept getDeptById(@PathVariable("id") long id){
        return deptService.getDeptById(id);
    }
    @GetMapping("/dept/list")
    public List<Dept> findAll(){
        return deptService.findAll();
    }
}

8、编写springboot核心启动类

package com.baoji.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

9、浏览器测试消息提供者是否获取数据(生产者测试成功！)

5、创建springcloud-consumer-80 消费者服务（此处80端口为消费者端口，服务器默认端口）

1、配置pom文件（给消费者pom中引入springcloud-api实体类服务和spring-boot-starter-web）

<?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.baoji</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-80</artifactId>
    <!--消费者-->
    <!--实体类+web-->
    <dependencies>
        <dependency>
            <groupId>com.baoji</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

2、编写配置文件（将RestTemplate手动注册到spring中，使用@bean注解）

消费者没有service层、一般分布式项目中，消费者如果想要直接访问生产者，必须使用RestTemplate, 供我们直接调用生产者控制层提供的接口就可以，我们将RestTemplate直接手动注册到spring中

package com.baoji.springcloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {  //Configuration  -- spring  applicationContext.xml
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

3、编写控制层

基本原理核心代码：

我们直接属性注入RestTemplate对象，先将生产者前面的绝对路径定义成静态常量，根据生产者控制层提供接口的类型来调用该对象里面的返回方法。

post类型的参数，返回的是restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);

get类型的参数，返回的是restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);

返回对象的方法参数为（生产者请求地址，实参，返回参数类型的字节码）

package com.baoji.springcloud.controller;

import com.baoji.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {
    //消费者：不应该有service层
    //RestTemplate  供我们直接调用就可以  直接手动注册到spring中
    //参数(url,请求路径：Map,Class<T> responseType)
    @Autowired
    private RestTemplate restTemplate;  //提供多种快捷访问Http服务的方法，简单的restFul服务模板
    //请求路径前固定的url
    private static final String REST_URL_PREFIX = "http://localhost:8080";

    //消费者请求的地址
    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        //服务器返回对应的对象
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
    }

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept) {
        //返回post类型的对象，三个参数（请求的地址，拼接的参数，返回响应的字节码）
        return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        //返回get类型的对象，两个参数（url,返回响应的字节码）
       return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }
}

4、编写消费者服务启动类

package com.baoji.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

5、浏览器测试消费者远程服务调用生产者获取数据

消费者生产者模式和普通ALLIN ONE之间的区别：完全解耦，服务与服务之间，没有依赖。

浏览器输入消费者接口的路径，注意看两次测试截图路径的变化，第一次为生产者通过url获取数据，第二次是消费者直接输入自己的url访问的路径获取数据，一般ALL IN ONE项目中，前端通过获取生产者的接口url来进行数据提取，现在多服务项目中，消费者可以不依赖生产者的url，就可以获取数据，达到了消息提供者与消息接收者之间的完全解耦。

5、Eureka介绍

我们都知道Dubbo框架的服务注册和发现是基于Zookeeper客户端实现的，每次消息提供者和消息接收者进行注册时必须要先开启Zookeeper客户端，才可以对服务进行注册。消息提供者和消息接收者通过RPC远程过程异步调用

Dubbo架构图：

Eureka是Springcloud框架的服务注册组件，服务提供者发送消息服务到注册中心，服务消费者获得注册中心的地址，微服务项目有了服务注册与发现，只需要使用服务的标识符，就可以访问到服务，而不需要经常修改调用的配置文件，功能类似于Dubbo的注册中心Zookeeper

Eureka架构原理：

1、SpringCloud封装了NetFlix公司的Eureka模块来实现注册和发现。
2、Eureka采用C-S架构，EurekaServer作为服务注册功能的服务器，他是服务注册中心
3、其他微服务使用Eureka的客户端连接到EurekaServer并维持心跳连接，系统维护人员就可以通过EureakaServer来监听系统中各个微服务是否正常运行，SpringCloude的其他模块（例如：Zuul）就可以通过EurekaServer来发现系统中的其他微服务。

三大角色：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hwL2Lnij-1592233612494)(https://user-gold-cdn.xitu.io/2020/6/15/172b7ff1716a16c0?w=1248&h=587&f=png&s=527511)]

6、使用Eureka实现服务发现与注册（创建子服务）

创建springcloud-eureka-7001子服务（端口号为7001）

eureka操作第一步：

1、导入pom依赖(spring-cloud-starter-netflix-eureka-server)

<?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.baoji</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-eureka-7001</artifactId>
    <!--导入eureka-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <version>2.0.2.RELEASE</version>
        </dependency>

    </dependencies>
</project>

eureka操作第二步：

2、Eureka配置文件编写(配置eureka服务端主机名、表示自己是注册中心、和eureka服务注册中心交互的地址)

server:
  port: 7001
#Eureka配置
eureka:
  instance:
    hostname: localhost # Eureka服务端的实例名称
  client:
    register-with-eureka: false  #表示是否向Eureka中心注册自己，自己就是Eureka服务器，不需要注册自己
    fetch-registry: false # fetch-registry为false 表示自己是注册中心
    service-url:  # 监控页面，和eureka服务注册中心交互的地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

3、编写springboot启动类

eureka操作第三步：

3、设置@EnableEurekaServer注解: 注册中心服务器端的启动类，可以接收别人注册进来

package com.baoji.springcloud;

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

//启动之后 访问http://localhost:7001/
@SpringBootApplication
@EnableEurekaServer  // EnableEurekaServer 注册中心服务器端的启动类，可以接收别人注册进来
public class EurekaServer_7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer_7001.class,args);
    }
}

4、浏览器测试（通过eureka地址测试是否成功（localhost:7001））

红线处表示服务注册后的服务实例存放处

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KJBms1ov-1592233612496)(https://user-gold-cdn.xitu.io/2020/6/15/172b8144db6719f5?w=1860&h=912&f=png&s=148821)]

7、将服务提供者注册进服务注册中心

eureka第一步：服务提供者中导入依赖

1、在服务提供者pom文件dependencys下添加spring-cloud-starter-eureka依赖

 <!--配置spring-cloud-starter-eureka  为了将服务提供者注册进注册中心-->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.3.RELEASE</version>
        </dependency>

eureka第二步：在服务提供者配置文件中添加服务发送之后注册到服务器的url路径

2、在服务提供者配置文件中加入eureka的配置

#Eureka的配置  服务注册到哪里  和注册中心服务的路径一样
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/

eureka第三步：在服务提供者启动类中添加自动注册注解

3、启动类中添加@EnableEurekaClient注解，将服务自动注册到服务端

@EnableEurekaClient  //把客户端服务启动之后，将服务自动注册到服务端

4、浏览器测试eureka(发现Application中已经注册进服务了，服务名为我们在生产者spring配置中的名字)

仔细看Status中描述信息为localhost地址，我们可以将此描述信息更改默认描述

5、更改eureka的默认信息

在生产者配置文件中的eureka配置中加入

  instance:
    instance-id: springcloud-provider-dept8001  # 修改eureka上的默认描述信息

此时我们可以发现配置信息已经更改了

6、接下来我们配置eureka的监控信息（不重要）

1、在消息接收方pom中加入完善监控的依赖

<!--actuator完善监控的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

2、在消息接收方配置文件中加入配置信息

#info信息
info:
  app.name: linchi-springcloud
  company.name: com.baoji

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s8MzTGI9-1592233612504)(https://user-gold-cdn.xitu.io/2020/6/15/172b849e0233fd71?w=837&h=396&f=png&s=49361)]

7、测试监控输出信息（点击start下的描述信息url,会出现刚才配置的监控个人信息）

8、Eureka自我保护机制

自我保护机制：当某时刻，消息提供方服务因断电、断网、自己关闭服务等各种原因导致某一个微服务不可用了，eureka不会立刻清理，依然会对该微服务的信息进行保存。

自我保护模式是一种应对网络异常的安全保护措施，宁可保护所有的微服务，也不盲目删除注销任何健康的微服务，使用自我保护模式，让Eureka集群更加的健壮和稳定。

springcloud中，可以使用eureka.server.enable-self-preservation = false禁用自我保护模式，但是不推荐使用。

9、服务发现

在团队开发中，面对的是好多个微服务，开发者要想通过微服务获取到对应服务的信息，就必须这么来做：

1、在服务发送者的controller类中，属性注入DiscoveryClient类，得到具体微服务的信息，通过这个类client.getServices()方法就可以获得所有微服务的清单，通过client.getInstances("SPRINGCLOUD-PROVIDER");就可以根据微服务id(微服务id为spring配置文件中配置的名称)获得每个微服务实例，遍历就可得到微服务的具体端口号、服务主机等信息。

//获取一些配置的信息，得到具体的微服务
    @Autowired
    private DiscoveryClient client;
    
     //注册进来的微服务  获取一些消息
    @GetMapping("/dept/discovery")
    public Object discovery() {
        //获得所有微服务列表的清单
        List<String> services = client.getServices();
        System.out.println("discovery=>services" + services);

        //得到具体的微服务信息  通过微服务的id
        List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER");
        for (ServiceInstance instance : instances) {
            System.out.println(
                    instance.getHost() + "\t" + instance.getUri() + "\t" + instance.getPort() + "\t"
            );
        }
        return this.client;
    }

2、在服务发送者的启动类中加入服务发现注解@EnableDiscoveryClient,该注解可以获取微服务的一些信息

@EnableDiscoveryClient  //服务发现，获取微服务的一些信息

3、浏览器测试获取到微服务的数据（输入http://localhost:8080/dept/discovery）

获取数据成功！

好了，我们今天微服务的内容就分享到这了，关于Eureka集群环境配置期待下一期的博客吧！！！

qq_41986840

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
粤嵌打卡第45天（SpringCloud学习之路二（亲手搭建一套微服务系统、Eureka服务注册、信息配置、自我保护机制））

今天我带领大家模拟一个微服务项目，将平常的ALL IN ONE项目拆分成多个子服务,实现消息提供者发送消息，消息接收者消费消息，最后会以Eureka进行服务注册与发现，让多个服务通过注册中心服务器来实现消费消息。1、创建springcloud主服务（普通Maven项目）pom文件的配置：springcloud依赖、springboot依赖、数据库mysql依赖、连接池Druid依赖、mybatis整合springboot依赖、junit单元测试依赖、lombak依赖、log4j日志依赖等<?x
复制链接

扫一扫