微服务的初步使用

已于 2023-10-10 16:23:23 修改
阅读量2.9k 收藏 8
点赞数 6
分类专栏： 微服务 Java IDEA 文章标签： java spring cloud 微服务
于 2023-10-05 23:32:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42881421/article/details/133589297
版权
IDEA 同时被 3 个专栏收录
16 篇文章 0 订阅
订阅专栏
Java
11 篇文章 0 订阅
订阅专栏
微服务
9 篇文章 0 订阅
订阅专栏

目录

环境说明

微服务案例的搭建

新建父工程

微服务模块

product-service（商品服务）

创建子工程

添加依赖

商品模块业务开发

创建业务数据库

测试

order-service（订单服务）

创建子工程

添加依赖

订单模块业务开发

测试

注册中心的使用

搭建注册中心

创建子工程

添加依赖

注册中心代码开发

测试

把服务注册到注册中心

将商品服务注册到注册中心

添加依赖

服务注册

添加服务发现支持

测试

将订单服务注册到注册中心

用服务列表名称进行调用

原理

修改代码

测试

注册中心的高可用

原理

两台Eureka互相注册

把各个微服务注册到两台Eureka中

测试

环境说明

jdk1.8

maven3.6.3

mysql8

idea2022

微服务案例的搭建

新建父工程

打开IDEA，File->New ->Project，填写Name（工程名称）和选择Location（工程存储位置），选择Java语言和Maven，点击Create创建maven工程，该工程为所有工程的父工程

官方查看Spring Cloud与Spring Boot的版本匹配问题

Spring Cloud

Spring Boot2.7.x匹配的Spring Cloud的版本为2021.0.x

修改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>org.example</groupId>
    <artifactId>spring-cloud-bk-2023</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.4</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>


    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2021.0.8</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>http://repo.spring.io/libs-snapshot-local</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>http://repo.spring.io/libs-milestone-local</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-releases</id>
            <name>Spring Releases</name>
            <url>http://repo.spring.io/libs-release-local</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>http://repo.spring.io/libs-snapshot-local</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>http://repo.spring.io/libs-milestone-local</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 父工程引入公共的依赖，例如：所有微服务模块均需要用到spring boot，spring boot依赖版本为2.7.12
  • 同时声明spring cloud的依赖。spring cloud依赖版本为2021.0.8，声明依赖后，以后子工程就不需要再指定spring cloud的相关版本了。
  • dependencies标签里配置远程仓库地址

注意：添加依赖后，需要刷新依赖。

微服务模块

父工程创建好之后，接下来就搭建各个微服务模块，这里以product-service(商品服务)和order-service(订单服务)为例。实现用户下订单的功能。

用户下订单业务流程如下：用户通过浏览器下订单，浏览器发起请求到订单服务，订单服务通过调用商品服务得到商品信息。

product-service（商品服务）
创建子工程

创建product-service子模块，右键父工程->New->Module

填写模块名称：product-service，选择Java，Maven，点击创建，如下图：

添加依赖

修改product-service的pom.xml，在</project>的上方添加如下依赖

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
    </dependencies>

刷新依赖

商品模块业务开发

代码结构如下

实体类

package org.example.product.entity;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.math.BigDecimal;

/**
 * 商品实体类
 */
@Data
@Entity
@Table(name="tb_product")
public class Product {
    @Id
    private Long id;
    private String productName;
    private Integer status;
    private BigDecimal price;
    private String productDesc;
    private String caption;
    private Integer inventory;
}

Dao接口

package org.example.product.dao;

import org.example.product.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface ProductDao extends JpaRepository<Product, Long>, JpaSpecificationExecutor<Product> {

}

Service接口

package org.example.product.service;

import org.example.product.entity.Product;

public interface ProductService {
    /**
     * 根据id查询
     */
    Product findById(Long id);

    /**
     * 保存
     */
    void save(Product product);
    /**
     * 更新
     */
    void update(Product product);
    /**
     * 删除
     */
    void delete(Long id);
}

Service接口实现类

package org.example.product.service.impl;

