springcloud简介及注册中心和单体项目拆分服务者消费者

最新推荐文章于 2022-01-30 22:34:27 发布
最新推荐文章于 2022-01-30 22:34:27 发布
阅读量472 收藏
点赞数 1
文章标签： springcloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/men_ma/article/details/110912805
版权

转载请标明出处：https://blog.csdn.net/men_ma/article/details/106847165.
本文出自 不怕报错 就怕不报错的小猿猿 的博客

springcloud简介及注册中心和单体项目拆分服务者消费者

目标

1、springcloud简介
2、注册中心eureka

1.Springcloud简介

1.1 简介

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. uul网关解决了服务调用安全性的问题
  2. 服务注册与发现（注册中心）eureka解决了各层服务耦合问题，它是微服务架构的核心，有它才能将单体项目拆解成微服务架构(就是解决了项目与项目之间的访问问题)
  3. Eureka集群解决了微服务中，注册中心宕机产生的问题
  4. Ribbon负载均衡及Feign消费者调用服务，减小了各微服务服务器的访问压力，默认采用了经典的轮询机制
  5. 熔断器Hystrix解决了，微服务架构中服务器雪崩（就是我们经常看到的刷着刷着网站刷不出来的那种，太多人刷了服务器会崩掉）现象
  6. 服务监控（单机Dashboard与集群turbine），方便运维人员查看微服务架构项目运行时，各个服务器的运行状态（一个单体项目会拆分为20多个项目，那么每个项目的运行状态到底怎么样，哪个阶段是好的哪个阶段是坏的，我们就是去监控这些项目的服务）
  7. 服务配置中心（springcloud config），用来通过github统一管理各个微服务的配置文件（yml文件）（就是将单个项目中的所有配置文件集中管理）

多模块的maven项目：
在这里插入图片描述

springcloud的版本：
在这里插入图片描述

SpringBoot版本和SpringCloud版本的关系：
在这里插入图片描述

springcloud核心架构：
在这里插入图片描述

springcloud组件架构：
在这里插入图片描述

s单体应用结构图：

在这里插入图片描述

2.入门案例

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

  1. 父工程：microservice
  2. 通用模块（M）：microservice-common
  3. 服务提供者（C）：microservice-student-provider-1001
  4. 服务消费者（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来调用提供者的服务的。

传统项目拆分成微服务架构图：
在这里插入图片描述

2.1 创建父工程microservice（maven项目）

父工程是一个maven项目，一般创建方式即可，父工程的主要用途是锁定pom依赖包版本。由于springcloud2X停止更新，这里我们采用稳定的低版本，配套的springboot版本为1x版本。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
项目建好之后我们先来调一下maven的环境和字符编码集
在这里插入图片描述
在这里插入图片描述

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.xiaoqing</groupId>
    <artifactId>t243microservice</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--<packaging>war</packaging>-->
    <packaging>pom</packaging>


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

maven集合工程的使用：
在这里插入图片描述

2.2 创建通用模块microservice-common

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

在这里插入图片描述
在这里插入图片描述
然后一直往下面建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.xiaoqing</groupId>
        <artifactId>t243microservice</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>microservice-common</artifactId>


    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

MicroserviceCommonApplication（启动类）：

package com.xiaoqing.microservicecommon;

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;

/**
 * (exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
 * :排除掉本项目默认不读写数据库
 */
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class MicroserviceCommonApplication {

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

}

使用jpa建表：
实体类Student：

package com.xiaoqing.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;
    }
     
     
     
}

在这里插入图片描述

2.3 创建服务提供（生产）者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.xiaoqing</groupId>
        <artifactId>t243microservice</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>com.xiaoqing</groupId>
            <artifactId>microservice-common</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

        <!--添加注册中心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>
        <!-- actuator监控引入 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</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: 1001
  context-path: /
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/t243?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

eureka:
  instance:
    hostname: localhost  #eureka客户端主机实例名称
    appname: microservice-student  #客户端服务名
    instance-id: microservice-student:1001 #客户端实例名称
    prefer-ip-address: true #显示IP
  client:
    service-url:
      defaultZone: http://localhost:2001/eureka   #把服务注册到eureka注册中心

info:
  groupId: com.xiaoqing.t243microservice
  artifactId: microservice-student-provider-1001
  version: 1.0-SNAPSHOT
  userName: http://xiaoqing.com
  phone: 123456

MicroserviceStudentProvider1001Application（启动类）： 

package com.xiaoqing.microservicestudentprovider1001;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * @EntityScan("com.xiaoqing.*.*"):让jpa去扫描
 */

