shell复制代码discovery.seed_hosts: ["192.168.21.130", "192.168.21.131", "192.168.21.132"]

shell复制代码cluster.initial_master_nodes: ["node1", "node2","node3"]

sql复制代码// 创建指定分片数量、副本数量的索引 
PUT /job_idx_shard_temp 
{ 
"mappings":{ 
"properties":{ 
"id":{"type":"long","store":true}, 
"area":{"type":"keyword","store":true}, 
"exp":{"type":"keyword","store":true},  
"edu":{"type":"keyword","store":true}, 
"salary":{"type":"keyword","store":true}, 
"job_type":{"type":"keyword","store":true}, 
"cmp":{"type":"keyword","store":true}, 
"pv":{"type":"keyword","store":true}, 
"title":{"type":"text","store":true}, 
"jd":{"type":"text"} 
} 
}, 
"settings":{ 
"number_of_shards":3, 
"number_of_replicas":2 
} 
} 

// 查看分片、主分片、副本分片 
GET /_cat/indices?v

sql复制代码GET /es_db/_search 
{ 
"query": { 
"match": { 
"remark": "java developer" 
} 
} 
}

sql复制代码GET /es_db/_search 
{ 
"query": { 
"match": { 
"remark": { 
"query": "java developer", 
"operator": "and" 
} 
} 
} 
}

sql复制代码GET /es_db/_search 
{ 
 "query": { 
 "match": { 
 "remark": { 
 "query": "java architect assistant", 
 "minimum_should_match": "68%" 
 } 
} 
} 
}

sql复制代码GET /es_db/_search 
{ "query": { 
 "bool": { 
 "should": [ 
   { 
   "match": { 
   "remark": "java" 
   } 
   }, 
   { 
   "match": { 
   "remark": "developer" 
   } 
   }, 
   { 
   "match": { 
   "remark": "assistant" 
   } 
   } 
 ], 
 "minimum_should_match": 2 
 } 
 } 
}

shell复制代码GET /es_db/_search 
{ 
"query": { 
"match": { 
"remark": "java developer" 
} 
} 
} 

# 转换后是： 
GET /es_db/_search 
{ 
"query": { "bool": { 
"should": [ 
{ 
"term": { 
"remark": "java" 
} 
}, 
{ 
"term": { 
"remark": { 
"value": "developer" 
} 
} 
} 
] 
} 
} 
} 


# 完全匹配
GET /es_db/_search 
{ 
"query": { 
"match": { 
"remark": { 
"query": "java developer", 
"operator": "and" 
} 
} 
} 
} 

# 转换后是： 
GET /es_db/_search 
{ 
"query": { 
"bool": { 
"must": [ 
{ 
"term": { 
"remark": "java" 
} }, 
{ 
"term": { 
"remark": { 
"value": "developer" 
} 
} 
} 
] 
} 
} 
} 


# 匹配度
GET /es_db/_search 
{ 
"query": { 
"match": { 
"remark": { 
"query": "java architect assistant", 
"minimum_should_match": "68%" 
} 
} 
} 
}

# 转换后为： 
GET /es_db/_search 
{ 
"query": { 
"bool": { 
"should": [ 
{ 
"term": { 
"remark": "java" 
} 
}, 
{ 
"term": { 
"remark": "architect" 
} 
}, { 
"term": { 
"remark": "assistant" 
} 
} 
], 
"minimum_should_match": 2 
} 
} 
}

shell复制代码
 GET /es_db/_search 
 {
 "query":{
 "bool":{
 "must":[
 {
 "match":{
 "remark":"java"
 }
 }
 ],
 "should":[
 {
 "match":{
 "remark":{
 "query":"developer",
 "boost":1
 }
 }
 },
 {
 "match":{
 "remark":{
 "query":"architect",
 "boost":3
 }
 }
 }
 ]
 }
 }
 }

shell复制代码GET /es_db/_search 
{ 
"query": { 
"dis_max": { 
"queries": [ 
{ 
"match": { "name": "rod" 
} 
}, 
{ 
"match": { 
"remark": "java developer" 
} 
} 
] 
} 
} 
} 

