@Component
@Scope(scopeName="xx",proxyMode=xxx)
public class XXX{}

@Configuration
public class XXXConfig{
	@Bean
	@Scope(scopeName="xx",proxyMode=xxx)
	public Xxx getXxx(){
		return new Xxx();
	}
}

public class MyAfterTransactionEvent extends ApplicationEvent {
    //自定义一些属性
    //...

    public MyAfterTransactionEvent(Object... source) {
        super(source);
    }
}

@Slf4j
@Component
public class MyTransactionListener {
        //注入一些bean
        //...

        @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
        public void onHelloEvent(/** 自定义事件**/MyAfterTransactionEvent event) {
         //提交后的业务逻辑
         ...
        }
       /**
        * 作用同上
        **/
@EventListener
		void onSaveUserEvent(MyAfterTransactionEvent event) {
			 TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
		        @Override
		        public void afterCommit() {
		         //提交后的业务逻辑
		         //...
		        }
		    });
		  } 
	  }

@Service 
public class HelloServiceImpl{
	@Autowired
    private ApplicationEventPublisher publisher;
    
	@Transactional
	void test(){
		//db操作
		//...
		publisher.publishEvent(new MyAfterTransactionEvent());
	}
	
}

public class SecurityContextHolder {
	public static final String MODE_THREADLOCAL = "MODE_THREADLOCAL"; //线程副本策略
	public static final String MODE_INHERITABLETHREADLOCAL = "MODE_INHERITABLETHREADLOCAL";//可继承线程副本策略
	public static final String MODE_GLOBAL = "MODE_GLOBAL"; //全局策略
	public static final String SYSTEM_PROPERTY = "spring.security.strategy";
	private static String strategyName = System.getProperty(SYSTEM_PROPERTY);
	private static SecurityContextHolderStrategy strategy;
	private static int initializeCount = 0;
	
	static {
	initialize();
}
private static void initialize() {
	if (!StringUtils.hasText(strategyName)) {
		// Set default 如果系统变量读不到，则默认为线程副本策略
		strategyName = MODE_THREADLOCAL;
	}

	if (strategyName.equals(MODE_THREADLOCAL)) {
		strategy = new ThreadLocalSecurityContextHolderStrategy();
	}
	else if (strategyName.equals(MODE_INHERITABLETHREADLOCAL)) {
		strategy = new InheritableThreadLocalSecurityContextHolderStrategy();
	}
	else if (strategyName.equals(MODE_GLOBAL)) {
		strategy = new GlobalSecurityContextHolderStrategy();
	}
	else {
		// Try to load a custom strategy 如果都不匹配，那么加载自定义策略，strategyName为自定义策略的类路径，自定义策略需实现SecurityContextHolderStrategy接口
		try {
			Class<?> clazz = Class.forName(strategyName);
			Constructor<?> customStrategy = clazz.getConstructor();
			strategy = (SecurityContextHolderStrategy) customStrategy.newInstance();
		}
		catch (Exception ex) {
			ReflectionUtils.handleReflectionException(ex);
		}
	}

	initializeCount++;
}
...

