微服务基础环境搭建

已于 2024-02-23 01:27:48 修改
阅读量1.5k 收藏 20
点赞数 18
文章标签： 微服务 架构 云原生
于 2024-02-22 04:49:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang115t/article/details/136223656
版权

一.创建父工程

用于聚合其他微服务模块

1 新建 Maven 项目

JDK8+Maven 项目+Web

2 项目设置

  1. 编码的选择 UTF8
  2. JDK 版本的选择

3 删除 src 目录

SpringBoot：模块探究之spring-boot-dependencies-CSDN博客

子模块能够依赖当前父级 pom.xml 配置

【Mybatis】maven配置pom.xml时找不到依赖项（已解决）-CSDN博客

从这往后配置

 <!-- 表明是一个父工程,聚合管理其他模块 -->
    <packaging>pom</packaging>
    <!--  项目名-->
    <name>E-Commerce-Centers Maven Webapp</name>
    <!--  项目描述-->
    <description>初始化微服务项目</description>
    <!--  项目url-->
    <url>http://maven.apache.org</url>
    <!--  项目开发年份-->
    <inceptionYear>2024</inceptionYear>
    <!-- 统一配置各个依赖版本 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--    指定JDK版本：8-->
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!--      开发测试Test-->
        <junit.version>4.12</junit.version>
        <!--   日志打印，使用最新的版本的log4j,防止安全漏洞-->
        <log4j.version>2.17.2</log4j.version>
        <!--    简化JavaBean：get、set、toString-->
        <lombok.version>1.18.20</lombok.version>
        <!--    数据库连接mysql:与数据库mysql版本要一致，否则报错-->
        <mysql.version>8.0.27</mysql.version>
        <!--    德鲁伊数据库连接池-->
        <druid.version>1.1.17</druid.version>
        <!--     mybatis数据库操作 -->
        <mybatis.spring.boot.version>2.2.0</mybatis.spring.boot.version>
    </properties>
    <!-- 1. dependencyManagement 作用: 子模块继承后, 锁定版本, 子模块不用再写 version
  -->
    <dependencyManagement>
        <dependencies>
            <!--      SpringBoot-->
            <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-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <!--              SpringCloud与SpringBoot版本要匹配对应-->
                <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数据库连接-该版本与properties标签内指定的版本一致-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!--druid德鲁伊数据库连接池：版本与properties标签内指定的版本一致-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <!--          myBatis：增删改查-->
            <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>
            <!--          测试Test-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!--          简化JavaBean-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.20</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!--  build-暂时先不要，打包：构建项目的名称-->
<!--    <build>-->
<!--        <finalName>E-Commerce-Centers</finalName>-->
<!--    </build>-->

Maven 的 dependencyManagement 说明

二.创建会员中心(service-provider)

微服务模块 service provider

当前模块主要功能：用于简单的 CRUD 增删改查

1 创建 Module 模块

该模块被父项目的 pom.xml 所管理依赖版本

模块名: member-service-provider-10000( 会员-提供服务模块-端口)

微服务模块(提供会员服务)

注意：创建子模块的位置：必须在父项目内部

复制父级项目的绝对路径，创建项目的时候，在该路径下创建子模块

子模块在父模块内，就算成功创建了子模块

查看当前子模块在父级项目内部

待子模块项目生成了项目结构后

如果创建失败，则参考如下博客，删除模块后重新创建

IDEA 如何删除模块和项目_idea移除项目,不是删除-CSDN博客

1-2 Pom.xml 加入相关依赖

修改 子模块 的 pom.xml , 加入相关依赖

子模块在引入依赖的时候，如果父项目也存在该依赖

子项目不指定该依赖版本，则以父项目的依赖版本为准

比如：

父项目:springboot 版本 2.2.0

子模块引入了 springboot 未指定版本，默认版本(父项目) 2.2.0

dependencys 标签中引入如下依赖即可,引入后记得刷新 Maven

<!--SpringBoot版本与父项目一致-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <!-- 如果在子工程/模块指定了 version，则以指定为准 -->
</dependency>
<!-- 老师解读
1. starter-actuator 是 springboot 程序的监控系统，
可以实现健康检查，info 信息等
2. 访问 http://localhost:10000/actuator 可以看到相关链接, 还可以做相关设置. -->
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web
-->
<!--        指定了监控系统版本-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web
-->
<!--        mybatis-->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<!--        springBoot cloud alibaba-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid-spring-boot-starter</artifactId>
  <!-- 这里我们重新指定一下 version -->
  <version>1.1.13</version>