import org.example.product.dao.ProductDao;
import org.example.product.entity.Product;
import org.example.product.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ProductServiceImpl implements ProductService {

    @Autowired
    private ProductDao productDao;

    @Override
    public Product findById(Long id) {
        return productDao.findById(id).get();
    }

    @Override
    public void save(Product product) {
        productDao.save(product);
    }

    @Override
    public void update(Product product) {
        productDao.save(product);
    }

    @Override
    public void delete(Long id) {
        productDao.deleteById(id);
    }
}

Controller类

package org.example.product.controller;

import org.example.product.entity.Product;
import org.example.product.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/product")
public class ProductController {
    @Autowired
    private ProductService productService;

    @Value("${server.port}")
    private String port;

    @Value("${client.ip-address}")
    private String ip;

    @RequestMapping(value = "/{id}",method = RequestMethod.GET)
    public Product findById(@PathVariable Long id) {
        Product product = productService.findById(id);
        product.setProductName("访问的服务地址:"+ip + ":" + port);
        return product;
    }

    @RequestMapping(value = "",method = RequestMethod.POST)
    public String save(@RequestBody Product product) {
        productService.save(product);
        return "保存成功";
    }

}

启动类

package org.example.product;

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

@SpringBootApplication
@EntityScan("org.example.product.entity")
public class ProductApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductApplication.class, args);
    }
}

application.yml配置

server:
  port: 9001
spring:
  application:
    name: service-product
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/shop1?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    username: root
    password: 123
  jpa:
    database: MySQL
    show-sql: true
    open-in-view: true
    generate-ddl: true #自动创建表

client:
  ip-address: 10.111.50.229

注意修改数据库信息，例如url、username、password

创建业务数据库

使用mysql创建数据库：shop1

mysql> create database shop1;

测试

运行启动类：ProductApplication.java

因为application.yml的spring.jpa.generate-ddl 配置为true会自动创建表，启动成功后，刷新数据库能看到tb_product表，表还没有具体数据

手动为tb_product表添加两行测试数据，例如：

浏览器访问

http://localhost:9001/product/1

访问到了数据库的数据 

order-service（订单服务）
创建子工程

子模块：order-service

添加依赖

修改order-service的pom.xml，在</project>的上方添加如下依赖

	<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
    </dependencies>

刷新依赖

订单模块业务开发

代码结构如下：

实体类

package org.example.order.entity;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.math.BigDecimal;

/**
 * 商品实体类
 */
@Data
@Entity
@Table(name="tb_product")
public class Product {
    @Id
    private Long id;
    private String productName;
    private Integer status;
    private BigDecimal price;
    private String productDesc;
    private String caption;
    private Integer inventory;
}

 控制类

package org.example.order.controller;

import org.example.order.entity.Product;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private RestTemplate restTemplate;

    @RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id){
        Product product = null;

        //调用其他微服务，get请求用getXxx post请求用postXxx
        product  = restTemplate.getForObject("http://localhost:9001/product/1", Product.class);


        return product;
    }

}

  启动类

package org.example.order;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EntityScan("org.example.order.entity")
public class OrderApplication {

    /**
     * 使用spring提供的RestTemplate发送http请求到商品服务
     *      1.创建RestTemplate对象交给容器管理
     *      2.在使用的时候,调用其方法完成操作 (getXX,postxxx)
     */
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }


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

  application.yml配置

server:
  port: 9002
spring:
  application:
    name: service-order
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/shop1?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    username: root
    password: 123
  jpa:
    database: MySQL
    show-sql: true
    open-in-view: true
    generate-ddl: true #自动创建表

client:
  ip-address: 10.111.50.229

注意修改数据库信息。

测试

运行启动类：OrderApplication.java

浏览器访问

http://localhost:9002/order/buy/1

 效果如下

和之前直接访问product服务返回一致，说明order服务调用了product服务

http://localhost:9001/product/1

代码总结：

  1. 在order启动类，创建RestTemplate对象交给Spring容器管理
  2. 在order控制类，注入restTemplate对象，在具体方法里调用商品服务：restTemplate.getForObject("http://localhost:9001/product/1", Product.class);

注册中心的使用

这里使用Eureka作为注册中心。

搭建注册中心

创建子工程

