x

build.gradle

@@ -93,9 +93,6 @@ subprojects {
         compile('org.springframework.boot:spring-boot-starter-undertow')
         compile('org.springframework.boot:spring-boot-starter-jdbc')
         compile('org.springframework.boot:spring-boot-starter-cache')
-        compile("org.springframework.session:spring-session-data-redis")
-        compile('org.springframework.boot:spring-boot-starter-data-redis')
-        compile('redis.clients:jedis:2.9.0')
 
         compile('org.springframework.cloud:spring-cloud-starter-netflix-eureka-server')
         compile('org.springframework.cloud:spring-cloud-starter-openfeign')

eureka-core/build.gradle

@@ -13,4 +13,5 @@ repositories {
 
 dependencies {
     testCompile group: 'junit', name: 'junit', version: '4.12'
+    compile 'org.springframework.boot:spring-boot-starter-data-redis-reactive'
 }

eureka-web/src/main/java/cn/gygxzc/cloud/tina/eureka/config/RedisAutoConfiguration.java

@@ -1,68 +0,0 @@
-package cn.gygxzc.cloud.tina.eureka.config;
-
-import com.fasterxml.jackson.annotation.JsonTypeInfo;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
-import org.springframework.boot.context.properties.EnableConfigurationProperties;
-import org.springframework.cache.CacheManager;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Primary;
-import org.springframework.data.redis.cache.RedisCacheManager;
-import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.data.redis.core.RedisOperations;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.data.redis.core.StringRedisTemplate;
-import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
-import org.springframework.data.redis.serializer.StringRedisSerializer;
-
-import java.text.SimpleDateFormat;
-
-/**
- * Created by niantuo on 2018/11/1.
- * redis 缓存配置
- */
-@Configuration
-@ConditionalOnClass(RedisOperations.class)
-@EnableConfigurationProperties(RedisProperties.class)
-public class RedisAutoConfiguration {
-
-
-    @Primary
-    @Bean("redisCacheManager")
-    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
-        return RedisCacheManager.create(connectionFactory);
-
-    }
-
-    @Primary
-    @Bean("redisTemplate")
-    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
-        RedisTemplate<Object, Object> template = new RedisTemplate<>();
-        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
-        template.setKeySerializer(stringRedisSerializer);
-        template.setHashKeySerializer(stringRedisSerializer);
-
-
-        ObjectMapper objectMapper = new ObjectMapper();
-        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
-        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
-
-        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer(objectMapper);
-        template.setValueSerializer(jsonRedisSerializer);
-        template.setHashValueSerializer(jsonRedisSerializer);
-        template.setConnectionFactory(redisConnectionFactory);
-        return template;
-    }
-
-    @Bean
-    @Primary
-    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
-        StringRedisTemplate template = new StringRedisTemplate();
-        template.setConnectionFactory(redisConnectionFactory);
-        return template;
-    }
-
-
-}

eureka-web/src/main/java/cn/gygxzc/cloud/tina/eureka/config/redis/JedisConnectionConfiguration.java

