SpringCloud系列：4. 完成Rest搭建服务提供者和消费者

已于 2022-06-11 10:32:58 修改
阅读量206 收藏
点赞数
分类专栏： Springcloud 文章标签： rest 微服务架构 分布式 restful spring
于 2021-07-14 15:32:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llzz_zzll/article/details/118727217
版权

前言

  1. Rest环境搭建
    1.1 Rest-Springcloud版本说明
    1.2 SpringCloud-Rest环境搭建(服务提供者)
    1.3 ## SpringCloud-Rest环境搭建(服务消费者)

前言

本文主要讲解SpringCloud实现’Rest环境搭建’(服务提供最和服务消费者)。并实现’服务消费者’正常访问’服务提供者’的具体服务。

1. Rest环境搭建

1.1 Rest-Springcloud版本说明

  1. SpringCloud版本选择-“图-spingcloud版本-1”
  2. SpringBoot实际开发的版本-“图-spingcloud版本-1”

在这里插入图片描述
图-spingcloud版本-1
在这里插入图片描述
图-spingcloud版本-2

1.2 SpringCloud-Rest环境搭建(服务提供者)

① 创建SpringCloud项目，演示如下
⑴ 第一步：首先创建一个父工程：来存放接下去要创建的一个个子工程项目。
IDEA打开-->Create Project -->左边：Maven-->
- groupid:com.lzk
- Aritifactid:springcloud
- version:1.0-SNAPSHOT
-->之后直接点击Next，之后选择对应的存放路径-->Finish。
⑵ 第二步：上面第一步创建的是一个父工程，它要代表一个总的。
- 删掉上面创建的父工程的"src"
- 在父工程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>com.lzk</groupId>
    <artifactId>springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 修改父工程项目的打包方式为： pom-->
    <packaging>pom</packaging>
    <!-- 总版本号管理：
    1. 将下面在<dependencyManagement>这个标签导入
    依赖的版本提到这个<properties>标签里面。
    2. 以后需要修改下面依赖的版本，直接在这个<properties>
    标签里面修改即可,当要修改某依赖的版本时，不用特意去下对应的依赖！
    -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler>1.8</maven.compiler>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
    </properties>


    <!--这是一个父工程项目，因此在此项目的pom.xml中
    需要使用<dependencyManagement>这个标签
    来实现对所有导入的进来的依赖jar包进行依赖管理
    -->
    <dependencyManagement>
        <dependencies>
            <!-- 这是springcloud的依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- 由于springcloud是依赖于springboot，因此这里还要导入springboot依赖 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.1.4.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--数据库依赖-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <!--Druid 数据库连接池组件-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.10</version>
            </dependency>
            <!--Springboot的启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.2</version>
            </dependency>
            <!--
            ${lombok.version},${junit.version},
            ${log4j.version}等等
            表示此依赖的版本号从上面的<properties>
            标签里面来设置。
            -->
            <!--log4j单元测试-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!--主要用于日志测试相关的依赖-->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>

            <!--Lombok -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <!--Log4j-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!--用来配置打包的插件的，不一定每个pom.xml都要配-->
    <build></build>
</project>


-------------子项目模块springcloud-api 开发----------------


⑶ 第三步：创建子工程项目(springcloud-api子模块)
-1 File-->New-->Project-->Maven-->输入子工程项目名-->Next
-->springcloud-api模块-->finish。

-2 创建完成，可以看出这个子项目模块：
springcloud-api 的pom.xml的<parent>父依赖是刚才我们创建的
那个父工程项目，而父工程项目通过<dependencyManagement>标签来实
现管理我们导入的依赖。

-3 但是注意我们在父工程项目中只是对导入的依赖进行管理
<dependencyManagement>标签，如果在子项目模块中需要用
到父工程项目中的某一个依赖，需要到子项目工程模块中去
导入使用需要的依赖，以此来去父项目工程中得到刚才导入
的依赖。
-->比如子项目模块的pom.xml需要lombok，直接在pom.xml中输入
依赖来导入使用lombok依赖：
<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>


⑷ 第四步：到数据库创建springcloud-api子模块对应的数据库"DB01",以及"DB01"下面对应的表。
- 到Mysql中手动创建DB01数据库,然后使用IDEA中连接DB01，在IDEA中创建对应的表，
并在IDEA中输入Sql语句，实现数据插入，相同语句创建5条数据：
insert into dept (dname,db_source) values ('开发部',DATABASE());
---> 这里的db_source字段表示：当前表对应的数据库名。

