记得上下班打卡 | git大法好，push需谨慎

Skip to content

L
liquidnet-bus-v1
Commit 17bc2a18 authored by 张禹's avatar 张禹
Browse files
Options

Merge branch 'Fix220511_consumer_kylin' into 'master' 

Fix220511 consumer kylin

See merge request !228
parents 63423972 b5feb07e
Show whitespace changes
Inline Side-by-side
Showing with 5568 additions and 0 deletions
liquidnet-bus-config/liquidnet-config/liquidnet-service-consumer-order-dev.yml 0 → 100644
View file @ 17bc2a18
liquidnet:
system:
updating:
switch: false
info:
port: 9993
context:
# context: /service-consumer
name: liquidnet-service-consumer-order
logfile:
path: /data/logs
name: service-consumer-order
max-history: 7
level: debug
mysql:
database-name: dev_ln_scene
mongodb:
sslEnabled: false
database: dev_ln_scene
#以下为spring各环境个性配置
\ No newline at end of file
liquidnet-bus-config/liquidnet-config/liquidnet-service-consumer-order-test.yml 0 → 100644
View file @ 17bc2a18
liquidnet:
system:
updating:
switch: false
info:
port: 9993
context:
# context: /service-consumer
name: liquidnet-service-consumer-order
logfile:
path: /data/logs
name: service-consumer-order
max-history: 7
level: info
mysql:
database-name: test_ln_scene
mongodb:
sslEnabled: false
database: test_ln_scene
#以下为spring各环境个性配置
liquidnet-bus-config/liquidnet-config/liquidnet-service-consumer-order.yml 0 → 100644
View file @ 17bc2a18
server:
port: ${liquidnet.info.port}
tomcat:
uri-encoding: UTF-8
servlet:
context-path: ${liquidnet.info.context}
# -----------------------------------------------------------
knife4j:
production: ${liquidnet.knife4j.disable}
basic:
enable: true
username: ${liquidnet.security.username}
password: ${liquidnet.security.password}
# -----------------------------------------------------------
logging:
# config: ${liquidnet.logfile.config}
file:
name: ${liquidnet.logfile.path}/${liquidnet.logfile.name}.log
max-size: 200MB
max-history: ${liquidnet.logfile.max-history}
pattern:
file: '%d{yyyy-MM-dd HH:mm:ss.SSS} [ %-5level] %thread [%logger{36}:%line] - %msg%n'
console: '%d{yyyy-MM-dd HH:mm:ss.SSS} [ %-5level] %thread [%logger{36}:%line] - %msg%n'
rolling-file-name: ${liquidnet.logfile.path}/${liquidnet.logfile.name}-%d{yyyy-MM-dd}.%i.log
level:
root: error
#以下是为指定包设置日志级别
com.liquidnet.service.feign: error
com.liquidnet: ${liquidnet.logfile.level}
# -----------------------------------------------------------
eureka:
# client:
# register-with-eureka: true
# fetch-registry: true
# serviceUrl:
# defaultZone: http://${liquidnet.security.username}:${liquidnet.security.password}@${liquidnet.eureka.host}/eureka-server/eureka
instance:
hostname: ${spring.cloud.client.ip-address}
lease-expiration-duration-in-seconds: 15 #服务过期时间配置,超过这个时间没有接收到心跳EurekaServer就会将这个实例剔除
lease-renewal-interval-in-seconds: 5 #服务刷新时间配置，每隔这个时间会主动心跳一次
prefer-ip-address: true
instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance_id:${server.port}}
# -----------------------------------------------------------
#actuator/info
info:
app:
name: ${liquidnet.info.name}
company:
name: zhengzai.tv
build:
groupId: '@project.groupId@'
artifactId: '@project.artifactId@'
version: '@project.version@'
# -----------------------------------------------------------
spring:
application:
name: ${liquidnet.info.name}
profiles:
include: common-service #这里加载management相关公共配置
redis:
database: ${liquidnet.redis.kylin.database}
dbs: ${liquidnet.redis.kylin.dbs}
port: ${liquidnet.redis.kylin.port}
host: ${liquidnet.redis.kylin.host}
password: ${liquidnet.redis.kylin.password}
lettuce:
pool:
max-active: 20
max-wait: -1
max-idle: 8
min-idle: 0
data:
mongodb:
uri: mongodb://${liquidnet.mongodb.user}:${liquidnet.mongodb.pwd}@${liquidnet.mongodb.host}/?authSource=admin&maxPoolSize=200&waitQueueMultiple=100
sslEnabled: ${liquidnet.mongodb.sslEnabled}
database: ${liquidnet.mongodb.database}
datasource:
name: ${liquidnet.mysql.database-name}
url: jdbc:mysql://${liquidnet.mysql.urlHostAndPort}/${liquidnet.mysql.database-name}?serverTimezone=UTC&characterEncoding=utf-8&useSSL=false
username: ${liquidnet.mysql.username}
password: ${liquidnet.mysql.password}
# type: org.apache.tomcat.jdbc.pool.DataSource
driver-class-name: com.mysql.cj.jdbc.Driver
hikari:
maximum-pool-size: 45
minimum-idle: 8
connection-test-query: SELECT 1
# -----------------------------------------------------------
# -----------------------------------------------------------
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/pom.xml 0 → 100644
View file @ 17bc2a18
<?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>liquidnet-service-consumer-all</artifactId>
<groupId>com.liquidnet</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>liquidnet-service-consumer-order</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
</dependency>
<dependency>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-common-cache-redis</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-service-kylin-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-service-candy-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-service-goblin-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-common-sms</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-common-third-zxlnft</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-common-third-antchain</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-service-galaxy-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-service-goblin-common</artifactId>
<version>1.0-SNAPSHOT</version>
<exclusions>
<exclusion>
<groupId>com.liquidnet</groupId>
<artifactId>liquidnet-common-web</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
</build>
</project>
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/ServiceConsumerOrderApplication.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
@Slf4j
@SpringBootApplication(scanBasePackages = {"com.liquidnet"})
public class ServiceConsumerOrderApplication implements CommandLineRunner {
@Autowired
private Environment environment;
public static void main(String[] args) {
SpringApplication.run(ServiceConsumerOrderApplication.class, args);
}
@Override
public void run(String... strings) throws Exception {
try {
log.info("\n----------------------------------------------------------\n\t" +
"Application '{}' is running! Access URLs:\n\t" +
"Local: \t\thttp://127.0.0.1:{}\n\t" +
"External: \thttp://{}:{}{}/doc.html\n\t" +
"Profile(s): \t{}\n----------------------------------------------------------",
environment.getProperty("spring.application.name"),
environment.getProperty("server.port"),
InetAddress.getLocalHost().getHostAddress(),
environment.getProperty("server.port"),
environment.getProperty("server.servlet.context-path"),
Arrays.toString(environment.getActiveProfiles()));
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerCommonBizRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
//package com.liquidnet.service.consumer.order.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.base.constant.MQConst;
//import com.liquidnet.service.consumer.order.receiver.*;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import java.util.ArrayList;
//import java.util.List;
//
//@Configuration
//public class ConsumerCommonBizRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// StringRedisTemplate stringRedisTemplate;
// @Autowired
// ConsumerGoblinBizArtworkUplRdsReceiver consumerGoblinBizArtworkUplRdsReceiver;
// @Autowired
// ConsumerGoblinBizArtworkClqRdsReceiver consumerGoblinBizArtworkClqRdsReceiver;
//// @Autowired
//// ConsumerGoblinBizArtworkGenRdsReceiver consumerGoblinBizArtworkGenRdsReceiver;
// @Autowired
// ConsumerGoblinBizIntegralReceiver consumerGoblinBizIntegralReceiver;
// @Autowired
// ConsumerGoblinMdbNftOrderReceiver consumerGoblinMdbNftOrderReceiver;
// @Autowired
// ConsumerGoblinMdbNftArtworkReceiver consumerGoblinMdbNftArtworkReceiver;
//
// @Bean// 藏品上传声明
// public List<Subscription> subscriptionBizArtworkUpl(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.BIZ_ARTWORK_UPL;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 1; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinBizArtworkUplRdsReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//
// @Bean// 藏品声明查询
// public List<Subscription> subscriptionBizArtworkClq(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.BIZ_ARTWORK_CLQ;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 1; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinBizArtworkClqRdsReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//
//// @Bean// 藏品生成
//// public List<Subscription> subscriptionBizArtworkGen(RedisConnectionFactory factory) {
//// List<Subscription> subscriptionList = new ArrayList<>();
//// MQConst.GoblinQueue stream = MQConst.GoblinQueue.BIZ_ARTWORK_GEN;
//// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
//// for (int i = 0; i < 20; i++) {
//// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
//// subscriptionList.add(listenerContainer.receiveAutoAck(
//// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
//// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinBizArtworkGenRdsReceiver
//// ));
//// listenerContainer.start();
//// }
//// return subscriptionList;
//// }
//
// @Bean// 增减积分
// public List<Subscription> subscriptionBizIntegral(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.BIZ_INTEGRAL;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 10; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinBizIntegralReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//
// @Bean// NFT订单 mongo操作
// public List<Subscription> subscriptionBizNftOrder(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.BIZ_NFT_MONGO;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 10; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinMdbNftOrderReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//
// @Bean// NFT数字藏品 mongo操作
// public List<Subscription> subscriptionBizNftArtwork(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.BIZ_ARTWORK_GEN;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 5; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinMdbNftArtworkReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerCommonSqlRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
//package com.liquidnet.service.consumer.order.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.base.constant.MQConst;
//import com.liquidnet.service.consumer.order.receiver.*;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import java.util.ArrayList;
//import java.util.List;
//
//@Configuration
//public class ConsumerCommonSqlRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// StringRedisTemplate stringRedisTemplate;
// @Autowired
// ConsumerGoblinSqlStoreRdsReceiver consumerGoblinSqlStoreRdsReceiver;
// @Autowired
// ConsumerGoblinSqlGoodsRdsReceiver consumerGoblinSqlGoodsRdsReceiver;
// @Autowired
// ConsumerGoblinSqlCouponRdsReceiver consumerGoblinSqlCouponRdsReceiver;
// @Autowired
// ConsumerGoblinSqlArtworkGenRdsReceiver consumerGoblinSqlArtworkGenRdsReceiver;
// @Autowired
// ConsumerGoblinNftOrderRdsReceiver consumerGoblinNftOrderRdsReceiver;
//
// @Bean// 店铺相关
// public List<Subscription> subscriptionSqlStore(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.SQL_STORE;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 1; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinSqlStoreRdsReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//
// @Bean// 商品相关
// public List<Subscription> subscriptionSqlGoods(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.SQL_GOODS;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 1; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinSqlGoodsRdsReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//
// @Bean// 店铺优惠券相关
// public List<Subscription> subscriptionSqlStoreCoupon(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.SQL_COUPON;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 5; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinSqlCouponRdsReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//
// @Bean// 藏品生成
// public List<Subscription> subscriptionSqlArtworkGen(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.SQL_ARTWORK_GEN;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 5; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinSqlArtworkGenRdsReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//
// @Bean// NFT订单
// public List<Subscription> subscriptionSqlNftOrder(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.GoblinQueue stream = MQConst.GoblinQueue.GOBLIN_NFT_ORDER;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 15; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerGoblinNftOrderRdsReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinOptTransferOverTimeRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinTransferOverTimeRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_TRANSFER_OVERTIME;
@Configuration
public class ConsumerKylinOptTransferOverTimeRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinTransferOverTimeRdsReceiver consumerKylinTransferOverTimeRdsReceiver;
/**
* 验票更新
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveTransferOverTimeResult(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_TRANSFER_OVERTIME.getGroup(), getConsumerName(SQL_TRANSFER_OVERTIME.name() + t)),
StreamOffset.create(SQL_TRANSFER_OVERTIME.getKey(), ReadOffset.lastConsumed()), consumerKylinTransferOverTimeRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 验票更新 */
@Bean
public Subscription subscriptionReceiveTransferOverTime0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransferOverTimeResult(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionReceiveTransferOverTime1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransferOverTimeResult(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionReceiveTransferOverTime2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransferOverTimeResult(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionReceiveTransferOverTime3(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransferOverTimeResult(listenerContainer, 3);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionReceiveTransferOverTime4(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransferOverTimeResult(listenerContainer, 4);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinOrderRefundExpressRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinOrderRefundExpressRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_ORDER_REFUND_EXPRESS;
@Configuration
public class ConsumerKylinOrderRefundExpressRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinOrderRefundExpressRdsReceiver consumerKylinOrderRefundExpressRdsReceiver;
/**
* 用户退款发快递
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlOrderRefundExpress(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_ORDER_REFUND_EXPRESS.getGroup(), getConsumerName(SQL_ORDER_REFUND_EXPRESS.name() + t)),
StreamOffset.create(SQL_ORDER_REFUND_EXPRESS.getKey(), ReadOffset.lastConsumed()), consumerKylinOrderRefundExpressRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
@Bean
public Subscription subscriptionOrderRefundExpress0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderRefundExpress(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionOrderRefundExpress1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderRefundExpress(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionOrderRefundExpress2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderRefundExpress(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlOptOrderCloseRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinSqlOptOrderCloseRedisReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_ORDER_CLOSE;
@Configuration
public class ConsumerKylinSqlOptOrderCloseRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinSqlOptOrderCloseRedisReceiver consumerKylinSqlOptOrderCloseRedisReceiver;
/**
* 订单关闭
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlOptOrderClose(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_ORDER_CLOSE.getGroup(), getConsumerName(SQL_ORDER_CLOSE.name() + t)),
StreamOffset.create(SQL_ORDER_CLOSE.getKey(), ReadOffset.lastConsumed()), consumerKylinSqlOptOrderCloseRedisReceiver
);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 订单关闭 */
@Bean
public Subscription subscriptionSqlOptOrderClose0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOptOrderClose1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOptOrderClose2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOptOrderClose3(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 3);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOptOrderClose4(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 4);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOptOrderClose5(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 5);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOptOrderClose6(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 6);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOptOrderClose7(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 7);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOptOrderClose8(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 8);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOptOrderClose9(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOptOrderClose(listenerContainer, 9);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlOrderAgainRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinSqlOrderAgainRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_ORDER_AGAIN;
@Configuration
public class ConsumerKylinSqlOrderAgainRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinSqlOrderAgainRdsReceiver consumerKylinSqlOrderAgainRdsReceiver;
/**
* 订单再次支付
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlOrderAgain(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_ORDER_AGAIN.getGroup(), getConsumerName(SQL_ORDER_AGAIN.name() + t)),
StreamOffset.create(SQL_ORDER_AGAIN.getKey(), ReadOffset.lastConsumed()), consumerKylinSqlOrderAgainRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 订单再次支付 */
@Bean
public Subscription subscriptionSqlOrderAgain0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderAgain(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlOrderCreateRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinSqlOrderCreateRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_ORDER_CREATE;
@Configuration
public class ConsumerKylinSqlOrderCreateRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinSqlOrderCreateRdsReceiver consumerKylinSqlOrderCreateRdsReceiver;
/**
* 创建订单
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlOrderCreate(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_ORDER_CREATE.getGroup(), getConsumerName(SQL_ORDER_CREATE.name() + t)),
StreamOffset.create(SQL_ORDER_CREATE.getKey(), ReadOffset.lastConsumed()), consumerKylinSqlOrderCreateRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 创建订单 */
@Bean
public Subscription subscriptionSqlOrderCreate0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderCreate1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderCreate2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderCreate3(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 3);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderCreate4(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 4);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderCreate5(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 5);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderCreate6(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 6);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderCreate7(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 7);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderCreate8(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 8);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderCreate9(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderCreate(listenerContainer, 9);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlOrderOvertimeRefundRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinSqlOrderOvertimeRefundRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_ORDER_OVERTIME_REFUND;
@Configuration
public class ConsumerKylinSqlOrderOvertimeRefundRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinSqlOrderOvertimeRefundRdsReceiver consumerKylinSqlOrderOvertimeRefundRdsReceiver;
/**
* 超时支付申请退款
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlOrderOvertimeRefund(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_ORDER_OVERTIME_REFUND.getGroup(), getConsumerName(SQL_ORDER_OVERTIME_REFUND.name() + t)),
StreamOffset.create(SQL_ORDER_OVERTIME_REFUND.getKey(), ReadOffset.lastConsumed()), consumerKylinSqlOrderOvertimeRefundRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 超时支付申请退款 */
@Bean
public Subscription subscriptionSqlOrderOvertimeRefund0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderOvertimeRefund(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlOrderPayRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinSqlOrderPayRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_ORDER_PAY;
@Configuration
public class ConsumerKylinSqlOrderPayRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinSqlOrderPayRdsReceiver consumerKylinSqlOrderPayRdsReceiver;
/**
* 订单支付
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlOrderPay(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_ORDER_PAY.getGroup(), getConsumerName(SQL_ORDER_PAY.name() + t)),
StreamOffset.create(SQL_ORDER_PAY.getKey(), ReadOffset.lastConsumed()), consumerKylinSqlOrderPayRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 订单支付 */
@Bean
public Subscription subscriptionSqlOrderPay0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderPay(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderPay1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderPay(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
//
// @Bean
// public Subscription subscriptionSqlOrderPay2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderPay(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlOrderPay3(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderPay(listenerContainer, 3);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlOrderPay4(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderPay(listenerContainer, 4);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlOrderPay5(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderPay(listenerContainer, 5);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlOrderPay6(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderPay(listenerContainer, 6);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlOrderPay7(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderPay(listenerContainer, 7);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlOrderPay8(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderPay(listenerContainer, 8);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlOrderPay9(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderPay(listenerContainer, 9);
// listenerContainer.start();
// return subscription;
// }
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlOrderRefundRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinSqlOrderRefundRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_ORDER_REFUND;
@Configuration
public class ConsumerKylinSqlOrderRefundRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinSqlOrderRefundRdsReceiver consumerKylinSqlOrderRefundRdsReceiver;
/**
* 订单申请退款
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlOrderRefund(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_ORDER_REFUND.getGroup(), getConsumerName(SQL_ORDER_REFUND.name() + t)),
StreamOffset.create(SQL_ORDER_REFUND.getKey(), ReadOffset.lastConsumed()), consumerKylinSqlOrderRefundRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 订单申请退款 */
@Bean
public Subscription subscriptionSqlOrderRefund0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderRefund(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderRefund1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderRefund(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderRefund2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderRefund(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderRefund3(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderRefund(listenerContainer, 3);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderRefund4(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderRefund(listenerContainer, 4);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlOrderWithdrawRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinSqlOrderWithdrawRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_ORDER_WITHDRAW;
@Configuration
public class ConsumerKylinSqlOrderWithdrawRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinSqlOrderWithdrawRdsReceiver consumerKylinSqlOrderWithdrawRdsReceiver;
/**
* 订单申请撤回
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlOrderWithdraw(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_ORDER_WITHDRAW.getGroup(), getConsumerName(SQL_ORDER_WITHDRAW.name() + t)),
StreamOffset.create(SQL_ORDER_WITHDRAW.getKey(), ReadOffset.lastConsumed()), consumerKylinSqlOrderWithdrawRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 订单申请撤回 */
@Bean
public Subscription subscriptionSqlOrderWithdraw0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderWithdraw(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderWithdraw1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderWithdraw(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlOrderWithdraw2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlOrderWithdraw(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
// @Bean
// public Subscription subscriptionSqlOrderWithdraw3(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderWithdraw(listenerContainer, 3);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlOrderWithdraw4(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlOrderWithdraw(listenerContainer, 4);
// listenerContainer.start();
// return subscription;
// }
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlPerformanceLackRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
//package com.liquidnet.service.consumer.order.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.base.constant.MQConst;
//import com.liquidnet.service.consumer.order.receiver.ConsumerKylinSqlPerformanceLackRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import java.util.ArrayList;
//import java.util.List;
//
//import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_PERFORMANCE_LACK;
//
//@Configuration
//public class ConsumerKylinSqlPerformanceLackRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// StringRedisTemplate stringRedisTemplate;
// @Autowired
// ConsumerKylinSqlPerformanceLackRdsReceiver consumerKylinSqlPerformanceLackRdsReceiver;
//
//// /**
//// * 缺票登记
//// *
//// * @param listenerContainer
//// * @param t
//// * @return
//// */
//// private Subscription receiveSqlPerformanceLack(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
//// return listenerContainer.receiveAutoAck(Consumer.from(SQL_PERFORMANCE_LACK.getGroup(), getConsumerName(SQL_PERFORMANCE_LACK.name() + t)),
//// StreamOffset.create(SQL_PERFORMANCE_LACK.getKey(), ReadOffset.lastConsumed()), consumerKylinSqlPerformanceLackRdsReceiver);
//// }
////
//// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
////
//// /* -------------------------------------------------------- ｜ 缺票登记 */
////
//// @Bean
//// public Subscription subscriptionSqlPerformanceLack0(RedisConnectionFactory factory) {
//// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
//// var subscription = receiveSqlPerformanceLack(listenerContainer, 0);
//// listenerContainer.start();
//// return subscription;
//// }
//
// /* -------------------------------------------------------- ｜ */
//
//
// @Bean// 缺票登记
// public List<Subscription> subscriptionSqlURegister(RedisConnectionFactory factory) {
// List<Subscription> subscriptionList = new ArrayList<>();
// MQConst.KylinQueue stream = MQConst.KylinQueue.SQL_PERFORMANCE_LACK;
// this.initStream(stringRedisTemplate, stream.getKey(), stream.getGroup());
// for (int i = 0; i < 1; i++) {
// StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = this.buildStreamMessageListenerContainer(factory);
// subscriptionList.add(listenerContainer.receiveAutoAck(
// Consumer.from(stream.getGroup(), getConsumerName(stream.name() + i)),
// StreamOffset.create(stream.getKey(), ReadOffset.lastConsumed()), consumerKylinSqlPerformanceLackRdsReceiver
// ));
// listenerContainer.start();
// }
// return subscriptionList;
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlTransferRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinTransferRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_TRANSFER;
@Configuration
public class ConsumerKylinSqlTransferRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinTransferRdsReceiver consumerKylinTransferRdsReceiver;
/**
* 验票更新
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveTransfer(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_TRANSFER.getGroup(), getConsumerName(SQL_TRANSFER.name() + t)),
StreamOffset.create(SQL_TRANSFER.getKey(), ReadOffset.lastConsumed()), consumerKylinTransferRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 验票更新 */
@Bean
public Subscription subscriptionReceiveTransfer0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransfer(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionReceiveTransfer1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransfer(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionReceiveTransfer2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransfer(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
// @Bean
// public Subscription subscriptionReceiveTransfer3(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveTransfer(listenerContainer, 3);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionReceiveTransfer4(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveTransfer(listenerContainer, 4);
// listenerContainer.start();
// return subscription;
// }
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/config/ConsumerKylinSqlTransferResultRedisStreamConfig.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.order.receiver.ConsumerKylinTransferResultRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.KylinQueue.SQL_TRANSFER_RESULT;
@Configuration
public class ConsumerKylinSqlTransferResultRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerKylinTransferResultRdsReceiver consumerKylinTransferResultRdsReceiver;
/**
* 验票更新
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveTransferResult(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SQL_TRANSFER_RESULT.getGroup(), getConsumerName(SQL_TRANSFER_RESULT.name() + t)),
StreamOffset.create(SQL_TRANSFER_RESULT.getKey(), ReadOffset.lastConsumed()), consumerKylinTransferResultRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 验票更新 */
@Bean
public Subscription subscriptionReceiveTransferResult0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransferResult(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionReceiveTransferResult1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransferResult(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionReceiveTransferResult2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveTransferResult(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
// @Bean
// public Subscription subscriptionReceiveTransferResult3(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveTransferResult(listenerContainer, 3);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionReceiveTransferResult4(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveTransferResult(listenerContainer, 4);
// listenerContainer.start();
// return subscription;
// }
/* -------------------------------------------------------- ｜ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/dto/PhoneDto.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.dto;
import lombok.Data;
import lombok.EqualsAndHashCode;
@Data
@EqualsAndHashCode
public class PhoneDto {
private String uid;
private String mobile;
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractBizRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import com.liquidnet.service.consumer.order.service.IBaseDao;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.stream.StreamListener;
/**
* 公共的业务队列消息监听器，具体业务消费逻辑通过`consumerMessageHandler`实现
*
* @author zhanggb
* Created by IntelliJ IDEA at 2022/3/31
*/
@Slf4j
public abstract class AbstractBizRedisReceiver implements StreamListener<String, MapRecord<String, String, String>> {
@Autowired
public IBaseDao baseDao;
@Autowired
public StringRedisTemplate stringRedisTemplate;
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue().get(MQConst.QUEUE_MESSAGE_KEY));
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
protected abstract boolean consumerMessageHandler(String msg);
protected abstract String getRedisStreamKey();
protected abstract String getRedisStreamGroup();
}
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractCouponOrderBackRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;//package com.liquidnet.service.consumer.order.receiver;
//
//import com.liquidnet.common.cache.redis.util.RedisUtil;
//import com.liquidnet.commons.lang.util.CollectionUtil;
//import com.liquidnet.commons.lang.util.JsonUtils;
//import com.liquidnet.service.base.OrderCloseMapping;
//import com.liquidnet.service.candy.constant.CandyRedisConst;
//import com.liquidnet.service.candy.dto.CandyUserCouponBasicDto;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.StreamRecords;
//import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.data.redis.stream.StreamListener;
//
//import java.util.ArrayList;
//import java.util.HashMap;
//import java.util.List;
//
//@Slf4j
//public abstract class AbstractCouponOrderBackRedisReceiver implements StreamListener<String, MapRecord<String, String, String>> {
// @Autowired
// StringRedisTemplate stringRedisTemplate;
// @Autowired
// private RedisUtil redisUtil;
//
// @Override
// public void onMessage(MapRecord<String, String, String> message) {
// log.debug("CONSUMER SQL[streamKey:{},messageId:{},stream:{},body:{}]",
// this.getRedisStreamKey(), message.getId(), message.getStream(), message.getValue());
//
// boolean result = this.consumerSqlOperationCouponOrderBackHandler(message.getValue().get("message"));
// log.info("CONSUMER SQL RESULT:{} ==> MESSAGE_ID:{}", result, message.getId());
//
// try {
// stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
// stringRedisTemplate.opsForStream().delete(this.getRedisStreamKey(), message.getId());
// } catch (Exception e) {
// log.error("#CONSUMER SQL RESULT:{} ==> DEL_REDIS_QUEUE_MSG_EXCEPTION[MESSAGE_ID:{},MSG:{}]", result, message.getId(), JsonUtils.toJson(message), e);
// } finally {
// try {
// stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
// stringRedisTemplate.opsForStream().delete(this.getRedisStreamKey(), message.getId());
// } catch (Exception ignored) {
// }
// }
// }
//
// private boolean consumerSqlOperationCouponOrderBackHandler(String msg) {
// boolean aBoolean = false;
// try {
// OrderCloseMapping.orderCloseMessage mqMessage = JsonUtils.fromJson(msg, OrderCloseMapping.orderCloseMessage.class);
//
// //这里是 uCouponId和uid 懒。所以没新写方法
// for (int x = 0; x < mqMessage.getOrderTicketIds().size(); x++) {
// String t = mqMessage.getOrderTicketIds().get(x);
// String uCouponId = t.split(",")[0];
// String uid = t.split(",")[1];
// ArrayList<String> uCouponIdList = CollectionUtil.arrayListString();
// uCouponIdList.add(uCouponId);
// List<CandyUserCouponBasicDto> dtoList = backCoupon(getCouponByUid(uid), uCouponIdList);
// setCouponByUid(uid, dtoList);
// }
//
// aBoolean = true;
// } catch (Exception e) {
// log.error("CONSUMER SQL FAIL ==> {}", e.getMessage(), e);
// } finally {
// if (!aBoolean) {
// HashMap<String, String> map = CollectionUtil.mapStringString();
// map.put("message", msg);
// stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
// }
// }
// return aBoolean;
// }
//
// private List<CandyUserCouponBasicDto> getCouponByUid(String uid) {
// String redisKey = CandyRedisConst.BASIC_USER_COUPON.concat(uid);
// Object obj = redisUtil.get(redisKey);
// if (obj == null) {
// //降级
// return new ArrayList();
// } else {
// return (List<CandyUserCouponBasicDto>) obj;
// }
// }
//
// // 覆盖 CandyUserCouponBasicDto数组 根据用户id
// private void setCouponByUid(String uid, List<CandyUserCouponBasicDto> dtoList) {
// String redisKey = CandyRedisConst.BASIC_USER_COUPON.concat(uid);
// redisUtil.set(redisKey, dtoList);
// }
//
// /**
// * 回退券
// *
// * @param dtoList CouponBaseDtoList
// * @param uCouponIdList 券唯一id list
// * @return List<CandyUserCouponBasicDto>
// */
// private List<CandyUserCouponBasicDto> backCoupon(List<CandyUserCouponBasicDto> dtoList, ArrayList<String> uCouponIdList) {
// boolean isHas = false;
// for (CandyUserCouponBasicDto dtoItem : dtoList) {
// if (uCouponIdList.contains(dtoItem.getUcouponId())) {
// if (dtoItem.getState().equals(5)) {
// dtoItem.setState(1);
// isHas = true;//券存在
// } else {
// }
// }
// }
// if (!isHas) {
// return null;//券不存在
// }
// return dtoList;
// }
//
// protected abstract String getRedisStreamKey();
//
// protected abstract String getRedisStreamGroup();
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractHttpRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.fasterxml.jackson.core.type.TypeReference;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.HttpUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.ResponseDto;
import com.liquidnet.service.base.SqlMapping;
import com.liquidnet.service.base.constant.MQConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.stream.StreamListener;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import java.util.*;
@Slf4j
public abstract class AbstractHttpRedisReceiver implements StreamListener<String, MapRecord<String, String, String>> {
@Autowired
StringRedisTemplate stringRedisTemplate;
@Value("${liquidnet.service.order.url}")
private String orderUrl;
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue());
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerMessageHandler(Map<String, String> message) {
try {
String codestr = message.get("codes");
String userIds = message.get("userIds");
String phonestr = message.get("phones");
String adminUid = message.get("adminUid");
List<String> codeList = Arrays.asList(codestr.split(","));
List<String> userIdList = Arrays.asList(userIds.split(","));
List<String> phoneList = Arrays.asList(phonestr.split(","));
LinkedList<Object[]> addLink = CollectionUtil.linkedListObjectArr();
for (int i = 0; i < userIdList.size(); i++) {
MultiValueMap<String, String> params = new LinkedMultiValueMap();
params.add("code", codeList.get(i));
params.add("userId", userIdList.get(i));
MultiValueMap<String, String> headers = CollectionUtil.linkedMultiValueMapStringString();
headers.add("Accept", "application/json;charset=UTF-8");
String post = HttpUtil.post(orderUrl + "/order/goblin/nft/airdrop", params, headers);
ResponseDto<Boolean> rsp = JsonUtils.fromJson(post, new TypeReference<ResponseDto<Boolean>>() {
});
if (rsp.isSuccess()) {
addLink.add(new Object[]{adminUid, codeList.get(i)});
} else {
log.error("airdrop send fail:[{}]" + phoneList.get(i));
}
}
if (addLink != null && !addLink.isEmpty()) {
LinkedList<String> sqls = CollectionUtil.linkedListString();
sqls.add(SqlMapping.get("goblin_activity.code.admin"));
String sqlData = SqlMapping.gets(sqls, addLink);
sendMsgByRedis(MQConst.GoblinQueue.GOBLIN_CODE_OPERA.getKey(), sqlData);
}
} catch (Exception e) {
log.error("airdrop send fail:[{}]");
}
return true;
}
public void sendMsgByRedis(String streamKey, String jsonMsg) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put(MQConst.QUEUE_MESSAGE_KEY, jsonMsg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(streamKey));
}
protected abstract String getRedisStreamKey();
protected abstract String getRedisStreamGroup();
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractMdbRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.constant.MQConst;
import com.liquidnet.service.goblin.dto.GoblinQueueBizMongoDto;
import com.mongodb.BasicDBObject;
import com.mongodb.client.result.UpdateResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.stream.StreamListener;
import java.util.HashMap;
/**
* 公共的业务Mongo数据处理队列消息监听器，具体业务消费逻辑通过`consumerMessageHandler`实现
*
* @author zhanggb
* Created by IntelliJ IDEA at 2022/4/22
*/
@Slf4j
public abstract class AbstractMdbRedisReceiver implements StreamListener<String, MapRecord<String, String, String>> {
@Autowired
public StringRedisTemplate stringRedisTemplate;
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private RedisUtil redisUtil;
private static final BasicDBObject BASIC_DB_OBJECT = new BasicDBObject();
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue().get(MQConst.QUEUE_MESSAGE_KEY));
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerMessageHandler(String msg) {
boolean aBoolean = true;
try {
GoblinQueueBizMongoDto queueBizMongoDto = JsonUtils.fromJson(msg, GoblinQueueBizMongoDto.class);
if (null != queueBizMongoDto) {
String collectName = queueBizMongoDto.getCollect(), columnName = queueBizMongoDto.getColumn();
String prefix = queueBizMongoDto.getPrefix(), bizId = queueBizMongoDto.getBizId();
Object o;
switch (queueBizMongoDto.getOpType()) {
case 1:// insert
o = redisUtil.get(prefix.concat(bizId));
if (null != o) {
mongoTemplate.insert(o, collectName);
}
break;
case 2:// update
o = redisUtil.get(prefix.concat(bizId));
if (null != o) {
BasicDBObject basicDBObject = (BasicDBObject) AbstractMdbRedisReceiver.BASIC_DB_OBJECT.clone();
UpdateResult updateResult = mongoTemplate.getCollection(collectName).updateOne(
Query.query(Criteria.where(columnName).is(bizId)).getQueryObject(),
basicDBObject.append("$set", mongoTemplate.getConverter().convertToMongoType(o))
);
}
break;
default:
log.error("CONSUMER MSG ERR_HANDLE[未知的操作类型,{}]", msg);
break;
}
}
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
aBoolean = false;
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put(MQConst.QUEUE_MESSAGE_KEY, msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
protected abstract String getRedisStreamKey();
protected abstract String getRedisStreamGroup();
}
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractOptOrderTransferOverTimeRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.OrderCloseMapping;
import com.liquidnet.service.consumer.order.utils.KylinUtils;
import com.liquidnet.service.kylin.constant.KylinRedisConst;
import com.liquidnet.service.kylin.dto.vo.mongo.KylinOrderTicketVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.stream.StreamListener;
import java.util.HashMap;
@Slf4j
public abstract class AbstractOptOrderTransferOverTimeRedisReceiver implements StreamListener<String, MapRecord<String, String, String>> {
@Autowired
StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisUtil redisUtil;
@Autowired
private KylinUtils kylinUtils;
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue().get("message"));
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerMessageHandler(String msg) {
boolean aBoolean = false;
try {
OrderCloseMapping.orderCloseMessage mqMessage = JsonUtils.fromJson(msg, OrderCloseMapping.orderCloseMessage.class);
if (mqMessage == null) {
} else {
for (int x = 0; x < mqMessage.getOrderTicketIds().size(); x++) {
String orderTicketId = mqMessage.getOrderTicketIds().get(x);
KylinOrderTicketVo vo = kylinUtils.getOrderTicketVo(orderTicketId);
String uid = vo.getTransferUid();
vo.setTransferUid("");
vo.setTransferStatus(0);
redisUtil.del(KylinRedisConst.ORDER_TRANSFER.concat(uid));
redisUtil.set("kylin:order:id:" + orderTicketId, vo);
kylinUtils.resetOrderListVo(vo.getUserId(), 2, orderTicketId, vo);
}
}
aBoolean = true;
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put("message", msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
protected abstract String getRedisStreamKey();
protected abstract String getRedisStreamGroup();
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractOrderCloseReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.core.type.TypeReference;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.HttpUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.SqlMapping;
import com.liquidnet.service.base.constant.MQConst;
import com.liquidnet.service.consumer.order.utils.GoblinNftUtils;
import com.liquidnet.service.goblin.constant.GoblinRedisConst;
import com.liquidnet.service.goblin.constant.GoblinStatusConst;
import com.liquidnet.service.goblin.dto.vo.GoblinNftOrderVo;
import com.liquidnet.service.goblin.dto.vo.GoblinOrderSkuVo;
import com.liquidnet.service.goblin.dto.vo.GoblinStoreOrderVo;
import com.liquidnet.service.goblin.dto.vo.GoblinUserCouponVo;
import com.liquidnet.service.goblin.param.BackCouponParam;
import com.mongodb.BasicDBObject;
import com.mongodb.client.result.UpdateResult;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.convert.MongoConverter;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.stream.StreamListener;
import org.springframework.util.MultiValueMap;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.*;
@Slf4j
public abstract class AbstractOrderCloseReceiver implements StreamListener<String, MapRecord<String, String, String>> {
@Autowired
StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisUtil redisUtil;
@Autowired
private GoblinNftUtils goblinNftUtils;
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private MongoConverter mongoConverter;
@Value("${liquidnet.service.candy.url}")
private String candyUrl;
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue());
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerMessageHandler(Map<String, String> messageMap) {
try {
String orderCode = messageMap.get("id"), type = messageMap.get("type"), time = messageMap.get("time");
LocalDateTime now = LocalDateTime.now(), closeTime = now.minusMinutes(5);
LocalDateTime createdAt = StringUtils.isEmpty(time) ? closeTime : LocalDateTime.parse(time);
long durationToMillis = Duration.between(createdAt, closeTime).toMillis();
if (durationToMillis >= 0) {
switch (type) {
case "GOBLIN":
return checkOrderTime(orderCode, type);
case "NFT":
return checkNftOrderTime(orderCode);
default:
return false;
}
} else {
try {
Thread.sleep(Math.abs(durationToMillis));
} catch (InterruptedException ignored) {
}
return consumerMessageHandler(messageMap);
}
} catch (Exception e) {
String redisStreamKey = this.getRedisStreamKey();
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", redisStreamKey, messageMap, e);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(messageMap).withStreamKey(redisStreamKey));
return false;
}
}
protected abstract String getRedisStreamKey();
protected abstract String getRedisStreamGroup();
public boolean checkOrderTime(String valueData, String type) {
LocalDateTime now = LocalDateTime.now();
try {
if (type.equals("GOBLIN")) {
String[] orderIds = getMasterCode(valueData);
for (String orderId : orderIds) {
GoblinStoreOrderVo orderVo = getGoblinOrder(orderId);
if (orderVo.getStatus().equals(GoblinStatusConst.Status.ORDER_STATUS_0.getValue())) {//订单回滚
LinkedList<String> sqls = CollectionUtil.linkedListString();
LinkedList<Object[]> sqlDataOrder = CollectionUtil.linkedListObjectArr();
LinkedList<Object[]> sqlDataSku = CollectionUtil.linkedListObjectArr();
sqls.add(SqlMapping.get("goblin_order.close.order"));
sqls.add(SqlMapping.get("goblin_order.close.sku"));
for (String orderSkuId : orderVo.getOrderSkuVoIds()) {
GoblinOrderSkuVo skuVo = getGoblinOrderSkuVo(orderSkuId);
//订单详情
skuVo.setStatus(GoblinStatusConst.Status.ORDER_STATUS_5.getValue());
updateGoblinOrderSkuVo(skuVo.getOrderSkuId(), skuVo);
setGoblinOrderSku(skuVo.getOrderSkuId(), skuVo);
//库存&限购&&待支付订单
String pre = GoblinStatusConst.MarketPreStatus.getPre(skuVo.getSkuId());
incrSkuStock(pre, skuVo.getSkuId(), skuVo.getNum());
decrSkuCountByUid(orderVo.getUserId(), skuVo.getSkuId(), skuVo.getNum());
//mysql
sqlDataSku.add(new Object[]{
skuVo.getStatus(), now, skuVo.getOrderSkuId(), now, now
});
}
//订单
orderVo.setStatus(GoblinStatusConst.Status.ORDER_STATUS_5.getValue());
updateGoblinStoreOrderVo(orderVo.getOrderId(), orderVo);
setGoblinOrder(orderVo.getOrderId(), orderVo);
//店铺券退券
if (!(orderVo.getStoreCouponId().equals("") || orderVo.getStoreCouponId() == null)) {
BackCouponParam backCouponParam = BackCouponParam.getNew();
backCouponParam.setuCouponIds(orderVo.getStoreCouponId());
backCouponParam.setUid(orderVo.getUserId());
backStoreCoupon(backCouponParam);
}
//平台券
if (!(orderVo.getUcouponId().equals("") || orderVo.getUcouponId() == null)) {
backCoupon(orderVo.getUcouponId(), orderVo.getUserId());
}
//mysql
sqlDataOrder.add(new Object[]{
orderVo.getStatus(), now, now, "超时关闭", orderVo.getOrderId(), now, now
});
//执行sql
sendMsgByRedis(MQConst.GoblinQueue.GOBLIN_ORDER_CLOSE.getKey(),
SqlMapping.gets(sqls, sqlDataOrder, sqlDataSku));
}
}
}
} catch (Exception e) {
log.error("库存回滚异常valueData={}", valueData, e);
}
return true;
}
public boolean checkNftOrderTime(String orderId) {
LocalDateTime now = LocalDateTime.now();
try {
GoblinNftOrderVo nftOrder = goblinNftUtils.getNftOrder(orderId);
if (nftOrder.getStatus().equals(GoblinStatusConst.NftStatus.ORDER_STATUS_1.getValue())) {
// 库存购买数量回滚
goblinNftUtils.decrSkuCountByUid(nftOrder.getUserId(), nftOrder.getSkuId(), nftOrder.getNum());
if (StringUtils.isEmpty(nftOrder.getBoxSkuId())) {// 购买藏品
goblinNftUtils.incrSkuStock(nftOrder.getSkuId(), nftOrder.getNum());
} else {// 购买盲盒
goblinNftUtils.incrSkuStock(nftOrder.getBoxSkuId(), nftOrder.getNum());
}
// 订单状态
nftOrder.setStatus(GoblinStatusConst.NftStatus.ORDER_STATUS_3.getValue());
nftOrder.setUpdatedAt(now);
nftOrder.setCancelTime(now);
nftOrder.setCancelReason("超时支付关闭");
goblinNftUtils.setNftOrder(nftOrder);
goblinNftUtils.updateGoblinNftOrderVo(nftOrder);
LinkedList<String> sqls = CollectionUtil.linkedListString();
LinkedList<Object[]> sqlDataOrder = CollectionUtil.linkedListObjectArr();
sqls.add(SqlMapping.get("goblin_nft_order.update.close"));
sqlDataOrder.add(new Object[]{
nftOrder.getStatus(), now, now, "超时支付关闭", nftOrder.getOrderId(), now, now
});
sendMsgByRedis(MQConst.GoblinQueue.GOBLIN_ORDER_CLOSE.getKey(),
SqlMapping.gets(sqls, sqlDataOrder));
}
return true;
} catch (Exception e) {
log.error("checkNftOrderTime异常 [valueData:{}, e:{}]", orderId, e);
return false;
}
}
private UpdateResult updateGoblinStoreOrderVo(String orderId, GoblinStoreOrderVo data) {
BasicDBObject object = cloneBasicDBObject().append("$set", mongoConverter.convertToMongoType(data));
return mongoTemplate.getCollection(GoblinStoreOrderVo.class.getSimpleName()).updateOne(
Query.query(Criteria.where("orderId").is(orderId)).getQueryObject(),
object);
}
private UpdateResult updateGoblinOrderSkuVo(String orderSkuId, GoblinOrderSkuVo data) {
BasicDBObject object = cloneBasicDBObject().append("$set", mongoConverter.convertToMongoType(data));
return mongoTemplate.getCollection(GoblinOrderSkuVo.class.getSimpleName()).updateOne(
Query.query(Criteria.where("orderSkuId").is(orderSkuId)).getQueryObject(),
object);
}
public String[] getMasterCode(String masterCode) {
String redisKey = GoblinRedisConst.REDIS_GOBLIN_ORDER_MASTER.concat(masterCode);
Object obj = redisUtil.get(redisKey);
if (obj == null) {
return null;
} else {
return ((String) obj).split(",");
}
}
// 获取 订单相关vo
public GoblinStoreOrderVo getGoblinOrder(String orderId) {
String redisKey = GoblinRedisConst.REDIS_GOBLIN_ORDER.concat(orderId);
Object obj = redisUtil.get(redisKey);
if (obj == null) {
return null;
} else {
return (GoblinStoreOrderVo) obj;
}
}
// 获取 订单相关Skuvo
public GoblinOrderSkuVo getGoblinOrderSkuVo(String orderSkuId) {
String redisKey = GoblinRedisConst.REDIS_GOBLIN_ORDER_SKU.concat(orderSkuId);
Object obj = redisUtil.get(redisKey);
if (obj == null) {
return null;
} else {
return (GoblinOrderSkuVo) obj;
}
}
// 赋值 订单相关Skuvo
public void setGoblinOrderSku(String orderSkuId, GoblinOrderSkuVo vo) {
String redisKey = GoblinRedisConst.REDIS_GOBLIN_ORDER_SKU.concat(orderSkuId);
redisUtil.set(redisKey, vo);
}
public int incrSkuStock(String marketPre, String skuId, Integer stock) {
String rk = GoblinRedisConst.REAL_STOCK_SKU;
if (marketPre != null && !marketPre.equals("null")) {
rk = rk.concat(marketPre + ":");
}
rk = rk.concat(skuId);
return (int) redisUtil.incr(rk, stock);
}
// 减少 用户sku购买个数
public int decrSkuCountByUid(String uid, String skuId, int number) {
String redisKey = GoblinRedisConst.REDIS_GOBLIN_BUY_COUNT.concat(uid + ":skuId:" + skuId);
return (int) redisUtil.decr(redisKey, number);
}
// 赋值 订单相关vo
public void setGoblinOrder(String orderId, GoblinStoreOrderVo vo) {
String redisKey = GoblinRedisConst.REDIS_GOBLIN_ORDER.concat(orderId);
redisUtil.set(redisKey, vo);
}
public void sendMsgByRedis(String streamKey, String jsonMsg) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put("message", jsonMsg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(streamKey));
}
public Boolean backStoreCoupon(BackCouponParam params) {
try {
List<GoblinUserCouponVo> voList = getUserCouponVos(params.getUid());
for (GoblinUserCouponVo vo : voList) {
if (vo.getUcouponId().equals(params.getuCouponIds())) {
if (LocalDateTime.now().isBefore(vo.getDuedAt())) {
vo.setState(1);
vo.setUsedFor("");
setUserCouponVos(params.getUid(), voList);
changeCouponVos(vo.getUcouponId(), vo);
sendMsgByRedis(MQConst.GoblinQueue.SQL_COUPON.getKey(),
SqlMapping.get("goblin_user_coupon.updateState", vo.getState(), vo.getUsedFor(), LocalDateTime.now(), vo.getUcouponId()));
}
break;
}
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
public void backCoupon(String uCouponId, String uid) {
try {
com.liquidnet.service.candy.param.BackCouponParam param = com.liquidnet.service.candy.param.BackCouponParam.getNew();
param.setuCouponIds(uCouponId);
param.setUid(uid);
MultiValueMap<String, String> header = CollectionUtil.linkedMultiValueMapStringString();
header.add("Accept", "application/json;charset=UTF-8");
ArrayList<com.liquidnet.service.candy.param.BackCouponParam> params = new ArrayList();
params.add(param);
String jsonString = JSON.toJSONString(params);
String returnData = HttpUtil.postRaw(candyUrl + "/candy-coupon/useBack", jsonString, header);
} catch (Exception e) {
log.error("回退券ERROR:{}", e);
}
}
public List<GoblinUserCouponVo> getUserCouponVos(String uid) {
String rk = GoblinRedisConst.USER_COUPON.concat(uid);
String valStr = (String) redisUtil.get(rk);
List<GoblinUserCouponVo> vos;
if (org.springframework.util.StringUtils.isEmpty(valStr)) {
return getGoblinUserCouponVo();
} else {
vos = JsonUtils.fromJson(valStr, new TypeReference<List<GoblinUserCouponVo>>() {
});
}
return vos;
}
public Boolean changeCouponVos(String ucouponId, GoblinUserCouponVo vo) {
return mongoTemplate.getCollection(GoblinUserCouponVo.class.getSimpleName())
.updateOne(Query.query(Criteria.where("ucouponId").is(ucouponId)).getQueryObject(),
cloneBasicDBObject().append("$set", mongoConverter.convertToMongoType(vo))
).getModifiedCount() > 0;
}
public boolean setUserCouponVos(String uid, List<GoblinUserCouponVo> vos) {
return redisUtil.set(GoblinRedisConst.USER_COUPON.concat(uid), JsonUtils.toJson(vos));
}
private static final BasicDBObject basicDBObject = new BasicDBObject();
private static final ArrayList<GoblinUserCouponVo> goblinUserCouponVo = new ArrayList<>();
public static BasicDBObject cloneBasicDBObject() {
return (BasicDBObject) basicDBObject.clone();
}
public static ArrayList<GoblinUserCouponVo> getGoblinUserCouponVo() {
return (ArrayList<GoblinUserCouponVo>) goblinUserCouponVo.clone();
}
}
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractSmsRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.liquidnet.common.sms.processor.SmsProcessor;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.SmsMessage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.stream.StreamListener;
import javax.annotation.Resource;
import java.util.HashMap;
@Slf4j
public abstract class AbstractSmsRedisReceiver implements StreamListener<String, MapRecord<String, String, String>> {
@Resource
SmsProcessor smsProcessor;
@Autowired
StringRedisTemplate stringRedisTemplate;
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue().get("message"));
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER SMS EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER SMS EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerMessageHandler(String msg) {
boolean aBoolean = false;
try {
SmsMessage smsMessage = JsonUtils.fromJson(msg, SmsMessage.class);
// aBoolean = smsProcessor.send(smsMessage.getPhone(), smsMessage.getSignName(), smsMessage.getTemplateCode(), smsMessage.getTemplateParam().toString());
ObjectNode templateParam = smsMessage.getTemplateParam();
aBoolean = smsProcessor.send(smsMessage.getPhone(), smsMessage.getSignName(), smsMessage.getTemplateCode(), null == templateParam ? "" : templateParam.toString());
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put("message", msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
protected abstract String getRedisStreamKey();
protected abstract String getRedisStreamGroup();
}
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractSqlOptOrderCloseRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.OrderCloseMapping;
import com.liquidnet.service.consumer.order.utils.KylinUtils;
import com.liquidnet.service.kylin.dto.vo.mongo.KylinOrderTicketEntitiesVo;
import com.liquidnet.service.kylin.dto.vo.mongo.KylinOrderTicketVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.stream.StreamListener;
import java.util.HashMap;
@Slf4j
public abstract class AbstractSqlOptOrderCloseRedisReceiver implements StreamListener<String, MapRecord<String, String, String>> {
@Autowired
StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisUtil redisUtil;
@Autowired
private KylinUtils kylinUtils;
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerSqlOperationOrderCloseHandler(message.getValue().get("message"));
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerSqlOperationOrderCloseHandler(String msg) {
boolean aBoolean = false;
try {
OrderCloseMapping.orderCloseMessage mqMessage = JsonUtils.fromJson(msg, OrderCloseMapping.orderCloseMessage.class);
for (int x = 0; x < mqMessage.getOrderTicketIds().size(); x++) {
String t = mqMessage.getOrderTicketIds().get(x);
String orderTicketId = t.split(",")[0];
String uid = t.split(",")[1];
KylinOrderTicketVo vo = kylinUtils.getOrderTicketVo(orderTicketId);
vo.setStatus(2);
redisUtil.set("kylin:order:id:" + orderTicketId, vo);
kylinUtils.resetOrderListVo(uid, 2, orderTicketId, vo);
// redis 限购
for (int i = 0; i < vo.getEntitiesVoList().size(); i++) {
KylinOrderTicketEntitiesVo items = vo.getEntitiesVoList().get(i);
kylinUtils.changeBuyInfo(items.getUserId(), items.getEnterIdCode(), items.getPerformanceId(), items.getTicketId(), -1);
}
}
aBoolean = true;
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put("message", msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
protected abstract String getRedisStreamKey();
protected abstract String getRedisStreamGroup();
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractSqlRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.SqlMapping;
import com.liquidnet.service.consumer.order.service.IBaseDao;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.stream.StreamListener;
import java.util.HashMap;
/**
* 公共的SQL队列消息监听器，具体SQL消费逻辑统一使用`consumerMessageHandler`
*
* @author zhanggb
* Created by IntelliJ IDEA at 2022/3/31
*/
@Slf4j
public abstract class AbstractSqlRedisReceiver implements StreamListener<String, MapRecord<String, String, String>> {
@Autowired
private IBaseDao baseDao;
@Autowired
StringRedisTemplate stringRedisTemplate;
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue().get("message"));
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerMessageHandler(String msg) {
boolean aBoolean = false;
try {
SqlMapping.SqlMessage sqlMessage = JsonUtils.fromJson(msg, SqlMapping.SqlMessage.class);
if (sqlMessage == null) {
aBoolean = true;
} else {
aBoolean = baseDao.batchSqls(sqlMessage.getSqls(), sqlMessage.getArgs());
}
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put("message", msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
protected abstract String getRedisStreamKey();
protected abstract String getRedisStreamGroup();
}
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/AbstractXlsRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.read.listener.PageReadListener;
import com.alibaba.fastjson.JSON;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.service.consumer.order.dto.PhoneDto;
import com.liquidnet.service.consumer.order.service.IBaseDao;
import com.liquidnet.service.goblin.constant.GoblinRedisConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.stream.StreamListener;
import java.net.URL;
import java.time.LocalDateTime;
import java.util.LinkedList;
import java.util.Map;
@Slf4j
public abstract class AbstractXlsRedisReceiver implements StreamListener<String, MapRecord<String, String, String>> {
@Autowired
private IBaseDao baseDao;
@Autowired
StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisUtil redisUtil;
private static final String SQL_INSERT_GOODS_BUY_ROSTER_LOG = "INSERT INTO goblin_goods_buy_roster_log (sku_id,buy_roster,buy_roster_type,parsing_result,created_at)VALUES(?,?,?,?,?)";
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue());
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerMessageHandler(Map<String, String> message) {
LinkedList<Object[]> objs = CollectionUtil.linkedListObjectArr();
String xlsPath = null, skuId = null;
Integer type = null;
boolean aBoolean = false;
try {
xlsPath = message.get("message");
String finalSkuId = (skuId = message.get("skuId"));
Integer finalType = (type = Integer.parseInt(message.get("type")));
EasyExcel.read(new URL(xlsPath).openStream(), PhoneDto.class, new PageReadListener<PhoneDto>(dataList -> {
for (PhoneDto data : dataList) {
if (data.getMobile() == null) {
continue;
}
String redisKey = GoblinRedisConst.REDIS_CAN_BUY.concat(finalSkuId + ":").concat(data.getMobile());
if (finalType.equals(1)) {//添加
if (log.isDebugEnabled()) {
log.debug("添加 读取到一条数据{}", JSON.toJSONString(data));
}
redisUtil.set(redisKey, 0);
} else {
if (log.isDebugEnabled()) {
log.debug("删除 读取到一条数据{}", JSON.toJSONString(data));
}
redisUtil.del(redisKey);
}
}
})).sheet().doRead();
objs.add(new Object[]{skuId, xlsPath, type, 1, LocalDateTime.now()});
aBoolean = baseDao.batchSql(SQL_INSERT_GOODS_BUY_ROSTER_LOG, objs);
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), message, e);
try {
objs.add(new Object[]{skuId, xlsPath, type, 2, LocalDateTime.now()});
aBoolean = baseDao.batchSql(SQL_INSERT_GOODS_BUY_ROSTER_LOG, objs);
} catch (Exception ignored) {
}
}
return aBoolean;
}
protected abstract String getRedisStreamKey();
protected abstract String getRedisStreamGroup();
}
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerCandyCouponBackRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;//package com.liquidnet.service.consumer.order.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerCandyCouponBackRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.CandyQueue.COUPON_BACK.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.CandyQueue.COUPON_BACK.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerCandyCouponOrderBackRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;//package com.liquidnet.service.consumer.order.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerCandyCouponOrderBackRdsReceiver extends AbstractCouponOrderBackRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.CandyQueue.COUPON_ORDER_BACK.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.CandyQueue.COUPON_ORDER_BACK.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerCandyCouponReceiveRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;//package com.liquidnet.service.consumer.order.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerCandyCouponReceiveRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.CandyQueue.COUPON_RECEIVE.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.CandyQueue.COUPON_RECEIVE.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerCandyCouponUseRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;//package com.liquidnet.service.consumer.order.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerCandyCouponUseRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.CandyQueue.COUPON_USE.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.CandyQueue.COUPON_USE.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGalaxyJsonNftPublishAndBuyReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.ResponseDto;
import com.liquidnet.service.base.constant.MQConst;
import com.liquidnet.service.consumer.order.service.processor.ConsumerGalaxyJsonNftPublishAndBuyProcessor;
import com.liquidnet.service.galaxy.dto.param.GalaxyNftPublishAndBuyReqDto;
import com.liquidnet.service.galaxy.dto.param.GalaxyNftPublishAndBuyRespDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.stereotype.Component;
import java.util.HashMap;
@Slf4j
@Component
public class ConsumerGalaxyJsonNftPublishAndBuyReceiver extends AbstractBizRedisReceiver {
@Autowired
private ConsumerGalaxyJsonNftPublishAndBuyProcessor jsonNftPublishAndBuyProcessor;
@Override
protected boolean consumerMessageHandler(String msg) {
boolean aBoolean = false;
try {
GalaxyNftPublishAndBuyReqDto textMessage = JsonUtils.fromJson(msg, GalaxyNftPublishAndBuyReqDto.class);
if (textMessage == null) {
aBoolean = true;
} else {
//执行计数
ResponseDto<GalaxyNftPublishAndBuyRespDto> responseDto = jsonNftPublishAndBuyProcessor.nftPublishAndBuy(textMessage);
if(responseDto.isSuccess()){
aBoolean = true;
}
}
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put("message", msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
@Override
protected String getRedisStreamKey() {
return MQConst.GalaxyQueue.JSON_NFT_PUBLISH_AND_BUY.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GalaxyQueue.JSON_NFT_PUBLISH_AND_BUY.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGalaxySqlNftOrderFailLogReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author AnJiabin <anjiabin@zhengzai.tv>
* @version V1.0
* @Description: TODO
* @class: ConsumerGalaxySqlNftOrderFailLogReceiver
* @Package com.liquidnet.service.consumer.order.receiver
* @Copyright: LightNet @ Copyright (c) 2022
* @date 2022/4/7 10:56
*/
@Slf4j
@Component
public class ConsumerGalaxySqlNftOrderFailLogReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GalaxyQueue.SQL_NFT_ORDER_FAIL_LOG.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GalaxyQueue.SQL_NFT_ORDER_FAIL_LOG.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGalaxySqlNftOrderInfoReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class ConsumerGalaxySqlNftOrderInfoReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GalaxyQueue.SQL_NFT_ORDER_INFO.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GalaxyQueue.SQL_NFT_ORDER_INFO.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGalaxySqlNftTradeInfoReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class ConsumerGalaxySqlNftTradeInfoReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GalaxyQueue.SQL_NFT_TRADE_INFO.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GalaxyQueue.SQL_NFT_TRADE_INFO.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGalaxySqlSeriesInfoReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class ConsumerGalaxySqlSeriesInfoReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GalaxyQueue.SQL_SERIES_INFO.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GalaxyQueue.SQL_SERIES_INFO.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGalaxySqlUserInfoReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class ConsumerGalaxySqlUserInfoReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GalaxyQueue.SQL_USER_INFO.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GalaxyQueue.SQL_USER_INFO.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinBizArtworkClqRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.fasterxml.jackson.databind.JsonNode;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.HttpUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.SqlMapping;
import com.liquidnet.service.base.constant.MQConst;
import com.liquidnet.service.galaxy.dto.param.GalaxyArtSeriesClaimResultQueryReqDto;
import com.liquidnet.service.galaxy.dto.param.GalaxyArtSeriesClaimResultQueryRespDto;
import com.liquidnet.service.goblin.constant.GoblinRedisConst;
import com.liquidnet.service.goblin.dto.vo.GoblinGoodsSkuInfoVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.stereotype.Component;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.LinkedList;
@Slf4j
@Component
public class ConsumerGoblinBizArtworkClqRdsReceiver extends AbstractBizRedisReceiver {
@Autowired
private RedisUtil redisUtil;
@Autowired
private MongoTemplate mongoTemplate;
// @Value("${liquidnet.service.galaxy.url}")
// private String serviceGalaxyUrl;
@Value("${liquidnet.service.goblin.url}")
private String serviceGoblinUrl;
private static final String SQL_UPDATE_GOODS_SKU_NFT = "UPDATE goblin_goods_sku_nft SET upchain=?,series_id=?,series_hash=?,nft_hash=?,declare_at=?,updated_at=? WHERE sku_id=? ";
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.BIZ_ARTWORK_CLQ.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.BIZ_ARTWORK_CLQ.getGroup();
}
@Override
protected boolean consumerMessageHandler(String msg) {
boolean aBoolean = false;
try {
if (StringUtils.isEmpty(msg)) {
log.warn("CONSUMER MSG NULL_MSG ==> [{}]:{}", this.getRedisStreamKey(), msg);
aBoolean = true;
} else {
String[] msgArr = msg.split(",");
String skuId = msgArr[0], time = msgArr.length == 2 ? msgArr[1] : null;
LocalDateTime now = LocalDateTime.now(), checkTime = now.minusSeconds(10);
LocalDateTime createAt = StringUtils.isEmpty(time) ? checkTime : LocalDateTime.parse(time);
long durationToMillis = Duration.between(createAt, checkTime).toMillis();
if (durationToMillis >= 0) {
aBoolean = this.bizArtworkClqProcessing(skuId);
} else {
try {
Thread.sleep(Math.abs(durationToMillis));
} catch (InterruptedException ignored) {
}
aBoolean = this.bizArtworkClqProcessing(skuId);
}
}
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put(MQConst.QUEUE_MESSAGE_KEY, msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
private boolean bizArtworkClqProcessing(String skuId) {
GoblinGoodsSkuInfoVo mgtGoodsSkuInfoVo = this.getGoodsSkuInfoVoFromMdb(skuId);
if (null == mgtGoodsSkuInfoVo) {
log.warn("#CONSUMER MSG NULL_SKU[{}]:[skuId={}]", this.getRedisStreamKey(), skuId);
return true;
}
int skuType = mgtGoodsSkuInfoVo.getSkuType(), upchain = mgtGoodsSkuInfoVo.getUpchain();
String unbox = mgtGoodsSkuInfoVo.getUnbox();
// 非数字藏品 || 盲盒 || 非声明中 || 已有声明系列ID
if (1 != skuType || !"0".equals(unbox) || 9 != upchain || StringUtils.isNotEmpty(mgtGoodsSkuInfoVo.getSeriesId())) {
log.warn("#CONSUMER MSG VOID_SKU[{}]:[skuId={},skuType={},unbox={},upchain={},seriesId={}]",
this.getRedisStreamKey(), skuId, skuType, unbox, upchain, mgtGoodsSkuInfoVo.getSeriesId());
return true;
}
GalaxyArtSeriesClaimResultQueryRespDto resultQueryRespDto = this.queryNftSeriesClaimResult(skuId, mgtGoodsSkuInfoVo.getRouteType());
if (null == resultQueryRespDto) return false;// 声明查询失败，重新入队处理
String seriesId = resultQueryRespDto.getSeriesId();
String txHash = resultQueryRespDto.getTxHash();
String nftHash = resultQueryRespDto.getNftHash();
String chainTimestamp = resultQueryRespDto.getChainTimestamp();
LocalDateTime now = LocalDateTime.now();
mongoTemplate.getCollection(GoblinGoodsSkuInfoVo.class.getSimpleName()).updateOne(
Query.query(Criteria.where("skuId").is(skuId).and("delFlg").is("0")).getQueryObject(),
Update.update("upchain", 1).set("seriesId", seriesId).set("seriesHash", txHash).set("nftHash", nftHash).set("declareAt", chainTimestamp).getUpdateObject()
);
redisUtil.del(GoblinRedisConst.BASIC_GOODS_SKU.concat(skuId));
// Mysql持久化
HashMap<String, String> sqlUpdateMap = CollectionUtil.mapStringString();
LinkedList<String> toMqSqls = CollectionUtil.linkedListString();
toMqSqls.add(SQL_UPDATE_GOODS_SKU_NFT);
LinkedList<Object[]> updateGoodsSkuNftObjs = CollectionUtil.linkedListObjectArr();
updateGoodsSkuNftObjs.add(new Object[]{1, seriesId, txHash, nftHash, chainTimestamp, now, skuId});
sqlUpdateMap.put(MQConst.QUEUE_MESSAGE_KEY, SqlMapping.gets(toMqSqls, updateGoodsSkuNftObjs));
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(sqlUpdateMap).withStreamKey(MQConst.GoblinQueue.SQL_GOODS.getKey()));
return true;
}
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
private GalaxyArtSeriesClaimResultQueryRespDto queryNftSeriesClaimResult(String skuId, String routerType) {
GalaxyArtSeriesClaimResultQueryReqDto artSeriesClaimResultQueryReqDto = GalaxyArtSeriesClaimResultQueryReqDto.getNew();
artSeriesClaimResultQueryReqDto.setSkuId(skuId);
artSeriesClaimResultQueryReqDto.setRouterType(routerType);
// String postUrl = serviceGalaxyUrl + "/galaxy/artwork/seriesClaimResultQuery";
String postUrl = serviceGoblinUrl + "/goblin/nftArtwork/seriesClaimResultQuery";
String postBoby = JsonUtils.toJson(artSeriesClaimResultQueryReqDto);
try {
String postRespStr = HttpUtil.postRaw(postUrl, postBoby, null);
JsonNode postRespJNode = JsonUtils.fromJson(postRespStr, JsonNode.class), postRespCode, postRespDataJNode;
if (null == postRespJNode || null == (postRespCode = postRespJNode.get("code")) || !postRespCode.asText().equals("0")) {
log.warn("#CONSUMER MSG FAIL_UPC[{}]查询失败[paramsStr={},postRespStr={}]", this.getRedisStreamKey(), postBoby, postRespStr);
return null;
}
if (1 != (postRespDataJNode = postRespJNode.get("data")).get("taskStatus").asInt()) {
log.warn("#CONSUMER MSG FAIL_UPC[{}]声明失败[paramsStr={},postRespStr={}]", this.getRedisStreamKey(), postBoby, postRespStr);
return null;
}
return JsonUtils.OM().convertValue(postRespDataJNode, GalaxyArtSeriesClaimResultQueryRespDto.class);
} catch (Exception e) {
log.error("Ex.CONSUMER MSG ERROR_UPC[{}]请求异常[url={},paramsStr={}],ex:{}", this.getRedisStreamKey(), postUrl, postBoby, e.getMessage());
return null;
}
}
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
public GoblinGoodsSkuInfoVo getGoodsSkuInfoVoFromMdb(String skuId) {
return mongoTemplate.findOne(Query.query(Criteria.where("skuId").is(skuId).and("delFlg").is("0")),
GoblinGoodsSkuInfoVo.class, GoblinGoodsSkuInfoVo.class.getSimpleName());
}
/* ------------------------------------------------------------------------------------ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinBizArtworkGenRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;//package com.liquidnet.service.consumer.order.receiver;
//
//import com.fasterxml.jackson.databind.node.ObjectNode;
//import com.liquidnet.common.cache.redis.util.RedisUtil;
//import com.liquidnet.commons.lang.util.CollectionUtil;
//import com.liquidnet.commons.lang.util.DateUtil;
//import com.liquidnet.commons.lang.util.IDGenerator;
//import com.liquidnet.commons.lang.util.JsonUtils;
//import com.liquidnet.service.base.SqlMapping;
//import com.liquidnet.service.base.constant.MQConst;
//import com.liquidnet.service.goblin.constant.GoblinRedisConst;
//import com.liquidnet.service.goblin.dto.GoblinQueueBizArtworkGenDto;
//import com.liquidnet.service.goblin.dto.vo.GoblinGoodsInfoVo;
//import com.liquidnet.service.goblin.dto.vo.GoblinUserDigitalArtworkVo;
//import com.liquidnet.service.goblin.dto.vo.GoblinGoodsSkuInfoVo;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.lang3.StringUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.data.mongodb.core.MongoTemplate;
//import org.springframework.data.mongodb.core.query.Criteria;
//import org.springframework.data.mongodb.core.query.Query;
//import org.springframework.data.mongodb.core.query.Update;
//import org.springframework.data.redis.connection.stream.RecordId;
//import org.springframework.data.redis.connection.stream.StreamRecords;
//import org.springframework.data.redis.core.StreamOperations;
//import org.springframework.stereotype.Component;
//import org.springframework.util.CollectionUtils;
//
//import java.time.LocalDateTime;
//import java.util.HashMap;
//import java.util.LinkedList;
//import java.util.List;
//
//@Slf4j
//@Component
//public class ConsumerGoblinBizArtworkGenRdsReceiver extends AbstractBizRedisReceiver {
// @Autowired
// private RedisUtil redisUtil;
// @Autowired
// private MongoTemplate mongoTemplate;
//
// private static final String SQL_INSERT_ARTWORK = "INSERT INTO goblin_user_digital_artwork (artwork_id, sku_id, uid, order_id, source, state, created_at)VALUES(?,?,?,?,?,?,?)";
//
// @Override
// protected String getRedisStreamKey() {
// return MQConst.GoblinQueue.BIZ_ARTWORK_GEN.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.GoblinQueue.BIZ_ARTWORK_GEN.getGroup();
// }
//
// @Override
// protected boolean consumerMessageHandler(String msg) {
// boolean aBoolean = false;
// try {
// GoblinQueueBizArtworkGenDto fromJsonObj = JsonUtils.fromJson(msg, GoblinQueueBizArtworkGenDto.class);
// if (fromJsonObj == null) {
// log.warn("CONSUMER MSG NULL_DTO ==> [{}]:{}", this.getRedisStreamKey(), msg);
// aBoolean = true;
// } else {
// aBoolean = this.bizArtworkGenProcessing(fromJsonObj);
// }
// } catch (Exception e) {
// log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
// } finally {
// if (!aBoolean) {
// HashMap<String, String> map = CollectionUtil.mapStringString();
// map.put("message", msg);
// stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
// }
// }
// return aBoolean;
// }
//
// private boolean bizArtworkGenProcessing(GoblinQueueBizArtworkGenDto dto) {
// String uid = dto.getUid(), skuId = dto.getSkuId(), orderId = dto.getOrderId(), fromArtworkId = dto.getFromArtId();
// Integer source = dto.getSource();
//
// GoblinGoodsSkuInfoVo goodsSkuInfoVo = this.getGoodsSkuInfoVoFromRdb(skuId);
// if (null == goodsSkuInfoVo || !"0".equals(goodsSkuInfoVo.getDelFlg())) {
// log.warn("#CONSUMER MSG NULL_SKU[{}]:[uid={},skuId={},orderId={},source={},fromArtworkId={}]", this.getRedisStreamKey(), uid, skuId, orderId, source, fromArtworkId);
// return true;
// }
//
// // 判断是否已生成
// String genMarkerKey = GoblinRedisConst.USER_DIGITAL_ARTWORK_GENMARK.concat(uid).concat(skuId).concat(orderId);
// if (this.hasUserDigitalArtworkVoFromRdb(genMarkerKey)) {// 已生成
// log.warn("#CONSUMER MSG EXIST_ART[{}]:[uid={},skuId={},orderId={},source={},fromArtworkId={}]", this.getRedisStreamKey(),
// uid, skuId, orderId, source, fromArtworkId);
// return true;
// }
//// GoblinDigitalArtworkVo existDigitalArtworkVo = this.getDigitalArtworkVoFromMdb(uid, skuId, orderId);
//// if (null != existDigitalArtworkVo) {// 已生成
//// log.warn("#CONSUMER MSG EXIST_ART[{}]:[uid={},skuId={},orderId={},source={}]", this.getRedisStreamKey(),
//// uid, skuId, orderId, source);
//// return true;
//// }
//
// GoblinGoodsInfoVo goodsInfoVo = this.getGoodsInfoVoFromRdb(goodsSkuInfoVo.getSpuId());
//
// LocalDateTime now = LocalDateTime.now();
//
// GoblinUserDigitalArtworkVo digitalArtworkVo = GoblinUserDigitalArtworkVo.getNew();
// String artworkId = IDGenerator.nextMilliId2();
// digitalArtworkVo.setArtworkId(artworkId);
// digitalArtworkVo.setSkuId(skuId);
// digitalArtworkVo.setUid(uid);
// digitalArtworkVo.setOrderId(orderId);
// digitalArtworkVo.setSource(source);
// digitalArtworkVo.setState(0);
// digitalArtworkVo.setDelFlg("0");
// digitalArtworkVo.setCreatedAt(now);
// digitalArtworkVo.setAuthor(goodsInfoVo.getAuthor());
// digitalArtworkVo.setPublisher(goodsInfoVo.getPublisher());
//
// // Mongo记录VO
// mongoTemplate.insert(digitalArtworkVo, GoblinUserDigitalArtworkVo.class.getSimpleName());
// boolean fromBoxArtworkFlg = StringUtils.isNotEmpty(fromArtworkId);
// if (fromBoxArtworkFlg) {// 更新盲盒藏品数据
// GoblinUserDigitalArtworkVo userDigitalArtworkVo = this.getUserDigitalArtworkVoFromRdb(fromArtworkId);
// if (null != userDigitalArtworkVo) {
// mongoTemplate.getCollection(GoblinUserDigitalArtworkVo.class.getSimpleName()).updateOne(
// Query.query(Criteria.where("artworkId").is(fromArtworkId).and("state").ne(1)).getQueryObject(),
// Update.update("state", userDigitalArtworkVo.getState())
// .set("delFlg", userDigitalArtworkVo.getDelFlg())
// .set("openingAt", mongoTemplate.getConverter().convertToMongoType(userDigitalArtworkVo.getOpeningAt()))
// .set("updatedAt", mongoTemplate.getConverter().convertToMongoType(userDigitalArtworkVo.getUpdatedAt()))
// .set("deletedAt", mongoTemplate.getConverter().convertToMongoType(userDigitalArtworkVo.getDeletedAt()))
// .getUpdateObject()
// );
// }
// } else {
// redisUtil.incr(GoblinRedisConst.USER_DIGITAL_ARTWORK_CT.concat(uid), 1);
// }
// // Redis记录VO
// redisUtil.set(GoblinRedisConst.USER_DIGITAL_ARTWORK.concat(digitalArtworkVo.getArtworkId()), digitalArtworkVo);
// // Redis更新藏品ID列表
// this.addGoblinUserDigitalArtworkIds(uid, artworkId, fromArtworkId);
// // Redis生成标记（缓存三天），用于上面的生成检查
// redisUtil.set(genMarkerKey, 1, 259200);
//
// StreamOperations<String, Object, Object> streamOperations = stringRedisTemplate.opsForStream();
// // Mysql持久化
// HashMap<String, String> sqlArtworkMap = CollectionUtil.mapStringString();
// LinkedList<String> toMqSqls = CollectionUtil.linkedListString();
// toMqSqls.add(SQL_INSERT_ARTWORK);
// LinkedList<Object[]> initArtworkObjs = CollectionUtil.linkedListObjectArr();
// initArtworkObjs.add(new Object[]{digitalArtworkVo.getArtworkId(), skuId, uid, orderId, source, digitalArtworkVo.getState(), now});
// sqlArtworkMap.put(MQConst.QUEUE_MESSAGE_KEY, SqlMapping.gets(toMqSqls, initArtworkObjs));
// streamOperations.add(StreamRecords.mapBacked(sqlArtworkMap).withStreamKey(MQConst.GoblinQueue.SQL_ARTWORK_GEN.getKey()));
// // NFT发行购买
// HashMap<String, String> bizNftBuyMap = CollectionUtil.mapStringString();
// ObjectNode bizNftBuyNode = JsonUtils.OM().createObjectNode();
// bizNftBuyNode.put("nftOrderPayId", orderId).put("routerType", "zxinchain")
// .put("skuId", skuId).put("userId", uid).put("buyTimestamp", DateUtil.Formatter.yyyyMMddHHmmss.format(now));
// bizNftBuyMap.put(MQConst.QUEUE_MESSAGE_KEY, bizNftBuyNode.toString());
// RecordId add = streamOperations.add(StreamRecords.mapBacked(bizNftBuyMap).withStreamKey(MQConst.GalaxyQueue.JSON_NFT_PUBLISH_AND_BUY.getKey()));
// log.info("CONSUMER MSG GEN_ART_TQ[{},message={}]", JsonUtils.toJson(add), bizNftBuyMap);
//
// return true;
// }
//
//
// /* ------------------------------------------------------------------------------------ */
//
//// public void setDigitalArtworkVo(GoblinDigitalArtworkVo vo) {
//// mongoTemplate.insert(vo, GoblinDigitalArtworkVo.class.getSimpleName());
//// redisUtil.set(GoblinRedisConst.USER_DIGITAL_ARTWORK.concat(vo.getArtworkId()), vo);
////
//// LinkedList<Object[]> paramsList = CollectionUtil.linkedListObjectArr();
//// paramsList.add(new Object[]{vo.getArtworkId(), vo.getSkuId(), vo.getUid(), vo.getOrderId(), vo.getSource(), vo.getState(), vo.getCreatedAt()});
//// this.baseDao.batchSql(SQL_INSERT_ARTWORK, paramsList);
//// }
////
//// public void sendMsgByRedisToQueue(String streamKey, String jsonMsg) {
//// HashMap<String, String> map = CollectionUtil.mapStringString();
//// map.put("message", jsonMsg);
//// stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(streamKey));
//// }
//
// /* ------------------------------------------------------------------------------------ */
// /* ------------------------------------------------------------------------------------ */
//
//
// public List<String> getUserDigitalArtworkIdsFromRdb(String uid) {
// return (List<String>) redisUtil.get(GoblinRedisConst.USER_DIGITAL_ARTWORK_IDS.concat(uid));
// }
//
// /**
// * 缓存并更新用户藏品ID集合
// */
// public boolean addGoblinUserDigitalArtworkIds(String uid, String artworkId, String boxArtworkId) {
// List<String> ids = this.getUserDigitalArtworkIdsFromRdb(uid);
// if (CollectionUtils.isEmpty(ids)) {
// ids = CollectionUtil.arrayListString();
// ids.add(artworkId);
// } else {
// ids.add(0, artworkId);
// if (null != boxArtworkId) ids.remove(boxArtworkId);
// int size = ids.size();
// if (size > 30) ids.remove(size - 1);
// }
// return redisUtil.set(GoblinRedisConst.USER_DIGITAL_ARTWORK_IDS.concat(uid), ids);
// }
//
// public GoblinGoodsSkuInfoVo getGoodsSkuInfoVoFromRdb(String skuId) {
// String rk = GoblinRedisConst.BASIC_GOODS_SKU.concat(skuId);
// GoblinGoodsSkuInfoVo vo = (GoblinGoodsSkuInfoVo) redisUtil.get(rk);
// if (null == vo && null != (vo = this.getGoodsSkuInfoVoFromMdb(skuId))) {
// redisUtil.set(rk, vo);
// }
// return vo;
// }
//
// public GoblinGoodsInfoVo getGoodsInfoVoFromRdb(String spuId) {
// String rk = GoblinRedisConst.BASIC_GOODS.concat(spuId);
// GoblinGoodsInfoVo vo = (GoblinGoodsInfoVo) redisUtil.get(rk);
// if (null == vo && null != (vo = this.getGoodsInfoVoFromMdb(spuId))) {
// redisUtil.set(rk, vo);
// }
// return vo;
// }
//
// public GoblinUserDigitalArtworkVo getUserDigitalArtworkVoFromRdb(String artworkId) {
// return (GoblinUserDigitalArtworkVo) redisUtil.get(GoblinRedisConst.USER_DIGITAL_ARTWORK.concat(artworkId));
// }
//
// public boolean hasUserDigitalArtworkVoFromRdb(String genMarkerKey) {
// return redisUtil.hasKey(genMarkerKey);
// }
//
// /* ------------------------------------------------------------------------------------ */
//
// public GoblinGoodsSkuInfoVo getGoodsSkuInfoVoFromMdb(String skuId) {
// return mongoTemplate.findOne(Query.query(Criteria.where("skuId").is(skuId)),
// GoblinGoodsSkuInfoVo.class, GoblinGoodsSkuInfoVo.class.getSimpleName());
// }
//
// public GoblinGoodsInfoVo getGoodsInfoVoFromMdb(String spuId) {
// return mongoTemplate.findOne(Query.query(Criteria.where("spuId").is(spuId)),
// GoblinGoodsInfoVo.class, GoblinGoodsInfoVo.class.getSimpleName());
// }
//
//// public GoblinDigitalArtworkVo getDigitalArtworkVoFromMdb(String uid, String skuId, String orderId) {
//// return mongoTemplate.findOne(Query.query(Criteria.where("uid").is(uid).and("skuId").is(skuId).and("orderId").is(orderId)),
//// GoblinDigitalArtworkVo.class, GoblinDigitalArtworkVo.class.getSimpleName());
//// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinBizArtworkUplRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.fasterxml.jackson.databind.JsonNode;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.HttpUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.SqlMapping;
import com.liquidnet.service.base.constant.MQConst;
import com.liquidnet.service.galaxy.dto.param.GalaxyArtSeriesClaimReqDto;
import com.liquidnet.service.galaxy.dto.param.GalaxyArtSeriesClaimRespDto;
import com.liquidnet.service.galaxy.dto.param.GalaxyNftUploadReqDto;
import com.liquidnet.service.galaxy.dto.param.GalaxyNftUploadRespDto;
import com.liquidnet.service.goblin.constant.GoblinRedisConst;
import com.liquidnet.service.goblin.dto.vo.GoblinGoodsInfoVo;
import com.liquidnet.service.goblin.dto.vo.GoblinGoodsSkuInfoVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.data.redis.core.StreamOperations;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.LinkedList;
@Slf4j
@Component
public class ConsumerGoblinBizArtworkUplRdsReceiver extends AbstractBizRedisReceiver {
@Autowired
private RedisUtil redisUtil;
@Autowired
private MongoTemplate mongoTemplate;
// @Value("${liquidnet.service.galaxy.url}")
// private String serviceGalaxyUrl;
@Value("${liquidnet.service.goblin.url}")
private String serviceGoblinUrl;
private static final String SQL_UPDATE_GOODS_SKU_NFT = "UPDATE goblin_goods_sku_nft SET upchain=?,display_url=?,nft_url=? WHERE sku_id=? AND upchain=0 ";
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.BIZ_ARTWORK_UPL.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.BIZ_ARTWORK_UPL.getGroup();
}
@Override
protected boolean consumerMessageHandler(String msg) {
boolean aBoolean = false;
try {
if (StringUtils.isEmpty(msg)) {
log.warn("CONSUMER MSG NULL_DTO ==> [{}]:{}", this.getRedisStreamKey(), msg);
aBoolean = true;
} else {
aBoolean = this.bizArtworkUplProcessing(msg);
}
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put(MQConst.QUEUE_MESSAGE_KEY, msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
private boolean bizArtworkUplProcessing(String skuId) {
GoblinGoodsSkuInfoVo mgtGoodsSkuInfoVo = this.getGoodsSkuInfoVoFromMdb(skuId);
if (null == mgtGoodsSkuInfoVo) {
log.warn("#CONSUMER MSG NULL_SKU[{}]:[skuId={}]", this.getRedisStreamKey(), skuId);
return true;
}
int skuType = mgtGoodsSkuInfoVo.getSkuType(), upchain = mgtGoodsSkuInfoVo.getUpchain();
String unbox = mgtGoodsSkuInfoVo.getUnbox();
// 非数字藏品 || 盲盒 || 非声明中 || 已有声明系列ID
if (1 != skuType || !"0".equals(unbox) || 0 != upchain || StringUtils.isNotEmpty(mgtGoodsSkuInfoVo.getSeriesId())) {
log.warn("#CONSUMER MSG VOID_SKU[{}]:[skuId={},skuType={},unbox={},upchain={},seriesId={}]",
this.getRedisStreamKey(), skuId, skuType, unbox, upchain, mgtGoodsSkuInfoVo.getSeriesId());
return true;
}
String displayUrl = mgtGoodsSkuInfoVo.getDisplayUrl(), nftUrl = mgtGoodsSkuInfoVo.getNftUrl();
if (StringUtils.isBlank(displayUrl)) {// 未上传过的直接上传处理，已上传过的跳过上传直接声明
GalaxyNftUploadReqDto galaxyNftUploadReqDto = GalaxyNftUploadReqDto.getNew();
galaxyNftUploadReqDto.setSkuId(skuId);
galaxyNftUploadReqDto.setOriginalDisplayUrl(mgtGoodsSkuInfoVo.getSkuPic());
galaxyNftUploadReqDto.setOriginalNftUrl(mgtGoodsSkuInfoVo.getMaterialUrl());
galaxyNftUploadReqDto.setRouterType(mgtGoodsSkuInfoVo.getRouteType());
GalaxyNftUploadRespDto galaxyNftUploadRespDto = this.uploadNftMaterial(galaxyNftUploadReqDto);
if (null == galaxyNftUploadRespDto) return false;// 上传失败，重新入队处理
displayUrl = galaxyNftUploadRespDto.getDisplayUrl();
nftUrl = galaxyNftUploadRespDto.getNftUrl();
}
GoblinGoodsInfoVo mgtGoodsInfoVo = this.getGoodsInfoVoFromMdb(mgtGoodsSkuInfoVo.getSpuId());
String skuTitle = mgtGoodsSkuInfoVo.getName() + mgtGoodsSkuInfoVo.getSubtitle();
GalaxyArtSeriesClaimReqDto galaxyArtSeriesClaimReqDto = GalaxyArtSeriesClaimReqDto.getNew();
galaxyArtSeriesClaimReqDto.setAuthor(mgtGoodsInfoVo.getAuthor());
galaxyArtSeriesClaimReqDto.setCoverUrl(displayUrl);
galaxyArtSeriesClaimReqDto.setDisplayUrl(displayUrl);
galaxyArtSeriesClaimReqDto.setNftDesc(skuTitle);
galaxyArtSeriesClaimReqDto.setNftName(skuTitle);
galaxyArtSeriesClaimReqDto.setNftUrl(nftUrl);
galaxyArtSeriesClaimReqDto.setRouterType(mgtGoodsSkuInfoVo.getRouteType());
galaxyArtSeriesClaimReqDto.setSellCount(String.valueOf(mgtGoodsSkuInfoVo.getPrice()));
galaxyArtSeriesClaimReqDto.setSeriesDesc(skuTitle);
galaxyArtSeriesClaimReqDto.setSkuId(skuId);
galaxyArtSeriesClaimReqDto.setTotalCount(Long.valueOf(mgtGoodsSkuInfoVo.getSkuStock()));
// 声明失败，标记`声明失败`
upchain = null == this.claimNftSeries(galaxyArtSeriesClaimReqDto) ? 2 : 9;
mongoTemplate.getCollection(GoblinGoodsSkuInfoVo.class.getSimpleName()).updateOne(
Query.query(Criteria.where("skuId").is(skuId).and("delFlg").is("0")).getQueryObject(),
Update.update("upchain", upchain).set("displayUrl", displayUrl).set("nftUrl", nftUrl).getUpdateObject()
);
redisUtil.del(GoblinRedisConst.BASIC_GOODS_SKU.concat(skuId));
// Mysql持久化
HashMap<String, String> sqlUpdateMap = CollectionUtil.mapStringString();
LinkedList<String> toMqSqls = CollectionUtil.linkedListString();
toMqSqls.add(SQL_UPDATE_GOODS_SKU_NFT);
LinkedList<Object[]> updateGoodsSkuNftObjs = CollectionUtil.linkedListObjectArr();
updateGoodsSkuNftObjs.add(new Object[]{upchain, displayUrl, nftUrl, skuId});
sqlUpdateMap.put(MQConst.QUEUE_MESSAGE_KEY, SqlMapping.gets(toMqSqls, updateGoodsSkuNftObjs));
StreamOperations<String, Object, Object> streamOperations = stringRedisTemplate.opsForStream();
streamOperations.add(StreamRecords.mapBacked(sqlUpdateMap).withStreamKey(MQConst.GoblinQueue.SQL_GOODS.getKey()));
HashMap<String, String> toQueueBeClaimQueryMsg = CollectionUtil.mapStringString();
toQueueBeClaimQueryMsg.put(MQConst.QUEUE_MESSAGE_KEY, skuId.concat(",").concat(String.valueOf(LocalDateTime.now())));
streamOperations.add(StreamRecords.mapBacked(toQueueBeClaimQueryMsg).withStreamKey(MQConst.GoblinQueue.BIZ_ARTWORK_CLQ.getKey()));
return true;
}
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
/**
* NFT素材上传
*
* @param nftUploadReqDto GalaxyNftUploadReqDto
* @return GalaxyNftUploadRespDto
*/
public GalaxyNftUploadRespDto uploadNftMaterial(GalaxyNftUploadReqDto nftUploadReqDto) {
// String postUrl = serviceGalaxyUrl + "/galaxy/artwork/nftUpload";
String postUrl = serviceGoblinUrl + "/goblin/nftArtwork/nftUpload";
String postBody = JsonUtils.toJson(nftUploadReqDto);
try {
String postRespStr = HttpUtil.postRaw(postUrl, postBody, null);
JsonNode postRespJNode = JsonUtils.fromJson(postRespStr, JsonNode.class), postRespCode;
if (null == postRespJNode || null == (postRespCode = postRespJNode.get("code")) || !postRespCode.asText().equals("0")) {
log.warn("#NFT素材上传:请求失败[paramsStr={},postRespStr={}]", postBody, postRespStr);
return null;
}
return JsonUtils.OM().convertValue(postRespJNode.get("data"), GalaxyNftUploadRespDto.class);
} catch (Exception e) {
log.error("Ex.NFT素材上传:请求异常[url={},paramsStr={}],ex:{}", postUrl, postBody, e.getMessage());
return null;
}
}
/**
* NFT系列声明
*
* @param seriesClaimReqDto GalaxyArtSeriesClaimReqDto
* @return GalaxyArtSeriesClaimRespDto
*/
public GalaxyArtSeriesClaimRespDto claimNftSeries(GalaxyArtSeriesClaimReqDto seriesClaimReqDto) {
// String postUrl = serviceGalaxyUrl + "/galaxy/nftArtwork/seriesClaim";
String postUrl = serviceGoblinUrl + "/goblin/nftArtwork/seriesClaim";
String postBody = JsonUtils.toJson(seriesClaimReqDto);
try {
String postRespStr = HttpUtil.postRaw(postUrl, postBody, null);
JsonNode postRespJNode = JsonUtils.fromJson(postRespStr, JsonNode.class), postRespCode;
if (null == postRespJNode || null == (postRespCode = postRespJNode.get("code")) || !postRespCode.asText().equals("0")) {
log.warn("#NFT系列声明:请求失败[paramsStr={},postRespStr={}]", postBody, postRespStr);
return null;
}
return JsonUtils.OM().convertValue(postRespJNode.get("data"), GalaxyArtSeriesClaimRespDto.class);
} catch (Exception e) {
log.error("Ex.NFT系列声明:请求异常[url={},paramsStr={}],ex:{}", postUrl, postBody, e.getMessage());
return null;
}
}
/* ------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------ */
public GoblinGoodsSkuInfoVo getGoodsSkuInfoVoFromMdb(String skuId) {
return mongoTemplate.findOne(Query.query(Criteria.where("skuId").is(skuId).and("delFlg").is("0")),
GoblinGoodsSkuInfoVo.class, GoblinGoodsSkuInfoVo.class.getSimpleName());
}
public GoblinGoodsInfoVo getGoodsInfoVoFromMdb(String spuId) {
return mongoTemplate.findOne(Query.query(Criteria.where("spuId").is(spuId).and("delFlg").is("0")),
GoblinGoodsInfoVo.class, GoblinGoodsInfoVo.class.getSimpleName());
}
/* ------------------------------------------------------------------------------------ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinBizIntegralReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.HttpUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.constant.MQConst;
import com.liquidnet.service.goblin.dto.GoblinQueueBizIntegralDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import java.util.HashMap;
@Slf4j
@Component
public class ConsumerGoblinBizIntegralReceiver extends AbstractBizRedisReceiver {
@Value("${liquidnet.service.stone.url}")
private String stoneUrl;
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.BIZ_INTEGRAL.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.BIZ_INTEGRAL.getGroup();
}
@Override
protected boolean consumerMessageHandler(String msg) {
boolean aBoolean = false;
try {
GoblinQueueBizIntegralDto fromJsonObj = JsonUtils.fromJson(msg, GoblinQueueBizIntegralDto.class);
if (fromJsonObj == null) {
log.warn("CONSUMER MSG NULL_DTO ==> [{}]:{}", this.getRedisStreamKey(), msg);
aBoolean = true;
} else {
aBoolean = this.bizIntegralProcessing(fromJsonObj);
}
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put(MQConst.QUEUE_MESSAGE_KEY, msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
private boolean bizIntegralProcessing(GoblinQueueBizIntegralDto dto) {
try {
log.info("bizIntegralProcessing params:{}", dto);
String uid = dto.getUid(), content = dto.getContent();
int type = dto.getType();
MultiValueMap<String, String> header = CollectionUtil.linkedMultiValueMapStringString();
header.add("Accept", "application/json;charset=UTF-8");
MultiValueMap<String, String> params = CollectionUtil.linkedMultiValueMapStringString();
params.add("score", dto.getScore().intValue() + "");
params.add("content", content);
params.add("uid", uid);
String resultData = "";
long ss = System.currentTimeMillis();
log.info("HttpUtil s:{}", ss);
if (type == 1) {
resultData = HttpUtil.post(stoneUrl + "/user/logs/in2111", params, header);
} else {
resultData = HttpUtil.post(stoneUrl + "/user/logs/de2111", params, header);
}
log.info("HttpUtil e:{}", System.currentTimeMillis() - ss);
log.info("bizIntegralProcessing result:{}", resultData);
return true;
} catch (Exception e) {
log.error("bizIntegralProcessing e:{}", e);
return false;
}
}
/* ------------------------------------------------------------------------------------ */
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinCodeReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class ConsumerGoblinCodeReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_CODE_OPERA.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_CODE_OPERA.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinMdbNftArtworkReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinMdbNftArtworkReceiver extends AbstractMdbRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.BIZ_ARTWORK_GEN.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.BIZ_ARTWORK_GEN.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinMdbNftOrderReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinMdbNftOrderReceiver extends AbstractMdbRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.BIZ_NFT_MONGO.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.BIZ_NFT_MONGO.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinNftOrderRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinNftOrderRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_NFT_ORDER.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_NFT_ORDER.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinOrderAGRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinOrderAGRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_ORDER_AGAIN.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_ORDER_AGAIN.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinOrderCPRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinOrderCPRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_ORDER_CREATE_PAY.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_ORDER_CREATE_PAY.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinOrderCloseRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinOrderCloseRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_ORDER_CLOSE.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_ORDER_CLOSE.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinPhoneCodeReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class ConsumerGoblinPhoneCodeReceiver extends AbstractHttpRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_PHONE_CODE_OPERA.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_PHONE_CODE_OPERA.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinSelfMarketRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinSelfMarketRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_SELF_MARKET.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_SELF_MARKET.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinShopCartReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinShopCartReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_SHOP_CART.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_SHOP_CART.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinSqlArtworkGenRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinSqlArtworkGenRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.SQL_ARTWORK_GEN.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.SQL_ARTWORK_GEN.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinSqlCouponRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinSqlCouponRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.SQL_COUPON.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.SQL_COUPON.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinSqlGoodsRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinSqlGoodsRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.SQL_GOODS.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.SQL_GOODS.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinSqlStoreRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinSqlStoreRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.SQL_STORE.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.SQL_STORE.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinStoreMarketRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinStoreMarketRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_STORE_MARKET.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_STORE_MARKET.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinStoreOrderRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinStoreOrderRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_STORE_ORDER_OPERA.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_STORE_ORDER_OPERA.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinUserOrderRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinUserOrderRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_USER_ORDER_OPERA.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_USER_ORDER_OPERA.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerGoblinXlsRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerGoblinXlsRdsReceiver extends AbstractXlsRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_XLS_OPERA.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_XLS_OPERA.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinOrderRefundExpressRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinOrderRefundExpressRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_ORDER_REFUND_EXPRESS.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_ORDER_REFUND_EXPRESS.getGroup();
}
}
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSmsNoticeRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSmsNoticeRdsReceiver extends AbstractSmsRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SMS_NOTICE.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SMS_NOTICE.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSqlOptOrderCloseRedisReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSqlOptOrderCloseRedisReceiver extends AbstractSqlOptOrderCloseRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_ORDER_CLOSE.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_ORDER_CLOSE.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSqlOrderAgainRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSqlOrderAgainRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_ORDER_AGAIN.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_ORDER_AGAIN.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSqlOrderCreateRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSqlOrderCreateRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_ORDER_CREATE.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_ORDER_CREATE.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSqlOrderOvertimeRefundRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSqlOrderOvertimeRefundRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_ORDER_OVERTIME_REFUND.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_ORDER_OVERTIME_REFUND.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSqlOrderPayRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSqlOrderPayRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_ORDER_PAY.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_ORDER_PAY.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSqlOrderRefundRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSqlOrderRefundRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_ORDER_REFUND.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_ORDER_REFUND.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSqlOrderWithdrawRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSqlOrderWithdrawRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_ORDER_WITHDRAW.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_ORDER_WITHDRAW.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSqlPerformanceLackRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSqlPerformanceLackRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_PERFORMANCE_LACK.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_PERFORMANCE_LACK.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinSqlStationRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinSqlStationRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_STATION.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_STATION.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinTransferOverTimeRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinTransferOverTimeRdsReceiver extends AbstractOptOrderTransferOverTimeRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_TRANSFER_OVERTIME.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_TRANSFER_OVERTIME.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinTransferRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinTransferRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_TRANSFER.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_TRANSFER.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerKylinTransferResultRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerKylinTransferResultRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.KylinQueue.SQL_TRANSFER_RESULT.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.KylinQueue.SQL_TRANSFER_RESULT.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose0RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose0RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_0.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_0.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose1RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose1RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_1.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_1.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose2RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose2RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_2.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_2.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose3RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose3RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_3.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_3.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose4RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose4RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_4.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_4.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose5RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose5RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_5.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_5.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose6RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose6RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_6.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_6.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose7RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose7RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_7.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_7.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose8RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose8RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_8.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_8.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerOrderClose9RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerOrderClose9RdsReceiver extends AbstractOrderCloseReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_9.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.GoblinQueue.GOBLIN_UN_PAY_9.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerSlimeFieldRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSlimeFieldRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SlimeQueue.SQL_SLIME_FIELD.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SlimeQueue.SQL_SLIME_FIELD.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerSlimeLineRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSlimeLineRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SlimeQueue.SQL_SLIME_LINE.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SlimeQueue.SQL_SLIME_LINE.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerSlimePerformanceInsertRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSlimePerformanceInsertRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SlimeQueue.SQL_SLIME_PERFORMANCE_INSERT.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SlimeQueue.SQL_SLIME_PERFORMANCE_INSERT.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerSlimePerformanceRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSlimePerformanceRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SlimeQueue.SQL_SLIME_PERFORMANCE_UPDATE.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SlimeQueue.SQL_SLIME_PERFORMANCE_UPDATE.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerSlimeSponsorRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSlimeSponsorRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SlimeQueue.SQL_SLIME_SPONSOR.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SlimeQueue.SQL_SLIME_SPONSOR.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerSlimeStep2RdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSlimeStep2RdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SlimeQueue.SQL_SLIME_STEP2.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SlimeQueue.SQL_SLIME_STEP2.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/receiver/ConsumerSlimeTicketRdsReceiver.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSlimeTicketRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SlimeQueue.SQL_SLIME_TICKET_UPDATE.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SlimeQueue.SQL_SLIME_TICKET_UPDATE.getGroup();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/service/IBaseDao.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.service;
import java.util.LinkedList;
public interface IBaseDao {
/**
* 批量执行sql
*
* @param sql
* @param values
* @return
*/
Boolean batchSql(String sql, LinkedList<Object[]> values);
/**
* 批量执行不定量sql
*
* @param sql
* @param values
* @return
*/
Boolean batchSqls(LinkedList<String> sql, LinkedList<Object[]>... values);
/**
* 执行sql语句 无 参数
*
* @param sql
* @return
*/
Boolean batchSqlNoArgs(LinkedList<String> sql);
/**
* xs 新增一条记录且返回主键Id
*
* @param sql 新增待执行sql
* @param param 参数
* @return 主键ID
*/
int insertSqlAndReturnKeyId(final String sql, final Object[] param);
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/service/impl/BaseDao.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.service.impl;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.consumer.order.service.IBaseDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
import javax.annotation.Resource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.LinkedList;
@Service
public class BaseDao implements IBaseDao {
private static final Logger log = LoggerFactory.getLogger(BaseDao.class);
@Resource
public JdbcTemplate jdbcTemplate;
@Resource(name = "transactionManager")
public DataSourceTransactionManager transactionManager;
@Override
public Boolean batchSql(final String sql, final LinkedList<Object[]> values) {
TransactionCallback<Boolean> callback = new TransactionCallback<Boolean>() {
@Override
public Boolean doInTransaction(final TransactionStatus transactionStatus) {
if (values.size() > 0) {
int[] ints = jdbcTemplate.batchUpdate(sql, values);
}
return true;
}
};
try {
TransactionTemplate tt = new TransactionTemplate(transactionManager);
return tt.execute(callback);
} catch (Exception ex) {
log.error("###\nSQL.Preparing:{}\nParameters:{}", JsonUtils.toJson(sql), JsonUtils.toJson(values), ex);
return false;
}
}
@Override
public Boolean batchSqls(final LinkedList<String> sql,
final LinkedList<Object[]>... values) {
try {
TransactionCallback<Boolean> callback = new TransactionCallback<Boolean>() {
@Override
public Boolean doInTransaction(final TransactionStatus transactionStatus) {
int i = 0;
for (LinkedList<Object[]> o : values) {
if (sql.size() < i + 1) {
break;
}
if (!o.isEmpty()) {
jdbcTemplate.batchUpdate(sql.get(i), o);
}
i++;
}
return true;
}
};
TransactionTemplate tt = new TransactionTemplate(transactionManager);
return tt.execute(callback);
} catch (Exception ex) {
// if (ex instanceof LiquidnetServiceException) {
// log.error("###Error.Code:{} - {}", ((LiquidnetServiceException) ex).getCode(), ex.getMessage());
// } else {
log.error("###Error.Sqls:{}\nParameters:{},Ex:{}", JsonUtils.toJson(sql), JsonUtils.toJson(values), ex.getMessage());
// }
return false;
}
}
@Override
public Boolean batchSqlNoArgs(final LinkedList<String> sql) {
try {
TransactionCallback<Boolean> callback = new TransactionCallback<Boolean>() {
@Override
public Boolean doInTransaction(final TransactionStatus transactionStatus) {
for (String o : sql) {
jdbcTemplate.execute(o);
}
return true;
}
};
TransactionTemplate tt = new TransactionTemplate(transactionManager);
return tt.execute(callback);
} catch (Exception ex) {
log.error("###Error.Sqls:{}\nParameters:{},Ex:{}", sql);
return false;
}
}
/**
* xs 新增一条记录且返回主键Id
*
* @param sql 新增待执行sql
* @param param 参数
* @return 主键ID
*/
public int insertSqlAndReturnKeyId(final String sql, final Object[] param) {
final String innersql = sql;
final Object[] innerO = param;
KeyHolder keyHolder = new GeneratedKeyHolder();
try {
jdbcTemplate.update(new PreparedStatementCreator() {
@Override
public PreparedStatement createPreparedStatement(final Connection con)
throws SQLException {
PreparedStatement ps = con.prepareStatement(innersql,
Statement.RETURN_GENERATED_KEYS);
for (int i = 0; i < innerO.length; i++) {
ps.setObject(i + 1, innerO[i]);
}
return ps;
}
}, keyHolder);
} catch (Exception e) {
log.error("###\nSQL.Preparing:{}\nParameters:{}", sql, JsonUtils.toJson(param), e);
}
return keyHolder.getKey().intValue();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/service/processor/ConsumerGalaxyJsonNftPublishAndBuyProcessor.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.service.processor;
import com.liquidnet.service.base.ResponseDto;
import com.liquidnet.service.galaxy.dto.param.GalaxyNftPublishAndBuyReqDto;
import com.liquidnet.service.galaxy.dto.param.GalaxyNftPublishAndBuyRespDto;
import com.liquidnet.service.galaxy.router.zxin.biz.ZxinTradeCommonBiz;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* @author AnJiabin <anjiabin@zhengzai.tv>
* @version V1.0
* @Description: TODO
* @class: ConsumerJsonNftPublishAndBuyProcessor
* @Package com.liquidnet.service.consumer.order.service.processor
* @Copyright: LightNet @ Copyright (c) 2022
* @date 2022/3/29 17:04
*/
@Slf4j
@Component
public class ConsumerGalaxyJsonNftPublishAndBuyProcessor {
@Autowired
private ZxinTradeCommonBiz zxinTradeCommonBiz;
/**
* 执行购买处理
* @param reqDto
* @return
*/
public ResponseDto<GalaxyNftPublishAndBuyRespDto> nftPublishAndBuy(GalaxyNftPublishAndBuyReqDto reqDto) {
return zxinTradeCommonBiz.nftPublishAndBuy(reqDto);
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/service/processor/ConsumerKylinSmsProcessor.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.service.processor;//package com.liquidnet.service.consumer.order.service.processor;
//
//import com.liquidnet.common.mq.constant.MQConst;
//import com.liquidnet.common.sms.processor.SmsProcessor;
//import com.liquidnet.commons.lang.util.JsonUtils;
//import com.liquidnet.service.base.SmsMessage;
//import com.rabbitmq.client.Channel;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.amqp.core.Message;
//import org.springframework.amqp.core.MessageProperties;
//import org.springframework.amqp.rabbit.annotation.Exchange;
//import org.springframework.amqp.rabbit.annotation.Queue;
//import org.springframework.amqp.rabbit.annotation.QueueBinding;
//import org.springframework.amqp.rabbit.annotation.RabbitListener;
//import org.springframework.stereotype.Component;
//
//import javax.annotation.Resource;
//import java.io.IOException;
//
///**
// * ConsumerAdamSmsProcessor.class
// *
// * @author zhanggb
// * Created by IntelliJ IDEA at 2021/7/13
// */
//@Slf4j
//@Component
//public class ConsumerKylinSmsProcessor {
// @Resource
// SmsProcessor smsProcessor;
//
// private void consumerSmsSendHandler(Message msg, Channel channel) {
// MessageProperties properties = msg.getMessageProperties();
// String consumerQueue = properties.getConsumerQueue();
// long deliveryTag = properties.getDeliveryTag();
// log.info("CONSUMER SMS ==> [consumerQueue:{},deliveryTag:{}]", consumerQueue, deliveryTag);
// String msgBody = new String(msg.getBody());
// log.debug("CONSUMER SMS ==> Preparing:{}", msgBody);
// try {
// SmsMessage smsMessage = JsonUtils.fromJson(msgBody, SmsMessage.class);
// boolean result = smsProcessor.send(smsMessage.getPhone(), smsMessage.getSignName(), smsMessage.getTemplateCode(), smsMessage.getTemplateParam().toString());
// log.debug("CONSUMER SMS result of execution:{}", result);
// if (result) {
// channel.basicAck(deliveryTag, false);
// } else {
// log.warn("###CONSUMER SMS[consumerQueue:{},deliveryTag={},sqlMessage:{}]", consumerQueue, deliveryTag, msgBody);
// channel.basicAck(deliveryTag, false);
// }
// } catch (IOException e) {
// log.error("CONSUMER SMS[consumerQueue:{},deliveryTag:{},sqlMessage:{}]", consumerQueue, deliveryTag, msgBody, e);
// }
// }
//
// /* ================================================================== ｜ 短信验证码 */
//
//// @RabbitListener(
//// bindings = @QueueBinding(
//// exchange = @Exchange(MQConst.EX_LNS_SMS_SENDER),
//// key = MQConst.RK_SMS_CODE,
//// value = @Queue(MQConst.QUEUES_SMS_CODE)
//// ),
//// concurrency = "25"
//// )
//// public void consumerSqlForSmsCode(Message msg, Channel channel) {
//// this.consumerSmsSendHandler(msg, channel);
//// }
//
// /* ================================================================== ｜ 短信通知 */
//
// @RabbitListener(
// bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EX_LNS_SMS_SENDER),
// key = MQConst.RK_SMS_NOTICE,
// value = @Queue(MQConst.QUEUES_SMS_NOTICE)
// ),
// concurrency = "10"
// )
// public void consumerSqlForSmsNotice(Message msg, Channel channel) {
// this.consumerSmsSendHandler(msg, channel);
// }
//
//
// /* ================================================================== ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/service/processor/ConsumerProcessor.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.service.processor;//package com.liquidnet.service.consumer.order.service.processor;
//
//import com.liquidnet.common.cache.redis.util.RedisUtil;
//import com.liquidnet.common.mq.constant.MQConst;
//import com.liquidnet.commons.lang.util.JsonUtils;
//import com.liquidnet.service.base.OrderCloseMapping;
//import com.liquidnet.service.base.SqlMapping;
//import com.liquidnet.service.consumer.order.Utils.KylinUtils;
//import com.liquidnet.service.consumer.service.IBaseDao;
//import com.liquidnet.service.kylin.dto.vo.mongo.KylinOrderTicketEntitiesVo;
//import com.liquidnet.service.kylin.dto.vo.mongo.KylinOrderTicketVo;
//import com.rabbitmq.client.Channel;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.lang.StringEscapeUtils;
//import org.springframework.amqp.core.MessageProperties;
//import org.springframework.amqp.rabbit.annotation.Exchange;
//import org.springframework.amqp.rabbit.annotation.Queue;
//import org.springframework.amqp.rabbit.annotation.QueueBinding;
//import org.springframework.amqp.rabbit.annotation.RabbitListener;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Component;
//import org.springframework.amqp.core.Message;
//
//import javax.annotation.Resource;
//import java.io.IOException;
//
///**
// * ConsumerProcessor.class
// *
// * @author zhanggb
// * Created by IntelliJ IDEA at 2021/4/29
// */
//@Slf4j
//@Component
//public class ConsumerProcessor {
// @Resource
// IBaseDao baseDao;
// @Autowired
// private RedisUtil redisUtil;
// @Autowired
// private KylinUtils kylinUtils;
//
//
// private void consumerSqlDaoHandler(Message msg, Channel channel) {
// MessageProperties properties = msg.getMessageProperties();
// String consumerQueue = properties.getConsumerQueue();
// long deliveryTag = properties.getDeliveryTag();
// SqlMapping.SqlMessage sqlMessage = JsonUtils.fromJson(new String(msg.getBody()), SqlMapping.SqlMessage.class);
// try {
// Boolean rstBatchSqls = baseDao.batchSqls(sqlMessage.getSqls(), sqlMessage.getArgs());
// if (rstBatchSqls) {
// channel.basicAck(deliveryTag, false);
// } else {
// log.warn("###CONSUMER SQL[consumerQueue:{},deliveryTag={},sqlMessage:{}]", consumerQueue, deliveryTag, JsonUtils.toJson(sqlMessage));
// channel.basicAck(deliveryTag, false);
// }
// } catch (IOException e) {
// log.error("CONSUMER SQL[consumerQueue:{},deliveryTag:{},sqlMessage:{}]", consumerQueue, deliveryTag, JsonUtils.toJson(sqlMessage), e);
// }
// }
//
// // 处理长sql语句
// private void consumerOperationOrderClose(Message msg, Channel channel) {
// MessageProperties properties = msg.getMessageProperties();
// String consumerQueue = properties.getConsumerQueue();
// long deliveryTag = properties.getDeliveryTag();
// String jsonStr = StringEscapeUtils.unescapeJava(new String(msg.getBody()));
// OrderCloseMapping.orderCloseMessage mqMessage = JsonUtils.fromJson(jsonStr.substring(1, jsonStr.length() - 1), OrderCloseMapping.orderCloseMessage.class);
// try {
// for (int x = 0; x< mqMessage.getOrderTicketIds().size(); x++) {
// String t = mqMessage.getOrderTicketIds().get(x);
// String orderTicketId = t.split(",")[0];
// String uid = t.split(",")[1];
// KylinOrderTicketVo vo = kylinUtils.getOrderTicketVo(orderTicketId);
// vo.setStatus(2);
// redisUtil.set("kylin:order:id:" + orderTicketId, vo);
//
// kylinUtils.resetOrderListVo(uid, 2, orderTicketId, vo);
// // redis 限购
// for (int i = 0; i < vo.getEntitiesVoList().size(); i++) {
// KylinOrderTicketEntitiesVo items = vo.getEntitiesVoList().get(i);
// kylinUtils.changeBuyInfo(items.getUserId(), items.getEnterIdCode(), items.getPerformanceId(), items.getTicketId(), -1);
// }
// }
// channel.basicAck(deliveryTag, false);
// } catch (Exception e) {
// log.error("CONSUMER SQL[consumerQueue:{},deliveryTag:{},sqlMessage:{}]", consumerQueue, deliveryTag, JsonUtils.toJson(mqMessage), e);
// }
// }
//
// // 验票更新
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EX_LNS_SQL_STATION), key = MQConst.RK_SQL_STATION,
// value = @Queue(MQConst.QUEUES_SQL_STATION)
// ))
// public void consumerSqlForStation(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// // 订单创建
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate1(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate2(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate3(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate4(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate5(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate6(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate7(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate8(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CREADE), key = MQConst.ROUTING_KEY_SQL_ORDER_CREATE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CREATE)
// ))
// public void consumerOrderCreate9(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// // 订单再次支付
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_AGAIN), key = MQConst.ROUTING_KEY_SQL_ORDER_AGAIN,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_AGAIN)
// ))
// public void consumerOrderPayAgain(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// // 订单关闭
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose1(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose2(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose3(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose4(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose5(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose6(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose7(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose8(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_CLOSE), key = MQConst.ROUTING_KEY_SQL_ORDER_CLOSE,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_CLOSE)
// ))
// public void consumerOrderClose9(Message msg, Channel channel) {
// this.consumerOperationOrderClose(msg, channel);
// }
//
//
// // 订单支付
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay1(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay2(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay3(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay4(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay5(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay6(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay7(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay8(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
// public void consumerOrderPay9(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_PAY), key = MQConst.ROUTING_KEY_SQL_ORDER_PAY,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_PAY)
// ))
//
// // 缺票登记
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_PERFORMANCE_LACK), key = MQConst.ROUTING_KEY_SQL_PERFORMANCE_LACK,
// value = @Queue(MQConst.QUEUES_SQL_PERFORMANCE_LACK)
// ))
// public void consumerPerformanceLack(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// // 申请退款
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_REFUND), key = MQConst.ROUTING_KEY_SQL_ORDER_REFUND,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_REFUND)
// ))
// public void consumerOrderRefund(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_REFUND), key = MQConst.ROUTING_KEY_SQL_ORDER_REFUND,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_REFUND)
// ))
// public void consumerOrderRefund1(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_REFUND), key = MQConst.ROUTING_KEY_SQL_ORDER_REFUND,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_REFUND)
// ))
// public void consumerOrderRefund2(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_REFUND), key = MQConst.ROUTING_KEY_SQL_ORDER_REFUND,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_REFUND)
// ))
// public void consumerOrderRefund3(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_REFUND), key = MQConst.ROUTING_KEY_SQL_ORDER_REFUND,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_REFUND)
// ))
// public void consumerOrderRefund4(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// // 申请退款撤回
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_WITHDRAW), key = MQConst.ROUTING_KEY_SQL_ORDER_WITHDRAW,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_WITHDRAW)
// ))
// public void consumerOrderRefundWithDraw(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_WITHDRAW), key = MQConst.ROUTING_KEY_SQL_ORDER_WITHDRAW,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_WITHDRAW)
// ))
// public void consumerOrderRefundWithDraw1(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_WITHDRAW), key = MQConst.ROUTING_KEY_SQL_ORDER_WITHDRAW,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_WITHDRAW)
// ))
// public void consumerOrderRefundWithDraw2(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_WITHDRAW), key = MQConst.ROUTING_KEY_SQL_ORDER_WITHDRAW,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_WITHDRAW)
// ))
// public void consumerOrderRefundWithDraw3(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_WITHDRAW), key = MQConst.ROUTING_KEY_SQL_ORDER_WITHDRAW,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_WITHDRAW)
// ))
// public void consumerOrderRefundWithDraw4(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//
// // 超时支付申请退款
// @RabbitListener(bindings = @QueueBinding(
// exchange = @Exchange(MQConst.EXCHANGES_LIQUIDNET_SQL_ORDER_OVERTIME_REFUND), key = MQConst.ROUTING_KEY_SQL_ORDER_OVERTIME_REFUND,
// value = @Queue(MQConst.QUEUES_SQL_ORDER_OVERTIME_REFUND)
// ))
// public void consumerOrderOvertimeRefund(Message msg, Channel channel) {
// this.consumerSqlDaoHandler(msg, channel);
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/utils/GoblinNftUtils.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.utils;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.service.goblin.constant.GoblinRedisConst;
import com.liquidnet.service.goblin.dto.vo.GoblinNftOrderVo;
import com.mongodb.BasicDBObject;
import com.mongodb.client.result.UpdateResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.convert.MongoConverter;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;
@Component
public class GoblinNftUtils {
@Autowired
private RedisUtil redisUtil;
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private MongoConverter mongoConverter;
private static final BasicDBObject basicDBObject = new BasicDBObject();
// 库存
public int decrSkuStock(String skuId, Integer stock) {
String redisKey = GoblinRedisConst.REAL_STOCK_SKU.concat(skuId);
return (int) redisUtil.decr(redisKey, stock);
}
public int incrSkuStock(String skuId, Integer stock) {
String redisKey = GoblinRedisConst.REAL_STOCK_SKU.concat(skuId);
return (int) redisUtil.incr(redisKey, stock);
}
// 减少 用户sku购买个数
public int decrSkuCountByUid(String uid, String skuId, int number) {
String redisKey = GoblinRedisConst.REDIS_GOBLIN_BUY_COUNT.concat(uid + ":skuId:" + skuId);
return (int) redisUtil.decr(redisKey, number);
}
// 订单详情vo
public void setNftOrder(GoblinNftOrderVo vo) {
String redisKey = GoblinRedisConst.REDIS_GOBLIN_NFT_ORDER_INFO.concat(vo.getOrderId());
redisUtil.set(redisKey, vo);
}
// 获取 订单详情vo
public GoblinNftOrderVo getNftOrder(String orderId) {
String redisKey = GoblinRedisConst.REDIS_GOBLIN_NFT_ORDER_INFO.concat(orderId);
Object obj = redisUtil.get(redisKey);
if (obj == null) {
return null;
} else {
return (GoblinNftOrderVo) obj;
}
}
// 订单详情vo
public void setGoblinNftOrderVo(GoblinNftOrderVo vo) {
mongoTemplate.insert(vo, GoblinNftOrderVo.class.getSimpleName());
}
public UpdateResult updateGoblinNftOrderVo(GoblinNftOrderVo data) {
BasicDBObject object = cloneBasicDBObject().append("$set", mongoConverter.convertToMongoType(data));
return mongoTemplate.getCollection(GoblinNftOrderVo.class.getSimpleName()).updateOne(
Query.query(Criteria.where("orderId").is(data.getOrderId())).getQueryObject(),
object);
}
public static BasicDBObject cloneBasicDBObject() {
return (BasicDBObject) basicDBObject.clone();
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/java/com/liquidnet/service/consumer/order/utils/KylinUtils.java 0 → 100644
View file @ 17bc2a18
package com.liquidnet.service.consumer.order.utils;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.service.kylin.constant.KylinRedisConst;
import com.liquidnet.service.kylin.dto.vo.mongo.KylinOrderTicketEntitiesVo;
import com.liquidnet.service.kylin.dto.vo.mongo.KylinOrderTicketVo;
import com.liquidnet.service.kylin.dto.vo.mongo.KylinPerformanceVo;
import com.liquidnet.service.kylin.dto.vo.returns.KylinOrderListVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
@Component
public class KylinUtils {
@Autowired
private RedisUtil redisUtil;
@Autowired
private MongoTemplate mongoTemplate;
/**
* @param userId 用户id
* @param type 1新增 2修改
* @param orderId 订单id [需要新增或者修改的订单id]
*/
public Boolean resetOrderListVo(String userId, Integer type, String orderId, KylinOrderTicketVo dataSingle) {
List<KylinOrderListVo> vo = new ArrayList<>();
List<KylinOrderListVo> redisVo = new ArrayList();
KylinOrderTicketVo data = dataSingle;
KylinOrderListVo voItem = KylinOrderListVo.getNew().copy(data);
List<KylinOrderListVo> redisData = (List<KylinOrderListVo>) redisUtil.get(KylinRedisConst.ORDER_LIST + userId);
if(redisData==null){
return false;
}
if (type == 1) {
redisVo.add(voItem);
if (redisData.size() > 0) {
if (redisData.get(0).getOrderTicketsId().equals(orderId)) {
redisData.remove(0);
}
}
}
redisVo.addAll(redisData);
switch (type) {
case 1:
for (int i = 0; i < redisVo.size(); i++) {
if (i == 40) {
break;
}
if (i == 0) {
vo.add(voItem);
} else {
vo.add(redisVo.get(i));
}
}
if (redisVo.size() == 0) {
vo.add(voItem);
}
redisUtil.set(KylinRedisConst.ORDER_LIST + userId, vo);
return true;
case 2:
for (int i = 0; i < redisVo.size(); i++) {
if (i == 40) {
break;
}
if (redisVo.get(i).getOrderTicketsId().equals(orderId)) {
vo.add(voItem);
} else {
vo.add(redisVo.get(i));
}
}
redisUtil.set(KylinRedisConst.ORDER_LIST + userId, vo);
return true;
default:
return false;
}
}
public void changeBuyInfo(String userId, String idCard, String performanceId, String ticketId, int buyCount) {
String redisKey;
int isTrueName = getPerformanceIsTrueName(performanceId);
// String useTime = "";
// HashMap<String, ArrayList<String>> allTicketId = new HashMap<>();
// for (int x = 0; x < vo.getTicketTimeList().size(); x++) {
// KylinTicketTimesVo timeItem = vo.getTicketTimeList().get(x);
// ArrayList<String> ticketList = new ArrayList<>();
// for (int y = 0; y < timeItem.getTicketList().size(); y++) {
// KylinTicketVo ticketItem = timeItem.getTicketList().get(y);
// if (ticketItem.getType() == 1) {
// ticketList.add(ticketItem.getTicketsId());
// }
// if (ticketItem.getTicketsId().equals(ticketId)) {
// useTime = ticketItem.getUseStart();
// }
// }
// allTicketId.put(timeItem.getUseStart(), ticketList);
// }
if (0 == isTrueName) {
redisKey = KylinRedisConst.USERID_BUY_INFO + userId;
} else {
redisKey = KylinRedisConst.IDCARD_BUY_INFO + idCard;
}
String performanceIdKey = redisKey + ":" + KylinRedisConst.PERFORMANCE_ID + ":" + performanceId;
String ticketIdKey = redisKey + ":" + KylinRedisConst.TICKET_ID + ":" + ticketId;
// String ticketUseTimeKey = ticketIdKey + ":" + KylinRedisConst.USE_TIME;
// redisUtil.set(ticketUseTimeKey, useTime);
if (buyCount > 0) {
redisUtil.incr(ticketIdKey, buyCount);
redisUtil.incr(performanceIdKey, buyCount);
} else {
redisUtil.decr(ticketIdKey, Math.abs(buyCount));
redisUtil.decr(performanceIdKey, Math.abs(buyCount));
}
}
/**
* 根据演出id 获取 演出vo 详情
*
* @param performanceId
* @return
*/
public KylinPerformanceVo getPerformanceVo(String performanceId) {
if (redisUtil.hasKey(KylinRedisConst.PERFORMANCES + performanceId)) {
} else {
KylinPerformanceVo performanceData = mongoTemplate.findOne(Query.query(Criteria.where("performancesId").is(performanceId)), KylinPerformanceVo.class, KylinPerformanceVo.class.getSimpleName());
redisUtil.set(KylinRedisConst.PERFORMANCES + performanceId, performanceData);
}
return (KylinPerformanceVo) redisUtil.get(KylinRedisConst.PERFORMANCES + performanceId);
}
/**
* 演出是否实名
*
* @param performanceId
*/
public int getPerformanceIsTrueName(String performanceId) {
Object obj = redisUtil.get(KylinRedisConst.PERFORMANCES_TRUE_NAME + performanceId);
if (obj != null) {
return (int) obj;
} else {
int isTrueName = getPerformanceVo(performanceId).getIsTrueName();
redisUtil.set(KylinRedisConst.PERFORMANCES_TRUE_NAME + performanceId, isTrueName);
return isTrueName;
}
}
/**
* 根据订单id 获取 订单vo 详情
*
* @param orderId
* @return
*/
public KylinOrderTicketVo getOrderTicketVo(String orderId) {
if (redisUtil.hasKey(KylinRedisConst.ORDER + orderId)) {
} else {
KylinOrderTicketVo ticketData = mongoTemplate.findOne(Query.query(Criteria.where("orderTicketsId").is(orderId)), KylinOrderTicketVo.class, KylinOrderTicketVo.class.getSimpleName());
List<KylinOrderTicketEntitiesVo> kylinOrderTicketEntitiesVoList = mongoTemplate.find(Query.query(Criteria.where("orderId").is(orderId)), KylinOrderTicketEntitiesVo.class, KylinOrderTicketEntitiesVo.class.getSimpleName());
ticketData.setEntitiesVoList(kylinOrderTicketEntitiesVoList);
redisUtil.set(KylinRedisConst.ORDER + orderId, ticketData);
}
return (KylinOrderTicketVo) redisUtil.get(KylinRedisConst.ORDER + orderId);
}
}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/resources/bootstrap-dev.yml 0 → 100644
View file @ 17bc2a18
# begin-dev-这里是配置信息基本值
liquidnet:
cloudConfig:
profile: dev
security:
username: user
password: user123
eureka:
host: 39.107.71.112:7001
# end-dev-这里是配置信息基本值
spring:
profiles:
include: service-consumer-order
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/resources/bootstrap-prod.yml 0 → 100644
View file @ 17bc2a18
# begin-prod-这里是配置信息基本值
liquidnet:
cloudConfig:
profile: prod
security:
username: user
password: user123
eureka:
host: 172.17.207.189:7001
# end-prod-这里是配置信息基本值
spring:
profiles:
include: service-consumer-order
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/resources/bootstrap-service-consumer-order.yml 0 → 100644
View file @ 17bc2a18
#eurekaServer配置
eureka:
client:
register-with-eureka: true
fetch-registry: true
serviceUrl:
defaultZone: http://${liquidnet.security.username}:${liquidnet.security.password}@${liquidnet.eureka.host}/eureka-server/eureka
#configServer配置
spring:
cloud:
config:
# uri: http://127.0.0.1:7002/support-config
# uri: http://39.107.71.112:7002/support-config
profile: ${liquidnet.cloudConfig.profile}
name: ${spring.application.name} #默认为spring.application.name
discovery:
enabled: true
service-id: liquidnet-support-config
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/resources/bootstrap-test.yml 0 → 100644
View file @ 17bc2a18
# begin-test-这里是配置信息基本值
liquidnet:
cloudConfig:
profile: test
security:
username: user
password: user123
eureka:
host: 172.17.207.177:7001
#instance:
# prefer-ip-address: true
#host: eureka-test-0.eureka-test-svc.zhengzai-test:7001/eureka-server/eureka,eureka-test-1.eureka-test-svc.zhengzai-test:7001/eureka-server/eureka,eureka-test-2.eureka-test-svc.zhengzai-test:7001/eureka-server/eureka
#host: 192.168.193.41:7001
# end-test-这里是配置信息基本值
spring:
profiles:
include: service-consumer-order
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/resources/bootstrap.yml 0 → 100644
View file @ 17bc2a18
spring:
application:
name: liquidnet-service-consumer-order
profiles:
active: dev
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-order/src/main/resources/sqlmap.properties 0 → 100644
View file @ 17bc2a18
#---- 订单关闭
goblin_order.close.order=UPDATE goblin_store_order SET status = ? ,updated_at = ? , cancel_time = ? , cancel_reason=? WHERE order_id = ? and (updated_at <= ? or created_at = ? or updated_at is null)
goblin_order.close.sku=UPDATE goblin_order_sku SET status = ? ,updated_at = ? WHERE order_sku_id = ? and (updated_at <= ? or created_at = ? or updated_at is null)
goblin_user_coupon.updateState=UPDATE goblin_user_coupon SET state = ? , used_for = ? ,updated_at = ? where ucoupon_id = ?
#-------- NFT -------
goblin_nft_order.update.close=UPDATE goblin_nft_order SET status = ?, updated_at = ?, cancel_time = ?, cancel_reason = ? WHERE order_id = ? and (updated_at <= ? or created_at = ? or updated_at is null)
#---- 兑换码操作
goblin_activity.code.admin=UPDATE goblin_nft_ex_code SET admin_uid = ? where code = ?
\ No newline at end of file
liquidnet-bus-service/liquidnet-service-consumer-all/pom.xml
View file @ 17bc2a18
......@@ -17,6 +17,7 @@
<module>liquidnet-service-consumer-sweet</module>
<module>liquidnet-service-consumer-stone</module>
<module>liquidnet-service-consumer-candy</module>
<module>liquidnet-service-consumer-order</module>
</modules>
<dependencies>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment