微服务基础环境搭建
2023年11月18日大约 22 分钟约 4393 字
创建父工程 ，用于聚合其它微服务模块
创建Maven项目
项目设置
删除 src 目录
配置父工程 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.lzw</groupId>
<artifactId>e-commerce-center</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 表明是一个父工程,聚合管理其他模块 -->
<packaging>pom</packaging>
<name>e-commerce-center Maven Webapp</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 配置各个依赖和版本: 后面如果有需要,还要增加-->
<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>
<!--配置spring-cloud-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Hoxton.SR1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--配置cloud-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>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>注意事项和细节
（1）Maven 的 dependencyManagement 说明
1、Maven 使用 dependencyManagement 元素来提供了一种管理依赖版本 号 的 方 式 。 通 常 在 项 目 packaging 为 POM, 中 使 用 dependencvManadement 元素。
2、使用 pom.xml 中的 dependencyManagement 元素能让所有在子项目中 引用一个依赖, Maven 会沿着父子层次向上走，直到找到一个拥有 dependencyManagement 元素的项目， 然后它就会使用这个 dependencyManagement 元素中指定的版本号。
3、好处∶如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项 目里都声明一个版本号，当升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要分别在子项目的修改;另外如果某个子项目需要另外的一个版 本，只需要声明 version 就可。
4、dependencyManagement 里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。
5、如果不在子项目中声明依赖，是不会从父项目中继承下来的; 只有在子项目 中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且 version 和 scope 都读取自父 pom
6、如果子项目中指定了版本号，那么会使用子项目中指定的 jar 版本
创建会员中心微服务模块-service provider
步骤
1、创建 Moduel & 完成配置
2、创建数据库/表
3、创建 entity-dao/Mapper.xml-service-controller
4、完成测试
1、创建 member-service-provider-10001 微服务模块[提供会员服务]
注意子模块的 pom.xml 文件
父模块的 pom.xml 文件
配置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.lzw</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<!--该项目继承成父项目的groupId是 com.lzw-->
<!--因此这里就不需要在指定groupId-->
<artifactId>member-service-provider-10001</artifactId>
<!--引入相关的依赖-->
<dependencies>
<!--引入web-starter 我们使用版本仲裁(从父项目继承了版本)-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--说明:starter-actuator 是springboot程序的监控系统, 可以实现系统的健康检测
可以通过http://localhost:10001/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>
<!--spring-boot-start-jdbc引入-->
<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>创建 src/main/resources/application.yml
server:
port: 10001
spring:
application:
name: member-service-provider-10001 #配置应用的名称
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.lzw.springcloud.entity # 实体类所在包，这样通过类名就可以引用创建 src/main/java/com/lzw/springcloud/MemberApplication.java
运行测试
package com.lzw.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @author LiAng
*/
@SpringBootApplication
public class MemberApplication {
public static void main(String[] args) {
SpringApplication.run(MemberApplication.class, args);
}
}2、创建数据库和表
CREATE DATABASE e_commerce_center_db
USE e_commerce_center_db
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`3、创建 src/main/java/com/lzw/springcloud/entity/Member.java
package com.lzw.springcloud.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author LiAng
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Member {
private Long id;
private String name;
private String pwd;
private String mobile;
private String email;
private Integer gender;
}4、创建 src/main/java/com/lzw/springcloud/entity/Result.java
package com.lzw.springcloud.entity;
/**
* @author LiAng
* Result<T> 对象就是后端返回给前端的数据，是以json格式返回
*/
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() {
}
//带参构造器-指定返回的data
public Result(T data) {
this.data = data;
}
//编写方法-返回需要的Result对象-表示成功的Result
public static Result success() {
Result result = new Result<>();
result.setCode("200");
result.setMsg("success");
return result;
}
//编写方法-返回需要的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对象-表示失败的Result
public static Result error(String code, String msg) {
Result result = new Result<>();
result.setCode(code);
result.setMsg(msg);
return result;
}
//编写方法-返回需要的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;
}
//编写方法-返回需要的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;
}
}5、创建src/main/java/com/lzw/springcloud/dao/MemberDao.java
package com.lzw.springcloud.dao;
import com.lzw.springcloud.entity.Member;
import org.apache.ibatis.annotations.Mapper;
/**
* @author LiAng
*/
@Mapper
public interface MemberDao {
//定义方法
//根据id返回member数据
public Member queryMemberById(Long id);
//添加member
public int save(Member member);
}6、创建 src/main/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.lzw.springcloud.dao.MemberDao">
<!--配置实现queryMemberById
1. 这里可以使用 resultType="Member"
2. 当然也可以使用resultMap="自定义的resultMap", 这里我们使用resultMap
-->
<resultMap id="BaseResultMap" type="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>
<select id="queryMemberById" parameterType="Long" resultMap="BaseResultMap">
SELECT * FROM `member` WHERE `id`=#{id}
</select>
<!--配置实现save -->
<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>7、创建 src/test/java/com/lzw/springcloud/MemberApplicationTest.java 测试
package com.lzw.springcloud;
import com.lzw.springcloud.dao.MemberDao;
import com.lzw.springcloud.entity.Member;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
/**
* @author LiAng
*/
@SpringBootTest
@Slf4j
public class MemberApplicationTest {
//装配 MemberDao
@Resource
private MemberDao memberDao;
//这里的@Test 选择 org.junit.jupiter.api.Test
@Test
public void queryMemberById(){
Member member = memberDao.queryMemberById(1l);
log.info("member={}",member);
}
@Test
public void save() {
Member member =
new Member(null, "狐狸精", "123", "13000000000", "hlj@sohu.com", 1);
int affected = memberDao.save(member);
log.info("affected~~{}", affected);
}
}8、创建 src/main/java/com/lzw/springcloud/service/MemberService.java
package com.lzw.springcloud.service;
import com.lzw.springcloud.entity.Member;
/**
* @author LiAng
*/
public interface MemberService {
//根据id返回member
public Member queryMemberById(Long id);
//添加member
public int save(Member member);
}9、创建 src/main/java/com/lzw/springcloud/service/impl/MemberServiceImpl.java
package com.lzw.springcloud.service.impl;
import com.lzw.springcloud.dao.MemberDao;
import com.lzw.springcloud.entity.Member;
import com.lzw.springcloud.service.MemberService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @author LiAng
*/
@Service
public class MemberServiceImpl implements MemberService {
//装配MemberDao
@Resource
private MemberDao memberDao;
@Override
public Member queryMemberById(Long id) {
return memberDao.queryMemberById(id);
}
@Override
public int save(Member member) {
return memberDao.save(member);
}
}10、修改 MemberApplicationTest.java 测试
//装配MemberService
@Resource
private MemberService memberService;
//这里的@Test 选择 org.junit.jupiter.api.Test
@Test
public void queryMemberById(){
//Member member = memberDao.queryMemberById(1l);
Member member = memberService.queryMemberById(1l);
log.info("member={}",member);
}
@Test
public void save() {
Member member =
new Member(null, "大树精", "123", "13000000000", "hlj@sohu.com", 1);
//int affected = memberDao.save(member);
int affected = memberService.save(member);
log.info("affected~~{}", affected);
}11、创建 src/main/java/com/lzw/springcloud/controller/MemberController.java
package com.lzw.springcloud.controller;
import com.lzw.springcloud.entity.Member;
import com.lzw.springcloud.entity.Result;
import com.lzw.springcloud.service.MemberService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
/**
* @author LiAng
*/
@Slf4j
@RestController
public class MemberController {
//装配MemberService
@Resource
private MemberService memberService;
@PostMapping("/member/save")
public Result save(@RequestBody Member member) {
int affected = memberService.save(member);
if (affected > 0) { //说明添加成功
return Result.success("添加会员成功", affected);
} else {
return Result.error("401", "添加会员失败");
}
}
//查询的方法/接口
//使用url占位符+@PathVariable
@GetMapping("/member/get/{id}")
public Result getMemberById(@PathVariable("id") Long id) {
Member member = memberService.queryMemberById(id);
//使用Result把查询到的结果返回
if (member != null) {
return Result.success("查询会员成功", member);
} else {
return Result.error("402","ID= " + id + "不存在");
}
}
}12、分别测试
创建使用会员微服务模块-service consumer
示意图
步骤
1、创建 Moduel(member-service-consumer-80) & 完成配置
2、创建 controller
3、完成测试
1、创建 member-service-consumer-80 微服务模块[使用会员服务]
配置 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.lzw</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>member-service-consumer-80</artifactId>
<!--引入相关的依赖-->
<dependencies>
<!--引入web-starter 我们使用版本仲裁(从父项目继承了版本)-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--说明:starter-actuator 是springboot程序的监控系统, 可以实现系统的健康检测
可以通过http://localhost:10000/actuator 看到相关的连接,和信息
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
</project>创建 src/main/resources/application.yml
（我的80端口被占用了，所以改成了81）
server:
port: 81
spring:
application:
name: member_service-consumer-81创建 src/main/java/com/lzw/springcloud/MemberConsumerApplication.java
package com.lzw.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @author LiAng
*/
@SpringBootApplication
public class MemberConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(MemberConsumerApplication.class,args);
}
}运行测试
2、创建 src/main/java/com/lzw/springcloud/entity/Member.java
package com.lzw.springcloud.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author LiAng
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Member {
private Long id;
private String name;
private String pwd;
private String mobile;
private String email;
private Integer gender;
}3、创建 src/main/java/com/lzw/springcloud/entity/Result.java
package com.lzw.springcloud.entity;
/**
* @author LiAng
*/
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() {
}
//带参构造器-指定返回的data
public Result(T data) {
this.data = data;
}
//编写方法-返回需要的Result对象-表示成功的Result
public static Result success() {
Result result = new Result<>();
result.setCode("200");
result.setMsg("success");
return result;
}
//编写方法-返回需要的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对象-表示失败的Result
public static Result error(String code, String msg) {
Result result = new Result<>();
result.setCode(code);
result.setMsg(msg);
return result;
}
//编写方法-返回需要的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;
}
//编写方法-返回需要的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;
}
}4、注入 RestTemplate
基本介绍
1、RestTemplate 是 Spring 提供的用于访问 Rest 服务的模板类
2、RestTemplate 提供了多种便捷访问远程 Http 服务的方法
3、可以这样理解：通过 RestTemplate, 我们可以发出 http 请求(支持 Restful 风格)，去调用 Controller 提供的 API 接口，就像我们使用浏览器发出 http 请求，调用该 API 接口一样
4、使用简单便捷
官网地址：https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html
创建
package com.lzw.springcloud.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
/**
* @author LiAng
* 配置类
* 配置注入 RestTemplate
*/
@Configuration
public class CustomizationBean {
//配置注入RestTemplate bean/对象
@Bean
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
}5、创建 src/main/java/com/lzw/springcloud/controller/MemberConsumerController.java
package com.lzw.springcloud.controller;
import com.lzw.springcloud.entity.Member;
import com.lzw.springcloud.entity.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
/**
* @author LiAng
*/
@RestController
@Slf4j
public class MemberConsumerController {
//定义member_service_provider_url 这是一个基础url地址
//使用shift+ctrl+u 进行字母大小写的切换
public static final String MEMBER_SERVICE_PROVIDER_URL =
"http://localhost:10001";
//装配RestTemplate bean/对象
@Resource
private RestTemplate restTemplate;
//方法/接口 添加member对象到数据库/表
@PostMapping("/member/consumer/save")
public Result<Member> save(Member member) {
log.info("service-consumer member={}",member);
//完整的url :MEMBER_SERVICE_PROVIDER_URL + "/member/save" => http://localhost:10001/member/save
//member : 就是通过restTemplate 发出的post请求携带数据(对象)
//Result.class: 返回对象类型
return restTemplate.postForObject(MEMBER_SERVICE_PROVIDER_URL+"/member/save",member,Result.class);
}
//方法/接口 , 根据id 调用服务接口,返回member对象信息
@GetMapping("/member/consumer/get/{id}")
public Result<Member> getMemberById(@PathVariable("id") Long id) {
return restTemplate.getForObject(MEMBER_SERVICE_PROVIDER_URL + "/member/get/" + id, Result.class);
}
}先运行 提供会员服务，再运行 使用会员服务 进行测试
注意事项和细节
添加会员数据库中为 null 的解决方案
将 提供会员服务 模块加入注解@RequestBody
修改一下 Entity 使其支持 序列化
开启 Run DashBoard
当 springcloud 的服务有多个时，管理多个服务的启动使用 run 会不好管理，这样我们就可以使用 Run Dashboard。
- 找到 你的项目/.idea/workspace.xml 文件在其中添加下面的代码即可
<component name="RunDashboard">
<option name="configurationTypes">
<set>
<option value="SpringBootApplicationConfigurationType" />
</set>
</option>
<option name="ruleStates">
<list>
<RuleState>
<option name="name" value="ConfigurationTypeDashboardGroupingRule" />
</RuleState>
<RuleState>
<option name="name" value="StatusDashboardGroupingRule" />
</RuleState>
</list>
</option>
</component>放在 <project version="4">后
- 重新启动 IDEA , 会看到如下界面
创建共用模块-供其它模块使用
需求
实现步骤
创建 e_commerce_center-common-api 模块
修改pom.xml
<!--引入公共模块需要的依赖-->
<dependencies>
<!--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>
</dependencies>抽取共用 API/类
enetity
package com.lzw.springcloud.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @author LiAng
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Member implements Serializable {
private Long id;
private String name;
private String pwd;
private String mobile;
private String email;
private Integer gender;
}package com.lzw.springcloud.entity;
/**
* @author LiAng
*/
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() {
}
//带参构造器-指定返回的data
public Result(T data) {
this.data = data;
}
//编写方法-返回需要的Result对象-表示成功的Result
public static Result success() {
Result result = new Result<>();
result.setCode("200");
result.setMsg("success");
return result;
}
//编写方法-返回需要的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对象-表示失败的Result
public static Result error(String code, String msg) {
Result result = new Result<>();
result.setCode(code);
result.setMsg(msg);
return result;
}
//编写方法-返回需要的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;
}
//编写方法-返回需要的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;
}使用Maven打成jar包
clean完，install 
工程重构
在 member-service-consumer-80 引入 e_commerce_center-common-api-1.0-SNAPSHOT.jar
删除原来entity包
修改pom.xml
<!--引入e_commerce_center-common-api-->
<!--version=1.0-SNAPSHOT-->
<!--groupId=com.lzw.springcloud-->
<!--artifactId=e_commerce_center-common-api-->
<dependency>
<groupId>com.lzw</groupId>
<artifactId>e_commerce_center-common-api</artifactId>
<version>${project.version}</version>
</dependency>在 member-service-provider-10000 引入 e_commerce_center-common-api-1.0-SNAPSHOT.jar
删除原来entity包
修改pom.xml
<!--引入e_commerce_center-common-api-->
<!--version=1.0-SNAPSHOT-->
<!--groupId=com.lzw.springcloud-->
<!--artifactId=e_commerce_center-common-api-->
<dependency>
<groupId>com.lzw</groupId>
<artifactId>e_commerce_center-common-api</artifactId>
<version>${project.version}</version>
</dependency>完成测试
浏览器输入 http://localhost/member/consumer/get/1