⑸ 第五步：springcloud-api子模块中创建实体类
- 在java下创建com.lzk.springcloud下创建"pojo"包
- "pojo"包下创建实体类"Dept"，且所有实体类实现序列化接口
(实体类若没有实现序列化接口，在通讯传输中就会报一个错误。)
- 实体类如下所示↓：

package com.lzk.springcloud.pojo;

/**
 * Created by Linzk on 2020/12
 * <p>
 * 部门表(实体类需要实现序列化)
 * -->实现序列化，避免数据传输出现错误。
 *
 *  1. @Accessors(chain = true) : 此注解为true表示支持"链式写   
 *  法"
 *  1.1 什么是链式写法呢？
 *  1.2 因为之前创建一个对象并赋值步骤为如下所示↓：
 *  Dept dept = new Dept();
 *  dept.setDeptNo(10);
 *  dept.setDname("a1");
 *
 * 1.3 现在开启支持链式写法在创建对象并赋值可以采用"链式写法"来实现赋值，
 * 如下所示↓：
 * Dept dept = new Dept();
 * dept.setDeptNo(10)setDname("a1"); -->像这样"链式写法"赋值
 *
 */
@Data
@NoArgsConstructor
@Accessors(chain = true)
public class Dept implements Serializable {
    /**
     * 主键
     */
    private Long deptno;

    private String dname;

    /**
     * 1.这个字段表示：
     *      -->该表对应的数据存于哪个数据库中。
     * 1.1 因为"微服务架构"是一个服务对应一个数据库
     *     -->在存数据时，可能会存在：同一个数据信息
     * 被存储到不同的数据库中，所以就创建此字段来区别数据
     * 存储的位置。
     *
     */
    private String db_source;

    /**
     * 构造器
     */
    public Dept(String dname) {
        this.dname = dname;
    }
}

↑ 此时子项目模块springcloud-api就只管负责pojo实体类的事情，
---->这个子模块的功能就写完了。



----------------------------------------------------



⑹ 第六步：接下去创建另一个子项目模块"服务的提供者模块"
(springcloud-provider-dept-8001)
▲：我们需要在这个子模块下完成编写：Dao接口 + 
mapper.xml配置文件(用Mybatis就需要创建一个这个配置文件) + 
Service接口 + ServiceImpl实现类 + Controller提供访问接口 + 
创建项目的主启动类。
↓↓↓↓↓↓
↓↓↓
↓(具体配置步骤如下)

-1. 由于我们后面会创建多个服务的提供者，因此可以在子项目模块的名
字后面，添加上对应提供者模块的端口号8001

-2. 首先在pom.xml中导入(springcloud-provider-dept-8001)需要的依赖
*** 注意 ***：注意我们在子项目模块中对于需要导入的依赖如果已经在
父项目模块中已经被<dependencyManagement>这个标签下管理和引入了，
就可以不用写对应依赖的版本号，子模块会自动继承父项目模块中的版本号。

-3. (springcloud-provider-dept-8001)子模块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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.lzk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-provider-dept-8001</artifactId>


    <dependencies>
        <!--
        首先：我们需要拿到实体类,所以需要将存放实
        体类的子模块依赖引入,这就叫服务拆分。
        -->
        <dependency>
            <groupId>com.lzk</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--其次：测试类junit依赖引入
        由于junit的依赖在父工程项目中已被管理，因此我们
        在此模块中引入junit依赖，不用写版本号，自动继承父工程项目
        里面junit的版本号
        -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!--数据库的连接依赖，同时这里版本号也不用写，
        该依赖也已经在父项目工程中被管理，这里自动继承父项目工程
        的版本号-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--数据库连接池相关依赖依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <!--日志相关-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--Springboot的test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <!--springboot web的启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jetty:可以使用jetty作为应用服务器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <!--热部署工具:代码修改自动更新代码，不用重启项目-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
</project>


⑺ 第七步：在(springcloud-provider-dept-8001)子模块中，编写
配置文件application.yml的配置 及 mybatis的.xml配置文件配置(mybatis-config.xml)
-1 配置文件application.yml的配置
server:
  port: 8001

