第一章 SpringCloud介绍及微服务架构编码构建

最新推荐文章于 2024-07-25 20:25:25 发布
最新推荐文章于 2024-07-25 20:25:25 发布
阅读量200 收藏 1
点赞数
文章标签： 架构 spring cloud 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53957101/article/details/132138585
版权

尚硅谷SpringCloud框架开发教程(SpringCloudAlibaba微服务分布式架构丨Spring Cloud)_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV18E411x7eT/?spm_id_from=333.337.search-card.all.click

1. 微服务架构概述

微服务架构是一种架构模式，它提倡将单一应用程序划分成一组小的服务，服务之间互相协调、互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务与服务间采用轻量级的通信机制互相协作（通常是基于HTTP协议的RESTful AP)。每个服务都围绕着具本业务进行构建，并且能够被独立的部署到生产环境、类生产环境等。另外，应当尽量避免统一的、集中式的服务管理机制，对具体的个服务而善应根据业务上下文，选择合适的语言、工具对其进行构建。

微服务技术栈：服务集群、注册中心、配置中心（热更新）、服务网关（校验、路由、负载均衡）、分布式缓存、分布式搜索、消息队列（异步通信）、数据库集群、分布式日志、系统监控链路追踪。

单体架构：将业务的所有的功能模块集中到一个项目中开发，打包成一个包部署。优点：架构简单、部署成本低；缺点：耦合度高 图片地址：XX系统架构图 流程图模板_ProcessOn思维导图、流程图https://www.processon.com/view/643bcd5f6dcb245472aae47a?fromnew=1

分布式架构：根据业务功能对系统进行拆分，每一页五五模块作为独立项目开发，称为一个服务。优点：降低服务耦合，有利于服务升级拓展；缺点：架构非常负载，运维、监控、部署难度提高。

2. Spring Cloud简介

SpringCloud=分布式微服务架构的一站式解决方案，是多种微服务架构落地技术的集合体，俗称微服务全家桶。Spring Cloud就是为开发人员所提供的一套快速构建的分布式系统工具。对于单体架构和分布式架构可以这么理解，单体架构对于Java开发人员可以说就是一个单体Spring Boot框架搭建的系统，而对于分布式架构如果使用微服务方式实现就是多个Spring Boot开发的服务集形成的系统。因此Spring Cloud相比于Spring Boot不在注重服务本身的开发而是服务集管理。

3. Spring Cloud技术栈

图片地址：Spring Cloud 微服务总体架构图 流程图模板_ProcessOn思维导图、流程图https://www.processon.com/view/64219530e9cb570f835d0326?fromnew=1

  • SpringCloud：注册中心（Eureka、Consul）、服务远程调用（Fegin--http协议）、配置中心（Spring Cloud Config）、服务网关（Spring Cloud Gateway、Zuul）、服务监控和保护（Hystrix）

  • Spring Cloud Alibaba：注册中心（Nacos、Eureka）、服务远程调用（Dubbo、Fegin）、配置中心（Spring Cloud Config、Nacos）、服务网关（Spring Cloud Gateway、Zuul）、服务监控和保护（Sentinel）

4. Spring Cloud与Spring Boot版本依赖

Spring Boot在git源代码地址：https://github.com/spring-projects/spring-boot/releases Spring Boot2.0新特性：https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Release-Notes Spring Boot官网：Spring Boot

Spring Cloud在git源代码地址：https://github.com/spring-projects/spring-cloud Spring Cloud官网：Spring Cloud

Spring Cloud与Spring Boot版本选择： 1.进入官网：Spring Cloud，

第一步：

第二步：

2.进入https://start.spring.io/actuator/info，筛选版本（对于json数据格式，可以使用tool.lu在线工具）

3.进入Spring Cloud官网滑到中底部

停更不停用： 被动修复bugs、不再接受和并请求、不在发布新版本

服务注册中心：Eureka（停更不停用）\Zookeeper\Consul\Nacos 服务调用：Ribbon\LoadBalancer\Feign（死了）\OpenFeign 服务降级：Hystrix（死了）\resilience4j\sentinel 服务网关：Zuul（死了）\gateway 服务配置：Config（不使用）\Nacos 服务总线：Bus（不使用)\Nacos

