2. 微服务架构编码构建

        从订单支付模块微服务开始。

1. 微服务cloud整体聚合工程搭建

1.1 父工程步骤

1）新建工程

 

2）Maven版本选择

3）字符编码

 4）注解生效激活

5）java编译版本选择

6）File Type过滤

这个设置的目的是为了去掉idea工程中的一些乱七八糟的文件

1.2 父工程Pom

注意：在idea中不能自动选择聚合工程类型，需要手动修改，例如；

因为是父工程，只是做一些依赖管理，所以需要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.bjc.cloud</groupId>
  <artifactId>cloud2020</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <modules>
    <module>cloud-provider-payment-8001</module>
  </modules>

  <!-- jar统一管理 -->
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compilier.source>1.8</maven.compilier.source>
    <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>
    <mysql.version>5.1.47</mysql.version>
    <druid.version>1.1.16</druid.version>
    <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
  </properties>

  <!-- 子模块集成之后，提供作用：锁定版本 + 子modlue不用写groupID和version -->
  <dependencyManagement>
    <dependencies>
      <!-- springBoot 2.2.2 -->
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot</artifactId>
        <version>2.2.2.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>

      <!-- cloud 版本 Hoxton.SR1 -->
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>Hoxton.SR1</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>

      <!-- spring cloud alibaba 2.1.0.RELEASE -->
      <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>2.1.0.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>

      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
      </dependency>
      <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
      </dependency>
      <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>${mybatis.spring.boot.version}</version>
      </dependency>
      <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
      </dependency>
      <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
        <optional>true</optional>
      </dependency>

    </dependencies>
  </dependencyManagement>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <fork>true</fork>
          <addResources>true</addResources>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

2. Rest微服务工程构建

2.1 支付模块构建

2.1.1 cloud-provider-payment-8001微服务提供者支付Module模块

1）新建子模块

2）修改src文件夹类型

修改之后：

3）修改子Module的pom文件

<?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>cloud2020</artifactId>
        <groupId>com.bjc.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-provider-payment-8001</artifactId>

    <dependencies>
        <!-- 添加bootweb启动依赖与健康监控依赖 -->
        <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>

        <!-- 添加mybatis启动器 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!-- druid启动器 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <!-- mysql -->
        <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>
            <optional>true</optional>
        </dependency>

        <!-- junit测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

    </dependencies>

</project>

4）yml配置文件

##  服务端口号
server:
  port: 8001
##  服务名称
spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
    url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false              # 数据库名称
    username: root
    password: root
    dbcp2:
      min-idle: 5                                           # 数据库连接池的最小维持连接数
      initial-size: 5                                       # 初始化连接数
      max-total: 5                                          # 最大连接数
      max-wait-millis: 200                                  # 等待连接获取的最大超时时间

mybatis:
  ## config-location: classpath:mybatis/mybatis.cfg.xml        # mybatis配置文件所在路径
  type-aliases-package: com.bjc.cloud.entities                # 所有Entity别名类所在包
  mapper-locations: classpath:mapper/*.xml                       # mapper映射文件

5）启动类

package com.bjc.cloud;

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

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

6）业务类

6.1 建表SQL

CREATE DATABASE db2019;
USE db2019;
CREATE TABLE payment(
	id BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
	SERIAL VARCHAR(200) DEFAULT '',
	PRIMARY KEY (id)
) ENGINE=Innodn AUTO_INCREMENT=1 DEFAULT CHARSET=utf8

6.2 实体类

业务实体：

package com.bjc.cloud.entity;

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

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain=true)	// 访问方式  chain=true 表示链式风格访问
public class Payment implements Serializable {
	private Long id;
	private String serial;
}

返回前端封装实体

package com.bjc.cloud.entity;

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

import java.util.List;

/**
 * 返回前端实体类，用于前后端交互的实体bean
 * */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain=true)	// 访问方式  chain=true 表示链式风格访问
public class CommonResult<T> {
	// 404 not fund
	private Integer code;
	private String message;
	private T data;
	public CommonResult(Integer code,String message){
		this(code,message,null);
	}
}

6.3 mapper

package com.bjc.cloud.mapper;

import com.bjc.cloud.entity.Payment;
import org.apache.ibatis.annotations.*;

@Mapper
public interface PaymentMapper {
	@Insert(value="insert into payment(serial) values(#{serial})")
	@Options(useGeneratedKeys=true, keyProperty="id", keyColumn="id") //该注解用于返回主键
	public int create(Payment payment);

	@Select("select * from payment where id=#{id}")
	public Payment getPaymentById(@Param("id") Long id);
}

注意；因为案例比较简单，用小小的注解就可以解决，所以，不用写映射配置文件了。