</dependency>
<!--        mysql-->
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-jdbc
-->
<!--        jdbc连接池-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
  <!--            lombok-->
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-test -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
</dependency>

1-3 创建 resources/application.yml

子模块下，新建application.yml,

注意：数据库的账号密码与数据库的 url 一定要配置正确

server:
  port: 10000 #服务端-端口号
spring:
  application:
    name: member-service-provider #当前模块的项目名称
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    #    driver-class-name: org.gjt.mm.mysql.Driver
    #数据库地址:
    #jdbc:mysql://域名:端口/数据库名称?useUnicode=true&characterEncoding=utf-8&useSSL=false
    url: jdbc:mysql://localhost:3306/furns_ssm?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root    #数据库名称
    password: abc123  #数据库密码
mybatis:
  mapperLocations: classpath:mapper/*.xml #后面 mapper 文件的位置
  type-aliases-package: com.wwf.entity #指定POJO扫描包来让mybatis自动扫描到自定义的POJO。

创建项目基本结构

1-4 创建主启动类 MemberApplication

/**
 * @author 卒迹
 * @version 1.0
 */
//指定注解的扫描路径MVC-@Controller、@Service等等...
@SpringBootApplication(scanBasePackages = {"com.wwf"})
//指定Mapping包扫描路径
@MapperScan(basePackages = {"com.wwf.dao"})
public class MemberApplication {
    public static void main(String[] args) {
        SpringApplication.run(MemberApplication.class, args);
    }
}

1-5 测试 Controller 是否能够正常访问

/**
 * @author 卒迹
 * @version 1.0
 */
@RestController
public class MemberController {
    @RequestMapping("/hi")
    public String hi() {
        return "hi springboot";
    }
}

根据 application.yml 配置的端口访问

http://localhost:10000/hi

2 创建数据库/表

#1.创建数据库
CREATE DATABASE e_commerce_center_db
#2.使用数据库
USE e_commerce_center_db
#3.创建会员表
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)
);
#4.插入1条会员信息
INSERT INTO member VALUES
(NULL, 'smith', MD5('123'), '123456789000', 'smith@sohu.com', 1);
#5.查询该会员表
SELECT * FROM member

2-0 新建 JavaBean

@AllArgsConstructor
@NoArgsConstructor
@Data
//Serializable 加上，后面可能使用
public class Member implements Serializable {
    private Long id;
    private String name;
    private String pwd;
    private String mobile;
    private String email;
    private Integer gender;
}

2-1 导入 Result 工具类

/**
* 1. 用于返回结果， 利于 json 格式
* 2. 这个工具类， 在网上也可找到
*/
public class Result<T> {
    private String code;
    private String msg;
    private T data;
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
    public Result() {
    }
    public Result(T data) {
        this.data = data;
    }
    public static Result success() {
        Result result = new Result<>();
        result.setCode("200");
        result.setMsg("success");
        return result;
    }
    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>(data);
        result.setCode("200");
        result.setMsg("success");
        return result;
    }
    public static <T> Result<T> success(String msg, T data) {
        Result<T> result = new Result<>(data);
        result.setCode("200");
        result.setMsg(msg);
        return result;
    }
    public static Result error(String code, String msg) {
        Result result = new Result();
        result.setCode(code);
        result.setMsg(msg);
        return 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;
    }
}

2-2 新建 MemberDAO 接口

注意：一定要在启动类中，添加扫描 Mapper 的注解

@Mapper
public interface MemberDao {
    // 根据id，查询会员
    Member queryMemberById(Long id);

    // 添加会员
    int save(Member member);
}

2-3 在 /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">
<!--1.先指定Mapper定义的接口的路径-->
<mapper namespace="com.wwf.dao.MemberDao">
  <!--insert添加数据SQL语句-->
  <!--1.  id:方法名
  2.  parameterType:方法形参
  3.  useGeneratedKeys="true" keyProperty="id": 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>
  <!--1.  id：结果集映射
  2.  type:JavaBean路径-->
  <resultMap id="BaseResultMap" type="com.wwf.entity.Member">
    <!--column      表的字段
    property    JavaBean的字段
    jdbcType     字段数据类型-->
    <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>
  <!--    1.  id:方法名-->
  <!--    2.  parameterType:方法形参-->
  <!--    3.  resultMap:其实就是返回值Member-->
  <!--将查询的结果：保持到当前结果集中，该结果集是1个PoJo对象(Member)-->
  <select id="queryMemberById" parameterType="Long" resultMap="BaseResultMap">
    select *
    from member
    where id = #{id}
  </select>
</mapper>

2-4 创建 Service 接口

/**
 * @author 卒迹
 * @version 1.0
 */