	//从spring容器中获取UserDetailsService(这个从数据库根据用户名查询用户信息,及加载权限的service)
UserDetailsService userDetailsService = 
      (UserDetailsService)SpringContextUtil.getBean("userDetailsService");
 
//根据用户名username加载userDetails
UserDetails userDetails = userDetailsService.loadUserByUsername(username);
 
//根据userDetails构建新的Authentication,这里使用了
//PreAuthenticatedAuthenticationToken当然可以用其他token,如UsernamePasswordAuthenticationToken               
PreAuthenticatedAuthenticationToken authentication = 
      new PreAuthenticatedAuthenticationToken(userDetails, userDetails.getPassword(),userDetails.getAuthorities());
 
//设置authentication中details
authentication.setDetails(new WebAuthenticationDetails(request));
 
//存放authentication到SecurityContextHolder
SecurityContextHolder.getContext().setAuthentication(authentication);
HttpSession session = request.getSession(true);
//在session中存放security context,方便同一个session中控制用户的其他操作
session.setAttribute("SPRING_SECURITY_CONTEXT", SecurityContextHolder.getContext());

public void send(String routingKey, String msg) {
      RabbitTemplate rabbitTemplate = applicationContext.getBean("rabbitTemplate", RabbitTemplate.class);
      rabbitTemplate.setReturnCallback(this);
      log.info("消息发送内容 : " + msg);
      CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
      rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
          if (!ack) {
              throw new RuntimeException("send error " + cause);
          } else {
              log.info("send() 消息发送成功 ");
          }
      });
      rabbitTemplate.convertAndSend("amq.topic", routingKey, msg, correlationId);
  }

public void convertAndSend(String exchange, String routingKey, Object object, CorrelationData correlationData) throws AmqpException {
      this.send(exchange, routingKey, this.convertMessageIfNecessary(object), correlationData);
  }

	public class MessageProperties implements Serializable {
    private static final long serialVersionUID = 1619000546531112290L;
    public static final String CONTENT_TYPE_BYTES = "application/octet-stream";
    public static final String CONTENT_TYPE_TEXT_PLAIN = "text/plain";
    public static final String CONTENT_TYPE_SERIALIZED_OBJECT = "application/x-java-serialized-object";
    public static final String CONTENT_TYPE_JSON = "application/json";
    public static final String CONTENT_TYPE_JSON_ALT = "text/x-json";
    public static final String CONTENT_TYPE_XML = "application/xml";
    public static final String SPRING_BATCH_FORMAT = "springBatchFormat";
    public static final String BATCH_FORMAT_LENGTH_HEADER4 = "lengthHeader4";
    public static final String SPRING_AUTO_DECOMPRESS = "springAutoDecompress";
    public static final String X_DELAY = "x-delay";
    public static final String DEFAULT_CONTENT_TYPE = "application/octet-stream";
    public static final MessageDeliveryMode DEFAULT_DELIVERY_MODE;
    public static final Integer DEFAULT_PRIORITY;
    private final Map<String, Object> headers = new HashMap();
    private volatile Date timestamp;
    private volatile String messageId;
    private volatile String userId;
    private volatile String appId;
    private volatile String clusterId;
    private volatile String type;
    private volatile String correlationId;
    private volatile String replyTo;
    private volatile String contentType = "application/octet-stream";
    private volatile String contentEncoding;
    private volatile long contentLength;
    private volatile boolean contentLengthSet;
    private volatile MessageDeliveryMode deliveryMode;
    private volatile String expiration;
    private volatile Integer priority;
    private volatile Boolean redelivered;
    private volatile String receivedExchange;
    private volatile String receivedRoutingKey;
    private volatile String receivedUserId;
    private volatile long deliveryTag;
    private volatile boolean deliveryTagSet;
    private volatile Integer messageCount;
    private volatile String consumerTag;
    private volatile String consumerQueue;
    private volatile Integer receivedDelay;
    private volatile MessageDeliveryMode receivedDeliveryMode;
    private volatile boolean finalRetryForMessageWithNoId;
    private transient volatile Type inferredArgumentType;
    private transient volatile Method targetMethod;
    private transient volatile Object targetBean;
}

public void send(String routingKey, String msg) {
      RabbitTemplate rabbitTemplate = applicationContext.getBean("rabbitTemplate", RabbitTemplate.class);
      rabbitTemplate.setReturnCallback(this);
      log.info("消息发送内容 : " + msg);
      CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
      rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
          if (!ack) {
              throw new RuntimeException("send error " + cause);
          } else {
              log.info("send() 消息发送成功 ");
          }
      });
      Message message = MessageBuilder.withBody(msg.getBytes())
              .setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN)
              .setCorrelationId(correlationId.toString())
              .build();
      rabbitTemplate.convertAndSend("amq.topic", routingKey, message, correlationId);
  }