# mybatis配置
mybatis:
  # 配置Mybatis读取实体类路径配置
  type-aliases-package: com.lzk.springcloud.pojo
  # mybatis核心配置文件所在路径
  config-location: classpath:mybatis/mybatis-config.xml
  # mybatis的mapper配置所在路径
  mapper-locations: classpath:mybatis/mapper/*.xml


# Spring的配置
spring:
  application:
    # spring服务提供者项目的名字
    name: springcloud-provider-dept
  # spring数据源
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://127.0.0.1:3306/db01?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    username: xxx
    password: xxx
    

-2 mybatis的.xml配置文件配置(mybatis-config.xml)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

</configuration>

-3 之后在(springcloud-provider-dept-8001)子模块中，编写接口
- com.lzk.springcloud.dao层接口编写
package com.lzk.springcloud.dao;

/**
 *  1. @Mapper注解：声明这是一个mapper接口，
 *  能够被Mybatis的配置文件mapper.xml扫描到，执行mapper.xml里面
 *  的Sql语句来操作数据库
 *
 *  2. @Repository注解：将此接口注入到Spring容器中
 *  -->接口注入容器中，bean
 *
 */
@Mapper
@Repository
public interface DeptDao {
    public boolean addDept(Dept dept);
    public Dept queryById(Long id);
    public List<Dept> queryAll();
}

-4 使用Mybatis实现持久层操作，就需要编写mapper.xml配置文件
在里面写入Sql语句
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--Mybatis配置文件中，配置mapper绑定操作数据库的接口所在路径-->
<mapper namespace="com.lzk.springcloud.dao.DeptDao">
    <!--添加的SQL语句-->
    <insert id="addDept" parameterType="Dept">
        insert into dept(dname,db_source)
        values (@{dname},DATABASE())
    </insert>
    <!--查询单条数据的SQL语句-->
    <select id="queryById" resultType="Dept" parameterType="Long">
        select * from dept where deptno = #{deptno};
    </select>
    <!--添加所有数据的SQL语句-->
    <select id="queryAll" resultType="Dept">
        select * from dept;
    </select>
</mapper>

-5 继续在(springcloud-provider-dept-8001)子模块中，编写Service层
(创建service包-->DeptService接口 + DeptServiceImpl实现类)

/**
 * -->这个接口类似Dept里面的一个服务
 */
public interface DeptService {
    public boolean addDept(Dept dept);
    public Dept queryById(Long id);
    public List<Dept> queryAll();
}

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptDao deptDao;

    @Override
    public boolean addDept(Dept dept) {
        return deptDao.addDept(dept);
    }

    @Override
    public Dept queryById(Long id) {
        return deptDao.queryById(id);
    }

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }
}

-5 在(springcloud-provider-dept-8001)子模块中，编写Controller
提供访问接口
package com.lzk.springcloud.controller;


/**
 * -->这个Controller类就是用来提供restful服务的
 */
@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept) {
        return deptService.addDept(dept);
    }

    @GetMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        return deptService.queryById(id);
    }

    @GetMapping("/dept/list")
    public List<Dept> queryAll() {
        return deptService.queryAll();
    }

}

-6 在(springcloud-provider-dept-8001)子模块中，创建项目的主启动类
@SpringBootApplication
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

⑻ 第八步：最后测试
- 启动Main()启动类-->
- 访问网页测试：http://localhost:8001/dept/get/1
- 如图所示"图test1"


-----------------------------------------------------


② 以上就是对创建一个服务提供者的项目(springcloud-provider-dept-8001)以及
springcloud-api的实体类创建。
⑴ 对于上面子项目模块中springcloud-provider-dept-8001中主要提供的服务是↓
- 增加部门
- id查询部门
- 查询全部部门
--->上面这三个服务。

1.3 ## SpringCloud-Rest环境搭建(服务消费者)

① 由于上面"## SpringCloud-Rest环境搭建(服务提供者)"中已经创建
了两个子项目模块"(springcloud-provider-dept-8001)和
(springcloud-api)"-->接下去就要创建服务消费者子模块。

② 接下去在"## SpringCloud-Rest环境搭建(服务提供者)"基础上，在
创建一个子模块作为"服务消费者"模块,此模块端口号设置为80端口，网
站默认端口是80端口，只要设置为80端口，你写请求的话就不需要带上端
口号。
⑴ 第一步：创建子项目模块(springcloud-consumer-dept-80)
- 并在springcloud-consumer-dept-80子模块pom.xml中导入依赖
(消费者模块与前端打交道的，不需要去连接数据库，因此只需要一些实体类和web依赖)
<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.lzk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-dept-80</artifactId>
    <!--实体类+web-->
    <dependencies>
        <dependency>
            <groupId>com.lzk</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--热部署工具:代码修改自动更新代码，不用重启项目-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
