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

最新推荐文章于 2024-05-20 11:41:11 发布

啊嘞嘞嘞嘞

最新推荐文章于 2024-05-20 11:41:11 发布

阅读量9.5k

点赞数 2

分类专栏： JAVA 文章标签： springcloud

本文链接：https://blog.csdn.net/weixin_40902527/article/details/88895793

版权

JAVA 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

搭建项目环境

ide：idea

jdk：jdk1.8

操作系统：mac

工程目录

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

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

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

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>
            <!-- 定义 spring cloud 版本 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- 定义 spring boot 版本 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- 定义 mysql 版本 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!-- 定义 mybatis 版本 -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <!-- 定义 lombok 版本 -->
            <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

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

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>microservice</artifactId>
        <groupId>com.demo</groupId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../microservice/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microservice-common</artifactId>
    <packaging>jar</packaging>


    <!-- 当前Module需要用到的依赖，按自己需求添加，版本号在父类已经定义了，这里不需要再次定义 -->
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>


</project>

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一下

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

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

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

1.在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>microservice</artifactId>
        <groupId>com.demo</groupId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../microservice/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microservice-provider</artifactId>
    <packaging>jar</packaging>

    <!-- 当前Module需要用到的依赖，按自己需求添加，版本号在父类已经定义了，这里不需要再次定义 -->
    <dependencies>
        <!-- 引入自己定义的 microservice-common 通用包，可以使用common模块中的TOrder类 -->
        <dependency>
            <groupId>com.demo</groupId>
            <artifactId>microservice-common</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- spring boot web 依赖 -->
        <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>
        <!-- mybatis 依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!-- mysql 依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

</project>

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

数据库结构：

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

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

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

1.在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>microservice</artifactId>
        <groupId>com.demo</groupId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../microservice/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microservice-consumer</artifactId>
    <packaging>jar</packaging>

    <!-- 当前Module需要用到的依赖，按自己需求添加，版本号在父类已经定义了，这里不需要再次定义 -->
    <dependencies>
        <!-- 引入自己定义的 microservice-common 通用包，可以使用common模块中的Order类 -->
        <dependency>
            <groupId>com.demo</groupId>
            <artifactId>microservice-common</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- spring boot web 依赖 -->
        <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>
    </dependencies>
</project>

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

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

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

总结流程

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

代码地址：https://github.com/zhangti0708/microservice

啊嘞嘞嘞嘞

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
[java] Spring Cloud学习（二）使用maven搭建spring cloud项目

搭建项目环境ide：ideajdk：jdk1.8操作系统：mac工程目录创建父工程（其他模块都魏父工程的子模块）1.新建一个空工程:File -> New -> New Project2.创建完成有弹出框新建modules，点击 + 号，新建一个父工程，也就是一个父 module。然后我们选择 maven 工程，选择 jdk 版本和模板，...
复制链接

扫一扫