day02-搭建微服务基础环境01

搭建微服务基础环境01

1.创建父工程，用于聚合其他微服务模块

1.1创建父项目

说明：我们先创建一个父项目，该父项目会去管理多个微服务模块（module），如下：

（1）File-New-Project-Maven，选择如下：

（2）输入项目名称等信息，然后next

（3）选择Maven，然后Finish

1.2项目设置

（1）File-Settings-Editor-File Encodings，将编码改为UTF-8，点击Apply

（2）Settings-Build，Execution，Deployment-Compiler-Java Compiler，将项目的编译版本改为8，点击OK

（3）删除父项目的src目录

（4）配置父项目的pom.xml，配置各个依赖版本

<?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.li.springcloud</groupId>
  <artifactId>E-Commerce-Center</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--将packaging的值改为pom，表明是一个父工程，聚合管理其他模块-->
  <packaging>pom</packaging>

  <name>E-Commerce-Center</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <!--统一配置各个依赖版本-->
  <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 , 防止安全漏洞-->
    <log4j.version>2.17.2</log4j.version>
    <lombok.version>1.18.20</lombok.version>
    <mysql.version>5.1.47</mysql.version>
    <druid.version>1.1.17</druid.version>
    <mybatis.spring.boot.version>2.2.0</mybatis.spring.boot.version>
  </properties>

  <!--dependencyManagement 作用:子模块继承后,锁定版本,子模块不用再写version-->
  <dependencyManagement>
  <dependencies>

    <!--配置Spring-Boot的依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>2.2.2.RELEASE</version>
      <!--1.type：pom 和 scope import配合使用
          2.表示父项目的子模块，在引入springboot相关依赖时，锁定版本为2.2.2.RELEASE
          3.通过pom+import 解决 maven 单继承机制-->
      <type>pom</type>
      <scope>import</scope>
    </dependency>

    <!--配置SpringCloud(注意和spring-boot版本对应关系)-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <version>Hoxton.SR1</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>

    <!--SpringCloud Alibaba-->
    <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-alibaba-dependencies</artifactId>
      <version>2.1.0.RELEASE</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>

    <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>

    <!--druid数据源-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>${druid.version}</version>
    </dependency>

    <!--SpringBoot 整合 mybatis 的 starter-->
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>${mybatis.spring.boot.version}</version>
    </dependency>

    <!--log4j-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>

    <!--Junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
    </dependency>

    <!--Lombok-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok.version}</version>
    </dependency>

  </dependencies>
  </dependencyManagement>

<!--<!--删除 build 和 reporting 节点-->-->
</project>

1.3dependencyManagement说明

1. Maven 使用 dependencyManagement 元素来提供了一种管理依赖版本号的方式。通常在packaging为pom的项目中使用该元素

2. 使用 pom.xml 中的 dependencyManagement 元素能让所有子项目引用一个依赖 ,Maven 会沿着父子层次向 上走，直到找到一个拥有dependencyManagement元素的项目，然后它就会使用这个dependencyManagement 元素中指定的版本号。

3. 好处∶如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项目里都声明一个版本号，当升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要分别在子项目中修改；另外如果某子项目需要另外的版本时，子项目只需要声明 version 就可。

4. dependencyManagement 里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。

5. 如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本时，才会从父项目中继承该项，并且version 和 scope 都读取自父 pom。作用范围一览图：

   

6. 如果子项目中指定了版本号，那么会使用子项目中指定的 jar 版本

2.创建会员中心微服务模块-service provider

2.1需求分析

1. 通过浏览器可以获取会员信息（通过会员中心微服务模块）
2. 可以通过postman进行测试查询和添加数据

2.2思路分析

1. 创建Module & 完成配置
2. 创建数据库 & 表
3. 创建 entity-dao/mapper.xml-service-controller
4. 完成测试

2.3实现步骤

2.3.1创建Module&完成配置

（1）创建名为 member-service-provider-10000 的微服务模块，提供会员服务。member代表会员服务，service-provider代表这是一个提供服务的模块，10000代表端口。

依次选择：File-New-Module

（2）选择Maven，直接下一步

（3）idea会自动识别父工程，如下，然后点击Finish

（4）如果创建成功，父项目会自动聚合子模块。父项目的pom.xml文件：

（5）修改member-service-provider-10000子模块的pom.xml，加入相关依赖

<?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>E-Commerce-Center</artifactId>
        <groupId>com.li.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>member-service-provider-10000</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <!--引入相关的依赖，版本都使用父项目声明的版本-->
    <dependencies>

        <!--web-starter-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--actuator-starter 是 springboot程序的监控系统，可以实现系统的健康监测
            可以通过http://localhost:10000/actuator看到相关的连接和信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!--引入mybatis-starter，整合到springboot中-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

        <!--druid-starter-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <!--这里父项目没有指定版本，需要手动指定-->
            <version>1.1.17</version>
        </dependency>

        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--jdbc-starter-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--test-starter-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

