templates/toco-springboot-template
Archived
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
horsepower
2024-07-17 11:28:07 +08:00
commit 195e217051
49 changed files with 2741 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
template/common/README.md Normal file
View File

@@ -0,0 +1,5 @@
> 本模块存放公共组件
``` \-- *.utils(工具类; package)
\-- *.enums(公共枚举; package)
\-- *.constants(公共常量; package)
```

80
template/common/pom.xml Normal file
View File

@@ -0,0 +1,80 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>{{ .groupId }}</groupId>
<artifactId>{{ .artifactId }}</artifactId>
<version>{{ .version }}</version>
</parent>
<artifactId>{{ .artifactId }}-common</artifactId>
<version>{{ .version }}</version>
<properties>
<elasticsearch.version>7.3.1</elasticsearch.version>
</properties>
<dependencies>
<dependency>
<groupId>com.vs</groupId>
<artifactId>dist</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>javax.annotation</groupId>
<artifactId>javax.annotation-api</artifactId>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<dependency>
<groupId>com.vs</groupId>
<artifactId>ox-basidc-common</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>transport</artifactId>
<version>${elasticsearch.version}</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>${elasticsearch.version}</version>
</dependency>
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>${elasticsearch.version}</version>
</dependency>
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-client</artifactId>
<version>4.9.7</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.vs</groupId>
<artifactId>vs.common.util</artifactId>
</dependency>
</dependencies>
</project>

14
template/common/src/main/java/{{.packagePath}}/common/config/MqConfig.java Normal file
View File

@@ -0,0 +1,14 @@
package {{ .package }}.common.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
@Data
@Configuration
@ConfigurationProperties(prefix = "rocketmq")
public class MqConfig {
private String nameServer;
private String topic;
private String consumerGroup;
}

21
template/common/src/main/java/{{.packagePath}}/common/config/RocketMqAutoConfiguration.java Normal file
View File

@@ -0,0 +1,21 @@
package {{ .package }}.common.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
import {{ .package }}.common.config.MqConfig;
import {{ .package }}.common.rocketmq.RocketMQService;
import {{ .package }}.common.rocketmq.RocketMQServiceImpl;
@Configuration
public class RocketMqAutoConfiguration {
@Resource
private MqConfig mqConfig;
@Bean
RocketMQService createRocketMQService() {
RocketMQServiceImpl instance = new RocketMQServiceImpl(mqConfig.getNameServer());
return instance;
}
}

2
template/common/src/main/java/{{.packagePath}}/common/constants/README.md Normal file
View File