# 返回结果
#! Elasticsearch built-in security features are not enabled. Without authentication, your cluster could be accessible to anyone. See https://www.elastic.co/guide/en/elasticsearch/reference/7.15/security-minimal-setup.html to enable security.
{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : 1.6375021,
    "hits" : [
      {
        "_index" : "es_db",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.6375021,
        "_source" : {
          "name" : "rod",
          "sex" : 0,
          "age" : 26,
          "address" : "广州白云山公园",
          "remark" : "php developer"
        }
      },
      {
        "_index" : "es_db",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.4691012,
        "_source" : {
          "name" : "张三",
          "sex" : 1,
          "age" : 25,
          "address" : "广州天河公园",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "es_db",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.5598161,
        "_source" : {
          "name" : "李四",
          "sex" : 1,
          "age" : 28,
          "address" : "广州荔湾大厦",
          "remark" : "java assistant"
        }
      },
      {
        "_index" : "es_db",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : 0.46919835,
        "_source" : {
          "name" : "小明",
          "sex" : 0,
          "age" : 19,
          "address" : "长沙岳麓山",
          "remark" : "java architect assistant"
        }
      }
    ]
  }
}

shell复制代码GET /es_db/_search 
{ 
"query": { 
"dis_max": { 
"queries": [ 
{ 
"match": { 
"name": "rod" 
} 
}, 
{ 
"match": { 
"remark": "java developer" 
} 
} 
], 
"tie_breaker":0.5 
} 
}
}

shell复制代码GET /es_db/_search
{
"query":{
"dis_max":{
"queries":[
{
"match":{
"name":"rod"
}
},
{
"match":{
"remark":{
"query":"javadeveloper",
"boost":2,
"minimum_should_match":2
}
}
}
],
"tie_breaker":0.5
}
}
}

# 返回结果
#! Elasticsearch built-in security features are not enabled. Without authentication, your cluster could be accessible to anyone. See https://www.elastic.co/guide/en/elasticsearch/reference/7.15/security-minimal-setup.html to enable security.
{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 1.6375021,
    "hits" : [
      {
        "_index" : "es_db",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.6375021,
        "_source" : {
          "name" : "rod",
          "sex" : 0,
          "age" : 26,
          "address" : "广州白云山公园",
          "remark" : "php developer"
        }
      }
    ]
  }
}



#使用multi_match语法为：其中type常用的有best_fields和most_fields。^n代表权重，相当于"boost":n。
GET /es_db/_search
{
"query":{
"multi_match":{
  "query": "rod java developer",
  "fields": ["name","remark^2"],
  "type": "best_fields",
  "tie_breaker": 0.5,
  "minimum_should_match": "50%"
}
}
}

shell复制代码GET /es_db/_search 
{ 
"query": { 
"multi_match": { 
"query": "java developer", 
"fields": ["name", "remark"], 
"type": "cross_fields", 
"operator" : "and" 
} 
} 
}

shell复制代码{
"category_name" : "手机",
"product_name" : "一加6T手机",
"price" : 568800,
"sell_point" : "国产最好的Android手机",
"tags": ["8G+128G", "256G可扩展"],
"color" : "红色",
"keyword" : "手机 一加6T手机 国产最好的Android手机"
}

shell复制代码PUT /es_db/_mapping
{
"properties": {
"provice" : {
"type": "text",
"analyzer": "standard",
"copy_to": "address"
},
"city" : {
"type": "text",
"analyzer": "standard",
"copy_to": "address"
},
"street" : {
"type": "text",
"analyzer": "standard",
"copy_to": "address"
},
"address" : {
"type": "text",
"analyzer": "standard"
}
}
}

shell复制代码GET _search 
{ 
"query" : { 
"match" : { 
"name" : "jave" 
}
} 
}

shell复制代码GET _search 
{ 
"query": { 
"match_phrase": { 
"remark": "java assistant" 
} 
} 
}

shell复制代码GET _analyze 
{ 
"text": "hello world, java spark", 
"analyzer": "standard" 
}

shell复制代码{ 
"tokens": [ 
{ 
"token": "hello", 
"start_offset": 0, 
"end_offset": 5, 
"type": "<ALPHANUM>", 
"position": 0 
}, 
{ 
"token": "world", 
"start_offset": 6, 
"end_offset": 11, 
"type": "<ALPHANUM>", 
"position": 1 
}, 
{ 
"token": "java", 
"start_offset": 13, 
"end_offset": 17, 
"type": "<ALPHANUM>", 
"position": 2 
}, 
{ 
"token": "spark", 
"start_offset": 18, 
"end_offset": 23, 
"type": "<ALPHANUM>", 
"position": 3 
} 
] 
}

