es,mongo,redis-cofig

package com.logapi.monitor.common.config;


import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig.Builder;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.message.BasicHeader;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Autowire;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import sun.misc.BASE64Encoder;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
* @author: ganchao
* @description:   RestClient方式連接ES
* @date: 2019/7/26 8:07
* @param:
* @return:
*/
@Configuration
@Slf4j
public class ElasticSearchRestClientConfig {
    @Value("${es.cluster-nodes}")
    private String nodes;
    @Value("${es.newcluster-nodes}")
    private String newnodes;
    private String schema = "http";
    private int connectTimeOut = 1000;
    private int socketTimeOut = 30000;
    private int connectionRequestTimeOut = 500;
    private int maxConnectNum = 100;
    private int maxConnectPerRoute = 100;
    private boolean uniqueConnectTimeConfig = true;
    private boolean uniqueConnectNumConfig = true;
    private RestClientBuilder builder;
    private RestHighLevelClient client;

    private RestClientBuilder newBuilder;
    private RestHighLevelClient newClient;

    private String newESUserName = "admin";
    private String newESUserPassWord = "Cmb%2019";

    /**
     * Bean name default  函數名字
     *0
     * @return
     */
    @Bean(autowire = Autowire.BY_NAME, name = "restHighLevelClient")
    public RestHighLevelClient client() {

        try {
            List<HttpHost> httpHosts = new ArrayList<>();
            String[] nodeArray = nodes.split(";");
            for (String node : nodeArray)
            {
                String host = node.split(":")[0];
                int port = Integer.valueOf(node.split(":")[1]);
                HttpHost httpHost = new HttpHost(host, port, schema);
                httpHosts.add(httpHost);
            }
            builder = RestClient.builder(httpHosts.toArray(new HttpHost[0]));

            if (uniqueConnectTimeConfig) {
                setConnectTimeOutConfig();
            }
            if (uniqueConnectNumConfig) {
                setMutiConnectConfig();
            }
            client = new RestHighLevelClient(builder);
            return client;
        } catch (NumberFormatException e) {
            e.printStackTrace();
            log.error("es客戶端連接失敗");
        }
        return null;
    }

    @Bean(autowire = Autowire.BY_NAME, name = "restHighLevelClientNew")
    public RestHighLevelClient newClient() {

        try {
            List<HttpHost> httpHosts = new ArrayList<>();
            String[] nodeArray = newnodes.split(";");
            for (String node : nodeArray)
            {
                String host = node.split(":")[0];
                int port = Integer.valueOf(node.split(":")[1]);
                HttpHost httpHost = new HttpHost(host, port, schema);
                httpHosts.add(httpHost);
            }

            final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
            credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials(newESUserName,newESUserPassWord));
            newBuilder = RestClient.builder(httpHosts.toArray(new HttpHost[0]))
             .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                                              @Override
                                              public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpAsyncClientBuilder) {
                                                  return httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                                              }
                                          });
            String auth = new BASE64Encoder().encode((newESUserName + ":" + newESUserPassWord).getBytes());
            newBuilder.setDefaultHeaders(new BasicHeader[]{new BasicHeader("Authorization", "Basic " + auth)});

            if (uniqueConnectTimeConfig) {
                setNewConnectTimeOutConfig();
            }
            if (uniqueConnectNumConfig) {
                setNewMutiConnectConfig();
            }
            newClient = new RestHighLevelClient(newBuilder);
            return newClient;
        } catch (NumberFormatException e) {
            e.printStackTrace();
            log.error("新es客戶端連接失敗");
        }
        return null;
    }

    /**
     * 異步httpclient的連接延時配置
     */
    public void setConnectTimeOutConfig() {
        builder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
            @Override
            public Builder customizeRequestConfig(Builder requestConfigBuilder) {
                requestConfigBuilder.setConnectTimeout(connectTimeOut);
                requestConfigBuilder.setSocketTimeout(socketTimeOut);
                requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeOut);
                return requestConfigBuilder;
            }
        });
    }

    public void setNewConnectTimeOutConfig() {
        newBuilder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
            @Override
            public Builder customizeRequestConfig(Builder requestConfigBuilder) {
                requestConfigBuilder.setConnectTimeout(connectTimeOut);
                requestConfigBuilder.setSocketTimeout(socketTimeOut);
                requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeOut);
                return requestConfigBuilder;
            }
        });
    }


    /**
     * 異步httpclient的連接數配置
     */
    public void setMutiConnectConfig() {
        builder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                httpClientBuilder.setMaxConnTotal(maxConnectNum);
                httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
                return httpClientBuilder;
            }
        });
    }

    public void setNewMutiConnectConfig() {
        newBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                httpClientBuilder.setMaxConnTotal(maxConnectNum);
                httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
                return httpClientBuilder;
            }
        });
    }

    /**
     * 關閉連接
     */
    public void close() {
        if (client != null) {
            try {
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

package com.logapi.monitor.common.config;

import com.mongodb.MongoClient;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.convert.*;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;

@Configuration
public class MongoClientConfig {
    @Value("${mongodb.HMongoHost}")
    private String host;
    @Value("${mongodb.HMongoport}")
    private int port;

    @Bean
    public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory, MongoMappingContext context, BeanFactory beanFactory) {
        DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
        MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);
        try {   mappingConverter.setCustomConversions(beanFactory.getBean(CustomConversions.class));
        } catch (NoSuchBeanDefinitionException ignore) {
        }
        // Don't save _class to mongo
        mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));

        return mappingConverter;
    }

    @Bean
    public MongoClient mongoClient(){
        return new MongoClient(host,port);
    }
}

 

package com.logapi.monitor.common.config;

