SpringCloud学习记录(1)-父工程与子模块创建及子模块调用

创建父工程，导入依赖

选择创建maven工程，步骤如下：

修改父工程的pom.xml，具体如下：

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0modelVersion>

  <groupId>com.atguigu.springcloudgroupId>
  <artifactId>cloud2020artifactId>
  <version>1.0-SNAPSHOTversion>
  <packaging>pompackaging>

  <modules>
    <module>cloud-provider-payment8001module>
      <module>cloud-consumer-order80module>
  modules>

  
  <properties>
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    <maven.compiler.source>1.8maven.compiler.source>
    <maven.compiler.target>1.8maven.compiler.target>
    <junit.version>4.12junit.version>
    <log4j.version>1.2.17log4j.version>
    <lombok.version>1.16.18lombok.version>
    <mysql.version>8.0.16mysql.version>
    <druid.version>1.1.16druid.version>
    <mybatis.spring.boot.version>1.3.0mybatis.spring.boot.version>
  properties>

  
  <dependencyManagement>
    <dependencies>
      
      <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-dependenciesartifactId>
        <version>2.2.2.RELEASEversion>
        <type>pomtype>
        <scope>importscope>
      dependency>
      
      <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-dependenciesartifactId>
        <version>Hoxton.SR1version>
        <type>pomtype>
        <scope>importscope>
      dependency>
      
      <dependency>
        <groupId>com.alibaba.cloudgroupId>
        <artifactId>spring-cloud-alibaba-dependenciesartifactId>
        <version>2.1.0.RELEASEversion>
        <type>pomtype>
        <scope>importscope>
      dependency>

      <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>${mysql.version}version>
      dependency>
      <dependency>
        <groupId>com.alibabagroupId>
        <artifactId>druidartifactId>
        <version>${druid.version}version>
      dependency>
      <dependency>
        <groupId>org.mybatis.spring.bootgroupId>
        <artifactId>mybatis-spring-boot-starterartifactId>
        <version>${mybatis.spring.boot.version}version>
      dependency>
      <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>${junit.version}version>
      dependency>
      <dependency>
        <groupId>log4jgroupId>
        <artifactId>log4jartifactId>
        <version>${log4j.version}version>
      dependency>
      <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <version>${lombok.version}version>
        <optional>trueoptional>
      dependency>
    dependencies>
  dependencyManagement>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-maven-pluginartifactId>
        <configuration>
          <fork>truefork>
          <addResources>trueaddResources>
        configuration>
      plugin>
    plugins>
  build>

project>

• 关于SpringCloud版本问题，根据官方文档推荐，SpringCloud H版，SpringBoot 2.2.2.RELEASE，其他依赖例如MySQL请根据自己需要，导入合适的

创建支付子Module，配置pom.xml，创建yml，修改配置

创建module步骤，后不再重复

导入pom.xml配置依赖

<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>cloud2020artifactId>
        <groupId>com.atguigu.springcloudgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>cloud-provider-payment8001artifactId>


    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>

        
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
        dependency>

        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druid-spring-boot-starterartifactId>
            <version>1.1.16version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>

        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>


    dependencies>

project>

• 注：关于子工程的依赖版本问题，项目运行中，会先解析父工程的pom.xml，读取中的依赖版本，然后再解析子工程的pom.xml，如果子工程的有写，就按父工程的依赖版本，如果有写，则按子工程所写的版本

创建yml配置文件，添加配置