5. 微服务服务架构搭建

技术和工具版本选型：spring cloud（Hoxton.SR1）、spring boot（2.2.2.RELEASE）、cloud alibaba（2.1.0.RELESE）、Java（8）、Maven（3.5以上）、MySQL（5.7以上）

5.1 搭建父工程

搭建父工程目的是为了规范jar的版本，对于整个微服务来说使用相同版本的jar包实现版本统一或者减少子项目多次输入jar包版本。

这里详细展示需要注意搭建一个项目工程步骤，后续省略： 1.New Project中（选择一个最小）

2.字符编码（setting->file encoding）

3.注解激活

4.Java编译版本

5.文件过滤

5.2 父工程pom
<groupId>com.yicai.springcloud</groupId>
  <artifactId>cloud2020</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--  表示pom总的父工程-->
  <packaging>pom</packaging>
​
  <!--统一jar和版本号管理-->
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compailer.target>1.8</maven.compailer.target>
    <junit.version>4.12</junit.version>
    <log4j.version>1.2.17</log4j.version>
    <lombok.version>1.18.24</lombok.version>
    <mysql.version>5.1.47</mysql.version>
    <druid.version>1.2.8</druid.version>
    <mybatis.spring.boot.version>1.3.2</mybatis.spring.boot.version>
  </properties>
​
  <!--  子模块继承之后，提供作用：锁定版本+子module不写groupId和version-->
  <!--  父pom的依赖管理，子项目不用引入版本号，Maven会沿着父子层次向上爬，直到有个dependencyManagement  -->
  <dependencyManagement>
    <dependencies>
      <!--      Spring Boot版本-->
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.2.2.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <!--      Spring Cloud版本-->
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>Hoxton.SR1</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <!--      spring cloud alibaba 2.1.0.RELEASE-->
      <!-- spring cloud alibaba 2.1.0.RELEASE  关于依赖来取问题：https://blog.csdn.net/xxly1994/article/details/107058474-->
      <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>2.1.0.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <!--      mysql-->
      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
      </dependency>
      <!--      druid-->
      <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
      </dependency>
      <!--      mybatis-->
      <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>${mybatis.spring.boot.version}</version>
      </dependency>
      <!--      junit-->
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
      </dependency>
      <!--      log4j-->
      <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
      </dependency>
      <!--      lombok-->
      <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
      </dependency>
    </dependencies>
  </dependencyManagement>
​
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <version>2.2.5.RELEASE</version>
        <configuration>
          <fork>true</fork>
          <addResources>true</addResources>
        </configuration>
      </plugin>
    </plugins>
  </build>

Maven中dependencyManagement与depency：

Maven 使用dependencyManagement 元素来提供了一种管理依赖版本号的方式。通常会在一个组织或者项目的最顶层的父POM 中看到dependencyManagement 元素。使用pom.xml 中的dependencyManagement 元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。Maven 会沿着父子层次向上走，直到找到一个拥有dependencyManagement 元素的项目，然后它就会使用这个dependencyManagement 元素中指定的版本号。 ​ dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom。如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

Maven中跳过单元测试：

5.3 Rest微服务工程构建

1.构建cloud-provider-payment8001

pom文件：

<dependencies>
<!--        spring-boot-web 启动类-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--        spring-boot-actuator 健康监控-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
<!--        druid基于spring-boot-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
<!--        jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
<!--        热更新-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </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>
    </dependencies>

application.yaml

#端口
server:
  port: 8001
  
spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.25.153:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: Mya_123456
​
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities

主启动类：

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

业务类：

Linux安装MySQL数据库

  1. 建表

create table `payment`(
    `id` bigint(20) not null auto_increment comment 'ID',
    `serial` varcahr(200) default '',
    primary key(`id`)
)engine=innodb auto_increment=1 default charset=utf8;

  1. entities

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {  //序列化
    private Long id;
    private String serial;
}

  1. dao