@@ -0,0 +1,2 @@
> 本模块存放公共常量
``` \-- *Constant.java

17
template/common/src/main/java/{{.packagePath}}/common/elasticsearch/ESConfig.java Normal file
View File

@@ -0,0 +1,17 @@
package {{ .package }}.common.elasticsearch;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Data
@ConfigurationProperties(prefix = "essql")
@Component
public class ESConfig {
private String url;
private String password;
private String username;
private String hosts;
private int port;
private String scheme;
}

172
template/common/src/main/java/{{.packagePath}}/common/elasticsearch/EsConfiguration.java Normal file
View File

@@ -0,0 +1,172 @@
package {{ .package }}.common.elasticsearch;
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;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.nio.conn.ssl.SSLIOSessionStrategy;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.Nullable;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import javax.net.ssl.*;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Objects;
@Configuration
public class EsConfiguration {
private static int connectTimeOut = 1000; // 连接超时时间
private static int socketTimeOut = 30000; // 连接超时时间
private static int connectionRequestTimeOut = 500; // 获取连接的超时时间
private static int maxConnectNum = 100; // 最大连接数
private static int maxConnectPerRoute = 100; // 最大路由连接数
@Resource
private ESConfig esConfig;
private ArrayList<HttpHost> hostList = null;
@PostConstruct
void init(){
hostList = new ArrayList<>();
String[] hostStrs = esConfig.getHosts().split(",");
for (String host : hostStrs) {
hostList.add(new HttpHost(host, esConfig.getPort(), esConfig.getScheme()));
}
}
@Bean
public RestHighLevelClient client() {
RestClientBuilder builder = RestClient.builder(hostList.toArray(new HttpHost[0]));
// 异步httpclient连接延时配置
builder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
@Override
public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
requestConfigBuilder.setConnectTimeout(connectTimeOut);
requestConfigBuilder.setSocketTimeout(socketTimeOut);
requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeOut);
return requestConfigBuilder;
}
});
final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(esConfig.getUsername(), esConfig.getPassword()));
SSLContext sc = null;
try{
sc = SSLContext.getInstance("SSL");
sc.init(null, trustAllCerts, new SecureRandom());
}catch(KeyManagementException e){
e.printStackTrace();
}catch(NoSuchAlgorithmException e){
e.printStackTrace();
}
SSLIOSessionStrategy sessionStrategy = new SSLIOSessionStrategy(sc, new NullHostNameVerifier());
SecuredHttpClientConfigCallback httpClientConfigCallback = new SecuredHttpClientConfigCallback(sessionStrategy,credentialsProvider);
// 异步httpclient连接数配置
builder.setHttpClientConfigCallback(httpClientConfigCallback);
RestHighLevelClient client = new RestHighLevelClient(builder);
return client;
}
static TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public X509Certificate[] getAcceptedIssuers() {
return null;
}
}};
public static class NullHostNameVerifier implements HostnameVerifier {
@Override
public boolean verify(String arg0, SSLSession arg1) {
return true;
}
}
class SecuredHttpClientConfigCallback implements RestClientBuilder.HttpClientConfigCallback {
@Nullable
private final CredentialsProvider credentialsProvider;
/**
* The {@link SSLIOSessionStrategy} for all requests to enable SSL / TLS encryption.
*/
private final SSLIOSessionStrategy sslStrategy;
/**
* Create a new {@link SecuredHttpClientConfigCallback}.
*
* @param credentialsProvider The credential provider, if a username/password have been supplied
* @param sslStrategy The SSL strategy, if SSL / TLS have been supplied
* @throws NullPointerException if {@code sslStrategy} is {@code null}
*/
SecuredHttpClientConfigCallback(final SSLIOSessionStrategy sslStrategy,
@Nullable final CredentialsProvider credentialsProvider) {
this.sslStrategy = Objects.requireNonNull(sslStrategy);
this.credentialsProvider = credentialsProvider;
}
/**
* Get the {@link CredentialsProvider} that will be added to the HTTP client.
* @return Can be {@code null}.
*/
@Nullable
CredentialsProvider getCredentialsProvider() {
return credentialsProvider;
}
/**
* Get the {@link SSLIOSessionStrategy} that will be added to the HTTP client.
*
* @return Never {@code null}.
*/
SSLIOSessionStrategy getSSLStrategy() {
return sslStrategy;
}
/**
* Sets the {@linkplain HttpAsyncClientBuilder#setDefaultCredentialsProvider(CredentialsProvider) credential provider},
*
* @param httpClientBuilder The client to configure.
* @return Always {@code httpClientBuilder}.
*/
@Override
public HttpAsyncClientBuilder customizeHttpClient(final HttpAsyncClientBuilder httpClientBuilder) {
// enable SSL / TLS
httpClientBuilder.setSSLStrategy(sslStrategy);
// enable user authentication
if (credentialsProvider != null) {
httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
}
httpClientBuilder.setMaxConnTotal(maxConnectNum);
httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
return httpClientBuilder;
}
}
}

506
template/common/src/main/java/{{.packagePath}}/common/elasticsearch/EsService.java Normal file
View File

@@ -0,0 +1,506 @@
package {{ .package }}.common.elasticsearch;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.elasticsearch.action.admin.indices.alias.Alias;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.GetAliasesResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.PutMappingRequest;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.json.JSONObject;
import org.springframework.context.annotation.Conditional;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import {{ .package }}.common.utils.JsonUtils;
/**
* es 的工具类
*/
@Component
public class EsService {
@Resource
private RestHighLevelClient restHighLevelClient;
private Logger log = LoggerFactory.getLogger(EsService.class);
/**
* 关键字
*/
public static final String KEYWORD = ".keyword";
/**
* 创建索引
*
* @param index 索引
* @return
*/
public boolean createIndex(String index) throws IOException {
if(isIndexExist(index)){
log.error("Index is exits!");
return false;
}
//1.创建索引请求
CreateIndexRequest request = new CreateIndexRequest(index);
//2.执行客户端请求
CreateIndexResponse response = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
log.info("创建索引{}成功",index);
return response.isAcknowledged();
}
/**
* 创建索引并指定分片和复制集数量
* @param indexName
* @param numberOfShards
* @param numberOfReplicas
* @return
* @throws IOException
*/
public boolean createIndexWithShards(String indexName, Integer numberOfShards, Integer numberOfReplicas) throws IOException {
CreateIndexRequest createIndexRequest = new CreateIndexRequest(indexName);
//设置分片信息
numberOfShards = numberOfShards == null ? 1 : numberOfShards;
numberOfReplicas = numberOfReplicas == null ? 1 : numberOfReplicas;
createIndexRequest.settings(Settings.builder().
put("index.number_of_shards", numberOfShards)
.put("index.number_of_replicas", numberOfReplicas));
//创建索引
CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
return createIndexResponse.isAcknowledged();
}
/**
* 创建索引，并关联别名
* @param indexName
* @param aliasName
* @return
* @throws IOException
*/
public boolean createIndexWithAlias(String indexName, String aliasName) throws IOException {
CreateIndexRequest request = new CreateIndexRequest(indexName);
if (StringUtils.isNotEmpty(aliasName)) {
request.alias(new Alias(aliasName));
}
CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
return createIndexResponse.isAcknowledged();
}
/**
* 删除索引
*
* @param index
* @return
*/
public boolean deleteIndex(String index) throws IOException {
if(!isIndexExist(index)) {
log.error("Index is not exits!");
return false;
}
//删除索引请求
DeleteIndexRequest request = new DeleteIndexRequest(index);
//执行客户端请求
AcknowledgedResponse delete = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
log.info("删除索引{}成功",index);
return delete.isAcknowledged();
}
/**
* 判断索引是否存在
*
* @param index
* @return
*/
public boolean isIndexExist(String index) throws IOException {
GetIndexRequest request = new GetIndexRequest(index);
boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
return exists;
}
/**
* 获取别名关联的index列表
* @param aliasName
* @return
* @throws IOException
*/
public List<String> getIndicesByAlias(String aliasName) throws IOException {
GetAliasesRequest aliasRequest = new GetAliasesRequest(aliasName);
GetAliasesResponse response = restHighLevelClient.indices().getAlias(aliasRequest, RequestOptions.DEFAULT);
if(!RestStatus.OK.equals(response.status())){
return new ArrayList<>();
}
return new ArrayList<>(response.getAliases().keySet());
}
/**
* 新增别名
* @param indexName
* @param aliasName
* @return
* @throws IOException
*/
public boolean addAlias(String indexName, String aliasName) throws IOException {
IndicesAliasesRequest aliasesRequest = new IndicesAliasesRequest();
IndicesAliasesRequest.AliasActions aliasAction =
new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.ADD)
.index(indexName)
.alias(aliasName);
aliasesRequest.addAliasAction(aliasAction);
AcknowledgedResponse acknowledgedResponse = restHighLevelClient.indices().updateAliases(aliasesRequest,RequestOptions.DEFAULT);
return acknowledgedResponse.isAcknowledged();
}
/**
* 修改别名关联的索引
* @param aliasname
* @param oldIndices
* @param newIndices
* @return
* @throws IOException
*/
public boolean changeAlias(String aliasname, List<String> oldIndices, List<String> newIndices) throws IOException {
IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
for(String newIndexname: newIndices) {
IndicesAliasesRequest.AliasActions addIndexAction = new IndicesAliasesRequest.AliasActions(
IndicesAliasesRequest.AliasActions.Type.ADD).index(newIndexname).alias(aliasname);
indicesAliasesRequest.addAliasAction(addIndexAction);
}
for(String oldIndexname: oldIndices) {
IndicesAliasesRequest.AliasActions removeAction = new IndicesAliasesRequest.AliasActions(
IndicesAliasesRequest.AliasActions.Type.REMOVE).index(oldIndexname).alias(aliasname);
indicesAliasesRequest.addAliasAction(removeAction);
}
AcknowledgedResponse indicesAliasesResponse = restHighLevelClient.indices().updateAliases(indicesAliasesRequest,
RequestOptions.DEFAULT);
return indicesAliasesResponse.isAcknowledged();
}
/**
* 别名是否存在
* @param aliasName
* @return
* @throws IOException
*/
public boolean isAliasExists(String aliasName) throws IOException {
GetAliasesRequest getAliasesRequest = new GetAliasesRequest(aliasName);
return restHighLevelClient.indices().existsAlias(getAliasesRequest, RequestOptions.DEFAULT);
}
/**
* 设置index mapping
* @param request
* @return
* @throws IOException
*/
public boolean addMappingForIndex(PutMappingRequest request) throws IOException {
request.setTimeout(TimeValue.timeValueMinutes(2));
AcknowledgedResponse response = restHighLevelClient.indices().putMapping(request, RequestOptions.DEFAULT);
return response.isAcknowledged();
}
/**
* 数据添加，正定ID
*
* @param jsonObject 要增加的数据
* @param index 索引，类似数据库
* @param id 数据ID, 为null时es随机生成
* @return
*/
public String addData(JSONObject jsonObject, String index, String id) throws IOException {
//创建请求
IndexRequest request = new IndexRequest(index);
//规则 put /test_index/_doc/1
request.id(id);
request.timeout(TimeValue.timeValueSeconds(1));
//将数据放入请求 json
IndexRequest source = request.source(jsonObject, XContentType.JSON);
//客户端发送请求
IndexResponse response = restHighLevelClient.index(request, RequestOptions.DEFAULT);
log.info("添加数据成功 索引为: {}, response 状态: {}, id为: {}",index,response.status().getStatus(), response.getId());
return response.getId();
}
public boolean addDataList(List<Pair<Long,?>> datas, String index) throws IOException {
//
BulkRequest bulkRequest = new BulkRequest();
bulkRequest.timeout(TimeValue.timeValueSeconds(10));
IndexRequest request;
if (datas!=null&&datas.size()>0){
for(Pair<Long,?> o: datas){
request = new IndexRequest(index);
String source = JsonUtils.toJson(o.getRight());
request.id(o.getLeft().toString());
request.source(source, XContentType.JSON);
bulkRequest.add(request);
}
}
BulkResponse resp = restHighLevelClient.bulk(bulkRequest,RequestOptions.DEFAULT);
if(resp.hasFailures()){
for(BulkItemResponse itemResponse : resp){
if(itemResponse.isFailed()){
BulkItemResponse.Failure failure = itemResponse.getFailure();
log.warn("同步索引失败：index:{}, id:{}, itemId:{}, error: {}", itemResponse.getIndex(), itemResponse.getId(), itemResponse.getItemId(), failure.getMessage());
}
}
}
return !resp.hasFailures();
}
/**
* 数据添加 随机id
*
* @param jsonObject 要增加的数据
* @param index 索引，类似数据库
* @return
*/
public String addData(JSONObject jsonObject, String index) throws IOException {
return addData(jsonObject, index, UUID.randomUUID().toString().replaceAll("-", "").toUpperCase());
}
/**
* 通过ID删除数据
*
* @param index 索引，类似数据库
* @param id 数据ID
*/
public void deleteDataById(String index, String id) throws IOException {
//删除请求
DeleteRequest request = new DeleteRequest(index, id);
//执行客户端请求
DeleteResponse delete = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
log.info("索引为: {}, id为: {}删除数据成功",index, id);
}
/**
* 通过ID 更新数据
*
* @param object 要增加的数据
* @param index 索引，类似数据库
* @param id 数据ID
* @return
*/
public void updateDataById(Object object, String index, String id) throws IOException {
//更新请求
UpdateRequest update = new UpdateRequest(index, id);
//保证数据实时更新
//update.setRefreshPolicy("wait_for");
update.timeout("1s");
update.doc(JsonUtils.toJson(object), XContentType.JSON);
//执行更新请求
UpdateResponse update1 = restHighLevelClient.update(update, RequestOptions.DEFAULT);
log.info("索引为: {}, id为: {}, 更新数据成功",index, id);
}
/**
* 通过ID 更新数据,保证实时性
*
* @param object 要增加的数据
* @param index 索引，类似数据库
* @param id 数据ID
* @return
*/
public void updateDataByIdNoRealTime(Object object, String index, String id) throws IOException {
//更新请求
UpdateRequest update = new UpdateRequest(index, id);
//保证数据实时更新
update.setRefreshPolicy("wait_for");
update.timeout("1s");
update.doc(JsonUtils.toJson(object), XContentType.JSON);
//执行更新请求
UpdateResponse update1 = restHighLevelClient.update(update, RequestOptions.DEFAULT);
log.info("索引为: {}, id为: {}, 更新数据成功",index, id);
}
/**
* 通过ID获取数据
*
* @param index 索引，类似数据库
* @param id 数据ID
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @return
*/
public Map<String,Object> searchDataById(String index, String id, String fields) throws IOException {
GetRequest request = new GetRequest(index, id);
if (StringUtils.isNotEmpty(fields)){
//只查询特定字段。如果需要查询所有字段则不设置该项。
request.fetchSourceContext(new FetchSourceContext(true,fields.split(","), Strings.EMPTY_ARRAY));
}
GetResponse response = restHighLevelClient.get(request, RequestOptions.DEFAULT);
Map<String, Object> map = response.getSource();
//为返回的数据添加id
map.put("id",response.getId());
return map;
}
/**
* 通过ID判断文档是否存在
* @param index 索引，类似数据库
* @param id 数据ID
* @return
*/
public boolean existsById(String index,String id) throws IOException {
GetRequest request = new GetRequest(index, id);
//不获取返回的_source的上下文
request.fetchSourceContext(new FetchSourceContext(false));
request.storedFields("_none_");
return restHighLevelClient.exists(request, RequestOptions.DEFAULT);
}
/**
* 获取低水平客户端
* @return
*/
public RestClient getLowLevelClient() {
return restHighLevelClient.getLowLevelClient();
}
/**
* 高亮结果集 特殊处理
* map转对象 JSONObject.parseObject(JSONObject.toJSONString(map), Content.class)
* @param searchResponse
* @param highlightField
*/
public List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) {
//解析结果
ArrayList<Map<String,Object>> list = new ArrayList<>();
for (SearchHit hit : searchResponse.getHits().getHits()) {
Map<String, HighlightField> high = hit.getHighlightFields();
HighlightField title = high.get(highlightField);
hit.getSourceAsMap().put("id", hit.getId());
Map<String, Object> sourceAsMap = hit.getSourceAsMap();//原来的结果
//解析高亮字段,将原来的字段换为高亮字段
if (title!=null){
Text[] texts = title.fragments();
String nTitle="";
for (Text text : texts) {
nTitle+=text;
}
//替换
sourceAsMap.put(highlightField,nTitle);
}
list.add(sourceAsMap);
}
return list;
}
/**
* 查询并分页
* @param index 索引名称
* @param query 查询条件
* @param size 文档大小限制
* @param from 从第几页开始
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @param sortField 排序字段
* @param highlightField 高亮字段
* @return
*/
public List<Map<String, Object>> searchListData(String index,
SearchSourceBuilder query,
Integer size,
Integer from,
String fields,
String sortField,
String highlightField) throws IOException {
SearchRequest request = new SearchRequest(index);
SearchSourceBuilder builder = query;
if (StringUtils.isNotEmpty(fields)){
//只查询特定字段。如果需要查询所有字段则不设置该项。
builder.fetchSource(new FetchSourceContext(true,fields.split(","),Strings.EMPTY_ARRAY));
}
from = from <= 0 ? 0 : from*size;
//设置确定结果要从哪个索引开始搜索的from选项，默认为0
builder.from(from);
builder.size(size);
if (StringUtils.isNotEmpty(sortField)){
//排序字段，注意如果proposal_no是text类型会默认带有keyword性质，需要拼接.keyword
builder.sort(sortField+".keyword", SortOrder.ASC);
}
//高亮
HighlightBuilder highlight = new HighlightBuilder();
highlight.field(highlightField);
//关闭多个高亮
highlight.requireFieldMatch(false);
highlight.preTags("<span style='color:red'>");
highlight.postTags("</span>");
builder.highlighter(highlight);
//不返回源数据。只有条数之类的数据。
//builder.fetchSource(false);
request.source(builder);
SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
log.error("=="+response.getHits().getTotalHits());
if (response.status().getStatus() == 200) {
// 解析对象
return setSearchResponse(response, highlightField);
}
return null;
}
}

26
template/common/src/main/java/{{.packagePath}}/common/elasticsearch/IndexService.java Normal file
View File

@@ -0,0 +1,26 @@
package {{ .package }}.common.elasticsearch;
import org.apache.commons.lang3.tuple.Pair;
import org.json.JSONException;
import org.springframework.core.ResolvableType;
import java.io.IOException;
import java.util.List;
import org.elasticsearch.client.indices.PutMappingRequest;
import {{ .package }}.common.elasticsearch.EsService;
public interface IndexService {
public boolean indexData(List<Long> ids, String table) throws JSONException, IOException;
public List<String> subscribeTable();
public String mainTable();
public List<Long> scanMainDBIds(long offsetId, int size);
public String indexName();
public PutMappingRequest getIndexMapping();
}

2
template/common/src/main/java/{{.packagePath}}/common/enums/README.md Normal file
View File

@@ -0,0 +1,2 @@
> 本模块存放公共枚举
``` \-- *Enum.java