/**
 * @time: 2019/2/18 9:14
 * @author: hl
 * @descripe: 失败消息记录
 * @version: 1.0
 */
Entity
@Table(name = "t_failure_mq_record")
@Data
@NoArgsConstructor
@EntityListeners(AuditingEntityListener.class)
public class FailureMqRecord extends Uuid {
    /**
     * 失败消息内容
     */
    private String message;
    /**
     * 重试次数
     */
    @Column(name = "retry_time")
    private Integer retryTime;

    /**
     * 消息状态 1:投递成功 2：投递失败
     */
    private Integer status;

    /**
     * 关联id
     */
    private String correlationId;
    /**
     * 创建时间
     */
    @CreatedDate
    @Column(name = "create_time", updatable = false)
    private Date createTime;

    public FailureMqRecord(String message) {
        this.message = message;
    }
}

/**
 * @time: 2019/2/13 9:47
 * @author: hl
 * @descripe:
 * @version: 1.0
 */
@Component
@Slf4j
public class RabbitMqSender implements RabbitTemplate.ReturnCallback {
    @Autowired
    private ApplicationContext applicationContext;
    @Autowired
    private FailureMqRecordRepository failureMqRecordRepository;

    public void send(String routingKey, FailureMqRecord failureMqRecord) {
        RabbitTemplate rabbitTemplate = applicationContext.getBean("rabbitTemplate", RabbitTemplate.class);
        //设置当前实例为rabbitmqtemplate的returncallback
        rabbitTemplate.setReturnCallback(this);
        rabbitTemplate.setConfirmCallback(((correlationData1, ack, cause) -> {
            if (!ack) { //投递至broker失败
                failureMqRecord.setStatus(2);//设为投递失败
                failureMqRecordRepository.save(failureMqRecord);
            }
        }));
        Message message = MessageBuilder.withBody(failureMqRecord.getMessage().getBytes())
                .setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN)
                .setCorrelationId(failureMqRecord.getCorrelationId())
                .build();
        rabbitTemplate.convertAndSend("amq.topic", routingKey, message, new CorrelationData(failureMqRecord.getCorrelationId()));
        failureMqRecord.setStatus(1);//设为投递成功
        failureMqRecord.setRetryTime(failureMqRecord.getRetryTime() + 1);//重试次数+1
        failureMqRecordRepository.save(failureMqRecord);
    }

    /**
     * 消息由exchang未能正确投递到queue时触发回调
     *
     * @param message
     * @param replyCode
     * @param replyText
     * @param exchange
     * @param routingKey
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) throws BusinessException {
        FailureMqRecord mq = failureMqRecordRepository.findByCorrelationId(message.getMessageProperties().getCorrelationId());
        mq.setStatus(2);
        failureMqRecordRepository.save(mq);
        log.error("审批消息：{} 投递至路由：{}失败", message.getBody(), routingKey);
    }
}

/**
 * @time: 2019/2/18 10:10
 * @author: huanglong
 * @descripe: 消息重发定时器
 * @version: 1.0
 */
@Component
@Slf4j
public class MqScheduler {
    @Autowired
    private RabbitMqSender rabbitMqSender;
    @Autowired
    private ApprovalMqRepository failureMqRecordRepository;
    @Autowired
    private RedisDistributedLock redisDistributedLock;

