SpringCloud（一）聚合工程搭建

写在前面：

• 你好，欢迎你的阅读！
• 我热爱技术，热爱分享，热爱生活， 我始终相信：技术是开源的，知识是共享的！
• 博客里面的内容大部分均为原创，是自己日常的学习记录和总结，便于自己在后面的时间里回顾，当然也是希望可以分享自己的知识。目前的内容几乎是基础知识和技术入门，如果你觉得还可以的话不妨关注一下，我们共同进步！
• 除了分享博客之外，也喜欢看书，写一点日常杂文和心情分享，如果你感兴趣，也可以关注关注！
• 微信公众号：傲骄鹿先生

说明：

1、专栏涉及到的源码已经同步至https://github.com/SetAlone/springcloud2020（持续更新）

2、springcloud系列博文内容为学习《尚硅谷2020最新版SpringCloud(H版&alibaba)框架开发教程》的记录，此系列课程是目前看来个人觉得非常不错的资源，在此可以与大家进行分享。

3、个人收集到了课程源码和所需的脑图、笔记等资源，如需要私信我即可。查找资源不易，希望可以给个点赞和关注。

一、IDEA新建project工作空间

1、New Project

2、聚合总父工程名字

3.、Maven选版本

4、工程名字

5、 字符编码

6、注解生效激活

7、java编译版本选8

8、File Type过滤（可做可不做）

父工程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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atguigu.springcloud</groupId>
    <artifactId>cloud2020</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!--统一管理jar包版本-->
    <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>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>8.0.19</mysql.version>
        <druid.version>1.1.16</druid.version>
        <spring.boot.version>2.2.2.RELEASE</spring.boot.version>
        <spring.cloud.version>Hoxton.SR1</spring.cloud.version>
        <spring.cloud.alibaba.version>2.1.0.RELEASE</spring.cloud.alibaba.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <!--子模块继承后,提供作用:锁定版本+子module不用groupId和version-->
    <dependencyManagement>
        <dependencies>
            <!--springboot 2.2.2-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--Spring cloud Hoxton.SR1-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.version}</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>${spring.cloud.alibaba.version}</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.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </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>

    <!--第三方maven私服-->
    <repositories>
        <repository>
            <id>nexus-aliyun</id>
            <name>Nexus aliyun</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>


</project>
 

Maven中的DependencyManagement和Dependencies

这样做的好处就是: 如果有多个子项目都引用同一样的依赖,则可以避免在每个使用的子项目里都声明一个版本号,这样想升级或切换到另一个版本时,只需在顶层父容器里更新,而不需要一个一个子项目的修改;另外如果某个子项目需要另外的一个版本,只需声明version版本 

父工程创建完成执行mvn:insall将父工程发布到仓库方便子工程继承。

二、Rest微服务工程搭建

每次建立一个新的Moudle模块的时候我们都将进行如下的操作步骤：建moudle，改pom，写yml，主启动类、业务类、测试

1.Cloud-provider-payment8001 微服务提供者Module模块

建moudle

在父工程上右键，new——>moudle，新建一个新的maven项目，不需要选择向导。命令为cloud-provider-payment8001。

创建完成后在父工程的pom文件中查看，会有如下的一个变化，因为新的子工程是继承自父工程的。

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

改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>SpringCloud2020</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-provider-payment8001</artifactId>

    <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-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>

    </dependencies>

</project>

写yml

在resources文件夹下 创建一个application.yml文件，进行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
    url: jdbc:mysql://000.000.000.000:3306/db2020_cloud?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities

主启动类

在java文件夹下创建一个新的java文件作为主启动类。

package com.atguigu.springcloud;

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

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

业务类

1、数据库建表：

 DROP TABLE IF EXISTS `payment`;
 CREATE TABLE `payment`
 (
     `id`     bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
     `serial` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '支付流水号',
     PRIMARY KEY (`id`) USING BTREE
 ) ENGINE = InnoDB
   CHARACTER SET = utf8
   COLLATE = utf8_general_ci COMMENT = '支付表'
   ROW_FORMAT = Dynamic;

2、实体类entities

主实体Payment

package com.atguigu.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

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

Json封装体CommonResult

package com.atguigu.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
    private Integer code;
    private String message;
    private T data;

    public CommonResult(Integer code, String message) {
        this(code, message, null);
    }
}

3、dao

接口PaymentDao

 package com.atguigu.springcloud.dao;
 ​
 import com.atguigu.springcloud.entities.Payment;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 ​
 ​
 @Mapper
 public interface PaymentDao {
 ​
     public int create(Payment payment);
 ​
     public Payment getPaymentById(@Param("id") Long id);
 }

4、mybatis的映射文件PaymentMapper.xml