shell复制代码GET _analyze 
{ 
"text": "hello world, java spark", 
"analyzer": "standard" 
} 

POST /test_a/_doc/3 
{ 
"f" : "hello world, java spark" 
} 

GET /test_a/_search 
{ 
"query": { 
"match_phrase": { 
"f" : { 
"query": "hello spark", 
"slop" : 2 
} 
} 
} 
}

GET /test_a/_search 
{ 
"query": { 
"match_phrase": { 
"f" : { 
"query": "spark hello", 
"slop" : 4 
} 
} 
} 
}

shell复制代码GET _analyze 
{ 
"text": "中国，一个世界上最强的国家", 
"analyzer": "ik_max_word" 
} 

POST /test_a/_doc/1 
{ 
"f" : "中国，一个世界上最强的国家" 
} 

GET /test_a/_search 
{ 
"query": { 
"match_phrase": { 
"f" : { 
"query": "中国最强", 
"slop" : 5 
} 
} 
} 
} 

GET /test_a/_search 
{ 
"query": { 
"match_phrase": {
"f" : { 
"query": "最强中国", 
"slop" : 9 
} 
} 
} 
}

shell复制代码POST /test_a/_doc/3
{
"f" : "hello, java is very good, spark is also very good"
}

POST /test_a/_doc/4
{
"f" : "java and spark, development language "
}

POST /test_a/_doc/5
{ "f" : "Java Spark is a fast and general‐purpose cluster computing system. I t provides high‐level APIs in Java, Scala, Python and R, and an optimized engi ne that supports general execution graphs."
}

POST /test_a/_doc/6
{
"f" : "java spark and, development language "
}

GET /test_a/_search
{
"query": {
"match": {
"f": "java spark"
}
}
}

GET /test_a/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"f": "java spark"
}
}
],
"should": [
{
"match_phrase": {
"f": {
"query": "java spark",
"slop" : 50
}
}
}
]
}
}
}

shell复制代码GET /test_a/_search 
{ 
"query": { 
"prefix": { 
"f.keyword": { 
"value": "J" 
} 
} 
} 
}

shell复制代码GET /test_a/_search 
{ 
"query": { 
"wildcard": { 
"f.keyword": { 
"value": "?e*o*" 
} 
}
} 
}

shell复制代码GET /test_a/_search 
{ 
"query": { 
"regexp" : { 
"f.keyword" : "[A‐z].+" 
} 
} 
}

shell复制代码GET /test_a/_search 
{ 
"query": { 
"match_phrase_prefix": { 
"f": { 
"query": "java s", 
"slop" : 10, 
"max_expansions": 10 
} 
} 
} 
}

shell复制代码GET /test_a/_search 
{ 
"query": { 
"fuzzy": { 
"f" : { 
"value" : "word", 
"fuzziness": 2 
} 
} 
} 
}

go复制代码syntax = "proto3";

package proto;

message String {
    string value = 1;
}

service HelloService {
    rpc Hello (String) returns (String);
}

go复制代码// HelloServiceServer is the server API for HelloService service.
type HelloServiceServer interface {
	Hello(context.Context, *String) (*String, error)
}

// HelloServiceClient is the client API for HelloService service.
type HelloServiceClient interface {
	Hello(ctx context.Context, in *String, opts ...grpc.CallOption) (*String, error)
}

go复制代码package main

import (
	"context"
	"google.golang.org/grpc"
	"log"
	"net"
	pb "rpc/proto" // 设置引用别名
)

type HelloServiceImpl struct{}

func (p *HelloServiceImpl) Hello(ctx context.Context, args *pb.String) (*pb.String, error) {
	reply := &pb.String{Value: "hello:" + args.GetValue()}
	return reply, nil
}

func main() {
	grpcServer := grpc.NewServer()
	pb.RegisterHelloServiceServer(grpcServer, new(HelloServiceImpl))

	lis, err := net.Listen("tcp", ":1234")
	if err != nil {
		log.Fatal(err)
	}

	grpcServer.Serve(lis)
}

go复制代码package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"log"
	pb "rpc/proto" // 设置引用别名
)

func main() {
	conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
	if err != nil {
		log.Fatal("dialing err:", err)
	}
	defer conn.Close()

	client := pb.NewHelloServiceClient(conn)
	reply, err := client.Hello(context.Background(), &pb.String{Value: "wekenw"})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(reply.GetValue())
}

go复制代码$ go run client.go
hello:wekenw

go复制代码syntax = "proto3";