6.4 service

package com.bjc.cloud.service.impl;

import com.bjc.cloud.entity.Payment;
import com.bjc.cloud.mapper.PaymentMapper;
import com.bjc.cloud.service.PaymentService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class PaymentServiceImpl implements PaymentService {
	@Resource
	private PaymentMapper paymentMapper;
	public int create(Payment payment) {
		return paymentMapper.create(payment);
	}

	public Payment getPaymentById(Long id) {
		return paymentMapper.getPaymentById(id);
	}
}

6.5 controller

package com.bjc.cloud.controller;

import com.bjc.cloud.entity.CommonResult;
import com.bjc.cloud.entity.Payment;
import com.bjc.cloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
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 javax.annotation.Resource;

@RestController
@Slf4j
public class PaymentController {
	@Resource
	private PaymentService paymentService;

	@PostMapping(value="/payment/create")
	public CommonResult<Integer> create(Payment payment){
		int result = paymentService.create(payment);
		log.info("*******  插入结果：" + result);
		if (result > 0) {
			return new CommonResult(200,"插入成功！",result);
		}
		return new CommonResult(500,"插入失败！");
	}

	@GetMapping(value="/payment/get/{id}")
	public CommonResult<Payment> getPaymentByid(@PathVariable("id") Long id){
		Payment payment = paymentService.getPaymentById(id);
		log.info("*******  查询结果：" + payment);
		if (null != payment) {
			return new CommonResult(200,"查询成功！").setData(payment);
		}
		return new CommonResult(500,"查询失败！");
	}
}

2.2 测试

1）测试插入

查看数据库

2）测试查询

3. 热部署DevTools

3.1 添加依赖

<!-- 热部署 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

3.2 添加插件

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <fork>true</fork>
          <addResources>true</addResources>
        </configuration>
      </plugin>
    </plugins>
  </build>

在父工程中添加

3.3 idea开启自动编译

3.4 更新值

打开工程任意文件，按住ctrl + shift + alt + / ，会弹出如下弹窗

点击第一个Registry，进入如图所示，并勾选如图所示复选框

然后勾选如下所示复选框

然后重启idea。

4. cloud-consumer-order80微服务消费者订单Module模块

4.1 操作步骤

1）新建工程cloud-consumer-order80

2）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>cloud2020</artifactId>
        <groupId>com.bjc.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-order80</artifactId>

    <dependencies>
        <!-- 添加bootweb启动依赖与健康监控依赖 -->
        <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>

        <!-- junit测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>


</project>

3）配置文件application.yml

server:
  port: 80

4）主启动类

package com.bjc.cloud;

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

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

5）业务类

5.1 实体bean

因为我们的消费者不需要关心具体的业务逻辑，只是用来获取相应的数据，所以只需要一个controller层即可，但是，我们需要一个实体bean，所以可以将8001的entity拷贝过来

如图；

5.2 配置类

最开始，我们使用RestTemplate来调用8001的业务方法获取数据，所以需要配置一下RestTemplate

package com.bjc.cloud.config;

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

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

5.3 controller

package com.bjc.cloud.controller;

import com.bjc.cloud.entity.CommonResult;
import com.bjc.cloud.entity.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
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;

@RestController
@Slf4j
public class OrderController {
	@Autowired
	private RestTemplate restTemplate;

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

	@GetMapping("/consumer/payment/create")
	public CommonResult<Integer> create(Payment payment){
		log.info("*******************");
		return restTemplate.postForObject(PAYMENT_URL + "payment/create",payment,CommonResult.class);
	}
	@GetMapping("/consumer/payment/get/{id}")
	public CommonResult<Payment> getPaymentByid(@PathVariable("id") Long id){
		return restTemplate.getForObject(PAYMENT_URL + "payment/get/"+id,CommonResult.class);
	}
}

4.2 测试

1）查询

2）插入

注意：这里需要8001的Controller的方法用@RequestBody注解，如图；

5. 工程重构

刚才我们已经完成了两个服务的互相调用，但是，我们发现，两个服务都有一个一模一样的entity，这样会造成代码的冗余，我们可以将这部分抽取出来。

5.1 新建通用部分工程cloud-api-commons

1）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>cloud2020</artifactId>
        <groupId>com.bjc.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-api-commons</artifactId>

    <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>
        <!-- 一个比较牛逼的api -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.1.0</version>
        </dependency>
    </dependencies>

</project>

2）将entity抽取到该工程中

3）打包安装

选中工程，跳过测试（点击闪电图标），刷新，如图：

然后clean

最后install

4）改造订单服务于支付服务

4.1 删除原来的entity

4.2 分别添加依赖

5.2 测试

1）测试生产者

2）测试消费者