<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns="http://www.springframework.org/schema/beans"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xmlns:tx="http://www.springframework.org/schema/tx"

    xsi:schemaLocation="http://www.springframework.org/schema/beans 
　　http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
　　http://www.springframework.org/schema/context 
　　http://www.springframework.org/schema/context/spring-context-3.0.xsd 
　　http://www.springframework.org/schema/aop 
　　http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
　　http://www.springframework.org/schema/tx 
　　http://www.springframework.org/schema/tx/spring-tx-3.0.xsd ">

    <bean id="propertyConfigurer" class="utils.XmlPropertyPlaceholderSupport">

        <property name="location" value="classpath:redis.properties" />

    </bean>

    <!-- redis pool -->

    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">

        <property name="maxTotal" value="${redis.maxTotal}" />

        <property name="maxIdle" value="${redis.maxIdle}" />

        <property name="testOnBorrow" value="${redis.testOnBorrow}" />

    </bean>

    <!-- redis pool config -->

    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">

        <property name="hostName" value="${redis.host}"></property>

        <property name="port" value="${redis.port}"></property>

        <property name="password" value="${redis.password}"></property>

        <property name="poolConfig" ref="poolConfig"></property>

    </bean>

    <!--redis redisTemplate -->

    <bean id="redisTemplate" class="utils.RedisHelper">

        <property name="connectionFactory" ref="jedisConnectionFactory" />

        <property name="keySerializer">

            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />

        </property>

        <property name="valueSerializer">

            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />

        </property>

        <property name="hashKeySerializer">

            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />

        </property>

        <property name="hashValueSerializer">

            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />

        </property>

        <property name="enableTransactionSupport" value="true"></property>

    </bean>

    <bean id="redisMessageListener" class="service.RedisSub">

        <property name="redisTemplate" ref="redisTemplate" />

    </bean>

    <bean id="redisMessageListenerContainer"

        class="org.springframework.data.redis.listener.RedisMessageListenerContainer"

        destroy-method="destroy">

        <property name="connectionFactory" ref="jedisConnectionFactory" />

        <property name="taskExecutor">

            <bean class="org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler">

                <property name="poolSize" value="10" />

            </bean>

        </property>

        <property name="messageListeners">

            <map>

                <entry key-ref="redisMessageListener">

                    <list>

                        <bean

                            class="org.springframework.data.redis.listener.ChannelTopic">

                            <constructor-arg value="cfd_md" />

                        </bean>

                        <!-- <bean class="org.springframework.data.redis.listener.PatternTopic">

                            <constructor-arg value="chat*" /> </bean> -->

                    </list>

                </entry>

            </map>

        </property>

    </bean>

</beans>

redis.hostpro=r-3ns15cdbd110c9c4.redis.rds.aliyuncs.com

redis.portpro=6379

redis.passwordpro=abc

redis.hostbeta=127.0.0.1

redis.portbeta=6379

redis.passwordbeta=abc

redis.hostlocal=47.244.48.230

redis.portlocal=6379

redis.passwordlocal=abc

redis.timeout=10000

redis.maxIdle=1

redis.maxTotal=5

redis.maxWaitMillis=10000

redis.minEvictableIdleTimeMillis=300000

redis.numTestsPerEvictionRun=1024

redis.timeBetweenEvictionRunsMillis=30000

redis.testOnBorrow=true

redis.testWhileIdle=true

#redis.sentinel.host1=172.20.1.230

#redis.sentinel.port1=26379

#redis.sentinel.host2=172.20.1.231

#redis.sentinel.port2=26379

#redis.sentinel.host3=172.20.1.232

#redis.sentinel.port3=26379

package com.oy;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.cache.annotation.CachingConfigurerSupport;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.MessageListener;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.listener.ChannelTopic;

import org.springframework.data.redis.listener.RedisMessageListenerContainer;

import org.springframework.data.redis.listener.Topic;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

@Configuration

public class RedisConfig extends CachingConfigurerSupport {

    public static final Logger log = LoggerFactory.getLogger(RedisConfig.class);

    @Bean

    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisSerializer<String> redisSerializer = new StringRedisSerializer();

        // RedisTemplate

        RedisTemplate<String, Object> template = new RedisTemplate<>();

        template.setConnectionFactory(factory);

        template.setKeySerializer(redisSerializer);

        template.setValueSerializer(redisSerializer);

        template.setHashKeySerializer(redisSerializer);

        template.setHashValueSerializer(redisSerializer);

        template.afterPropertiesSet();

        return template;

    }

    @Bean(destroyMethod = "destroy")

    public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory factory,

            MessageListener redisMessageListener) {

        RedisMessageListenerContainer container = new RedisMessageListenerContainer();

        container.setConnectionFactory(factory);

        ThreadPoolTaskScheduler taskExecutor = new ThreadPoolTaskScheduler();

        taskExecutor.setPoolSize(10);

        taskExecutor.initialize();

        container.setTaskExecutor(taskExecutor);

        Map<MessageListener, Collection<? extends Topic>> listeners = new HashMap<>();

        List<Topic> list = new ArrayList<>();

        list.add(new ChannelTopic("cfd_md"));

        listeners.put(redisMessageListener, list);

        container.setMessageListeners(listeners);

        return container;

    }

}

#spring.profiles.active=beta

spring.profiles.active=local

logging.file=/home/wwwlogs/xxx/log.log

#redis
spring.redis.host=127.0.0.1

spring.redis.port=6379

spring.redis.password=xxx

spring.redis.jedis.pool.maxActive=8

spring.redis.jedis.pool.max-idle=8

spring.redis.jedis.pool.min-idle=0

spring.redis.timeout=0