20200825：今天七夕，呱呱呱
 
Open3D是一个支持三维数据处理的开源库，支持C ++和Python。后端经过高度优化，并设置为并行化。MIT协议。
 
官网：http://www.open3d.org/
 
GitHub: https://github.com/intel-isl/Open3D
 
python版本安装方便：pip install open3d  或者
 
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple open3d
 
下面介绍C++版本的配置（相比于一行python代码，C++真是牛逼）
 
一、下载源码
 
GitHub地址：https://github.com/intel-isl/Open3D
 
1.1 克隆源码【笔者的源码路径为 D:/Open3D/Open3D】
 
 
1.2 切换版本【笔者用过的版本为 v0.8.0 和 v0.10.0】
 
 
1.3 更新子模块【用于获取第三方库！很重要！】
 
注意：v0.8.0更新的时候没有报错；但是v0.10.0更新的时候失败了【抱着试试的心态继续进行，后续没出错，感觉是我 git 用的还不熟练的原因吧】
 
 
 
结果如下：
 
 
二、CMake编译
 
2.1 设置路径
 
【source code: D:/Open3D/Open3D； build binaries: D:/Open3D】
 
【笔者设置 CMAKE/CMAKE_INSTALL_PREFIX 的路径为 D:/Open3D/install】
 
2.2 generator选择 Visual Studio 15 2017【官方建议 VS2019及以上】，optional platform for generator 选择x64
 
 
2.3 Configure -> Configure done
 
2.4 Generate -> Generating done
 
三、生成解决方案
 
3.1 打开
 
VS2017打开 D:/Open3D/Open3D.sln【官方建议 VS2019及以上】Release-x64
 
3.2 将CMakePredefinedTargets/ALL_BUILD设为启动项，右击生成
 
【v0.8.0版本报错了：...\VS2017\IDE\Common7\IDE\VC\VCTargets\Microsoft.CppCommon.targets(209,5): error MSB6006: “cmd.exe”已退出，代码为 9009。后续没报错，所以貌似好像应该可能大概 没啥影响吧】
 
【v0.10.0版本没有报错：成功61个】
 
3.3 打包包
 
右击 CMakePredefinedTargets/INSTALL，仅用于项目 -> 仅生成INSTALL；
 
在 D:/Open3D/install 中会生成CMake文件、头文件、静态库，如下图
 
 
四、测试
 
官方参考：http://www.open3d.org/docs/release/cpp_project.html#create-cplusplus-project【very nice】
 
4.1 下载测试文件
 
下载TestVisualizer.cpp和 CMakeLists.txt到 F:/testVisualizer【路径随便改，高兴就行】
 
4.2 修改TestVisualizer.cpp，完整代码如下：
 
#include <iostream>
#include <memory>
#include <thread>

#include <Open3D/Open3D.h>

// A simplified version of examples/Cpp/Visualizer.cpp to demonstrate linking
// an external project to Open3D.
int main(int argc, char *argv[])
{
	/* add by lljydyx */
	argc = 4;
	argv[1] = "pointcloud";
	argv[2] = "F:/rabbit.pcd";


    using namespace open3d;

    utility::SetVerbosityLevel(utility::VerbosityLevel::Debug);
    if (argc < 3)
	{
        utility::LogInfo("Open3D {}\n", OPEN3D_VERSION);
        utility::LogInfo("\n");
        utility::LogInfo("Usage:\n");
        utility::LogInfo("    > TestVisualizer [mesh|pointcloud] [filename]\n");
        // CI will execute this file without input files, return 0 to pass
        return 0;
    }

    std::string option(argv[1]);
    if (option == "mesh")
	{
        auto mesh_ptr = std::make_shared<geometry::TriangleMesh>();
        if (io::ReadTriangleMesh(argv[2], *mesh_ptr)) {
            utility::LogInfo("Successfully read {}\n", argv[2]);
        } else {
            utility::LogWarning("Failed to read {}\n\n", argv[2]);
            return 1;
        }
        mesh_ptr->ComputeVertexNormals();
        visualization::DrawGeometries({mesh_ptr}, "Mesh", 1600, 900);
    }
	else if (option == "pointcloud")
	{
        auto cloud_ptr = std::make_shared<geometry::PointCloud>();
        if (io::ReadPointCloud(argv[2], *cloud_ptr))
		{
            utility::LogInfo("Successfully read {}\n", argv[2]);
        }
		else
		{
            utility::LogWarning("Failed to read {}\n\n", argv[2]);
            return 1;
        }
        cloud_ptr->NormalizeNormals();
        visualization::DrawGeometries({cloud_ptr}, "PointCloud", 1600, 900);
    }
	else
	{
        utility::LogWarning("Unrecognized option: {}\n", option);
        return 1;
    }
    utility::LogInfo("End of the test.\n");

    return 0;
}
 
