1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package com.zbooksoft.gdmis.config;
 
import com.ruili.wcp.common.CustomConfigUtil;
import com.ruili.wcp.configsettting.SystemConfig;
import com.ruili.wcp.web.common.LicenseException;
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.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.util.ObjectUtils;
 
import javax.annotation.PostConstruct;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
 
/**
 * @Description ES客户端配置
 * @Author fsr
 * @Date 2021/12/20
 **/
@Configuration
@DependsOn(value = {"customConfigUtil"}) // 声明一下并不一定生效
public class RestHighLevelConfig {
 
    private String host = "127.0.0.1";
    private Integer port = 9200;
 
    private static final String PROTOCOL = "http"; // 协议
    private static final int CONNECT_TIME_OUT = 1000; // http连接超时 毫秒
    private static final int SOCKET_TIME_OUT = 6000; // sock超时
    private static final int CONNECTION_REQUEST_TIME_OUT = 5000; // 请求超时
 
    private static final int MAX_CONNECT_NUM = 50;
    private static final int MAX_CONNECT_PER_ROUTE = 50;
 
 
    @Autowired
    private CustomConfigUtil customConfigUtil;
 
    public static void main(String[] args) throws IOException {
        Class<CustomConfigUtil> customConfigUtilClass = CustomConfigUtil.class;
        Class<? extends ClassLoader> aClass = customConfigUtilClass.getClassLoader().getClass();
        InputStream resourceAsStream = aClass.getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        properties.load(resourceAsStream);
        properties.get("jdbc.driver");
        properties.get("jdbc.url");
        properties.get("jdbc.username");
        Object password = properties.get("jdbc.password");
        System.out.println(password);
    }
 
    private RestHighLevelClient restHighLevelClient;
 
    @PostConstruct
    public void init() throws LicenseException {
        SystemConfig systemConfig = this.customConfigUtil.getConfigObj(SystemConfig.class);
        if (systemConfig == null) {
            systemConfig = new SystemConfig();
            customConfigUtil.setConfigObj(systemConfig);
        }
        String esHost = systemConfig.getElasticSearchServerHost();
        if (!ObjectUtils.isEmpty(esHost)) {
            this.host = esHost;
        }
        String esPort = systemConfig.getElasticSearchServerPort();
        if (!ObjectUtils.isEmpty(esPort)) {
            this.port = Integer.valueOf(esPort);
        }
        // 设置访问参数
        HttpHost httpHost = new HttpHost(this.host, this.port, PROTOCOL);
        RestClientBuilder clientBuilder = RestClient.builder(httpHost);
 
        //判断是否要用户密码验证
        if (systemConfig.getElasticSearchRequiresAuthentication()) {
            String esUserName = systemConfig.getElasticSearchUserName();
            String esPassword = systemConfig.getElasticSearchPassword();
 
            CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
            credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(esUserName, esPassword));
            clientBuilder.setHttpClientConfigCallback(f -> {
                f.setDefaultCredentialsProvider(credentialsProvider)
                        .setMaxConnTotal(MAX_CONNECT_NUM)
                        .setMaxConnPerRoute(MAX_CONNECT_PER_ROUTE);
                f.disableConnectionState();
                return f;
            });
        } else {
            // http连接池设置
            clientBuilder.setHttpClientConfigCallback(builder -> {
                builder.setMaxConnTotal(MAX_CONNECT_NUM).setMaxConnPerRoute(MAX_CONNECT_PER_ROUTE);
                builder.disableConnectionState();
                return builder;
            });
        }
 
        // 超时设置
        clientBuilder.setRequestConfigCallback(builder -> {
            builder.setConnectTimeout(CONNECT_TIME_OUT)
                    .setSocketTimeout(SOCKET_TIME_OUT)
                    .setConnectionRequestTimeout(CONNECTION_REQUEST_TIME_OUT);
            return builder;
        });
 
        restHighLevelClient = new RestHighLevelClient(clientBuilder);
    }
 
    @Bean
    public RestHighLevelClient restHighLevelClient() {
        return restHighLevelClient;
    }
 
}