RestClient 类客户端 5种请求方式
public class EsRestClient {
private static final String PUT = "PUT";
private static final String POST = "POST";
private static final String GET = "GET";
private static final String HEAD = "HEAD";
private static final String DELETE = "DELETE";
public static RestClient getClient(){
return getClient(CommonResource.cloud_es_dm_ip, CommonResource.cloud_es_dm_rest_port);
}
public static RestClient getClient(String ip, Integer port){
return RestClient.builder(new HttpHost(ip,port)).setMaxRetryTimeoutMillis(6000).build();
}
public static String sendGet(String ip,Integer port,String index,String type,String query){
RestClient restClient = getClient(ip,port);
String rs = null;
try {
HttpEntity entity = new NStringEntity(query, ContentType.APPLICATION_JSON);
String endpoint = "/"+index+"/"+type+"/_search";
if(StringUtils.isBlank(type)){
endpoint = "/"+index+"/_search";
}
Response response = restClient.performRequest(GET, endpoint, Collections.singletonMap("pretty", "true"),entity);
rs = EntityUtils.toString(response.getEntity());
} catch (IOException e) {
e.printStackTrace();
}finally {
close(restClient);
}
return rs;
}
public static String sendPost(List<String> indexs,List<String> types,String query){
RestClient restClient = getClient();
String rs = null;
try {
String index = StringUtils.join(indexs, ",");
String type = "/";
if(Objects.nonNull(types) && !types.isEmpty()){
type += StringUtils.join(types, ",")+"/";
}
HttpEntity entity = new NStringEntity(query, ContentType.APPLICATION_JSON);
String endpoint = "/"+index+type+"_search";
Response response = restClient.performRequest(POST, endpoint, Collections.singletonMap("pretty", "true"),entity);
rs = EntityUtils.toString(response.getEntity());
} catch (IOException e) {
e.printStackTrace();
}finally {
close(restClient);
}
return rs;
}
public static String sendPut(String ip, int port,String index,String type,String id,String data){
RestClient restClient = getClient(ip,port);
String rs = null;
try {
HttpEntity entity = new NStringEntity(data, ContentType.APPLICATION_JSON);
String requestType = POST;
String endpoint = "/"+index+"/"+type;
if(StringUtils.isNoneBlank(id)){
requestType = PUT;
endpoint = "/"+index+"/"+type+"/"+id;
}
Response response = restClient.performRequest(requestType, endpoint, Collections.singletonMap("pretty", "true"),entity);
rs = EntityUtils.toString(response.getEntity());
} catch (IOException e) {
e.printStackTrace();
}finally {
close(restClient);
}
return rs;
}
public static String sendDelete(RestClient restClient,String index,String type){
return sendDelete(restClient,index,type,null);
}
public static String sendDelete(RestClient restClient,String index,String type,String id){
String rs = null;
try {
String endpoint = "/"+index+"/"+type+"/"+id;
if(StringUtils.isBlank(id)){
endpoint = "/"+index+"/"+type;
}else if(StringUtils.isBlank(type)){
endpoint = "/"+index;
}
Response response = restClient.performRequest(DELETE, endpoint);
rs = EntityUtils.toString(response.getEntity());
} catch (IOException e) {
e.printStackTrace();
}finally {
close(restClient);
}
return rs;
}
public static boolean sendHead(RestClient restClient,String index,String type){
int code = 200;
try {
String endpoint = "/"+index+"/"+type;
// String endpoint = "/"+index+"/_mapping/"+type;//5.x
if(StringUtils.isBlank(type)){
endpoint = "/"+index;
}
Response response = restClient.performRequest(HEAD, endpoint);//200存在,404不存在
code = response.getStatusLine().getStatusCode();
} catch (IOException e) {
e.printStackTrace();
}finally {
close(restClient);
}
return code == 200?true:false;
}
public static void close(RestClient restClient){
if(Objects.nonNull(restClient)){
try {
restClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
RestClient service类
@Service
public class MyDataElasticSearchDriverImpl implements IMyDataDriver {
private static final Logger log = Logger.getLogger(MyDataElasticSearchDriverImpl.class);
@Override
public List<String> getTables(String ip, Integer port, String username,String password, String database) {
List<String> tables = Lists.newArrayList();
RestClient restClient = EsRestClient.getClient(ip,port);
Map<String,Object> requestData = Maps.newHashMap();
requestData.put("from", 1);
requestData.put("size", 100);
HttpEntity entity = new NStringEntity(JSON.toJSONString(requestData), ContentType.APPLICATION_JSON);
Response response;
JSONObject jsonObj = null;
try {
response = restClient.performRequest("GET", "/"+database, Collections.singletonMap("pretty", "true"),entity);
jsonObj = JSON.parseObject(EntityUtils.toString(response.getEntity()));
} catch (IOException e) {
e.printStackTrace();
}
@SuppressWarnings("unchecked")
Map<String,Object> mappings = (Map<String,Object>)(jsonObj.getJSONObject(database).get("mappings"));
for (Map.Entry<String,Object> m : mappings.entrySet()) {
tables.add(m.getKey());
}
return tables;
}
@Override
public List<String> getDatabases(String ip, Integer port, String username,String password) {
List<String> dataBases = Lists.newArrayList();
RestClient restClient = EsRestClient.getClient(ip, port);
try {
Response response = restClient.performRequest("GET", "/_cat/indices?v", Collections.singletonMap("pretty", "true"));
String rs = EntityUtils.toString(response.getEntity());
BufferedReader br = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(rs.getBytes(Charset.forName("utf8"))), Charset.forName("utf8")));
String line = null;
int index = 0;
while((line = br.readLine()) != null){
if(index > 0){
List<String> indices = Lists.newLinkedList();
String[] data = line.split(" ");
int a=0;
for (String s : data) {
if(!"".equals(s)){
a++;
}
if(a==3) {
dataBases.add(s);
a=0;
break;
}
}
}
index++;
}
br.close();
} catch (IOException e) {
e.printStackTrace();
}
EsRestClient.close(restClient);
return dataBases;
}
@Override
public List<String> getFields(String ip, Integer port, String username,String password, String database, String table) {
List<String> fields = Lists.newArrayList();
RestClient restClient = EsRestClient.getClient(ip, port);
try {
Response response = restClient.performRequest("GET", "/"+database+"/_mapping/"+table, Collections.singletonMap("pretty", "true"));
String rs = EntityUtils.toString(response.getEntity());
JSONObject jsonObj = JSON.parseObject(rs);
@SuppressWarnings("unchecked")
Map<String,Object> properties = (Map<String,Object>)(jsonObj.getJSONObject(database).getJSONObject("mappings").getJSONObject(table).get("properties"));
for (Map.Entry<String,Object> m : properties.entrySet()) {
fields.add(m.getKey());
}
} catch (IOException e) {
e.printStackTrace();
}
EsRestClient.close(restClient);
return fields;
}
@Override
public RestData<Map<String, Object>> getData(String ip, Integer port,
String username, String password, String database, String table,
int start, int offset) {
List<Map<String,Object>> rsList =new ArrayList<>();
long rsCount = 0l;
Map<String,Object> requestData = Maps.newHashMap();
requestData.put("from", start);
requestData.put("size", offset);
String rs = EsRestClient.sendGet(ip,port,database, table, JSON.toJSONString(requestData));
try {
JSONObject jsonObj = JSON.parseObject(rs);
JSONObject hits = jsonObj.getJSONObject("hits");
JSONArray arr = hits.getJSONArray("hits");
if(Objects.nonNull(arr)){
rsCount = hits.getLong("total");
if(rsCount > 0){
for (int i = 0;i < arr.size();i++) {
String _id = arr.getJSONObject(i).getString("_id");
JSONObject obj = arr.getJSONObject(i).getJSONObject("_source");
obj.put("_id", _id);
Map<String,Object> map = (Map<String,Object>)(obj);
rsList.add(map);
}
}
}
} catch (Exception e) {
log.error(e);
}
return new RestData<>(rsList,rsCount);
}
@Override
public RestData<Map<String,Object>> searchData(String ip, Integer port, String username, String password, List<String> databases, List<String> tables, List<String> fields, String query,String sort, int start, int offset) {
Map<String,Object> requestData = Maps.newHashMap();
if(Objects.nonNull(fields) && fields.size()>0){
requestData.put("_source", fields);
}
if(StringUtils.isNoneBlank(query)){
requestData.put("query",JSON.parse(query));
requestData.put("from", start);
requestData.put("size", offset);
}
if(StringUtils.isNoneBlank(sort)){
requestData.put("sort",JSON.parse(sort));
}
String rs = EsRestClient.sendPost(databases, tables, JSON.toJSONString(requestData));
JSONObject jsonObj = JSON.parseObject(rs);
JSONObject hits = jsonObj.getJSONObject("hits");
JSONArray arr = hits.getJSONArray("hits");
List<Map<String,Object>> rsList = new ArrayList<>(offset);
long rsCount = 0;
if(Objects.nonNull(arr)){
rsCount = hits.getLong("total");
if(rsCount > 0){
for (int i = 0;i < arr.size();i++) {
Map<String,Object> map = (Map<String,Object>)(arr.getJSONObject(i).getJSONObject("_source"));
map.put("_id", arr.getJSONObject(i).getString("_id"));
rsList.add(map);
}
}
}
return new RestData<>(rsList,rsCount);
}
@Override
public StatDataBean statDimension1(String ip, Integer port, String username, String password, List<String> databases, List<String> tables,
String aggs,String query, Integer returnType, Integer pageSize) {
StatDataBean rs = new StatDataBean();
List<String> xdata = new ArrayList<>();
List<Double> sdata = new ArrayList<>();
Map<String,Object> requestData = Maps.newHashMap();
try {
requestData.put("aggs", JSON.parse(aggs));
requestData.put("size", 0);
if(query!=null && !query.equals("")){
requestData.put("query", JSON.parse(query));
}
String rsData = EsRestClient.sendPost(databases, tables, JSON.toJSONString(requestData));
JSONObject jsonObj = JSON.parseObject(rsData);
JSONObject byKey = jsonObj.getJSONObject("aggregations").getJSONObject("colors");
JSONArray arr = byKey.getJSONArray("buckets");
if(Objects.nonNull(arr)){
for (int i = 0;i < arr.size();i++) {
JSONObject obj = arr.getJSONObject(i);
String k = obj.getString("key_as_string");
k = Objects.isNull(k)?obj.getString("key"):k;
long v = obj.getLong("doc_count");
if(returnType== StatDataBean.returnType.KV){
rs.addKVData2Series(k, v);
}else{
xdata.add(k);
sdata.add(Double.valueOf(v));
}
}
}
} catch (Exception e) {
throw e;
}
rs.addData2X(xdata);
rs.addData2Series("",sdata);
return rs;
}
public StatDataBean statDimension2(String ip, Integer port, String username, String password, List<String> databases, List<String> tables,
String aggs, String query, Integer returnType, Integer pageSize) {
StatDataBean rs = new StatDataBean();
Table<String, String, Double> rsTable = HashBasedTable.create();
Map<String,Object> requestData = Maps.newHashMap();
try {
requestData.put("aggs", JSON.parse(aggs));
requestData.put("size", 0);
if(query!=null && !query.equals("")){
requestData.put("query", JSON.parse(query));
}
String rsData = EsRestClient.sendPost(databases, tables, JSON.toJSONString(requestData));
JSONObject jsonObj = JSON.parseObject(rsData);
JSONObject byKey = jsonObj.getJSONObject("aggregations").getJSONObject("by_key1");
JSONArray arr = byKey.getJSONArray("buckets");
if(Objects.nonNull(arr)){
for (int i = 0;i < arr.size();i++) {
JSONObject obj1 = arr.getJSONObject(i);
String k1 = obj1.getString("key_as_string");
k1 = Objects.isNull(k1)?obj1.getString("key"):k1;
JSONObject byKey2 = obj1.getJSONObject("by_key2");
JSONArray arr2 = byKey2.getJSONArray("buckets");
for (int j = 0;j < arr2.size();j++) {
JSONObject obj2 = arr2.getJSONObject(j);
String k2 = obj2.getString("key_as_string");
k2 = Objects.isNull(k2)?obj2.getString("key"):k2;
long v = obj2.getLong("doc_count");
rsTable.put(k1, k2, Double.valueOf(v));
}
}
}
List<String> xdata = new ArrayList<>();
xdata.addAll(rsTable.rowKeySet());
rs.addData2X(xdata);
for(String k2 : rsTable.columnKeySet()){
List<Double> sdata = new ArrayList<>();
for(String k1 : xdata){
Double v = rsTable.get(k1, k2);
v = Objects.isNull(v)?0.0:v;
sdata.add(v);
}
rs.addData2Series(k2,sdata);
}
} catch (Exception e) {
throw e;
}
return rs;
}
/* public boolean checkIndexIsExist(String ip, int port, String database){
return checkTypeIsExist(ip, port, database, null);
}*/
public boolean checkTypeIsExist(RestClient restClient, String database, String table){
return EsRestClient.sendHead(restClient, database, table);
}
@Override
public int createTable(String ip, Integer port, String database, String table,List<MyDataTableCreateBean> colList) {
try{
RestClient restClient = EsRestClient.getClient(ip, port);
if(checkTypeIsExist(restClient, database, table))
return 0;
Map<String,Object> type = Maps.newHashMap();
Map<String,Object> properties = Maps.newHashMap();
Map<String,Object> fields = Maps.newHashMap();
for(MyDataTableCreateBean col : colList){
Map<String,Object> field = Maps.newHashMap();
//字段类型
switch(col.getType()){
case MyDataTableCreateBean.Type.Integer:
field.put("type", "integer");
break;
case MyDataTableCreateBean.Type.Long:
field.put("type", "long");
break;
case MyDataTableCreateBean.Type.Date:
field.put("type", "date");
field.put("format", "yyyyMMdd || yyyy-MM-dd HH:mm:ss");
break;
default :
field.put("type", "text");
// field.put("type", "text");
break;
}
if(col.getIsIndex()>0){
//field.put("index_analyzer", "ik");
// field.put("analyzer", "ik_max_word");
}else{
field.put("index", "not_analyzed");
}
fields.put(col.getField(), field);
}
properties.put("properties", fields);
type.put(table, properties);
String mappings = "{\"mappings\":"+JSON.toJSONString(type)+"}";
String endPoint = "/"+database;
if(EsRestClient.sendHead(restClient, database, "")){//已存在
mappings = JSON.toJSONString(properties);
endPoint = "/"+database+"/_mapping/"+table;
}
HttpEntity entity = new NStringEntity(mappings, ContentType.APPLICATION_JSON);
Response response = restClient.performRequest("PUT", endPoint, Collections.singletonMap("pretty", "true"),entity);
JSONObject jsonObj = JSON.parseObject(EntityUtils.toString(response.getEntity()));
if(jsonObj.getBooleanValue("acknowledged")){
return 1;
}
EsRestClient.close(restClient);
} catch (Exception e) {
log.error(e);
return 0;
}
return 1;
}
@Override
public int dropTable(RestClient restClient, String database, String table){
int flag = 0;
try {
if(checkTypeIsExist(restClient, database, table)){//索引或type存在
String rs = EsRestClient.sendDelete(restClient,database,table);
JSONObject jsonObj = JSON.parseObject(rs);
if(jsonObj.getBooleanValue("acknowledged")){
flag = 1;
}
}
} catch (Exception e) {
log.error(e);
return flag;
}
return flag;
}
@Override
public void dropData(RestClient restClient, String database, String table, String id) {
EsRestClient.sendDelete(restClient,database,table,id);
}
@Override
public void addData(String ip, int port, String database, String table,String objId, String data) {
EsRestClient.sendPut(ip, port, database, table, objId, data);
}
}
测试
public Boolean addMapping2(String index, String type,List<MyDataTableCreateBean> colList) {
String es_ip = CommonResource.cloud_es_dm_ip;
int es_port = CommonResource.cloud_es_dm_tcp_port;
try{
//this.myDataElasticSearchDriver.createTable(es_ip, CommonResource.cloud_es_dm_rest_port, index, type, colList);
List<String> databases=new ArrayList<>();
databases.add("cars");
List<String> tables=new ArrayList<>();
tables.add("transactions");
List<String> fields=new ArrayList<>();
fields.add("title");
fields.add("cooperationWay");
fields.add("type");
String query="{\"match\":{\"title\":\"技\"}}";
String aggs="{\"colors\":{\"terms\":{ \"field\": \"color\"}}}";
Integer returnType=0;
Integer pageSize=0;
int start=0;
int offset=100;
//RestData<Map<String, Object>> mapRestData = this.myDataElasticSearchDriver.searchData(es_ip, CommonResource.cloud_es_dm_rest_port, index, type, databases, tables,fields,query,sort,start,offset);
StatDataBean statDataBean = this.myDataElasticSearchDriver.statDimension1(es_ip, CommonResource.cloud_es_dm_rest_port, index, type, databases, tables, aggs, "", returnType, pageSize);
for(String s :tables)
System.out.println(s);
return true;
}catch (Exception e){
return false;
}
}