public interface MemberService {
    // 查询方法(通过id获取到Member(PoJo/entity))
    Member queryMemberById(Long id);

    // 插入1条数据
    int save(Member member);
}

2-5 创建 ServiceImpl 实现类

/**
 * @author 卒迹
 * @version 1.0
 */
@Service
public class MemberServiceImpl implements MemberService {// 实现了MemberService接口
    @Resource
    private MemberDao memberDao;// 从IOC容器中得到该DAO对象-Service层调用DAO层的方法

    // 调用DAO对象的查询方法(id)
    @Override
    public Member queryMemberById(Long id) {
        return memberDao.queryMemberById(id);
    }

    // 调用DAO对象的添加方法
    @Override
    public int save(Member member) {
        return memberDao.save(member);
    }
}

2-6 Controller 层

/**
 * @author 卒迹
 * @version 1.0
 */
@RequestMapping("/member")// 请求路径根目录
@RestController//@Controller+@ResponseBody
@Slf4j// 日志
public class MemberController {
    @RequestMapping("/hi")
    public String hi() {
        return "hi springboot";
    }

    // Controller调用Service层方法
    @Resource
    private MemberService memberService;


    
    //添加会员
    // 接口:http://localhost:10000/member/add
    // 提交的数据类型：{
    //     "name":"jack",
    //     "pwd":"123",
    //     "mobile":"123456789000",
    //     "email":"jack@sohu.com",
    //     "gender":"0"
    // }
    
    @PostMapping("/add")
    public Result<Member> add(@RequestBody Member member) {
        log.info("Member=" + member);
        int affect = memberService.save(member);
        if (affect < 0) {// 添加失败
            return Result.error("-1", "添加失败");
        }
        // 添加成功-将Member以JSON格式响应给浏览器
        return Result.success("添加成功", member);
    }

    
     // 查询会员-id    
    // 接口：http://localhost:10000/member/queryMemberById?id=1;
    @GetMapping("/queryMemberById")
    public Result<Member> queryMemberById(@RequestParam(value = "id") Long id) {
        Member member = memberService.queryMemberById(id);
        if (member == null) {
            return Result.error("-1", "该用户不存在!");
        }
        return Result.success("查询成功", member);

    }

}

2-7 修改 application.yml 配置文件中数据库的配置

2-8 PostMan 测试

添加

接口:http://localhost:10000/member/add

提交的数据类型 JSON：

{

"name":"jack",

"pwd":"123",

"mobile":"123456789000",

"email":"jack@sohu.com",

"gender":"0"

}

查询

2-9 查看数据库-添加

三.创建使用微服务模块

各个模块之间接口的相互调用的关系

service consumer-消费模块的 Controller 层

调用 service provider-模块中的接口的Controller服务的功能

思路分析：

相互访问对方接口的模块必须都要启动SpringBoot主程序

3-1 复制主项目的绝对路径

3-2 新建模块

查看当前子模块是否在父模块中

3-3 加入相关依赖 pom.xml

dependencys 标签中加入如下的依赖

<!--springBoot-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <!-- 如果在子工程/模块指定了 version，则以指定为准 -->
</dependency>
<!--        监控-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!--        mybatis-->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
<!--        lombok-->
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
</dependency>
<!--        test-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
</dependency>

3-4 刷新 Maven 项目-查看当前子项目的依赖，是否与父项目的依赖版本是一致的

3-5 配置 application.yml

/resources/ application.yml

分析：只需要配置端口即可

我们直接通过当前的接口去调用到另外的模块的接口进行增删改查

server:
  port: 80

思路分析：

我们只需要启动 SpringBoot，并在 Controller 的接口方法中

调用到 service-provider 模块中 Controller 层中接口的方法

3-6 创建启动类-springBoot

/**
 * @author 卒迹
 * @version 1.0
 */
// scanBasePackages = {"com.wwf"} 配置包扫描注解的路径
@SpringBootApplication(scanBasePackages = {"com.wwf"})
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);

    }
}

3-7 创建 JavaBean

3-8 新建工具类 Result

/**
 * @author 卒迹
 * @version 1.0
 * @author 卒迹
 * @version 1.0
 */

/**
 * 1. 用于返回结果， 利于 json 格式
 * 2. 这个工具类， 在网上也可找到
 */
public class Result<T> {
    private String code;
    private String msg;
    private T data;

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Result() {
    }

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

