Java 泛型的使用，日志入ES

最新推荐文章于 2023-10-08 23:30:00 发布
最新推荐文章于 2023-10-08 23:30:00 发布
阅读量618 收藏 1
点赞数
分类专栏： java 文章标签： java elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45739956/article/details/119999326
版权

ES支持哪些数据类型？？

① 基本字段类型
字符串：text(分词),keyword(不分词)   StringField(不分词文本),TextFiled(要分词文本)
              text默认为全文文本，keyword默认为非全文文本
数字：long,integer,short,double,float
日期：date
逻辑：boolean
② 复杂数据类型
对象类型：object
数组类型：array
地理位置：geo_point,geo_shape

在这里插入图片描述

在这里插入图片描述

注意:如果已经有数据,不能直接做映射,先删除掉,在添加映射,再添加数据
***简单映射***

POST {indexName}/{typeName}/_mapping
{
    "{typeName}": {
        "properties": {
            "id": {
                "type": "long"
            },
            "content": {
                "type": "text",
                "analyzer": "ik_smart",
                "search_analyzer": "ik_smart"
            }
        }
    }


注意：你可以在第一次创建索引的时候指定映射的类型。此外，你也可以晚些时候为新类型添加映射（或者为已有的类型更新映射）。

你可以向已有映射中增加字段，但你不能修改它。如果一个字段在映射中已经存在，这可能意味着那个字段的数据已经被索引。如果你改变了字段映射，那已经被索引的数据将错误并且不能被正确的搜索到。

我们可以更新一个映射来增加一个新字段，但是不能把已有字段的类型那个从 analyzed  改到 not_analyzed。
**同时对多个类型的映射配置方式（推荐）**
PUT {indexName}
{
  "mappings": {
    "user": {
      "properties": {
        "id": {
          "type": "integer"
        },
        "info": {
          "type": "text",
          "analyzer": "ik_smart",
          "search_analyzer"
        }
      }
    },
    "dept": {
      "properties": {
        "id": {
          "type": "integer"
        },
        ...更多字段映射配置
      }
    }
  }
}

对象及数组类型映射

在这里插入图片描述

数组与对象数组 --> 注意：数组中元素的类型必须一致。

在这里插入图片描述

)对象数组 - 里面所有对象字段的类型是一样的–>只需映射一个就好

在这里插入图片描述

注意1：同内联对象一样，对象数组也会被扁平化索引

在这里插入图片描述

注意2：扁平化后，对象属性的相关性已经丢失，因为每个多值字段只是一个数值集，不是排序的数组。

比如查询：哪个女朋友的年龄是18岁？ 这个是无法查询到答案，如果需要保留关系，需要使用嵌套对象nested objects。

全局映射

  • 【 全局映射可以通过动态模板和默认设置两种方式实现 】

ex:员工类型的id要改为integer,而且部门类型的也要改为integer,甚至所有的都要改.这时每个都去修改非常麻烦.可以设置全局映射

默认方式：default

[ 一般用来设置_all不要了 ]
索引下所有的类型映射配置会继承_default_的配置，user类型的文档中将不会合并所有字段到_all，而dept会 如：

在这里插入图片描述

动态模板：dynamic_templates

注意：ES会默认把string类型的字段映射为text类型（默认使用标准分词器）和对应的keyword类型，如：

在这里插入图片描述
在实际应用场景中，一个对象的属性中，需要全文检索的字段较少，大部分字符串不需要分词，因此，需要利用全局模板覆盖自带的默认模板：
在这里插入图片描述

说明：上例中定义了两种动态映射模板string_as_text和string_as_keyword
在实际的类型字段映射时，会依次匹配：
    ①字段自定义配置
    ②全局dynamic_templates[string_as_text、string_as_keyword]
    ③索引dynamic_templates[...]
    ④ES自带的string类型映射，以最先匹配上的为准。
注意：索引库在创建的时候会继承当前最新的dynamic_templates，索引库创建后，修改动态模板，无法应用到已存在的索引库。