113
template/common/src/main/java/{{.packagePath}}/common/redis/RedisPoolConfig.java Normal file
View File

@@ -0,0 +1,113 @@
package {{ .package }}.common.redis;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import cn.hutool.core.util.StrUtil;
import org.springframework.beans.factory.annotation.Value;
import java.util.HashSet;
import java.util.Set;
@Configuration
@EnableConfigurationProperties({RedisPoolProperties.class})
public class RedisPoolConfig {
@Autowired
private RedisPoolProperties redisPoolProperties;
@Value("${redis-config.pool.password:}")
private String password;
/**
* 连接池的基本配置
*
* @return JedisPoolConfig
*/
@Bean
public JedisPoolConfig initPoolConfig() {
JedisPoolConfig poolConfig = new JedisPoolConfig();
// 设置最大连接数，默认值为8.如果赋值为-1，则表示不限制；
poolConfig.setMaxTotal(redisPoolProperties.getMaxTotal());
// 最大空闲连接数
poolConfig.setMaxIdle(redisPoolProperties.getMaxIdle());
// 最小空闲连接数
poolConfig.setMinIdle(redisPoolProperties.getMinIdle());
// 获取Jedis连接的最大等待时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
poolConfig.setMaxWaitMillis(redisPoolProperties.getMaxWaitMillis());
// 每次释放连接的最大数目
poolConfig.setNumTestsPerEvictionRun(redisPoolProperties.getNumTestsPerEvictionRun());
// 释放连接的扫描间隔（毫秒）,如果为负数,则不运行逐出线程, 默认-1
poolConfig.setTimeBetweenEvictionRunsMillis(redisPoolProperties.getTimeBetweenEvictionRunsMillis());
// 连接最小空闲时间
poolConfig.setMinEvictableIdleTimeMillis(redisPoolProperties.getMinEvictableIdleTimeMillis());
// 连接空闲多久后释放, 当空闲时间&gt;该值 且 空闲连接&gt;最大空闲连接数 时直接释放
poolConfig.setSoftMinEvictableIdleTimeMillis(redisPoolProperties.getSoftMinEvictableIdleTimeMillis());
// 在获取Jedis连接时，自动检验连接是否可用
poolConfig.setTestOnBorrow(redisPoolProperties.isTestOnBorrow());
// 在将连接放回池中前，自动检验连接是否有效
poolConfig.setTestOnReturn(redisPoolProperties.isTestOnReturn());
// 自动测试池中的空闲连接是否都是可用连接
poolConfig.setTestWhileIdle(redisPoolProperties.isTestWhileIdle());
// 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
poolConfig.setBlockWhenExhausted(redisPoolProperties.isBlockWhenExhausted());
// 是否启用pool的jmx管理功能, 默认true
poolConfig.setJmxEnabled(redisPoolProperties.isJmxEnabled());
// 是否启用后进先出, 默认true
poolConfig.setLifo(redisPoolProperties.isLifo());
// 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
poolConfig.setNumTestsPerEvictionRun(redisPoolProperties.getNumTestsPerEvictionRun());
poolConfig.setTestOnBorrow(false);
return poolConfig;
}
/**
* 创建JedisCluster客户端， 将redis客户端放到容器中； 连接redis集群
* Jedis 连接集群
*
* @return JedisCluster 使用完成后不需要手动释放连接，返回客户端， 使用完成后不需要手动释放连接， 客户端会自动释放连接
*/
// @Bean
// @Qualifier("JedisCluster")
// public JedisCluster getJedisCluster() {
// return new JedisCluster(getSet(), initPoolConfig());
// }
/**
* 单例版 需要手动获取jedis实例，用完后需要手动释放
*
* @return 返回redis连接池，
*/
@Bean
public JedisPool getRedisPool() {
String host = StrUtil.subBefore(redisPoolProperties.getHostAndPort(), ":", false);
int port = Integer.parseInt(StrUtil.subAfter(redisPoolProperties.getHostAndPort(), ":", false));
if(StrUtil.isNotEmpty(this.password)) {
return new JedisPool(initPoolConfig(),host,port ,1000, password);
}else{
return new JedisPool(initPoolConfig(),host,port);
}
}
/**
* 获取集群对象集合
*
* @return Set
*/
public Set<HostAndPort> getSet() {
String hostAndPortStr = redisPoolProperties.getHostAndPort();
String[] hostAndPortArrays = hostAndPortStr.trim().split(",");
Set<HostAndPort> hostAndPorts = new HashSet<>();
for (String hostAndPort : hostAndPortArrays) {
hostAndPorts.add(new HostAndPort(hostAndPort.split(":")[0], Integer.parseInt(hostAndPort.split(":")[1])));
}
return hostAndPorts;
}
}

