SpringCloud从零开始（二）maven的分布式项目框架的搭建

川长思鸟来 2021-11-19 13:38 333阅读 0赞

#### 一、项目搭建 ####

maven分布式项目的基本架构

> \----microservice(父工程)  
> \--------microservice\_api  
> \--------microservice\_product\_provider8001  
> \--------microservice\_product\_provider80

其中`microservice`为父工程，用来管理整个项目的依赖。`microservice_api`这个是各种模块公用的部分，其中可以放置如：工具类，实体类。`microservice_product_provider8001`为服务的提供者。`microservice_product_provider80`这个模块为服务的消费者。他们的父子关系通过父工程`microservice`的`pom.xml`文件来体现。

#### 二、创建microservice(父工程) ####

打开IDEA File >new>project>  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70]  
不用选择模板，点击next。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 1]  
输入GroupId和ArtifactId 。输入完成之后点击next. 再点击finish，他会让你选择是否在当前窗口创建。  
![在这里插入图片描述][2019072718582650.png]  
选择This Window。这样等待一下，工程就创建出来了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 2]  
因为这个是父工程，不用存储任何代码，只用于管理依赖，所以这个工程的`src`文件夹可以直接删除。另外需要注意的是。创建出来的工程默认打包方式是`jar`我们需手动添加`<packaging>pom</packaging>`。如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 3]  
接下里要做的就是管理相关依赖，定义版本。当父工程规定了相关依赖的版本之后，它的子工程引入相同的依赖的好后，就无序定义版本了，因为父工程已经定义好了

<?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.kuke</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>
            <junit.version>4.12</junit.version>
            <log4j.version>1.2.17</log4j.version>
            <lombok.version>1.16.18</lombok.version>
        </properties>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Dalston.SR1</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>1.5.9.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>5.0.4</version>
                </dependency>
                <dependency>
                    <groupId>com.alibaba</groupId>
                    <artifactId>druid</artifactId>
                    <version>1.0.31</version>
                </dependency>
                <dependency>
                    <groupId>org.mybatis.spring.boot</groupId>
                    <artifactId>mybatis-spring-boot-starter</artifactId>
                    <version>1.3.0</version>
                </dependency>
                <dependency>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-core</artifactId>
                    <version>1.2.3</version>
                </dependency>
                <dependency>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                    <version>${junit.version}</version>
                    <scope>test</scope>
                </dependency>
                <dependency>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                    <version>${log4j.version}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
    </project>

### 三、创建子工程microservice\_api ###

点击我们刚刚创建好的父工程microservice 右键>new>Model  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 4]  
同样选择next,输入版本号  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 5]  
因为是子模块，所以GroupId已经确定了。点击netxt后，再点击finsh。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 6]  
我们发现在父工程下面就多了一个子模块，`microservice_api`,并且在父工程的pom文件当中，该模块已经被父工程管理了。（见上图）  
现在开始添加与`microservice_api`相关的依赖，（该模块是提供，所有公共模块的所需要的：如实体类，工具类）

在该模块下创建实体类`Product`

@NoArgsConstructor//无参构造
    @Data//get set方法
    @Accessors(chain=true)
    public class Product { 
        private long pid;//商品的id
        private String pName;//商品的名称
        private String dbSource;//商品所在的数据库
        public Product(String pName) { 
            this.pName = pName;
        }
    }

创建完成之后，将其打成`jar`放在本地仓库中，供其他模块引用。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 7]  
执行install命令。当控制台输出下面的信息，也就算是构建成功了

[INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 11.907 s
    [INFO] Finished at: 2019-07-27T19:33:45+08:00
    [INFO] Final Memory: 21M/251M
    [INFO] ------------------------------------------------------------------------

### 四、创建工程microservice\_product\_provider8001 ###

这个工程是服务的提供者，也是创建一个子模块如同创建`microservice_api`模块一样，这里步骤就省略…创建完成之后如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 8]  
同样导入`microservice_product_provider8001`相关依赖所需要的依赖

<dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-config</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
            </dependency>
            <dependency>
                <groupId>com.kuake</groupId>
                <artifactId>microcloudservice-api</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>springloaded</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
            </dependency>
        </dependencies>

**该工程的目录结构如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 9]  
添加该服务提供者的配置文件`application.yml`

spring:
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource #使用druid数据源
        driver-class-name: com.mysql.jdbc.Driver
        username: root
        password: root
        url: jdbc:mysql://localhost:3306/springcloud001
      # 数据源其他配置
        initialSize: 5
        minIdle: 5
        maxActive: 20
        maxWait: 60000
        timeBetweenEvictionRunsMillis: 60000
      application:
        name: microservice-product-provider8001
    server:
      port: 8001
    mybatis:        #mybatis基本的配置
      config-location: classpath:mybatis/mybatis-config.xml
      mapper-locations:
        - classpath:mybatis/mapper/ProductMapper.xml

添加配置文件`mybatis-config.xml`

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <settings>
            
            <setting name="mapUnderscoreToCamelCase" value="true"/>
        </settings>
    </configuration>