实践：映射的配置会影响到后续数据的索引过程，因此，在实际项目中应遵循如下顺序规则： 【有数据不做映射+根据优先级倒序来】

① 配置全局动态模板映射（覆盖默认的string映射）
② 配置字段映射（由于基本类型主要用于过滤和普通查询，因此，字段映射主要对需要全文检索的字段进行配置）
③ 创建、更新和删除文档
④ 搜索

优化后的代码

@Data
public class InvokeRequest {
    /**
     * 请求地址
     */
    private String url;
    /**
     * 请求接口名称
     */
    private String interfaceName;
    /**
     * 请求参数
     */
    private Object request;
    /**
     * 请求方法
     */
    private String method;
    /**
     * 编码方式
     */
    private String codeScheme;
    /**
     * 接口路径
     */
    private String interfacePath;

}

import **************************;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Slf4j
@Service
@AllArgsConstructor
@NoArgsConstructor
public class InvokeService {

    @Value("${method.address}")
    private String address;

    @Resource
    private RequestContext requestContext;
    @Autowired
    private TokenService tokenService;
    @Autowired
    private LogService logService;

    public <E extends BaseResponse> E invoke(InvokeRequest invokeRequest, Class<E> responseClazz) {
        log.info("调用 {} 接口请求信息: {}", invokeRequest.getInterfacePath(), invokeRequest);

        String token = tokenService.getToken();
        String result = "";
        TimeInterval timeInterval = new TimeInterval();
        ICommonParam commonParam = requestContext.getCommonParam() == null ? new BaseCommonParam() : requestContext.getCommonParam();

        // 定义需要返回的对象
        E response = null;

        String url = address + "/openapi/httpService/" + invokeRequest.getInterfacePath() + "?access_token=" + token + "&method=" + invokeRequest.getMethod() + "&format=json";
        String requestParm = CustomJsonUtil.objectToJson(invokeRequest.getRequest());
        try {
            response = responseClazz.newInstance();

            if (StrUtil.isEmpty(token)) {
                response.setResCode("-1");
                response.setResDesc("未获取到token");
            }

            result = HttpRequestUtil.sendPost(url, requestParm, invokeRequest.getCodeScheme());

            log.info("调用 {} 接口返回信息: {} ", invokeRequest.getInterfaceName(), result);

            response = (E) CustomJsonUtil.jsonToObject(result, responseClazz);
        } catch (Exception e) {
            log.error(" error", e);
            response.fail(e.getMessage());
        } finally {
            log.info("调用 {} 接口用时: {} 毫秒", invokeRequest.getInterfaceName(), timeInterval.interval());
            logService.addLog(invokeRequest, url, commonParam, requestParm, result, response.getResCode(), timeInterval.interval());
        }

        return response;
    }

}

addLog() ，日志入es

import **************;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;

import lombok.extern.slf4j.Slf4j;
import org.frameworkset.elasticsearch.ElasticSearchHelper;
import org.frameworkset.elasticsearch.client.ClientInterface;
import org.frameworkset.spi.async.annotation.Async;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.Date;

/**
 * 记录接口日志
 */
@Slf4j
@Service
public class LogService {

    private static final String BASE_INDEX_NAME_LOG_CMOP = "ubp-log-cmop";
    public static final String CREATE_CMOP_LOG = "createCmopLog";
    private static String INDEX_NAME;
    private String mappath = "esmapper/LogCmop.xml";

    @Autowired
    private ProjectProperties projectProperties;

    @PostConstruct
    public void LogApiEsService() {
        // ubp-log-cmop-stage-ubp
        INDEX_NAME = BASE_INDEX_NAME_LOG_CMOP.concat(StrUtil.DASHED).concat(ProjectProperties.env).concat(StrUtil.DASHED).concat(projectProperties.getGroup());
    }