package proto;

message String {
    string value = 1;
}

service HelloService {
    rpc Hello (String) returns (stream String){};
}

go复制代码package main

import (
	"google.golang.org/grpc"
	"log"
	"net"
	pb "rpc/proto" // 设置引用别名
	"strconv"
)

// HelloServiceImpl 定义我们的服务
type HelloServiceImpl struct{}

//实现Hello方法
func (p *HelloServiceImpl) Hello(req *pb.String, srv pb.HelloService_HelloServer) error {
	for n := 0; n < 5; n++ {
		// 向流中发送消息， 默认每次send送消息最大长度为`math.MaxInt32`bytes
		err := srv.Send(&pb.String{
			Value: req.Value + strconv.Itoa(n),
		})
		if err != nil {
			return err
		}
	}
	return nil
}

func main() {
	// 新建gRPC服务器实例
	grpcServer := grpc.NewServer()
	// 在gRPC服务器注册我们的服务
	pb.RegisterHelloServiceServer(grpcServer, new(HelloServiceImpl))

	lis, err := net.Listen("tcp", ":1234")
	if err != nil {
		log.Fatal(err)
	}
	log.Println(" net.Listing...")
	//用服务器 Serve() 方法以及我们的端口信息区实现阻塞等待，直到进程被杀死或者 Stop() 被调用
	err = grpcServer.Serve(lis)
	if err != nil {
		log.Fatalf("grpcServer.Serve err: %v", err)
	}
}

go复制代码package main

import (
	"context"
	"google.golang.org/grpc"
	"io"
	"log"
	pb "rpc/proto" // 设置引用别名
)

// SayHello 调用服务端的 Hello 方法
func SayHello(client pb.HelloServiceClient, r *pb.String) error {
	stream, _ := client.Hello(context.Background(), r)
	for {
		resp, err := stream.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}

		log.Printf("resp: %v", resp)
	}

	return nil
}


func main() {
	conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
	if err != nil {
		log.Fatal("dialing err:", err)
	}
	defer conn.Close()

	// 建立gRPC连接
	client := pb.NewHelloServiceClient(conn)

	// 创建发送结构体
	req := pb.String{
		Value: "stream server grpc ",
	}
	SayHello(client, &req)
}

go复制代码$ go run server.go
2021/11/16 21:57:18  net.Listing...

go复制代码$ go run client.go
2021/11/16 21:57:31 resp: value:"stream server grpc 0"
2021/11/16 21:57:31 resp: value:"stream server grpc 1"
2021/11/16 21:57:31 resp: value:"stream server grpc 2"
2021/11/16 21:57:31 resp: value:"stream server grpc 3"
2021/11/16 21:57:31 resp: value:"stream server grpc 4"

java复制代码package com.hongcha.mongodb.core;

import java.lang.annotation.Annotation;
import java.util.Map;

/**
 * 条件相关注解的处理器注册
 */
public interface ConditionsAnnotationHandlerRegister {
    /**
     * Annotation 必须标准ConditionsAnnotation注解
     *
     * @param annotation
     * @param conditionsAnnotationHandler
     */
    void registerHandler(Class<? extends Annotation> annotation, ConditionsAnnotationHandler conditionsAnnotationHandler);

    /**
     * 返回的是一个copy,不是原注册Map
     *
     * @return
     */
    Map<Class<? extends Annotation>, ConditionsAnnotationHandler> getAllRegisteredHandler();

    ConditionsAnnotationHandler getHandler(Class<? extends Annotation> annotation);

}

java复制代码package com.hongcha.mongodb.core;

import java.lang.annotation.Annotation;
import java.util.Map;

/**
 * 注册运算符相关注解的处理器注册
 */
public interface OperatorAnnotationHandlerRegister {
    /**
     * Annotation 必须标准OperatorAnnotation注解
     *
     * @param annotation
     * @param operatorAnnotationHandler
     */
    void registerHandler(Class<? extends Annotation> annotation, OperatorAnnotationHandler operatorAnnotationHandler);

    /**
     * 返回的是一个copy,不是原注册Map
     * @return
     */
    Map<Class<? extends Annotation>, OperatorAnnotationHandler> getAllRegisteredHandler();

    OperatorAnnotationHandler getHandler(Class<? extends Annotation> annotation);
}

java复制代码package com.hongcha.mongodb.core.service;