CMakeList.txt 如下：
 
cmake_minimum_required(VERSION 3.1)
set (CMAKE_CXX_STANDARD 14)

project(TestVisualizer)

# Find installed Open3D, this imports
#   Open3D_INCLUDE_DIRS
#   Open3D_LIBRARIES
#   Open3D_LIBRARY_DIRS
#   Open3D_C_FLAGS
#   Open3D_CXX_FLAGS
#   Open3D_EXE_LINKER_FLAGS
if(WIN32)
    find_package(Open3D HINTS ${CMAKE_INSTALL_PREFIX}/CMake)
else()
    find_package(Open3D HINTS ${CMAKE_INSTALL_PREFIX}/lib/CMake)
    list(APPEND Open3D_LIBRARIES dl)
endif()

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${Open3D_C_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Open3D_CXX_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${Open3D_EXE_LINKER_FLAGS}")

# Set OS-specific things here
if(WIN32)
    if (ENABLE_GUI)
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /FORCE:MULTIPLE")
        # Filament is built with /MT[d], but by default CMake automatically
        # sets "/MD" and "/MDd". They can't coexist, so we need to replace them.
        string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE})
        string(REPLACE "/MDd" "/MTd" CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
        string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
        string(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
    endif()
elseif(CYGWIN)
elseif(APPLE)
elseif(UNIX)
	add_definitions(-DUNIX)
	add_compile_options(-Wno-deprecated-declarations)
	add_compile_options(-Wno-unused-result)
    add_definitions(-O3)
endif(WIN32)

# Open3D
if (Open3D_FOUND)
    message(STATUS "Found Open3D ${Open3D_VERSION}")

    # link_directories must be before add_executable
    link_directories(${Open3D_LIBRARY_DIRS})

    add_executable(TestVisualizer TestVisualizer.cpp)

    target_link_libraries(TestVisualizer ${Open3D_LIBRARIES})

    target_include_directories(TestVisualizer PUBLIC ${Open3D_INCLUDE_DIRS})

    # Hot fix windows dll not found issue, assumming we're using the Release build
    option(BUILD_SHARED_LIBS "Whether Open3D was build as shared library" OFF)
    if(WIN32 AND BUILD_SHARED_LIBS)
        message("Will copy Open3D.dll to ${CMAKE_CURRENT_BINARY_DIR}/Release")
        add_custom_command(TARGET TestVisualizer POST_BUILD
                        COMMAND ${CMAKE_COMMAND} -E copy
                                ${CMAKE_INSTALL_PREFIX}/bin/Open3D.dll
                                ${CMAKE_CURRENT_BINARY_DIR}/Release)
    endif()
    if(WIN32 AND ENABLE_GUI)
        message("Will copy SDL2.dll to ${CMAKE_CURRENT_BINARY_DIR}/Release")
        add_custom_command(TARGET TestVisualizer POST_BUILD
                        COMMAND ${CMAKE_COMMAND} -E copy
                                ${CMAKE_INSTALL_PREFIX}/lib/SDL2.dll
                                ${CMAKE_CURRENT_BINARY_DIR}/Release)
    endif()

else ()
    message(SEND_ERROR "Open3D not found")
endif ()
 
4.3 按照官方参考进行 CMake 编译【笔者的Open3D_DIR路径为 D:/Open3D/install/CMake 】
 
 
4.4 Configure -> Configure done
 
4.5 Generate -> Generating done
 
 五、运行
 
VS2017打开 F:\testVisualizer\build\TestVisualizer.sln，Release-x64
 
将ALL_BUILD设置为启动项，右击生成。
 
将TestVisualizer设置为启动项，运行结果如下
 
 
 
六、编译好的Open3D库和测试代码地址
 
v0.8.0: Open3D_C++_v0.8.0_VS2017_库和测试代码、数据
 
v0.10.0: Open3D_C++_v0.10.0_VS2017 库和测试代码、数据
 
 
链接：https://pan.baidu.com/s/1BKTcEbmI9vhmKTjJv-gBlw
 提取码：fh8l
 

常见的读写操作：
 
with open(r'filename.txt') as f:
   data_user=pd.read_csv(f)  #文件的读操作

with open('data.txt', 'w') as f:
   f.write('hello world')  #文件的写操作
   
 
相关参数：
 
r:	以只读方式打开文件。文件的指针将会放在文件的开头。这是**默认模式**。
rb: 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+: 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+:以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w:	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb:	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+:	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+:以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a:	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab:	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+:	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+:以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

 
file对象的属性：
 
file.read([size])   将文件数据作为字符串返回，可选参数size控制读取的字节数
file.readlines([size])   返回文件中行内容的列表，size参数可选
file.write(str)   将字符串写入文件
file.writelines(strings)   将字符串序列写入文件
file.close()   关闭文件
file.closed	表示文件已经被关闭，否则为False

file.mode	Access文件打开时使用的访问模式
file.encoding	文件所使用的编码
file.name	文件名
file.newlines	未读取到行分隔符时为None，只有一种行分隔符时为一个字符串，当文件有多种类型的行结束符时，则为一个包含所有当前所遇到的行结束的列表
file.softspace	为0表示在输出一数据后，要加上一个空格符，1表示不加。这个属性一般程序员用不着，由程序内部使用

 OpenEuler是华为推动的一个免费开源的Linux发行平台。这篇文章简单介绍一下OpenEuler的基本信息，并以当前最新的20.09版本为例，并进行一下x86架构下虚拟机下的安装体验。
 
基本信息
 
OpenEuler的基本信息如下所示：
 
项目
说明
官方网站
https://openeuler.org/
开源/闭源
开源
代码管理地址
https://gitee.com/openeuler
下载地址
https://openeuler.org/zh/download/
文档地址
https://openeuler.org/zh/documentation/
当前版本
20.09
特点
 
在gitee上OpenEuler简介是这样写的：
 
 
 
通过社区合作，打造创新平台，构建支持多处理器架构、统一和开放的操作系统openEuler，推动软硬件生态繁荣发展。
 
 
可以看到支持多处理器架构，推动软硬生态发展是OpenEuler的目的之一，多处理架构值得就是ARM或者是X86的体系结构，OpenEuler提供了不同安装镜像供用户直接使用。
 
版本
 
 
 
版本命名方式：社区版本按照交付年份和月份进行版本号命名。例如，openEuler 20.09于2020年09月发布。
 
 
社区版本分为长期支持版本和创新版本。
 
 
长期支持版本（LTS版本）：发布间隔周期定为2年，提供4年社区支持。社区首个LTS版本openEuler 20.03 已于20年3月正式发布。
 
 
社区创新版本：openEuler每隔6个月会发布一个社区创新版本，提供6个月社区支持，下一个社区创新版本将于2021年3月发布。
 
 
 
License
 
OpenEuler社区接纳OCI所提供的开源协议列表：
 
 
 
社区认可的开源协议列表：https://opensource.org/licenses/alphabetical
 
 
 
 
社区默认使用的协议为mulan V2协议：https://opensource.org/licenses/MulanPSL-2.0
 注：木兰协议中对于授予专利许可进行了明确
 
 
下载安装镜像
 
目前OpeEuler提供了ARM和X86两种方式的安装镜像可供下载，X86的20.09的下载地址如下所示：
 
https://repo.openeuler.org/openEuler-20.09/ISO/x86_64/
 
 
带有everything的iso：包含所有的软件包，可以做本机repo源
带有debuginfo的iso：包含debuginfo
不带everything的iso：普通安装的软件包，也是本文所使用的软件包
sha256sum：用来验证下载完整性的校验和的值
 
liumiaocn:Downloads liumiao$ ls -l *openEuler*
-rw-r--r--@ 1 liumiao  staff  3790301184 Nov 28 06:14 openEuler-20.09-x86_64-dvd.iso
-rw-r--r--@ 1 liumiao  staff          97 Nov 28 06:21 openEuler-20.09-x86_64-dvd.iso.sha256sum
liumiaocn:Downloads liumiao$
 
事前准备
 
下载的完整性验证
 
使用下载的iso和sha256sum使用如下命令进行验证即可：
 
 
 
执行命令：sha256sum -c openEuler-20.09-x86_64-dvd.iso.sha256sum
 
 
liumiaocn:Downloads liumiao$ sha256sum -c openEuler-20.09-x86_64-dvd.iso.sha256sum 
openEuler-20.09-x86_64-dvd.iso: OK
liumiaocn:Downloads liumiao$ 
 
虚拟机准备
 
这里使用VirtualBox进行事前虚拟机器的准备，和普通准备并没有什么不同，资源设定如下：
 
内存 2048M
磁盘 20G
光盘设定下载的引导文件
 
 注：本文中的Virtual Box使用了NAT方式。
 
安装过程
 
安装模式说明
 
安装模式分文本模式和图形模式，主要的适应场景应该是主要在于目标机器是否有显卡的区别。本文中主要使用图形模式进行安装。
 
步骤1: 安装选项
 
 
此处和普通安装基本没有区别，选择最上面的选项进行安装即可，中间选项会检查一下安装文件之后进行安装，最后的Troubleshoot提供创建应急启动等常见特性：
 
 
从上图中可以看到，比如存在Boot From Local Driver这种应急的措施都是有的，一般的Linux发行版都具有类似的功能。
 
步骤2: 安装过程的语言设定
 
可以选择中文或者应为作为安装过程中的提示语言，此处选择中文
 
 
步骤3: 安装设定
 
基本设定
 可以进行键盘、语言、安装源、安装类型（软件选择）、分区方式以及网络设定、时区以及用户和根用户密码设定。首先必须设定的是分区方式。
 

 此处直接选择设定自动分区方式
 
 然后设定网络基本信息
 
 
 然后设定根目录用户密码，需要满足要求的安全强度
 
 如果需要创建用户也可以在安装阶段创建
 
 此时点击开始安装即可进行安装了
 
 
步骤4: 重启
 
等待安装完成，点击下图的重启按钮即可完成安装
 
 此处在Virtual Box下，当前版本在体验的过程中仍然会回到安装目录，所以安装之后手动修改一下Virtual Box的此虚拟机的Boot顺序，将硬盘调整至光驱之前即可。
 
 
步骤5: 结果确认
 
 
登录验证
 使用前文创建的密码，此处可以成功使用root登录。
 
 
 
内核版本确认
 
 
 
Systemd确认
 根进程Systemd已经就绪，firewalld服务也已经启动
 
 
 
版本确认
 
 
[root@liumiaocn ~]# ls /etc/*release*
/etc/openEuler-release  /etc/os-release  /etc/system-release  /etc/system-release-cpe
[root@liumiaocn ~]# 
[root@liumiaocn ~]# cat /etc/openEuler-release 
openEuler release 20.09
[root@liumiaocn ~]# 
[root@liumiaocn ~]# cat /etc/os-release 
NAME="openEuler"
VERSION="20.09"
ID="openEuler"
VERSION_ID="20.09"
PRETTY_NAME="openEuler 20.09"
ANSI_COLOR="0;31"

[root@liumiaocn ~]# 
 
网络连通性确认
 
 所以可以看到基本正常可以使用了。
 
总结
 
整体来说基本上和普通的Linux发行版一样，可以直接正常使用的状态，作为刚刚推出的版本还是很不错的。

 
文章目录
 
什么是OpenSearch
Open Search 和 Elastic Search对比
open search
ElasticSearch
对比
  
Open Search 的创建
我们对Open Search的使用
API 分类
搜索方式
目前在用的产品
  
遇到的问题

 
什么是OpenSearch
 
开放搜索（OpenSearch）是一款结构化数据搜索托管服务，为移动应用开发者和网站站长提供简单、高效、稳定、低成本和可扩展的搜索解决方案。
 
OpenSearch基于阿里巴巴自主研发的大规模分布式搜索引擎平台，该平台承载了阿里巴巴全部主要搜索业务，包括淘宝、天猫、一淘、1688、ICBU、神马搜索等业务。OpenSearch以平台服务化的形式，将专业搜索技术简单化、低门槛化和低成本化，让搜索引擎技术不再成为客户的业务瓶颈，以低成本实现产品搜索功能并快速迭代。
 使用OpenSearch搭建搜索服务，您只需：
 
创建搜索应用
编辑您的应用结构
上传数据
从您的网站或应用程序提交搜索请求
 简单、高效、低成本和可扩展。但要是后期用好，还需慢慢调试。
 
Open Search 和 Elastic Search对比
 
open search
 
优点：
 
 
支持用户上传数据或同步云数据，实时性有保障。（可以节省1-2台服务器）
 
 
应用结构、排序相关性自由定制，搜索服务更个性化。可以自定义粗排精排算法，但是LCU 和查询命中的文档、召回的文档、formula的复杂度、查询的复杂度等都有关系。
 
 
基于阿里巴巴在搜索领域的积累，提供查询分析功能，对用户查询词进行纠错、词权重分析、停用词过滤，让搜索服务更智能。可以自定义分词器，下拉提示等。可以很方便的设置召回结果的粗排精排，并且内置了一些对应的函数。
 
下拉提示例子，连衣裙 这个query，可以通过如下方式查询得到：
 中文前缀：连，连衣;
 全拼前缀：l, li, lian, lianyi, lianyiqun, …
 简拼前缀：l, ly, lyq;
 汉字加拼音： 连yi, 连衣qun；
 并且下拉提示可以进行人工干预如推荐名单和黑名单。
 
 
可视化的界面、丰富的模板，不用精通代码也能快速创建自己的搜索应用。
 
 
一张OpenSearch表可以支持多个rds及TDDL(mysql)来源表（如分库分表的场景），并且还有一些字段处理插件，这个挺适合咱们的博客场景
 
 
 
提供A/Btest功能，方便进行优化(快速迭代算法)
 
 缺点
 
 
open search和es的命中文档数差了一个数量级 通用分词 和es中ik_smark对比
 
 
子账号没有权限
 
 
分词不能使用or进行query
 
 
目前主辅表，仅支持 N:1 或 1:1 的关系，不支持 1:N（即多表数据关联关系中，多的一方只能是主表，且主表只能有1个）。可以进行表拆分或者合并进行应对。但是改动可能较大。
 
 
主辅表需通过应用表外键与附表主键进行数据关联，且表外键只能关联辅表主键。
 
 
最多只支持2层关联。
 
多表数据关联支持
 表a->表b，表b->表c
 表a->表d
 不支持超过2层多表数据关联
 表a->表b，表b->表c，表c->表d
 不支持环状多表数据关联
 表a->表b，表b->表a
 
 
ElasticSearch
 
1、在查询方面更加灵活
 2、需要自己实现etl工作
 
对比
 
数据准备
 问答数据：文档数257,250，存储容量为815M。
 
OpenSearch 和 es 查询语句限制
 
open search直接使用默认的粗排精排算法
 
es和open search 都查询title 和body
 LCU 使用情况
 目前ask的数据测试query，并发25左右,单次查询均值在5ms以内，平均值LCU在0.3左右。
 人工评估结果
 es查询评估平均得分3.50，opensearch查询评估平均得分2.76
 
Open Search 的创建
 
一共有三种创建方式：
 
通过模板创建应用结构
通过上传文档创建应用结构
通过数据源创建应用结构
 步骤：
 1).添加表
 
 
 
 
 2).手动修改创建的应用结构
 
 3). 定义索引结构
 1⃣️需放到 query子句中的字段，必须创建为索引（浮点型不支持创建为索引），分词方式详情请参见字段和分词类型。
 需放到 filter子句，sort子句，及函数中涉及字段有明确标识，需设置为属性的字段必须创建为属性。
 分词字段类型无法配置为属性，例如 TEXT，SHORT_TEXT等都不支持，只支持数值字段类型及不分词字段类型配置为属性，例如 int，int_array，float，float_array，double，double_array，literal，literal_array 等字段类型。
 
 同步数据源
 
 
