带你玩转SpringCloud实战

断路器所有配置

	//========================All
    ;HystrixCommand(fallbackMethod = ;str_fallbackMethod;,
            groupKey = ;strGroupCommand;,
            commandKey = ;strCommand;,
            threadPoolKey = ;strThreadPool;,

            commandProperties = {
                    // 设置隔离策略;THREAD 表示线程池 SEMAPHORE;信号池隔离
                    ;HystrixProperty(name = ;execution.isolation.strategy;, value = ;THREAD;),
                    // 当隔离策略选择信号池隔离的时候;用来设置信号池的大小;最大并发数;
                    ;HystrixProperty(name = ;execution.isolation.semaphore.maxConcurrentRequests;, value = ;10;),
                    // 配置命令执行的超时时间
                    ;HystrixProperty(name = ;execution.isolation.thread.timeoutinMilliseconds;, value = ;10;),
                    // 是否启用超时时间
                    ;HystrixProperty(name = ;execution.timeout.enabled;, value = ;true;),
                    // 执行超时的时候是否中断
                    ;HystrixProperty(name = ;execution.isolation.thread.interruptOnTimeout;, value = ;true;),
                    // 执行被取消的时候是否中断
                    ;HystrixProperty(name = ;execution.isolation.thread.interruptOnCancel;, value = ;true;),
                    // 允许回调方法执行的最大并发数
                    ;HystrixProperty(name = ;fallback.isolation.semaphore.maxConcurrentRequests;, value = ;10;),
                    // 服务降级是否启用;是否执行回调函数
                    ;HystrixProperty(name = ;fallback.enabled;, value = ;true;),
                    // 是否启用断路器
                    ;HystrixProperty(name = ;circuitBreaker.enabled;, value = ;true;),
                    // 该属性用来设置在滚动时间窗中;断路器熔断的最小请求数。例如;默认该值为 20 的时候;
                    // 如果滚动时间窗;默认10秒;内仅收到了19个请求; 即使这19个请求都失败了;断路器也不会打开。
                    ;HystrixProperty(name = ;circuitBreaker.requestVolumeThreshold;, value = ;20;),
                    // 该属性用来设置在滚动时间窗中;表示在滚动时间窗中;在请求数量超过
                    // circuitBreaker.requestVolumeThreshold 的情况下;如果错误请求数的百分比超过50,
                    // 就把断路器设置为 ;打开; 状态;否则就设置为 ;关闭; 状态。
                    ;HystrixProperty(name = ;circuitBreaker.errorThresholdPercentage;, value = ;50;),
                    // 该属性用来设置当断路器打开之后的休眠时间窗。 休眠时间窗结束之后;
                    // 会将断路器置为 ;半开; 状态;尝试熔断的请求命令;如果依然失败就将断路器继续设置为 ;打开; 状态;
                    // 如果成功就设置为 ;关闭; 状态。
                    ;HystrixProperty(name = ;circuitBreaker.sleepWindowinMilliseconds;, value = ;5000;),
                    // 断路器强制打开
                    ;HystrixProperty(name = ;circuitBreaker.forceOpen;, value = ;false;),
                    // 断路器强制关闭
                    ;HystrixProperty(name = ;circuitBreaker.forceClosed;, value = ;false;),
                    // 滚动时间窗设置;该时间用于断路器判断健康度时需要收集信息的持续时间
                    ;HystrixProperty(name = ;metrics.rollingStats.timeinMilliseconds;, value = ;10000;),
                    // 该属性用来设置滚动时间窗统计指标信息时划分;桶;的数量;断路器在收集指标信息的时候会根据
                    // 设置的时间窗长度拆分成多个 ;桶; 来累计各度量值;每个;桶;记录了一段时间内的采集指标。
                    // 比如 10 秒内拆分成 10 个;桶;收集这样;所以 timeinMilliseconds 必须能被 numBuckets 整除。否则会抛异常
                    ;HystrixProperty(name = ;metrics.rollingStats.numBuckets;, value = ;10;),
                    // 该属性用来设置对命令执行的延迟是否使用百分位数来跟踪和计算。如果设置为 false, 那么所有的概要统计都将返回 -1。
                    ;HystrixProperty(name = ;metrics.rollingPercentile.enabled;, value = ;false;),
                    // 该属性用来设置百分位统计的滚动窗口的持续时间;单位为毫秒。
                    ;HystrixProperty(name = ;metrics.rollingPercentile.timeInMilliseconds;, value = ;60000;),
                    // 该属性用来设置百分位统计滚动窗口中使用 “ 桶 ”的数量。
                    ;HystrixProperty(name = ;metrics.rollingPercentile.numBuckets;, value = ;60000;),
                    // 该属性用来设置在执行过程中每个 “桶” 中保留的最大执行次数。如果在滚动时间窗内发生超过该设定值的执行次数;
                    // 就从最初的位置开始重写。例如;将该值设置为100, 滚动窗口为10秒;若在10秒内一个 “桶 ”中发生了500次执行;
                    // 那么该 “桶” 中只保留 最后的100次执行的统计。另外;增加该值的大小将会增加内存量的消耗;并增加排序百分位数所需的计算时间。
                    ;HystrixProperty(name = ;metrics.rollingPercentile.bucketSize;, value = ;100;),
                    // 该属性用来设置采集影响断路器状态的健康快照;请求的成功、 错误百分比;的间隔等待时间。
                    ;HystrixProperty(name = ;metrics.healthSnapshot.intervalinMilliseconds;, value = ;500;),
                    // 是否开启请求缓存
                    ;HystrixProperty(name = ;requestCache.enabled;, value = ;true;),
                    // HystrixCommand的执行和事件是否打印日志到 HystrixRequestLog 中
                    ;HystrixProperty(name = ;requestLog.enabled;, value = ;true;),
            },
            threadPoolProperties = {
                    // 该参数用来设置执行命令线程池的核心线程数;该值也就是命令执行的最大并发量
                    ;HystrixProperty(name = ;coreSize;, value = ;10;),
                    // 该参数用来设置线程池的最大队列大小。当设置为 -1 时;线程池将使用 SynchronousQueue 实现的队列;
                    // 否则将使用 LinkedBlockingQueue 实现的队列。
                    ;HystrixProperty(name = ;maxQueueSize;, value = ;-1;),
                    // 该参数用来为队列设置拒绝阈值。 通过该参数; 即使队列没有达到最大值也能拒绝请求。
                    // 该参数主要是对 LinkedBlockingQueue 队列的补充,因为 LinkedBlockingQueue
                    // 队列不能动态修改它的对象大小;而通过该属性就可以调整拒绝请求的队列大小了。
                    ;HystrixProperty(name = ;queueSizeRejectionThreshold;, value = ;5;),
            }
    )
    public String strConsumer() {
        return ;hello 2020;;
    }

    public String str_fallbackMethod() {
        return ;*****fall back str_fallbackMethod;;
    }

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

