springCloud学习之使用springBoot搭建父子工程(Rest微服务)

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了springCloud学习之使用springBoot搭建父子工程(Rest微服务)，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含17744字，纯文字阅读大概需要26分钟。

内容图文

前言

在学习微服务之前，我们需要搭建一个父子结构的项目，实现一个公共的API项目子项目、接口生产者子项目、接口消费者子项目。

说明

工具：IDEA 2020.3
父项目名：microservicecloud
api子项目名：microservicecloud-api
provider(生产者)子项目名：microservicecloud-provider-dept-8001

搭建步骤

一.新建父项目(microservicecloud)

1. 点击选择File – New – Project
   
2. 选择Maven – 取消create from archetype – 点击下一步
   
3. 正确填写项目信息后，点击Finish
   
4. 删除多余的文件，只保留pom.xml文件
   
5. 编辑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">
    <modelVersion>4.0.0</modelVersion>
	<!--  项目信息 -->
    <groupId>com.atguigu.springcloud</groupId>
    <artifactId>microservicecloud</artifactId>
    <version>0.0.1-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>

    <build>
        <finalName>microservicecloud</finalName>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <delimiters>
                        <delimit>$</delimit>
                    </delimiters>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

这样我们就完成了一个父工程的创建

二.新建子项目(microservicecloud-api)

1. 点击选择File – New – Project,这里和建立父项目时一样
2. 选择create from archetype – 选择quickstart – 点击Next
   
3. 填写相关的项目信息。与新建父亲工程一样，只是将microservicecloud项目名 改成 microservicecloud-api即可。
4. 点击finish后生成如下项目结构：
   
5. 编辑microservicecloud-api项目的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">
    <modelVersion>4.0.0</modelVersion>

    <parent><!-- 子类里面显示声明才能有明确的继承表现，无意外就是父类的默认版本否则自己定义 -->
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>microservicecloud</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <artifactId>microservicecloud-api</artifactId><!-- 当前Module我自己叫什么名字 -->

    <dependencies><!-- 当前Module需要用到的jar包，按自己需求添加，如果父类已经包含了，可以不用写版本号 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
<!--        <dependency>-->
<!--            <groupId>org.springframework.cloud</groupId>-->
<!--            <artifactId>spring-cloud-starter-feign</artifactId>-->
<!--        </dependency>-->
    </dependencies>
</project>

当我们成功创建一个子项目后，你会发现在父项目的pom.xml文件下面多了一个子项目的引入，如下：

三.新建子项目(microservicecloud-provider-dept-8001)

前几步和新建microservicecloud-api子项目一样，不熟悉的翻看上面。这里主要说明下主要配置文件的内容。

1.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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>microservicecloud</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>microservicecloud-provider-dept-8001</artifactId>
    <dependencies>
        <!-- 引入自己定义的api通用包，可以使用Dept部门Entity -->
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>microservicecloud-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-jetty</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>
</project>

这里需要注意以下以下代码，当我们需要在microservicecloud-provider-dept-8001引入microservicecloud-api里面的内容时，需要配置如下代码才能正确引入：

<dependency>
	<!-- 引入自己定义的api通用包，可以使用Dept部门Entity -->
    <groupId>com.atguigu.springcloud</groupId>
    <artifactId>microservicecloud-api</artifactId>
    <version>${project.version}</version>
</dependency>

2.mybatis整合：

因为我们是建立的一个生产者的子项目，所以我们需要将mybatis整合到子项目中。
在项目目录src.main.resources下面新建application.yml配置文件，内容如下：

server:
  port: 8001

mybatis:
  config-location: classpath:mybatis/mybatis.cfg.xml        # mybatis配置文件所在路径
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包
  mapper-locations:
    - classpath:mybatis/mapper/**/*.xml                       # mapper映射文件

spring:
  application:
    name: microservicecloud-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
    url: jdbc:mysql://localhost:3306/clouddb01              # 数据库名称
    username: root
    password: root
    dbcp2:
      min-idle: 5                                           # 数据库连接池的最小维持连接数
      initial-size: 5                                       # 初始化连接数
      max-total: 5                                          # 最大连接数
      max-wait-millis: 200                                  # 等待连接获取的最大超时时间