import com.hongcha.mongodb.core.Page;
import com.hongcha.mongodb.core.annotation.ConditionsAnnotation;
import com.hongcha.mongodb.core.annotation.OperatorAnnotation;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

import java.util.List;

/**
 * mongodb的基础service接口
 * T 对应集合实体类
 * 根据ObjectParam构成条件的参数参考下面的注解以及标注
 *
 * @see ConditionsAnnotation
 * @see OperatorAnnotation
 */
public interface BaseMongoService<T> {
    /**
     * 根据id获取数据
     * @param id id
     * @return
     */
    T getById(String id);


    /**
     * 检查id是否存在,如果不存在那么就会抛出异常，
     *
     * @param id      id
     * @param message 提示信息
     * @return
     */
    T checkByIdAngGet(String id, String message);

    /**
     * 插入实体类到db
     *
     * @param t
     * @return
     */
    boolean insert(T t);


    /**
     * 往对应的集合中批量插入数据，注意批量的数据中不要包含重复的id
     *
     * @param list
     * @return
     */
    boolean insertBatch(List<T> list);


    /**
     * 根据id删除数据
     *
     * @param id
     * @return
     */

    boolean deleteById(String id);

    /**
     * 根据object构造条件删除数据
     *
     * @param objectParam
     * @param
     * @return
     */
    boolean delete(Object objectParam);

    /**
     * 根据原始Query删除
     *
     * @param query
     * @return
     */
    boolean delete(Query query);

    /**
     * 根据 object修改
     *
     * @param id
     * @param objectUpdate
     * @param
     * @return
     */
    boolean updateById(String id, Object objectUpdate);

    /**
     * 根据update修改
     *
     * @param id
     * @param update
     * @return
     */
    boolean updateById(String id, Update update);


    /**
     * @param objectParam  构成query的object
     * @param objectUpdate 构成update的object
     * @return
     */

    boolean update(Object objectParam, Object objectUpdate);

    /**
     * 根据原始Query和Update进行修改
     *
     * @param query
     * @param update
     * @return
     */

    boolean update(Query query, Update update);

    /**
     * 获取所有数据
     *
     * @return
     */
    List<T> select();

    /**
     * 根据对象生成条件查找符合条件的实体数据
     *
     * @param objectParam
     * @return
     */
    List<T> select(Object objectParam);


    /**
     * 根据对象来生产条件查找返回R类型数据
     *
     * @param objectParam
     * @param returnClass
     * @param <R>         接收的返回类型
     * @return
     */
    <R> List<R> select(Object objectParam, Class<R> returnClass);

    /**
     * 根据Query查找符合条件的数据
     *
     * @param query
     * @return
     */
    List<T> select(Query query);

    /**
     * 根据原生query来进行查找
     *
     * @param query
     * @param returnClass
     * @param <R>
     * @return
     */
    <R> List<R> select(Query query, Class<R> returnClass);


    T selectOne(Object objectParam);

    /**
     * 根据对象来生产条件查找返回R类型数据,获取第一个符合的
     *
     * @param objectParam
     * @param returnClass
     * @param <R>         接收的返回类型
     * @return
     */
    <R> R selectOne(Object objectParam, Class<R> returnClass);


    T selectOne(Query query);


    /**
     * 根据原生Query查找第一个
     *
     * @param query
     * @param returnClass
     * @param <R>
     * @return
     */
    <R> R selectOne(Query query, Class<R> returnClass);


    Page<T> page(Object objectParam, Page<T> page);


    /**
     * 分页方法,会将data填充到传入的page里面去
     *
     * @param objectParam 根据object构造条件
     * @param page        不能为空，调用前请填充好current和size
     * @param returnClass 返回的类型
     * @param <R>
     * @return
     * @see Page
     * @see Page#setCurrent(int)  当前页
     * @see Page#setSize(int)  条数
     */
    <R> Page<R> page(Object objectParam, Page<R> page, Class<R> returnClass);


    Page<T> page(Query query, Page<T> page);

    /**
     * 分页方法,会将data填充到传入的page里面去
     *
     * @param query       原生query构造，但是不要加skip和limit,该方法会自动判断
     * @param page        不能为空，调用前请填充好current和size
     * @param returnClass 返回的类型
     * @param <R>
     * @return
     * @see Page
     * @see Page#setCurrent(int)  当前页
     * @see Page#setSize(int)  条数
     */
    <R> Page<R> page(Query query, Page<R> page, Class<R> returnClass);


    long count();

