首页手记 SpringCloud应用学习入门：轻松搭建第一个微服务应用

SpringCloud应用学习入门：轻松搭建第一个微服务应用

标签：

Spring Cloud

概述

本文详细介绍了如何从零开始搭建SpringCloud应用，涵盖安装开发环境、创建第一个SpringBoot项目、实现服务发现与注册以及服务间通信等内容。通过本文的学习，读者可以全面了解SpringCloud应用学习入门的各个步骤和关键点。

引入SpringCloud

SpringCloud是什么

SpringCloud 是一套基于Spring Boot的微服务框架，它提供了一整套的微服务解决方案，旨在简化微服务的开发与部署。SpringCloud是一系列框架的有序集合，涵盖了一系列微服务架构中常见的模式和组件，如服务发现、服务调用、服务容错、配置中心等。SpringCloud的核心作用是让构建分布式系统变得更容易。

SpringCloud的主要组件

SpringCloud包含多个核心组件，每个组件负责微服务架构中的不同方面：

Eureka：基于REST的服务发现实现，提供了服务注册与发现的功能。

示例配置（application.yml）：

spring:
application:
 name: service-provider
eureka:
client:
 register-with-eureka: true
 fetch-registry: true
 service-url:
   defaultZone: http://localhost:8761/eureka/

Ribbon：客户端负载均衡，提供了多个负载均衡算法。
Feign：声明式的Web服务客户端，它使得编写Web服务客户端更加容易。

Hystrix：提供断路器模式以保护微服务架构。

示例配置（application.yml）：

hystrix:
command:
 default:
   execution:
     isolation:
       strategy: SEMAPHORE
       timeout:
         enabled: true
         value: 1000

Zuul：提供动态路由、过滤和监控等功能的API网关。
Config：集中化配置，可以将配置统一放到配置中心，支持本地配置文件、git等。
Spring Cloud Stream：用于与消息代理（如RabbitMQ、Kafka等）进行交互。

SpringCloud的优势

SpringCloud的优势体现在以下几个方面：

简化开发：通过一系列预配置的组件，开发者可以更容易地开发微服务。
服务治理：提供服务注册与发现、负载均衡、断路器等功能，简化了服务治理的实现。
弹性伸缩：支持服务自愈、容错和高可用性，提高了系统的可伸缩性。
集中配置：通过配置中心，可以动态更新配置，简化了应用的配置管理。
快速集成：基于Spring Boot，能够快速集成各种服务，扩展性强。

安装与配置开发环境

搭建Java开发环境

要开发SpringCloud应用，首先需要搭建一个Java开发环境。以下是具体步骤：

安装JDK：确保安装了Java开发工具包（JDK）。
设置环境变量：
- 设置JAVA_HOME环境变量指向JDK的安装目录。
- 设置PATH环境变量包含Java的bin目录。
示例配置：
```
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
export PATH=$JAVA_HOME/bin:$PATH
```
验证安装：
使用命令java -version和javac -version验证安装是否成功。

java -version
javac -version

安装IDE（如IntelliJ IDEA或Eclipse）

开发SpringCloud应用推荐使用集成开发环境（IDE）来提高开发效率。以下介绍如何安装和配置IntelliJ IDEA和Eclipse：

安装IntelliJ IDEA：

访问官网下载IntelliJ IDEA。
进行安装，选择合适的安装路径。
安装完成后启动IDEA，配置相应的插件（如Spring Boot）。

安装Eclipse：

访问Eclipse官网下载Eclipse开发工具。
解压文件，启动Eclipse。
安装相应的插件（如Spring IDE）以支持Spring Boot开发。

配置Maven或Gradle

Maven和Gradle是构建工具，用于管理项目依赖和构建过程。以下是配置步骤：

配置Maven：

下载Maven并解压到指定目录。
设置M2_HOME环境变量指向Maven的安装目录。
设置PATH环境变量包含Maven的bin目录。

示例配置：
```
export M2_HOME=/path/to/maven
export PATH=$M2_HOME/bin:$PATH
```
验证安装：
```
mvn -version
```

配置Gradle：

下载Gradle并解压到指定目录。
设置GRADLE_HOME环境变量，指向Gradle的安装目录。

设置PATH环境变量包含Gradle的bin目录。

示例配置：

export GRADLE_HOME=/path/to/gradle
export PATH=$GRADLE_HOME/bin:$PATH

验证安装：
```
gradle -v
```

创建第一个SpringBoot项目

使用Spring Initializr快速创建项目