在父工程下，创建子工程模块eureka_server

eureka_server代码结构如下

添加依赖

修改eureka_service的pom.xml，在</project>的上方添加如下依赖

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

刷新依赖

注册中心代码开发

启动类

package org.example.eureka;

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

@SpringBootApplication
// 激活eurekaserver
@EnableEurekaServer
public class EurekaServerAppliation {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerAppliation.class, args);
    }
}

application.yml配置文件

spring:
  application:
    name: eureka-server
server:
  port: 9000
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  server:
    enable-self-preservation: false
    eviction-interval-timer-in-ms: 4000

注意：eureka要顶格写，没有缩进。

Eureka配置含义：

register-with-eureka：是否将自己注册到注册中心

fetch-registry：是否从eureka中获取注册信息

service-url：配置暴露给Eureka Client的请求地址

enable-self-preservation：关闭自我保护

eviction-interval-timer-in-ms：剔除服务间隔的时间

测试

运行启动类

浏览器访问

http://localhost:9000/

能看到如下界面，说明eureka注册中心服务搭建成功 

把服务注册到注册中心

把各个微服务注册到注册中心步骤如下：

1.添加EurekaClient依赖

2.服务注册：修改application.yml添加EurekaServer的信息

3.修改启动类，添加服务发现的支持（可选）

将商品服务注册到注册中心

把product-serviceI商品服务注册到Eureka注册中心。

添加依赖

修改product-service的pom.xml，添加如下依赖

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

刷新依赖

服务注册

修改product-service的application.yml添加EurekaServer的信息

eureka:
  client:
    service-url:
      defaultZone: http://localhost:9000/eureka/

添加服务发现支持

添加服务发现支持有3中方式，任意选3种方式其中之一进行操作。

方式1：

在启动类上方添加@EnableEurekaClient

// 激活EurekaClient
@EnableEurekaClient
public class ProductApplication {

方式2：在启动类上方添加@EnableDiscoveryClient

方式3：启动类不用加注解

测试

启动eureka服务和product服务

浏览器访问

http://localhost:9000/

Instances currently registered with Eureka看到了一行SERVICE-PRODUCT相关数据，说明商品服务成功注册到了Eureka注册中心

将订单服务注册到注册中心

与注册到商品服务同样的方式，把order-service（订单服务）注册到eureka中。

用服务列表名称进行调用

原理

之前的调用方式如下，直接把调用的服务地址写在代码（硬编码）里，如果调用的服务地址变化了，相应调用的地方都需要修改，代码耦合度高。

product  = restTemplate.getForObject("http://localhost:9001/product/1", Product.class);

解决代码耦合度高的方法是把所有服务都注册到注册中心，调用时使用的是服务名进行调用，服务名字到注册中心找到（发现）对应的服务地址，然后发起服务调用。

图中服务发现是通过服务名称从Eureka中拿到服务的元数据: 服务的主机名,ip等，只要服务名称不变，服务地址发生变化后只要把最新变化的信息注册到Eureka，就能从Eureka拿到最新的元数据，把元数据中的主机名和ip等信息进行拼接发起服务调用，从而避免服务调用的硬编码问题。

修改代码

修改OrderController.java

使用服务名称到Eureka发现服务实例

// 通过服务名称获取实例，同一个服务名称可能有多个实例
List<ServiceInstance> instances = discoveryClient.getInstances("SERVICE-PRODUCT");

 完整代码如下

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private RestTemplate restTemplate;

    /**
     * 注入DiscoveryClient
     *   springcloud提供的获取原数组的工具类
     *      调用方法获取服务的元数据信息
     */
    @Autowired
    private DiscoveryClient discoveryClient;

    @RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id){
        Product product = null;
        // 通过服务名称获取实例，同一个服务名称可能有多个实例
        List<ServiceInstance> instances = discoveryClient.getInstances("SERVICE-PRODUCT");
        for (ServiceInstance instance : instances) {
            System.out.println(instance);
        }

        //调用其他微服务，get请求用getXxx post请求用postXxx
        product  = restTemplate.getForObject("http://localhost:9001/product/1", Product.class);


        return product;
    }

}

