Rest微服务工程构建

最新推荐文章于 2024-04-02 19:08:23 发布
最新推荐文章于 2024-04-02 19:08:23 发布
阅读量172 收藏 1
点赞数
分类专栏： springcloud学习 文章标签： spring boot java spring mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44732146/article/details/118445937
版权

首先创建微服务提供者模块cloud-provider-payment8001
打开cloud2020项目创建maven项目cloud-provider-payment8001

在这里插入图片描述
然后

在这里插入图片描述
修改pom文件

        <!--包含了sleuth+zipkin(后面用)-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
        <!--        eureka-client客户端（后面有）-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</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-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>
        <!--mysql-connector-java-->
        <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>

在resources目录下面新建配置文件application.yml
在这里插入图片描述
把下面的配置粘贴进去

 
server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource   # 当前数据源操作类型
    driver-class-name: com.mysql.cj.jdbc.Driver    # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/springcloud2020?useUnicode=true&characterEncoding=utf-8&useSSL=NO&serverTimezone=Asia/Shanghai
    username: root
    password: 123456


mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.zhubayi.springcloud.entities    # 所有Entity别名类所在包

添加启动类PaymentMain8001

package com.zhubayi.springcloud;

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

/**
 * @author zhubayi
 */
@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
public class PaymentMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8001.class,args);
    }
}

在这里插入图片描述
创建数据库，和数据表
打开SQLyog，新建数据springcloud2020
在这里插入图片描述
进入springcloud2020数据库，再创建表
在这里插入图片描述

若没有SQLyog这个软件，使用下面的sql语句创建表

/*
SQLyog Ultimate v13.1.1 (64 bit)
MySQL - 8.0.25 : Database - springcloud2020
*********************************************************************
*/

/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`springcloud2020` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;

USE `springcloud2020`;

/*Table structure for table `payment` */

DROP TABLE IF EXISTS `payment`;

CREATE TABLE `payment` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `serial` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

/*Data for the table `payment` */

insert  into `payment`(`id`,`serial`) values 
(1,'测试'),
(2,'哈哈哈'),
(3,'嘿嘿嘿'),
(5,'java se'),
(6,'ssds');

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

然后创建实体类Payment

package com.zhubayi.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @author zhubayi
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {
    private Long id;
    private String serial;
}

注意实体类的属性最好与数据的字段保持一致

还有统一的结果返回类CommonResult

package com.zhubayi.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author zhubayi
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class CommonResult<T> {
    private Integer code;
    private String message;
    private T data;
    public CommonResult(Integer code,String message){
        this(code,message,null);
    }
}

创建持久层dao,在它下面创建接口PaymentDao

package com.zhubayi.springcloud.dao;

import com.zhubayi.springcloud.entities.Payment;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * @author zhubayi
 */
@Mapper
public interface PaymentDao {
    /**
     * 创建
     * @param payment
     * @return
     */
    int create(Payment payment);

    Payment getPaymentById(@Param("id") Long id);

    List<Payment> findAll();
}