</project>

⑵ 第二步：实现子项目模块(springcloud-consumer-dept-80)的配置文件配置
- 对于消费者模块，只需要配置一个端口号即可
server:
  port: 80
  

⑶ 第三步：子项目模块(springcloud-consumer-dept-80)创建controller

/**
 *  --->此消费者模块，不应该有service层
 *  1. 任何东西在springboot都有一个对应的xxxxTemplate的模板
 *  这个xxxxTemplate的模板，就是有对应的请求，我们直接调用模板
 *  里面的方法即可。
 *  1.1 我们要使用这个xxxxTemplate的模板，就需要将其注册到
 *  Spring中,我们可以自己创建一个配置类，将RestTemplate可以获
 *  取到服务请求的这个模板类，注入的SPring容器中，
 *
 *  1.2 将RestTemplate模板注入到Spring后，我们就可以使用它来实
 *  现请求服务获取
 *
 */
@RestController
public class DeptConsumerController {

    /**
     * 为了获取对应的服务，我们注入RestTemplate模板来实现，服务
     * 请求获取
     * 1. RestTemplate有三个参数
     *  (String url,请求的实体使用Map来存放, Class<T> 
     * responseType>
     * 2. 我们现在这个"消费者模块"没有service层，但是我们要去调
     * 用远程的服务
     *  -->我们要去远程的服务获取"部门表"的信息，就需要
     * 到"http://localhost:8001/dept/list"
     *  这样一个地址拿，我们就需要在消费者这里
     * 将"http://localhost:8001/dept/list"这
     *  个地址获取到
     *
     *  2.1 "http://localhost:8001/dept/list" 这个前缀
     * http://localhost:8001/是固定的,因此我们可以将这个固定
     * 的前缀写成一个常量
     *
     *  3. 方法请求返回值：return 里面传入的参数有两个：URL请
     * 求的地址 + 响应的参数类型
     *
     *
     *  4. RestTemplate ==>就是提供多种便捷访问远程http服务的
     * 方法。是一种简单的restful服务模板，是spring提供的一种模
     * 板集即：你想要去远程拿东西 == 什么方式拿 + 去哪个地方拿 
     * + 拿什么东西
     *
     */
    @Autowired
    private RestTemplate restTemplate;

    private static final String REST_URL_PREFIX = "http://localhost:8001/";


    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept) {
        /**
         * 1. postForObject() ==>表示是Post请求
         * 2. dept ==>表示传进来的参数拼接到请求路径URL中去的
         * 值
         * 3. boolean ==> 表示返回值的类型
         */
        return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add",dept,boolean.class);

    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        /**
         * 1. getForObject() ==>表示是Get请求
         * 2. id ==>表示传进来的参数拼接到请求路径URL中去的值
         * 3. 括号参数后面的Dept.class ==》是方法的返回值类型
         */
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id,Dept.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list() {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list",List.class);
    }
}


⑷ 第四步：由于我们消费者需要获取服务，而springboot对任何东西都
提供一个xxxxTemplate的模板，我们需要请求某个东西直接调用
xxxxTemplate的模板即可。
- 因此我们可以创建一个"xxxxTemplate的模板"的bean，将其注入到
spring中并实现调用xxxxTemplate的模板来发起请求，完成服务的请求
获取。

/**
 *  1. 回顾一下
 *  我们在类上添加@Configuration注解，就相当于
 *  将这个类作为Spring里面的"applicationContext.xml配置类"
 *  在这个配置类里面配置bean
 *
 *
 */
@Configuration
public class ConfigBean {
    