@Mapper
public interface PaymentDao {
    //新增
    int create(Payment payment);
    //读取
    Payment getPaymentById(@Param("id") Long id);
}
<mapper namespace="com.yicai.springcloud.dao.PaymentDao">

    <insert id="create" parameterType="com.yicai.springcloud.entities.Payment" useGeneratedKeys="true" keyProperty="id">
        insert into payment(serial) value(#{serial})
    </insert>

    <resultMap id="BaseResultMap" type="com.yicai.springcloud.entities.Payment">
        <id property="id" column="id" jdbcType="BIGINT"></id>
        <id property="serial" column="serial" jdbcType="VARCHAR"></id>
    </resultMap>

    <select id="getPaymentById" resultMap="BaseResultMap" parameterType="Long">
        select * from payment where id=#{id}
    </select>
    
</mapper>

  1. service

public interface PaymentService {
    //新增
    int create(Payment payment);
    //读取
    Payment getPaymentById(@Param("id") Long id);
}
@Service
public class PaymentServiceImpl implements PaymentService {

    @Resource
    private PaymentDao paymentDao;

    @Override
    public int create(Payment payment) {
        return paymentDao.create(payment);
    }

    @Override
    public Payment getPaymentById(Long id) {
        return paymentDao.getPaymentById(id);
    }
}

  1. controller

@RestController
@Slf4j
public class PaymentController {

    @Autowired
    private PaymentService paymentService;

    @PostMapping(value = "/payment/create")
    public CommonResult create(Payment payment){
        int result= paymentService.create(payment);
        log.info("*********插入结果："+result);
        if(result>0){
            return new CommonResult(200,"插入成功",result);
        }else {
            return new CommonResult(444,"插入失败");
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id){
        Payment payment= paymentService.getPaymentById(id);
        log.info("*********插入结果："+payment);
        if(payment != null){
            return new CommonResult(200,"成功",payment);
        }else {
            return new CommonResult(444,"没有");
        }
    }
}

  1. 测试

2.构建cloud-consumer-order80

pom文件：

<dependencies>
        <!--        spring-boot-web 启动类-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--        spring-boot-actuator 健康监控-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--        热更新-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </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>
    </dependencies>

application.yaml：

server:
  port: 80

主启动类：

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

业务层：

  1. 实体类：跟colud-provider-payment8001项目一样

  2. 使用RestTemplate，配置RestTempalte

@Configuration
public class ApplicationContextConfig {
    
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

  1. controller

@RestController
@Slf4j
public class OrderController {

    public static final String PAYMENT_URL="http://localhost:8001";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment){
        return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);
    }

    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
    }
}

  1. 测试

 

添加注解@RequestBody解决此类问题。

RestTemplate：RestTemplate提供了多种便捷访问远程Http服务的方法,是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集。 官网：https://docs.spring.io/spring-framewprk/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html

快捷方式：

  1. 热部署（生产不建议）

  2. RunDashboard

3.工程重构

工程重构：主要就是将相同代码部分组成一个module项目，将module项目打成jar的方式，在其他项目中引入，解决代码冗余。

创建cloud-api-commons模块：

pom文件：

<dependencies>
        <!--        热更新-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.6</version>
        </dependency>
    </dependencies>

entities：跟colud-provider-payment8001项目一样

cloud-api-commons项目clean和install，其他模块并引入jar包：

<dependency>
    <groupId>com.yicai.springcloud</groupId>
    <artifactId>cloud-api-commons</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

测试：

gitee源代码地址：springcloud_study: springcloud：服务集群、注册中心、配置中心（热更新）、服务网关（校验、路由、负载均衡）、分布式缓存、分布式搜索、消息队列（异步通信）、数据库集群、分布式日志、系统监控链路追踪。