    @Async
    public void addLog(InvokeRequest invokeRequest, String url, ICommonParam commonParam, String requestParm, String result, String returnCode, long interval) {
        LogCmop logCmop = new LogCmop();
        logCmop.setRequestUrl(url);
        logCmop.setRequestParam(StrUtil.subPre(requestParm, 2000));
        logCmop.setMethodName(invokeRequest.getMethod());
        logCmop.setRemark(invokeRequest.getInterfaceName());
        logCmop.setDuration(interval);
        logCmop.setReturnCode(returnCode);
        logCmop.setReturnMessage(StrUtil.subPre(result, 5000));
        logCmop.setChainId(commonParam.getChainId());
        logCmop.preInsert();

        ClientInterface client = ElasticSearchHelper.getConfigRestClientUtil(mappath);
        String dynamicIndexName = this.createDynamicIndexIfNotExist(client);

        LogCmopES logCmopES = new LogCmopES();
        BeanUtils.copyProperties(logCmop, logCmopES);
        logCmopES.setUserId(logCmop.getCreateBy());
        logCmopES.setTimestamp(DateUtil.format(new Date(), DatePattern.UTC_MS_WITH_ZONE_OFFSET_PATTERN));

        client.addDocument(dynamicIndexName, logCmopES);
    }

    private String createDynamicIndexIfNotExist(ClientInterface client) {
        String dynamicIndexName = client.getDynamicIndexName(INDEX_NAME);

        boolean existence = client.existIndice(dynamicIndexName);
        if (!existence) {
            client.createIndiceMapping(dynamicIndexName, CREATE_CMOP_LOG);
        }
        return dynamicIndexName;
    }

}

日志的实体类

@Data
@EqualsAndHashCode(callSuper = true)
@TableName("tb_log_cmop")
public class LogCmop extends BaseEntity {
    /**
     * 请求URL
     */
    private String requestUrl;
    /**
     * 请求参数
     */
    private String requestParam;
    /**
     * 方法名称
     */
    private String methodName;
    /**
     * 请求耗时
     */
    private Long duration;
    /**
     * 返回码
     */
    private String returnCode;
    /**
     * 返回信息
     */
    private String returnMessage;
    /**
     * 链路ID
     */
    private String chainId;
}

ES日志实体


@Data
public class LogCmopES {
    /**
     * 请求URL
     */
    private String requestUrl;
    /**
     * 请求参数
     */
    private String requestParam;
    /**
     * 方法名称
     */
    private String methodName;
    /**
     * 请求耗时
     */
    private Long duration;
    /**
     * 返回码
     */
    private String returnCode;
    /**
     * 返回信息
     */
    private String returnMessage;
    /**
     * 接口名称（中文）
     */
    private String interfaceName;
    /**
     * 链路ID
     */
    private String chainId;
    /**
     * 格林尼治时间
     */
    private String timestamp;
    /**
     * 用户id
     */
    private Long userId;
}

esmapper.xml

<properties>

    <property name="createCmopLog">
        <![CDATA[{
        "settings": {
            "number_of_shards": 1,
            "number_of_replicas": 0
        },
        "mappings": {
            "properties": {
                "requestUrl": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "requestParam": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "methodName": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "duration": {
                    "type": "integer"
                },
                "returnCode": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "returnMessage": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "interfaceName": {
                    "type": "keyword"
                },
                "chainId": {
                    "type": "keyword"
                },
				"userId": {
					"type": "keyword"
				},
                "timestamp": {
                    "type": "date"
                }
            }
        }
        }]]>
    </property>

</properties>

未优化的代码

import *********************；
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.frameworkset.spi.async.annotation.Async;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

/**
 * 记录接口日志
 */
@Slf4j
@Service
@AllArgsConstructor
@NoArgsConstructor
public class LogServiceImpl  implements LogService {
    @Autowired
    private RequestContext requestContext;
    @Autowired
    private LogCmopService logCmopService;
    @Value("${method.address}")
    private String address;