server:
  port: 9001

;SpringBootApplication
;EnableHystrixDashboard
public class HystrixDashboardMain9001{
    public static void main(String[] args){
        SpringApplication.run(HystrixDashboardMain9001.class,args);
    }
}

<!-- actuator监控信息完善 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

/**
 *此配置是为了服务监控而配置;与服务容错本身无关;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;
}

<!--gateway-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

server:
  port: 9527

spring:
  application:
    name: cloud-gateway
  cloud:
    gateway:
      routes:
        - id: payment_routh #payment_route    #路由的ID;没有固定规则但要求唯一;建议配合服务名
          uri: http://localhost:8001          #匹配后提供服务的路由地址
          predicates:
            - Path=/payment/get/**         # 断言;路径相匹配的进行路由

        - id: payment_routh2 #payment_route    #路由的ID;没有固定规则但要求唯一;建议配合服务名
          uri: http://localhost:8001          #匹配后提供服务的路由地址
          predicates:
            - Path=/payment/lb/**         # 断言;路径相匹配的进行路由

eureka:
  instance:
    hostname: cloud-gateway-service
  client: #服务提供者provider注册进eureka服务列表内
    service-url:
      register-with-eureka: true
      fetch-registry: true
      defaultZone: http://eureka7001.com:7001/eureka

server:
  port: 9527

spring:
  application:
    name: cloud-gateway
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true #开启从注册中心动态创建路由的功能;利用微服务名进行路由
      routes:
        - id: payment_routh #payment_route    #路由的ID;没有固定规则但要求唯一;建议配合服务名
          # uri: http://localhost:8001          #匹配后提供服务的路由地址
          uri: lb://cloud-payment-service #匹配后提供服务的路由地址
          predicates:
            - Path=/payment/get/**         # 断言;路径相匹配的进行路由

        - id: payment_routh2 #payment_route    #路由的ID;没有固定规则但要求唯一;建议配合服务名
          # uri: http://localhost:8001          #匹配后提供服务的路由地址
          uri: lb://cloud-payment-service #匹配后提供服务的路由地址
          predicates:
            - Path=/payment/lb/**         # 断言;路径相匹配的进行路由
            #- After=2020-02-05T15:10:03.685;08:00[Asia/Shanghai]         # 断言;路径相匹配的进行路由
            #- Before=2020-02-05T15:10:03.685;08:00[Asia/Shanghai]         # 断言;路径相匹配的进行路由
            #- Between=2020-02-02T17:45:06.206;08:00[Asia/Shanghai],2020-03-25T18:59:06.206;08:00[Asia/Shanghai]
            #- Cookie=username
            #- Header=X-Request-Id, d;  # 请求头要有X-Request-Id属性并且值为整数的正则表达式
            #- Host=**.baidu.com
            #- Method=GET
            #- Query=username, d;  # 要有参数名username并且值还要是整数才能路由
          #filters:   #过滤器配置
          #  - AddRequestParameter=X-Request-Id,1024 #过滤器工厂会在匹配的请求头加上一对请求头;名称为X-Request-Id值为1024

eureka:
  instance:
    hostname: cloud-gateway-service
  client: #服务提供者provider注册进eureka服务列表内
    service-url:
      register-with-eureka: true
      fetch-registry: true
      defaultZone: http://eureka7001.com:7001/eureka

;SpringBootApplication
;EnableEurekaClient
public class GateWayMain9527 {

    public static void main(String[] args) {
        SpringApplication.run(GateWayMain9527.class, args);
    }
}

/**
 * java代码方式配置路由转发
 */
