父工程构建

创建父工程

创建Maven工程

工程搭建 - 图1

设置编码

工程搭建 - 图2

设置注解激活生效

工程搭建 - 图3

设置编译版本

工程搭建 - 图4

过滤FileTpye设置，在目录中隐藏文件

工程搭建 - 图5

这样目录看着就很舒服

工程搭建 - 图6

父工程POM文件

  • 父工程只是做依赖管理

    所以packing方式为pom，并且不需要编写代码，将src文件夹删除

工程搭建 - 图7

  • 统一管理jar包版本
    1. <properties>
    2.   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    3.   <maven.compiler.source>1.8</maven.compiler.source>
    4.   <maven.compiler.target>1.8</maven.compiler.target>
    5.   <junit.version>4.12</junit.version>
    6.   <log4j.version>1.2.17</log4j.version>
    7.   <lombok.version>1.16.18</lombok.version>
    8.   <mysql.version>5.1.47</mysql.version>
    9.   <druid.version>1.1.16</druid.version>
    10.   <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    11. </properties>

  • 添加依赖

    2. <!-- 子模块继承之后，提供作用：锁定版本+子modlue不用写groupId和version  -->
    3. <dependencyManagement>
    4.   <dependencies>
    5.     <!--spring boot 2.2.2-->
    6.     <dependency>
    7.       <groupId>org.springframework.boot</groupId>
    8.       <artifactId>spring-boot-dependencies</artifactId>
    9.       <version>2.2.2.RELEASE</version>
    10.       <type>pom</type>
    11.       <scope>import</scope>
    12.     </dependency>
    13.     <!--spring cloud Hoxton.SR1-->
    14.     <dependency>
    15.       <groupId>org.springframework.cloud</groupId>
    16.       <artifactId>spring-cloud-dependencies</artifactId>
    17.       <version>Hoxton.SR1</version>
    18.       <type>pom</type>
    19.       <scope>import</scope>
    20.     </dependency>
    21.     <!--spring cloud alibaba 2.1.0.RELEASE-->
    22.     <dependency>
    23.       <groupId>com.alibaba.cloud</groupId>
    24.       <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    25.       <version>2.1.0.RELEASE</version>
    26.       <type>pom</type>
    27.       <scope>import</scope>
    28.     </dependency>
    29.     <dependency>
    30.       <groupId>mysql</groupId>
    31.       <artifactId>mysql-connector-java</artifactId>
    32.       <version>${mysql.version}</version>
    33.     </dependency>
    34.     <dependency>
    35.       <groupId>com.alibaba</groupId>
    36.       <artifactId>druid</artifactId>
    37.       <version>${druid.version}</version>
    38.     </dependency>
    39.     <dependency>
    40.       <groupId>org.mybatis.spring.boot</groupId>
    41.       <artifactId>mybatis-spring-boot-starter</artifactId>
    42.       <version>${mybatis.spring.boot.version}</version>
    43.     </dependency>
    44.     <dependency>
    45.       <groupId>junit</groupId>
    46.       <artifactId>junit</artifactId>
    47.       <version>${junit.version}</version>
    48.     </dependency>
    49.     <dependency>
    50.       <groupId>log4j</groupId>
    51.       <artifactId>log4j</artifactId>
    52.       <version>${log4j.version}</version>
    53.     </dependency>
    54.     <dependency>
    55.       <groupId>org.projectlombok</groupId>
    56.       <artifactId>lombok</artifactId>
    57.       <version>${lombok.version}</version>
    58.       <optional>true</optional>
    59.     </dependency>
    60.   </dependencies>
    61. </dependencyManagement>

  • dependencyManagement和dependencies

    • Maven 使用dependencyManagement 元素来提供了一种管理依赖版本号的方式。通常会在一个组织或者项目的最顶层的父POM 中看到dependencyManagement 元素。
    • 使用pom.xml 中的dependencyManagement 元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。Maven 会沿着父子层次向上走，直到找到一个拥有dependencyManagement 元素的项目，然后它就会使用这个dependencyManagement 元素中指定的版本号。
    • dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖（子项目通过<dependence>引入）。
    • 如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。
  • 跳过单元测试

    工程搭建 - 图8

  • 至此，父项目就搭建完成了。通过Maven的clean、install就可以生成包给子项目引入