添加配置文件`ProductMapper.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.kuake.dao.ProductMapper">
        <select id="findById" resultType="com.kuake.entity.Product" parameterType="long">
            select * from tb_product where pid = #{id}
        </select>
        <select id="findAll" resultType="com.kuake.entity.Product">
            SELECT * FROM tb_product
        </select>
        <insert id="add" parameterType="com.kuake.entity.Product">
            INSERT  INTO tb_product(p_name, db_source) VALUES (#{pName},DATABASE())
        </insert>
    </mapper>

`Controller`如下：

@RestController
    public class ProductController { 
        @Autowired
        private ProductService productService;
    
        @GetMapping("/product/list")
        public List<Product> list(){ 
            return productService.list();
        }
    
        @GetMapping("/product/{id}")
        public Product get(@PathVariable Long id){ 
            return productService.get(id);
        }
    
        @PostMapping("/product")
        public boolean add(@RequestBody Product product){ 
            return  productService.add(product);
        }
    }

编写主启动类`Provider8001Application`

@MapperScan(basePackages = { "com.kuake.dao"}) //扫描mapper接口
    @SpringBootApplication
    public class Provider8001Application { 
        public static void main(String[] args) { 
            SpringApplication.run(Provider8001Application.class,args);
        }
    }

浏览器输入`http://localhost:8001/product/list`返回结果

[{"pid":1,"dbSource":"springcloud001","pname":"舒肤佳"},{"pid":2,"dbSource":"springcloud001","pname":"可口可乐"},{"pid":3,"dbSource":"springcloud001","pname":"百事可乐"},{"pid":4,"dbSource":"springcloud001","pname":"冰箱"},{"pid":5,"dbSource":"springcloud001","pname":"电视"},{"pid":6,"dbSource":"springcloud001","pname":"苹果"}]

说明服务的提供者，提供服务，现在编写服务的消费者，来消费这个服务。

### 五、创建工程创建工程microservice\_product\_consumer80 ###

这是服务的消费者，创建过程省略…  
添加`pom.xml`依赖。

配置`application.yml`

server:
      port: 80

创建消费者的`Controller`

@RestController
    public class ConsumerController { 
        private  static  final String REST_URL_PREFIX = "http://localhost:8001/";
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/consumer/product/list")
        public List<Product> list(){ 
            return restTemplate.getForObject(REST_URL_PREFIX+"product/list",List.class);
        }
    
        @GetMapping("/consumer/product/{id}")
        public Product get(@PathVariable Long id){ 
            return restTemplate.getForObject(REST_URL_PREFIX+"product/"+id,Product.class);
        }
    
        @RequestMapping("/consumer/product")
        public boolean add(Product Product){ 
            return restTemplate.postForObject(REST_URL_PREFIX+"/product",Product,Boolean.class);
        }
    }

我们通过`RestTemplate`来进行服务调用，这是`spring`提供给我们，基于Rest服务调用的一个模板方法，内部封装了大量方法。在使用之前我们先得创建一个，并注入到容器当中，代码如下：

@Configuration//标注这是一个配置类
    public class MyConfig { 
        @Bean
        public RestTemplate restTemplate(){ 
            return new RestTemplate();
        }
    }

创建消费者的启动类`Consumer80Application`

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

保持服务提供者`microservice_product_consumer80`开启状态，启动服务的消费者`microservice_product_consumer80`模块。模块启动成功之后  
浏览器输入请求`http://localhost/consumer/product/list`（默认就是80端口）

数据正常返回了。这样我们分布式的初步框架就搭建好啦。我们就创建了两个服务，一个服务的提供者，一个服务的消费者。消费者通过RestTemplate调用服务提供者的服务。关系图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 10]  
虽然这样实现基于rest的远程调用，但是这里有一个弊端，就是微服务都是游离状态并没有人能管理。现在就需要一个服务的管家，当我需要服务的时候只需要问这个管家“有我需要的服务嘛”？，这样就简化了服务的发现过程。  
那么这个管家springcloud有没有向我们提供呢？下一篇连载，将会揭晓答案。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70]: /images/20211119/929fd202ff3443a599308d83f6b01c96.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 1]: /images/20211119/a8d675c4696d45de9d8f8551d7afaedb.png
[2019072718582650.png]: /images/20211119/92a60d3b7f444f02a05917a7c04bf0d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 2]: /images/20211119/fc12ddadc4eb4d6fbe6a11ca192583f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 3]: /images/20211119/dd26947284ed41e79a62a25149a6ce04.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 4]: /images/20211119/2703fe8b7050474fb3f34050a3ba899d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 5]: /images/20211119/9296a777320d43b696d684685f50b813.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 6]: /images/20211119/53f6126306f748ddbe085842293d23fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 7]: /images/20211119/db320f33f042420ea9567c375cb31d56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 8]: /images/20211119/88c4bd81dc604dedbed3767a1e200459.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 9]: /images/20211119/0835f9e7385d4c3a8419840ecb65aae3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczMjk1NQ_size_16_color_FFFFFF_t_70 10]: /images/20211119/7a625c3c29774b1abed71e1a64d03613.png