145
template/common/src/main/java/{{.packagePath}}/common/redis/RedisPoolProperties.java Normal file
View File

@@ -0,0 +1,145 @@
package {{ .package }}.common.redis;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@Configuration
@ConfigurationProperties(prefix = "redis-config.pool")
public class RedisPoolProperties {
private String hostAndPort;
private int maxTotal;
private int maxIdle;
private int minIdle;
private Long maxWaitMillis;
private Long timeBetweenEvictionRunsMillis;
private Long minEvictableIdleTimeMillis;
private Long softMinEvictableIdleTimeMillis;
private boolean testOnBorrow;
private boolean testOnReturn;
private boolean testWhileIdle;
private boolean blockWhenExhausted;
private boolean jmxEnabled;
private boolean lifo;
private int numTestsPerEvictionRun;
public String getHostAndPort() {
return hostAndPort;
}
public void setHostAndPort(String hostAndPort) {
this.hostAndPort = hostAndPort;
}
public int getMaxTotal() {
return maxTotal;
}
public void setMaxTotal(int maxTotal) {
this.maxTotal = maxTotal;
}
public int getMaxIdle() {
return maxIdle;
}
public void setMaxIdle(int maxIdle) {
this.maxIdle = maxIdle;
}
public int getMinIdle() {
return minIdle;
}
public void setMinIdle(int minIdle) {
this.minIdle = minIdle;
}
public Long getMaxWaitMillis() {
return maxWaitMillis;
}
public void setMaxWaitMillis(Long maxWaitMillis) {
this.maxWaitMillis = maxWaitMillis;
}
public Long getTimeBetweenEvictionRunsMillis() {
return timeBetweenEvictionRunsMillis;
}
public void setTimeBetweenEvictionRunsMillis(Long timeBetweenEvictionRunsMillis) {
this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
}
public Long getMinEvictableIdleTimeMillis() {
return minEvictableIdleTimeMillis;
}
public void setMinEvictableIdleTimeMillis(Long minEvictableIdleTimeMillis) {
this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
}
public Long getSoftMinEvictableIdleTimeMillis() {
return softMinEvictableIdleTimeMillis;
}
public void setSoftMinEvictableIdleTimeMillis(Long softMinEvictableIdleTimeMillis) {
this.softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;
}
public boolean isTestOnBorrow() {
return testOnBorrow;
}
public void setTestOnBorrow(boolean testOnBorrow) {
this.testOnBorrow = testOnBorrow;
}
public boolean isTestOnReturn() {
return testOnReturn;
}
public void setTestOnReturn(boolean testOnReturn) {
this.testOnReturn = testOnReturn;
}
public boolean isTestWhileIdle() {
return testWhileIdle;
}
public void setTestWhileIdle(boolean testWhileIdle) {
this.testWhileIdle = testWhileIdle;
}
public boolean isBlockWhenExhausted() {
return blockWhenExhausted;
}
public void setBlockWhenExhausted(boolean blockWhenExhausted) {
this.blockWhenExhausted = blockWhenExhausted;
}
public boolean isJmxEnabled() {
return jmxEnabled;
}
public void setJmxEnabled(boolean jmxEnabled) {
this.jmxEnabled = jmxEnabled;
}
public boolean isLifo() {
return lifo;
}
public void setLifo(boolean lifo) {
this.lifo = lifo;
}
public int getNumTestsPerEvictionRun() {
return numTestsPerEvictionRun;
}
public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {
this.numTestsPerEvictionRun = numTestsPerEvictionRun;
}
}