@EntityScan("com.xiaoqing.*.*")
@EnableEurekaClient
@SpringBootApplication
public class MicroserviceStudentProvider1001Application {

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

}

StudentRepository（jpa的增删改查）： 

package com.xiaoqing.microservicestudentprovider1001.repository;

import com.xiaoqing.microservicecommon.entity.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

/**
 * jpa的增删改查
 */
public interface StudentRepository extends JpaRepository<Student, Integer>, JpaSpecificationExecutor<Student> {
 
}

StudentService.java 层就不贴啦：

StudentServiceImpl.java ： 

package com.xiaoqing.microservicestudentprovider1001.service.impl;

import com.xiaoqing.microservicecommon.entity.Student;
import com.xiaoqing.microservicestudentprovider1001.repository.StudentRepository;
import com.xiaoqing.microservicestudentprovider1001.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author晴sister
 * @site https://blog.csdn.net/men_ma
 * @company xxx公司
 * @create  2020-12-08 11:13
 */


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： 

package com.xiaoqing.microservicestudentprovider1001.controller;

import com.xiaoqing.microservicecommon.entity.Student;
import com.xiaoqing.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;
        }
    }
}

2.4 创建服务消费者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.xiaoqing</groupId>
        <artifactId>t243microservice</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.xiaoqing</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: 8080
  context-path: /

MicroserviceStudentConsumer80Application:

package com.xiaoqing.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.xiaoqing.microservicestudentconsumer80.config;

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

@Configuration
public class SpringCloudConfig {

    /**
     * 通过RestTemplate这个协议让消费者与生产者产生数据交互
     *      restful:操作网络协议的，关于http的增删改查
     * @return
     */
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

StudentConsumerController.java :

package com.xiaoqing.microservicestudentconsumer80.controller;

import com.xiaoqing.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 {

    /*
        "http://localhost:1001":是生产者也是提供者
        当你访问8080服务时就会自动访问1001服务
    */
    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;
        }
    }
}

我们来启动一下服务先看一下效果：
数据库中的数据：
在这里插入图片描述

启动生产者（提供者）服务-----再启动消费者服务的成功效果图如下:

1001端口的生产者（提供者）访问：
在这里插入图片描述
8080端口的消费者访问：
在这里插入图片描述

3.初识springcloud的eureka（注册中心）

传统的单体项目访问：
在这里插入图片描述

体验微服务架构拆分以及服务提供者与服务消费者的概念：

在这里插入图片描述

3.1 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基本架构（服务注册与发现原理）：
在这里插入图片描述

3.2 Eureka的使用

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

新建 module microservice-eureka-server-2001（springboot项目）；
在pom文件中加入eureka-server依赖；
在yml文件中添加Eureka服务端相关信息；
在启动类中添加@EnableEurekaServer注解；

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.xiaoqing</groupId>
        <artifactId>t243microservice</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     #alse 由于注册中心的职责就是维护服务实例，它并不需要去检索服务，所以也设置为false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/       #设置与Eureka注册中心交互的地址，查询服务和注册服务用到

MicroserviceEurekaServer2001Application:

package com.xiaoqing.microserviceeurekaserver2001;

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

/**
 * EnableEurekaServer:开启Eureka服务
 */
@EnableEurekaServer
@SpringBootApplication
public class MicroserviceEurekaServer2001Application {

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

}

搭建成功截图如下:
在这里插入图片描述

3.3 向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  #eureka客户端主机实例名称
    appname: microservice-student  #客户端服务名
    instance-id: microservice-student:1001 #客户端实例名称
    prefer-ip-address: true #显示IP
  client:
    service-url:
      defaultZone: http://localhost:2001/eureka   #把服务注册到eureka注册中心

这里的defaultZone要和前面服务注册中心的暴露地址一致；
在这里插入图片描述

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

package com.xiaoqing.microservicestudentprovider1001;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * @EntityScan("com.xiaoqing.*.*"):让jpa去扫描
 */

@EntityScan("com.xiaoqing.*.*")
@EnableEurekaClient
@SpringBootApplication
public class MicroserviceStudentProvider1001Application {

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

}

然后我们测试下，先启动服务注册中心，再启动这个服务提供者；
然后运行：http://localhost:2001/
服务提供者成功注册截图如下：
在这里插入图片描述

点击实例状态结果如下：
在这里插入图片描述

解决方案如下:

  1. 首先在服务提供者项目pom.xml里加入actuator监控依赖：
<!-- actuator监控引入 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

在这里插入图片描述

  1. 最后服务提供者项目application.yml加上info配置：