然后在resoures下面创建mapper目录，在mapper目录下创建PaymentDao.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.zhubayi.springcloud.dao.PaymentDao">

    <!--  插入  -->
    <insert id="create" parameterType="com.zhubayi.springcloud.entities.Payment" useGeneratedKeys="true" keyProperty="id">
        insert into payment(serial) values (#{serial})
    </insert>
    <!--       根据id查询-->
    <select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap">
        select * from `payment` where id=#{id}
    </select>
    <!--    查所有-->
    <select id="findAll" resultType="com.zhubayi.springcloud.entities.Payment">
        select * from `payment`
    </select>
    <resultMap id="BaseResultMap" type="com.zhubayi.springcloud.entities.Payment">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <result column="serial" property="serial" jdbcType="VARCHAR"/>
    </resultMap>
</mapper>

再创建service业务层，在service下面创建接口PaymentService

package com.zhubayi.springcloud.service;

import com.zhubayi.springcloud.entities.Payment;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * @author zhubayi
 */
public interface PaymentService {
    int create(Payment payment);

    Payment getPaymentById(Long id);

    List<Payment> findAll();
}

再创建实现类PaymentServiceImpl

package com.zhubayi.springcloud.service.impl;

import com.zhubayi.springcloud.dao.PaymentDao;
import com.zhubayi.springcloud.entities.Payment;
import com.zhubayi.springcloud.service.PaymentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author zhubayi
 */
@Service
public class PaymentServiceImpl implements PaymentService {
    @Autowired
    private PaymentDao paymentDao;
    @Override
    public int create(Payment payment) {
        return paymentDao.create(payment);
    }

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

    @Override
    public List<Payment> findAll() {
        return paymentDao.findAll();
    }
}

最后创建controller层，在controller下面创建PaymentController

package com.zhubayi.springcloud.controller;

import com.zhubayi.springcloud.entities.CommonResult;
import com.zhubayi.springcloud.entities.Payment;
import com.zhubayi.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
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 java.util.List;

/**
 * @author zhubayi
 */
@Slf4j
@RestController
@RequestMapping("payment")
public class PaymentController {
    @Autowired
    private PaymentService paymentService;
    @Value("${server.port}")
    private String serverPort;
    @Autowired
    private DiscoveryClient discoveryClient;
    @GetMapping("list")
    public CommonResult list(){
        CommonResult<List<Payment>> commonResult = new CommonResult<>();
        commonResult.setCode(200);
        commonResult.setMessage("success"+serverPort);
        commonResult.setData(paymentService.findAll());
        return commonResult;
    }
    @PostMapping("create")
    public CommonResult create(@RequestBody Payment payment){
        int res = paymentService.create(payment);
        log.info("***插入结果***{}",res);
        if(res>0){
           return   new CommonResult(200,"插入成功,端口:"+serverPort);
        }
        return   new CommonResult(444,"插入失败");
    }
    @GetMapping("get/{id}")
    public CommonResult get(@PathVariable("id") Long id){
        Payment payment= paymentService.getPaymentById(id);
        if(payment!=null){
            return   new CommonResult(200,"查询成功，端口:"+serverPort,payment);
        }
        return   new CommonResult(444,"查询失败,端口："+serverPort);
    }
 }

以上都完成的目录样子
在这里插入图片描述
进行测试:
测试根据id查询: http://localhost:8001/payment/get/3
在这里插入图片描述
查询所有:
http://localhost:8001/payment/list
在这里插入图片描述
测试创建：
打开Postman,新建请求，发送请求
地址http://127.0.0.1:8001/payment/create
在这里插入图片描述
在这里插入图片描述
添加成功!
主要步骤可概括为:

  1. 建module
  2. 改POM文件
  3. 修改application.yml配置文件
  4. 新建主启动
  5. 添加业务类

创建微服务提供者模块cloud-consumer-order80

点击右键new Module,选择maven项目

在这里插入图片描述
修改pom文件,添加下面的依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <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>

在resources下面新建配置文件application.yml文件

server:
  port: 80

添加主启动类OrderMain80

package com.zhubayi.springcloud;

import com.zhubayi.myrule.MySelfRule;
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;

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

添加实体类Payment

package com.zhubayi.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @author zhubayi
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {
    private Long id;
    private String serial;
}

统一返回类CommonResult

package com.zhubayi.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author zhubayi
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class CommonResult<T> {
    private Integer code;
    private String message;
    private T data;
    public CommonResult(Integer code,String message){
        this(code,message,null);
    }
}

在项目中注入RestTemplate交给Spring容器管理
RestTemplate提供了多种便捷访问远程Http服务的方法，
是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集

新建配置包config,在它下面新建ApplicationContextConfig配置类

package com.zhubayi.springcloud.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

/**
 * @author zhubayi
 */
@Configuration
public class ApplicationContextConfig {
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

新建controller包,在它下面创建OrderController类

package com.zhubayi.springcloud.controller;

import com.zhubayi.springcloud.entities.CommonResult;
import com.zhubayi.springcloud.entities.Payment;
import com.zhubayi.springcloud.lb.MyLoadBalancer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.net.URI;
import java.util.List;

/**
 * @author zhubayi
 */

@RestController
@RequestMapping("/consumer/order")
public class OrderController {
  	public static final String PaymentSrv_URL = "http://localhost:8001";
    @Autowired
    private RestTemplate restTemplate;
   
    @GetMapping("create")
    public CommonResult create(Payment payment){
      return   restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);
    }
 	@GetMapping("/get/{id}")
    public CommonResult get(@PathVariable("id")Long id){
        return   restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
    }
  }

完整的目录结构:圈起来的部分，其他的是后面的相关
在这里插入图片描述

启动OrderMain80进行测试:
http://localhost/consumer/order/get/1
在这里插入图片描述
测试添加http://localhost/consumer/order/create?serial=aaaaa1
在这里插入图片描述

由于cloud-consumer-order80模块和cloud-provider-payment8001有重复部分Payment和CommonResult,
我们可以抽取一个公共模块cloud-api-commons,让cloud-consumer-order80模块和cloud-provider-payment8001都依赖它即可

新建cloud-api-commons模块
在这里插入图片描述
创建类Payment和CommonResult
Payment类

package com.zhubayi.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @author zhubayi
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {
    private Long id;
    private String serial;
}

CommonResult类

package com.zhubayi.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author zhubayi
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class CommonResult<T> {
    private Integer code;
    private String message;
    private T data;
    public CommonResult(Integer code,String message){
        this(code,message,null);
    }
}

在cloud-consumer-order80模块和cloud-provider-payment8001的pom文件添加上:

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

完整的项目目录:
项目目录

胡八一、
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
创建REST服务
jhlyh的博客
08-02 328
创建REST服务
REST简介
weixin_30361753的博客
07-23 3500
　　一说到REST，我想大家的第一反应就是“啊，就是那种前后台通信方式。”但是在要求详细讲述它所提出的各个约束，以及如何开始搭建REST服务时，却很少有人能够清晰地说出它到底是什么，需要遵守什么样的准则。 　　在您将看到的这一篇文章中，我们将对REST，尤其是基于HTTP的REST服务进行详细地介绍。通过这些文章，您不仅可以了解到什么是REST，更能清晰地了解到您在编写REST服务时所...
七、构建 RESTful 服务
走在bug的路上
08-05 1227
● REST 简介 ● JPA 实现 REST ● MongoDB 实现 REST
分布式系统核心：REST风格架构实战：基于Java实现REST API
最新发布
2401_83384536的博客
04-02 856
本节，将基于市面上最为流行的3款Java框架——Jersey、ApacheCXF、Spring Web MVC——来分别演示如何实现REST API。
二、REST风格微服务架构搭建
hnkd16的专栏
08-08 1396
使用SpringBoot、SpringCloud、Mybatis创建一个简单CURD的Rest风格微服务架构。 源码：https://github.com/hnyydp/microservice 项目代码结构： 1、父工程建立 首先建立一个父项目microservice，用来统一管理项目依赖版本，注意创建的是maven pom项目。 pom.xml &lt;properties&g...
rest 简单服务搭建---jersey（使用IDEA
xiao/du的博客
09-11 1703
0. 创建新项目 　　在IntelliJ中创建新项目，选择Java Enterprise -&gt; RESTful Web Service -&gt; Setup libery later. 1. 加入web框架和maven框架 　　右键单击项目名-&gt; Add Frameworks Support，分别勾选Web Application和Maven。 3. 在maven中加...
NetflixConductor:一个微服务的编排器
02-20
Netflix内容平台工程团队运行由微服务上执行的任务的异步编排驱动的多个业务流程。其中一些是长期运行的流程，跨越几天。这些流程在准备好标题流式传输给全球的观众上发挥关键作用。这些流程的几个实例是：用于内容...
PortafolioWeb:最终职业项目。 具有Node.js和REST API和MySQL DB的具有微服务架构的网站
04-07
该网站采用微服务架构构建，但具有单个MySQL数据库（注意：服务使用Sequelize ORM来更流畅地处理数据）。 微服务使用HTTP REST样式请求进行通信。 我的Github中有5个不同的项目，它们以字符串“ PortafolioWeb”...
SpringBootRESTfulAPI脚手架
08-07
这是一个基于SpringBoot 2.1.1 RELEASE，用于搭建RESTful API工程的脚手架，只需三分钟你就可以开始编写业务代码，不再烦恼于构建项目与风格统一。
构建基于rest的Web服务
ZZY1078689276的专栏
01-05 2175
构建的rest的Web服务所要实现的功能 构建rest的Web服务器 构建rest的Web服务器需要准备的前提条件 构建Maven格式的rest的Web服务 构建Maven格式的rest的Web服务器基础框架 添加java代码 创建一个资源controller 使应用程序成为可执行文件 构建一个可执行JAR 测试服务 构建的rest的Web服务所要实现的功能   构建一个接受H
rest微服务案例
wyyblog
08-14 1059
1、搭建环境 IDEA + SpringBoot + SpringCloud 2、整体结构 3、搭建步骤 3.1创建主工程 microservicecloud 3.1.1 pom.xml文件配置 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apach...
微服务基础实践一:基于rest实现服务之间的调用
渣男的博客
03-30 1359
一：概念 所谓的微服务，就是把以前单体的一个应用根据数据库或者业务等等进行拆分，实现解耦，同时也为以后的服务应用升级提供可控性。通俗一点，就是应用加功能更快并且性能也更好，最重要的是，不会影响到别的服务，比如说你的系统把用户管理单独弄成了一个微服务，那么有一天你的需求变更了，要给用户增加一个点赞功能，按照旧的做法，需要重新部署应用，但是如果你的系统采用的是微服务的架构，这个时候就不需要停掉整个系...
Spring Boot 之 构建RESTful服务
探索er的博客
04-21 1997
构建RESTful服务
SpringMVC项目Rest风格
时代各有不同，青春一脉相承。
11-06 383
REST（Representational State Transfer），表现形式状态转换,它是一种软件架构风格。传统方式一般是一个请求url对应一种操作，这样做不仅麻烦，也不安全，因为会程序的人读取了你的请求url地址，就大概知道该url实现的是一个什么样的操作。查看REST风格的描述，你会发现请求地址变的简单了，并且光看请求URL并不是很能猜出来该URL的具体功能，所以REST的优点有:隐藏资源的访问行为，无法通过地址得知对资源是何种操作，书写简化。但是我们的问题也随之而来了，一个相同的url地址即可
微服务之Rest构建分布式微服务&服务调用Rest和Dubbo（集群版Eureka Server服务注册中心
狗凡的博客
10-23 741
Spring Cloud： 在SpringBoot基础上提供了一套微服务的解决方案，包括注册、发现、配置中心服务网关、负载均衡、熔断器，是一系列框架的集合，利用springBoot 的开发便利性巧妙的便利简化了分布式开发。比如发现注册、配置总线 ； 在Spring Cloud微服务的实际项目开发中，多个微服务之间不仅是相对独立的，而且也是相对关联的；也就是说，微服务之间需要相互访问，多个微服务...
5秒钟搭建一个简单版的restful资源服务器
weixin_34246551的博客
07-10 225
利用Mins可以在五秒钟内(不包括下载文件时间....)搭建一个简单的restful资源服务器。 准备 首先安装Mins： brew tap chenhg5/tap && brew install mins 复制代码由于我在mac系统下，所以使用brew安装。对应系统可以下载对应二进制执行文件，下载链接为：https://github.com/chenhg5/mins/releas...
八：对微服务通讯方式RPC vs REST的理解
热门推荐
Oscar Chen
07-30 1万+
微服务的服务都是独立进程，服务之间的通讯的效率、稳定性等等关乎着系统是否能高效、稳定运行。常见的通讯方式有RPC及REST，从以下几个方面去理解微服务的服务通讯方式以及选择： 2. 关于RPC 1.1 什么是RPC 1.2 RPC有什么用 1.3 RPC的框架有哪些 3. 什么是REST 4. 两者有什么区别 5. 微服务通讯该如何选择 *补充了一些对于dubbo的体会*
springboot(2) rest项目起飞
qq_33540325的博客
07-12 355
上篇文章已经成功搭建了一个springboot项目，但是还没看到结果，本篇将继续在上篇基础上添加部分示例，下面开始起飞。 1.项目结构，我在demo目录下，新增两个包，一个放实体，一个放controller，如图 2.在controller包下，新建FirstController文件，并新增方法 @RestController @RequestMapping("/first") public
微服务怎么用REST通信
06-13
REST是一种基于HTTP协议的通信协议，它通过HTTP的GET、POST、PUT、DELETE等方法来实现对服务端资源的操作。在微服务架构中，每个服务都可以暴露自己的RESTful API，其他服务可以通过HTTP请求来调用该服务的API，从而...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值