;Configuration
public class GateWayConfig {

    /**
     * 配置了一个id为path_route的路由规则;
     * 当访问地址 http://localhost:9527/guonei时会自动转发到地址;http://news.baidu.com/guonei
     *
     * ;param builder
     * ;return
     */
    ;Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        RouteLocatorBuilder.Builder routes = builder.routes();

        routes.route(;path_route;, r -> r.path(;/guonei;).uri(;http://news.baidu.com/guonei;)).build();

        return routes.build();

    }

    /**
     * 配置了一个id为path_route2的路由规则;
     * 当访问地址 http://localhost:9527/guoji时会自动转发到地址;http://news.baidu.com/guoji
     *
     * ;param builder
     * ;return
     */
    ;Bean
    public RouteLocator customRouteLocator2(RouteLocatorBuilder builder) {
        RouteLocatorBuilder.Builder routes = builder.routes();
        routes.route(;path_route2;, r -> r.path(;/guoji;).uri(;http://news.baidu.com/guoji;)).build();
        return routes.build();
    }
}

;Component
public class MyLogGateWayFilter implements GlobalFilter, Ordered {

    /**
     * 过滤器执行逻辑
     * ;param exchange
     * ;param chain
     * ;return
     */
    ;Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        System.out.println(;time:;;new Date();;	 执行了自定义的全局过滤器: ;;;MyLogGateWayFilter;;;hello;);

        String uname = exchange.getRequest().getQueryParams().getFirst(;uname;);
        if (uname == null) {
            System.out.println(;****用户名为null;无法登录;);
            exchange.getResponse().setStatusCode(HttpStatus.NOT_ACCEPTABLE);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    }

    /**
     * 过滤器顺序
     * ;return
     */
    ;Override
    public int getOrder() {
        return 0;
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

server:
  port: 3344

spring:
  application:
    name:  cloud-config-center #注册进Eureka服务器的微服务名
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/xxxxx/springcloud-configs.git #GitHub上面的git仓库名字
          ####搜索目录
          search-paths:
            - cloud-config-center
          #username: root
          #password: 123456
      ####读取分支
      label: master

#服务注册到eureka地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka

;SpringBootApplication
;EnableConfigServer
public class ConfigCenterMain3344 {

    public static void main(String[] args) {
        SpringApplication.run(ConfigCenterMain3344.class, args);
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

server:
  port: 3355

spring:
  application:
    name: cloud-config-client
  cloud:
    #Config客户端配置
    config:
      label: master #分支名称
      name: application #配置文件名称
      profile: dev #读取后缀名称   上述3个综合;master分支上config-dev.yml的配置文件被读取http://localhost:3344/master/application-dev.yml
      uri: http://localhost:3344 #配置中心地址

#服务注册到eureka地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
      
# 暴露监控端点
management:
  endpoints:
    web:
      exposure:
        include: ;*;

;SpringBootApplication
;EnableEurekaClient
public class ConfigClientMain3355 {

    public static void main(String[] args) {
        SpringApplication.run(ConfigClientMain3355.class, args);
    }
}

;RestController
//开启config配置中心自动刷新
;RefreshScope
public class ConfigClientController {

    ;Value(;${config.info};)
    private String configInfo;

    ;GetMapping(;/configInfo;)
    public String getConfigInfo() {
        return configInfo;
    }
}

<!--添加消息总线RabbitMQ支持-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

server:
  port: 3344

spring:
  application:
    name:  cloud-config-center #注册进Eureka服务器的微服务名
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/xxxxx/springcloud-configs.git #GitHub上面的git仓库名字
          ####搜索目录
          search-paths:
            - cloud-config-center
          #username: root
          #password: 123456
      ####读取分支
      label: master
  #rabbitmq相关配置
  rabbitmq:
    host: 192.168.198.101
    port: 5672
    username: guest
    password: guest

#服务注册到eureka地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka

##rabbitmq相关配置,暴露bus刷新配置的端点
management:
  endpoints: #暴露bus刷新配置的端点
    web:
      exposure:
        include: ;bus-refresh;

<!--添加消息总线RabbitMQ支持-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

server:
  port: 3355

spring:
  application:
    name: cloud-config-client
  cloud:
    #Config客户端配置
    config:
      label: master #分支名称
      name: application #配置文件名称
      profile: dev #读取后缀名称   上述3个综合;master分支上config-dev.yml的配置文件被读取http://localhost:3344/master/application-dev.yml
      uri: http://localhost:3344 #配置中心地址
  #rabbitmq相关配置 15672是Web管理界面的端口;5672是MQ访问的端口
  rabbitmq:
    host: 192.168.198.101
    port: 5672
    username: guest
    password: guest

#服务注册到eureka地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka

# 暴露监控端点
management:
  endpoints:
    web:
      exposure:
        include: ;*;

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!--Spring Cloud Steam Rabbit整合包-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--基础配置-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

server:
  port: 8801

spring:
  application:
    name: cloud-stream-provider
  rabbitmq:
    host: 192.168.198.101
    port: 5672
    username: guest
    password: guest
  cloud:
    stream:
      binders: # 在此处配置要绑定的rabbitmq的服务信息;
        defaultRabbit: # 表示定义的名称;用于于binding整合
          type: rabbit # 消息组件类型
      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: send-8801.com  # 在信息列表时显示主机名称
    prefer-ip-address: true     # 访问的路径变为IP地址

;SpringBootApplication
public class StreamMQMain8801 {

    public static void main(String[] args) {
        SpringApplication.run(StreamMQMain8801.class, args);
    }
}

;EnableBinding(Source.class) // 可以理解为是一个消息的发送管道的定义
public class MessageProviderImpl implements IMessageProvider {

    ;Resource
    private MessageChannel output; // 消息的发送管道

    ;Override
    public String send() {
        String serial = UUID.randomUUID().toString();
        this.output.send(MessageBuilder.withPayload(serial).build()); // 创建并发送消息
        System.out.println(;***serial: ; ; serial);
        return serial;
    }
}

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!--Spring Cloud Steam Rabbit整合包-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--基础配置-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

server:
  port: 8802

spring:
  application:
    name: cloud-stream-consumer
  rabbitmq:
    host: 192.168.198.101
    port: 5672
    username: guest
    password: guest
  cloud:
    stream:
      binders: # 在此处配置要绑定的rabbitmq的服务信息;
        defaultRabbit: # 表示定义的名称;用于于binding整合
          type: rabbit # 消息组件类型
      bindings: # 服务的整合处理
        input: # 这个名字是一个通道的名称
          destination: studyExchange # 表示要使用的Exchange名称定义
          content-type: application/json # 设置消息类型;本次为对象json;如果是文本则设置“text/plain”
          binder: defaultRabbit # 设置要绑定的消息服务的具体设置
          group: groupA # 设置消费组

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: receive-8802.com  # 在信息列表时显示主机名称
    prefer-ip-address: true     # 访问的路径变为IP地址

;SpringBootApplication
public class StreamMQMain8802 {

    public static void main(String[] args) {
        SpringApplication.run(StreamMQMain8802.class, args);
    }
}

;Component
;EnableBinding(Sink.class)
public class ReceiveMessageListener {

    ;Value(;${server.port};)
    private String serverPort;

    ;StreamListener(Sink.INPUT)
    public void input(Message<String> message) {
        System.out.println(;消费者1号;------->接收到的消息;; ; message.getPayload() ; ;	 port: ; ; serverPort);
    }
}

<!--包含了sleuth;zipkin-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>

server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  zipkin:
    base-url: http://localhost:9411
  sleuth:
    sampler:
      #采样率值介于 0 到 1 之间;1 则表示全部采集
     probability: 1

<!--包含了sleuth;zipkin-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>

server:
  port: 80

spring:
    application:
        name: cloud-order-service
    zipkin:
      base-url: http://localhost:9411
    sleuth:
      sampler:
        probability: 1

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

<!--SpringCloud ailibaba nacos -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

server:
  port: 9001

spring:
  application:
    name: nacos-payment-provider
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #配置Nacos地址

management:
  endpoints:
    web:
      exposure:
        include: ;*;

;EnableDiscoveryClient
;SpringBootApplication
public class PaymentMain9001 {

    public static void main(String[] args) {
        SpringApplication.run(PaymentMain9001.class, args);
    }
}

<!--SpringCloud ailibaba nacos -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

server:
  port: 83

spring:
  application:
    name: nacos-order-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

#消费者将要去访问的微服务名称(注册成功进nacos的微服务提供者)
service-url:
  nacos-user-service: http://nacos-payment-provider 

;EnableDiscoveryClient
;SpringBootApplication
public class OrderNacosMain83 {

    public static void main(String[] args) {
        SpringApplication.run(OrderNacosMain83.class, args);
    }
}

;Configuration
public class ApplicationContextBean{
    ;Bean
    ;LoadBalanced
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

;RestController
public class OrderNacosController {

    ;Resource
    private RestTemplate restTemplate;

    ;Value(;${service-url.nacos-user-service};)
    private String serverURL;

    ;GetMapping(;/consumer/payment/nacos/{id};)
    public String paymentInfo(;PathVariable(;id;) Long id) {
        return restTemplate.getForObject(serverURL ; ;/payment/nacos/; ; id, String.class);
    }
}

<dependencies>
    <!--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>
    <!--一般基础配置-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

# nacos配置
server:
  port: 3377

spring:
  application:
    name: nacos-config-client
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #Nacos服务注册中心地址
      config:
        server-addr: localhost:8848 #Nacos作为配置中心地址
        file-extension: yaml #指定yaml格式的配置
        #namespace: 5da1dccc-ee26-49e0-b8e5-7d9559b95ab0 #指定namespace
        #group: TEST_GROUP #指定group
        
# ${spring.application.name}-${spring.profile.active}.${spring.cloud.nacos.config.file-extension}

spring:
  profiles:
    active: dev # 表示开发环境

;EnableDiscoveryClient
;SpringBootApplication
public class NacosConfigClientMain3377{
    public static void main(String[] args) {
            SpringApplication.run(NacosConfigClientMain3377.class, args);
    }
}

;RestController
;RefreshScope //在控制器类加入;RefreshScope注解使当前类下的配置支持Nacos的动态刷新功能。
public class ConfigClientController{
    ;Value(;${config.info};)
    private String configInfo;

    ;GetMapping(;/config/info;)
    public String getConfigInfo() {
        return configInfo;
    }
}

<!--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>

server:
  port: 8401

spring:
  application:
    name: cloud-sentinel-service
  cloud:
    nacos:
      discovery:
        #Nacos服务注册中心地址
        server-addr: 192.168.198.101:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: 192.168.198.101:8858
        #默认8719端口;假如被占用会自动从8719开始依次;1扫描,直至找到未被占用的端口
        port: 8719

management:
  endpoints:
    web:
      exposure:
        include: ;*;

;EnableDiscoveryClient
;SpringBootApplication
public class MainApp8401 {

    public static void main(String[] args) {
        SpringApplication.run(MainApp8401.class, args);
    }
}

;RestController
public class FlowLimitController {

    ;GetMapping(;/testA;)
    public String testA() {
        return ;------testA;;
    }

    ;GetMapping(;/testB;)
    public String testB() {
        return ;------testB;;
    }
    
    ;GetMapping(;/testC;)
    public String testC(){
        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        return ;------testC;;
    }

    ;GetMapping(;/testD;)
    public String testD(){
        int age = 10/0;
        return ;------testD;;
    }

    ;GetMapping(;/testE;)
    public String testE(){
        int age = 10/0;
        return ;------testE 测试异常比例;;
    }
    
    ;GetMapping(;/testHotKey;)
    ;SentinelResource(value = ;testHotKey;, blockHandler = ;dealHandler_testHotKey;)
    public String testHotKey(;RequestParam(value = ;p1;, required = false) String p1,
                             ;RequestParam(value = ;p2;, required = false) String p2) {
        return ;------testHotKey;;
    }

    public String dealHandler_testHotKey(String p1, String p2, BlockException exception) {
        return ;-----dealHandler_testHotKey;;
    }

}

public class CustomerBlockHandler{
    public static CommonResult handleException(BlockException exception){
        return new CommonResult(2020,;自定义的限流处理信息......CustomerBlockHandler;);
    }
}

	/**
     * 自定义通用的限流处理逻辑;
     blockHandlerClass = CustomerBlockHandler.class
     blockHandler = handleException
     上述配置;找CustomerBlockHandler类里的handleException方法进行兜底处理
     */
    /**
     * 自定义通用的限流处理逻辑
     */
    ;GetMapping(;/rateLimit/customerBlockHandler;)
    ;SentinelResource(value = ;customerBlockHandler;,
            blockHandlerClass = CustomerBlockHandler.class, blockHandler = ;handleException;)
    public CommonResult customerBlockHandler() {
        return new CommonResult(200, ;按客户自定义限流处理逻辑;);
    }

<!--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>

server:
  port: 84


spring:
  application:
    name: nacos-order-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: localhost:8080
        #默认8719端口;假如被占用会自动从8719开始依次;1扫描,直至找到未被占用的端口
        port: 8719


#消费者将要去访问的微服务名称(注册成功进nacos的微服务提供者)
service-url:
  nacos-user-service: http://nacos-payment-provider

;EnableDiscoveryClient
;SpringBootApplication
public class OrderNacosMain83 {

    public static void main(String[] args) {
        SpringApplication.run(OrderNacosMain83.class, args);
    }
}

;Configuration
public class ApplicationContextConfig{
    ;Bean
    ;LoadBalanced
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

;RestController
;Slf4j
public class CircleBreakerController{
    public static final String SERVICE_URL = ;http://nacos-payment-provider;;

    ;Resource
    private RestTemplate restTemplate;

    ;RequestMapping(;/consumer/fallback/{id};)
    ;SentinelResource(value = ;fallback;,fallback = ;handlerFallback;) //fallback负责业务异常
    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;
    }
    
    public CommonResult handlerFallback(;PathVariable  Long id,Throwable e) {
        Payment payment = new Payment(id,;null;);
        return new CommonResult<>(444,;兜底异常handlerFallback,exception内容  ;;e.getMessage(),payment);
    }
}

;RestController
;Slf4j
public class CircleBreakerController{
    public static final String SERVICE_URL = ;http://nacos-payment-provider;;

    ;Resource
    private RestTemplate restTemplate;

    ;RequestMapping(;/consumer/fallback/{id};)
    ;SentinelResource(value = ;fallback;,blockHandler = ;blockHandler;) //blockHandler负责在sentinel里面配置的降级限流
    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 (;非法参数异常....;);
        }else if (result.getData() == null) {
            throw new NullPointerException (;NullPointerException,该ID没有对应记录;);
        }
        return result;
    }
    
    public CommonResult blockHandler(;PathVariable  Long id,BlockException blockException) {
        Payment payment = new Payment(id,;null;);
        return new CommonResult<>(445,;blockHandler-sentinel限流,无此流水: blockException  ;;blockException.getMessage(),payment);
    }

}

;RestController
;Slf4j
public class CircleBreakerController{
    public static final String SERVICE_URL = ;http://nacos-payment-provider;;

    ;Resource
    private RestTemplate restTemplate;

    ;RequestMapping(;/consumer/fallback/{id};)
    ;SentinelResource(value = ;fallback;,fallback = ;handlerFallback;,blockHandler = ;blockHandler;)
    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 (;非法参数异常....;);
        }else if (result.getData() == null) {
            throw new NullPointerException (;NullPointerException,该ID没有对应记录;);
        }
        return result;
    }
    
    public CommonResult handlerFallback(;PathVariable  Long id,Throwable e) {
        Payment payment = new Payment(id,;null;);
        return new CommonResult<>(444,;fallback,无此流水,exception  ;;e.getMessage(),payment);
    }
    
    public CommonResult blockHandler(;PathVariable  Long id,BlockException blockException) {
        Payment payment = new Payment(id,;null;);
        return new CommonResult<>(445,;blockHandler-sentinel限流,无此流水: blockException  ;;blockException.getMessage(),payment);
    }

}

;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}) 
    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;
    }

<!--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>
<!--SpringCloud openfeign -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

server:
  port: 84


spring:
  application:
    name: nacos-order-consumer
  cloud:
    nacos:
      discovery:
        #Nacos服务注册中心地址
        server-addr: localhost:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: localhost:8080
        #默认8719端口;假如被占用会自动从8719开始依次;1扫描,直至找到未被占用的端口
        port: 8719

management:
  endpoints:
    web:
      exposure:
        include: ;*;
# 激活Sentinel对Feign的支持
feign:
  sentinel:
    enabled: true  

;EnableDiscoveryClient
;SpringBootApplication
;EnableFeignClients
public class OrderNacosMain84 {