info:
  groupId: com.xiaoqing.t243microservice
  artifactId: microservice-student-provider-1001
  version: 1.0-SNAPSHOT
  userName: http://xiaoqing.com
  phone: 123456

在这里插入图片描述
服务提供者pom修改
结果图如下:
在这里插入图片描述

小结：

1、springcloud解决了什么问题？
2、最简单的分布式架构的项目
①一个消费者一个生产者
3、引入eureka初步解决可能的服务宕机的问题（要与后面的博客配合使用）
②初步理解注册中心的作用
4、配置注册中心中的服务的联系负责人

over…这篇博客花了太多的时间来
希望喜欢的可以给博主点个赞支持一下，谢谢！！

不怕报错 就怕不报错的小猿猿
关注
SpringCloud微服务拆分实战之大二 (下)Java期末大作孽
`or 1 or 不正经の泡泡
06-04 922
由于时间关系，这次期末作孽只能做一个非常简单的玩意，由于期末作业可以在阶段作品的基础上进行优化，于是我有个大胆的想法，为什么我不阔以直接把SpringBoot 构建的单体项目拆分为微服务架构，这个也是一个升级嘛，顺便复习一下微服务。本次微服务拆分的案例是：嘿从零开始基于SpringBoot 打造在线聊天室（4.4W字最长博文）（PS：主要是为了对付期末作业，如果没事的话，别这样乱拆）这个是基于vue + springBoot 整合mybatis websocket 做的在线聊天室（这里直接使用Map来代替r
SpringCloud【微服务架构进化论、微服务的拆分规范和原则、为什么选择Spring Cloud、什么是服务治理 】(一)-全面详解（学习总结---从入门到深化）
最新发布
12-10 1929
SpringCloud【微服务架构进化论、微服务的拆分规范和原则、为什么选择Spring Cloud、什么是服务治理 】(一)-全面详解（学习总结---从入门到深化）
SpringCloud入门
今晚几点睡的博客
01-08 389
springcloud1、SpringCloud简介简介入门案例2、注册中心eureka 1、SpringCloud简介 简介 Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring Clo...
springcloud篇二之生产者与消费者
qq_39298872的博客
03-02 1207
一、springcloud篇之生产者与消费者 1.1、新建一个maven项目作为父工程,只留pom配置文件 以下是我们会用的一些依赖,使用的是依赖管理，springcloud和springboot版本对用很重要 别出错了 <packaging>pom</packaging> <properties> <project.build.sourceEncoding>utf-8</project.build.sourceEncoding>
SpringCloud -- 服务拆分和远程调用、提供者与消费者
天行健 君子以自强不息，地势坤 君子以厚德载物。
01-30 2135
服务拆分和远程调用
Nacos
liyanan21的博客
04-08 1963
目录 架构 名字服务（Naming Service） 服务注册与发现 Nacos core 1. 回调机制 2. 寻址机制 3. 数据一致性 服务（Service）是 Nacos 世界的一等公民。Nacos 支持几乎所有主流类型的“服务”的发现、配置和管理 特性大图：要从功能特性，非功能特性，全面介绍我们要解的问题域的特性诉求 架构大图：通过清晰架构，让您快速进入 N...
Dubbo和Spring Cloud微服务架构对比——服务注册和发现.docx
01-03
- **服务发现**：服务消费者需要调用另一个服务时，会通过服务注册中心获取目标服务的信息（如IP地址、端口等），然后发起调用。 #### Dubbo与Spring Cloud在服务注册与发现上的比较 1. **Dubbo**： - **注册中心...
SpringBoot项目拆分为SpringCloud微服务管理
weixin_43608969的博客
10-30 2152
问题背景：由于之前的项目赶的匆忙，所以把所有功能的代码都整合在了一起，以致于耦合度太高，造成了牵一发动全身的情况，所以现在时间相对充分，就将之前的项目拆分成微服务管理。 原项目其实并非springboot项目，而是Spring项目，因为要拆出来做成springBoot，这里就不说Spring的事情了。 最终项目结构： 我这里只做个demo，所以在原项目基础上做的，这里拆出来了三个module分别为注册中心，服务提供者和服务调用者。所谓SpringCloud微服务，就要每一个模块都要成为独立的服务，各自运行，
Spring Cloud Alibaba 从入门到精通1
08-03
Spring Cloud则在此基础上，为微服务提供了统一的抽象和实现，包括服务注册发现、熔断机制、配置管理等功能。Spring Cloud Alibaba 是Spring Cloud生态的一部分，它为开发者提供了与Spring Boot无缝集成的微服务组件...
分布式（微服务）项目拆分之注册中心、服务消费者、服务提供者的相关配置
Code2017的博客
05-11 885
分布式（微服务）项目拆分之注册中心、服务消费者、服务提供者的相关配置注意事项操作步骤 注意事项 整个过程中要注意导包、版本、JDK是否有添加等问题 操作步骤 注册中心：Eureka（服务注册于发现的框架），是SpringCloud Netflix的一部分，整个过程中要注意导包、版本、JDK是否有添加等问题 SpringCloud是基于SpringBoot的，所以先要创建一个SpringBoot项...
基于springcloud的微服务实战
AI开源工具分享
08-17 2502
1引言 1.1目的 本博文是基于springboot+springcloud实现的微服务架构改造，提供对研发人员的技术架构支持。版本0.0.1主要实现了四个模块的功能：服务生产者，服务消费者，服务注册中心，客户端负载均衡。后续还会根据项目进展进行持续优化和扩展。 1.2背景 对现有项目进行服务化改造实践，提高团队技术储备。 1.3定义 服务生产者：独立的应用，负责提供微服务 服
spring cloud注册中心，服务提供作者，服务消费者的一些区别
Ay_Ly的博客
07-18 2632
Spring Cloud Eureka, 使用Netflix Eureka来实现服务注册与发现。 Eureka服务端，我们也称为服务注册中心。   同其他服务注册中心 一 样，支持高可用配置。它依托于强 一 致性提供良好的服务实例可用性，可以应对多种不同的故障场景。如果Eureka以集群模式部署，当集群中有分片出现故障时，那么Eureka就转入自我保护模式。它允许在分片故障期间继续提供服务的发...
springcloud(一) 服务拆分
weixin_30411239的博客
12-24 421
一般我们的项目如果需要从单应用服务升级到微服务，必须要将原来的服务做拆分，我这边的拆分也是基于将之前spb-demo的springboot单应用做拆分，拆分出三个应用，spb-brian-query-service(brian查询服务)，spb-core(注册中心)，spb-job(job任务服务)，服务升级拆分注意几个关键点拆分起来很简单： 1.原来的spb-demo的springboot单应...
spring cloud微服务注册服务提供者以及服务的消费者到注册中心
带刺的螳螂
08-18 3452
一、搭建工具介绍： idea springboot 2.x 版本 jdk1.8.x 版本 上一篇博客简单的介绍了springcloud微服务注册中心的搭建，有了注册中心之后，我们需要把服务提供者以及服务的消费者都需要注册到我们注册中心所在的地址，在这里简单介绍一下两个概念： 服务提供者：服务的提供者指的是某一个程序发布一个向外可以被外界访问的服务接口，就好比去商店买东西，商店就属于服务的...
SpringBoot + RabbitMQ实战（生产者、消费者分离）
Jake Weng
11-20 1770
IDE：Intellij Idea 2018.1.5 based on: jdk 1.8.0_191 建立spring工程 自行命名Group和Artifact 创建maven项目是其中的group id和artifact id怎么填写 groupid和artifactId被统称为“坐标”是为了保证项目唯一性而提出的，如果你要把你项目弄到maven本地仓库去，你想要找到你的项目就必须根据这两...
【项目创建流程】注册中心和服务调用和配置中心
积木
07-08 646
【项目创建流程】Nacos注册中心和服务调用和配置中心Nacos注册中心1、常见注册中心 Eureka：Eureka是Spring Cloud Netflix中的重要组件，主要作用就是做服务注册和发现。2.0遇到性能瓶颈，停止维护，现在已经闭源。 Consul：Consul是基于GO语言开发的开源工具，主要面向分布式，服务化的系统提供服务注册、服务发现和配置管理的功...
SpringCloud搭建（上）----注册中心+服务提供者+服务消费者
kelly921011的博客
09-09 1374
一、SpringCloud概述 1.什么是微服务： 简而言之，微服务微服务架构风格这种开发方式，是以开发一组小型服务的方式来开发一个独立的应用系统。其中每个小型服务都是运行在自己的进程中，并且采用HTTP资源API这样轻量的机制来相互通信。这些服务围绕业务功能进行搭建，并能通过全自动的部署机制来进行独立部署。这些微服务可以使用不同的语言来编写，并且可以使用不同的数据存储技术。对这些微...
深入理解SpringCloud微服务技术栈：从初识到Eureka注册中心
此外，文档还定义了服务提供者和服务消费者的概念，服务提供者提供接口供其他微服务调用，而服务消费者则调用这些接口以完成业务逻辑。服务提供者和消费者的角色是相对的。 在第二章中，重点讲述了Eureka注册中心的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值