Skip to content

S
SpringCloud2020

梦中观雨 / SpringCloud2020
与 Fork 源项目一致

Fork自 Lcry / SpringCloud2020

通知 3
Star 0
Fork 0
S
SpringCloud2020

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 c11faa2d 编写于 作者: Lcry's avatar Lcry 🖥
浏览文件
操作

P138-P148：完成分布式事务Seata,更新Readme

上级 e10c8f00
隐藏空白更改
内联 并排
Showing with 3679 addition and 14 deletion
.gitignore
浏览文件 @ c11faa2d
......@@ -139,4 +139,7 @@ cloudalibaba-provider-nacos-payment9002/target/
cloudalibaba-provider-nacos-payment9003/target/
cloudalibaba-provider-nacos-payment9004/target/
cloudalibaba-sentinel-service8401/target/
cloudalibaba-consumer-nacos-order84/target/
\ No newline at end of file
cloudalibaba-consumer-nacos-order84/target/
cloudalibaba-seata-order-service12001/target/
cloudalibaba-seata-storage-service12002/target/
cloudalibaba-seata-account-service12003/target/
\ No newline at end of file
README.md
浏览文件 @ c11faa2d
# SpringCloud2020学习笔记
#### 技术选型
SpringCloud：Hoxton.SR1
## 技术选型
SpringBoot：2.2.2RELEASE
| 依赖 | 版本 |
| ------------------- | ------------- |
| SpringCloud | Hoxton.SR1 |
| SpringBoot | 2.2.2.RELEASE |
| SpringCloud Alibaba | 2.1.0.RELEASE |
SpringCloud Alibaba：2.1.0.RELEASE
Java：8
Maven：3.5及以上
## 工具汇总
MySQL：5.7及以上
| 名称 | 版本 | 备注 | 下载地址 |
| ------------- | -------- | -------------------- | ------------------------------------------------------------ |
| Java | 8 | | [官网下载](https://www.oracle.com/java/technologies/javase-jdk8-downloads.html) |
| Maven | 3.5+ | | [官网下载](http://maven.apache.org/download.cgi) |
| MySQL | 5.7+ | | [官网下载](https://dev.mysql.com/downloads/mysql/5.7.html) |
| IntelliJ IDEA | 2019.3.3 | | [官网下载](https://www.jetbrains.com/idea/download/) |
| zookeeper | 3.4.14 | | [官网下载](https://zookeeper.apache.org/releases.html) |
| nacos-server | 1.2.0 | nacos服务端 | [Github下载](https://github.com/alibaba/nacos/releases/tag/1.2.0) |
| consul-server | 1.7.2 | consul服务端 | [官网下载](https://www.consul.io/downloads.html) |
| zipkin-server | 2.12.9 | zipkin链路监控服务端 | [第三方下载](https://dl.bintray.com/openzipkin/maven/io/zipkin/java/zipkin-server/) |
| postman | 7.20.1 | 接口请求测试 | [官网下载](https://www.postman.com/downloads/) |
| Seata | 0.9.0 | 分布式事务服务端 | [官网下载](https://seata.io/zh-cn/blog/download.html) |
> 项目中使用的数据库文件在项目根目录resouces/SQL/下，阶段代码直接查看提交记录
>
> 配套视频：https://www.bilibili.com/video/av93813318
## 项目结构说明
#### 项目结构
| 项目名 | 用途 | 所用技术 |
| --------------------------------------- | :---------------------------------------------- | ------------------------------------------------------------ |
| cloud-api-commons | 公共代码部分（返回结果集、实体等） | \ |
......@@ -44,10 +61,1674 @@ MySQL：5.7及以上
| cloudalibaba-provider-nacos-payment9004 | 服务方通过Nacos注册服务模拟查询2 | 服务注册（Nacos） |
| cloudalibaba-sentinel-service8401 | 服务限流和熔断Sentinel示例 | 服务注册（Nacos）、服务限流和熔断（Sentinel） |
| cloudalibaba-consumer-nacos-order84 | 消费方通过整合Feign和Sentinel | 服务注册（Nacos）、服务限流和熔断（Sentinel）、服务调用（Openfeign）、负载均衡（Rabbin） |
| cloudalibaba-seata-order-service12001 | 分布式事务商品下单微服务 | 分布式事务（Seata）、服务注册（Nacos）、服务调用（Openfeign）、负载均衡（Rabbin） |
| cloudalibaba-seata-storage-service12002 | 分布式事务库存微服务 | 分布式事务（Seata）、服务注册（Nacos）、服务调用（Openfeign）、负载均衡（Rabbin） |
| cloudalibaba-seata-account-service12003 | 分布式事务账户微服务 | 分布式事务（Seata）、服务注册（Nacos）、服务调用（Openfeign）、负载均衡（Rabbin） |
## 知识点整理
### 一、服务注册与发现
#### 1、使用Eureka服务端
1）导入依赖
```xml
<!--eureka-server-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
<!--热部署推荐一起-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 7001
eureka:
instance:
hostname: eureka7001.com #Eureka服务端的实例名称
client:
#false表示不向注册中心中注册自己
register-with-eureka: false
#false表示自己就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
fetch-registry: false
service-url:
#设置与Eureka Server之间交互的地址，查询服务和注册服务都需要依赖这个地址
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #单机版,指向自己
#defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka #集群版
server:
#关闭Eureka自我保护机制，保证不可用服务被及时剔除
enable-self-preservation: false
eviction-interval-timer-in-ms: 2000
```
3）启动类添加注解@EnableEurekaServer
```java
@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7001 {
public static void main(String[] args) {
SpringApplication.run(EurekaMain7001.class, args);
}
}
```
4）验证
访问：http://localhost:7001
> 对应项目：cloud-eureka-server7001、cloud-eureka-server7002
#### 2、使用Eureka客户端
1）导入依赖
```xml &lt;!--引入eureka客户端eureka-client --&gt;
<!--引入eureka客户端eureka-client -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 8001
spring:
application:
name: cloud-payment-service
eureka:
client:
#表示是否将自己注册进EurekaServer，默认为true
register-with-eureka: true
#是否从EurekaServer中抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
fetchRegistry: true
service-url:
defaultZone: http://localhost:7001/eureka #单机版
#defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka #集群版
instance:
instance-id: payment8001 #修改Status名称
prefer-ip-address: true
#Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认30)
lease-renewal-interval-in-seconds: 10
#Eureka服务端在收到最后一次心跳后等待的时间上限，单位为秒(默认90)，超时剔除服务
lease-expiration-duration-in-seconds: 60
```
3）启动类添加注解@EnableDiscoveryClient（推荐）或者@EnableEurekaClient
```java
@SpringBootApplication
@EnableDiscoveryClient //Discovery服务发现
public class PaymentMain8001 {
public static void main(String[] args) {
SpringApplication.run(PaymentMain8001.class, args);
}
}
```
> 对应项目：cloud-provider-payment8001、cloud-provider-payment8002等
#### 3、使用Zookeeper注册服务
1）导入依赖
```xml
<!-- SpringBoot整合zookeeper客户端 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
<!-- 先排除自带的zookeeper -->
<exclusions>
<exclusion>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- 添加本机zookeeper3.4.14版本 -->
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.14</version>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 8004
#服务别名——注册到zookeeper注册中心的名称
spring:
application:
name: cloud-provider-payment
cloud:
zookeeper:
connect-string: 127.0.0.1:2181
```
3）启动类添加注解@EnableDiscoveryClient
```java
@SpringBootApplication
@EnableDiscoveryClient //该注解用于向使用zookeeper作为注册中心时注册服务
public class ZkPaymentMain8004 {
public static void main(String[] args) {
SpringApplication.run(ZkPaymentMain8004.class, args);
}
}
```
> 对应项目：cloud-provider-zk-payment8004
#### 4、使用Consul注册服务
1）导入依赖
```xml
<!-- consul软件官方下载：https://www.consul.io/downloads.html
开发模式启动：consul agent -dev
验证：浏览器访问 http://localhost:8500
若提示:
Consul returned an error. You may have visited a URL that is loading an unknown resource,so you can try going back to the root or try re-submitting your ACL Token/SecretID by going back to ACLs.
错误请使用其他浏览器访问试试
-->
<!--consul版服务提供方-->
<!--SpringCloud consul-server -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 8006
spring:
application:
name: consul-provider-payment
#consul注册中心地址
cloud:
consul:
host: localhost
port: 8500
discovery:
#hostname: 127.0.0.1
service-name: ${spring.application.name}
```
3）启动类添加注解@EnableDiscoveryClient
```java
@SpringBootApplication
@EnableDiscoveryClient
public class ConsulPaymentMain8006 {
public static void main(String[] args) {
SpringApplication.run(ConsulPaymentMain8006.class, args);
}
}
```
> 对应项目：cloud-provider-consul-payment8006
### 二、负载均衡调用
#### 1、使用Ribbon负载均衡
默认eureka集成了rabbin，配置即可使用，默认是轮训策略。
1）新建规则类MySelfRule.java
```java
/**
* MySelfRule
*
* @author lcry
* 自定义Ribbon默认轮训规则类
*/
@Configuration
public class MySelfRule {
@Bean
public IRule myRule() {
return new RandomRule();//定义为随机
}
}
```
> IRule实现类有如下：
>
> com.netflix.loadbalancer.RoundRobinRule：轮询
>
> com.netflix.loadbalancer.RandomRule：随机
>
> com.netflix.loadbalancer.RetryRule：先按照RoundRobinRule的策略获取服务,如果获取服务失败则在指定时间内进行重试,获取可用的服务
>
> WeightedResponseTimeRule：对RoundRobinRule的扩展,响应速度越快的实例选择权重越多大,越容易被选择
>
> BestAvailableRule：会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务
>
> AvailabilityFilteringRule：先过滤掉故障实例,再选择并发较小的实例
>
> ZoneAvoidanceRule：默认规则,复合判断server所在区域的性能和server的可用性选择服务器
2）启动类添加注解`@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MySelfRule.class)//启用Ribbon`
```java
@SpringBootApplication
@EnableDiscoveryClient
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MySelfRule.class)//启用Ribbon
public class OrderMain80 {
public static void main(String[] args) {
SpringApplication.run(OrderMain80.class, args);
}
}
```
若使用restTemplate直接使用轮训规则，可以直接在配置类上@LoadBalanced注解
```java
/**
* ApplicationContextConfig
*
* @author lcry
* @date 2020/03/14 12:05
* 配置RestTemplate
*/
@Configuration
public class ApplicationContextConfig {
@Bean //相当于Spring中applicationContext.xml中<bean id="" class="">
@LoadBalanced //使用此注解赋予RestTemplate负载均衡的能力，测试自定义算法注释掉
public RestTemplate getRestTemplate() {
return new RestTemplate();
}
}
```
> 对应项目：cloud-consumer-order80
#### 2、使用OpenFeign
1）导入依赖
```xml
<!-- openfeign -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 80
eureka:
client:
register-with-eureka: false
service-url:
defaultZone: http://localhost:7001/eureka #单机版
#defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka #集群版
#OpenFeign的超时控制配置：默认只等待1秒，超时则报错
#设置Feign客户端超时时间（OpenFeign默认支持Ribbon）
ribbon:
#指的是建立连接所用的时间，适用于网络状况正常的情况下，两端连接所用的时间
ReadTimeout: 5000
#指的是建立连接后从服务器读取到可用资源所用的时间
connectTimeout: 5000
#开启Feign的日志客户端
logging:
level:
#Feign日志以什么级别监听哪个接口
com.lcry.springcloud.service.PaymentFeignService: debug
```
3）启动类添加注解@EnableFeignClients
```java
@SpringBootApplication
//启用Feign
@EnableFeignClients
public class FeignOrderMain80 {
public static void main(String[] args) {
SpringApplication.run(FeignOrderMain80.class, args);
}
}
```
4）配置日志打印信息 FeignConfig.java
```java
/**
* FeignConfig
*
* @author lcry
* @date 2020/03/14 22:04
* Feign日志控制
*/
@Configuration
public class FeignConfig {
@Bean
Logger.Level feignLoggerLevel() {
/**
* 日志级别：
* NONE ：不记录任何日志（默认）
* BASIC：仅记录请求方法、URL、响应状态代码以及执行时间
* HEADERS：记录BASIC级别的基础上，记录请求和响应的header
* FULL：记录请求和响应的header，body和元数据
*/
return Logger.Level.FULL;
}
}
```
5）远程调用服务
```java
/**
* PaymentFeignService
*
* @author lcry
*/
@Component
@FeignClient(value = "CLOUD-PAYMENT-SERVICE") //需要调用的目标微服务应用名称
public interface PaymentFeignService {
//Feign接口中的方法要与目标服务中的Controller中的方法完全一致，可以直接copy
@GetMapping(value = "/payment/get/{id}")
public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id);
@GetMapping(value = "/payment/feign/timeout")
public String paymentFeignTimeout();
}
```
> 对应项目：cloud-consumer-feign-order80
### 三、服务熔断与降级
#### 1、使用HyStrix熔断和降级
1）导入依赖
```xml
<!--hystrix-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 8001
spring:
application:
name: cloud-provider-hystrix-payment
eureka:
client:
register-with-eureka: true
fetch-registry: true
service-url:
defaultZone: http://127.0.0.1:7001/eureka
#defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
```
3）启动类添加注解@EnableHystrix
```java
@SpringBootApplication
@EnableEurekaClient
@EnableHystrix //服务端开启Hystrix或者使用@EnableCircuitBreaker
public class HystrixPaymentMain8001 {
public static void main(String[] args) {
SpringApplication.run(HystrixPaymentMain8001.class, args);
}
}
```
4）服务降级示例代码,@HystrixCommand注解实现
```java
/**
* 模拟超时3s
*
* @param id
* @return
*/
@Override
@HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler", commandProperties = {
//超时5s或者异常直接降级
@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "5000")
})
public String paymentInfo_TimeOut(Integer id) {
//int age = 10/0;
int timenum = 3;
try {
TimeUnit.SECONDS.sleep(timenum);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "线程池: " + Thread.currentThread().getName() + " id: " + id + "\t" + "O(∩_∩)O哈哈~" + " 耗时(秒): " + timenum;
}
public String paymentInfo_TimeOutHandler(Integer id) {
return "线程池: " + Thread.currentThread().getName() + " 8001系统繁忙或者运行报错，请稍后再试,id: " + id + "\t" + "o(╥﹏╥)o";
}
```
5）服务熔断示例代码
```java
/**
* 以下内容属于服务熔断
*
* @param id
* @return
*/
@Override
@HystrixCommand(fallbackMethod = "paymentCircuitBreaker_fallback", commandProperties = {
@HystrixProperty(name = "circuitBreaker.enabled", value = "true"),// 是否开启断路器
@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),// 请求次数
@HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "10000"), // 时间窗口期
@HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "60"),// 失败率达到多少后跳闸
})
public String paymentCircuitBreaker(@PathVariable("id") Integer id) {
if (id < 0) {
throw new RuntimeException("id 不能负数");
}
String serialNumber = IdUtil.simpleUUID();
return Thread.currentThread().getName() + "\t" + "调用成功，流水号: " + serialNumber;
}
public String paymentCircuitBreaker_fallback(@PathVariable("id") Integer id) {
return "id 不能负数，请稍后再试，/(ㄒoㄒ)/~~ id: " + id;
}
```
> 对应项目：cloud-provider-hystrix-payment8001、cloud-consumer-feign-order80
#### 2、使用HystrixDashboard监控仪表盘
1）导入依赖
```xml
<!-- hystrix服务监控平台dashboard -->
<!-- 被监控服务一定要引入web和actuator两个依赖 -->
<!--
监控地址：http：//ip：端口/hystrix
被监控填写：http://ip：端口/hystrix.stream
-->
<!-- hystrix-dashboard -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 9001
```
3）启动类添加注解@EnableHystrixDashboard
```java
/**
* HystrixDashboardMain9001
*
* @author lcry
*/
@SpringBootApplication
@EnableHystrixDashboard //启用注解
public class HystrixDashboardMain9001 {
public static void main(String[] args) {
SpringApplication.run(HystrixDashboardMain9001.class, args);
}
}
```
4）被监控端配置
- 引入依赖
```xml
<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>
```
- 启动类注入
```java
/**
* 此配置是为了服务监控而配置，与服务容错本身无关，springcloud升级后的坑
* ServletRegistrationBean因为springboot的默认路径不是"/hystrix.stream"，
* 只要在自己的项目里配置上下面的servlet就可以了
*/
@Bean
public ServletRegistrationBean getServlet() {
HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet);
registrationBean.setLoadOnStartup(1);
registrationBean.addUrlMappings("/hystrix.stream");
registrationBean.setName("HystrixMetricsStreamServlet");
return registrationBean;
}
```
5）验证
访问hystrix服务监控平台http：//localhost:9001，被监控填写：http:// ip：端口/hystrix.stream
> 对应项目：cloud-consumer-hystrix-dashboard9001、cloud-provider-hystrix-payment8001
### 四、路由网关
#### 1、使用Zuul
忽略，直接使用Gateway新一代网关
#### 2、使用SpringCloud Gateway
1）导入依赖
```xml
<!--gateway-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!--eureka-client-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!--引入自己定义的api调用包，可以使用Payment支付Entity-->
<dependency>
<groupId>com.lcry</groupId>
<artifactId>cloud-api-commons</artifactId>
<version>${project.version}</version>
</dependency>
```
2）通过application.yml配置路由网关示例（推荐）
```java
server:
port: 9527
spring:
application:
name: cloud-gateway
cloud:
gateway:
discovery:
locator:
enabled: true #开启从注册中心动态创建路由的功能，利用微服务名进行路由
routes:
- id: payment_route #payment_route #路由的ID，没有固定规则但要求唯一，建议配合服务名
#uri: http://localhost:8001 #匹配后提供服务的路由地址
uri: lb://cloud-payment-service #匹配后提供服务的路由地址
predicates:
- Path=/payment/get/** # 断言，路径相匹配的进行路由
- id: payment_route2 #payment_route #路由的ID，没有固定规则但要求唯一，建议配合服务名
#uri: http://localhost:8001 #匹配后提供服务的路由地址
uri: lb://cloud-payment-service #匹配后提供服务的路由地址
predicates:
- Path=/payment/lb/** # 断言，路径相匹配的进行路由
#- After=2020-02-21T15:51:37.485+08:00[Asia/Shanghai]
#- Cookie=username,zzyy
#- Header=X-Request-Id, \d+ # 请求头要有X-Request-Id属性并且值为整数的正则表达式
eureka:
instance:
hostname: cloud-gateway-service
client: #服务提供者provider注册进eureka服务列表内
service-url:
register-with-eureka: true
fetch-registry: true
defaultZone: http://localhost:7001/eureka
```
3）通过编码方式实现路由网关
```java
/**
* 通过编码方式实现路由
*/
@Configuration
public class GateWayConfig {
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder routeLocatorBuilder) {
RouteLocatorBuilder.Builder routes = routeLocatorBuilder.routes();
routes.route("path_route_baidunews",
r -> r.path("/guonei")
.uri("http://news.baidu.com/guonei")).build();
return routes.build();
}
}
```
4）自定义过滤逻辑示例 MyLogGateWayFilter.java
```java
/**
* 自定义过滤器示例-一般用于鉴权或者全局日志
*/
@Component
@Slf4j
public class MyLogGateWayFilter implements GlobalFilter, Ordered {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
log.info("***********come in MyLogGateWayFilter: " + new Date());
//请求参数必须带username，并且不能为空
String uname = exchange.getRequest().getQueryParams().getFirst("username");
if (StrUtil.isEmpty(uname)) {
log.info("*******用户名为空，非法用户，o(╥﹏╥)o");
exchange.getResponse().setStatusCode(HttpStatus.NOT_ACCEPTABLE);
return exchange.getResponse().setComplete();
}
return chain.filter(exchange); //放行给下一条过滤链
}
@Override
public int getOrder() {
//执行顺序，越小越先执行
return 0;
}
}
```
> 对应项目：cloud-gateway-gateway9527
### 五、分布式配置中心
#### 1、使用SpringCloud Config服务端
1）导入依赖
```xml
<!-- config-server依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 3344
spring:
application:
name: cloud-config-center #注册进Eureka服务器的微服务名
cloud:
config:
server:
git:
uri: git@gitee.com:lcry/springcloud-config.git #git仓库地址
####搜索目录
search-paths:
- springcloud-config
####读取分支
label: master
#服务注册到eureka地址
eureka:
client:
service-url:
defaultZone: http://localhost:7001/eureka
```
3）启动类添加注解@EnableConfigServer
```java
@SpringBootApplication
@EnableConfigServer //启用注册中心服务端
public class ConfigCenterMain3344 {
public static void main(String[] args) {
SpringApplication.run(ConfigCenterMain3344.class, args);
}
}
```
> 对应项目：cloud-config-center-3344
#### 2、使用SpringCloud Config客户端
1）导入依赖
```xml
<!-- spring-config客户端依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 3355
spring:
application:
name: config-client
cloud:
#Config客户端配置
config:
label: master #分支名称
name: config #配置文件名称
profile: dev #读取后缀名称 上述3个综合：master分支上config-dev.yml的配置文件被读取http://config-3344.com:3344/master/config-dev.yml
uri: http://localhost:3344 #配置中心地址server:
port: 3355
spring:
application:
name: config-client
cloud:
#Config客户端配置
config:
label: master #分支名称
name: config #配置文件名称
profile: dev #读取后缀名称 上述3个综合：master分支上config-dev.yml的配置文件被读取http://config-3344.com:3344/master/config-dev.yml
uri: http://localhost:3344 #配置中心地址
```
> 对应项目：cloud-config-client-3355、cloud-config-client-3356
### 六、消息总线
#### 1、使用SpringCloud Bus刷新配置
1）导入依赖
```xml
<!--添加消息总线RabbitMQ支持-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
```
2）SpringCloud Config服务端application.yml示例
```yaml
#rabbitmq相关配置
rabbitmq:
host: 192.168.179.150
port: 5672
username: admin
password: admin
#全局刷新POST请求 http://注册中心地址/actuator/bus-refresh
#定点通知：(只通知部分）http://注册中心地址/actuator/refresh/{服务名称:端口}
#如：http://localhost:3344/actuator/bus-refresh/config-client:3355
##rabbitmq相关配置,暴露bus刷新配置的端点
management:
endpoints: #暴露bus刷新配置的端点
web:
exposure:
include: 'bus-refresh'
```
3）SpringCloud Config客户端application.yml示例
```yaml
#rabbitmq相关配置 15672是Web管理界面的端口；5672是MQ访问的端口
rabbitmq:
host: 192.168.179.150
port: 5672
username: admin
password: admin
# 手动刷新地址POST http：//客户端访问地址/actuator/refresh
# curl -X POST "http://localhost:3355/actuator/refresh"
# 暴露监控端点
management:
endpoints:
web:
exposure:
include: "*"
```
4）刷新配置注解@RefreshScope
```java
@RestController
@RefreshScope //刷新配置生效
public class ConfigClientController {
@Value("${server.port}")
private String serverport;
@Value("${config.info}")
private String configInfo;
// 直接获取配置文件
@GetMapping("/configInfo")
public String getConfigInfo() {
return configInfo + "服务端口："+serverport;
}
}
```
> 对应项目：cloud-config-center-3344、cloud-config-center-3355、cloud-config-center-3356
### 七、消息驱动
#### 1、使用Stream发送方
1）导入依赖
```xml
<!-- 引入stream-rabbit-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 8801
spring:
application:
name: cloud-stream-provider
cloud:
stream:
binders: # 在此处配置要绑定的rabbitmq的服务信息；
defaultRabbit: # 表示定义的名称，用于于binding整合
type: rabbit # 消息组件类型
environment: # 设置rabbitmq的相关的环境配置
spring:
rabbitmq:
host: 192.168.179.150
port: 5672
username: admin
password: admin
bindings: # 服务的整合处理
output: # 这个名字是一个通道的名称
destination: studyExchange # 表示要使用的Exchange名称定义
content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
binder: defaultRabbit # 设置要绑定的消息服务的具体设置
eureka:
client: # 客户端进行Eureka注册的配置
service-url:
defaultZone: http://localhost:7001/eureka
instance:
lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒）
lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒）
instance-id: cloud-stream-provider8801 # 在信息列表时显示主机名称
prefer-ip-address: true # 访问的路径变为IP地址
```
3）定义推送管道
```java
/**
* //定义消息的推送管道
*/
@EnableBinding(Source.class) //定义消息的推送管道，生产者固定写法
@Slf4j
public class MessageProviderImpl implements IMessageProvider {
@Resource
private MessageChannel output; // 消息发送管道
@Override
public String send() {
String serial = UUID.randomUUID().toString();
output.send(MessageBuilder.withPayload(serial).build());
log.info(String.format("生成的流水号:{%s}", serial));
return serial;
}
}
```
> 对应项目：cloud-stream-provider-rabbitmq8801
#### 2、使用Stream接受方
1）导入依赖
```xml
<!-- stream-rabbit -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 8802
spring:
application:
name: cloud-stream-consumer
cloud:
stream:
binders: # 在此处配置要绑定的rabbitmq的服务信息；
defaultRabbit: # 表示定义的名称，用于于binding整合
type: rabbit # 消息组件类型
environment: # 设置rabbitmq的相关的环境配置
spring:
rabbitmq:
host: 192.168.179.150
port: 5672
username: admin
password: admin
bindings: # 服务的整合处理
input: # 这个名字是一个通道的名称
destination: studyExchange # 表示要使用的Exchange名称定义
content-type: application/json # 设置消息类型，本次为对象json，如果是文本则设置“text/plain”
binder: defaultRabbit # 设置要绑定的消息服务的具体设置
group: receiveclientA #分组避免重复消费和持久化问题
eureka:
client: # 客户端进行Eureka注册的配置
service-url:
defaultZone: http://localhost:7001/eureka
instance:
lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒）
lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒）
instance-id: cloud-stream-consumer8802 # 在信息列表时显示主机名称
prefer-ip-address: true # 访问的路径变为IP地址
```
3）接收消息逻辑代码
```java
@Component
@EnableBinding(Sink.class)
public class ReceiveMessageListenerController {
@Value("${server.port}")
private String serverPort;
@StreamListener(Sink.INPUT) //固定的写法，对应yml配置的通道名称
public void input(Message<String> message) {
System.out.println("消费者1号,----->接受到的消息: " + message.getPayload() + "\t port: " + serverPort);
}
}
```
> 对应项目：cloud-stream-consumer-rabbitmq8802、cloud-stream-consumer-rabbitmq8802
### 八、分布式链路追踪
#### 1、使用sleuth客户端
1）导入依赖
```xml
<!--链路监控包含了sleuth+zipkin-->
<!--服务端下载地址：https://dl.bintray.com/openzipkin/maven/io/zipkin/java/zipkin-server/-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>
<!--引入eureka客户端eureka-client -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</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-actuator</artifactId>
</dependency>
```
2）application.yml示例
```yaml
spring:
application:
name: cloud-payment-service
#链路监控配置，配置链路监控服务端地址
zipkin:
base-url: http://localhost:9411
sleuth:
sampler:
#采样率值介于 0 到 1 之间，1 则表示全部采集
probability: 1
```
> 对应项目：cloud-provider-payment8001、cloud-consumer-order80
### 九、SpringCloud alibaba
#### 1、使用Nacos服务注册
1）导入依赖
```xml
<!--SpringCloud ailibaba nacos -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
```
2）application.yml示例
```yaml
server:
port: 9001
spring:
application:
name: nacos-payment-provider
cloud:
nacos:
discovery:
server-addr: localhost:8848 #配置Nacos地址,注册服务到Nacos
management:
endpoints:
web:
exposure:
include: '*'
```
3）启动类添加注解@EnableDiscoveryClient
```java
/**
* NacosPaymentMain9001
*
* @author lcry
* @date 2020/03/16 18:03
*/
@EnableDiscoveryClient
@SpringBootApplication
public class NacosPaymentMain9001 {
public static void main(String[] args) {
SpringApplication.run(NacosPaymentMain9001.class,args);
}
}
```
> 对应项目：cloudalibaba-provider-nacos-payment9001、cloudalibaba-provider-nacos-payment9002
#### 2、使用Nacos注册中心
1）导入依赖
```xml
<!-- nacos服务直接到官网下载以jar运行即可-->
<!--nacos-config-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<!--nacos-discovery-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--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>
```
2）application.yml示例
```yaml
#激活配置文件选项
spring:
profiles:
active: dev # 表示开发环境
#active: test # 表示测试环境
#active: prod # 表示生产环境
# nacos配置
server:
port: 3377
spring:
application:
name: nacos-config-client
cloud:
nacos:
discovery:
server-addr: localhost:8848 #Nacos服务注册中心地址
config:
server-addr: localhost:8848 #Nacos作为配置中心地址
namespace: Test-NameSpace-HA1 #命名空间ID,nacos1.2可以自定义
group: DEV_GROUP #分组ID
file-extension: yaml #指定yaml格式的配置
#
#命名规范：
# ${spring.application.name}-${spring.profile.active}.${spring.cloud.nacos.config.file-extension}
# nacos-config-client-dev.yaml
```
3）启动类添加注解@EnableDiscoveryClient
```java
/**
* ConfigNacosMain3344
*
* @author lcry
* @date 2020/03/16 17:49
*/
@SpringBootApplication
@EnableDiscoveryClient
public class ConfigNacosMain3377 {
public static void main(String[] args) {
SpringApplication.run(ConfigNacosMain3377.class, args);
}
}
```
4）业务类添加注解@RefreshScope
```java
/**
* NacosClientController
*
* @author lcry
*/
@RestController
@RefreshScope //支持Nacos的动态刷新功能。
public class NacosClientController {
@Value("${config.info}") //通过nacos配置中心获取文件
private String configInfo;
@GetMapping("/config/info")
public String getConfigInfo() {
return configInfo;
}
}
```
> 对应项目：cloudalibaba-config-nacos-client3377
#### 3、使用Sentiel限流
1）导入依赖
```xml
<!--SpringCloud ailibaba nacos -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--SpringCloud ailibaba sentinel-datasource-nacos 后续做持久化用到-->
<dependency>
<groupId>com.alibaba.csp</groupId>
<artifactId>sentinel-datasource-nacos</artifactId>
</dependency>
<!--SpringCloud ailibaba sentinel -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<!--openfeign-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
```
2）application.yml配置示例
```yaml
#测试端口
server:
port: 8401
spring:
application:
name: cloudalibaba-sentinel-service
cloud:
nacos:
discovery:
server-addr: localhost:8848 #Nacos服务注册中心地址
sentinel:
transport:
dashboard: localhost:8080 #配置Sentinel dashboard地址
port: 8719 #随机找一个地址，如果冲突就往后+1
#持久化配置
# datasource:
# ds1:
# nacos:
# server-addr: localhost:8848
# dataId: cloudalibaba-sentinel-service
# groupId: DEFAULT_GROUP
# data-type: json
# rule-type: flow
management:
endpoints:
web:
exposure:
include: '*'
feign:
sentinel:
enabled: true # 激活Sentinel对Feign的支持
```
3）接口先请求一次，然后在sentinel控制台进行相应限流模式操作
4）自定义限流异常页面等，使用注解@SentinelResource
```java
@GetMapping("/testHotKey")
@SentinelResource(value = "testHotKey", blockHandler = "deal_testHotKey")
public String testHotKey(@RequestParam(value = "p1", required = false) String p1,
@RequestParam(value = "p2", required = false) String p2) {
//int age = 10/0;
return "------testHotKey";
}
public String deal_testHotKey(String p1, String p2, BlockException exception) {
//sentinel系统默认的提示：Blocked by Sentinel (flow limiting)
return "------deal_testHotKey,o(╥﹏╥)o";
}
@GetMapping("/rateLimit/byResource")
@SentinelResource(value = "byResource", blockHandler = "handleException")
public CommonResult byResource() {
return new CommonResult(200, "按资源名称限流测试OK", new Payment(2020L, "serial001"));
}
public CommonResult handleException(BlockException exception) {
return new CommonResult(444, exception.getClass().getCanonicalName() + "\t 服务不可用");
}
@GetMapping("/rateLimit/byUrl")
@SentinelResource(value = "byUrl")
public CommonResult byUrl() {
return new CommonResult(200, "按url限流测试OK", new Payment(2020L, "serial002"));
}
@GetMapping("/rateLimit/customerBlockHandler")
@SentinelResource(value = "customerBlockHandler", //资源名称
blockHandlerClass = CustomerBlockHandler.class, //异常自定义
blockHandler = "handlerException1") //调用自定义类某个方法
public CommonResult customerBlockHandler() {
return new CommonResult(200, "按客戶自定义", new Payment(2020L, "serial003"));
}
```
```java
/**
* @author lcry
* @date 2020/03/17 14:51
* 用户自定义处理异常类
*/
public class CustomerBlockHandler {
public static CommonResult handlerException1(BlockException exception) {
return new CommonResult(4444, "按客戶自定义,global handlerException----1");
}
public static CommonResult handlerException2(BlockException exception) {
return new CommonResult(4444, "按客戶自定义,global handlerException----2");
}
}
```
> 对应项目：cloudalibaba-sentinel-service8401
#### 4、使用Sentinel服务熔断
1）导入依赖
```xml
<!-- 服务消费方，整合rabbin和feign，sentinel限流熔断等-->
<!--SpringCloud openfeign -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!--SpringCloud ailibaba sentinel-datasource-nacos做持久化用到-->
<dependency>
<groupId>com.alibaba.csp</groupId>
<artifactId>sentinel-datasource-nacos</artifactId>
</dependency>
<!--SpringCloud ailibaba nacos -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--SpringCloud ailibaba sentinel -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
```
2）启动类添加启用Openfeign注解@EnableFeignClients
```java
@EnableDiscoveryClient
@SpringBootApplication
@EnableFeignClients //整合feign
public class NacosOrderMain84 {
public static void main(String[] args) {
SpringApplication.run(NacosOrderMain84.class, args);
}
}
```
3）熔断和降级示例业务代码
```java
/**
* CircleBreakerController
*
* @author lcry
* 使用示例：
*/
@RestController
@Slf4j
public class CircleBreakerController {
public static final String SERVICE_URL = "http://nacos-payment-provider";
// 整个rabbin - restTemplate
@Resource
private RestTemplate restTemplate;
// 整合sentinel
@RequestMapping("/consumer/fallback/{id}")
//@SentinelResource(value = "fallback") //没有配置
//@SentinelResource(value = "fallback",fallback = "handlerFallback") //fallback只负责业务异常
//@SentinelResource(value = "fallback",blockHandler = "blockHandler") //blockHandler只负责sentinel控制台配置违规
// @SentinelResource(value = "fallback",fallback = "handlerFallback",blockHandler = "blockHandler", //分开自定义
// exceptionsToIgnore = {IllegalArgumentException.class}//排除异常不限流
// )
@SentinelResource(value = "fallback", //,fallback = "handlerFallback",
blockHandlerClass = CustomerBlockHandler.class, //异常自定义
blockHandler = "handlerException1" //分开自定义
)
public CommonResult<Payment> fallback(@PathVariable Long id) {
CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/" + id, CommonResult.class, id);
if (id == 4) {
throw new IllegalArgumentException("IllegalArgumentException,非法参数异常....");
} else if (result.getData() == null) {
throw new NullPointerException("NullPointerException,该ID没有对应记录,空指针异常");
}
return result;
}
//本例是fallback
public CommonResult handlerFallback(@PathVariable Long id, Throwable e) {
Payment payment = new Payment(id, "null");
return new CommonResult<>(444, "兜底异常handlerFallback,exception内容 " + e.getMessage(), payment);
}
//本例是blockHandler
public CommonResult blockHandler(@PathVariable Long id, BlockException blockException) {
Payment payment = new Payment(id, "null");
return new CommonResult<>(445, "blockHandler-sentinel限流,无此流水: blockException " + blockException.getMessage(), payment);
}
//OpenFeign调用
@Resource
private PaymentService paymentService;
@GetMapping(value = "/consumer/paymentSQL/{id}")
public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id) {
return paymentService.paymentSQL(id);
}
/*
测试自定义限流
*/
@GetMapping(value = "/consumer/paymentSQL")
@SentinelResource(value = "customerBlockHandler", //资源名称
blockHandlerClass = CustomerBlockHandler.class, //异常自定义
blockHandler = "handlerException1") //调用自定义类某个方法
public CommonResult<Payment> paymentSQL2() {
return paymentService.paymentSQL(1L);
}
}
```
> 对应项目：cloudalibaba-consumer-nacos-order84
#### 5、使用分布式事务Seata
1）引入依赖
```xml
<!--nacos-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--seata-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-seata</artifactId>
<!-- 排除自带的，我们使用0.9.0-->
<exclusions>
<exclusion>
<artifactId>seata-all</artifactId>
<groupId>io.seata</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>io.seata</groupId>
<artifactId>seata-all</artifactId>
<version>0.9.0</version>
</dependency>
<!--feign-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
```
2）application.yml配置示例
```yaml
#微服务端口
server:
port: 12001
spring:
application:
name: seata-order-service
cloud:
alibaba:
seata:
#自定义事务组名称需要与seata-server中的对应
tx-service-group: fsp_tx_group
nacos:
discovery:
server-addr: localhost:8848
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/seata_order?useUnicode=true&characterEncoding=utf-8&useSSL=false
username: root
password: lcry
#禁用feign
feign:
hystrix:
enabled: false
#OpenFeign的超时控制配置：默认只等待1秒，超时则报错
#设置Feign客户端超时时间（OpenFeign默认支持Ribbon）
ribbon:
#指的是建立连接所用的时间，适用于网络状况正常的情况下，两端连接所用的时间
ReadTimeout: 5000
#指的是建立连接后从服务器读取到可用资源所用的时间
connectTimeout: 5000
#日志级别
logging:
level:
io:
seata: info
#mybatis映射
mybatis:
mapperLocations: classpath:mapper/*.xml
```
3）配置file.conf和register.conf，可以直接从Seata上直接拷贝到resources目录下做部分改动
4）业务代码添加注解@GlobalTransactional开启全局事务
```java
/**
* 创建订单->调用库存服务扣减库存->调用账户服务扣减账户余额->修改订单状态
* 简单说：下订单->扣库存->减余额->改状态
*/
@Override
@GlobalTransactional(name = "tx-create-order", rollbackFor = Exception.class)
public void create(Order order) {
log.info("----->开始新建订单");
//1 新建订单
orderDao.create(order);
//2 扣减库存
log.info("----->订单微服务开始调用库存，做扣减Count");
storageService.decrease(order.getProductId(), order.getCount());
log.info("----->订单微服务开始调用库存，做扣减end");
//3 扣减账户
log.info("----->订单微服务开始调用账户，做扣减Money");
accountService.decrease(order.getUserId(), order.getMoney());
log.info("----->订单微服务开始调用账户，做扣减end");
//4 修改订单状态，从零到1,1代表已经完成
log.info("----->修改订单状态开始");
orderDao.update(order.getUserId(), 0);
log.info("----->修改订单状态结束");
log.info("----->下订单结束了，O(∩_∩)O哈哈~");
}
```
> 对应项目：cloudalibaba-seata-order-service12001、cloudalibaba-seata-storage-service12002、cloudalibaba-seata-account-service12003
**完结~**
持续更新中....
\ No newline at end of file
cloud-eureka-server7001/pom.xml
浏览文件 @ c11faa2d
......@@ -11,8 +11,9 @@
<!-- eureka服务端1-->
<artifactId>cloud-eureka-server7001</artifactId>
<!--eureka-server-->
<dependencies>
<!--eureka-server-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
......
cloud-gateway-gateway9527/src/main/java/com/lcry/springcloud/config/GateWayConfig.java
浏览文件 @ c11faa2d
......@@ -20,4 +20,4 @@ public class GateWayConfig {
return routes.build();
}
}
}
\ No newline at end of file
cloud-provider-consul-payment8006/src/main/java/com/lcry/springcloud/ConsulPaymentMain8006.java
浏览文件 @ c11faa2d
......@@ -16,5 +16,4 @@ public class ConsulPaymentMain8006 {
public static void main(String[] args) {
SpringApplication.run(ConsulPaymentMain8006.class, args);
}
}
cloud-stream-provider-rabbitmq8801/src/main/java/com/lcry/springcloud/service/impl/MessageProviderImpl.java
浏览文件 @ c11faa2d
......@@ -26,4 +26,4 @@ public class MessageProviderImpl implements IMessageProvider {
log.info(String.format("生成的流水号:{%s}", serial));
return serial;
}
}
}
\ No newline at end of file
cloudalibaba-seata-account-service12003/pom.xml 0 → 100644
浏览文件 @ c11faa2d
<?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>2020SpringCloud</artifactId>
<groupId>com.lcry</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<!-- 分布式事务seate-账户微服务-->
<artifactId>cloudalibaba-seata-account-service12003</artifactId>
<dependencies>
<!--nacos-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--seata-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-seata</artifactId>
<!-- 排除自带的，我们使用0.9.0-->
<exclusions>
<exclusion>
<artifactId>seata-all</artifactId>
<groupId>io.seata</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>io.seata</groupId>
<artifactId>seata-all</artifactId>
<version>0.9.0</version>
</dependency>
<!--feign-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!--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>
<!--mysql-druid-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.37</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.10</version>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
</project>
\ No newline at end of file
cloudalibaba-seata-account-service12003/src/main/java/com/lcry/springcloudalibaba/AccountServerMain12003.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* AccountServerMain12003
*
* @author lcry
* @date 2020/03/18 16:01
*/
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableDiscoveryClient
@EnableFeignClients
public class AccountServerMain12003 {
public static void main(String[] args) {
SpringApplication.run(AccountServerMain12003.class, args);
}
}
cloudalibaba-seata-account-service12003/src/main/java/com/lcry/springcloudalibaba/config/DataSourceProxyConfig.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.config;
import com.alibaba.druid.pool.DruidDataSource;
import io.seata.rm.datasource.DataSourceProxy;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;
/**
* 使用Seata对数据源进行代理
*/
@Configuration
public class DataSourceProxyConfig {
@Value("${mybatis.mapperLocations}")
private String mapperLocations;
@Bean
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource druidDataSource(){
return new DruidDataSource();
}
@Bean
public DataSourceProxy dataSourceProxy(DataSource dataSource) {
return new DataSourceProxy(dataSource);
}
@Bean
public SqlSessionFactory sqlSessionFactoryBean(DataSourceProxy dataSourceProxy) throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSourceProxy);
sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
sqlSessionFactoryBean.setTransactionFactory(new SpringManagedTransactionFactory());
return sqlSessionFactoryBean.getObject();
}
}
cloudalibaba-seata-account-service12003/src/main/java/com/lcry/springcloudalibaba/config/MyBatisConfig.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.config;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
/**
* MyBatisConfig
*
* @author lcry
* @date 2020/03/18 15:46
*/
@Configuration
@MapperScan({"com.lcry.springcloudalibaba.dao"})
public class MyBatisConfig {
}
cloudalibaba-seata-account-service12003/src/main/java/com/lcry/springcloudalibaba/controller/AccountController.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.controller;
import com.lcry.springcloudalibaba.domain.CommonResult;
import com.lcry.springcloudalibaba.service.AccountService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.math.BigDecimal;
@RestController
public class AccountController {
@Resource
private AccountService accountService;
/**
* 扣减账户余额
*/
@GetMapping("/account/decrease")
public CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money) {
accountService.decrease(userId, money);
return new CommonResult(200, "扣减账户余额成功！");
}
}
cloudalibaba-seata-account-service12003/src/main/java/com/lcry/springcloudalibaba/dao/AccountDao.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.dao;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.math.BigDecimal;
@Mapper
public interface AccountDao {
/**
* 扣减账户余额
*/
void decrease(@Param("userId") Long userId, @Param("money") BigDecimal money);
}
cloudalibaba-seata-account-service12003/src/main/java/com/lcry/springcloudalibaba/domain/Account.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {
private Long id;
/**
* 用户id
*/
private Long userId;
/**
* 总额度
*/
private BigDecimal total;
/**
* 已用额度
*/
private BigDecimal used;
/**
* 剩余额度
*/
private BigDecimal residue;
}
cloudalibaba-seata-account-service12003/src/main/java/com/lcry/springcloudalibaba/domain/CommonResult.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 实体类
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
private Integer code;
private String message;
private T data;
public CommonResult(Integer code, String message) {
this(code, message, null);
}
}
\ No newline at end of file
cloudalibaba-seata-account-service12003/src/main/java/com/lcry/springcloudalibaba/service/AccountService.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.service;
import org.springframework.web.bind.annotation.RequestParam;
import java.math.BigDecimal;
public interface AccountService {
/**
* 扣减账户余额
*
* @param userId 用户id
* @param money 金额
*/
void decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
}
cloudalibaba-seata-account-service12003/src/main/java/com/lcry/springcloudalibaba/service/impl/AccountServiceImpl.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.service.impl;
import com.lcry.springcloudalibaba.dao.AccountDao;
import com.lcry.springcloudalibaba.service.AccountService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.concurrent.TimeUnit;
/**
* 账户业务实现类
*/
@Service
@Slf4j
public class AccountServiceImpl implements AccountService {
@Resource
private AccountDao accountDao;
/**
* 扣减账户余额
*/
@Override
public void decrease(Long userId, BigDecimal money) {
log.info("------->account-service中扣减账户余额开始");
//模拟超时异常，全局事务回滚
//暂停1秒钟线程
// try {
// TimeUnit.SECONDS.sleep(1);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
accountDao.decrease(userId, money);
log.info("------->account-service中扣减账户余额结束");
}
}
cloudalibaba-seata-account-service12003/src/main/resources/application.yml 0 → 100644
浏览文件 @ c11faa2d
#微服务端口
server:
port: 12003
spring:
application:
name: seata-account-service
cloud:
alibaba:
seata:
#自定义事务组名称需要与seata-server中的对应
tx-service-group: fsp_tx_group
nacos:
discovery:
server-addr: localhost:8848
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/seata_account?useUnicode=true&characterEncoding=utf-8&useSSL=false
username: root
password: lcry
#禁用feign
feign:
hystrix:
enabled: false
#日志级别
logging:
level:
io:
seata: info
#mybatis映射
mybatis:
mapperLocations: classpath:mapper/*.xml
\ No newline at end of file
cloudalibaba-seata-account-service12003/src/main/resources/file.conf 0 → 100644
浏览文件 @ c11faa2d
transport {
# tcp udt unix-domain-socket
type = "TCP"
#NIO NATIVE
server = "NIO"
#enable heartbeat
heartbeat = true
#thread factory for netty
thread-factory {
boss-thread-prefix = "NettyBoss"
worker-thread-prefix = "NettyServerNIOWorker"
server-executor-thread-prefix = "NettyServerBizHandler"
share-boss-worker = false
client-selector-thread-prefix = "NettyClientSelector"
client-selector-thread-size = 1
client-worker-thread-prefix = "NettyClientWorkerThread"
# netty boss thread size,will not be used for UDT
boss-thread-size = 1
#auto default pin or 8
worker-thread-size = 8
}
shutdown {
# when destroy server, wait seconds
wait = 3
}
serialization = "seata"
compressor = "none"
}
service {
#vgroup->rgroup
vgroup_mapping.fsp_tx_group = "default"
#only support single node
default.grouplist = "127.0.0.1:8091"
#degrade current not support
enableDegrade = false
#disable
disable = false
#unit ms,s,m,h,d represents milliseconds, seconds, minutes, hours, days, default permanent
max.commit.retry.timeout = "-1"
max.rollback.retry.timeout = "-1"
disableGlobalTransaction = false
}
client {
async.commit.buffer.limit = 10000
lock {
retry.internal = 10
retry.times = 30
}
report.retry.count = 5
tm.commit.retry.count = 1
tm.rollback.retry.count = 1
}
transaction {
undo.data.validation = true
undo.log.serialization = "jackson"
undo.log.save.days = 7
#schedule delete expired undo_log in milliseconds
undo.log.delete.period = 86400000
undo.log.table = "undo_log"
}
support {
## spring
spring {
# auto proxy the DataSource bean
datasource.autoproxy = false
}
}
\ No newline at end of file
cloudalibaba-seata-account-service12003/src/main/resources/mapper/AccountMapper.xml 0 → 100644
浏览文件 @ c11faa2d
<?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.lcry.springcloudalibaba.dao.AccountDao">
<resultMap id="BaseResultMap" type="com.lcry.springcloudalibaba.domain.Account">
<id column="id" property="id" jdbcType="BIGINT"/>
<result column="user_id" property="userId" jdbcType="BIGINT"/>
<result column="total" property="total" jdbcType="DECIMAL"/>
<result column="used" property="used" jdbcType="DECIMAL"/>
<result column="residue" property="residue" jdbcType="DECIMAL"/>
</resultMap>
<update id="decrease">
UPDATE t_account
SET
residue = residue - #{money},used = used + #{money}
WHERE
user_id = #{userId};
</update>
</mapper>
cloudalibaba-seata-account-service12003/src/main/resources/registry.conf 0 → 100644
浏览文件 @ c11faa2d
registry {
# file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
type = "nacos"
nacos {
serverAddr = "localhost:8848"
namespace = ""
cluster = "default"
}
eureka {
serviceUrl = "http://localhost:8761/eureka"
application = "default"
weight = "1"
}
redis {
serverAddr = "localhost:6379"
db = "0"
}
zk {
cluster = "default"
serverAddr = "127.0.0.1:2181"
session.timeout = 6000
connect.timeout = 2000
}
consul {
cluster = "default"
serverAddr = "127.0.0.1:8500"
}
etcd3 {
cluster = "default"
serverAddr = "http://localhost:2379"
}
sofa {
serverAddr = "127.0.0.1:9603"
application = "default"
region = "DEFAULT_ZONE"
datacenter = "DefaultDataCenter"
cluster = "default"
group = "SEATA_GROUP"
addressWaitTime = "3000"
}
file {
name = "file.conf"
}
}
config {
# file、nacos 、apollo、zk、consul、etcd3
type = "file"
nacos {
serverAddr = "localhost"
namespace = ""
}
consul {
serverAddr = "127.0.0.1:8500"
}
apollo {
app.id = "seata-server"
apollo.meta = "http://192.168.1.204:8801"
}
zk {
serverAddr = "127.0.0.1:2181"
session.timeout = 6000
connect.timeout = 2000
}
etcd3 {
serverAddr = "http://localhost:2379"
}
file {
name = "file.conf"
}
}
cloudalibaba-seata-order-service12001/pom.xml 0 → 100644
浏览文件 @ c11faa2d
<?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>2020SpringCloud</artifactId>
<groupId>com.lcry</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<!-- 分布式事务seate-订单微服务-->
<artifactId>cloudalibaba-seata-order-service12001</artifactId>
<dependencies>
<!--nacos-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--seata-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-seata</artifactId>
<exclusions>
<exclusion>
<artifactId>seata-all</artifactId>
<groupId>io.seata</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>io.seata</groupId>
<artifactId>seata-all</artifactId>
<version>0.9.0</version>
</dependency>
<!--feign-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!--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>
<!--mysql-druid-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.37</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.10</version>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
</project>
\ No newline at end of file
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/OrderServerMain12001.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* OrderServerMain12001
*
* @author lcry
* @date 2020/03/18 12:32
*/
@EnableDiscoveryClient
@EnableFeignClients
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)//取消数据源的自动创建
public class OrderServerMain12001 {
public static void main(String[] args) {
SpringApplication.run(OrderServerMain12001.class, args);
}
}
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/config/DataSourceProxyConfig.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.config;
import com.alibaba.druid.pool.DruidDataSource;
import io.seata.rm.datasource.DataSourceProxy;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;
/**
* @author lcry
* @date 2020/03/18 12:32
* 使用Seata对数据源进行代理
*/
@Configuration
public class DataSourceProxyConfig {
@Value("${mybatis.mapperLocations}")
private String mapperLocations;
@Bean
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource druidDataSource(){
return new DruidDataSource();
}
@Bean
public DataSourceProxy dataSourceProxy(DataSource dataSource) {
return new DataSourceProxy(dataSource);
}
@Bean
public SqlSessionFactory sqlSessionFactoryBean(DataSourceProxy dataSourceProxy) throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSourceProxy);
sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
sqlSessionFactoryBean.setTransactionFactory(new SpringManagedTransactionFactory());
return sqlSessionFactoryBean.getObject();
}
}
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/config/MyBatisConfig.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.config;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
/**
* @author lcry
* @date 2020/03/18 12:32
*/
@Configuration
@MapperScan({"com.lcry.springcloudalibaba.dao"})
public class MyBatisConfig {
}
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/controller/OrderController.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.controller;
import com.lcry.springcloudalibaba.domain.CommonResult;
import com.lcry.springcloudalibaba.domain.Order;
import com.lcry.springcloudalibaba.service.OrderService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
* @author lcry
* @date 2020/03/18 12:32
*/
@RestController
public class OrderController {
@Resource
private OrderService orderService;
/**
* 创建订单
*
* @param order
* @return
*/
@PostMapping("/order/create")
public CommonResult create(@RequestBody Order order) {
orderService.create(order);
return new CommonResult(200, "订单创建成功");
}
}
\ No newline at end of file
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/dao/OrderDao.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.dao;
import com.lcry.springcloudalibaba.domain.Order;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* @author lcry
* @date 2020/03/18 12:32
*/
@Mapper
public interface OrderDao {
//1 新建订单
void create(Order order);
//2 修改订单状态，从零改为1
void update(@Param("userId") Long userId, @Param("status") Integer status);
}
\ No newline at end of file
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/domain/CommonResult.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author lcry
* @date 2020/03/18 12:32
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
private Integer code;
private String message;
private T data;
public CommonResult(Integer code, String message) {
this(code, message, null);
}
}
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/domain/Order.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* @author lcry
* @date 2020/03/18 12:32
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order {
private Long id;
private Long userId;
private Long productId;
private Integer count;
private BigDecimal money;
private Integer status; //订单状态：0：创建中；1：已完结
}
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/service/AccountService.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.service;
import com.lcry.springcloudalibaba.domain.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.math.BigDecimal;
/**
* @author lcry
* @date 2020/03/18 12:32
*/
@FeignClient(value = "seata-account-service")
public interface AccountService {
@GetMapping(value = "/account/decrease")
CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
}
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/service/OrderService.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.service;
import com.lcry.springcloudalibaba.domain.Order;
/**
* @author lcry
* @date 2020/03/18 12:32
*/
public interface OrderService {
void create(Order order);
}
\ No newline at end of file
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/service/StorageService.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.service;
import com.lcry.springcloudalibaba.domain.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.math.BigDecimal;
/**
* @author lcry
* @date 2020/03/18 12:32
*/
@FeignClient(value = "seata-storage-service")
public interface StorageService {
@PostMapping(value = "/storage/decrease")
CommonResult decrease(@RequestParam("productId") Long productId, @RequestParam("count") Integer count);
}
cloudalibaba-seata-order-service12001/src/main/java/com/lcry/springcloudalibaba/service/impl/OrderServiceImpl.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.service.impl;
import com.lcry.springcloudalibaba.dao.OrderDao;
import com.lcry.springcloudalibaba.domain.Order;
import com.lcry.springcloudalibaba.service.AccountService;
import com.lcry.springcloudalibaba.service.OrderService;
import com.lcry.springcloudalibaba.service.StorageService;
import io.seata.spring.annotation.GlobalTransactional;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @author lcry
* @date 2020/03/18 12:32
*/
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
@Resource
private OrderDao orderDao;
@Resource
private StorageService storageService;
@Resource
private AccountService accountService;
/**
* 创建订单->调用库存服务扣减库存->调用账户服务扣减账户余额->修改订单状态
* 简单说：下订单->扣库存->减余额->改状态
*/
@Override
@GlobalTransactional(name = "tx-create-order", rollbackFor = Exception.class)
public void create(Order order) {
log.info("----->开始新建订单");
//1 新建订单
orderDao.create(order);
//2 扣减库存
log.info("----->订单微服务开始调用库存，做扣减Count");
storageService.decrease(order.getProductId(), order.getCount());
log.info("----->订单微服务开始调用库存，做扣减end");
//3 扣减账户
log.info("----->订单微服务开始调用账户，做扣减Money");
accountService.decrease(order.getUserId(), order.getMoney());
log.info("----->订单微服务开始调用账户，做扣减end");
//4 修改订单状态，从零到1,1代表已经完成
log.info("----->修改订单状态开始");
orderDao.update(order.getUserId(), 0);
log.info("----->修改订单状态结束");
log.info("----->下订单结束了，O(∩_∩)O哈哈~");
}
}
cloudalibaba-seata-order-service12001/src/main/resources/application.yml 0 → 100644
浏览文件 @ c11faa2d
#微服务端口
server:
port: 12001
spring:
application:
name: seata-order-service
cloud:
alibaba:
seata:
#自定义事务组名称需要与seata-server中的对应
tx-service-group: fsp_tx_group
nacos:
discovery:
server-addr: localhost:8848
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/seata_order?useUnicode=true&characterEncoding=utf-8&useSSL=false
username: root
password: lcry
#禁用feign
feign:
hystrix:
enabled: false
#OpenFeign的超时控制配置：默认只等待1秒，超时则报错
#设置Feign客户端超时时间（OpenFeign默认支持Ribbon）
ribbon:
#指的是建立连接所用的时间，适用于网络状况正常的情况下，两端连接所用的时间
ReadTimeout: 5000
#指的是建立连接后从服务器读取到可用资源所用的时间
connectTimeout: 5000
#日志级别
logging:
level:
io:
seata: info
#mybatis映射
mybatis:
mapperLocations: classpath:mapper/*.xml
cloudalibaba-seata-order-service12001/src/main/resources/file.conf 0 → 100644
浏览文件 @ c11faa2d
transport {
# tcp udt unix-domain-socket
type = "TCP"
#NIO NATIVE
server = "NIO"
#enable heartbeat
heartbeat = true
#thread factory for netty
thread-factory {
boss-thread-prefix = "NettyBoss"
worker-thread-prefix = "NettyServerNIOWorker"
server-executor-thread-prefix = "NettyServerBizHandler"
share-boss-worker = false
client-selector-thread-prefix = "NettyClientSelector"
client-selector-thread-size = 1
client-worker-thread-prefix = "NettyClientWorkerThread"
# netty boss thread size,will not be used for UDT
boss-thread-size = 1
#auto default pin or 8
worker-thread-size = 8
}
shutdown {
# when destroy server, wait seconds
wait = 3
}
serialization = "seata"
compressor = "none"
}
service {
vgroup_mapping.fsp_tx_group = "default" #修改自定义事务组名称
default.grouplist = "127.0.0.1:8091"
enableDegrade = false
disable = false
max.commit.retry.timeout = "-1"
max.rollback.retry.timeout = "-1"
disableGlobalTransaction = false
}
client {
async.commit.buffer.limit = 10000
lock {
retry.internal = 10
retry.times = 30
}
report.retry.count = 5
tm.commit.retry.count = 1
tm.rollback.retry.count = 1
}
## transaction log store
store {
## store mode: file、db
mode = "db"
## file store
file {
dir = "sessionStore"
# branch session size , if exceeded first try compress lockkey, still exceeded throws exceptions
max-branch-session-size = 16384
# globe session size , if exceeded throws exceptions
max-global-session-size = 512
# file buffer size , if exceeded allocate new buffer
file-write-buffer-cache-size = 16384
# when recover batch read size
session.reload.read_size = 100
# async, sync
flush-disk-mode = async
}
## database store
db {
## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp) etc.
datasource = "dbcp"
## mysql/oracle/h2/oceanbase etc.
db-type = "mysql"
driver-class-name = "com.mysql.jdbc.Driver"
url = "jdbc:mysql://127.0.0.1:3306/seata"
user = "root"
password = "lcry"
min-conn = 1
max-conn = 3
global.table = "global_table"
branch.table = "branch_table"
lock-table = "lock_table"
query-limit = 100
}
}
lock {
## the lock store mode: local、remote
mode = "remote"
local {
## store locks in user's database
}
remote {
## store locks in the seata's server
}
}
recovery {
#schedule committing retry period in milliseconds
committing-retry-period = 1000
#schedule asyn committing retry period in milliseconds
asyn-committing-retry-period = 1000
#schedule rollbacking retry period in milliseconds
rollbacking-retry-period = 1000
#schedule timeout retry period in milliseconds
timeout-retry-period = 1000
}
transaction {
undo.data.validation = true
undo.log.serialization = "jackson"
undo.log.save.days = 7
#schedule delete expired undo_log in milliseconds
undo.log.delete.period = 86400000
undo.log.table = "undo_log"
}
## metrics settings
metrics {
enabled = false
registry-type = "compact"
# multi exporters use comma divided
exporter-list = "prometheus"
exporter-prometheus-port = 9898
}
support {
## spring
spring {
# auto proxy the DataSource bean
datasource.autoproxy = false
}
}
cloudalibaba-seata-order-service12001/src/main/resources/mapper/OrderMapper.xml 0 → 100644
浏览文件 @ c11faa2d
<?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.lcry.springcloudalibaba.dao.OrderDao">
<resultMap id="BaseResultMap" type="com.lcry.springcloudalibaba.domain.Order">
<id column="id" property="id" jdbcType="BIGINT"/>
<result column="user_id" property="userId" jdbcType="BIGINT"/>
<result column="product_id" property="productId" jdbcType="BIGINT"/>
<result column="count" property="count" jdbcType="INTEGER"/>
<result column="money" property="money" jdbcType="DECIMAL"/>
<result column="status" property="status" jdbcType="INTEGER"/>
</resultMap>
<insert id="create">
insert into t_order (id,user_id,product_id,count,money,status)
values (null,#{userId},#{productId},#{count},#{money},0);
</insert>
<update id="update">
update t_order set status = 1
where user_id=#{userId} and status = #{status};
</update>
</mapper>
cloudalibaba-seata-order-service12001/src/main/resources/registry.conf 0 → 100644
浏览文件 @ c11faa2d
registry {
# file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
type = "nacos"
nacos {
serverAddr = "localhost:8848"
namespace = ""
cluster = "default"
}
eureka {
serviceUrl = "http://localhost:8761/eureka"
application = "default"
weight = "1"
}
redis {
serverAddr = "localhost:6379"
db = "0"
}
zk {
cluster = "default"
serverAddr = "127.0.0.1:2181"
session.timeout = 6000
connect.timeout = 2000
}
consul {
cluster = "default"
serverAddr = "127.0.0.1:8500"
}
etcd3 {
cluster = "default"
serverAddr = "http://localhost:2379"
}
sofa {
serverAddr = "127.0.0.1:9603"
application = "default"
region = "DEFAULT_ZONE"
datacenter = "DefaultDataCenter"
cluster = "default"
group = "SEATA_GROUP"
addressWaitTime = "3000"
}
file {
name = "file.conf"
}
}
config {
# file、nacos 、apollo、zk、consul、etcd3
type = "file"
nacos {
serverAddr = "localhost"
namespace = ""
}
consul {
serverAddr = "127.0.0.1:8500"
}
apollo {
app.id = "seata-server"
apollo.meta = "http://192.168.1.204:8801"
}
zk {
serverAddr = "127.0.0.1:2181"
session.timeout = 6000
connect.timeout = 2000
}
etcd3 {
serverAddr = "http://localhost:2379"
}
file {
name = "file.conf"
}
}
cloudalibaba-seata-storage-service12002/pom.xml 0 → 100644
浏览文件 @ c11faa2d
<?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>2020SpringCloud</artifactId>
<groupId>com.lcry</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<!-- 分布式事务seate-库存微服务-->
<artifactId>cloudalibaba-seata-storage-service12002</artifactId>
<dependencies>
<!--nacos-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--seata-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-seata</artifactId>
<!-- 排除自带的，我们使用0.9.0-->
<exclusions>
<exclusion>
<artifactId>seata-all</artifactId>
<groupId>io.seata</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>io.seata</groupId>
<artifactId>seata-all</artifactId>
<version>0.9.0</version>
</dependency>
<!--feign-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!--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>
<!--mysql-druid-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.37</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.10</version>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
</project>
\ No newline at end of file
cloudalibaba-seata-storage-service12002/src/main/java/com/lcry/springcloudalibaba/StorageServerMain12002.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* StorageServerMain12002
*
* @author lcry
* @date 2020/03/18 15:41
*/
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableDiscoveryClient
@EnableFeignClients
public class StorageServerMain12002 {
public static void main(String[] args) {
SpringApplication.run(StorageServerMain12002.class, args);
}
}
cloudalibaba-seata-storage-service12002/src/main/java/com/lcry/springcloudalibaba/config/DataSourceProxyConfig.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.config;
import com.alibaba.druid.pool.DruidDataSource;
import io.seata.rm.datasource.DataSourceProxy;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;
/**
* 使用Seata对数据源进行代理
*/
@Configuration
public class DataSourceProxyConfig {
@Value("${mybatis.mapperLocations}")
private String mapperLocations;
@Bean
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource druidDataSource(){
return new DruidDataSource();
}
@Bean
public DataSourceProxy dataSourceProxy(DataSource dataSource) {
return new DataSourceProxy(dataSource);
}
@Bean
public SqlSessionFactory sqlSessionFactoryBean(DataSourceProxy dataSourceProxy) throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSourceProxy);
sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
sqlSessionFactoryBean.setTransactionFactory(new SpringManagedTransactionFactory());
return sqlSessionFactoryBean.getObject();
}
}
cloudalibaba-seata-storage-service12002/src/main/java/com/lcry/springcloudalibaba/config/MyBatisConfig.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.config;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
/**
* MyBatisConfig
*
* @author lcry
* @date 2020/03/18 15:46
*/
@Configuration
@MapperScan({"com.lcry.springcloudalibaba.dao"})
public class MyBatisConfig {
}
cloudalibaba-seata-storage-service12002/src/main/java/com/lcry/springcloudalibaba/controller/StorageController.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.controller;
import com.lcry.springcloudalibaba.domain.CommonResult;
import com.lcry.springcloudalibaba.service.StorageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
* StorageController
*
* @author lcry
* @date 2020/03/18 15:47
*/
@RestController
public class StorageController {
@Resource
private StorageService storageService;
/**
* 扣减库存
*/
@PostMapping("/storage/decrease")
public CommonResult decrease(Long productId, Integer count) {
storageService.decrease(productId, count);
return new CommonResult(200,"扣减库存成功！");
}
}
cloudalibaba-seata-storage-service12002/src/main/java/com/lcry/springcloudalibaba/dao/StorageDao.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.dao;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* StorageDao
*
* @author lcry
* @date 2020/03/18 15:47
*/
@Mapper
public interface StorageDao {
//扣减库存
void decrease(@Param("productId") Long productId, @Param("count") Integer count);
}
cloudalibaba-seata-storage-service12002/src/main/java/com/lcry/springcloudalibaba/domain/CommonResult.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author lcry
* @date 2020/03/18 15:47
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T>
{
private Integer code;
private String message;
private T data;
public CommonResult(Integer code, String message)
{
this(code,message,null);
}
}
\ No newline at end of file
cloudalibaba-seata-storage-service12002/src/main/java/com/lcry/springcloudalibaba/domain/Storage.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.domain;
import lombok.Data;
@Data
public class Storage {
private Long id;
/**
* 产品id
*/
private Long productId;
/**
* 总库存
*/
private Integer total;
/**
* 已用库存
*/
private Integer used;
/**
* 剩余库存
*/
private Integer residue;
}
cloudalibaba-seata-storage-service12002/src/main/java/com/lcry/springcloudalibaba/service/StorageService.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.service;
public interface StorageService {
/**
* 扣减库存
*/
void decrease(Long productId, Integer count);
}
cloudalibaba-seata-storage-service12002/src/main/java/com/lcry/springcloudalibaba/service/impl/StorageServiceImpl.java 0 → 100644
浏览文件 @ c11faa2d
package com.lcry.springcloudalibaba.service.impl;
import com.lcry.springcloudalibaba.dao.StorageDao;
import com.lcry.springcloudalibaba.service.StorageService;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @author lcry
*/
@Service
@Slf4j
public class StorageServiceImpl implements StorageService {
@Resource
private StorageDao storageDao;
/**
* 扣减库存
*/
@Override
public void decrease(Long productId, Integer count) {
log.info("------->storage-service中扣减库存开始");
storageDao.decrease(productId,count);
log.info("------->storage-service中扣减库存结束");
}
}
cloudalibaba-seata-storage-service12002/src/main/resources/application.yml 0 → 100644
浏览文件 @ c11faa2d
#微服务端口
server:
port: 12002
spring:
application:
name: seata-storage-service
cloud:
alibaba:
seata:
#自定义事务组名称需要与seata-server中的对应
tx-service-group: fsp_tx_group
nacos:
discovery:
server-addr: localhost:8848
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/seata_storage?useUnicode=true&characterEncoding=utf-8&useSSL=false
username: root
password: lcry
#禁用feign
feign:
hystrix:
enabled: false
#日志级别
logging:
level:
io:
seata: info
#mybatis映射
mybatis:
mapperLocations: classpath:mapper/*.xml
\ No newline at end of file
cloudalibaba-seata-storage-service12002/src/main/resources/file.conf 0 → 100644
浏览文件 @ c11faa2d
transport {
# tcp udt unix-domain-socket
type = "TCP"
#NIO NATIVE
server = "NIO"
#enable heartbeat
heartbeat = true
#thread factory for netty
thread-factory {
boss-thread-prefix = "NettyBoss"
worker-thread-prefix = "NettyServerNIOWorker"
server-executor-thread-prefix = "NettyServerBizHandler"
share-boss-worker = false
client-selector-thread-prefix = "NettyClientSelector"
client-selector-thread-size = 1
client-worker-thread-prefix = "NettyClientWorkerThread"
# netty boss thread size,will not be used for UDT
boss-thread-size = 1
#auto default pin or 8
worker-thread-size = 8
}
shutdown {
# when destroy server, wait seconds
wait = 3
}
serialization = "seata"
compressor = "none"
}
service {
#vgroup->rgroup
vgroup_mapping.fsp_tx_group = "default"
#only support single node
default.grouplist = "127.0.0.1:8091"
#degrade current not support
enableDegrade = false
#disable
disable = false
#unit ms,s,m,h,d represents milliseconds, seconds, minutes, hours, days, default permanent
max.commit.retry.timeout = "-1"
max.rollback.retry.timeout = "-1"
disableGlobalTransaction = false
}
client {
async.commit.buffer.limit = 10000
lock {
retry.internal = 10
retry.times = 30
}
report.retry.count = 5
tm.commit.retry.count = 1
tm.rollback.retry.count = 1
}
transaction {
undo.data.validation = true
undo.log.serialization = "jackson"
undo.log.save.days = 7
#schedule delete expired undo_log in milliseconds
undo.log.delete.period = 86400000
undo.log.table = "undo_log"
}
support {
## spring
spring {
# auto proxy the DataSource bean
datasource.autoproxy = false
}
}
cloudalibaba-seata-storage-service12002/src/main/resources/mapper/StorageMapper.xml 0 → 100644
浏览文件 @ c11faa2d
<?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.lcry.springcloudalibaba.dao.StorageDao">
<resultMap id="BaseResultMap" type="com.lcry.springcloudalibaba.domain.Storage">
<id column="id" property="id" jdbcType="BIGINT"/>
<result column="product_id" property="productId" jdbcType="BIGINT"/>
<result column="total" property="total" jdbcType="INTEGER"/>
<result column="used" property="used" jdbcType="INTEGER"/>
<result column="residue" property="residue" jdbcType="INTEGER"/>
</resultMap>
<update id="decrease">
UPDATE
t_storage
SET
used = used + #{count},residue = residue - #{count}
WHERE
product_id = #{productId}
</update>
</mapper>
cloudalibaba-seata-storage-service12002/src/main/resources/registry.conf 0 → 100644
浏览文件 @ c11faa2d
registry {
# file 、nacos 、eureka、redis、zk
type = "nacos"
nacos {
serverAddr = "localhost:8848"
namespace = ""
cluster = "default"
}
eureka {
serviceUrl = "http://localhost:8761/eureka"
application = "default"
weight = "1"
}
redis {
serverAddr = "localhost:6381"
db = "0"
}
zk {
cluster = "default"
serverAddr = "127.0.0.1:2181"
session.timeout = 6000
connect.timeout = 2000
}
file {
name = "file.conf"
}
}
config {
# file、nacos 、apollo、zk
type = "file"
nacos {
serverAddr = "localhost"
namespace = ""
cluster = "default"
}
apollo {
app.id = "fescar-server"
apollo.meta = "http://192.168.1.204:8801"
}
zk {
serverAddr = "127.0.0.1:2181"
session.timeout = 6000
connect.timeout = 2000
}
file {
name = "file.conf"
}
}
cloudalibaba-sentinel-service8401/src/main/resources/application.yml
浏览文件 @ c11faa2d
......@@ -13,6 +13,7 @@ spring:
transport:
dashboard: localhost:8080 #配置Sentinel dashboard地址
port: 8719 #随机找一个地址，如果冲突就往后+1
#持久化配置
# datasource:
# ds1:
# nacos:
......
pom.xml
浏览文件 @ c11faa2d
......@@ -36,6 +36,9 @@
<module>cloudalibaba-provider-nacos-payment9003</module>
<module>cloudalibaba-provider-nacos-payment9004</module>
<module>cloudalibaba-consumer-nacos-order84</module>
<module>cloudalibaba-seata-order-service12001</module>
<module>cloudalibaba-seata-storage-service12002</module>
<module>cloudalibaba-seata-account-service12003</module>
</modules>
<packaging>pom</packaging>
......
resouces/SQL/payment.sql 0 → 100644
浏览文件 @ c11faa2d
/*
Navicat Premium Data Transfer
Source Server : 本地mysql
Source Server Type : MySQL
Source Server Version : 50717
Source Host : localhost:3306
Source Schema : db2020
Target Server Type : MySQL
Target Server Version : 50717
File Encoding : 65001
Date: 18/03/2020 21:28:53
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for payment
-- ----------------------------
DROP TABLE IF EXISTS `payment`;
CREATE TABLE `payment` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
`serial` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 30 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of payment
-- ----------------------------
INSERT INTO `payment` VALUES (1, 'aaa');
SET FOREIGN_KEY_CHECKS = 1;
resouces/SQL/seata.sql 0 → 100644
浏览文件 @ c11faa2d
/*
Navicat Premium Data Transfer
Source Server : 本地mysql
Source Server Type : MySQL
Source Server Version : 50717
Source Host : localhost:3306
Source Schema : seata
Target Server Type : MySQL
Target Server Version : 50717
File Encoding : 65001
Date: 18/03/2020 21:29:08
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for branch_table
-- ----------------------------
DROP TABLE IF EXISTS `branch_table`;
CREATE TABLE `branch_table` (
`branch_id` bigint(20) NOT NULL,
`xid` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
`transaction_id` bigint(20) NULL DEFAULT NULL,
`resource_group_id` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`resource_id` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`lock_key` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`branch_type` varchar(8) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`status` tinyint(4) NULL DEFAULT NULL,
`client_id` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`application_data` varchar(2000) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`gmt_create` datetime(0) NULL DEFAULT NULL,
`gmt_modified` datetime(0) NULL DEFAULT NULL,
PRIMARY KEY (`branch_id`) USING BTREE,
INDEX `idx_xid`(`xid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of branch_table
-- ----------------------------
-- ----------------------------
-- Table structure for global_table
-- ----------------------------
DROP TABLE IF EXISTS `global_table`;
CREATE TABLE `global_table` (
`xid` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
`transaction_id` bigint(20) NULL DEFAULT NULL,
`status` tinyint(4) NOT NULL,
`application_id` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`transaction_service_group` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`transaction_name` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`timeout` int(11) NULL DEFAULT NULL,
`begin_time` bigint(20) NULL DEFAULT NULL,
`application_data` varchar(2000) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`gmt_create` datetime(0) NULL DEFAULT NULL,
`gmt_modified` datetime(0) NULL DEFAULT NULL,
PRIMARY KEY (`xid`) USING BTREE,
INDEX `idx_gmt_modified_status`(`gmt_modified`, `status`) USING BTREE,
INDEX `idx_transaction_id`(`transaction_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of global_table
-- ----------------------------
-- ----------------------------
-- Table structure for lock_table
-- ----------------------------
DROP TABLE IF EXISTS `lock_table`;
CREATE TABLE `lock_table` (
`row_key` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
`xid` varchar(96) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`transaction_id` mediumtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL,
`branch_id` mediumtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL,
`resource_id` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`table_name` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`pk` varchar(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
`gmt_create` datetime(0) NULL DEFAULT NULL,
`gmt_modified` datetime(0) NULL DEFAULT NULL,
PRIMARY KEY (`row_key`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of lock_table
-- ----------------------------
SET FOREIGN_KEY_CHECKS = 1;
resouces/SQL/seata_account.sql 0 → 100644
浏览文件 @ c11faa2d
/*
Navicat Premium Data Transfer
Source Server : 本地mysql
Source Server Type : MySQL
Source Server Version : 50717
Source Host : localhost:3306
Source Schema : seata_account
Target Server Type : MySQL
Target Server Version : 50717
File Encoding : 65001
Date: 18/03/2020 21:29:21
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for t_account
-- ----------------------------
DROP TABLE IF EXISTS `t_account`;
CREATE TABLE `t_account` (
`id` bigint(11) NOT NULL AUTO_INCREMENT,
`user_id` bigint(11) NULL DEFAULT NULL COMMENT '用户id',
`total` decimal(10, 0) NULL DEFAULT NULL COMMENT '总额度',
`used` decimal(10, 0) NULL DEFAULT NULL COMMENT '已用额度',
`residue` decimal(10, 0) NULL DEFAULT NULL COMMENT '剩余可用额度',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of t_account
-- ----------------------------
INSERT INTO `t_account` VALUES (1, 1, 100, 80, 20);
-- ----------------------------
-- Table structure for undo_log
-- ----------------------------
DROP TABLE IF EXISTS `undo_log`;
CREATE TABLE `undo_log` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`branch_id` bigint(20) NOT NULL,
`xid` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`context` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`rollback_info` longblob NOT NULL,
`log_status` int(11) NOT NULL,
`log_created` datetime(0) NOT NULL,
`log_modified` datetime(0) NOT NULL,
`ext` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE,
UNIQUE INDEX `ux_undo_log`(`xid`, `branch_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of undo_log
-- ----------------------------
SET FOREIGN_KEY_CHECKS = 1;
resouces/SQL/seata_order.sql 0 → 100644
浏览文件 @ c11faa2d
/*
Navicat Premium Data Transfer
Source Server : 本地mysql
Source Server Type : MySQL
Source Server Version : 50717
Source Host : localhost:3306
Source Schema : seata_order
Target Server Type : MySQL
Target Server Version : 50717
File Encoding : 65001
Date: 18/03/2020 21:29:29
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for t_order
-- ----------------------------
DROP TABLE IF EXISTS `t_order`;
CREATE TABLE `t_order` (
`id` bigint(11) NOT NULL AUTO_INCREMENT,
`user_id` bigint(11) NULL DEFAULT NULL COMMENT '用户id',
`product_id` bigint(11) NULL DEFAULT NULL COMMENT '产品id',
`count` int(11) NULL DEFAULT NULL COMMENT '数量',
`money` decimal(11, 0) NULL DEFAULT NULL COMMENT '金额',
`status` int(1) NULL DEFAULT NULL COMMENT '订单状态：0：创建中；1：已完结',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 21 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of t_order
-- ----------------------------
INSERT INTO `t_order` VALUES (12, 1, 1, 1, 10, 1);
INSERT INTO `t_order` VALUES (18, 1, 1, 1, 10, 1);
INSERT INTO `t_order` VALUES (19, 1, 1, 1, 10, 1);
-- ----------------------------
-- Table structure for undo_log
-- ----------------------------
DROP TABLE IF EXISTS `undo_log`;
CREATE TABLE `undo_log` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`branch_id` bigint(20) NOT NULL,
`xid` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`context` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`rollback_info` longblob NOT NULL,
`log_status` int(11) NOT NULL,
`log_created` datetime(0) NOT NULL,
`log_modified` datetime(0) NOT NULL,
`ext` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE,
UNIQUE INDEX `ux_undo_log`(`xid`, `branch_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 20 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of undo_log
-- ----------------------------
SET FOREIGN_KEY_CHECKS = 1;
resouces/SQL/seata_storage.sql 0 → 100644
浏览文件 @ c11faa2d
/*
Navicat Premium Data Transfer
Source Server : 本地mysql
Source Server Type : MySQL
Source Server Version : 50717
Source Host : localhost:3306
Source Schema : seata_storage
Target Server Type : MySQL
Target Server Version : 50717
File Encoding : 65001
Date: 18/03/2020 21:29:38
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for t_storage
-- ----------------------------
DROP TABLE IF EXISTS `t_storage`;
CREATE TABLE `t_storage` (
`id` bigint(11) NOT NULL AUTO_INCREMENT,
`product_id` bigint(11) NULL DEFAULT NULL COMMENT '产品id',
`total` int(11) NULL DEFAULT NULL COMMENT '库存',
`used` int(11) NULL DEFAULT NULL COMMENT '已用库存',
`residue` int(11) NULL DEFAULT NULL COMMENT '剩余库存',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of t_storage
-- ----------------------------
INSERT INTO `t_storage` VALUES (1, 1, 10, 8, 2);
-- ----------------------------
-- Table structure for undo_log
-- ----------------------------
DROP TABLE IF EXISTS `undo_log`;
CREATE TABLE `undo_log` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`branch_id` bigint(20) NOT NULL,
`xid` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`context` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`rollback_info` longblob NOT NULL,
`log_status` int(11) NOT NULL,
`log_created` datetime(0) NOT NULL,
`log_modified` datetime(0) NOT NULL,
`ext` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE,
UNIQUE INDEX `ux_undo_log`(`xid`, `branch_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 10 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of undo_log
-- ----------------------------
SET FOREIGN_KEY_CHECKS = 1;
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或