    public static Result success() {
        Result result = new Result<>();
        result.setCode("200");
        result.setMsg("success");
        return result;
    }

    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>(data);
        result.setCode("200");
        result.setMsg("success");
        return result;
    }

    public static <T> Result<T> success(String msg, T data) {
        Result<T> result = new Result<>(data);
        result.setCode("200");
        result.setMsg(msg);
        return result;
    }

    public static Result error(String code, String msg) {
        Result result = new Result();
        result.setCode(code);
        result.setMsg(msg);
        return 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;
    }
}

3-9 新建配置类

/**
 * @author 卒迹
 * @version 1.0
 */
@Configuration// 自动将Bean对象注入到IOC容器中
public class CustomizationBean {
    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

3-10 Controller 层

通过当前模块 Controller 层的接口，

去访问另外模块中的 Controller 的接口

前提是服务的端口都要是启动的

10000 端口和80端口服务是启动的状态

3-11 测试访问当前端口为 80 的接口的方法

该端口为 80 的接口的方法

会去请求转发访问 10000 端口的 Controller 层接口的方法

http://localhost:80/member/consumer/save

80 端口的查询的接口

访问该 80 端口 的接口：

http://localhost:80/member/consumer/get/1

会去调用 10000 端口的接口

http://localhost:10000/member/queryMemberById?id=1

四.创建共用模块-供其他模块使用

我们可以发现在 80 和 10000 端口两个服务中，都用到了相同的 Bean

4-1 创建公共的模块 Moduel

创建 e_commerce_center-common-api

验证是否创建成功-查看父项目 pom.xml 的子模块导入情况

查看当前子模块 pom 的父级项目的依赖关系

查看当前子模块是否在父级项目内

4-2 修改当前子模块 的 pom.xml 配置

这里按照项目的实际情况，引入相应的需要封装公共模块的 api

当前我的项目，现在只需要封装 Bean,所以只需要引入 lombok 即可

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
    <!--
    老师解读<optional>true</optional>:
  1. true 表示两个项目之间依赖不传递
  2. 小伙伴可以这里理解<optional>true</optional>: 防止将该依赖传递到其他模块中
      说的再具体一点，比如 member-service-consumer-80 模块依赖了本项目, 
      那么本项目不会把 lombok 传递给 member-service-consumer-80
  3. 不设置 optional 或者 optional 是 false，表示传递依赖
  -->
<optional>true</optional>
</dependency>
<!-- 以后需要什么可以这里在引入. -->

4-3 抽取共用 API/类

@AllArgsConstructor
@NoArgsConstructor
@Data
//Serializable 加上，后面可能使用
public class Member implements Serializable {
    private Long id;
    private String name;
    private String pwd;
    private String mobile;
    private String email;
    private Integer gender;
}
/**
 * @author 卒迹
 * @version 1.0
 * @author 卒迹
 * @version 1.0
 */

/**
 * 1. 用于返回结果， 利于 json 格式
 * 2. 这个工具类， 在网上也可找到
 */
public class Result<T> {
    private String code;
    private String msg;
    private T data;

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Result() {
    }

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

    public static Result success() {
        Result result = new Result<>();
        result.setCode("200");
        result.setMsg("success");
        return result;
    }

    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>(data);
        result.setCode("200");
        result.setMsg("success");
        return result;
    }

    public static <T> Result<T> success(String msg, T data) {
        Result<T> result = new Result<>(data);
        result.setCode("200");
        result.setMsg(msg);
        return result;
    }

    public static Result error(String code, String msg) {
        Result result = new Result();
        result.setCode(code);
        result.setMsg(msg);
        return 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;
    }
}

4-4 使用 Maven 打包成 jar

确保当前打包方式为 jar

在其他需要使用到公共部分的 模块中，引入当前打包的 Jar

该 Jar 为提取的公共的模块

<!-- 引入 e_commerce_center-common-api -->
<!-- 这里的groupId 你在创建模块的时候的groupId -->
<dependency>
  <groupId>com.hspedu.springcloud</groupId>
  <artifactId>e_commerce_center-common-api</artifactId>
  <version>${project.version}</version>
</dependency>

删除其他服务(端口)中抽取出来的公共 entity 和 response

我这里抽取出来的 entity 和 response 这两个包

在引入 Jar 包后，在当前模块中删除这两个

如果报错了，

可以看看 maaper.xml 中，JavaBean 配置的路径是否是正确的