在如下方是添加断点，进行调试。看到instance里面的信息有ipAddr主机信息和port端口信息。

拼接服务主机和端口，进行调用

        //获取对应的服务        
        ServiceInstance instance = instances.get(0);
        //解析得到主机和端口
        String host = instance.getHost();
        int port = instance.getPort();

        //调用其他微服务，拼接服务调用url
        product  = restTemplate.getForObject("http://"+host+":"+port+"/product/1", Product.class);

完整代码如下

package org.example.order.controller;

import org.example.order.entity.Product;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private RestTemplate restTemplate;

    /**
     * 注入DiscoveryClient
     *   springcloud提供的获取原数组的工具类
     *      调用方法获取服务的元数据信息
     */
    @Autowired
    private DiscoveryClient discoveryClient;

    @RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id){
        Product product = null;
        // 通过服务名称(大小写不敏感)获取实例(元数据)，同一个服务名称可能有多个实例
        List<ServiceInstance> instances = discoveryClient.getInstances("service-product");
//        for (ServiceInstance instance : instances) {
//            System.out.println(instance);
//        }
        ServiceInstance instance = instances.get(0);
        String host = instance.getHost();
        int port = instance.getPort();

        //调用其他微服务，get请求用getXxx post请求用postXxx
        product  = restTemplate.getForObject("http://"+host+":"+port+"/product/1", Product.class);
        
        return product;
    }

}
测试

启动eureka服务、product服务、order服务

浏览器访问

http://localhost:9002/order/buy/1

 能访问到数据，效果如下

解决了硬编码服务调用问题。

注册中心的高可用

原理

注册中心只有单节点Eureka服务，如果Eureka发生故障，这时候服务调用也被影响，存在单点故障问题。

注册中心的高可用方案是从1台Eureka变为2台Eureka（或更多），即使其中的一台Eureka出现故障，还有其他的Eureka提供服务，确保注册中心的高可用。

具体实现如下：

  1. 两个Eureka互相注册（通过启动两个Eureka实例得到两个Eureka服务）
  2. 各个微服务注册到两台Eureka中

两台Eureka互相注册

通过启动两个Eureka实例得到两个Eureka服务

  • Eureka1服务的端口为9000
  • Eureka2服务的端口为8000

修改eureka_server的application.yml，修改应用名称，把eureka-server1(9000)向eureka-server2(8000)注册

spring:
  application:
    name: eureka-server1
server:
  port: 9000
# Eureka配置
eureka:
  instance:
    hostname: localhost
  client:
    #配置暴露给Eureka Client的请求地址
    service-url:
      defaultZone: http://127.0.0.1:8000/eureka/
  server:
    #关闭自我保护
    enable-self-preservation: false
    #剔除服务间隔的时间
    eviction-interval-timer-in-ms: 4000

启动eureka-server1服务（9000端口）

这时候发现idea控制台输出如下异常，是正常情况，因为8000的实例还没有启动，等8000启动了就好了。