（6）在member-service-provider-10000子模块中创建resources/application.yml文件

server:
  port: 10000
spring:
  application:
    name: member-service-provider-10000 #配置应用的名称
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource #指定数据源类型
    url: jdbc:mysql://localhost:3306/e_commerce_center_db?useSSL=true&useUnicode=true&characterEncoding=UTF-8
    username: root
    password: 123456
mybatis:
  mapper-locations: classpath:mapper/*.xml #指定mapper.xml文件位置
  type-aliases-package: com.li.springcloud.entity #实体类的包，这样通过类名就可以引用

（7）启动子模块的主程序：

package com.li.springcloud;

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

/**
 * @author 李
 * @version 1.0
 */
@SpringBootApplication
public class MemberApplication {
    public static void main(String[] args) {
        SpringApplication.run(MemberApplication.class, args);
    }
}

测试结果：运行成功。

2.3.2创建数据库&表

-- 创建数据库
CREATE DATABASE e_commerce_center_db
USE e_commerce_center_db

-- 创建member表
CREATE TABLE `member`(
`id` 		BIGINT NOT NULL AUTO_INCREMENT COMMENT 'id',
`name` 		VARCHAR(64) COMMENT '用户名',
`pwd` 		CHAR(32) COMMENT '密码',
`mobile` 	VARCHAR(20) COMMENT '手机号码',
`email` 	VARCHAR(64) COMMENT '邮箱',
`gender` 	TINYINT COMMENT '性别',
 PRIMARY KEY (id)
);

-- 测试数据
INSERT INTO member
VALUES(NULL, 'smith', MD5('123'), '123456789000', 'smith@sohu.com', 1);

SELECT * FROM member;

2.3.3业务实现

2.3.3.1utils层

Result工具类，用于同一返回的数据类型

package com.li.springcloud.utils;

/**
 * @author 李
 * @version 1.0
 返回结果对象，以json格式返回
 */
public class Result<T> {
    private String code;//状态码 200-success 400-fail
    private String msg;//状态说明
    private T data;//返回的数据，使用泛型

    public Result() {
    }

    public Result(T data) {
        this.data = data;
    }

    //返回需要的result对象，表示成功
    public static Result success() {
        Result result = new Result<>();
        result.setCode("200");
        result.setMsg("success");
        return result;
    }

    //返回成功的result对象，表示成功，同时携带数据
    //如果需要在static方法中使用泛型，需要在static关键字后添加<T>
    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>(data);
        result.setCode("200");
        result.setMsg("success");
        return result;
    }

    //返回成功的result对象，表示成功，同时携带数据和自定义msg
    public static <T> Result<T> success(String msg, T data) {
        Result<T> result = new Result<>(data);
        result.setCode("200");
        result.setMsg(msg);
        return result;
    }

    //返回需要的result对象-表示失败
    //因为失败的原因有很多中，因此直接将其作为参数传进来
    public static Result error(String code, String msg) {
        Result result = new Result<>();
        result.setCode(code);
        result.setMsg(msg);
        return result;
    }

    //返回成功的result对象，表示失败，同时携带数据
    public static <T> Result<T> error(String code, String msg, T data) {
        Result<T> result = new Result<>(data);
        result.setCode(code);
        result.setMsg(msg);
        return result;
    }

    //getter、setter方法省略
}

2.3.3.2entity层

Member实体类：

package com.li.springcloud.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author 李
 * @version 1.0
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Member {
    private Long id;
    private String name;
    private String pwd;
    private String mobile;
    private String email;
    private Integer gender;
}

2.3.3.3dao层

Member对应的Dao层接口：MemberDao.java

package com.li.springcloud.dao;

import com.li.springcloud.entity.Member;

/**
 * @author 李
 * @version 1.0
 */
public interface MemberDao {
    //根据id返回member对象
    public Member queryMemberById(Long id);
    //添加member
    public int save(Member member);
}

如果在这里不添加@Mapper注解，则需要在主程序中添加@MapperScan(basePackages = {"com.li.springcloud.dao"})