import com.mongodb.MongoClient;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.core.convert.*;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;


public class MongoConfig {

    /** @deprecated */
    @Deprecated
    public MongoTemplate getMongoTemplate(String mongoHost, int mongoPort, String database){
        // remove _class
        MongoDbFactory factory = new SimpleMongoDbFactory(new MongoClient(mongoHost,mongoPort), database);
        MappingMongoConverter converter =
                new MappingMongoConverter(factory, new MongoMappingContext());
        converter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return new MongoTemplate(factory,converter);
    }

    /** @deprecated */
    @Deprecated
    public static MongoTemplate getNewMongoTemplate(String mongoHost, int mongoPort, String database){
        // remove _class
        MongoDbFactory factory = new SimpleMongoDbFactory(new MongoClient(mongoHost,mongoPort), database);
        DefaultDbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
        MongoMappingContext mappingContext = new MongoMappingContext();
        MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, mappingContext);
        //List<Object> list = new ArrayList<>();
        //list.add(new BigDecimalToDecimal128Converter());//自定義的類型轉換器
        //list.add(new Decimal128ToBigDecimalConverter());//自定義的類型轉換器
        //converter.setCustomConversions(new MongoCustomConversions(list));
        converter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return new MongoTemplate(factory,converter);
    }

    public static MongoTemplate getNewMongoTemplate(MongoClient mongoClient, String database){
        // remove _class
        MongoDbFactory factory = new SimpleMongoDbFactory(mongoClient, database);
        DefaultDbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
        MongoMappingContext mappingContext = new MongoMappingContext();
        MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, mappingContext);
        //List<Object> list = new ArrayList<>();
        //list.add(new BigDecimalToDecimal128Converter());//自定義的類型轉換器
        //list.add(new Decimal128ToBigDecimalConverter());//自定義的類型轉換器
        //converter.setCustomConversions(new MongoCustomConversions(list));
        converter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return new MongoTemplate(factory,converter);
    }


}

package com.logapi.monitor.common.config;

import com.logapi.monitor.common.util.RedisUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;

@Configuration
public class RedisConfig {

    @Value("${spring.redis.jedis.pool.max-idle}")
    private Integer maxIdle;

    @Value("${spring.redis.jedis.pool.max-active}")
    private Integer maxTotal;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private Integer maxWaitMillis;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.cluster.nodes}")
    private String clusterNodes;

    @Value("${spring.redis.cluster.max-redirects}")
    private Integer mmaxRedirectsac;

    /**
     * JedisPoolConfig 連接池
     *
     * @return
     */
    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大空閒數
        jedisPoolConfig.setMaxIdle(maxIdle);
        // 連接池的最大數據庫連接數
        jedisPoolConfig.setMaxTotal(maxTotal);
        // 最大建立連接等待時間
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        // 逐出連接的最小空閒時間 默認1800000毫秒(30分鐘)
        //jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        // 每次逐出檢查時 逐出的最大數目 如果爲負數就是 : 1/abs(n), 默認3
        //jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
        // 逐出掃描的時間間隔(毫秒) 如果爲負數,則不運行逐出線程, 默認-1
        //jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        // 是否在從池中取出連接前進行檢驗,如果檢驗失敗,則從池中去除連接並嘗試取出另一個
        //jedisPoolConfig.setTestOnBorrow(testOnBorrow);
        // 在空閒時檢查有效性, 默認false
        //jedisPoolConfig.setTestWhileIdle(testWhileIdle);
        return jedisPoolConfig;
    }

    /**
     * Redis集羣的配置
     *
     * @return RedisClusterConfiguration
     * @throws
     * @autor lpl
     * @date 2017年12月22日
     */
    @Bean
    public RedisClusterConfiguration redisClusterConfiguration() {
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        //Set<RedisNode> clusterNodes
        String[] serverArray = clusterNodes.split(" ");

        Set<RedisNode> nodes = new HashSet<RedisNode>();

        for (String ipPort : serverArray) {
            String[] ipAndPort = ipPort.split(":");
            nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
        }

        redisClusterConfiguration.setClusterNodes(nodes);
        redisClusterConfiguration.setMaxRedirects(mmaxRedirectsac);
        redisClusterConfiguration.setPassword(RedisPassword.of(password));

        return redisClusterConfiguration;
    }

    /**
     * 配置工廠
     *
     * @param @param  jedisPoolConfig
     * @param @return
     * @return JedisConnectionFactory
     * @throws
     * @Title: JedisConnectionFactory
     * @autor lpl
     * @date 2017年12月22日
     */
    @Bean
    public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig, RedisClusterConfiguration redisClusterConfiguration) {
        JedisConnectionFactory JedisConnectionFactory = new JedisConnectionFactory(redisClusterConfiguration, jedisPoolConfig);

        return JedisConnectionFactory;
    }

    /**
     * 實例化 RedisTemplate 對象
     *
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }

    /**
     * 設置數據存入 redis 的序列化方式,並開啓事務
     *
     * @param redisTemplate
     * @param factory
     */
    private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
        //如果不配置Serializer，那麼存儲的時候缺省使用String，如果用User類型存儲，那麼會提示錯誤User can't cast to String！
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        // 開啓事務
        redisTemplate.setEnableTransactionSupport(true);
        redisTemplate.setConnectionFactory(factory);
    }


    /**
     * 注入封裝RedisTemplate
     *
     * @return RedisUtil
     * @throws
     * @Title: redisUtil
     * @autor lpl
     * @date 2017年12月21日
     */
    @Bean(name = "redisUtil")
    public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
        RedisUtil redisUtil = new RedisUtil();
        redisUtil.setRedisTemplate(redisTemplate);
        return redisUtil;
    }

}