美文网首页
SpringCloud-REST实现生产者与消费者的通信服务

SpringCloud-REST实现生产者与消费者的通信服务

作者: CryFace | 来源:发表于2020-06-17 11:36 被阅读0次

环境搭建

我们需要创建一个普通的maven项目就行，因为后面我们的服务将会以模块在里面创建。同时我们将src目录删除，因为我们不会用到这个目录。

然后就是导入SpringCloud的依赖，同时要导入SpringBoot的依赖，我们之前说过，二者是有依赖关系的。要注意的SpringCloud的版本号所兼容的SpringBoot，这里可以去官网查询。这是目前比较新的


官网查询地址：https://spring.io/projects/spring-cloud#learn

然后就是一个正常SpringBoot的项目所需要的依赖，数据库，启动器，日志一些之类。下面给份参考

<?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.lin</groupId>
    <artifactId>springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>api</module>
    </modules>

    <!--打包方式 pom-->
    <packaging>pom</packaging>

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

    <dependencyManagement>
        <dependencies>
            <!--spring cloud的依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--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>
            <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>
            <!--junit-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.16.18</version>
            </dependency>
            <!--logback-->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
            <!--log4j-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

服务提供者

我们在主项目下，创建一个api的模块，主要放我们的实体类。


同样是普通的maven项目就行，然后我们再次引入需要的lombok的依赖，可以发现依赖是指向我们的父maven项目。这样我们在父项目就可以很好的管理每个子模块的依赖。


我们在该模块下创建一个实体类，并在数据库下创建该表，往数据库里面插入数据。

我们的实体类需要实现序列化，不然传输的时候会报错

package com.lin.springcloud.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

@Data
@NoArgsConstructor
@Accessors(chain = true) //链式写法，例：new user().get().set()  可以链式使用的方法
public class User implements Serializable {

    private int id;
    private String name;
    //数据存在哪一个数据库，因为微服务下，我们很可能存在很多的数据库，一个消息可能存在不同数据库
    private String db_source;

    private User(String name){
        this.name = name;
    }
}

然后就是创建我们的数据库（按照我们的实体类创建表，实际上开发我们就是先表再实体类，嘿嘿），这里就不多演示，我们展示一下插入的数据。


这里我们的数据已经有了，我们接下来就是创建服务提供者的模块，比如数据接口之类。

我们创建一个provider,标记端口为8001。因为服务多都需要端口，所以我们后面设置的时候要配置不同的端口。同时对该模块引入相关依赖

<?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.lin</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>provider</artifactId>

    <dependencies>
        <!--我们需要实体类，所以配置api-->
        <dependency>
            <groupId>com.lin</groupId>
            <artifactId>api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--服务器，这里我们使用jetty-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
    </dependencies>
</project>

然后我们在该模块下的resources下创建一个application.yml文件，就是我们的SpringBoot的配置文件，然后我们配置端口和数据源之类的配置

server:
  port: 8001
#mybatis配置
mybatis:
  type-aliases-package: com.lin.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
#spring的配置
spring:
  application:
    name: springcloud-provider
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db_springcloud?useUnicode=true&characterEncoding=utf-8
    username: rootlin
    password: 123456

账号密码之类填写自己的数据库即可。配置完就是我们的mybatis增删改查一套了，接口，service实现一套。

<?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.lin.springcloud.mapper.UserMapper">

    <select id="queryUserById" resultType="User">
        select * from user where id = #{id}
    </select>

    <select id="queryListUser" resultType="User">
        select * from user
    </select>

    <insert id="addUser" parameterType="User">
        insert into user (name,db_source)
        values (#{name},DATABASE())
    </insert>

</mapper>

package com.lin.springcloud.mapper;

import com.lin.springcloud.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
@Repository
public interface UserMapper {

    User queryUserById(int id);
    List<User> queryListUser();
    boolean addUser(User user);

}

package com.lin.springcloud.service;

import com.lin.springcloud.pojo.User;
import org.springframework.stereotype.Service;

import java.util.List;

public interface UserService {


    User queryUserById(int id);
    List<User> queryListUser();
    boolean addUser(User user);

}

package com.lin.springcloud.service;

import com.lin.springcloud.mapper.UserMapper;
import com.lin.springcloud.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserSercice{

    @Autowired
    private UserMapper userMapper;

    @Override
    public User queryUsreById(int id) {
        return userMapper.queryUsreById(id);
    }

    @Override
    public List<User> queryListUser() {
        return userMapper.queryListUser();
    }

    @Override
    public boolean addUser(User user) {
        return userMapper.addUser(user);
    }
}

然后就是Controller层了，也就是我们的服务提供者，前面做了那么多的铺垫也都是为了这一步。我们以Restful风格来编写

package com.lin.springcloud.controller;


import com.lin.springcloud.pojo.User;
import com.lin.springcloud.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    UserService userService;

    @PostMapping("/user/add")
    public boolean addUser(User user){
        return userService.addUser(user);
    }

    @GetMapping("/user/get/{id}")
    public User queryUserById(@PathVariable int id){
        return userService.queryUserById(id);
    }

    @GetMapping("/user/list")
    public List<User> queryListUser(){
        return userService.queryListUser();
    }
}