    /**
     * 每3分钟执行一次
     * 将投递失败消息重新投递到rabbitmq
     */
    @Scheduled(cron = "* */3 * * * ?")
    void push() {
        List<FailureMqRecord> failureMqRecords = failureMqRecordRepository.findAll()
                .stream()
                .filter(failureMqRecord -> {
                    if (failureMqRecord.getRetryTime() == 3) {
                        log.error("警告！该消息已重投3次失败，请人工处理，消息记录uuid:{}", failureMqRecord.getUuid());
                    }
                    //过滤出重试次数不超过3次、状态为2的消息记录
                    if (failureMqRecord.getRetryTime() < 3 && failureMqRecord.getStatus() == 0) {
                        return true;
                    }
                    return false;
                })
                .collect(Collectors.toList());

        Iterator<FailureMqRecord> mqIterator = failureMqRecords.iterator();
        while (mqIterator.hasNext()) {
            FailureMqRecord failureMqRecord = mqIterator.next();
            //获取🔒,过期时间5秒，不重复获取
            if (redisDistributedLock.lock(failureMqRecord.getUuid(), 5000L, 0, 1000L)) {
                // 因为有可能上一个线程刚释放该记录的锁，就被当前先线程获取到该记录的锁，导致记录已被
                FailureMqRecord failurelatest = failureMqRecordRepository.findById(failureMqRecord.getUuid()).orElse(null);
                ApprovalPushMessage pushMessage = JSON.parseObject(failurelatest.getMessage(), ApprovalPushMessage.class);
                //当前时间距离该记录最近一次修改时间的间隔，防止上个线程重试过后，当前线程又重试一次
                long lastUpdatePeriod = System.currentTimeMillis() - failurelatest.getUpdateTime().getTime(); //距离上次更新间隔
                //重判断记录是否符合条件,重试次数小于3、状态为投递失败、距离上次重试不能少于2分钟
                if (failurelatest.getRetryTime() < 3 && failurelatest.getStatus() == 2 && lastUpdatePeriod > 2 * 60 * 1000) {
                    rabbitMqSender.send("approval.create", failureMqRecord);
                }
                //释放🔒
                redisDistributedLock.releaseLock(failureMqRecord.getUuid());
            }
        }
    }
}

logger.info("rpc请求开始");
   long rpcstart = System.currentTimeMillis();

   StoreStaffDTO staffDTO = staffClient.getStaffDTO(userDTO.getUuid()); //获取门店员工信息
   SupplierDTO supplierDTO = supplierClient.getSupplierDTO(userDTO.getSupplierCode()); //获取供应商信息
   StoreDTO staffStoreDTO = storeClient.getStoreDTO(userDTO.getStoreUuid()); //获取员工所在门店信息
   CustomerInfoDTO customerInfoDTO = customerInfoClient.getCustomerInfo(approval.getCustomerUuid()); //获取顾客信息
   StoreDTO inStoreDto = ObjectUtils.isEmpty(approval.getInStoreUuid()) ? null : storeClient.getStoreDTO(approval.getInStoreUuid());//获取客户转入门店信息
   ServerDto serverDto = ObjectUtils.isEmpty(approval.getServerUuid()) ? null : serveClient.getServeSpecTypeByuuid(approval.getServerUuid()); //获取服务信息
   CustAccountDto custAccountDto = ObjectUtils.isEmpty(approval.getCustCardUuid()) ? null : accountClient.getCustAccount(approval.getCustCardUuid()); //获取顾客账户信息

   long rpcend = System.currentTimeMillis();
   logger.info("rpc请求结束，耗时：{}毫秒", (rpcend - rpcstart));

