Elasticsearch Java-API CRUD Java操作Elasticsearch

                 参考资料:

请使用google浏览器安装Sense,或在liunx下使用curl。
Es restful api 是基础，要先学一下才能使用java-pai，不然相当模糊。

Es入门很容易，但是主要难度在高级查询上，很多高级的查询相当复杂，需要不断学习。我现在只是了解点皮毛而已。

http://eggtwo.com/news/detail/143
http://es.xiaoleilu.com/030_Data/20_Exists.html
http://blog.csdn.net/cnweike/article/details/33736429

Es的maven库

     <!-- elasticsearch -->```
    <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>2.1.0</version>
        </dependency>

1.获取ELasticsearch的Client，client是elasticsearch java的客户端操作入口，需要传递ip地址和端口号。

public abstract class AbstractElasticsearchService {

private static Logger logger = Logger.getLogger(AbstractElasticsearchService.class);

private Client client;

/**
 * 初始化方法
 */
public abstract void init();

/**
 * 获取client
 * 
 * @return
 * @throws Exception
 */
public Client getClient() throws Exception {

    if (client == null) {
        client = TransportClient.builder().build()
                .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("localhost"), 9300));
    }
    return client;
}

/**
 * 关闭client
 */
public void closeClient() {
    client.close();
}

/**
 * 创建索引
 * 
 * @throws Exception
 */
public void createIndex(String indexName) throws Exception {
    CreateIndexResponse createIndexResponse = getClient().admin().indices().prepareCreate(indexName).execute()
            .actionGet();
    System.out.println(createIndexResponse.isAcknowledged());
}

/**
 * 创建domain对应的映射
 * 
 * @param analyzeFields
 * @param indexType
 * @return
 * @throws Exception
 */
public XContentBuilder getDomainMapping(List<String> analyzeFields, String indexType) throws Exception {

    XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject(indexType)
            .startObject("properties");

    for (String field : analyzeFields) {
        mapping = mapping.startObject(field).field("type", "string").field("store", "yes").endObject();
    }
    mapping = mapping.endObject().endObject().endObject();
    return mapping;
}

/**
 * 创建映射
 * 
 * @param mapping
 * @param indexName
 * @param indexType
 * @return
 * @throws Exception
 */
public PutMappingResponse createMapping(XContentBuilder mapping, String indexName, String indexType)
        throws Exception {

    PutMappingRequest mappingRequest = Requests.putMappingRequest(indexName).type(indexType).source(mapping);
    PutMappingResponse mappingResponse = getClient().admin().indices().putMapping(mappingRequest).actionGet();
    return mappingResponse;
}

/**
 * 封装esTerms的请求参数
 * 
 * @param esTerms
 * @return
 */
protected String buildQueryString(List<ESTerm> esTerms) {
    StringBuilder stringBuilder = new StringBuilder();
    if (esTerms == null) {
        logger.debug("The esTerm is empty");
        return null;
    }

    for (int i = 0; i < esTerms.size(); i++) {
        ESTerm esTerm = esTerms.get(i);

        if (i == 0) {
            stringBuilder.append(esTerm.getName() + ":" + esTerm.getValue());
            continue;
        }
        stringBuilder.append("OR");
        stringBuilder.append(esTerm.getName() + ":" + esTerm.getValue());
    }
    return stringBuilder.toString();
}

/**
* 删除一个索引库，相当于删除数据库
* @param indexName
* @return
*/
public boolean deleteIndex(String indexName) {

    if (indexName == null) {
        logger.debug("The indexName is empty");
        return false;
    }
    try {
        DeleteIndexRequest request = new DeleteIndexRequest(indexName);
        DeleteIndexResponse deleteIndexResponse = getClient().admin().indices().delete(request).actionGet();
        if (!deleteIndexResponse.isAcknowledged()) {
            logger.debug("The delete fail");
            return false;
        }
        return true;
    } catch (Exception e) {
        return false;
    }

}


/**
 * 
 * @param keyword  需要查询的关键字
 * @param esMatches 构建查询条件
 */
public void buildESMatch(String keyword, List<ESTerm> esMatches) {

    if (keyword != null) {
        keyword = keyword.trim();
    }
    List<String> useToSearch = new ArrayList<String>();// 此处可以在spring中进行配置
    if (useToSearch != null) {
        final String finalTerm = keyword;
        for (String searchName : useToSearch) {
            ESTerm esMatch = new ESTerm();
            esMatch.setName(searchName);
            esMatch.setValue(finalTerm);
            esMatches.add(esMatch);
        }

    }

}

}

public class MechanismSearchService extends AbstractElasticsearchService {

private static Logger logger = Logger.getLogger(AbstractElasticsearchService.class);

@Override
public void init() {
    try {
        createIndex("dragon", true);

        List<String> fields = new ArrayList<String>();
        fields.add("id");
        fields.add("accountType");
        fields.add("organizationName");
        fields.add("accountCode");
        fields.add("organizationName");
        fields.add("accountCode");
        fields.add("createDate");
        fields.add("contacts");
        fields.add("callPhone");
        fields.add("capitalAccountLimits");
        fields.add("subAccountLimits");
        fields.add("status");
        fields.add("username");
        fields.add("password");
        fields.add("freezeNote");
        fields.add("accountNote");
        XContentBuilder mapping = getDomainMapping(fields, "mechanism");
        createMapping(mapping, "dragon", "mechanism");
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }
}

/**
 * 创建机构列表的索引
 * 
 * @param mechanisms
 * @throws Exception
 */
public void createMechismIndex(List<Mechanism> mechanisms) throws Exception {

    if (mechanisms == null) {
        return;
    }
    for (Mechanism mechanism : mechanisms) {
        String jsonData = JSONObject.toJSONString(mechanism);
        IndexResponse indexResponse = getClient().prepareIndex().setIndex("dragon").setType("mechanism")
                .setId(mechanism.getId().toString()).setSource(jsonData).execute().actionGet();
        System.out.println("创建索引的版本号:" + indexResponse.getVersion());
    }

}

/**
 * 增加一条机构的索引
 * 
 * @param mechanism
 */
public void insertMechismIndex(Mechanism mechanism) {
    if (mechanism == null) {
        logger.debug("The mechanism is empty");
        return;
    }
    try {
        String jsonData = JSONObject.toJSONString(mechanism);
        IndexResponse indexResponse = getClient().prepareIndex().setIndex("dragon").setType("mechanism")
                .setId(mechanism.getId().toString()).setSource(jsonData).execute().actionGet();
        logger.debug("create index version is:" + indexResponse.getVersion());
    } catch (Exception e) {
        logger.debug("The insert Mechism is fail");
        logger.debug(e.getMessage());
    }
}

/**
 * 修改一条索引的内容
 * 
 * @param mechanism
 */
public void updateMecjismIndex(Mechanism mechanism) {
    if (mechanism == null) {
        logger.debug("The mechanism is empty");
        return;
    }
    try {
        String jsonData = JSONObject.toJSONString(mechanism);
        UpdateResponse updateResponse = getClient().prepareUpdate().setIndex("dragon").setType("mechanism")
                .setId(mechanism.getId().toString()).setDoc(jsonData.getBytes()).execute().actionGet();
        logger.debug("update idnex version is:" + updateResponse.getVersion());
    } catch (Exception e) {
        logger.debug("The update mechanism is empty");
        logger.debug(e.getMessage());
    }

}

/**
 * 搜索机构列表的结果
 * 
 * @param esTerm
 * @return
 * @throws Exception
 */
public SearchResponse findMechismIndex(ESTerm esTerm, List<ESTerm> esMatches, ESRange esRange,
        List<ESSort> esSortList, ESAggregation esAggregation) throws Exception {

    SearchResponse response = null;
    try {
        SearchRequestBuilder searchRequestBuilder = buildSearchRequestBuilder();
        BoolQueryBuilder qb = QueryBuilders.boolQuery();
        searchRequestBuilder.setQuery(qb);

        if (esTerm != null) {
            qb.must(QueryBuilders.termQuery(esTerm.getName(), esTerm.getValue()));
        }
        buildQueryBuilder(esMatches, esRange, esSortList, esAggregation, searchRequestBuilder, qb);
        logger.debug(searchRequestBuilder.toString());
        response = searchRequestBuilder.execute().actionGet();
        return response;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return response;
}

private SearchRequestBuilder buildSearchRequestBuilder() throws Exception {
    return getClient().prepareSearch("dragon").setTypes("mechanism").setSearchType(SearchType.DFS_QUERY_THEN_FETCH);
}

/**
 * 
 * @param esTerms
 * @param esMatches
 * @param esRange
 * @param esSortList
 * @param esAggregation
 * @return
 * @throws Exception
 */
public SearchResponse findMechismIndex(List<ESTerm> esTerms, List<ESTerm> esMatches, ESRange esRange,
        List<ESSort> esSortList, ESAggregation esAggregation) throws Exception {
    SearchResponse response = null;
    try {
        SearchRequestBuilder searchRequestBuilder = buildSearchRequestBuilder();
        BoolQueryBuilder qb = QueryBuilders.boolQuery();
        searchRequestBuilder.setQuery(qb);

        if (esTerms != null) {
            for (ESTerm term : esTerms) {
                qb.should(QueryBuilders.termQuery(term.getName(), term.getValue()));
            }
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
    return response;
}

/**
 * 封装请求的参数
 * 
 * @param esMatches
 * @param esRange
 * @param esSortList
 * @param esAggregation
 * @param searchRequestBuilder
 * @param qb
 * @return
 */
public void buildQueryBuilder(List<ESTerm> esMatches, ESRange esRange, List<ESSort> esSortList,
        ESAggregation esAggregation, SearchRequestBuilder searchRequestBuilder, BoolQueryBuilder qb) {

    String queryString = null;

    queryString = buildQueryString(esMatches);

    // 封装esTerm的条件
    if (queryString != null) {
        qb.must(QueryBuilders.queryStringQuery(queryString));
    }
    // 封装排序条件
    if (esSortList != null) {
        for (ESSort esSort : esSortList) {
            FieldSortBuilder sortBuilder = new FieldSortBuilder(esSort.getPropertyName());
            sortBuilder.order(esSort.getSortOrder());
            sortBuilder.unmappedType("long");
            searchRequestBuilder.addSort(sortBuilder);
        }
    }
    // 封装聚合条件
    if (esAggregation != null) {
        searchRequestBuilder.addAggregation(AggregationBuilders.terms(esAggregation.getAggregationName())
                .field(esAggregation.getPropertyName()));
    }
    // 封装区间条件，价格
    if (esRange != null) {
        qb.filter(QueryBuilders.rangeQuery(esRange.getPropertyName()).from(esRange.getFrom()).to(esRange.getTo()));
    }

}

/**
 * 删除一个type下具体的某一个索引数据
 * 
 * @param id
 * @param type
 */
public void deleteIndex(String id, String type) {

    try {
        DeleteResponse deleteResponse = getClient().prepareDelete().setIndex("dragon").setType(type).setId(id)
                .execute().actionGet();
        Set<String> results = deleteResponse.getHeaders();
        for (String m : results) {
            logger.debug(m);
        }

        if (deleteResponse.isFound()) {
            logger.debug("the delete id is :" + id + "and type is:" + type);
            return;
        }
        logger.debug("Could not found to delete with id is :" + id + "and type is :" + type);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 测试删除一个type
 * 
 * @param type
 */
public void deleteType(String type) {

    try {
        DeleteResponse deleteResponse = getClient().prepareDelete().setIndex("dragon").setType(type).execute()
                .actionGet();
        if (deleteResponse.isFound()) {
            logger.debug("the delete  type is:" + type);
            return;
        }
        logger.debug("Could not found to   type is:" + type);
    } catch (Exception e) {
        logger.debug(e.getMessage());
    }

}

/**
 * 创建索引，是否需要覆盖原索引
 * 
 * @param indexName
 *            索引库的名字
 * @param overried
 *            是否需要覆盖
 */
public void createIndex(String indexName, Boolean overried) {
    try {
        boolean exits = getClient().admin().indices().prepareExists(indexName).execute().actionGet().isExists();
        if (exits && !overried) {
            logger.debug("The index " + indexName + "isExits,and not need ovverid");
            return;
        }
        if (exits) {
            DeleteIndexRequest request = new DeleteIndexRequest(indexName);
            DeleteIndexResponse deleteIndexResponse = getClient().admin().indices().delete(request).actionGet();
            if (!deleteIndexResponse.isAcknowledged()) {
                logger.error("Fail to delete the index " + indexName);
            }
        }
        getClient().admin().indices().prepareCreate(indexName).execute().actionGet();
    } catch (Exception e) {
        logger.debug(e.getMessage());
    }
}

}
“`