技术选型
1. 上篇：SpringBoot 2.X版和SpringCloud H版
2. 下篇：SpringCloud Alibaba
3. Springcloud和Springboot之间的依赖关系如何看：
4. 更详细的版本对应查看方法
不仅有Cloud和Boot的选择约束，还有其他。
5. 最终选择
cloud Hoxton.SR1
boot 2.2.2.RELEASE
cloud alibaba 2.1.0.RELEASE
JAVA JAVA8
Maven 3.5及以上
Mysql 5.7及以上
boot最新版已经到2.4.x了，为什么用2.2.2呢？
需要照顾到cloud，由cloud来选择boot的版本。
6. 参考资料
1 父工程
1.1 父工程环境
1. 父工程
2. 工程名
3. 字符编码
4. 注解生效激活
5. java编译版本 1.8
6. File Type过滤
得到效果：
1.2 父工程POM：
此处只是约定了下子工程引入依赖时的版本号。
如果不想用这个版本，子模块可以自行决定，也不行加别的依赖。
1. <packaging>pom</packaging>
2. 删掉src等文件夹，只留一个pom.xml
3. dependencyManagement和dedependencies
1. <dependencyManagement>：
Maven使用dependencyManagement元素来提供一管理依赖版本号的方式。
通常会在一个组织或者项目的最顶层POM中看到dependencyManagement元素。
使用pom.xml中的dependencyManagement元素能让所有在子项目中引用一个依赖而不用显式
的列出版本号。
Maven会沿着父子层次向上走，直到找到一个拥有dependencyManagement元素的项目，然后
它就会使用这个dependencyManagement元素中指定的版本号，
即：一般用在父工程，子模块继承之后，提供作用：锁定版本+子module不用写groupId和version
例如在父项目中：
<dependencyManagement>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.2</version>
</dependency>
...
</dependencies>
</dependencyManagement>
在子项目里就可以添加mysql-connector-java时可以不指定版本号，例如：
<dependencyManagement>
<dependencies>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependencies>
</dependencyManagement>
这样做的好处就是：如果有多个子项目都引用同一样的依赖，则可以避免在每个使用的子项目里都声明
一个版本号，这样当想升级或切换到另一个版本时只需在顶层改即可，就很方便。
如果某个子项目需要另外的一个版本，只需单独声明version即可。
注意：dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明去要用的依赖。子项目没有指定版本号时，才会从父项目处继承依赖。
4. Maven中跳过单元测试
跳过maven生命周期的test阶段（为了节省时间）。
5. 父工程创建完成执行mvn:install将父工程发布到仓库方便子工程继承。
注意：mysql-connector-java与Mysql、Java的对应版本
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
所以MySQL我重新安装了一个5.7的版本
<mysql.version>8.0.18</mysql.version>
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>cloud2020</artifactId>
<version>1.0-SNAPSHOT</version>
<!--这是一个总的maven父工程-->
<packaging>pom</packaging>
<!--统一管理jar包版本-->
<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.18.10</lombok.version>
<mysql.version>8.0.18</mysql.version>
<druid.version>1.1.16</druid.version>
<mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
</properties>
<!--子模块继承之后，提供作用：锁定版本+子module不用写groupId和version-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>3.0.0</version>
</dependency>
<!--spring boot 2.2.2-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.2.2.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--spring cloud Hoxton.SR1-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Hoxton.SR1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--spring cloud 阿里巴巴-->
<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>
<scope>runtime</scope>
</dependency>
<!-- druid-->
<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>
<!--junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
</dependency>
<!--log4j-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
2 Rest微服务工程构建
1. 建module
2. 改pom
3. 写yml
4. 主启动
5. 业务类
2 微服务提供者 支付Module模块
2.1 建Module： cloud-provider-payment8001
1. 建Module
2.2 改pom
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>cloud2020</artifactId>
<groupId>com.atguigu.springcloud</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<!--由于父类写了dependencyManagement，所以这里不用谢groupId和version-->
<artifactId>cloud-provider-payment8001</artifactId>
<dependencies>
<!--web/actuator这两个一般一起使用，写在一起-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--监控-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!--Mybatis和SpringBoot的整合-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<!--如果没写版本,从父层面找,找到了就直接用,全局统一-->
</dependency>
<!--mysql-connector-java-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--jdbc-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--热部署-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>
2.3 写yml
3. 写yml
# 微服务端口号
server:
port: 8001
# 微服务名称
spring:
application:
name: cloud-payment-service
datasource:
type: com.alibaba.druid.pool.DruidDataSource # 数据源
driver-class-name: com.mysql.cj.jdbc.Driver # mysql驱动包
url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
username: root
password: root
mybatis:
mapper-locations: classpath:mapper/*.xml # 扫描类路径下mapper文件夹下的.xml配置文件
type-aliases-package: com.atguigu.springcloud.entities # 该包所有Entity类，取默认别名
2.4 主启动类
4. 主启动类
@SpringBootApplication
public class PaymentMain8001 {
public static void main(String[] args) {
SpringApplication.run(PaymentMain8001.class, args);
}
}
2.5 业务类
5. 业务类
1. 建表 SQL
2. entities
3. dao
4. service
5. controller
2.5.1 建表 SQL
1. SQL语句
CREATE TABLE `payment`(
#注释它是 'ID'
`id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
# 单引号引住，默认值是空字符串
`serial` VARCHAR(200) DEFAULT'',
PRIMARY KEY(`id`)
)ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8
2.5.2 后端业务
1. 主实体：Payment
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {
private Long id;
private String serial;
}
2. Json封装体CommonResult
返回给前端的一个通用的JSON实体串，和前端沟通时，不讲具体后台业务。
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
//404 not_found ： Integer String
private Integer code;
private String message;
//这不是针对某一个实体类的Josn串封装类
private T data;
//当T是null时，定义一个两个参数的构造
public CommonResult(Integer code, String message){
this(code, message, null);
}
}
3. dao
1. dao接口
@Mapper
public interface PaymentDao {
public int create(Payment payment);
public Payment getPaymentById(@Param("id") Long id);
}
2. classpath:mapper/PaymentMapper.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.PaymentDao">
<!--
注意yml中:type-aliases-package: com.atguigu.springcloud.entities # 该包所有Entity类，取默认别名
useGeneratedKeys="true",keyProperty="id"
设置插入成功时使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中
-->
<insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
insert into payment(serial) values(#{serial});
</insert>
<!--定义一个结果接和实体类的映射表-->
<resultMap id="BaseResultMap" type="com.atguigu.springcloud.entities.Payment">
<id column="id" property="id" jdbcType="BIGINT"/>
<id column="serial" property="serial" jdbcType="VARCHAR"/>
</resultMap>
<select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap">
select * from payment where id=#{id};
</select>
</mapper>
4. service
1. PaymentService
public interface PaymentService {
public int create(Payment payment);
public Payment getPaymentById(@Param("id") Long id);
}
2. PaymentServiceImpl
@Service
public class PaymentServiceImpl implements PaymentService {
@Resource
private PaymentDao paymentDao;
public int create(Payment payment){
return paymentDao.create(payment);
}
public Payment getPaymentById(Long id){
return paymentDao.getPaymentById(id);
}
}
5. controller
@RestController
@Slf4j
public class PaymentController {
@Resource
private PaymentService paymentService;
//传给前端JSON
@PostMapping(value = "/payment/create") //写操作POST
public CommonResult create(Payment payment){
//由于在mapper.xml配置了useGeneratedKeys="true" keyProperty="id"，会将自增的id封装到实体类中
int result = paymentService.create(payment);
log.info("*****插入结果：" + result);
if(result > 0){
return new CommonResult(200, "插入数据库成功", result);
}else {
return new CommonResult(444,"插入数据库失败", null);
}
}
//传给前端JSON
@GetMapping(value = "/payment/get/{id}") //写操作POST
public CommonResult getPaymentById(@PathVariable("id") Long id){
Payment payment = paymentService.getPaymentById(id);
log.info("*****查询结果：" + payment);
if(payment != null){
return new CommonResult(200, "查询数据库成功", payment);
}else {
return new CommonResult(444,"查询ID:"+id+"没有对应记录", null);
}
}
}
2.6 测试
2.6.1 测试@GetMapping(value = "/payment/get/{id}")
1. 启动报错：
Cause:
Error resolving class. Cause: org.apache.ibatis.type.TypeException:
Could not resolve type alias 'BaseResultMap'.
Cause: java.lang.ClassNotFoundException: Cannot find class: BaseResultMap
2. 启动报错：errorCode 1045, state 28000
create connection SQLException, url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8, errorCode 1045, state 28000
原因
改成password: root
3. 测试失败：发送请求http://localhost:8001/payment/get/1
原因：
改成
4. 测试成功
2.6.2 测试@PostMapping(value = "/payment/create")
1. 测试：发送请求http://localhost:8001/payment/create?serial=atguigu002
2. 测试失败：403
请求方法不支持：
3. 原因：
controller中插入方法的接收POST请求，但是这样发送的却是GET请求。
4. POSTMAN 模拟发送POST请求
测试成功
注意：浏览器不好直接发送POST请求。
2.7 小结
1. 建module
2. 改pom
3. 写yml
4. 主启动
4. 业务类
3 热部署Devtools
1. Adding devtools to your project
粘贴到子模块 cloud-provider-payment8001 的pom.xml中
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
2. Adding plugin to your pom.xml
粘贴到聚合父类总工程的pom.xml里
<build>
<finalName>cloud2020</finalName> # 可加可不加
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<fork>true</fork>
<addResources>true</addResources>
</configuration>
</plugin>
</plugins>
</build>
3. Enabling automatic build
开启自动编译的选项
4. Update the value of
热注册开启：
ctrl+alt+shift+/:弹出一个选框，选第一个.
勾选：这两个
5. 重启IDEA
6. 建议：只在开发阶段使用，实际上线生产部署阶段必须关闭。
太慢了，效果不明显，吃配置，电脑会卡。
而且如果热部署起效慢的话，我得请求资源会404。
3 微服务消费者 消费Module模块
1. 建module
2. 改pom
3. 写yml
4. 主启动
5. 业务类
3.1 建Module：cloud-consumer-order80
3.2 改pom
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--监控-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!--热部署-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
3.3 写yml
80端口是默认的http端口，可以默认不写
baidu.com ==== baidu.com:80
8080和80端口无本质区别
Apache Tomcat web server安装后，默认的服务端口就是8080
因为考虑到用户发送请求一般不会输入80，所以给消费者模块加80端口。
3.5 主启动类
@SpringBootApplication
public class OrderMain80 {
public static void main(String[] args) {
SpringApplication.run(OrderMain80.class, args);
}
}
3.6 业务类
消费者要调用8001端口的生产者，那么在业务类中还要service/controller/dao等包吗？
显然，消费者不需要访问数据库等操作，只需要一个controller控制层即可。
3.6.1 后端代码
1. 实体类Payment
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {
private Long id;
private String serial;
}
2. JSON封装类 CommonResult<T>
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
//404 not_found ： Integer String
private Integer code;
private String message;
//这不是针对某一个实体类的Josn串封装类
private T data;
//当T是null时，定义一个两个参数的构造
public CommonResult(Integer code, String message){
this(code, message, null);
}
}
3. controller控制层
用restTemplate实现消费者和提供者微服务之间的横向调用
1. RestTemplate提供了多种便捷访问远程Http服务的方法，是一种简单便捷的访问restful
服务模版类，是Spring提供的用于访问Rest服务的客户端模版工具。
2. 使用
使用restTemplate访问restful接口非常的简单粗暴无脑
(url, requestMap, ResponseBean.class)这是那个参数分别代表：
rest请求地址，请求参数，HTTP响应转换成的对象类型。
3. 依靠一个配置类，将其注入到容器
4. 配置类： 向容器中注入一个restTemplate Bean
@Configuration
public class ApplicationContextConfig {
@Bean
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
}
5. controller代码
当消费者模块接收到请求时，会用restTemplate去调用生产者模块中的方法
即用restTemplate实现消费者和提供者微服务之间的横向调用。
@RestController
@Slf4j
public class OrderController {
//暂时在这里写死
public static final String PAYMENT_URL = "http:localhost:8001";
/**
* 用restTemplate实现消费者和提供者微服务之间的横向调用
*/
@Resource
private RestTemplate template;
//按理说插入数据应该是POST，可以从浏览器只能发GET请求，尽管不符合RESTFUL，
// 但是下面的template.postForObject调用却是POST请求
@GetMapping("/consumer/payment/create")
public CommonResult<Payment> create(Payment payment){
//调用生产者模块中的生产方法
return template.postForObject(PAYMENT_URL+"payment/create", payment, CommonResult.class);
}
@GetMapping("/consumer/payment/get/{id}")
public CommonResult<Payment> getPayment(@PathVariable("id") Long id){
return template.getForObject(PAYMENT_URL+"/payment/get/"+id, CommonResult.class);
}
}
3.7 测试查询操作
1. 先启动生产者8001 模块
2. 在启动消费者80 模块
3. Services
当我启动第二个模块时，IDEA给了我提示，按照提示点击。
4. 生产者8001 自测通过
5. 用消费者80模块，调用生产者8080中的接口
注意：我们默认消费者是不知道端口的，所以消费者端口是80可以默认不写。
http://localhost/consumer/payment/get/2
6. 测试成功
3.8 测试插入操作
1. 发送请求：http://localhost/consumer/payment/create?serial=ttxxll
说明调用流程成功了。
2. 但是数据库中的结果：
说明插入操作的确插入了，但是插入的是一个空值。
3. 不要忘了@RequestBody注解
@RequestBody注解对应的类在将HTTP的输入流(含请求体)装配到目标类(即:@RequestBody后面 的类)时，会根据json字符串中的key来匹配对应实体类的属性，如果匹配一致且json中的该key对应的值符合(或可转换为)实体类的对应属性的类型要求时，会调用实体类的setter方法将值赋给该属性。
原因：
@GetMapping("/consumer/payment/create")
public CommonResult<Payment> create(Payment payment){
/**
* 调用生产者模块中的生产方法
*
* 这里要注意一下：restTemplate是访问Rest服务的客户端模版工具类，这里类似于又发送一个http请求，
* 但是第二个参数payment对象在传递(http传输)的过程中，肯定要序列化，这里肯定是Json字符串了，
* 所以在生产者那边根据默认的参数封装规则，封装不进去。
* --->所以生产者中的接收该参数的方法要加上@RequestBody注解
*/
return template.postForObject(PAYMENT_URL+"/payment/create", payment, CommonResult.class);
}
4. 在生产者接收该参数的方法要加上@RequestBody注解
5. 插入操作测试成功
4. 工程重构
我们发现了一个问题：
两个微服务模块中都有entities，而且一模一样。如果程序中有很多这样的代码，那么这就有冗余。
我们要将其抽取出来，形成我们自己的jar包。
打成一份，一分部署，处处共用。
思想：
将相同重复的代码，将其抽取到一个公开共用的一个工程里面，供大家统一调配使用。
4.1 新建一个公开共用的木块： cloud-api-commons
这个模块不对外暴露，所以不像前面的两个微服务命名上有接口。
4.2 改pom
<dependencies>
<!--热部署-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!--糊涂工具包-->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.1.0</version>
</dependency>
</dependencies>
4.3 将entities包放到cloud-api-commons模块
4.4 打包发布
将其maven打包，发布上传到我们共用的本地库，供其他两个模块调用。
clean + install
发布到了我的本地仓库：
D:\Developer_Tools\maven_repository\com\atguigu\springcloud\cloud-api-commons\1.0-SNAPSHOT
4.5 改造生产者和消费者模块
1. 删除各自的原先有的entities文件夹
2. 引入刚才发布的jar包
<!--引入我们自定义的公共api jar包-->
<dependency>
<groupId>com.atguigu.springcloud</groupId>
<artifactId>cloud-api-commons</artifactId>
<version>${project.version}</version>
</dependency>
4.6 测试
测试成功。