    @Async
    @Override
    public <T, E extends BaseResponse> E invoke(LogRecordRequest recordRequest, Class<E> responseClazz) {
        log.info("调用 {} 接口", recordRequest.getInterfacePath());
        String result = "";
        TimeInterval timeInterval = new TimeInterval();
        ICommonParam commonParam = requestContext.getCommonParam() == null ? new BaseCommonParam() : requestContext.getCommonParam();
        //定义需要返回的对象
        E response = null;
        String token = recordRequest.getToken();
        if (StrUtil.isEmpty(token)) {
            response.setResCode("-1");
            response.setResDesc("未获取到token");
        } else {
            String url = address + recordRequest.getInterfacePath() + "?access_token=" + token + "&method=" + recordRequest.getMethod() + "&format=json";
            try {
                response = responseClazz.newInstance();
                result = HttpRequestUtil.sendPost(url, recordRequest.getRequest(), recordRequest.getCodeScheme());
                log.info("调用 {} 接口返回信息: {} ",recordRequest.getInterfaceName(), result);
                response = (E) CustomJsonUtil.jsonToObject(result, recordRequest.getT().getClass());
            } catch (Exception e) {
                log.error(" error", e);
                response.setResCode(AdapterEnum.CODE_1004.getCode());
                response.setResDesc(AdapterEnum.CODE_1004.getValue());
                return response;
            } finally {
                log.info("调用 {} 接口用时: {} 毫秒",recordRequest.getInterfaceName(), timeInterval.interval());
                LogCmopAddRequest logCmopAddRequest = new LogCmopAddRequest();
                logCmopAddRequest.setRequestUrl(recordRequest.getUrl());
                logCmopAddRequest.setRequestParam(StrUtil.subPre(recordRequest.getRequest(), 2000));
                logCmopAddRequest.setMethodName(recordRequest.getMethod());
                logCmopAddRequest.setDuration(timeInterval.interval());
                logCmopAddRequest.setReturnCode(response.getResCode());
                logCmopAddRequest.setReturnMessage(StrUtil.subPre(result, 5000));
                logCmopAddRequest.setChainId(commonParam.getChainId());
                logCmopService.add(logCmopAddRequest);
            }
        }
        return response;
    }
}
任小伍
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 异步写文件_java异步写日志到文件中实现代码
weixin_35974392的博客
02-12 380
java异步写日志到文件中详解实现代码：package com.tydic.ESUtil;import java.io.File;import java.io.FileWriter;import java.io.IOException;import java.io.InputStream;import java.io.PrintWriter;import java.util.Properties;...
JAVA-日志的异步收集输出
纵马饮白虹的博客
05-24 2321
记录一下最近做的一个Web项目中的日志问题 项目使用的日志体系如下：使用sl4j作为门面，log的实际实现是log4j 问题如下： 在请求高并发的情况下，推测日志会出现串的情况。 举个例子： public void echo() { log.info("Function begin"); //...省略若干行代码... log.info("Function ru...
Logstash 只将 Java 错误日志写入 es 索引
panbuhei
08-05 849
此文档中包含一个 Logstash 加载多个配置文件和只输出 Java 错误日志的配置文件。
java日志到ES索引的字段细化
lihongbiao0610的博客
07-08 813
java日志收集到ES索引，由message字段对应一整行日志 拆分为多个字段对应一行日志的过程叫做java日志到ES索引的字段细化。
logstash收集java程序日志，并保存到es中
ka3p06的博客
12-04 5061
说明：收集多个java程序的日志，并输出到es中。   编辑logstash的conf文件 vim log.conf 配置文件内容如下： input { file { start_position =&gt; end ### 读文件的位子 path =&gt; "/root/projects/fp-ap...
Java进阶路线
02-15
- **Lucene, ElasticSearch, Solr, ELK**：流行的企业级搜索解决方案。 - **准确性, 召回率, 实时性**：评估搜索质量的关键指标。 - **禁词, 同义词, 直达, 分词**：提高搜索相关性的技术手段。 #### 十七、性能...
Java面试题大全（整理版）1000+面试题 (面试准备+Java基础+高级特性+常见问题+答案解析)
08-16
Java面试题大全，涵盖范围广泛，包括Java基础、高级特性、常见问题以及各种技术栈的面试题，如MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、Redis、MySQL等，旨在帮助Java开发者提升面试成功率。...
spring-data-elasticsearch基本添删改查,maven项目
04-17
3. **实体类定义**：在Spring Data Elasticsearch中，我们需要为要索引的数据定义对应的Java实体类。这些类通常包含`@Document`注解，指定索引名，并且类中的字段使用`@Field`注解来定义其在Elasticsearch中的映射。...
java学习路线pdf版本
01-06
- ELK(Elasticsearch、Logstash、Kibana)。 17. **虚拟化/容器化**： - Docker容器技术。 - Kubernetes、Swarm容器编排。 这个学习路线覆盖了Java开发中的主要知识点，通过这个路线，学习者可以系统地学习并...
针对日志产生上报到es的实践
weizainaiping的博客
09-28 1240
背景 日志检索是在服务治理中用来快速定位错误的一个主要方式，在没有日志检索服务之前，都是需要通过获取相应的日志来进行排查定位。这是一个传统的方式。 为了更快地提升排查效率，现在市场上出现了很多关于日志检索的框架，比较常见的是ELK的搭建方式。 在这里面logStash是相对比较重的软件，目前针对日志，采用filebeat来替换采集。 遇到问题 因为elasticsearch是使用json格式来持久化文档，为了更好地控制日志检索的效果，我们需要特别的处理日志上报的json内容，同时也可以减少在fil
springBoot整合kafka和elasticSearch,实现批量拉取日志以及批量更新到es里
01-15
从Kafka中批量拉去数据，然后批量更新到es里。一次拉取的数量可以设置，现在是10000，轻松运转，更新到es内部也是，目标是百万日志秒处理
springboot项目查询es中的日志内容
04-21
自己系统配置了切面将所需操作数据存入elasticSearch后，使用java进行查询操作es，从而查看筛选日志。前端采用的是layUi，进行简单的筛选和展示
日志整合Slf4j
呼啦呼啦嘞的博客
12-28 118
日志整合
Es 8.x Index和Mapping详解及Java API 注解
最新发布
lixinkuan的博客
10-08 1896
【代码】Es 8.x Java API 注解详解。
ES部署使用及java接入手册
LaughingBi的博客
03-01 2852
通过ElasticSearch搜索。
第07讲：Java操作之ElasticSearch高级查询
分享日常工作技术
01-09 1110
运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果：
Elasticsearch 无阻碍查询，泛型封装，反射实现。让你ES查询只需要一个实现
weishui21的博客
07-05 350
ES好处和作用就不多说了，但是查询让人烦躁，看了无数大佬作品，几乎没有封装的方法。一个表一个查询方法，让人苦不堪言 更具自己需要的类型随意封装查询，可以可以根据java的设计模式来实现case过程...
Log4j2自定义Appender将日志写入到ElasticSearch
poxiaomeng187的博客
08-04 2117
海豚调度DolpinScheduler做任务调度。流程是 提交一个shell 到海豚，shell里使用 spark-submit 提交 java 程序，然后使用海豚的api 去获取日志,log4j2自定义appender
java es mapping_ES之Mapping映射创建
weixin_35890416的博客
02-19 2740
packagees;importorg.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder;importorg.elasticsearch.client.AdminClient;importorg.elasticsearch.client.IndicesAdminClient;importorg.elasticse...
深入解析Java泛型的使用与应用
- 泛型是Java中的“参数化类型”，它允许你在类、接口和方法的声明中使用类型参数，而非固定的类型。这类似于函数参数，但这里的类型参数不是在运行时动态绑定的，而是在编译期间确定。 - 泛型的核心目标是通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值