微服务工程构建

  • 总体模块

    工程搭建 - 图9

80端口作为客户端模块

8001端口作为微服务提供者模块

微服务提供者模块

  • 步骤

    1. 建Module
    2. 修改pom文件
    3. 编写配置文件
    4. 编写模块主程序
    5. 编写业务类
  • 建Module

    建立Maven项目即可，注意JDK版本的选择

工程搭建 - 图10

选择父工程以及模块名

工程搭建 - 图11

此时的结构

工程搭建 - 图12

同时，父工程的pom文件自动新增了module

工程搭建 - 图13

  • 修改pom文件

    工程搭建 - 图14

同时可以看到引入的依赖中，有的版本号没有写，是因为使用的父工程中的版本号。

父工程中没有的模块，子工程还是需要些的

  1.  <!--引入的依赖-->
  2.     <dependencies>
  3.         <dependency>
  4.             <groupId>org.springframework.boot</groupId>
  5.             <artifactId>spring-boot-starter-web</artifactId>
  6.         </dependency>
  7.         <dependency>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-actuator</artifactId>
  10.         </dependency>
  11.         <dependency>
  12.             <groupId>org.mybatis.spring.boot</groupId>
  13.             <artifactId>mybatis-spring-boot-starter</artifactId>
  14.         </dependency>
  15.         <dependency>
  16.             <groupId>com.alibaba</groupId>
  17.             <artifactId>druid-spring-boot-starter</artifactId>
  18.             <version>1.1.10</version>
  19.         </dependency>
  20.         <!--mysql-connector-java-->
  21.         <dependency>
  22.             <groupId>mysql</groupId>
  23.             <artifactId>mysql-connector-java</artifactId>
  24.         </dependency>
  25.         <!--jdbc-->
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter-jdbc</artifactId>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-devtools</artifactId>
  33.             <scope>runtime</scope>
  34.             <optional>true</optional>
  35.         </dependency>
  36.         <dependency>
  37.             <groupId>org.projectlombok</groupId>
  38.             <artifactId>lombok</artifactId>
  39.             <optional>true</optional>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-test</artifactId>
  44.             <scope>test</scope>
  45.         </dependency>
  46.     </dependencies>
  • 编写配置文件
    1. server:
    2. port: 8001
    3. spring:
    4. application:
    5.   name: cloud-payment-service
    6. datasource:
    7.   type: com.alibaba.druid.pool.DruidDataSource
    8.   driver-class-name: com.mysql.jdbc.Driver
    9.   url: jdbc:mysql://101.35.238.236:3306/springcloud?useUnicode=true&characterEncoding=utf-8&useSSL=false
    10.   username: 
    11.   password: 
    12. mybatis:
    13. mapper-locations: classpath:mapper/*.xml # 扫描Mapper的路径为类路径下mapper文件夹下的所有.xml文件
    14. type-aliases-package: top.chasingwind.springcloud.entities # Entity所在包
  • 编写模块主程序

    工程搭建 - 图15

  • 编写业务类

    1. 创建表 ``mysql CREATE TABLEpayment` (

    id bigint(20) NOT NULL AUTO_INCREMENT COMMENT ‘ID’,

    serial varchar(200) DEFAULT ‘’,

    PRIMARY KEY (id)

) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8

  3.    2. 
  4. 创建实体类
  5. > ![](https://blog.chasingwind.top/9H9egb.png#alt=)
  7. > ![](https://blog.chasingwind.top/tK5Xel.png#alt=)
  9. > 定义通用返回实体类
  11. > ![](https://blog.chasingwind.top/VqXLtF.png#alt=)
  15.    3. 
  16. 创建Dao接口
  17. > ![](https://blog.chasingwind.top/fuJB5z.png#alt=fuJB5z)
  21.    4. 
  22. 创建Dao映射文件xml文件
  23. > 注意需要和配置文件中的路径对应
  25. > ![](https://blog.chasingwind.top/syGddS.png#alt=)
  29.    5. 
  30. Service层
  31. > ![](https://blog.chasingwind.top/8dmFag.png#alt=)
  35.    6. 
  36. Controller层
  37. > ![](https://blog.chasingwind.top/MagdNB.png#alt=)
  41.    7. 
  42. 启动测试
  43. > 直接运行模块的SpringBoot启动类启动
  45. > create
  47. > ![](https://blog.chasingwind.top/1VfLYH.png#alt=)
  49. > getById
  51. > ![](https://blog.chasingwind.top/lY3vRg.png#alt=)
  56. <a name="7c759483"></a>
  57. ### 客户端消费者模块
  59. - 
  60. 客户端只需要调用服务端的功能即可，所以只需要实现Controller
  62. - 
  63. 建立Module
  64. > ![](https://blog.chasingwind.top/bDZJtX.png#alt=)
  68. - 
  69. 修改pom文件
  70. ```xml
  72.     <dependencies>
  73.         <dependency>
  74.             <groupId>org.springframework.boot</groupId>
  75.             <artifactId>spring-boot-starter-web</artifactId>
  76.         </dependency>
  77.         <dependency>
  78.             <groupId>org.springframework.boot</groupId>
  79.             <artifactId>spring-boot-starter-actuator</artifactId>
  80.         </dependency>
  82.         <dependency>
  83.             <groupId>org.springframework.boot</groupId>
  84.             <artifactId>spring-boot-devtools</artifactId>
  85.             <scope>runtime</scope>
  86.             <optional>true</optional>
  87.         </dependency>
  88.         <dependency>
  89.             <groupId>org.projectlombok</groupId>
  90.             <artifactId>lombok</artifactId>
  91.             <optional>true</optional>
  92.         </dependency>
  93.         <dependency>
  94.             <groupId>org.springframework.boot</groupId>
  95.             <artifactId>spring-boot-starter-test</artifactId>
  96.             <scope>test</scope>
  97.         </dependency>
  98.     </dependencies>
  • 编写配置文件

    可以通过HTTP地址（即常说的“网址”）加“: 80”来访问网站，因为浏览网页服务默认的端口号都是80，因此只需输入网址即可，不用输入“: 80”了。

工程搭建 - 图16

  • 编写模块主程序

    工程搭建 - 图17

  • 编写业务类

    1. 实体类

      工程搭建 - 图18

  1. Controller层实现调用微服务模块—RestTemplate

    • 客户端要调用微服务提供者，由于是两个模块。客户端并不能直接通过注入Bean的方式调用到微服务提供者。

    • 借助RestTemplate调用远程Http服务

    • RestTemplate提供了多种便捷访问远程Http服务的方法， 是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集

    • 官网API

    • 使用配置类将RestTemplate注入到IOC容器中

      工程搭建 - 图19

  1. 实现Controller层

    工程搭建 - 图20

  1. 测试

    工程搭建 - 图21

工程搭建 - 图22

工程重构

  • 上面的模块存在的问题

    entities中的实体类在两个模块中都存在，并且是一模一样的，这样会导致冗余

工程搭建 - 图23

  • 将各个模块中重复的部分提取出来，作为一个新的模块被其他模块引用

    1. 创建新模块

      工程搭建 - 图24

  1. 修改pom文件

    中间还可以引入各个模块通用的依赖，比如hutool工具包

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-devtools</artifactId>
  5.             <scope>runtime</scope>
  6.             <optional>true</optional>
  7.         </dependency>
  8.         <dependency>
  9.             <groupId>org.projectlombok</groupId>
  10.             <artifactId>lombok</artifactId>
  11.             <optional>true</optional>
  12.         </dependency>
  13.         <dependency>
  14.             <groupId>cn.hutool</groupId>
  15.             <artifactId>hutool-all</artifactId>
  16.             <version>5.1.0</version>
  17.         </dependency>
  18.     </dependencies>

  1. 由于此模块是被其他模块进行引用，所以不需要配置文件和主程序类

  2. 将各个模块重复的部分放到此模块中

    工程搭建 - 图25

  1. Maven clean install确保可以正常打包

  2. 微服务提供者和客户端进行引入

    在各自模块中引入公共模块，然后删除各自模块中的entities包

  1.         <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
  2.         <dependency>
  3.             <groupId>top.chasingwind</groupId>
  4.             <artifactId>cloud-api-commons</artifactId>
  5.             <version>${project.version}</version>
  6.         </dependency>

工程搭建 - 图26

  1. 测试

    正常使用

工程搭建 - 图27