Spring Cloud(03)——构建支付模块和消费者订单模块以及工程重构

Spring Cloud(03)——构建支付模块和消费者订单模块以及工程重构

在上一篇Spring Cloud(02)——搭建订单-支付微服务模块中，我们已经建好了父项目，下面就要在父项目里面建子模块了，先建服务提供模块，也就是支付模块，再建服务消费者模块，也就是消费者订单模块。

1、构建支付模块

1、环境搭建

1、建在父工程中建一个子模块：cloud-provider-payment8001

建完后会发现父pom里多了一行modules，为：

<modules>
  <module>cloud-provider-payment8001</module>
</modules>

2、子模块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.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <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>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>

3、编写配置文件

server:
  port: 8001

spring:
  application:
    name: cloud-payment-service

4、编写主启动类

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

2、编写业务

1、建库建表

CREATE TABLE `db01`.`payment`( 
 `id` BIGINT(50) NOT NULL AUTO_INCREMENT, 
 `serial` VARCHAR(50), 
 PRIMARY KEY (`id`) 
 ) ENGINE=INNODB CHARSET=utf8 COLLATE=utf8_general_ci; 
 

2、idea连接数据库

3、编写数据库配置文件

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8&useSSl=false
    username: root
    password: 19990802

4、编写实体类

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

编写json封装体

@Data
@AllArgsConstructor
@NoArgsConstructor
//传给前端的json封装体
public class CommonResult<T> {
    
    private Integer code;  //异常编码
    private String message;//异常信息
    private T      data;   
    
    //两个参数的构造方法
    public CommonResult(Integer code, String message) {
        this(code, message, null);
    }
}

5、编写dao层接口

@Mapper
public interface PaymentDao {

    public int create(Payment payment);


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

mapper.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.cheng.springcloud.dao.PaymentDao">

    <!--获取到数据库自动生成的主键ID-->
    <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
        insert into Payment (serial) values (#{serial})
    </insert>

    <resultMap id="BaseMap" type="Payment">
        <id column="id" property="id"  jdbcType="BIGINT"/>
        <id column="serial" property="serial" jdbcType="VARCHAR"/>
    </resultMap>

    <select id="getPaymentById" parameterType="Long" resultMap="BaseMap">
        select * from Payment where id=#{id}
    </select>

</mapper>

增加mybatis配置

mybatis:
  type-aliases-package: com.cheng.springcloud.pojo
  mapper-locations: classpath:mapper/*.xml

6、编写业务层

业务层接口

public interface PaymentService {

    public int create(Payment payment);


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

}

业务层实现类

@Service
public class PaymentServiceImpl implements PaymentService{

    @Resource
    private PaymentDao paymentDao;


    @Override
    public int create(Payment payment) {
        return paymentDao.create(payment);
    }

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

7、编写controller

@RestController
@Slf4j
public class PaymentController {

    @Resource
    private PaymentService paymentService;

    @PostMapping("/payment/create")
    public CommonResult create(Payment payment){
        int result = paymentService.create(payment);

        log.info("=======添加结果="+result);

        if (result > 0){
            return new CommonResult(200,"添加执行成功",result);
        }else {
            return new CommonResult(500,"添加执行失败",null);
        }
    }

    @GetMapping("/payment/create/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id){
        Payment payment = paymentService.getPaymentById(id);

        log.info("=======查询结果="+payment);

        if (payment != null){
            return new CommonResult(200,"查询执行成功",payment);
        }else {
            return new CommonResult(500,"查询id为"+id+"执行失败",null);
        }
    }
}

8、启动程序测试：在表Payment插入一条数据：

insert into payment(serial) values ('jingdong')

测试getPaymentById方法：

访问请求：localhost:8001/payment/get/1

访问请求：localhost:8001/payment/get/2

测试create方法：因为create方法的提交方式是post，所以建议用postman来测试。

访问请求：localhost:8001/payment/create?serial

测试成功！

2、构建消费者订单模块

1、环境搭建

1、在父工程中建一个子模块：cloud-consumer-order8001

2、导入依赖：

<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>

    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>

3、配置文件application.yml

server:
  port: 80

4、主启动类

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

2、编写业务

1、拷贝支付模块中的实体类到消费者模块

2、因为消费者只需要访问服务提供者提供的服务，所有只需编写controller

这里我们使用RestTemplate进行远程访问。 RestTemplate 是从Spring3.0开始支持的一个http请求工具，是一种简单便捷的访问restful服务的模板类，是spring提供的用于访问Rest服务的客户端模板工具集。

它提供了常见的rest请求方案的模板，例如get请求，post请求，put请求，delete请求以及一些通用的请求执行方法exchange以及execute。

先编写配置类将RestTemplate注入到容器中：

@Configuration
public class ConfigBean {

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

再编写controller访问远程的服务：

package com.cheng.springcloud.controller;

import com.cheng.springcloud.pojo.CommonResult;
import com.cheng.springcloud.pojo.Payment;
import lombok.extern.slf4j.Slf4j;
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.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@RestController
@Slf4j
public class OrderController {


    //把远程地址前缀提取出来
    public static final String REST_URL_PREFIX = "http://localhost:8001";

    @Resource
    private RestTemplate restTemplate;


    //postForObject参数：url+方法参数+返回值的class对象,服务端用的什么请求，客户端也用什么请求
    @GetMapping("/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment){
        return restTemplate.postForObject(REST_URL_PREFIX+"/payment/create",payment,CommonResult.class);

    }

    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/payment/get/"+id,CommonResult.class);
    }
}

测试

先启动支付模块，再启动消费者模块

1、测试查询操作

访问请求http://localhost/consumer/payment/get/2：看是否能访问到服务提供者提供的服务，

访问成功！

2、测试添加操作：

访问请求：http://localhost/consumer/payment/create?serial=“455”，看是否可以添加成功，

添加成功，然后再打开我们的数据库看看，

发现我们添加的数据竟然是null，但在上面的请求中，我们明明有传递数据的，为什么会显示null呢？

这是因为没有使用@RequestBody来接收json格式的数据，

@RequestBody的作用其实是将json格式的数据转为java对象。

解决方法：在提供服务的方法体上加上@RequestBody：

@PostMapping(value = "/payment/create")
public CommonResult create(@RequestBody Payment payment){
    int result = paymentService.create(payment);

    log.info("=======添加结果="+result);

    if (result > 0){
        return new CommonResult(200,"添加执行成功",result);
    }else {
        return new CommonResult(500,"添加执行失败",null);
    }
}

使用热部署快速build项目，

访问http://localhost/consumer/payment/create?serial=“万里”，看这次是否为null，

看数据库结果

添加成功！

3、工程重构

在我们上面的两个模块中，都有同一个目录，就是pojo目录，在正常开发中会造成冗余，因此我们要把它拿出来。

1、新建一个模块cloud-api-commons

2、导入依赖

<dependencies>
    <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>
    <!--Hutool是一个小而全的Java工具类库-->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.1.0</version>
    </dependency>
</dependencies>

3、把pojo目录拷贝到cloud-api-commons模块下

4、执行maven命令，clean和install

5、改造支付8001和订单80

先删除两个模块中的poji目录，然后在两个模块中添加下面依赖：

<!--引入api模块，可以使用里面的实体类-->
<dependency>
    <groupId>com.cheng.springcloud</groupId>
    <artifactId>cloud-api-commons</artifactId>
    <version>${project.version}</version>
</dependency>

目前工程样图：