Spring Initializr是一个在线工具，可以快速创建Spring Boot项目。以下是具体步骤：

访问Spring Initializr网站：https://start.spring.io/
填写项目的基本信息，例如：
- 项目类型：选择Maven或Gradle
- 语言：Java
- 依赖：选择Spring Web、Spring Boot DevTools等
点击Generate生成项目，下载生成的压缩文件。
解压文件，导入到IDE中。

示例配置（Maven项目）：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
</dependency>

添加SpringCloud依赖

在创建的项目中，添加SpringCloud相关依赖。示例配置（Maven）：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

项目结构与基本配置

创建的项目通常会包含以下目录结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── myapp
│   │               ├── Application.java
│   │               └── controller
│   │                   └── HelloController.java
│   └── resources
│       ├── application.yml
│       └── static
└── test
    └── java
        └── com
            └── example
                └── myapp
                    └── ApplicationTests.java

Application.java是项目启动类：

package com.example.myapp;

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

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

application.yml是项目的配置文件：

spring:
  application:
    name: myapp
server:
  port: 8080
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/

实现服务发现与注册

使用Eureka作为服务注册中心

Eureka是Netflix开源的一个服务注册与发现的组件，主要用于服务发现和负载均衡。以下是配置Eureka服务注册中心的步骤：

创建一个Spring Boot项目作为Eureka服务器。
添加依赖项（Maven）：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

配置application.yml：

server:
  port: 8761
spring:
  application:
    name: eureka-server
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
  server:
    enable-self-preservation: false

启动Eureka服务器。

配置服务提供者与消费者

服务提供者：在另一个Spring Boot项目中添加Eureka客户端依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

配置服务提供者：

spring:
  application:
    name: service-provider
server:
  port: 8081
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/

实现服务提供者功能，例如创建一个简单的REST服务：

package com.example.serviceprovider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@RequestMapping("/api")
class ServiceProviderController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from Service Provider";
    }
}

服务消费者：创建另一个Spring Boot项目作为服务消费者，添加Eureka客户端依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

配置服务消费者：

spring:
  application:
    name: service-consumer
server:
  port: 8082
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/

实现服务消费者功能，例如使用RestTemplate调用服务提供者：

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

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

@RestController
@RequestMapping("/api")
class ServiceConsumerController {
    private final RestTemplate restTemplate;

    public ServiceConsumerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/hello")
    public String hello() {
        return restTemplate.getForObject("http://SERVICE-PROVIDER/api/hello", String.class);
    }
}

测试服务发现与注册功能

启动Eureka服务器：
```
mvn spring-boot:run
```
启动服务提供者：
```
mvn spring-boot:run
```
启动服务消费者：
```
mvn spring-boot:run
```
访问服务消费者提供的REST接口，验证服务发现与注册功能是否正常：
```
http://localhost:8082/api/hello
```

实现服务间通信

使用Feign进行RPC调用

Feign是一个声明式的Web服务客户端，使编写Web服务客户端变得更加容易。以下是配置Feign的步骤：

添加Feign依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

启用Feign客户端：在服务消费者项目中，添加@EnableFeignClients注解。

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

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

定义Feign客户端：创建一个接口，用于声明服务端点的方法。

package com.example.serviceconsumer;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@FeignClient(value = "SERVICE-PROVIDER", url = "http://SERVICE-PROVIDER/api")
public interface ServiceProviderClient {
    @GetMapping("/hello")
    String hello();
}

使用Feign客户端：在服务消费者控制器中，注入并使用Feign客户端。

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@RequestMapping("/api")
class ServiceConsumerController {
    private final ServiceProviderClient serviceProviderClient;

    public ServiceConsumerController(ServiceProviderClient serviceProviderClient) {
        this.serviceProviderClient = serviceProviderClient;
    }

    @GetMapping("/hello")
    public String hello() {
        return serviceProviderClient.hello();
    }
}

使用Ribbon进行客户端负载均衡

Ribbon是Netflix的一个基于HTTP和TCP的服务调用客户端，目的是提供一种简单易用的客户端负载均衡工具。以下是配置Ribbon的步骤：

添加Ribbon依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

配置Ribbon：在服务消费者中，配置Ribbon以实现负载均衡。

spring:
  application:
    name: service-consumer
server:
  port: 8082
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/
ribbon:
  NIWRRule:
    enabled: true
  MaxAutoRenewsPerInterval: 100
  MaxAutoRetries: 1
  MaxAutoRetriesNextServer: 1