r-0] c.n.d.s.t.d.RedirectingEurekaHttpClient  : Request execution error. endpoint=DefaultEndpoint{ serviceUrl='http://127.0.0.1:8000/eureka/}, exception=java.net.ConnectException: Connection refused: connect stacktrace=com.sun.jersey.api.client.ClientHandlerException: java.net.ConnectException: Connection refused: connect

修改eureka_server的application.yml，修改端口号，修改应用名称，把eureka-server2(8000)向eureka-server1(9000)注册

spring:
  application:
    name: eureka-server2
server:
  port: 8000
# Eureka配置
eureka:
  instance:
    hostname: localhost
  client:
    #配置暴露给Eureka Client的请求地址
    service-url:
      defaultZone: http://127.0.0.1:9000/eureka/
  server:
    #关闭自我保护
    enable-self-preservation: false
    #剔除服务间隔的时间
    eviction-interval-timer-in-ms: 4000

再启动一个eureka实例（模拟启动，真实环境应该是在不同机器启动）：右键EurakaServerApplication-->Copy Configuration

修改名字

点开Not Started，启动EurekaApplication2

浏览器访问

http://localhost:9000/

http://localhost:8000/

可以看到访问9000，能看到两个实例，访问8000也能看到两个实例。

我们只实例把9000注册到8000，把8000注册到9000，但不管我们访问到哪一个端口，都能看到两个实例，说明两个Eureka之间能进行信息同步。

可以进一步验证这个结论，查看product-service的application.yml，只向9000注册

我们启动product-service，再次查看9000端口和8000端口

只向9000注册SERVICE-PRODUCT服务，发现9000和8000都有SERVICE-PRODUCT

把各个微服务注册到两台Eureka中

既然存在两个Eureka，每个服务可以同时向这两个Eureka去获取，两个地址用逗号隔开

修改order和product的配置文件

eureka:
  client:
    service-url:
      defaultZone: http://localhost:9000/eureka/,http://localhost:8000/eureka/

测试

启动oder服务和product服务

分别查看9000和8000端口，能看到order服务和product服务都注册成功了

在其中一台Eureka模拟故障，例如停止EurekaServerApplication2，看注册中心是否依然正常可用

查看9000端口，order和product服务均正常看到，说明Eureka高可用实现了。

查看9000的日志报异常，因为9000向8000注册，8000端口服务停止了，所以属于正常情况。

Caused by: java.net.ConnectException: Connection refused: connect

 浏览器访问

http://localhost:9002/order/buy/1

 依然能访问到数据，效果如下

完成！enjoy it!

【微服务】springboot对接Prometheus指标监控使用详解
congge
07-07 9686
springboot对接Prometheus指标监控使用详解
【微服务】springboot 多模块打包使用详解
congge
07-25 8542
springboot整合mavem多模块打包详解
微服务教程
01-21
微服务搭建教程，欢迎大家下载。跟着文档一步一步搭建就可以。
微服务系列教程
05-01 264
Spring Boot 2是微服务的基础，在2018年3月初，Spring Boot 正式宣布进入2.0时代。下面一起来步入Spring Boot 2时代，领略Spring Boot 2带来的开发乐趣吧！ 本系统源代码地址： https://github.com/cloudskyme/springboot2 微服务基础之Spring Boot 2： 飞5的Spring Boot2...
微服务hystrix解析部署使用全流程
最新发布
m0_71240584的博客
09-29 1114
是一个做熔断的框架，当程序被高并发访问时可能会造成微服务的宕机，hystrix可以熔断微服务之间通信。防止后台服务发生雪崩。
《微服务零基础入门教程》一步一步，带你走进微服务的世界
2401_84048006的博客
04-02 943
总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！
微服务教程-Dubbo教程、Spring Cloud教程、Nacos教程
qq_32352777的博客
07-16 554
转载请标明出处： https://blog.csdn.net/qq_32352777/article/details/96130705 来自昌杰的攻城狮之路 Dubbo教程 前置篇：Linux下安装java JDK & 部署Zookeeper 前置篇：Linux下安装Tomcat 8.5 讲解篇：Dubbo深度详解，及结合Zookeeper、SSM的RPC实战 ...
微服务教程-使用Spring Cloud
paraller_15的博客
10-27 430
微服务教程-使用Spring Cloud
阿里强推，微服务初步：RESTful API 设计指南
fx20211108的博客
11-15 437
网络应用程序，分为前端和后端两个部分。当前的发展趋势，就是前端设备层出不穷（手机、平板、桌面电脑、其他专用设备......）。 因此，必须有一种统一的机制，方便不同的前端设备与后端进行通信。这导致API构架的流行，甚至出现"API First"的设计思想。RESTful API是目前比较成熟的一套互联网应用程序的API设计理论。我以前写过一篇《理解RESTful架构》，探讨如何理解这个概念。 今天，我将介绍RESTful API的设计细节，探讨如何设计一套合理、好用的API。我的主要参考了两篇文章（1，
微服务架构Spring Cloud 之 Spring Cloud介绍及demo项目初步搭建(一)
12-21
Spring Cloud 并非重新发明轮子，而是整合了诸如 Netflix OSS（Eureka、Ribbon、Hystrix 等）、Zuul、Config Server、Spring Cloud Bus 等现有组件，提供了一套统一的、开箱即用的微服务解决方案。对于中小型互联网...
【系统架构设计师】论文：论微服务架构及其应用（高分论文3篇）
数据知道的博客
09-02 4568
我公司承接某视频会议云直播项目。该项目主要为了解决视频会议系统对用户终端硬件要求过高、入会用户数量受限的问题，通过增加云直播的方式，将云直播与视频会议对接，以支持更多用户在电脑网页和手机端观看会议实况。我在项目中担任技术负责人，负责项目服务划分、架构设计和技术指导工作。本文结合我的亲身实践，论述了微服务架构在项目中的应用。在服务分层设计阶段，以客户需求为依据，对系统功能进行总体分层架构设计，各层各施其职。
微服务入门
qq_44732432的博客
01-12 1643
​ 微服务的架构特征： 微服务的上述特性其实是在给分布式架构制定一个标准，进一步降低服务之间的耦合度，提供服务的独立性和灵活性。做到高内聚，低耦合。 因此，可以认为微服务是一种经过良好架构设计的分布式架构方案 。 但方案该怎么落地？选用什么样的技术栈？全球的互联网公司都在积极尝试自己的微服务落地方案。 其中在Java领域最引人注目的就是SpringCloud提供的方案了。 ​
微服务（项目原理和教程）
小辣鸡富贵的博客
10-05 1211
Spring Cloud组件
[微服务教程]1. 微服务架构概念&面试题
晴天天天蓝
03-31 278
微服务系列教程：教程文集 单体架构到微服务 单体架构 项目初期的一般方案是采取单体架构，把所有功能模块打包到一个jar/war包内，并发布于web容器内运行 集群架构 随着用户量以及流量增加，服务器性能受到瓶颈，此时一般通过集群方式，添加新服务器来分散流量。此举可大幅度提升业务系统的并行处理能力 业务垂直化拆分 集群下如果还是所有业务都放在一个包内运行，对于代码维护扩展是非常困难的，此时需要考虑对业务进行拆分，降低业务耦合度，提升稳定性。如拆分出用户、搜索、订单、支付等业务模块分别管理 服务化(SOA.
【微服务｜初识】一步一步，带你走进微服务的世界
梵高
01-26 3101
微服务，已经成为了互联网行业的最低的门槛，如果不能熟练的掌握微服务，我想无论是升级加薪，还是进大厂，都是很困难的，接下来跟我一起学习微服务，一步一步的大好坚实的基础，为美好的未来做铺垫。......
SpringCloud微服务搭建教程
五道口
02-23 945
SpringCloud是什么？ SpringCloud是分布式一站式的解决方案。 SpringCloud是微服务技术的一种落地的体现和实现。 SpringCloud和SpringBoot的区别和关系？ 1.SpringBoot专注于快速方便的开发单个个体微服务。 2.SpringCloud是关注全局的微服务协调整理治理框架以及一整套的落地解决方案，它将SpringBoot开发的一个个单体微服务整合...
微服务从入门到精通【入门篇一】
weixin_43121638的博客
12-03 1833
前言 博主是一名97年的程序员，在职场上摸爬滚打了一年。从毕业至今，生活可以说是五味杂陈。这篇文章是我的第一篇文章，后面会持续更新，希望看完这篇文章的读者能有自己的感悟和收获。本篇文章主要带大家熟悉微服务以及学会应用springcloud的注册中心和负载均衡。 1.了解微服务 1.1什么是微服务？ 微服务从字面上解释就是微小的服务，在业界其实并没有给出微服务标准的定义，不过我们可以从俩个维度去理解微服务： .
微服务快速入门
小小先生的博客
06-09 180
认识微服务 贴几个链接： Sring Cloud中文网 Spring Cloud 英文教程 微服务来源 这里推荐一本书：Spring Cloud微服务实战。版本有点老了，但是里面干货不少，对于入门帮助极大。 具体介绍就不多打字了，直接贴教程吧。 服务提供方 顾名思义，提供服务的。 构建一个SpringBoot项目，就做一个最简单的查找。和普通Spring Boot项目没什么区别。 项目结构： 数据库： pom.xml： <?xml version="1.0" enc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值