    /**
     * 根据object生成条件查找count
     *
     * @param objectParam 条件
     * @return
     */
    long count(Object objectParam);

    /**
     * 根据Query生产count
     *
     * @param query
     * @return
     */
    long count(Query query);

    /**
     * 默认为T类型
     *
     * @param conditions
     * @param page
     * @return
     * @see #aggregatePage(List, Page, Class)
     */
    Page<T> aggregatePage(List<AggregationOperation> conditions, Page<T> page);

    /**
     * 不进行排序
     *
     * @param conditions
     * @param page
     * @param clazz
     * @param <R>
     * @return
     * @see #aggregatePage(List, Sort, Page, Class)
     */
    <R> Page<R> aggregatePage(List<AggregationOperation> conditions, Page<R> page, Class<R> clazz);

    /**
     * 对该集合的aggregate的聚合函数分页,conditions不要添加skip和limit以及sort,该方法会自动添加 page请先填充好current和size
     * 拿到的数据会填充到入参参数page的data中
     *
     * @param conditions
     * @param sort       排序 如果为null将不会添加
     * @param page
     * @param clazz      接受数据的类型
     * @return
     * @see Page
     * @see Page#setCurrent(int)  当前页
     * @see Page#setSize(int)  条数
     */
    <R> Page<R> aggregatePage(List<AggregationOperation> conditions, Sort sort, Page<R> page, Class<R> clazz);

    /**
     * 接受类型为T类型
     *
     * @param aggregation
     * @return
     * @see #aggregateData(Aggregation, Class)
     */
    List<T> aggregateData(Aggregation aggregation);

    /**
     * 对聚合函数返回的接受进行接受
     *
     * @param aggregation
     * @param outputType
     * @param <R>
     * @return
     * @see #aggregate(Aggregation, Class)
     */
    <R> List<R> aggregateData(Aggregation aggregation, Class<R> outputType);

    /**
     * 对BaseMongoServiceImpl的入参table进行聚合函数查找,返回AggregationResults
     *
     * @param aggregation
     * @param outputType  接受结果的类型
     * @param <R>
     * @return
     */
    <R> AggregationResults<R> aggregate(Aggregation aggregation, Class<R> outputType);


}

scss复制代码package com.hongcha.mongodb.starter;

import com.hongcha.mongodb.core.*;
import com.hongcha.mongodb.core.annotation.*;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.util.StringUtils;

import java.lang.annotation.Annotation;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;

@Configurable
public class MongoHelperAutoConfig implements InitializingBean {

    private static Map<Class<? extends Annotation>, ConditionsAnnotationHandler> DEFAULT_CONDITIONS = new HashMap<>();
    private static Map<Class<? extends Annotation>, OperatorAnnotationHandler> DEFAULT_OPERATOR = new HashMap<>();

    static {

        DEFAULT_CONDITIONS.put(Eq.class, (criteria, value) -> skipNullHandler(criteria, value, Criteria::is));
        DEFAULT_CONDITIONS.put(Gt.class, (criteria, value) -> skipNullHandler(criteria, value, Criteria::gt));
        DEFAULT_CONDITIONS.put(Gte.class, (criteria, value) -> skipNullHandler(criteria, value, Criteria::gte));
        DEFAULT_CONDITIONS.put(Lt.class, (criteria, value) -> skipNullHandler(criteria, value, Criteria::lt));
        DEFAULT_CONDITIONS.put(Lte.class, (criteria, value) -> skipNullHandler(criteria, value, Criteria::lte));
        DEFAULT_CONDITIONS.put(Ne.class, (criteria, value) -> skipNullHandler(criteria, value, Criteria::ne));
        DEFAULT_CONDITIONS.put(In.class, (criteria, value) -> skipNullHandler(criteria, value, Criteria::in));
        DEFAULT_CONDITIONS.put(Regex.class, (criteria, value) -> {
            if (value == null)
                return criteria;
            String strValue = value.toString();
            return skipNullHandler(criteria, strValue, Criteria::regex);
        });

    }

    static {

        DEFAULT_OPERATOR.put(AndOperator.class, ((criteriaLeft, criteriaRight) -> skipNullHandler(criteriaLeft, criteriaRight, Criteria::andOperator)));
        DEFAULT_OPERATOR.put(OrOperator.class, ((criteriaLeft, criteriaRight) -> skipNullHandler(criteriaLeft, criteriaRight, Criteria::orOperator)));
        DEFAULT_OPERATOR.put(NorOperator.class, ((criteriaLeft, criteriaRight) -> skipNullHandler(criteriaLeft, criteriaRight, Criteria::norOperator)));
    }