7
template/common/src/main/java/{{.packagePath}}/common/rocketmq/RocketMQService.java Normal file
View File

@@ -0,0 +1,7 @@
package {{ .package }}.common.rocketmq;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
public interface RocketMQService {
DefaultMQPushConsumer getConsumer(String consumerGroup);
}

34
template/common/src/main/java/{{.packagePath}}/common/rocketmq/RocketMQServiceImpl.java Normal file
View File

@@ -0,0 +1,34 @@
package {{ .package }}.common.rocketmq;
import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.exception.MQClientException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Slf4j
public class RocketMQServiceImpl implements RocketMQService {
private String serverAddr = null;
public RocketMQServiceImpl(String serverAddr) {
this.serverAddr = serverAddr;
}
Map<String, DefaultMQPushConsumer> consumerMap = new ConcurrentHashMap<>();
@Override
@Synchronized
public DefaultMQPushConsumer getConsumer(String consumerGroup) {
DefaultMQPushConsumer defaultMQPushConsumer = consumerMap.get(consumerGroup);
if (defaultMQPushConsumer != null) {
return defaultMQPushConsumer;
}
DefaultMQPushConsumer instance = new DefaultMQPushConsumer(consumerGroup);
instance.setNamesrvAddr(this.serverAddr);
this.consumerMap.put(consumerGroup, instance);
return instance;
}
}

