springboot的redis队列监听推送websocket失效

开发环境redis监听队列能监听到，但到了线上环境，redis监听器失效，采用jredis进行订阅反而监听到了，纳闷？
RedisConfig配置编码
package cn.gov.sztobacco.cishop.business.config;

import java.time.Duration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;

import org.jflame.toolkit.cache.RedisClient;
import org.jflame.toolkit.cache.SpringCacheClientImpl;

import cn.gov.sztobacco.cishop.support.MyCacheKeyGenerator;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

@Autowired
private JedisConnectionFactory redisConnectionFactory;

@Override
@Bean
public CacheManager cacheManager() {
    // StringRedisSerializer keySerializer = new StringRedisSerializer();
    GenericFastJsonRedisSerializer valueSerializer = new GenericFastJsonRedisSerializer();
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
    // config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer));
    config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer));
    // 设置缓存的默认过期时间
    config.entryTtl(Duration.ofHours(2));
    config.prefixKeysWith(MyCacheKeyGenerator.KEY_PREFIX);
    config.disableCachingNullValues();
    RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
            .cacheDefaults(config)
            .build();
    return cacheManager;

}

@Override
public KeyGenerator keyGenerator() {
    return new MyCacheKeyGenerator();
}

@Bean
public RedisTemplate<String,?> redisTemplate() {
    // 配置redisTemplate
    RedisTemplate<String,?> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(redisConnectionFactory);

    StringRedisSerializer stringSerializer = new StringRedisSerializer();
    GenericFastJsonRedisSerializer valueSerializer = new GenericFastJsonRedisSerializer();
    redisTemplate.setKeySerializer(stringSerializer); // key序列化
    redisTemplate.setHashKeySerializer(stringSerializer);
    redisTemplate.setValueSerializer(valueSerializer);
    redisTemplate.setHashValueSerializer(valueSerializer);
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
}

@Bean
public RedisMessageListener redisMessageListener() {
    return new RedisMessageListener();
}

@Bean
public ChannelTopic orderTopic() {
    return new ChannelTopic("ORDER");
}

@Bean
public ChannelTopic appTopic() {
    return new ChannelTopic("APP");
}

@Bean
public ChannelTopic machineTopic() {
    return new ChannelTopic("MACHINE");
}

@Bean
public ChannelTopic brandTopic() {
    return new ChannelTopic("BRAND");
}

@Bean
public ChannelTopic goodsTopic() {
    return new ChannelTopic("GOODS");
}

@Bean
public ChannelTopic actualOrderTopic() {
    return new ChannelTopic("ACTUALORDER");
}

@Bean
public ChannelTopic entryTopic() {
    return new ChannelTopic("ENTRY");
}

@Bean
public ChannelTopic messageTopic() {
    return new ChannelTopic("MESSAGE");
}

/* @Bean
public RedisMessageListenerContainer redisMessageListenerContainer() {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(redisConnectionFactory);
    List<ChannelTopic> topics = new ArrayList<>(6);
    topics.add(orderTopic());
    topics.add(machineTopic());
    topics.add(brandTopic());
    topics.add(goodsTopic());
    topics.add(appTopic());
    topics.add(entryTopic());
    topics.add(messageTopic());
    container.addMessageListener(redisMessageListener(), topics);
   
    return container;
}*/

@Bean
public RedisClient redisClient() {

    RedisClient redisClient = new SpringCacheClientImpl(redisConnectionFactory);
    /*JedisPoolConfig poolCfg = new JedisPoolConfig();
    poolCfg.setMaxTotal(500);
    poolCfg.setMaxIdle(1);
    
    // jedis
    JedisConnection jedisConn = new JedisConnection("127.0.0.1", 11, poolCfg);
    jedisConn.init();
    RedisClient redisClient = new JedisClientImpl(jedisConn);*/
    return redisClient;
}

}
在XXXApplication主类进行注入jredis主动订阅队列
package cn.gov.sztobacco.cishop;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.redis.connection.jedis.JedisConnection;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.ghgcn.support.spring.SpringContextHolder;

import cn.gov.sztobacco.cishop.business.config.JedisPus;
import redis.clients.jedis.Jedis;

@SpringBootApplication
@EnableTransactionManagement
public class Application {

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

    JedisConnectionFactory redisConnectionFactory = SpringContextHolder.getBean(JedisConnectionFactory.class);
    JedisConnection conn = (JedisConnection) redisConnectionFactory.getConnection();
    Jedis jedis = conn.getJedis();
    jedis.subscribe(new JedisPus(), new String[] { "ORDER","MACHINE","GOODS","BRAND","APP","ENTRY","MESSAGE" });
}

}