我愿为一粒沙
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
阿里首席架构师解读：Spring Cloud与Docker微服务架构实战
m0_54828003的博客
07-30 292
1.1单体应用架构存在的问题1.2如何解决单体应用架构存在的问题1.3什么是微服务1.4微服务架构的优点与挑战1.5微服务设计原则1.6如何实现微服务架构11.1Eureka常见问题11.2Hystrix/Feign整合Hystrix后首次请求失败11.3Turbine聚合的数据不完整11.4SpringCloud各组件配置属性11.5SpringCloud定位同题思路总结。...
阿里首席架构师解读：Spring Cloud 与 Docker 微服务架构实战
weixin_70730532的博客
06-28 358
活、不够稳定、不易扩展，等等)，所以大家对“如何成功实施微服务架构”越来越感兴趣。在 Java 技术栈中，Spring Cloud 独树一帜，提供了一整套微服务解决方案，它基于 Spring Boot 而构建，延续了 Spring 体系一贯的“简单可依赖”，但是由于微服务本身涉及的技术或概念比较广，所以在正式“入坑”之前,最好能有一本实战性强的书籍作为参考。下面就给大家推荐一下这本由阿里 P8 架构师编写的《Spring Cloud 与 Docker 微服务架构实战》，作为一部帮助大家实现微服务架构落地的作
Spring Cloud 微服务架构
xmh_sxh_1314的博客
02-12 671
本文示例基于Spring Boot 1.5.x实现，如对Spring Boot不熟悉，可以先学习我的这一篇：《Spring Boot 1.5.x 基础学习示例》。关于微服务基本概念不了解的童鞋，可以先阅读下始祖Martin Fowler的《Microservice》，本文不做介绍和描述。 一、分布式服务框架的发展 1.1 第一代服务框架 代表：Dubbo(Java)、Orleans(.Net)等 ...
SpringCloud微服务架构
最新发布
zyy030616的博客
07-25 1417
feign:client:config:default:# 设置日志记录级别，其取值共有none、basic、headers、full@Bean全局有效具体服务有效需求：定义全局过滤器，拦截请求，判断请求的参数是否满足下面条件：参数中是否有authorization，authorization参数值是否为admin如果同时满足则放行，否则拦截实现：import org。
spring cloud 微服务架构
xdkb159的博客
07-05 3988
Spring Cloud包含多个子项目，Spring Cloud Config（可扩展配置服务）、Spring Cloud Netflix、Spring Cloud CloudFoundry（开源PaaS云平台）、Spring Cloud AWS（亚马逊云服务平台）、Spring Cloud Security、Spring Cloud Commons、pring Cloud Zook...
springcloud之微服务架构
level_Tiller的博客
12-09 141
微服务 &微服务架构 微服务 不等于 微服务架构 微服务 : 强调的是服务的大小,它关注的是某一个点,是具体解决某一个问题\提供落地对应服务的一个服务应用,狭义的看,可以看做eclipse里面的一个个微服务工程/或者module.强调的是一个个的个体,每个个体完成一个具体的任务或者功能. 微服务架构是一种架构模式或者说是一种架构风格,它提倡将单一应用程序划分成一组小的服务,...
系统架构演变
wanghao112956的博客
08-16 101
（想自学习编程的小伙伴请搜索圈T社区，更多行业相关资讯更有行业相关免费视频教程。完全免费哦!） 集中式架构 优点：开发起来容易 缺点：代码耦合度高，后期维护较为困难 垂直拆分 集中式的架构是无法应对高并发的业务，所有请求都走一个模块，所以垂直拆分是根据业务功能对系统进行拆分 优点：解决了并发问题，可以对不同的模块进行优化 缺点：虽然对个业务进行了拆分，但还是存在许多的重复开发 分布式服务 将拆...
SpringCloud视频教程全套百度网盘
03-01
Spring Cloud 是一个基于 Spring Boot 的开发框架，旨在为微服务架构提供全面的支持，包括服务发现、配置管理、熔断、路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话状态管理等。它通过整合一...
SpringCloud实战：从公共模块搭建一套完整微服务架构
m0_63437643的博客
02-11 880
公共模块封装 从本篇开始，我们将学习框架的搭建。由于代码量巨大，本书不可能全部贴出，所以只展示一些核心代码。全部源码可以从本书配套源码中查看。 经过前几章的学习，读者应该对本项目有了大致的了解，也已搭建好了各个基本模块。为了保证应用程序的复用性和可扩展性，我们需要将一些常用的基本方法封装起来，以便各个模块调用。 在一个完整的微服务架构体系中，字符串和日期的处理往往是最多的。在一些安全应用场景下，还会用到加密算法。为了提升应用的扩展性，我们还应对接口进行版本控制。因此，我们需要对这些场景进行一定的封装，
Spring微服务实战第8章 使用Spring Cloud Stream的事件驱动架构
天空鸟的博客
09-13 478
文章目录第8章　使用Spring Cloud Stream的事件驱动架构8.1　为什么使用消息传递、EDA和微服务8.1.1　使用同步请求-响应方式来传达状态变化1．服务之间的紧密耦合2．服务之间的脆弱性3．在修改组织服务以增加新的消费者方面是不灵活的8.1.2　使用消息传递在服务之间传达状态更改1．松耦合2．耐久性3．可伸缩性4．灵活性8.1.3　消息传递架构的缺点1．消息处理语义2．消息可见性3．消息编排8.2　Spring Cloud Stream简介Spring Cloud Stream架构1．发射
SpringCloud-微服务架构
你看到的逆袭，只不过是一场预备很久，草蛇灰线，伏笔千里的反攻
07-29 571
在讲springCloud之前讲讲为什么要有springCloud，从学习中知道springCloud的兴起是因为Dubbo社区五年没有更新，在计算机这个行业里面五年没有进步真的太恐怖了，所以springCloud火热起来，以绝对的优势横扫分布式领域。虽然现在Dubbo已经开始活跃，但是springCloud绝不会被取代，而是蒸蒸日上，这时候我相信你和一样，肯定想知道原因。 springClou...
Spring Cloud微服务架构
兴浩的博客
06-06 2447
什么是微服务？ 微服务的概念源于 2014 年 3 月 Martin Fowler 所写的一篇文章“Microservices”。文中内容提到：微服务架构是一种架构模式，它提倡将单一应用程序划分成一组小的服务，服务之间互相协调、互相配合，为用户提供最终价值。 微服务架构优势 复杂度可控 在将应用分解的同时，规避了原本复杂度无止境的积累。每一个微服务专注于单一功能，并通过定义良好的接口清晰表述服务边界。 由于体积小、复杂度低，每个微服务可由一个小规模开发团队完全掌控，易于保持高可维护性和开发效率。 独立
04_SpringCloud
姬凝霜
12-09 278
1.简介 1.1 微服务架构 微服务架构： "微服务”一词源于 Martin Fowler的名为 Microservices的博文,可以在他的官方博客上找到 http://martinfowler.com/articles/microservices.html 微服务是系统架构上的一种设计风格,它的主旨是将一个原本独立的系统拆分成多个小型服务,这些小型服务都在各自独立的进程中运行,服务之间一般通过 HTTP 的 RESTfuLAPI 进行通信协作。 被拆分成的每一个小型服务都围绕着系统中的某一项或
云计算python Spring cloud 微服务
m0_60655253的博客
11-20 1366
理论 微服务概念 微服务的概念源于2014年3月Martin Fowler所写的一篇文章“Microservices”,微服务架构是一种架构模式，他提倡将单一应用程序划分成一组小的服务，服务之间互相互相协调、互相配合，为用户提供最终价值，每个服务运行在其独立的进程中，服务与服务间采用器轻量级的通信机制互相沟通（通常是基于HTTP的RESTFUL API）。每个服务都围绕着具体业务进行构建，并且能够被独立的部署到生产环境、类生产环境等，另外，应尽量避免统一的、集中式的服务管理机制，对具体的一个服务而言，.
SpringCloud 微服务架构
qq13321123的博客
06-19 176
实战视频参考通过实战，精通Spring Cloud微服务注册中心 Spring Cloud 是一个基于 Spring Boot 实现的微服务框架，它包含了实现微服务架构所需的各种组件。 注：Spring Boot 简单理解就是简化 Spring 项目的搭建、配置、组合的框架。因为与构建微服务本身没有直接关系，所以本文不对 Spring Boot 进行展开。 另外本文有一些例子涉及到 Spring 和 Spring Boot，建议先了解一下 Spring 和 Spring Boot 再阅读本文。 .
SpringCloud微服务架构(一)
MRhan6的博客
07-19 812
单体架构将业务的所有功能集中在一个项目中开发，打成一个包部署。优点架构简单部署成本低缺点耦合度高分布式架构根据业务功能对系统进行拆分，每个业务模块作为独立项目开发，称为一个服务。优点降低服务耦合有利于服务升级拓展缺点架构复杂，难度大微服务是一种经过良好架构设计的分布式架构方案。拆分粒度更小、服务更独立、耦合度更低架构非常复杂，运维、监控、部署难度提高。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我愿为一粒沙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值