微服务环境搭建
weixin_66202611的博客
11-25 1809
系统架构大体经历了下面几个过程: 单体应用架构--->垂直应用架构--->分布 式架构--->SOA架构--->微服务架构单体架构介绍互联网早期，一般的网站应用流量较小，只需一个应用，将所有功能代码都部署在一起就可以，这 样可以减少开发、部署和维护的成本。比如说一个电商系统，里面会包含很多用户管理，商品管理，订单管理，物流管理等等很多模块， 我们会把它们做成一个web项目，然后部署到一台tomcat服务器上。如图所示优点：项目架构简单，小型项目的话， 开发成本低项目部署在一个节点上， 维护方便。
微服务介绍&微服务环境搭建
qq_44247968的博客
11-26 1502
从互联网早起到现在，系统架构大体经历了下面几个过程: 单体应用架构--->垂直应用架构--->分布 式架构--->SOA架构--->微服务架构，当然还有悄然兴起的Service Mesh(服务网格化)。
最新版微服务项目搭建
m0_46606920的博客
09-08 1393
最新版微服务搭建，使用nacos，redis，mongodb，gateway，openfeign等技术
【微服务 从0开始 】Spring Cloud 简单搭建一个微服务项目
最新发布
m0_74823778的博客
09-27 1039
【秒懂·云原生】目前主要更新微服务，一起学习一起进步。主要介绍Spring boot与Spring Cloud的关系，以及如何搭建一个微服务项目在构建第一个微服务之前，我们先了解一下Spring bootSpring框架功能很强大，但是就算是一个很简单的项目，开发者也需要进行大量的配置工作，因此在Spring 4.0之后出现了Spring Boot框架，它的作用很简单，就是帮助开发者自动配置Spring的相关依赖。
微服务环境的搭建
JAVA_SR的博客
08-26 2375
电商项目，订单微服务，商品微服务。
搭建微服务环境
Add小兵的博客
09-30 450
微服务环境搭建 提示：想要了解微服务的点击上一篇博客–>微服务介绍 SpringCloud 介绍点击–>Spring Cloud快速了解入门 1. 案例准备 电商系统：搭建用户微服务，商品微服务，订单微服务 1.1 技术选型 maven：3.5+ 数据库：mysql 5.7 持久层：MybatisPlus 其他：Spring Cloud Alibaba 1.2 模块设计 父工程：shop-parent 用户微服务：shop-user 商品微服务：shop-goods 订单微服务: sho
微服务架构的环境搭建及简单测试
qq_63492318的博客
11-25 2027
简单介绍了系统架构的演变过程，以及微服务架构的环境搭建案例及测试...
金融微服务中间件环境搭建与容器化部署指南
资源摘要信息:"金融项目微服务中间件生产环境搭建及容器化项目部署.zip" 标题和描述提到了几个关键概念：微服务、中间件、容器化部署。本内容将围绕这些概念详细展开，并解释它们在金融项目中的应用和重要性。 ...
微服务的搭建实例
01-10
例子主要是使用springCloud来来实现微服务的简单搭建，包括服务的注册与发现，服务的人消费者与提供者，zuul的配置等基本的微服务。
自己做的微服务环境简单搭建----网上书店
03-26
项目博客地址https://blog.csdn.net/u014191624/article/details/88814553；包含微服务内容有 1:服务的注册与发现（Eureka） 2:服务消费者（Feign）(Finchley版本) 3:路由网关(zuul)(Finchley版本) 4：服务消费者（rest+ribbon）(Finchley版本)
微服务框架搭建和开发
11-23
适合微服务的初学者对微服务架构的搭建与设计。
【微服务】微服务环境搭建
m0_64210833的博客
03-01 874
例来演示微服务的调⽤：客户向订单微服务发起⼀个下单的请求，在进⾏保存订单之前需要调⽤商品微服务查询商品的信息。在微服务架构中，最常⻅的场景就是微服务之间的相互调⽤。我们以电商系统中常⻅的。10.直接往数据库中添加几条数据，启动项目进行调用即可。启动⼯程，等到数据库表创建完毕之后，加⼊测试数据。我们⼀般把服务的主动调⽤⽅称为。商品微服务 【端⼝:8081。订单微服务 【端⼝:8091。，把服务的被调⽤⽅称为。
微服务开发环境搭建
llh304的博客
06-09 824
为了避免每次拉取代码或提交代码输入账号密码，设置ssh免密连接，设置好后通过命令 ssh -T git@gitee.com查看是否成功，会提示是否需要使用这个密钥作为连接，输入yes即可，以后就会使用这个密钥提交拉取。所有模块添加成功后，把这个项目作为一个总项目，把微服务其他服务作为一个模块添加进来，复制其他一个服务中的pom.xml到这个总目录底下修改配置文件，删除没有到文件，添加package为pom。点击maven+号，把总服务添加进来，对总服务进行操作，其他都会更新。安装后，需要安装一些插件。
微服务基本环境的搭建
while(True): print('adorable')
12-02 299
以支付，订单为例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值