SpringCloud 基本入门

最新推荐文章于 2024-08-17 19:48:03 发布
最新推荐文章于 2024-08-17 19:48:03 发布
阅读量425 收藏
点赞数 3
分类专栏： spring SpringCloud 文章标签： Spring SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44641053/article/details/103125294
版权
本文介绍了SpringCloud作为微服务解决方案的基本概念、组件和前景。通过对比单体项目与分布式项目，阐述了SpringCloud简化分布式系统开发的优势。文章详细讲解了SpringCloud的组成，如Eureka服务发现，以及其与Dubbo的比较。此外，还提供了简单的入门案例，展示了如何创建服务提供者和消费者，并介绍了Eureka的使用。最后，讨论了SpringCloud在国内的普及现状和其优点，包括集大成者、约定优于配置、轻量级组件和开发简便等特性。
摘要由CSDN通过智能技术生成

SpringCloud 入门使用

本章知识：

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

初识 SpringCloud

在我们以前都是使用的都是单机项目，笼统的说就是所有的东西都在一个整体项目中， 那么两者之间有什么区别呢？

以前的单机项目的优点有：开发简便,部署方便，硬要说缺点的话就是对于分布式项目来说的话耦合度就太高了，每个人都是开发一个同一个项目，使用的文件都可能有所差异，所以在开发过程中开发人员可能空间距离就不易太远了（更好讨论）。

那么，分布式项目优点：就在于它里面的每个模块都可以分为不同的子项目，那么对于耦合度的话就大大的解耦了。而且在每个子项目中每个写子项目的人都可以用自己不同的插件和文件格式，这个的自由度就非常高了，缺点的话，咳咳，就在于难部署，配置文件会麻烦一点。
在这里插入图片描述
在这里插入图片描述

Spring Cloud 是一套完整的微服务解决方案，基于 Spring Boot 框架，准确的说，它不是一个框架，而是一个大的容器，它将市面上较好的微服务框架集成进来，从而简化了开发者的代码量。

和Dubbo的比较：
在这里插入图片描述

SpringCloud 简介

SpringCloud 是一系列框架的有序集合。

spring cloud 为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等。它运行环境简单，可以在开发人员的电脑上跑。

换句话来说，SpringBoot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用SpringBoot的开发风格做到一键启动和部署。

SpringCloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，
通过SpringBoot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

在这里插入图片描述

SpringCloud 组成

在这里插入图片描述
SpringCloud的子项目，大致可分成两类。
第一类是对现有成熟框架"SpringBoot化"的封装和抽象，也是数量最多的项目;
第二类是开发了一部分分布式系统的基础设施的实现，如Spring Cloud Stream扮演的就是kafka, ActiveMQ这样的角色。
对于我们想快速实践微服务的开发者来说，第一类子项目就已经足够使用，
如:

  • Spring Cloud Netflix是对Netflix开发的一套分布式服务框架的封装，包括服务的发现和注册，负载均衡、断路器、REST客户端、请求路由等。

  • Spring Cloud Config将配置信息中央化保存, 配置Spring Cloud Bus可以实现动态修改配置文件

  • Spring Cloud Bus分布式消息队列，是对Kafka, MQ的封装

  • Spring Cloud Security对Spring Security的封装，并能配合Netflix使用

  • Spring Cloud Zookeeper对Zookeeper的封装，使之能配置其它Spring Cloud的子项目使用

  • Spring Cloud EurekaSpring Cloud Eureka 是 Spring Cloud Netflix 微服务套件中的一部分，它基于Netflix Eureka 做了二次封装，主要负责完成微服务架构中的服务治理功能。

SpringCloud 发展前景

SpringCloud对于中小型互联网公司来说是一种福音，因为这类公司往往没有实力或者没有足够的资金投入去开发自己的分布式系统基础设施，使用SpringCloud一站式解决方案能在从容应对业务发展的同时大大减少开发成本。

同时，随着近几年微服务架构和Docker容器概念的火爆，也会让SpringCloud在未来越来越"云"化的软件开发风格中立有一席之地，尤其是在目前五花八门的分布式解决方案中提供了标准化的、全站式的技术方案，意义可能会堪比当年Servlet规范的诞生，有效推进服务端软件系统技术水平的进步。

（Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，相互之间不会有任何接口。）

但是，目前，国内使用 Spring Cloud 技术的大公司并不多见，不是因为 Spring Cloud 不好！主要原因有以下几点：

1、Spring Cloud 中文文档较少，出现问题网上没有太多的解决方案。

2、国内创业型公司技术老大大多是阿里系员工，然而，阿里系多采用 Dubbo 来构建微服务架构。

3、大型公司基本都有自己的分布式解决方案，而中小型公司的架构很多又用不上微服务，所以没有采用 Spring Cloud 的必要性。

但是，SpringCloud的优点还是很有有诱惑力的。

其主要 优点 有：

1、集大成者，Spring Cloud 包含了微服务架构的方方面面。

2、约定优于配置，基于注解，没有配置文件。