这里需要注意的是，首先你需要有一个可连接的mysql数据库(不管是本地安装的mysql或者是其他来源服务器)，其次是配置mybatis时在resources/mybatis/mybatis.cfg.xml路径下需要有一个mybatis的配置文件mybatis.cfg.xml(可选配置，如果不添加信息在application.yml下面将这个配置去掉)
mybatis.cfg.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="cacheEnabled" value="true" /><!-- 二级缓存开启 -->
	</settings>
</configuration>

3.编写项目启动类：

springBoot需要配置一个项目的启动类DeptProvider8001_App(名称随意)：

package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

完成以上的配置后，我们已经成功的实现了springBoot和mybatis的整合，下面我们可以编写一些简单的API来测试以下是否配置成功。

4.编写测试代码

建立数据库表(脚本)：

DROP DATABASE IF EXISTS cloudDB01;
CREATE DATABASE cloudDB01 CHARACTERSET UTF8;
USE cloudDB01;
CREATE TABLE dept(
  deptno BIGINT NOT NULL PRIMARYKEY AUTO_INCREMENT,
  dname VARCHAR(60),
  db_source   VARCHAR(60)
);
INSERT INTO dept(dname,db_source) VALUES('开发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE());
SELECT * FROM dept;

上面的脚本是为了新建一个cloudDB01的数据库，同时在数据库中新建一个dept表并插入数据，效果如下图：

编写简单的测试文件：

Dept .java
这里使用了一个公共的Dept.java这个文件我是编写在公共子项目microservicecloud-api中，其他的均写在microservicecloud-provider-dept-8001下

package com.atguigu.springcloud.entities;

import java.io.Serializable;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

// 空参构造函数
@NoArgsConstructor
// 全参数构造函数
//@AllArgsConstructor
// getter setter toString
@Data
//开启链式风格访问
@Accessors(chain=true)
public class Dept implements Serializable// entity --orm--- db_table
{
    private Long 	deptno; // 主键
    private String 	dname; // 部门名称
    private String 	db_source;// 来自那个数据库，因为微服务架构可以一个服务对应一个数据库，同一个信息被存储到不同数据库
    public Dept(String dname) {
        this.dname = dname;
    }
}

DeptMapper.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.atguigu.springcloud.dao.DeptDao">

	<select id="findById" resultType="Dept" parameterType="Long">
		select deptno,dname,db_source from dept where deptno=#{deptno};
	</select>
	<select id="findAll" resultType="Dept">
		select deptno,dname,db_source from dept;
	</select>
	<insert id="addDept" parameterType="Dept">
		INSERT INTO dept(dname,db_source) VALUES(#{dname},DATABASE());
	</insert>
</mapper>

DeptDao.java

package com.atguigu.springcloud.dao;
import com.atguigu.springcloud.entities.Dept;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;

@Mapper
public interface DeptDao {
    boolean addDept(Dept dept);

    Dept findById(Long id);

    List<Dept> findAll();
}

这里需要注意一下，一定不要忘记注解@Mapper

DeptService.jave

package com.atguigu.springcloud.service;
import com.atguigu.springcloud.entities.Dept;
import java.util.List;

public interface DeptService {
    boolean add(Dept dept);
    Dept get(Long id);
    List<Dept> list();
}

DeptServiceImpl.java

package com.atguigu.springcloud.service.impl;
import com.atguigu.springcloud.entities.Dept;
import com.atguigu.springcloud.dao.DeptDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.atguigu.springcloud.service.DeptService;
import java.util.List;

@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptDao deptDao;

    @Override
    public boolean add(Dept dept) {
        return deptDao.addDept(dept);
    }

    @Override
    public Dept get(Long id) {
        return deptDao.findById(id);
    }

    @Override
    public List<Dept> list() {
        List<Dept> reList = deptDao.findAll();
        return reList;
    }
}

这里需要注意一下，一定不要忘记注解@Service

DeptController.java

package com.atguigu.springcloud.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.atguigu.springcloud.entities.Dept;
import com.atguigu.springcloud.service.DeptService;

@RestController
public class DeptController {

	@Autowired
	private DeptService service;

	@RequestMapping(value = "/dept/add", method = RequestMethod.POST)
	public boolean add(@RequestBody Dept dept) {
		return service.add(dept);
	}

	@RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)
	public Dept get(@PathVariable("id") Long id) {
		return service.get(id);
	}

	@RequestMapping(value = "/dept/list", method = RequestMethod.GET)
	public List<Dept> list() {
		return service.list();
	}
}

这样我们就完成了测试代码的编写，得到以下目录结构：