在src\main\resources下创建文件夹mapper，再创建PaymentMapper.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.atguigu.springcloud.dao.PaymentDao">
 ​
     <insert id="insert" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
         insert into payment(serial)
         values (#{serial});
     </insert>
 ​
 <!--    使用resultMap进行映射-->
     <resultMap id="BaseResultMap" type="com.atguigu.springcloud.entities.Payment">
         <id column="id" property="id" jdbcType="BIGINT"></id>
         <id column="serial" property="serial" jdbcType="VARCHAR"></id>
     </resultMap>
     <select id="getPaymentById" parameterType="Long" resultType="BaseResultMap">
         select * from payment where id=#{id};
     </select>
 ​
 </mapper>

5、service

接口PaymentService

 package com.atguigu.springcloud.service;
 ​
 ​
 import com.atguigu.springcloud.entities.Payment;
 import org.apache.ibatis.annotations.Param;
 ​
 public interface PaymentService {
     public int create(Payment payment);
 ​
     public Payment getPaymentById(@Param("id") Long id);
 ​
 }

接口实现类PaymentServiceImpl

package com.atguigu.springcloud.service.impl;
 ​
 import com.atguigu.springcloud.dao.PaymentDao;
 import com.atguigu.springcloud.entities.Payment;
 import com.atguigu.springcloud.service.PaymentService;
 import org.springframework.stereotype.Service;
 ​
 import javax.annotation.Resource;
 ​
 @Service
 public class PaymentServiceImpl implements PaymentService {
 ​
     @Resource
     private PaymentDao paymentDao;
 ​
     public int create(Payment payment){
         return paymentDao.create(payment);
     }
 ​
     public Payment getPaymentById(Long id){
         return paymentDao.getPaymentById(id);
     }
 ​
 }

6、controller

package com.atguigu.springcloud.controller;
 ​
 import com.atguigu.springcloud.entities.CommonResult;
 import com.atguigu.springcloud.entities.Payment;
 import com.atguigu.springcloud.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 create(@RequestBody Payment payment) {
         int result = paymentService.create(payment);
         log.info("*****插入结果：" + result);
 ​
         if (result > 0) {
             return new CommonResult(200, "插入数据库成功", result);
         } else {
             return new CommonResult(444, "插入数据库失败", null);
         }
     }
 ​
     @GetMapping(value = "/payment/get/{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(444, "没有对应记录，查询ID:"+id, null);
         }
     }
 }

测试

• 在浏览器输入http://localhost:8001/payment/get/31进行测试

• postman模拟post

2、热部署Devtools

1.Adding devtools to your project

在cloud-provider-payment8001项目的pom文件中添加依赖

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

2.Adding plugin to your pom.xml

在聚合父类总工程的pom.xml里添加配置

<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.Enabling automatic build（开启自动编译的选项）

在设置settings中开启自动编译选项

4、Update the value of

组合键ctrl+shift+alt+/ 打开如下的选项卡进行设置

进行上面的4个步骤后即可开启热部署的设置，当你在启动项目的情况下修改其他内容，项目会自行的重新启动，不用再手动的重新启动，提高了开发的效率。但是在实际的生产环境中一班不会开启热部署的。

3、cloud-consumer-order80 微服务消费者订单Module模块

还是按照建立新moudle的几个步骤快速构建

1、建立新的moudle，继承自父工程，命名为cloud-consumer-order80

2、改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>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>cloud2020</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

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

    <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>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

3、写yml

server:
	port:80

4、主启动类

package com.atguigu.spring;

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

import java.io.Serializable;

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

5、业务类

作为一个消费者模块，我们不需要再进行数据的操作，因此不需要service和dao。

实体类entities（复制上面模块的中的实体即可）

controller

1）使用Resttemplate完成客户端消费者80模块到微服务提供者8001模块的调用。

使用Resttemplate对象的话需要将它注入到springboot的容器中。

package com.atguigu.springcloud.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();
    }
}

2）编写controller类

package com.atguigu.springcloud.controller;

import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.client.ServiceInstance;
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;

import javax.annotation.Resource;
import java.net.URI;
import java.util.List;

@RestController
@Slf4j
public class OrderController
{
    public static final String PAYMENT_URL = "http://localhost:8001";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment)
    {
        return restTemplate.postForObject(PAYMENT_URL +"/payment/create",payment,CommonResult.class);
    }

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

6、测试

3、工程重构

因为整个项目采用的工程聚合的方式进行构建，我们在完成 了上面的两个子模块的建立后，发现两个项目中有共同的部分，即业务类中的实体entities文件夹是共有的部分，因此我们可以将其提取出来，作为一个模块进行构建：

1）建立新的moudle，命名为cloud-api-commons

2)修改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>springcloud2020</artifactId>
        <groupId>com.atguigu.springcloud</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>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.1.0</version>
        </dependency>
    </dependencies>

</project>

3）将同有的部分：实体类进行复制

4）使用mvn命令进行clean、install

5）在订单80和支付8001分别改造

• 删除原有的实体类entities文件夹
• 修改各自的pom文件，在pom文件中添加依赖

<dependency>
    <groupId>com.atguigu.springcloud</groupId>
    <artifactId>cloud-api-common</artifactId>
    <version>${project.version}</version>
</dependency>
 

4、工程样图

在完成了父工程和两个子工程的搭建后就会如下图的样图