首页手记 SpringCloud项目开发实战入门教程

SpringCloud项目开发实战入门教程

标签：

Java Spring Cloud 微服务

概述

本文详细介绍了Spring Cloud项目开发实战，涵盖了服务注册与发现、服务间通信、配置中心集成及服务容错保护等核心概念和组件。通过示例代码和实战案例，展示了如何搭建和运行一个完整的Spring Cloud微服务项目。希望读者通过本文能够掌握Spring Cloud的基本使用方法，为进一步学习和实践打好基础。

SpringCloud项目开发实战入门教程

Spring Cloud简介

什么是Spring Cloud

Spring Cloud 是一组基于Spring Boot的框架，旨在简化分布式系统中常见模式的实现，如配置管理、服务发现、断路器、智能路由、微服务仪表盘、批处理作业、分布式会话等等。Spring Cloud的构建理念是每一个组件都可以独立使用，也可以组合来解决复杂的业务场景。

Spring Cloud的核心概念

Spring Cloud的核心概念包括服务发现、配置管理、负载均衡、断路器、路由、过滤等。

服务发现：允许服务通过注册中心动态地发现其它服务的位置，是微服务架构中非常重要的一个环节。
配置管理：集中化管理配置，使得配置可以在运行时动态刷新。
负载均衡：根据负载情况智能分配请求到不同的实例上，提高系统的可用性和响应速度。
断路器：监控服务之间的调用情况，当检测到服务出现故障时，立即停止继续调用，防止故障蔓延。
路由与过滤：对请求进行过滤和路由，实现请求的动态路由和过滤。

Spring Cloud的版本选择

Spring Cloud的版本选择需要根据项目的具体需求和依赖版本进行选择。通常，Spring Cloud的版本会跟随Spring Boot的版本更新，确保兼容性和稳定性。建议选择最新版本的Spring Cloud，以获得最新的功能和改进。常用的版本有Hoxton、2020.0.x等。选择版本时，可以在Spring Cloud官网查看版本信息和更新日志。

Spring Cloud项目搭建

准备开发环境

JDK：建议使用JDK 1.8及以上版本。
IDE：推荐使用IntelliJ IDEA或Eclipse作为开发工具。
Spring Boot：本教程基于Spring Boot 2.x版本。
Maven 或 Gradle：用于构建和管理项目依赖。
Eclipse IDE for Spring Boot 或 Spring Tool Suite：这些工具集成了Spring Boot和Spring Cloud的开发工具。

创建Spring Boot项目

创建一个Spring Boot项目可以使用Spring Initializr，这是一个官方提供的在线工具，用于快速生成Spring Boot项目的基础结构。以下是具体步骤：

访问Spring Initializr的官网：https://start.spring.io/
选择项目的基本信息（如组名、项目名、语言等）。
选择需要的依赖（如Spring Web、Spring Cloud等）。
点击“Generate”按钮下载生成的项目。

生成的项目是一个基本的Spring Boot项目结构，已经包含了一些基本的配置文件和启动类。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── demo
│   │               ├── DemoApplication.java
│   │               └── DemoApplicationTests.java
│   └── resources
│       ├── application.yml
│       └── log4j2.xml

引入Spring Cloud依赖

在项目的pom.xml文件中添加Spring Cloud的相关依赖。这里以Spring Cloud版本为2020.0.0为例。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2020.0.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

服务发现与注册

Eureka服务注册与发现

Eureka是Netflix开源的一个服务注册和发现组件，是Spring Cloud支持的核心组件之一。它提供了服务注册、服务发现和心跳检测的功能。

Eureka服务器端配置

首先，创建一个Eureka Server服务注册中心。

创建一个新的Spring Boot项目。
在pom.xml文件中添加Eureka Server依赖：

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

在application.yml文件中配置Eureka Server：

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

创建启动类EurekaServerApplication.java：

package com.example.eureka;

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

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

Eureka客户端配置

接下来，配置一个服务提供者作为Eureka客户端，向Eureka服务器注册。

在pom.xml中添加Eureka客户端依赖：

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

在application.yml中配置服务提供者：

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

创建服务提供者的启动类ServiceProviderApplication.java：

package com.example.serviceprovider;

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

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

创建服务提供者接口Service.java：

package com.example.serviceprovider.service;

public interface Service {
    String sayHello(String name);
}

创建服务提供者实现类ServiceImpl.java：

package com.example.serviceprovider.service;

import org.springframework.stereotype.Service;