在 resources/mapper/MemberMapper.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.li.springcloud.dao.MemberDao">

    <!--为了拓展，这里使用resultMap-->
    <resultMap id="BaseResultMap" type="com.li.springcloud.entity.Member">
        <id column="id" property="id" jdbcType="BIGINT"></id>
        <id column="name" property="name" jdbcType="VARCHAR"></id>
        <id column="pwd" property="pwd" jdbcType="VARCHAR"></id>
        <id column="mobile" property="mobile" jdbcType="VARCHAR"></id>
        <id column="email" property="email" jdbcType="VARCHAR"></id>
        <id column="gender" property="gender" jdbcType="TINYINT"></id>
    </resultMap>

    <!--配置实现queryMemberById()-->
    <select id="queryMemberById" parameterType="Long" resultMap="BaseResultMap">
        SELECT * FROM `member` WHERE `id` = #{id}
    </select>

    <!--配置实现save(),useGeneratedKeys=true,获取自增长id-->
    <insert id="save" parameterType="Member" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO `member` (`name`, `pwd`, `mobile`, `email`, `gender`)
        VALUES (#{name}, MD5(#{pwd}), #{mobile}, #{email}, #{gender});
    </insert>
</mapper>

测试类：

注意：测试类需要和主程序在同一个路径下，否则需要手动指定class

package com.li.springcloud;

import ...

/**
 * @author 李
 * @version 1.0
 */
@SpringBootTest
@Slf4j
public class MemberApplicationTest {

    //装配MemberDao
    @Resource
    private MemberDao memberDao;

    @Test //注意：引入的是 org.junit.jupiter.api.Test;
    public void queryMemberById() {
        Member member = memberDao.queryMemberById(1L);
        log.info("member={}", member);
    }

    @Test //引入的是 org.junit.jupiter.api.Test;
    public void save() {
        Member member =
                new Member(null, "牛魔王", "123456", "18077560000", "jack@qq.com", 1);
        int save = memberDao.save(member);
        log.info("受影响的行数={}", save);
    }
}

queryMemberById()测试结果：

member=Member(id=1, name=smith, pwd=202cb962ac59075b964b07152d234b70, mobile=123456789000, email=smith@sohu.com, gender=1)

save()测试结果：

受影响的行数=1

2.3.3.4service层

MemberService接口：

package com.li.springcloud.service;

import com.li.springcloud.entity.Member;

/**
 * @author 李
 * @version 1.0
 */
public interface MemberService {
    //根据id返回member
    public Member queryMemberById(Long id);

    //添加member
    public int save(Member member);
}

MemberServiceImpl实现类：

package com.li.springcloud.service.impl;

import ...

/**
 * @author 李
 * @version 1.0
 */
@Service
public class MemberServiceImpl implements MemberService {
    @Resource
    private MemberDao memberDao;

    @Override
    public Member queryMemberById(Long id) {
        return memberDao.queryMemberById(id);
    }

    @Override
    public int save(Member member) {
        return memberDao.save(member);
    }
}

测试类：

package com.li.springcloud;

import ...

/**
 * @author 李
 * @version 1.0
 */
@SpringBootTest
@Slf4j
public class MemberApplicationTest {
    //装配MemberService
    @Resource
    private MemberService memberService;

    @Test
    public void queryMemberById() {
        Member member = memberService.queryMemberById(3L);
        log.info("member={}", member);
    }

    @Test
    public void save() {
        Member member =
            new Member(null, "tomas", "hahah123", "0773-2345-678", "tomas@qq.com", 0);
        int save = memberService.save(member);
        log.info("受影响的行数={}", save);
    }
}

queryMemberById()测试结果：

member=Member(id=3, name=jack, pwd=202cb962ac59075b964b07152d234b70, mobile=123456789000, email=smith@sohu.com, gender=1)

save()测试结果：

受影响的行数=1

2.3.3.5controller层

package com.li.springcloud.controller;

import ...

/**
 * @author 李
 * @version 1.0
 */
@Controller
@Slf4j
public class MemberController {
    @Resource
    private MemberService memberService;

    @PostMapping("/member/save")
    @ResponseBody
    public Result save(Member member) {
        int affected = memberService.save(member);
        if (affected > 0) {
            return Result.success("添加会员成功", affected);
        } else {
            return Result.error("401", "添加会员失败");
        }
    }

    @GetMapping("/member/get/{id}")
    @ResponseBody
    public Result getMemberById(@PathVariable("id") Long id) {
        Member member = memberService.queryMemberById(id);
        if (member != null) {
            return Result.success("查询成功", member);
        } else {
            return Result.error("402", "Id=" + id + "用户不存在！");
        }
    }
}

2.3.4完成测试

（1）测试controller的save()方法

使用postman进行测试

返回结果：

数据成功插入表中：

（2）测试controller的getMemberById()方法

测试成功。

2.4注意事项和细节

1. 如果前端是以json格式来发送数据的，需要在controller层的方法参数前使用@RequestBody，来将json数据封装成对应的Javabean。同时需要保证前端发送的http请求头中，Content-Type指定的是json格式。

2. 如果前端是以表单或者参数提交的，则不需要@RequestBody

3. 在进行springboot应用程序测试时，引入的JUnit是 org.junit.jupiter.api.Test 包的

4. 在运行程序时，一定要确保你的 XxxMapper.xml文件被自动放到了 target 目录的 classes 指定的目录下