@@ -1,126 +0,0 @@
-package cn.gygxzc.cloud.tina.eureka.config.redis;
-
-import org.apache.commons.pool2.impl.GenericObjectPool;
-import org.springframework.beans.factory.ObjectProvider;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.autoconfigure.data.redis.JedisClientConfigurationBuilderCustomizer;
-import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
-import org.springframework.boot.context.properties.EnableConfigurationProperties;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Primary;
-import org.springframework.data.redis.connection.RedisClusterConfiguration;
-import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.data.redis.connection.RedisSentinelConfiguration;
-import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
-import org.springframework.data.redis.connection.jedis.JedisConnection;
-import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
-import org.springframework.util.StringUtils;
-import redis.clients.jedis.Jedis;
-import redis.clients.jedis.JedisPoolConfig;
-
-import java.time.Duration;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * Created by niantuo on 2018/11/1.
- * Jedis 配置
- */
-
-@Configuration
-@EnableConfigurationProperties(RedisProperties.class)
-@ConditionalOnClass({GenericObjectPool.class, JedisConnection.class, Jedis.class})
-public class JedisConnectionConfiguration extends RedisConnectionConfiguration {
-
-    private final RedisProperties properties;
-
-    private final List<JedisClientConfigurationBuilderCustomizer> builderCustomizers;
-
-    JedisConnectionConfiguration(RedisProperties properties,
-                                 ObjectProvider<RedisSentinelConfiguration> sentinelConfiguration,
-                                 ObjectProvider<RedisClusterConfiguration> clusterConfiguration,
-                                 ObjectProvider<List<JedisClientConfigurationBuilderCustomizer>> builderCustomizers) {
-        super(properties, sentinelConfiguration, clusterConfiguration);
-        this.properties = properties;
-        this.builderCustomizers = builderCustomizers
-                .getIfAvailable(Collections::emptyList);
-    }
-
-    @Bean
-    @Primary
-    public RedisConnectionFactory redisConnectionFactory() {
-        return createJedisConnectionFactory();
-    }
-
-    private JedisConnectionFactory createJedisConnectionFactory() {
-        JedisClientConfiguration clientConfiguration = getJedisClientConfiguration();
-        if (getSentinelConfig() != null) {
-            return new JedisConnectionFactory(getSentinelConfig(), clientConfiguration);
-        }
-        if (getClusterConfiguration() != null) {
-            return new JedisConnectionFactory(getClusterConfiguration(),
-                    clientConfiguration);
-        }
-        return new JedisConnectionFactory(getStandaloneConfig(), clientConfiguration);
-    }
-
-    private JedisClientConfiguration getJedisClientConfiguration() {
-        JedisClientConfiguration.JedisClientConfigurationBuilder builder = applyProperties(
-                JedisClientConfiguration.builder());
-        RedisProperties.Pool pool = this.properties.getJedis().getPool();
-        if (pool != null) {
-            applyPooling(pool, builder);
-        }
-        if (StringUtils.hasText(this.properties.getUrl())) {
-            customizeConfigurationFromUrl(builder);
-        }
-        customize(builder);
-        return builder.build();
-    }
-
-    private JedisClientConfiguration.JedisClientConfigurationBuilder applyProperties(
-            JedisClientConfiguration.JedisClientConfigurationBuilder builder) {
-        if (this.properties.isSsl()) {
-            builder.useSsl();
-        }
-        if (this.properties.getTimeout() != null) {
-            Duration timeout = this.properties.getTimeout();
-            builder.readTimeout(timeout).connectTimeout(timeout);
-        }
-        return builder;
-    }
-
-    private void applyPooling(RedisProperties.Pool pool,
-                              JedisClientConfiguration.JedisClientConfigurationBuilder builder) {
-        builder.usePooling().poolConfig(jedisPoolConfig(pool));
-    }
-
-    private JedisPoolConfig jedisPoolConfig(RedisProperties.Pool pool) {
-        JedisPoolConfig config = new JedisPoolConfig();
-        config.setMaxTotal(pool.getMaxActive());
-        config.setMaxIdle(pool.getMaxIdle());
-        config.setMinIdle(pool.getMinIdle());
-        if (pool.getMaxWait() != null) {
-            config.setMaxWaitMillis(pool.getMaxWait().toMillis());
-        }
-        return config;
-    }
-
-    private void customizeConfigurationFromUrl(
-            JedisClientConfiguration.JedisClientConfigurationBuilder builder) {
-        RedisConnectionConfiguration.ConnectionInfo connectionInfo = parseUrl(this.properties.getUrl());
-        if (connectionInfo.isUseSsl()) {
-            builder.useSsl();
-        }
-    }
-
-    private void customize(
-            JedisClientConfiguration.JedisClientConfigurationBuilder builder) {
-        for (JedisClientConfigurationBuilderCustomizer customizer : this.builderCustomizers) {
-            customizer.customize(builder);
-        }
-    }
-
-
-}

eureka-web/src/main/java/cn/gygxzc/cloud/tina/eureka/config/redis/RedisConnectionConfiguration.java