4.测试结果

当我们做完以上的操作后，我们可以测试以下代码了，通过DeptProvider8001_App.java启动类启动项目(不清楚springBoot如何启动的同学去百度查以下，这里就不做描述了)，以下启动完成：

浏览器访问接口请求地址，返回结果集：

这样我们就完成了mybatis的整合和测试。

5.踩过的坑

有些同学发现查询出来的数据可能存在中文乱码，这是因为mysql数据库的编码设置得不对，统一采用utf8来存储数据。查看mysql数据库的编码，修改数据库编码即可。
如何修改mysql默认编码可参考另一篇博文：https://blog.csdn.net/qq_33631756/article/details/116118366

四.新建子项目(microservicecloud-consumer-dept-80)

前几步和新建microservicecloud-provider-dept-8001子项目一样，这里介绍下配置文件内容即可

1.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">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.atguigu.springcloud</groupId>
    <artifactId>microservicecloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>

  <artifactId>microservicecloud-consumer-dept-80</artifactId>
  <description>部门微服务消费者</description>

  <dependencies>
    <dependency><!-- 自己定义的api -->
      <groupId>com.atguigu.springcloud</groupId>
      <artifactId>microservicecloud-api</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 修改后立即生效，热部署 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>springloaded</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
    </dependency>
  </dependencies>
</project>

主要引入了microservicecloud-api和spring-boot-starter-web(作为消费者引入web)

2.application.yml配置文件

和生产者子项目一样，我们先新建一个application.yml文件，然后编辑以下内容：

server:
  port: 80

2.定义configBean.java

在com.atguigu.springcloud包路径下新建cfgbeans包，然后在cfgbeans包里面新建一个configBean.java文件，编辑configBean.java文件内容：

package com.atguigu.springcloud.cfgbeans;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
//boot -->spring   applicationContext.xml --- @Configuration配置   ConfigBean = applicationContext.xml
@Configuration
public class configBean {
    @Bean
    public RestTemplate getRestTemplate()
    {
        return new RestTemplate();
    }
}

说明：
在springBoot中java类添加注解@Configuration表示这个文件是spring的一个bean对象配置文件，作用和springMVC里面的applicationContext.xml配置文件一样的，主要是对bean对象的配置注入。
以上例子我们就是对RestTemplate对象进行了一个注入(RestTemplate类似于JDBCTemplate一样，里面基于HttpClient封装了简单的rest请求api，可以直接模仿浏览器发送rest请求)，作为一个消费端我们主要就是对生产者暴露的接口进行调用。

3.编写项目启动类：

新建一个消费者项目启动类DeptConsumer80_App

package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

4.编写测试代码

编写一个controller文件，使用RestTemplate对microservicecloud-provider-dept-8001(生产者)提供的接口进行调用，获取数据库数据。

package com.atguigu.springcloud.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import com.atguigu.springcloud.entities.Dept;

@RestController
public class DeptController_Consumer
{
	private static final String REST_URL_PREFIX = "http://localhost:8001";

	/**
	 * 使用 使用restTemplate访问restful接口非常的简单粗暴无脑。 (url, requestMap,
	 * ResponseBean.class)这三个参数分别代表 REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。
	 */
	@Autowired
	private RestTemplate restTemplate;

	@RequestMapping(value = "/consumer/dept/add")
	public boolean add(Dept dept)
	{
		return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
	}

	@RequestMapping(value = "/consumer/dept/get/{id}")
	public Dept get(@PathVariable("id") Long id)
	{
		return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
	}

	@RequestMapping(value = "/consumer/dept/list")
	public List<Dept> list()
	{
		return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
	}
}

5.测试结果

最后我们启动microservicecloud-provider-dept-8001(生产者)子项目和我们的microservicecloud-consumer-dept-80(消费者)子项目，浏览器访问消费者rest请求：
http://localhost/consumer/dept/list

如图所示，表示我们成功的通过microservicecloud-consumer-dept-80调用microservicecloud-provider-dept-8001获取到了数据库的部门数据。
至此我们就完成了父子结构项目的搭建，并实现一个公共的API项目子项目、接口生产者子项目、接口消费者子项目之间的调用。

内容总结

以上是互联网集市为您收集整理的springCloud学习之使用springBoot搭建父子工程(Rest微服务)全部内容，希望文章能够帮你解决springCloud学习之使用springBoot搭建父子工程(Rest微服务)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

---