    public static void main(String[] args) {
        SpringApplication.run(OrderNacosMain84.class, args);
    }
}

;FeignClient(value = ;nacos-payment-provider;,fallback = PaymentFallbackService.class)
public interface PaymentService{
    ;GetMapping(value = ;/paymentSQL/{id};)
    public CommonResult<Payment> paymentSQL(;PathVariable(;id;) Long id);
}

;Component
public class PaymentFallbackService implements PaymentService {

    ;Override
    public CommonResult<Payment> paymentSQL(Long id) {
        return new CommonResult<>(444, ;服务降级返回,没有该流水信息;, new Payment(id, ;errorSerial......;));
    }
}

<!--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>
<!-- SpringBoot整合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>

server:
  port: 8401

spring:
  application:
    name: cloud-sentinel-service
  cloud:
    nacos:
      discovery:
        #Nacos服务注册中心地址
        server-addr: 192.168.198.101:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: 192.168.198.101:8858
        #默认8719端口;假如被占用会自动从8719开始依次;1扫描,直至找到未被占用的端口
        port: 8719
      datasource:
        ds1:
          nacos:
            server-addr: 192.168.198.101:8848  #Nacos配置中心地址
            dataId: ${spring.application.name}
            groupId: DEFAULT_GROUP
            data-type: json
            rule-type: flow

management:
  endpoints:
    web:
      exposure:
        include: ;*;

feign:
  sentinel:
    enabled: true # 激活Sentinel对Feign的支持

<!--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>

server:
  port: 2001

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
    username: root
    password: 123456

feign:
  hystrix:
    enabled: false

logging:
  level:
    io:
      seata: info

mybatis:
  mapperLocations: classpath:mapper/*.xml

;EnableDiscoveryClient
;EnableFeignClients
;SpringBootApplication(exclude = DataSourceAutoConfiguration.class)//取消数据源的自动创建
public class SeataOrderMainApp2001 {

    public static void main(String[] args) {
        SpringApplication.run(SeataOrderMainApp2001.class, args);
    }
}

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;

;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();
    }

}

	;Override
    ;GlobalTransactional(name = ;fsp-create-order;, rollbackFor = Exception.class)
    public void create(Order order) {
        log.info(;------->下单开始;);
        //本应用创建订单
        orderDao.create(order);

        //远程调用库存服务扣减库存
        log.info(;------->order-service中扣减库存开始;);
        storageService.decrease(order.getProductId(), order.getCount());
        log.info(;------->order-service中扣减库存结束;);

        //远程调用账户服务扣减余额
        log.info(;------->order-service中扣减余额开始;);
        accountService.decrease(order.getUserId(), order.getMoney());
        log.info(;------->order-service中扣减余额结束;);

        //修改订单状态为已完成
        log.info(;------->order-service中修改订单状态开始;);
        orderDao.update(order.getUserId(), 0);
        log.info(;------->order-service中修改订单状态结束;);

        log.info(;------->下单结束;);
    }

### yml

;;;yaml
server:
  port: 2001

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
    username: root
    password: 123456

feign:
  hystrix:
    enabled: false

logging:
  level:
    io:
      seata: info

mybatis:
  mapperLocations: classpath:mapper/*.xml

;EnableDiscoveryClient
;EnableFeignClients
;SpringBootApplication(exclude = DataSourceAutoConfiguration.class)//取消数据源的自动创建
public class SeataOrderMainApp2001 {

    public static void main(String[] args) {
        SpringApplication.run(SeataOrderMainApp2001.class, args);
    }
}

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;

;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();
    }

}

	;Override
    ;GlobalTransactional(name = ;fsp-create-order;, rollbackFor = Exception.class)
    public void create(Order order) {
        log.info(;------->下单开始;);
        //本应用创建订单
        orderDao.create(order);

        //远程调用库存服务扣减库存
        log.info(;------->order-service中扣减库存开始;);
        storageService.decrease(order.getProductId(), order.getCount());
        log.info(;------->order-service中扣减库存结束;);

        //远程调用账户服务扣减余额
        log.info(;------->order-service中扣减余额开始;);
        accountService.decrease(order.getUserId(), order.getMoney());
        log.info(;------->order-service中扣减余额结束;);

        //修改订单状态为已完成
        log.info(;------->order-service中修改订单状态开始;);
        orderDao.update(order.getUserId(), 0);
        log.info(;------->order-service中修改订单状态结束;);

        log.info(;------->下单结束;);
    }