3、轻量级组件，Spring Cloud 整合的组件大多比较轻量级，且都是各自领域的佼佼者。

4、开发简便，Spring Cloud 对各个组件进行了大量的封装，从而简化了开发。

5、开发灵活，Spring Cloud 的组件都是解耦的，开发人员可以灵活按需选择组件。

配套参考资料：

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

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

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

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文件）

简单入门案例

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

父工程：microservice
通用模块（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.dj..”)；

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

基本步骤

  1. 创建父工程 microservice

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

    先创建一个快速的maven项目：
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    选择maven仓库后，增加 Maven Property
    在这里插入图片描述
    在这里插入图片描述
    创建完成之后检查配置：
    在这里插入图片描述
    编码格式都设置为UTF-8：
    在这里插入图片描述
    总的pom.xml 配置如下

    在这里插入图片描述

    先删掉一些东西：
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    重新导入下边的依赖：

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

    完整的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.dj</groupId>
  <artifactId>springcloud01</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>springcloud01</name>
  <!-- FIXME change it to the project's website -->
  <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>

  1. 创建通用模块 microservice-common
    在这里插入图片描述
    在这里插入图片描述
    SpringBoot 版本选择 2.2.1
    在这里插入图片描述
    在这里插入图片描述
    通用模块主要存放实体类、工具包等被整个微服务框架所使用的代码。
    创建一个简单的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.dj</groupId>
        <artifactId>springcloud01</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>microservice-common</artifactId>

    <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>
            </plugin>
        </plugins>
    </build>

</project>

    MicroserviceCommonApplication.java

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

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

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

}

    Student.java

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

  1. 创建服务提供者 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.dj</groupId>
        <artifactId>springcloud01</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>microservice-student-provider-1001</artifactId>

    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.dj</groupId>
            <artifactId>microservice-common</artifactId>
        </dependency>
        <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>
    </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/springcloud?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

    MicroserviceStudentProvider1001Application.java

    package com.dj.microservicestudentprovider1001;

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

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

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

}

    StudentRepository.java

    package com.dj.microservicestudentprovider1001.reporsity;

import com.dj.microservicecommon.entity.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

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

    StudentService.java

    package com.dj.microservicestudentprovider1001.service;

import com.dj.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.dj.microservicestudentprovider1001.service.impl;

import com.dj.microservicecommon.entity.Student;
import com.dj.microservicestudentprovider1001.reporsity.StudentRepository;
import com.dj.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.dj.microservicestudentprovider1001.controller;

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

  1. 创建服务消费者 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.dj</groupId>
		<artifactId>springcloud01</artifactId>
		<version>1.0-SNAPSHOT</version>
	</parent>
	<artifactId>microservice-common</artifactId>

	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>com.dj</groupId>
			<artifactId>microservice-common</artifactId>
		</dependency>
		<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>
	</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.dj.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.dj.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.dj.microservicestudentconsumer80.controller;

import com.dj.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依赖

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.dj</groupId>
	        <artifactId>springcloud01</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>

在这里插入图片描述

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

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注册中心交互的地址，查询服务和注册服务用到

在启动类中添加@EnableEurekaServer注解

	package com.dj.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上加上配置：

	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注册中心交互的地址，查询服务和注册服务用到
	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.dj.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.dj.*.*")
	@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>

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

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

bug分享

在这里插入图片描述
在这里插入图片描述
找到我的apache路径，里面的conf文件，修改settings.xml里面的路径，D:\initPath\mvn\apache-maven-3.5.0\conf
在这里插入图片描述
在这里插入图片描述

本章小结：

1、SpringCloud解决了什么问题？
解决了项目中耦合度过高的问题。

2、最简单的分布式架构的项目
① 一个消费者一个生产者

3、引入Eureka初步解决可能的服务宕机的问题（与下篇博客配合使用）
② 初步理解注册中心的作用

4、配置注册中心中的服务的联系负责人

子项目结构
简单的说下本章所演示项目的结构：
common(公共模块)
consumer(消费者)
Eureka Server(服务注册中心)[Eureka服务端]
provider(服务提供者)[Eureka客户端]

1、父容器：所有的子项目都放到里面

2、common(公共模块): 所有的一些工具类和实体类都放到里面，调用还是可以调用到

3、consumer(消费者): 所有的配置没多少，就是用来模拟客户端的，但是要注意要加上忽略数据源的配置，否则会报错

4、provider(服务提供者)[Eureka客户端]: 所有的服务请求都再次进行一个处理,同时当在Eureka服务端注册过后就可以被其管理。

5、Eureka Server(服务注册中心)[Eureka服务端]: 服务注册中心，可以管理所有注册在内的服务子项目。