    /**
     * 想要获取哪一个bean，创建方法的时候返回想要的那个bean即可
     * -->这样就将RestTemplate这个bean注册到我们Spring里面，
     * 此时我们就可以用它了。
     *
     */
    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

⑸ 第五步：创建一个启动类DeptConsumer_80,测试来获取远程服务
-1 先启动"服务提供者"8001的子项目模块启动类，并检查访问(里面的三个服务)是否可以正常的访问。
-->测试访问是否成功：http://localhost:8001/dept/get/1
8001端口"服务提供者"测试，如图所示-"图provider-1"。

-2 在启动"服务消费者"80的子项目模块启动类，测试远程获取服务是否成功
--> http://localhost/consumer/dept/get/1
80端口"服务消费者"测试，如图所示-"图consumer-1"(由于网页默认是
80端口因此我们访问网站的时候，可以不用带上80端口)。


-------------------------------------------------------


③ 至此，我们服务的"提供者和消费者"的增删改就搭建完成了。
⑴ 服务的消费者"DeptConsumerController"-->这是一个非常核心的东西。
- 这也是我们RestFule，Http基于RPC的一个本质的区别
⑵ 对于使用SpringBoot(Dubbo+Zookeeepr)搭建"服务提供者和服务消费者"的项目中：
- 第一点：需要他们有共同的接口。
- 第二点：我们消费者是从远程@Reference去引用的。
⑶ 现在我们使用SpringCloud搭建"服务提供者和服务消费者"的项目中：
- 第一点：只需要知道远程的一个URL地址就可以了。知道那个地址，我
们可以从地址入手去发送请求就好了。

在这里插入图片描述
图provider-1

在这里插入图片描述

图consumer-1

源远流长ღ
关注
专栏目录
Spring Cloud Rest的环境搭建详解【服务提供者和服务消费者】
一键难忘的博客
04-06 729
是 Lombok 提供的一个注解，用于自动生成Java Bean的相关代码，包括类的构造方法、Getter/Setter 方法、equals、hashCode和toString方法。是 Lombok 提供的一个注解，用于生成链式调用方法，即将多个 Setter 方法连成一条链，可以在代码中实现一行代码完成多个属性的赋值操作，提高代码的可读性和编写效率。是 Lombok 提供的一个注解，用于自动生成一个无参构造方法。配置application.yml：配置SpringBoot、mybatis。
Spring Cloud 入门 -- 搭建Eureka注册中心 实现服务者与消费者的服务调用
Trouvailless的博客
04-20 725
一、什么是Spring Cloud？ 摘自​​Spring Cloud官网​​ Spring Cloud provides tools for developers to quickly build some of the common patterns in distributed systems (e.g. configuration management, service discovery, circuit breakers, intelligent routing, micro-p...
Rest环境搭建：服务提供者和消费者---SpringCloud
web17886480312的博客
04-07 218
Rest环境搭建：服务提供者和消费者 4.1 介绍 我们会使用一个Dept部门模块做一个微服务通用案例Consumer消费者(Client)通过REST调用Provider提供者(Server)提供的服务。 回顾Spring，SpringMVC，Mybatis等以往学习的知识。 Maven的分包分模块架构复习。 一个简单的Maven模块结构是这样的： – app-parent: 一个父项目(app-parent)聚合了很多子项目(app-utilapp-daoapp-web…) |-- pom.
springcloud - 提供者-消费者
空中烟花
06-15 933
一、创建服务提供者 1、
Rest服务提供者和服务消费者
old_wzhou的博客
08-28 287
Spring Cloud 首先我们先创建一个maven项目 因为是父项目我们可以删除项目目录下的src 然后修改一下打包方式为pom 然后添加依赖 要注意springcloud的springboot版本兼容问题 接下来我们就可以加入模块了 新建一个模块我们会发现父项目并没有包导入进来，那是因为父项目只是管理包。 在新模块中导入时他会指向父项目的依赖 ...
面试专题-面试人员必看-微服务架构面试专题系列：Dubbo+Spring Boot+Spring Cloud.rar
08-05
- 服务提供者和服务消费者的概念 - ZooKeeper在Dubbo中的作用，如何实现服务注册与发现 - Dubbo的调用方式，如RPC、REST等 - Hessian和protobuf作为序列化协议的区别与选择 -Dubbo的集群策略，如Failover、Fail...
SpringCloud搭建（上）----注册中心+服务提供者+服务消费者
kelly921011的博客
09-09 1380
一、SpringCloud概述 1.什么是微服务： 简而言之，微服务微服务架构风格这种开发方式，是以开发一组小型服务的方式来开发一个独立的应用系统。其中每个小型服务都是运行在自己的进程中，并且采用HTTP资源API这样轻量的机制来相互通信。这些服务围绕业务功能进行搭建，并能通过全自动的部署机制来进行独立部署。这些微服务可以使用不同的语言来编写，并且可以使用不同的数据存储技术。对这些微...
SpringCloud-基于SpringBoot 2.1.3.RELEASE版本从零搭建分布式框架之服务提供者（三）
cuixhao110的博客
03-12 3549
上一篇 SpringCloud-基于SpringBoot 2.1.3.RELEASE版本从零搭建分布式框架之服务提供者（三）
springcloud_rest 部门服务提供者
weixin_43774824的博客
01-17 167
父工程构建： 为了方便，新建 java Working Set 项目分类，填写名字finish即可！
springcloud入门(一)之基本概念、服务提供者及消费者
指尖上的革新
12-16 1420
1 springcloud入门概述 1.1 什么是springcloud springcloud官网 springcloud,基于springboot提供了一套微服务解决方案，包括服务注册与发现，配置中心，全链路监控，服务网关，负载均衡，熔断器等组件； 除了基于Netflix的开源组件做高度抽象封装之外，还有一些选型中立的开源组件。 sprincloud利用springboot的开发便利性，巧妙地简化了分布式系统基础设施的开发，springcloud为开发人员提供了快速构建分布式的一些列工具， 包括配置
SpringCloud之Rest环境搭建：服务提供者和服务消费者
Java追求者的博客
06-12 214
1. SpringCloud版本选择 大版本说明 实际开发版本关系
一、SpringCloud-Rest
qq_26440111的博客
08-17 119
创建springcloud Maven父工程 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...
SpringCloud笔记之Rest环境搭建
JAVA开发区的博客
09-18 589
REST描述的是在网络中 client 和 server 的一种交互形式，REST本身不实用，实用的是如何设计RestFul API（REST风格的网络接口）
SpringCloud(一) Rest环境搭建
AwhisperY的博客
10-20 267
SpringCloud(一) 前言 刚入门springcloud，听了一个小时springcloud的介绍，云里雾里，不甚理解，只知道作为微服务的提供，减少了重复造轮子，并使模块开发更加独立，具体的熔断，负载均衡，等等等，大概要自己实操学完才理解。。于是不再重复看介绍，打算实操完再说理解 Rest学习环境搭建 JU坑 配置pom依赖，折腾了快一天。 选择合适的springcloud包。 一开始配置完依赖，运行程序打开网页，程序报错 Caused by: java.lang.NoSuchMethodError
SpringCloud入门学习之Rest服务
Herishwater的博客
05-22 371
文章目录父模块服务提供者数据库环境搭建数据筹备服务提供服务消费者问题记录参考文献 父模块 1、首先新建一个普通的 maven 项目，作为父级目录，之后的服务提供者和服务消费者都放在该目录下。 2、导入相关依赖，供子模块引用 <!--集中维护依赖版本--> <properties> <junit.version>4.12</junit.version> <lombok.version>1.18.12&l
SpringCloud环境搭建 --- Rest使用
hello_list的博客
08-07 427
个人主页：https://blog.csdn.net/hello_list?type=blog今天来到SpringCloud的学习，我们从spring boot微服务阶段，学习到了用springboot去创建很多的微服务，但是这么多微服务我们如果去管理，以及相互之间的联系呢？而到了我们学习springcloud阶段，其实相对而言是变简单的，不需要写很多代码以及什么操作，主要就是接收思想，了解其中的机制，而springCloud项目基于springboot项目，只需要几行简单的配置即可开始使用；......
SpringCloud—搭建Rest环境
可达鸭的博客
07-06 215
了解Rest和RPC的区别，搭建Rest架构的环境，实现基本案例
SpringCloud-Rest微服务工程的构建
萌萌虎的博客
08-20 1238
上面是几年前的微服务常用的组件，最近几年springcloudAlibaba正逐渐成为主流。下面列出了最近较流行的微服务架构，其亮点是新增加了若干Alibaba的微服务组件，如nacos、sentinel。：我的idea默认不会识别出springboot的配置和配置文件。这样一来，我们建立了三个子模块，可以实现基本的业务。5. Service接口与实现类。，是Spring提供的用于访问Rest服务的。4. mapper映射文件。3. mapper接口。的方法， 是一种简单便捷的访问。
SpringCloud实战：服务注册与发现详解
"详解springcloud之服务注册与发现" ...本篇内容将深入探讨Spring Cloud中的服务注册与发现机制，主要涉及Eureka...服务消费者则通过Eureka查找并调用服务提供者。这种机制极大地提高了微服务架构的灵活性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值