@Service
public class ServiceImpl implements Service {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

创建控制器ServiceController.java：

package com.example.serviceprovider.controller;

import com.example.serviceprovider.service.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceController {
    private final Service service;

    @Autowired
    public ServiceController(Service service) {
        this.service = service;
    }

    @GetMapping("/hello")
    public String sayHello(@RequestParam String name) {
        return service.sayHello(name);
    }
}

通过上述步骤，服务提供者已经可以向Eureka服务器注册并提供服务了。

Config配置中心

Spring Cloud Config提供了分布式系统中的外部化配置支持。它可以集中管理所有应用的外部化配置，并且支持版本控制。

Config Server配置

创建一个新的Spring Boot项目。
在pom.xml中添加Config Server依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
    </dependency>
</dependencies>

在application.yml中配置Config Server：

spring:
   application:
      name: config-server
server:
   port: 8888
spring:
   cloud:
      config:
         server:
            git:
               uri: https://github.com/user/repo
               username: user
               password: password
               clone-on-start: true

创建启动类ConfigServerApplication.java：

package com.example.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.ConfigurationServer;

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

在GitHub中创建一个仓库（例如config-repo），并将配置文件存储在该仓库中。例如创建一个application.yml文件：

spring:
  profiles:
  active: dev

Config Client配置

在客户端应用中集成Config Client，从Config Server获取配置。

在pom.xml中添加Config Client依赖：

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

在bootstrap.yml中配置Config Client：

spring:
   application:
      name: config-client
   cloud:
      config:
         uri: http://localhost:8888
         profile: dev
         label: master

创建启动类ConfigClientApplication.java：

package com.example.configclient;

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

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

创建配置文件的控制器ConfigController.java：

package com.example.configclient.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConfigController {
    @Value("${spring.application.name}")
    private String appName;

    @GetMapping("/appName")
    public String getAppName() {
        return appName;
    }
}

通过上述步骤，Config Client可以从Config Server获取配置。

服务间通信

RestTemplate使用

RestTemplate是Spring提供的用于发送HTTP请求的类。它提供了多种方法来发送HTTP请求，并接收响应。

使用RestTemplate发送GET请求

创建服务提供者接口Service.java：

package com.example.serviceprovider.service;

public interface Service {
    String sayHello(String name);
}

创建服务提供者实现类ServiceImpl.java：

package com.example.serviceprovider.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.client.RestTemplate;

public class ServiceImpl implements Service {
    private final RestTemplate restTemplate;