logger.info("rpc请求开始");
   long rpcstart = System.currentTimeMillis();

   Approval approvalFina = approval;
   CompletableFuture<StoreDTO> storeDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           return storeClient.getStoreDTO(userDTO.getStoreUuid());
       } catch (Exception e) {
           logger.error("获取门店信息rpc错误，原因：", e);
           throw e;
       }
   });
   CompletableFuture<StoreDTO> inStoreDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           if (!ObjectUtils.isEmpty(approvalFina.getInStoreUuid())) {
               return storeClient.getStoreDTO(approvalFina.getInStoreUuid());
           }
           return null;
       } catch (Exception e) {
           logger.error("获取转入门店信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<SupplierDTO> supplierDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           return supplierClient.getSupplierDTO(userDTO.getSupplierCode());
       } catch (Exception e) {
           logger.error("获取供应商信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<StoreStaffDTO> staffDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           return staffClient.getStaffDTO(userDTO.getUuid());
       } catch (Exception e) {
           logger.error("获取门店员工信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<CustomerInfoDTO> customerInfoDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           return customerInfoClient.getCustomerInfo(approvalFina.getCustomerUuid());
       } catch (Exception e) {
           logger.error("获取顾客信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<ServerDto> serverDtoCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           if (!ObjectUtils.isEmpty(approvalFina.getServerUuid())) {
               return serveClient.getServeSpecTypeByuuid(approvalFina.getServerUuid());
           }
           return null;
       } catch (Exception e) {
           logger.error("获取服务信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<CustAccountDto> custAccountDtoCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           if (!ObjectUtils.isEmpty(approvalFina.getCustCardUuid())) {
               return accountClient.getCustAccount(approvalFina.getCustCardUuid());
           }
           return null;
       } catch (Exception e) {
           logger.error("获取顾客账户信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture.allOf(storeDTOCompletableFuture, inStoreDTOCompletableFuture, serverDtoCompletableFuture,
           supplierDTOCompletableFuture, staffDTOCompletableFuture, customerInfoDTOCompletableFuture, custAccountDtoCompletableFuture);

   StoreStaffDTO staffDTO = null;//员工信息
   SupplierDTO supplierDTO = null; //供应商信息
   StoreDTO staffStoreDTO = null;//员工所在门店信息
   CustomerInfoDTO customerInfoDTO = null; //顾客信息
   StoreDTO inStoreDto = null;//顾客转入门店信息
   ServerDto serverDto = null; //服务信息
   CustAccountDto custAccountDto = null; //顾客账户信息
   try {
       staffStoreDTO = storeDTOCompletableFuture.get();
       inStoreDto = inStoreDTOCompletableFuture.get();
       staffDTO = staffDTOCompletableFuture.get();
       supplierDTO = supplierDTOCompletableFuture.get();
       customerInfoDTO = customerInfoDTOCompletableFuture.get();
       serverDto = serverDtoCompletableFuture.get();
       custAccountDto = custAccountDtoCompletableFuture.get();
   } catch (InterruptedException e) {
       logger.error("线程中断错误信息：{}", e);
   } catch (ExecutionException e) {
       logger.error("线程执行错误信息：{}", e);
   }

   long rpcend = System.currentTimeMillis();
   logger.info("rpc请求结束，耗时：{}毫秒", (rpcend - rpcstart));

@Configuration
public class FeignOauth2RequestInterceptor implements RequestInterceptor {
    private final String AUTHORIZATION_HEADER = "Authorization";
    private final String BEARER_TOKEN_TYPE = "Bearer";

    @Override
    public void apply(RequestTemplate requestTemplate) {
        SecurityContext securityContext = SecurityContextHolder.getContext();
        Authentication authentication = securityContext.getAuthentication();
        if (authentication != null && authentication.getDetails() instanceof OAuth2AuthenticationDetails) {
            OAuth2AuthenticationDetails details = (OAuth2AuthenticationDetails) authentication.getDetails();
            requestTemplate.header(AUTHORIZATION_HEADER, String.format("%s %s", BEARER_TOKEN_TYPE, details.getTokenValue()));
        }
    }
}

CompletableFuture<StoreDTO> storeDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
         try {
             logger.info("当前线程名：{}", Thread.currentThread().getName());
             return storeClient.getStoreDTO(userDTO.getStoreUuid());
         } catch (Exception e) {
             logger.error("获取门店信息rpc错误，原因：", e);
             throw e;
         }
     });

logger.info("rpc请求开始");
   long rpcstart = System.currentTimeMillis();

   SecurityContext securityContext = SecurityContextHolder.getContext();//从当前请求线程中拿到securityContext安全上下文
   Approval approvalFina = approval;
   CompletableFuture<StoreDTO> storeDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           SecurityContextHolder.setContext(securityContext); //设置securityContext安全上下文线程副本
           return storeClient.getStoreDTO(userDTO.getStoreUuid());
       } catch (Exception e) {
           logger.error("获取门店信息rpc错误，原因：", e);
           throw e;
       }
   });
   CompletableFuture<StoreDTO> inStoreDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           if (!ObjectUtils.isEmpty(approvalFina.getInStoreUuid())) {
               SecurityContextHolder.setContext(securityContext);
               return storeClient.getStoreDTO(approvalFina.getInStoreUuid());
           }
           return null;
       } catch (Exception e) {
           logger.error("获取转入门店信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<SupplierDTO> supplierDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           SecurityContextHolder.setContext(securityContext);
           return supplierClient.getSupplierDTO(userDTO.getSupplierCode());
       } catch (Exception e) {
           logger.error("获取供应商信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<StoreStaffDTO> staffDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           SecurityContextHolder.setContext(securityContext);
           return staffClient.getStaffDTO(userDTO.getUuid());
       } catch (Exception e) {
           logger.error("获取门店员工信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<CustomerInfoDTO> customerInfoDTOCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           SecurityContextHolder.setContext(securityContext);
           return customerInfoClient.getCustomerInfo(approvalFina.getCustomerUuid());
       } catch (Exception e) {
           logger.error("获取顾客信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<ServerDto> serverDtoCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           if (!ObjectUtils.isEmpty(approvalFina.getServerUuid())) {
               SecurityContextHolder.setContext(securityContext);
               return serveClient.getServeSpecTypeByuuid(approvalFina.getServerUuid());
           }
           return null;
       } catch (Exception e) {
           logger.error("获取服务信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture<CustAccountDto> custAccountDtoCompletableFuture = CompletableFuture.supplyAsync(() -> {
       try {
           logger.info("当前线程名：{}", Thread.currentThread().getName());
           if (!ObjectUtils.isEmpty(approvalFina.getCustCardUuid())) {
               SecurityContextHolder.setContext(securityContext);
               return accountClient.getCustAccount(approvalFina.getCustCardUuid());
           }
           return null;
       } catch (Exception e) {
           logger.error("获取顾客账户信息rpc错误，原因：{}", e);
           throw e;
       }
   });
   CompletableFuture.allOf(storeDTOCompletableFuture, inStoreDTOCompletableFuture, serverDtoCompletableFuture,
           supplierDTOCompletableFuture, staffDTOCompletableFuture, customerInfoDTOCompletableFuture, custAccountDtoCompletableFuture);


   StoreStaffDTO staffDTO = null;//员工信息
   SupplierDTO supplierDTO = null; //供应商信息
   StoreDTO staffStoreDTO = null;//员工所在门店信息
   CustomerInfoDTO customerInfoDTO = null; //顾客信息
   StoreDTO inStoreDto = null;//顾客转入门店信息
   ServerDto serverDto = null; //服务信息
   CustAccountDto custAccountDto = null; //顾客账户信息

   try {
       staffStoreDTO = storeDTOCompletableFuture.get();
       inStoreDto = inStoreDTOCompletableFuture.get();
       staffDTO = staffDTOCompletableFuture.get();
       supplierDTO = supplierDTOCompletableFuture.get();
       customerInfoDTO = customerInfoDTOCompletableFuture.get();
       serverDto = serverDtoCompletableFuture.get();
       custAccountDto = custAccountDtoCompletableFuture.get();
   } catch (InterruptedException e) {
       logger.error("线程中断错误信息：{}", e);
   } catch (ExecutionException e) {
       logger.error("线程执行错误信息：{}", e);
   }

   long rpcend = System.currentTimeMillis();
   logger.info("rpc请求结束，耗时：{}毫秒", (rpcend - rpcstart));