• 在resources目录下创建application.yml文件，修改配置，数据库连接请按自己需要修改，热部署开启方法自行百度，目前使用的是实体类，后看能否使用Map代替实体类，请注意关注版本更新

  server:
    port: 8001
  
  spring:
    application:
      name: cloud-payment-service
    devtools:
      restart:
        enabled: true
    datasource:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/cloudtest?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: jy20wyx.
  
  mybatis:
    mapperLocations: classpath:mapper/*.xml
    type-aliases-package: com.atguigu.springcloud.entities
  

创建业务类类

• 完成创建后，工程目录

• 创建主启动类

  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, args);
      }
  }
  

• 创建Payment实体类，其中@AllArgsConstructor为引入全参构造，@NoArgsConstructor为无参构造，@Date为引入get/set/toString等方法

  package com.atguigu.springcloud.domain;
  
  import lombok.AllArgsConstructor;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  
  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class Payment {
      private Long id;
      private String serial;
  }
  

• 创建CommonResult类，其中，code为返回的状态，200 – 成功，444 – 失败，与前端开发人员约定，message为返回前端信息，data为返回数据

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

• 在resources目录下创建mapper文件夹，在文件夹里创建paymentMapper.xml，具体类位置等信息请按自己实际情况来

  
  
  
  <mapper namespace="com.atguigu.springcloud.mapper.PaymentMapper">
  
  
      <insert id="create" parameterType="com.atguigu.springcloud.domain.Payment" useGeneratedKeys="true" keyProperty="id">
              insert into payment(serial) values(${serial});
  
      insert>
  
      <resultMap id="BaseResultMap" type="com.atguigu.springcloud.domain.Payment">
          <id column="id" property="id" jdbcType="BIGINT">id>
          <id column="serial" property="serial" jdbcType="VARCHAR">id>
      resultMap>
      <select id="getPaymentById"  parameterType="Long" resultMap="BaseResultMap">
              select * from payment where id=#{id}
      select>
  
  mapper>
  

• 数据库创建，就一张表，表名payment，数据库名与yml文件连接名字一致

  

• 创建paymentMapper接口类

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

• 创建paymentService服务类接口以及其实体类paymentServiceImpl

  package com.atguigu.springcloud.service;
  
  import com.atguigu.springcloud.domain.Payment;
  
  public interface PaymentService {
      public int create(Payment payment);
  
      public Payment getPaymentById(Long id);
  
  }
  

  package com.atguigu.springcloud.service.impl;
  
  import com.atguigu.springcloud.domain.Payment;
  import com.atguigu.springcloud.mapper.PaymentMapper;
  import com.atguigu.springcloud.service.PaymentService;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  
  @Service
  public class PaymentServiceImpl implements PaymentService {
      @Autowired
      private PaymentMapper paymentMapper;
  
      @Override
      public int create(Payment payment) {
          return paymentMapper.create(payment);
      }
  
      @Override
      public Payment getPaymentById(Long id) {
          return paymentMapper.getPaymentById(id);
      }
  }
  

• 控制层paymentController创建

  package com.atguigu.springcloud.controller;
  
  import com.atguigu.springcloud.domain.CommonResult;
  import com.atguigu.springcloud.domain.Payment;
  import com.atguigu.springcloud.service.PaymentService;
  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.PostMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  @Slf4j
  @RestController
  public class PaymentController {
      @Autowired
      private PaymentService paymentService;
  
      @PostMapping("/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,"插入数据库失败!");
          }
      }
  
      @GetMapping("/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);
          }
      }
  }
  
  

创建订单子工程，用于调用支付子工程

• 同样操作建立cloud-consumer-order80子工程，因只做调用，所以只有控制层，其项目目录如下：
  

• pox.xml依赖

  
  <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>cloud2020artifactId>
          <groupId>com.atguigu.springcloudgroupId>
          <version>1.0-SNAPSHOTversion>
      parent>
      <modelVersion>4.0.0modelVersion>
  
      <artifactId>cloud-consumer-order80artifactId>
  
      <dependencies>
          
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>
  
          
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-actuatorartifactId>
          dependency>
  
          
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-devtoolsartifactId>
              <scope>runtimescope>
              <optional>trueoptional>
          dependency>
  
          
          <dependency>
              <groupId>org.projectlombokgroupId>
              <artifactId>lombokartifactId>
              <optional>trueoptional>
          dependency>
  
          
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-testartifactId>
              <scope>testscope>
          dependency>
      dependencies>
  
  project>
  

• ApplicationContextConfig类，传统情况下在java代码里访问restful服务，一般使用Apache的HttpClient。不过此种方法使用起来太过繁琐。spring提供了一种简单便捷的模板类来进行操作，这就是RestTemplate。

  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();
      }
  }
  

• 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();
      }
  }
  

• 将cloud-privoder-payment8001中的两个实体类复制到本子模块中

• 新建OrderController类，使用RestTemplate发送请求到8001端口，调用方法

  package com.atguigu.springcloud.controller;
  
  import com.atguigu.springcloud.domain.CommonResult;
  import com.atguigu.springcloud.domain.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;
  
  @RestController
  @Slf4j
  public class OrderController {
      public static final String PAYMENT_URL = "http://localhost:8001";
  
      @Autowired
      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) {
          log.info("id:"+id);
          return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id, CommonResult.class);
      }
  }
  

• 使用8001端口访问效果

• 使用80端口(自动隐藏)，端口访问

创建子Module，重构工程

• 观察项目结构，两个子Module有重复代码——domain实体类，所以需要整合到一个新的Module，在其他Module中使用pom.xml依赖直接引入，步骤如下（建Module步骤不重复）：

​ 项目结构

• 将CommonResult和Payment复制到此Module，在其他Module中删除domain包，进入Maven页，选择此Module，将其clean再install，再其余Module中的pom.xml中添加依赖，具体如下：

  <dependency>
      <groupId>com.atguigu.springcloudgroupId>
      <artifactId>cloud-api-commonsartifactId>
      <version>${project.version}version>
  dependency>
  

创建子Module，重构工程

• 观察项目结构，两个子Module有重复代码——domain实体类，所以需要整合到一个新的Module，在其他Module中使用pom.xml依赖直接引入，步骤如下（建Module步骤不重复）：

  ​ 项目结构

• 将CommonResult和Payment复制到此Module，在其他Module中删除domain包，进入Maven页，选择此Module，将其clean再install，再其余Module中的pom.xml中添加依赖，具体如下：

  <dependency>
      <groupId>com.atguigu.springcloudgroupId>
      <artifactId>cloud-api-commonsartifactId>
      <version>${project.version}version>
  dependency>
  

• 将项目重启即可