    @Autowired
    public ServiceImpl(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Override
    public String sayHello(String name) {
        String url = "http://service-provider/hello";
        return restTemplate.getForObject(url, String.class, name);
    }
}

创建服务提供者的启动类ServiceProviderApplication.java：

package com.example.serviceprovider;

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

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

创建控制器ServiceController.java：

package com.example.serviceprovider.controller;

import com.example.serviceprovider.service.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceController {
    private final Service service;

    @Autowired
    public ServiceController(Service service) {
        this.service = service;
    }

    @GetMapping("/hello")
    public String sayHello(@RequestParam String name) {
        return service.sayHello(name);
    }
}

Feign客户端开发

Feign是Netflix开源的一个声明式HTTP客户端，它使得编写HTTP客户端变得非常简单。Feign可以与Spring Cloud集成，实现服务间的通信。

使用Feign定义服务接口

创建服务提供者接口Service.java：

package com.example.serviceprovider.service;

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

@FeignClient(name = "service-provider")
public interface Service {
    @GetMapping("/hello")
    String sayHello(@RequestParam String name);
}

创建服务提供者的启动类ServiceProviderApplication.java：

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.cloud.openfeign.EnableFeignClients;

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

创建控制器ServiceController.java：

package com.example.serviceprovider.controller;

import com.example.serviceprovider.service.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceController {
    private final Service service;

    @Autowired
    public ServiceController(Service service) {
        this.service = service;
    }

    @GetMapping("/hello")
    public String sayHello(@RequestParam String name) {
        return service.sayHello(name);
    }
}

通过上述步骤，Feign客户端可以方便地调用服务提供者的接口。

服务容错与保护

Hystrix断路器

Hystrix是一种用于处理分布式系统延迟和容错的库，它可以实现断路器、超时和降级功能，防止系统过载。

使用Hystrix实现服务熔断

创建服务提供者接口Service.java：

package com.example.serviceprovider.service;

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

@FeignClient(name = "service-provider", fallback = ServiceFallback.class)
public interface Service {
    @GetMapping("/hello")
    String sayHello(@RequestParam String name);
}

package com.example.serviceprovider.service;

public class ServiceFallback implements Service {
    @Override
    public String sayHello(String name) {
        return "Service is down, please try again later";
    }
}

创建服务提供者的启动类ServiceProviderApplication.java：

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.cloud.openfeign.EnableFeignClients;

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

创建控制器ServiceController.java：

package com.example.serviceprovider.controller;

import com.example.serviceprovider.service.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceController {
    private final Service service;

    @Autowired
    public ServiceController(Service service) {
        this.service = service;
    }

    @GetMapping("/hello")
    public String sayHello(@RequestParam String name) {
        return service.sayHello(name);
    }
}

通过上述步骤，Hystrix可以在服务出现故障时立即停止继续调用，防止故障蔓延。

Zuul路由与过滤

Zuul是Netflix开源的一个基于Java的路由和服务代理组件，它是Spring Cloud Netflix的一部分，提供了动态路由、过滤、请求合并等功能。

使用Zuul实现路由

创建一个新的Spring Boot项目。
在pom.xml中添加Zuul依赖：

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

在application.yml中配置Zuul：

spring:
   application:
      name: zuul-server
server:
   port: 9000
zuul:
   routes:
      service-provider:
         path: /service-provider/**
         url: http://service-provider
eureka:
   client:
      register-with-eureka: true
      fetch-registry: true
      service-url:
         defaultZone: http://localhost:8761/eureka/

创建启动类ZuulServerApplication.java：

package com.example.zuulserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

通过上述步骤，Zuul可以实现请求的动态路由。

使用Zuul实现过滤

Zuul提供多种过滤器类型，包括pre（前置）、route（路由）、post（后置）和error（错误）过滤器。

创建前置过滤器PreFilter.java：

package com.example.zuulserver.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import org.springframework.stereotype.Component;

@Component
public class PreFilter extends ZuulFilter {
    @Override
    public String filterType() {
        return "pre";
    }

    @Override
    public int filterOrder() {
        return 1;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        ctx.set("requestTime", System.currentTimeMillis());
        return null;
    }
}

创建路由过滤器RouteFilter.java：

package com.example.zuulserver.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import org.springframework.stereotype.Component;

@Component
public class RouteFilter extends ZuulFilter {
    @Override
    public String filterType() {
        return "route";
    }

    @Override
    public int filterOrder() {
        return 1;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        long requestTime = ctx.get("requestTime", Long.class);
        ctx.set("responseTime", System.currentTimeMillis());
        ctx.set("elapsedTime", ctx.get("responseTime") - requestTime);
        return null;
    }
}

通过上述步骤，Zuul可以实现请求的过滤和路由。

实战案例

实战项目搭建

项目结构

创建一个新的Spring Boot项目。
在pom.xml中添加必要的依赖。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── eureka
│   │               ├── EurekaServerApplication.java
│   │           └── configserver
│   │               ├── ConfigServerApplication.java
│   │           └── serviceprovider
│   │               ├── ServiceProviderApplication.java
│   │           └── zuulserver
│   │               ├── ZuulServerApplication.java
│   └── resources
│       ├── application.yml
│       └── bootstrap.yml

配置文件

application.yml：用于Eureka Server和ServiceProvider的配置。
bootstrap.yml：用于Config Client的配置。

功能模块开发

Eureka Server

在EurekaServerApplication.java中配置Eureka Server。

package com.example.eureka;

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

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

Config Server

在ConfigServerApplication.java中配置Config Server。

package com.example.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.ConfigurationServer;

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

ServiceProvider

在ServiceProviderApplication.java中配置ServiceProvider。

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.cloud.openfeign.EnableFeignClients;

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

Zuul Server

在ZuulServerApplication.java中配置Zuul Server。

package com.example.zuulserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

测试与部署

测试

启动Eureka Server。
启动Config Server。
启动ServiceProvider。
启动Zuul Server。
访问http://localhost:8761，查看Eureka Server注册列表。
访问http://localhost:8888，查看Config Server配置信息。
访问http://localhost:8080/hello?name=World，查看ServiceProvider的响应。
访问http://localhost:9000/service-provider/hello?name=World，查看Zuul Server的请求转发。

部署

部署时需要考虑以下几点：

容器化：使用Docker容器化各个应用组件，便于部署和管理。
配置管理：使用Config Server集中化管理配置。
服务注册与发现：使用Eureka Server进行服务注册和发现。
路由与过滤：使用Zuul进行路由和过滤。
断路器：使用Hystrix实现服务容错和保护。

通过上述步骤，可以实现一个完整的Spring Cloud微服务项目。

总结

本文详细介绍了Spring Cloud的各个核心概念和组件，并通过示例代码展示了如何使用Spring Cloud进行服务注册与发现、服务间通信、服务容错与保护等。通过实战案例部分，读者可以了解如何将这些组件组合起来，搭建一个完整的微服务项目。希望读者通过本文能够掌握Spring Cloud的基本使用方法，为进一步学习和实践打好基础。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

胡说叔叔

手记
篇

粉丝

130

获赞与收藏

581

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340953 3155

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空