一只媛球球
关注
专栏目录
Spring Cloud 入门 新手入门
05-04
SpringCloud入门资源，适合新手，配合CSDN博客观看。
Spring Cloud基础入门
06-11
1、了解Spring Cloud核心模块构成概要，实操通过模版空代码搭建自有框架，了解Spring Cloud核心模块拉通细节；2、实操搭建服务脚手架，构建服务增删改查基础模块，考虑利用模版代码来加速解决；3、服务调用实例讲解...
springcloud简单入门
weixin_44832841的博客
04-29 189
1 Monolith和MicroService Monolith：单体应用架构 项目被打包成许多jar包，最终合并在一起形成一个war包，并将war包上传到web容器中解压然后重启服务器。这种将所有代码及功能都包含在一个war包中的项目组织方式称为Monolith。一般适用于中小型项目。 优点：项目很小的情况下开发比较容易，结构简单； 缺点：项目较大的情况下编译难、部署难、测试难，技术兼容难（多种...
Spring Cloud 入门，一篇搞定！
最新发布
hooheha的博客
08-17 659
SpringCloud是目前国内使用最广泛的微服务框架。官网地址：https://spring.io/projects/spring-cloud。SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。原理流程：Ribbon 通过 @LoadBalanced 注解标记了 RestTemplate 工具类，所以 Ribbon 就会去拦截 RestTemplate 所发起的 HTTP 请求，并做出一系列对策。
springcloud入门（1）
onlylixiaobei的博客
02-12 1750
今天用springboot创建一个小应用。 首先，创建一个简单的maven应用，如下图： 然后，配置pom.xml文件： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http:
springcloud 入门
m0_46084322的博客
03-18 176
微服务架构演进过程 微服务架构 微服务是系统架构上的一种设计风格,它的主旨是将一个原本独立的系统拆分成多个小型服务,这些小型服务都在各自独立的进程中运行,服务之间一般通过 HTTP 的 RESTfuL API 进行通信协作。 被拆分成的每一个小型服务都围绕着系统中的某一项或某些耦合度较高的业务功能进行构建,并且每个服务都维护着白身的数据存储、业务开发自动化测试案例以及独立部署机制。 由于有了轻量级的通信协作基础,所以这些微服务可以使用不同的语言来编写。 用springcloud进行微服务架构 Spring
Spring Cloud 简单入门
Forrest Gump的博客
03-27 124
1、微服务简介 微服务核心就是把传统的单机应用，根据业务将单机应用拆分为一个一个的服务，彻底的解 耦，每一个服务都是提供特定的功能，一个服务只做一件事,类似进程，每个服务都能够单 独部署，甚至可以拥有自己的数据库。这样的一个一个的小服务就是微服务。 微服务架构提倡： ①:将一个单一应用程序开发为一组小型服务 ②:每个服务运行在自己的进程中 ③:服务之间通过轻量级的通信机制(http rest ap...
Spring Cloud Alibaba 从入门到精通1
08-03
【Spring Cloud Alibaba 从入门到精通1】 Spring Cloud Alibaba 是一套基于阿里巴巴集团内部中间件实践经验，为Java开发者提供的微服务解决方案。它旨在简化云原生应用的开发过程，尤其是在Spring Cloud生态中，...
Spring Cloud视频入门教程百度网盘资源地址
04-16
本视频教程讲述的是Spring Cloud教程从入门级视频，懂一点Spring Boot的选手就可以学习该视频，但是想要学好Cloud，Boot是基础
SpringCloud基础教程
12-31
本基础教程旨在帮助初学者全面理解并掌握SpringCloud的核心概念和技术，通过实践源码与配套文档，深入学习其工作原理和应用方式。 首先，我们需要了解SpringCloud的基础架构，它由多个子项目组成，如Eureka（服务...
《spring cloud入门》
01-30
spring cloud应用越来越多，这个介绍，值得你一看，共勉
springCloud入门
05-02
springCloud入门文档，有注册中心，熔断器，路由等等，附代码
SpringCloud入门
叶
02-11 287
springcloud简单入门
springcloud入门
qq_24271537的博客
02-20 89
好东西 转https://blog.csdn.net/hantangduhey/category_9015566.html
Springcloud入门
userwang的博客
12-08 178
目录springcloud简介入门案例 springcloud简介 Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给
SpringCloud.入门
A2895922320的博客
02-16 289
一：SpringCloud概念 这里用一个电商平台举例 流程： 1.SpringCloud SpringCloud核心组件：Eureka SpringCloud核心组件：Fegin SpringCloud核心组件：Ribbon（负载均衡） SpringCloud核心组件：Hystrix SpringCloud核心组件：Zuul 二：Nacos的搭建 1.解压Nacos-server的压缩包 2.双击nacos包下bin目录下的startu...
一、SpringCloud入门
余笙的博客
05-26 302
一、微服务 1、微服务介绍 微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事，从技术角度看就是一种小而独立的处理过程，类似进程概念，能够自行单独启动或销毁，拥有自己独立的数据库。 2、微服务和微服务架构 微服务： 强调的是服务的大小，它关注的是某一个点，是具体解决某一个问题或提供落地对应服务的一个服务应用，狭意的看，可以看作Eclipse里面的一个个微服务工程或者Module 微服务架构： 是⼀种架构模式，它提倡将单⼀应⽤
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值