@@ -1,157 +0,0 @@
-package cn.gygxzc.cloud.tina.eureka.config.redis;
-
-import org.springframework.beans.factory.ObjectProvider;
-import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
-import org.springframework.data.redis.connection.*;
-import org.springframework.util.Assert;
-import org.springframework.util.StringUtils;
-
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Created by niantuo on 2018/11/1.
- * 完全的抄袭源代码
- */
-
-public class RedisConnectionConfiguration {
-
-    private final RedisProperties properties;
-
-    private final RedisSentinelConfiguration sentinelConfiguration;
-
-    private final RedisClusterConfiguration clusterConfiguration;
-
-    protected RedisConnectionConfiguration(RedisProperties properties,
-                                           ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider,
-                                           ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider) {
-        this.properties = properties;
-        this.sentinelConfiguration = sentinelConfigurationProvider.getIfAvailable();
-        this.clusterConfiguration = clusterConfigurationProvider.getIfAvailable();
-    }
-
-    protected final RedisStandaloneConfiguration getStandaloneConfig() {
-        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
-        if (StringUtils.hasText(this.properties.getUrl())) {
-            ConnectionInfo connectionInfo = parseUrl(this.properties.getUrl());
-            config.setHostName(connectionInfo.getHostName());
-            config.setPort(connectionInfo.getPort());
-            config.setPassword(RedisPassword.of(connectionInfo.getPassword()));
-        } else {
-            config.setHostName(this.properties.getHost());
-            config.setPort(this.properties.getPort());
-            config.setPassword(RedisPassword.of(this.properties.getPassword()));
-        }
-        config.setDatabase(this.properties.getDatabase());
-        return config;
-    }
-
-    protected final RedisSentinelConfiguration getSentinelConfig() {
-        if (this.sentinelConfiguration != null) {
-            return this.sentinelConfiguration;
-        }
-        RedisProperties.Sentinel sentinelProperties = this.properties.getSentinel();
-        if (sentinelProperties != null) {
-            RedisSentinelConfiguration config = new RedisSentinelConfiguration();
-            config.master(sentinelProperties.getMaster());
-            config.setSentinels(createSentinels(sentinelProperties));
-            if (this.properties.getPassword() != null) {
-                config.setPassword(RedisPassword.of(this.properties.getPassword()));
-            }
-            config.setDatabase(this.properties.getDatabase());
-            return config;
-        }
-        return null;
-    }
-
-    /**
-     * Create a {@link RedisClusterConfiguration} if necessary.
-     *
-     * @return {@literal null} if no cluster settings are set.
-     */
-    protected final RedisClusterConfiguration getClusterConfiguration() {
-        if (this.clusterConfiguration != null) {
-            return this.clusterConfiguration;
-        }
-        if (this.properties.getCluster() == null) {
-            return null;
-        }
-        RedisProperties.Cluster clusterProperties = this.properties.getCluster();
-        RedisClusterConfiguration config = new RedisClusterConfiguration(
-                clusterProperties.getNodes());
-        if (clusterProperties.getMaxRedirects() != null) {
-            config.setMaxRedirects(clusterProperties.getMaxRedirects());
-        }
-        if (this.properties.getPassword() != null) {
-            config.setPassword(RedisPassword.of(this.properties.getPassword()));
-        }
-        return config;
-    }
-
-    private List<RedisNode> createSentinels(RedisProperties.Sentinel sentinel) {
-        List<RedisNode> nodes = new ArrayList<>();
-        for (String node : sentinel.getNodes()) {
-            try {
-                String[] parts = StringUtils.split(node, ":");
-                Assert.state(parts.length == 2, "Must be defined as 'host:port'");
-                nodes.add(new RedisNode(parts[0], Integer.valueOf(parts[1])));
-            } catch (RuntimeException ex) {
-                throw new IllegalStateException(
-                        "Invalid redis sentinel " + "property '" + node + "'", ex);
-            }
-        }
-        return nodes;
-    }
-
-    protected ConnectionInfo parseUrl(String url) {
-        try {
-            URI uri = new URI(url);
-            boolean useSsl = (url.startsWith("rediss://"));
-            String password = null;
-            if (uri.getUserInfo() != null) {
-                password = uri.getUserInfo();
-                int index = password.indexOf(':');
-                if (index >= 0) {
-                    password = password.substring(index + 1);
-                }
-            }
-            return new ConnectionInfo(uri, useSsl, password);
-        } catch (URISyntaxException ex) {
-            throw new IllegalArgumentException("Malformed url '" + url + "'", ex);
-        }
-    }
-
-    protected static class ConnectionInfo {
-
-        private final URI uri;
-
-        private final boolean useSsl;
-
-        private final String password;
-
-        public ConnectionInfo(URI uri, boolean useSsl, String password) {
-            this.uri = uri;
-            this.useSsl = useSsl;
-            this.password = password;
-        }
-
-        public boolean isUseSsl() {
-            return this.useSsl;
-        }
-
-        public String getHostName() {
-            return this.uri.getHost();
-        }
-
-        public int getPort() {
-            return this.uri.getPort();
-        }
-
-        public String getPassword() {
-            return this.password;
-        }
-
-    }
-}

eureka-web/src/main/resources/application-sit.yml

@@ -22,4 +22,4 @@ eureka:
     ip-address: 192.168.42.1
   client:
     service-url:
-      defaultZone: http://192.168.42.1:${server.port}/eureka/
+      defaultZone: http://config.tonyandmoney.cn/eureka/

eureka-web/src/main/resources/application.yml

@@ -58,15 +58,15 @@ eureka:
     prefer-ip-address: true
     lease-renewal-interval-in-seconds: 15
     lease-expiration-duration-in-seconds: 32
-    ip-address: 192.168.42.11
     metadata-map:
       startup: ${random.int}
       tags: config
+    ip-address: 127.0.0.1
   client:
     register-with-eureka: true
     fetch-registry: true
     service-url:
-      defaultZone: http://envir:envir@${eureka.instance.ip-address}:${server.port}/eureka/
+      defaultZone: http://${eureka.instance.ip-address}:${server.port}/eureka/
     registry-fetch-interval-seconds: 5
     instance-info-replication-interval-seconds: 20
     initial-instance-info-replication-interval-seconds: 45