113
template/common/src/main/java/{{.packagePath}}/common/utils/JsonUtils.java Normal file
View File

@@ -0,0 +1,113 @@
package {{ .package }}.common.utils;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.MissingNode;
import com.vs.ox.common.utils.ObjectMapperFactory;
import java.io.IOException;
import java.util.Optional;
public class JsonUtils {
private static final ObjectMapper objectMapper = ObjectMapperFactory.getDefaultObjectMapper();
static {
objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
}
public static ObjectMapper getObjectMapper() {
return objectMapper;
}
public static String toJson(Object value) {
try {
return objectMapper.writeValueAsString(value);
} catch (JsonProcessingException e) {
throw new IllegalStateException("to Json error", e);
}
}
public static <T> T readObject(String json, TypeReference<T> typeReference) {
return readObject(json, objectMapper.getTypeFactory().constructType(typeReference));
}
public static <T> T readObject(String json, Class<T> clazz) {
return readObject(json, objectMapper.getTypeFactory().constructType(clazz));
}
public static <T> T readObject(byte[] json, Class<T> clazz) {
try {
return objectMapper.readValue(json, clazz);
} catch (IOException e) {
throw new IllegalStateException("read Json error", e);
}
}
public static <T> T readObject(String json, JavaType javaType) {
if (isBlank(json)) {
return null;
}
try {
return objectMapper.readValue(json, javaType);
} catch (IOException e) {
throw new IllegalStateException("read Json error", e);
}
}
public static JsonNode path(String json, String path) {
if (isBlank(json)) {
return MissingNode.getInstance();
}
try {
String atPath = path;
if (!path.startsWith("/")) {
atPath = "/" + path;
}
return objectMapper.readTree(json).at(atPath);
} catch (IOException e) {
throw new IllegalStateException("read Json error", e);
}
}
private static boolean isBlank(String str) {
int strLen;
if (str == null || (strLen = str.length()) == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if ((!Character.isWhitespace(str.charAt(i)))) {
return false;
}
}
return true;
}
public static <T> Optional<T> readPath(String json, String path, TypeReference<T> typeReference) {
return readPath(json, path, objectMapper.getTypeFactory().constructType(typeReference));
}
public static <T> Optional<T> readPath(String json, String path, Class<T> clazz) {
JsonNode jsonNode = path(json, path);
if (jsonNode.isMissingNode()) {
return Optional.empty();
}
try {
return Optional.of(objectMapper.treeToValue(jsonNode, clazz));
} catch (JsonProcessingException e) {
throw new IllegalStateException(e);
}
}
public static <T> Optional<T> readPath(String json, String path, JavaType javaType) {
JsonNode jsonNode = path(json, path);
if (jsonNode.isMissingNode()) {
return Optional.empty();
}
return Optional.of(objectMapper.convertValue(jsonNode, javaType));
}
}

3
template/common/src/main/java/{{.packagePath}}/common/utils/README.md Normal file
View File

@@ -0,0 +1,3 @@
> 本模块存放公共工具类
``` \-- *Util.java
```