创建成功
 
 数据上传
 上面我们是以RDS为例，激活应用后会默认开始导入全量数据，可以在应用管理 - 基本配置 - 索引重建中看到具体进度。
 
我们对Open Search的使用
 
API 分类
 
 
搜索方式
 
可以通过http(get、post)形式或Java、PHP sdk方式进行搜索与上传。
 
目前在用的产品
 
APP中@ 操作
 
 具体的Java 代码
 
添加maven
 
<dependency>
  <groupId>com.aliyun.opensearch</groupId>
  <artifactId>aliyun-sdk-opensearch</artifactId>
  <version>3.2.0</version>
</dependency>
 
部分代码
 
private static SearcherClient searcherClient=null;
    static {
        //创建并构造OpenSearch对象
        OpenSearch openSearch = new OpenSearch(Constants.ACCESSKEY, Constants.SECRET, Constants.HOST);
        //创建OpenSearchClient对象，并以OpenSearch对象作为构造参数
        OpenSearchClient serviceClient = new OpenSearchClient(openSearch);
        //创建SearcherClient对象，并以OpenSearchClient对象作为构造参数
        searcherClient = new SearcherClient(serviceClient);
    }

    /**
     * 配置信息
     * @return
     */
    public Config getConfig(List<String> appNames,int start,int hit,List<String> fields){
        //定义Config对象，用于设定config子句参数，指定应用名，分页，数据返回格式等等
        Config config = new Config(appNames);
        config.setStart(start);
        config.setHits(hit);
        //设置返回格式为fulljson格式
        config.setSearchFormat(SearchFormat.JSON);
        // 设置搜索结果返回应用中哪些字段
        config.setFetchFields(fields);
        return config;
    }

    /**
     * 粗排精排
     * @return
     */
    public Rank getRank(int size){
        if(size>500){
            size=500;
        }
      // 设置精排文档
       Rank rank=new Rank();

        rank.setReRankSize(size);
        return rank;
    }

    /**
     * @param jsonParam 传过来的参数
     *                  {
     *       "filter":"username=\"Joanna_or_zhouzhou\"",//按照某个字段过滤
     *       "reRankSize":"500",//参与精排的条数
     *       "fetchFields":"id,title,nickname",//获取的域/字段
     *       "pageSize":"20",//每页多少条
     *       "index":"nickname",//索引
     *       "page":"0",//第几页 注：0为第一页
     *       "sort":"-id",  //-按照某个字段降序 + 按照某个字段增序  最好不要使用sort 耗资源
     *       "queryWord":"巴掌大的脚印" , //搜索词
     *       "summary":[
     *               {
     *               "snippet":"1",//片段数量
     *               "field":"nickname",//指定的生效的字段。此字段必需为可分词的text类型的字段。
     *               "len":"50",//片段长度
     *               "ellipsis":"...",//片段链接符
     *               "element":"em"//飘红标签
     *               }
     *           ]
     *       }
     * @return
     */
    public ResultVo dataDispose(com.alibaba.fastjson.JSONObject jsonParam){
        ResultVo resultVo=new ResultVo();
        com.alibaba.fastjson.JSONArray jsonArray=new com.alibaba.fastjson.JSONArray();
        List<String> appNames=new ArrayList<>();
        String appName=jsonParam.getString("appName");
        if(StringUtils.isEmpty(appName)){
            resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0001);
            resultVo.setMessage("app应用名为空");
            resultVo.setData(jsonArray);
            return resultVo;
        }else{
            appNames.add(appName);
        }

        if(jsonParam==null || jsonParam.size()<=0){
            resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0002);
            resultVo.setMessage("app参数为空");
            resultVo.setData(jsonArray);
            return resultVo;
        }
        //搜索词
        String queryWord=jsonParam.getString("queryWord");
        if(queryWord==null || queryWord.isEmpty()){
            resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0003);
            resultVo.setMessage("queryWord为必填项不能为空");
            resultVo.setData(jsonArray);
            return resultVo;
        }else{
            queryWord=queryWord.replaceAll("\\\\"," ").replaceAll("\'"," ");
        }
        int start=0;
        int hit=20;
        //第几页 注：0为第一页  config=start:20, hit:20, format:xml
        String page=jsonParam.getString("page");
        //每页多少条
        String pageSize=jsonParam.getString("pageSize");
        //opensearch start+hit<=5000，超过5000会直接报错无结果。
        if(page!=null && NumberUtils.isDigits(page) && Integer.valueOf(page)>=0){
            if(pageSize!=null &&  NumberUtils.isDigits(pageSize) && Integer.valueOf(pageSize)>0){
                hit=Integer.valueOf(pageSize);
            }
            start=Integer.valueOf(page)*hit;
            if(start+hit>Constants.MAXSEARCHRESULT){
                resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0004);
                resultVo.setMessage("查询总数不能超过5000");
                resultVo.setData(jsonArray);
                return resultVo;
            }
        }
        List<String> fetchFields=new ArrayList<>();
        //获取的域/字段
        String fetchFieldStr=jsonParam.getString("fetchFields");
        if(fetchFieldStr==null){
            resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0005);
            resultVo.setMessage("获取结果域为必填项");
            resultVo.setData(jsonArray);
            return resultVo;
        }else{
            fetchFields.addAll(Arrays.asList(fetchFieldStr.split(",")));
        }
        Config config = getConfig(appNames,start,hit,fetchFields);
        SearchParams searchParams = new SearchParams(config);
        //参与精排的条数
        String reRankSize=jsonParam.getString("reRankSize");
        if(reRankSize!=null && NumberUtils.isDigits(reRankSize)){
            searchParams.setRank(getRank(Integer.valueOf(reRankSize)));
        }else{
            searchParams.setRank(getRank(200));
        }
        //索引
        String index=jsonParam.getString("index");
        //-按照某个字段降序 + 按照某个字段增序  最好不要使用sort 耗资源
        String queryStr="";
        if(index==null){
            resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0007);
            resultVo.setMessage("索引不能为空");
            resultVo.setData(jsonArray);
            return resultVo;
        }else{
            queryStr=index+":"+"'"+queryWord+"'";
        }
        //按照某个字段过滤
        String filter=jsonParam.getString("filter");
        if(filter!=null){
            if(filter.indexOf("=")>-1){
                int eindex = filter.indexOf("=");
                String pre = filter.substring(0, eindex);
                String next = filter.substring(eindex + 1);
                queryStr+=" AND "+pre+":"+next;
            }
//            //这里针对CSDN_User 做处理  提高查询效率
//            if("CSDN_User".equals(appName)){
//
//            }else{
//                searchParams.setFilter(filter);
//            }
        }
        String sort=jsonParam.getString("sort");
        if(sort!=null){
            queryStr=queryStr+"&&sort="+sort;
        }
        log.info("querystr:"+queryStr);
        searchParams.setQuery(queryStr);
        SearchParamsBuilder paramsBuilder = SearchParamsBuilder.create(searchParams);
        try {
            JSONArray summary = jsonParam.getJSONArray("summary");
            if(summary!=null && summary.size()>0){
                for (int i=0;i<summary.size();i++){
                    com.alibaba.fastjson.JSONObject jsonObject = summary.getJSONObject(i);
                    String field = jsonObject.getString("field");
                    int snippet=1;
                    String snippetStr = jsonObject.getString("snippet");
                    if(snippetStr!=null && NumberUtils.isDigits(snippetStr)){
                        snippet=Integer.valueOf(snippetStr);
                    }
                    int len=50;
                    String lenStr = jsonObject.getString("len");
                    if(lenStr!=null && NumberUtils.isDigits(lenStr)){
                        len=Integer.valueOf(lenStr);
                    }
                    String ellipsis = jsonObject.getString("ellipsis");
                    String element = jsonObject.getString("element");
                    paramsBuilder.addSummary(field,len,element,ellipsis,snippet);
                }

            }
        }catch (Exception e){
            resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0006);
            resultVo.setMessage(e.getMessage());
            resultVo.setData(jsonArray);
            return resultVo;
        }
        try {
            SearchResult searchResult = searcherClient.execute(paramsBuilder);
            String result = searchResult.getResult();
            JSONObject obj = new JSONObject(result);
            Object status = obj.get("status");
            if(Constants.OK.equals(status+"")){
                JSONObject map = (JSONObject)obj.get("result");
                Object items = map.get("items");
                resultVo.setData(JSON.parseArray(items.toString()));
                resultVo.setCode("200");
                resultVo.setMessage("查询成功");
                com.aliyun.opensearch.sdk.dependencies.org.json.JSONArray compute_cost = (com.aliyun.opensearch.sdk.dependencies.org.json.JSONArray)map.get("compute_cost");
                if(compute_cost!=null && compute_cost.length()>0){
                    JSONObject jsonObject = compute_cost.getJSONObject(0);
                    Object lcu = jsonObject.get("value");
                    log.info("查询成功,消耗LCU："+lcu);

                }
            }else{
                resultVo.setData(jsonArray);
                resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE00010);
                Object errors = obj.get("errors");
                if(errors!=null){
                    resultVo.setMessage(errors+"");
                }else{
                    resultVo.setMessage("查询失败");
                }
                log.error("查询失败："+errors);
                return resultVo;
            }

        } catch (OpenSearchException e) {
            resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0008);
            resultVo.setMessage(e.getMessage());
            resultVo.setData(jsonArray);
            log.error(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0008+" : "+e.getMessage());
            return resultVo;
        } catch (OpenSearchClientException e) {
            resultVo.setCode(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0009);
            resultVo.setMessage(e.getMessage());
            resultVo.setData(jsonArray);
            log.error(Constants.ERRORHTTPCODE+Constants.PRODUCTCODE+Constants.CODE0009+" : "+e.getMessage());
            return resultVo;
        }
        return resultVo;
    }
    public ResultVo searchData(com.alibaba.fastjson.JSONObject jsonParam) {
        ResultVo resultVo = dataDispose(jsonParam);
        return resultVo;
    }
 
遇到的问题
 
表关联问题
性能问题 （filter 字段建立索引）
子账号没有权限导入数据
目前redis中的数据不能进行关联同步
query分词之后只能and进行搜索
 
引用：官方文档
 
备注：
 
LCU是用来衡量搜索应用计算能力的单位，一个LCU代表搜索集群中10millicores的计算能力，计算资源估算方法：LCU个数=QPS*compute_cost，millicores是CPU资源的单位，即一个核的1/1000, compute_cost是单次查询计算消耗的LCU