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

环境搭建

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

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

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

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

    4.0.0

    com.lin
    springcloud
    1.0-SNAPSHOT
    
        api
    

    
    pom

    
        UTF-8
        1.8
        1.8
    

    
        
            
            
                org.springframework.cloud
                spring-cloud-dependencies
                Greenwich.SR1
                pom
                import
            
            
            
                org.springframework.boot
                spring-boot-dependencies
                2.1.4.RELEASE
                pom
                import
            
            
            
                mysql
                mysql-connector-java
                5.1.47
            
            
                com.alibaba
                druid
                1.1.10
            
            
            
                org.mybatis.spring.boot
                mybatis-spring-boot-starter
                1.3.2
            
            
            
                junit
                junit
                4.12
            
            
            
                org.projectlombok
                lombok
                1.16.18
            
            
            
                ch.qos.logback
                logback-core
                1.2.3
            
            
            
                log4j
                log4j
                1.2.17
            
        
    

服务提供者

我们在主项目下，创建一个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。因为服务多都需要端口，所以我们后面设置的时候要配置不同的端口。同时对该模块引入相关依赖

    
        springcloud
        com.lin
        1.0-SNAPSHOT
    
    4.0.0

    provider

    
        
        
            com.lin
            api
            1.0-SNAPSHOT
        
        
            junit
            junit
        
        
            mysql
            mysql-connector-java
        
        
            com.alibaba
            druid
        
        
            ch.qos.logback
            logback-core
        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
        
        
            org.springframework.boot
            spring-boot-starter-test
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-jetty
        
    

然后我们在该模块下的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实现一套。

    
        select * from user where id = #{id}
    

    
        select * from user
    

    
        insert into user (name,db_source)
        values (#{name},DATABASE())
    

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 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 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 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 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和实体类的依赖就行

    
        springcloud
        com.lin
        1.0-SNAPSHOT
    
    4.0.0

    consumer

    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            com.lin
            api
            1.0-SNAPSHOT
        
    

然后创建我们的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 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和微服务的概念学习可以有进一步的认识和了解。

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

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