然后我们写一个springboot的主启动类，因为我们这样创建的项目是没有的，在同级目录下，创建UserProvider_8001.java的主启动类。

package com.lin.springcloud;

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

//启动类注解
@SpringBootApplication
public class UserProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(UserProvider_8001.class,args);
    }
}

我们启动测试一下，看看是否能够成功使用这些接口。


接口是可以用的，addUser因为我们是post请求，所以无法通过地址栏来添加用户。但是在下面我们消费者是可以有办法实现的。

服务消费者

我们创建一个consumer模块，在模块导入依赖，只需要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.lin</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>consumer</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.lin</groupId>
            <artifactId>api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

然后创建我们的application.yml，设置一个端口就行

server:
  port: 80

创建我们的启动类

package com.lin.springcloud;

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

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

然后直接就是我们的Controller层，这里我们的通信就需要用到RestTemplate。这类似我们用到的其他模板文件，需要注册到spirng中，然后就可供我们调用

package com.lin.springcloud.config;

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

@Configuration
public class ConfigBean {

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

}

Controller层

package com.lin.springcloud.controller;

import com.lin.springcloud.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class UserControllerConsumer {

    //提供了很多远程http的远程方法
    @Autowired
    private RestTemplate restTemplate;

    //我们服务提供者的地址栏前缀
    private static final String REST_URL_Provider = "http://localhost:8001";

    @RequestMapping("/consumer/user/get/{id}")
    public User get(@PathVariable int id){
        return restTemplate.getForObject(REST_URL_Provider+"/user/get/"+id,User.class);
    }

    @RequestMapping("/consumer/user/list")
    public List<User> queryList(){
        return restTemplate.getForObject(REST_URL_Provider+"/user/list",List.class);
    }

    @RequestMapping("/consumer/user/add")
    public boolean addUser(User user){
        return restTemplate.postForObject(REST_URL_Provider+"/user/add",user,Boolean.class);
    }
}

服务测试

我们先启动提供者的服务器，然后再启动消费者的服务器。通过地址栏的来进行数据查询和增加演示





我们添加了一个用户名为user6的用户也成功了，我们远程是用post的请求，但是我们在消费的时候是用get来访问，然后调用远程的post，这样就成功通过地址栏来添加用户了。这不是重点，但是也要了解。

可以看到，我们拆分服务，将原本的一站式变成了三个微服务模块来使用，对SpringCloud和微服务的概念学习可以有进一步的认识和了解。

给上项目目录结构，方便小伙伴实践

本文实践参考自狂神说学习视频

相关文章

  • SpringCloud-REST实现生产者与消费者的通信服务

    环境搭建 我们需要创建一个普通的maven项目就行，因为后面我们的服务将会以模块在里面创建。同时我们将src目录删...

  • Kafka, avro序列化

    借助confluent的schema-registry服务, 实现生产者与消费者共享schema 要点使用conf...

  • 线程通信-wait（notify）

    知识总结 多线程通信最经典的模型就是生产者消费者模式，java中有队列LinkedList可以实现该模式，做到通信...

  • JUC中线程之间得通信

    使用synchronized实现线程间通信,线程间通信：1、生产者+消费者2、通知等待唤醒机制.多线程编程模板:1...

  • Dubbo起步

    目录 定义接口 生产者生产者依赖生产者实现 消费者消费者依赖消费者实现 初步印象 定义接口 生产者 生产者依赖 生...

  • Java 并发编程——生产者与消费者

    1. 生产者与消费者 1.1 程序基本实现（问题引出） 生产者与消费者是线程操作的经典案例，即：生产者不断生产，消...

  • 多进程、多线程、生成器实现生产者消费者模型

    多线程实现 多线程实现生产者消费者模型的逻辑十分简单，生产者与消费者之间通过队列来进行通讯，所以生产者不用等待消费...

  • java实现kafka生产者和消费者同通信

    方式一： 基于maven的java kafka的生产者和消费者直接的通信： 配置本地的zookeeper服务，同时...

  • 操作系统知识点持续更新

    生产者消费者问题 关于生产者消费者问题可以参考这篇文章：生产者消费者问题的java实现 临界区与互斥量 临界区：保...

  • SpringCloud（2）

    生产者 /消费者注册中心(Eureka) 1.服务消费者/服务生产者 简单理解，服务消费者就是发起服务调用的请求方...

网友评论

      本文标题：SpringCloud-REST实现生产者与消费者的通信服务

      本文链接：https://www.haomeiwen.com/subject/jowdxktx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|SpringCloud-REST实现生产者与消费者的通信服务|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！