    @Autowired
    ConditionsAnnotationHandlerRegister conditionsAnnotationHandlerRegister;
    @Autowired
    OperatorAnnotationHandlerRegister operatorAnnotationHandlerRegister;

    private static <T> Criteria skipNullHandler(Criteria criteria, T value, BiFunction<Criteria, T, Criteria> biFunction) {
        if (value == null)
            return criteria;
        if (value instanceof String) {
            String s = (String) value;
            if (!StringUtils.hasText(s))
                return criteria;
        }
        if (value instanceof Collection) {
            Collection c = (Collection) value;
            if (c.isEmpty())
                return criteria;
        }
        return biFunction.apply(criteria, value);
    }

    @ConditionalOnMissingBean
    @Bean
    public ConditionsAnnotationHandlerRegister conditionsAnnotationHandlerRegister() {
        return new DefaultConditionsAnnotationHandlerRegister();
    }

    @ConditionalOnMissingBean
    @Bean
    public OperatorAnnotationHandlerRegister operatorAnnotationHandlerRegister() {
        return new DefaultOperatorAnnotationHandlerRegister();
    }

    @ConditionalOnMissingBean
    @Bean
    public MongoHelper mongoDBHelper() {
        return new MongoHelper();
    }


    @Override
    public void afterPropertiesSet() throws Exception {
        initConditionsAnnotationHandlerRegister(conditionsAnnotationHandlerRegister);
        initOperatorAnnotationHandlerRegister(operatorAnnotationHandlerRegister);
    }

    private void initOperatorAnnotationHandlerRegister(OperatorAnnotationHandlerRegister register) {
        DEFAULT_OPERATOR.forEach((annotation, handler) -> {
            if (register.getHandler(annotation) == null) {
                register.registerHandler(annotation, handler);
            }
        });
    }

    private void initConditionsAnnotationHandlerRegister(ConditionsAnnotationHandlerRegister register) {
        DEFAULT_CONDITIONS.forEach((annotation, handler) -> {
            if (register.getHandler(annotation) == null) {
                register.registerHandler(annotation, handler);
            }
        });
    }

}

java复制代码
void lock() // 如果锁可用就获得锁，如果锁不可用就阻塞直到锁释放

void lockInterruptibly() // 和lock()方法相似, 但阻塞的线程 可 中 断 ， 抛 出

java.lang.InterruptedException 异常

boolean tryLock() // 非阻塞获取锁;尝试获取锁，如果成功返回 true

boolean tryLock(long timeout, TimeUnit timeUnit) //带有超时时间的获取锁方法

void unlock() // 释放锁

java复制代码   public class ReentrantDemo {
        public synchronized void demo() {
            System.out.println("begin:demo");
            demo2();
        }
    }

java复制代码public void demo2() {
        System.out.println("begin:demo1");
        synchronized (this) {
        }
		 public static void main(String[] args) {
        ReentrantDemo rd = new ReentrantDemo();
        new Thread(rd::demo).start();
    }

java复制代码public class AtomicDemo {
        private static int count = 0;
        static Lock lock = new ReentrantLock();
        public static void inc() {
            lock.lock();
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
            lock.unlock();
        }
  		public static void main(String[] args) throws InterruptedException {
            for (int i = 0; i < 1000; i++) {
                new Thread(() -> {
                    AtomicDemo.inc();
                }).start();
            }
            Thread.sleep(3000);
            System.out.println("result:" + count);
        }
    }

java复制代码public class LockDemo {
        static Map<String, Object> cacheMap = new HashMap<>();
        static ReentrantReadWriteLock rwl = new
                ReentrantReadWriteLock();
        static Lock read = rwl.readLock();
        static Lock write = rwl.writeLock();
        public static final Object get(String key) {
            System.out.println("开始读取数据");
            read.lock(); //读锁
            try {
                return cacheMap.get(key);
            } finally {
                read.unlock();
            }
        }
        public static final Object put(String key, Object value) {
            write.lock();
            System.out.println("开始写数据");
            try {
                return cacheMap.put(key, value);
            } finally {
                write.unlock();
            }
        }
    }

java复制代码public void lock() {

        sync.lock();

    }

java复制代码final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread. * currentThread * ());
        else {
            acquire(1);
        }
    }