使用Ribbon：在服务消费者中，通过RestTemplate调用服务提供者时，Ribbon会自动进行负载均衡。

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "SERVICE-PROVIDER", configuration = RibbonConfiguration.class)
public class ServiceConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceConsumerApplication.class, args);
    }
}

@RestController
@RequestMapping("/api")
class ServiceConsumerController {
    private final RestTemplate restTemplate;

    public ServiceConsumerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/hello")
    public String hello() {
        return restTemplate.getForObject("http://SERVICE-PROVIDER/api/hello", String.class);
    }
}

class RibbonConfiguration {
    // Ribbon配置相关的bean
}

使用Hystrix实现服务容错

Hystrix是一个用于处理分布式系统的延迟和容错的开源库，通过隔离服务的访问点，停止服务级联失败，以及提供近实时的监控和控制，来提高系统的弹性。

添加Hystrix依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

配置Hystrix：在服务消费者中，配置Hystrix以提供服务容错。

spring:
  application:
    name: service-consumer
server:
  port: 8082
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/
hystrix:
  command:
    default:
      execution:
        isolation:
          strategy: SEMAPHORE
          timeout:
            enabled: true
            value: 1000

使用Hystrix：在服务消费者中，通过Hystrix来保护服务调用。

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient
@EnableHystrix
@RibbonClient(name = "SERVICE-PROVIDER", configuration = RibbonConfiguration.class)
public class ServiceConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceConsumerApplication.class, args);
    }
}

@RestController
@RequestMapping("/api")
class ServiceConsumerController {
    private final RestTemplate restTemplate;

    public ServiceConsumerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/hello")
    public String hello() {
        return restTemplate.getForObject("http://SERVICE-PROVIDER/api/hello", String.class);
    }
}

class RibbonConfiguration {
    // Ribbon配置相关的bean
}

class HystrixConfiguration {
    // Hystrix配置相关的bean
}

部署与运行

将项目打包成可执行的JAR文件

为了将Spring Boot项目部署到生产环境，通常需要将其打包成可执行的JAR文件。以下是具体步骤：

使用Maven打包：
```
mvn clean package
```
使用Gradle打包：
```
gradle build
```
查看打包后的JAR文件：

打包完成后，可以在项目的target（Maven）或build/libs（Gradle）目录下找到生成的JAR文件。

在本地或云服务器上部署应用

部署应用的步骤如下：

选择部署方式：
- 本地部署：将打包好的JAR文件上传到本地服务器，并通过命令行启动。
- 云服务器部署：将打包好的JAR文件上传到云服务器（如AWS、阿里云等）。
上传JAR文件：
使用SCP、FTP或其他文件传输工具将JAR文件上传到服务器。
启动JAR文件：
使用以下命令启动JAR文件：
```
java -jar /path/to/your-app.jar
```

监控与日志管理

为了监控和管理应用的日志，可以采取以下措施：

使用Spring Boot Actuator：
Spring Boot Actuator提供了生产就绪功能，包括监控、信息端点、健康检查等。

配置日志输出：
在application.yml中配置日志输出。

logging:
 level:
   root: INFO
 file:
   name: /var/log/yourapp.log

使用外部日志管理工具：
可以使用ELK Stack（Elasticsearch、Logstash、Kibana）或Graylog等工具进行日志集中管理。
启动时参数：
启动应用时可以传递参数，设置日志级别等。
```
java -jar /path/to/your-app.jar --logging.level.root=DEBUG
```

总结

通过本篇文章的学习，读者应该能够掌握如何从零开始搭建一个Spring Cloud微服务应用。从安装开发环境到创建第一个Spring Boot项目，再到实现服务发现与注册、服务间通信、部署与运行，都进行了详细介绍。Spring Cloud的强大功能使得构建微服务系统变得更加容易，希望读者能够通过这篇文章更好地理解和应用Spring Cloud。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

吃鸡游戏

手记
篇

粉丝

55

获赞与收藏

339

关注作者，订阅最新文章

相关文章推荐

【SpringCloud微服务实战】搭建企业级应用开发框架（一）：架构说明

微服务入门【系列视频课程】

姚半仙：微服务应用要考虑的第一个问题什么？

微服务实战——微服务架构选型SpringCloud / Dubbo / K8S比较（一）

【SpringCloud-Alibaba系列教程】2.搭建用户微服务模块

阅读免费教程

Spring Cloud Hystrix

15个小节 6089 120

后端通用面试教程

41个小节 30273 342

网络编程入门教程

20个小节 12461 235

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空