[java] Spring Cloud学习（二）使用maven搭建spring cloud项目

忘是亡心i 2022-02-26 10:42 472阅读 0赞

### 搭建项目环境 ###

ide：idea

jdk：jdk1.8

操作系统：mac

工程目录

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkwMjUyNw_size_16_color_FFFFFF_t_70][]

### 创建父工程（其他模块都为父工程的子模块） ###

1.新建一个空工程: File -> New -> New Project

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkwMjUyNw_size_16_color_FFFFFF_t_70 1][]

2.创建完成有弹出框 新建modules，点击 + 号，新建一个父工程，也就是一个父 module。然后我们选择 maven 工程，选择 jdk 版本和模板，模板也可以不选择，我这里就没有选择，自己搭建即可。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkwMjUyNw_size_16_color_FFFFFF_t_70 2][]

4. 在pom文件中设置spring boot的parent

<?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.demo</groupId>
        <artifactId>microservice</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>pom</packaging>
    
        <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>
            <spring-cloud.version>Edgware.SR1</spring-cloud.version>
            <spring-boot.version>1.5.10.RELEASE</spring-boot.version>
            <mysql.version>5.1.46</mysql.version>
            <mybatis.version>1.3.2</mybatis.version>
            <lombok.version>1.16.18</lombok.version>
        </properties>
        <dependencyManagement>
            <dependencies>
                
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>${spring-boot.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>org.mybatis.spring.boot</groupId>
                    <artifactId>mybatis-spring-boot-starter</artifactId>
                    <version>${mybatis.version}</version>
                </dependency>
                
                <dependency>
                    <groupId>org.projectlombok</groupId>
                    <artifactId>lombok</artifactId>
                    <version>${lombok.version}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>

父工程配置完了，子模块可以直接通过<parent>标签引用父工程的依赖包

### 创建microservice-common模块（公共模块）供其子模块调用 ###

1.在父工程中添加common子模块，右键microservice - new - module

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkwMjUyNw_size_16_color_FFFFFF_t_70 3][]

创建步骤和上面的一样，项目名：microservice-common

2.在pom中添加依赖包

3. 在scr/main/java/下创建实体类，添加公共实体类供其他服务调用

package com.demo.springcloud.entity;
    
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.experimental.Accessors;
    
    /**
     * 订单实体
     *@AllArgsConstructor 注解：表示生成带有所有属性的构造方法
     *@NoArgsConstructor 注解：表示生成不带参数的构方法
     *@Data 注解：表示生成get和set方法
     */
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    public class TOrder {
    
        /**
         * 主键id
         */
        private Long id;
    
        /**
         * 商品名称
         */
        private String name;
    
        /**
         * 商品价格
         */
        private Double price;
    
        /**
         * 所存的数据库名称
         */
        private String dbSource;
    }

4. 将common打包成jar文件，点击maven 分别 clean和 install一下

![20190329164215385.png][]

公共模块初步搭建完成，稍后测试一下～

### 创建服务提供者模块microservice-provider ###

创建服务提供者模块，添加方式和microservice-common一样。服务提供模块，主要负责在表中查询出订单信息，然后将信息通过接口提供给调用方，所以在该模块中，我们需要整合一下 mybatis

1.在pom文件中配置整合的依赖包

2.配置application.yml

# 服务端口号
    server:
      port: 8001
    
    # 数据库地址
    datasource:
      url: localhost:3306/demo
    
    spring:
      application:
        name: microservice-order # 对外暴露的服务名称
    
      datasource: # 数据库配置
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://${datasource.url}?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&autoReconnect=true&failOverReadOnly=false&maxReconnects=10
        username: root
        password: root
        hikari:
          maximum-pool-size: 10 # 最大连接池数
          max-lifetime: 1770000

3.创建数据持久层接口

public interface OrderMapper {
    
        @Select("select * from microservice where id = #{id}")
        TOrder findById(Long id);
    
        @Select("select * from microservice")
        List<TOrder> findAll();
    
    }

4.创建业务层接口以及实现类

//业务层接口
    public interface OrderService {
    
        TOrder findById(Long id);
    
        List<TOrder> findAll();
    }
    
    //接口实现类
    @Service
    public class OrderServiceImpl implements OrderService {
    
        @Resource
        private OrderMapper orderMapper;
    
        public TOrder findById(Long id) {
            return orderMapper.findById(id);
        }
    
        public List<TOrder> findAll() {
            return orderMapper.findAll();
        }
    }