java复制代码protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

java复制代码UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))

UnsafeWrapper("Unsafe_CompareAndSwapInt");

oop p = JNIHandles::resolve(obj); //将 Java 对象解析成 JVM 的 oop（普通对象指针）,

jint* addr = (jint *) index_oop_from_field_offset_long(p, offset); //根据对象 p 和地址偏移量找到地址

return (jint)(Atomic::cmpxchg(x, addr, e)) == e; //基于 cas 比较并替换， x 表示需要更新的值，addr 表示 state

java复制代码public final void acquire(int arg) {
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
		NonfairSync.tryAcquire
}

java复制代码protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

ReentrantLock.nofairTryAcquire

java复制代码final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();//获取当前执行的线程

java复制代码int c = getState();//获得 state 的值
if(c ==0) {//表示无锁状态
        if (compareAndSetState(0, acquires)) {//cas 替换 state 的值，cas 成功表示获取锁成功
            setExclusiveOwnerThread(current);//保存当前获得锁的线程,下次再来的时候不要再尝试竞争锁return true; 
        }
    }
else if(current ==getExclusiveOwnerThread()){//如果同一个线程来获得锁，直接增加重入次数
        int nextc = c + acquires;
        if (nextc < 0) *// overflow*
        throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
return false;
}

java复制代码private Node addWaiter(Node mode) {
    Node node = new Node(Thread. * currentThread * (), mode);//把当前线程封装为 Node
    Node pred = tail; //tail 是 AQS 中表示同比队列队尾的属性，默认是 null
    if (pred != null) {//tail 不为空的情况下，说明队列中存在节点
        node.prev = pred;//把当前线程的 Node 的 prev 指向 tail
        if (compareAndSetTail(pred, node)) {//通过 cas 把 node加入到 AQS 队列，也就是设置为 tail
            pred.next = node;//设置成功以后，把原 tail 节点的 next指向当前 node
            return node;
        }
    }
    enq(node);//tail=null,把 node 添加到同步队列
    return node;
}


// enq 就是通过自旋操作把当前节点加入到队列中
private Node enq(final Node node) {
    for (; ; ) {
        Node t = tail;
        if (t == null) { *// Must initialize*
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

java复制代码private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;//前置节点的waitStatus

    if (ws == Node.SIGNAL)//如果前置节点为 SIGNAL，意味着只需要等待其他前置节点的线程被释放，
        return true;//返回 true，意味着可以直接放心的挂起了
    if (ws > 0) {//ws 大于 0，意味着 prev 节点取消了排队，直接移除这个节点就行
        do {
            node.prev = pred = pred.prev;//相当于: pred=pred.prev;
            node.prev = pred;
        } while (pred.waitStatus > 0); //这里采用循环，从双向列表中移除 CANCELLED 的节点
        pred.next = node;

    } else {//利用 cas 设置 prev 节点的状态为 SIGNAL(-1)
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

java复制代码private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

//    selfInterrupt：标识如果当前线程在 acquireQueued中被中断过，则需要产生一 个中断请求，原因是线程在调用 acquireQueued方法的时候是不会响应中断请求的
    static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }

java复制代码public final boolean release(int arg) {
    if (tryRelease(arg)) { //释放锁成功
        Node h = head; //得到 aqs 中 head 节点
        if (h != null && h.waitStatus != 0)//如果 head 节点不为空并且状态！=0. 调用 unparkSuccessor (h) 唤醒后续节点
        unparkSuccessor(h);
        return true;
    }
    return false;
}

java复制代码 protected final boolean tryRelease(int releases) {
        int c = getState() - releases;
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;

    }
//    unparkSuccessorprivate 
    void unparkSuccessor(Node node) {
        int ws = node.waitStatus;//获得 head 节点的状态
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);// 设置 head 节点状态为 0
        Node s = node.next;//得到 head 节点的下一个节点
        if (s == null || s.waitStatus > 0) {
//如果下一个节点为 null 或者 status>0 表示 cancelled 状态.
//通过从尾部节点开始扫描，找到距离 head 最近的一个waitStatus <= 0 的节点 s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null) //next 节点不为空，直接唤醒这个线程即可
            LockSupport.unpark(s.thread);
    }

java复制代码private Node enq(final Node node) {
    for (; ; ) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

java复制代码final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (; ; ) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                interrupted = true;
        }

    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

java复制代码final void lock() {
    acquire(1);
}

java复制代码protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    } else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}