5.创建服务控制层

@RestController
    @RequestMapping("/provider/order")
    public class OrderProviderController {
    
        @Resource
        private OrderService orderService;
    
        @GetMapping("/get/{id}")
        public TOrder getOrder(@PathVariable Long id) {
            return orderService.findById(id);
        }
    
        @GetMapping("/get/list")
        public List<TOrder> getAll() {
            return orderService.findAll();
        }
    }

6.创建服务启动类

@SpringBootApplication
    @MapperScan("com.itcodai.springcloud.dao")
    public class OrderProvider {
    
        public static void main(String[] args) {
            SpringApplication.run(OrderProvider.class, args);
        }
    }

数据库结构：

![20190329170326124.png][]

服务提供者模块搭建完了可以启动测试，浏览器输入：localhost:8001/provider/order/get/list

![20190329170446766.png][]

### 创建订单消费者模块microservice-consumer ###

新建子模块的方法和上面两个子 模块一模一样，在命名的时候命名为 `microservice-consumer` 即可。 microservice-consumer 模块主要是用来调用 microservice-provider模块提供的订单信息，所以在 microservice-consumer 模块中我们不需要引入 mybatis 和 mysql 相关的依赖

1.在pom文件配置依赖包

2.创建RestTmplate类。在微服务都是以 HTTP 接口的形式暴露自身服务的，因此在调用远程服务时就必须使用 HTTP 客户端。Spring Boot 中使用的是 RestTemplate，首先，我们写一个配置类，将 RestTemplate 作为一个 Bean 交给 Spring 来管理

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

3.有了RestTmplate，接下来我们可以在 Controller 中注入该 RestTemplate 来调用 `microservice-provider`提供的服务了

//@RestController 相当于Controller注释加ResponesBody注释
    @RestController
    @RequestMapping("/consumer/order")
    public class OrderConsumerController {
    
        // 订单服务提供者模块的 url 前缀
        private static final String ORDER_PROVIDER_URL_PREFIX = "http://localhost:8001";
    
        @Resource
        private RestTemplate restTemplate;
    
        @GetMapping("/get/{id}")
        public TOrder getOrder(@PathVariable Long id) {
    
            return restTemplate.getForObject(ORDER_PROVIDER_URL_PREFIX + "/provider/order/get/" + id, TOrder.class);
        }
    
        @GetMapping("/get/list")
        public List<TOrder> getAll() {
            return restTemplate.getForObject(ORDER_PROVIDER_URL_PREFIX + "/provider/order/get/list", List.class);
        }
    }

订单消费者模块搭建完了可以启动测试一下

浏览器访问：http://localhost:8080/consumer/order/get/list

返回结果，说明服务调用成功

![20190329171440613.png][]

可以看到通过订单消费者调用服务提供者暴露的服务，实现了每个服务专注于自身的逻辑，服务之间解耦合。

总结流程

订单消费模块不直接请求数据库，而是通过 http 远程调用订单提供模块的服务来获取订单信息。也就是说，在微服务里，每个服务只关注自身的逻辑和实现，不用管其他服务的实现，需要获取某个服务的数据时，只要调用该服务提供的接口即可获取相应的数据。实现了每个服务专注于自身的逻辑，服务之间解耦合。

代码地址：[https://github.com/zhangti0708/microservice][https_github.com_zhangti0708_microservice]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkwMjUyNw_size_16_color_FFFFFF_t_70]: /images/20220226/0b4a9e53f86a48edb2f4135cacd899ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkwMjUyNw_size_16_color_FFFFFF_t_70 1]: /images/20220226/030589129ac84453a0a84f77f58a5319.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkwMjUyNw_size_16_color_FFFFFF_t_70 2]: /images/20220226/77eec67339dd4d3a87d9ac812b69f8cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkwMjUyNw_size_16_color_FFFFFF_t_70 3]: /images/20220226/36143906e5784f508e812077c6a68ae5.png
[20190329164215385.png]: /images/20220226/5931f8792a9f4896b9d5eee0f339982b.png
[20190329170326124.png]: /images/20220226/d8a815ea2e59457980afff627d946bb4.png
[20190329170446766.png]: /images/20220226/c50106a1260042f7beb3abd58db9ee5b.png
[20190329171440613.png]: /images/20220226/5831153d17794850a68c7bcabb49bbdd.png
[https_github.com_zhangti0708_microservice]: https://github.com/zhangti0708/microservice