精华内容
下载资源
问答
  • java socket客户端指定端口与服务端交互 1.一般情况生成socket实例的时候:socket = new Socket("localhost", 6666); 这种情况生成实例的时候,会选择一个没有使用的端口与服务端交互 2.在某些防火墙...
    java socket客户端指定端口与服务端交互
    
    1.一般情况生成socket实例的时候:socket = new Socket("localhost", 6666);
    这种情况生成实例的时候,会选择一个没有使用的端口与服务端交互

    2.在某些防火墙的限制下,可能随机的端口,在服务端发送消息的时候可能会限制,需要指定相应的端口,需要将实例化步骤修改如下即可

    socket=new Socket();
    socket.bind(new InetSocketAddress(9999));//绑定本地端口
    socket.connect(new InetSocketAddress("localhost", 6666));//连接远程服务端接口

    展开全文
  • tcp问题,客户端Socket提问,getLocalPort(),连接的是本地的服务端,第一次运行是2880,第二次运行是2881,第三次运行是2882,我想了解客户端端口是怎么回事,端口是怎么分配的?
  • java socket客户端绑定本地端口的方法

    千次阅读 2019-10-22 10:02:31
    1. java socket链接服务端时, 不绑定本地端口(随机端口), 可以使用以下方法创建socket: Socket socket=new Socket("127.0.0.1",6000); 2. 如果需要绑定本地端口(指定端口), 可以使用以下方法创建socket Socket ...

    1. java socket链接服务端时, 不绑定本地端口(随机端口), 可以使用以下方法创建socket:

    Socket socket=new Socket("127.0.0.1",6000);

    2. 如果需要绑定本地端口(指定端口), 可以使用以下方法创建socket

    Socket socket=new Socket();

    //connect之前绑定本地端口 

    socket.bind(new InetSocketAddress(3000));

    socket.connect(new InetSocketAddress("127.0.0.1", 6000));

    展开全文
  • ElasticSearch集群安装及Java客户端使用

    千次阅读 2019-12-28 00:09:08
    ElasticSearch集群安装及Java客户端使用 1、传统模式安装 1.1 ElasticSearch安装 下载Es安装包 ElasticSearch的官方地址:https://www.elastic.co/guide/en/elasticsearch/reference/master/index.html 1.2 ES图形化...

    ElasticSearch集群安装及Java客户端使用

    1、传统模式安装

    1.1 ElasticSearch安装

    下载Es安装包

    ElasticSearch的官方地址:https://www.elastic.co/guide/en/elasticsearch/reference/master/index.html

    1.2 ES图形化管理界面安装

    1. 下载head https://github.com/mobz/elasticsearch-head
    2. 下载Node.js https://nodejs.org/en/download
      ​ 安装完成 在cmd窗口执行node -v查看node.js的版本号 检查是否安装成功
    1. 安装grunt

    通过node.js的包管理器npm安装grunt为全局,grunt是基于Node.js的项目构建工具

    npm install -g grunt-cli

    4)执行 npm install (不执行该命宁 使用grunt server命令会报错)

    npm install

    5)elasticsearch-head解压目录下打开命宁窗口

    执行 grunt server 启动服务

    访问http://localhost:9100 (elasticsearch-head服务端口)

    6、配置ElasticSearch跨域访问 修改 config/elasticsearch.yml 文件

    http.cors.enabled: true
    http.cors.allow-origin: "*"
    

    需要重启ES服务

    7、在head页面输入链接的ElasticSearch地址,点击连接按钮

    2 容器化安装

    2.1 ElasticSearch安装

    这里使用docker+docker compose 搭建Elasticsearch集群

    2.1.1 环境准备

    docker、docker-compose环境安装,参考官网安装:https://docs.docker.com/compose/install/

    运行:

    #docker安装
    curl -sSL https://get.daocloud.io/docker | sh
     
    #docker-compose安装
    curl -L \
    https://get.daocloud.io/docker/compose/releases/download/1.23.2/docker-compose-`uname -s`-`uname -m` \
    > /usr/local/bin/docker-compose
     
    chmod +x /usr/local/bin/docker-compose
     
    #查看安装结果
    docker-compose -v
    

    2.1.2 创建elasticsearch数据、日志存放目录

    #创建数据/日志目录 这里我们部署3个节点
    mkdir /root/app/elasticsearch/data/{node0,node1,node2} -p
    mkdir /root/app/elasticsearch/logs/{node0,node1,node2} -p
    cd /root/app/elasticsearch
    #权限
    chmod 0777 data/* -R && chmod 0777 logs/* -R
     
    #防止JVM报错
    echo vm.max_map_count=262144 >> /etc/sysctl.conf
    sysctl -p
    

    2.1.3 基于elasticsearch的官方镜像,制作一个集成了IK分词器的新镜像

    Es默认的分词器,在中文的分词上并不友好,会将语句每个字进行分词作为索引,所以在使用Term关键字查询的时候多个汉字无法命中文档。这个时候就需要一个合理的分词规则,将一个完整的语句划分为多个比较复合表达逻辑的独立的词条。IK分词器在是一款基于词典和规则的中文分词器,所以这里将IK分词器集成到elasticsearch中。集成IK分词器有两种方式:

    方式一: 执行docker exec命令进入容器,下载IK分词器zip包https://github.com/medcl/elasticsearch-analysis-ik/releases,然后解压复制到elasticsearch的插件目录,然后重启容器即可,但是这样需要在集群里的每个容器都执行一遍,后续容器销毁了,创建新的容器还需要重复来一遍,费事费力,果断放弃。

    方式二: 基于elasticsearch的官方镜像,制作一个集成了IK分词器的新镜像,这样后续只要基于这个新镜像创建的新容器就自带了IK分词器,这里需要注意,由于elasticsearch每次版本变动比较大,所以在集成IK分词器时要注意版本对应

    2.1.3.1 编写DockerFile

    FROM docker.elastic.co/elasticsearch/elasticsearch:7.4.0
    #作者
    MAINTAINER GongLJ <G381413362@163.com>
    RUN sh -c '/bin/echo -e "y" | /usr/share/elasticsearch/bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.4.0/elasticsearch-analysis-ik-7.4.0.zip'
    

    2.1.3.2 构建镜像

    docker build --tag=elasticsearch-ik-custom:7.4.0 .
    

    在这里插入图片描述

    2.1.4 创建docker-compose编排文件

    version: '2.2'
    services:
      es01:
        image: elasticsearch-ik-custom:7.4.0
        container_name: es01
        environment:
          - node.name=es01
          - cluster.name=es-docker-cluster
          - discovery.seed_hosts=es02,es03
          - cluster.initial_master_nodes=es01,es02,es03
          - bootstrap.memory_lock=true
          - http.cors.enabled=true
          - http.cors.allow-origin=*
          - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
        ulimits:
          memlock:
            soft: -1
            hard: -1
        volumes:
          - ./data/node0:/usr/share/elasticsearch/data
          - ./logs/node0:/usr/share/elasticsearch/logs
        ports:
          - 9200:9200
        networks:
          - elastic
      es02:
        image: elasticsearch-ik-custom:7.4.0
        container_name: es02
        environment:
          - node.name=es02
          - cluster.name=es-docker-cluster
          - discovery.seed_hosts=es01,es03
          - cluster.initial_master_nodes=es01,es02,es03
          - bootstrap.memory_lock=true
          - http.cors.enabled=true
          - http.cors.allow-origin=*
          - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
        ulimits:
          memlock:
            soft: -1
            hard: -1
        volumes:
          - ./data/node1:/usr/share/elasticsearch/data
          - ./logs/node1:/usr/share/elasticsearch/logs
        networks:
          - elastic
    es03:
        image: elasticsearch-ik-custom:7.4.0
        container_name: es03
        environment:
          - node.name=es03
          - cluster.name=es-docker-cluster
          - discovery.seed_hosts=es01,es02
          - cluster.initial_master_nodes=es01,es02,es03
          - bootstrap.memory_lock=true
          - http.cors.enabled=true
          - http.cors.allow-origin=*
          - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
        ulimits:
          memlock:
            soft: -1
            hard: -1
        volumes:
          - ./logs/node2:/usr/share/elasticsearch/data
          - ./logs/node2:/usr/share/elasticsearch/logs
        networks:
          - elastic
    
    networks:
      elastic:
        driver: bridge
    
    

    参数说明:

    • 集群名称:cluster.name=es-docker-cluster
    • 节点名称:node.name=es01
    • 是否可作为主节点:node.master=true
    • 是否存储数据:node.data=true
    • 锁定进程的物理内存地址避免交换(swapped)来提高性能:bootstrap.memory_lock=true

    2.1.4 创建并启动服务

    #启动
    docker-compose up -d
    #查看
    docker-compose ps
    

    2.1.5 安装Head插件

    可参考我的博客:博客地址 CSDN地址

    ElasticSearch的相关概念

    1 概述

    Elasticsearch是面向文档(document oriented)的,这意味着它可以存储整个对象或文档(ducoment)。然而它不仅仅是存储,还会索引(index)每个文档的内容使之能搜索。在Elasticsearch中,你可以对文档(而非成行成列的数据)进行索引、排序、过滤。Elasticsearch比传统关系型数据库如下。

    关系型数据库 -> Databases -> Tables -> Rows -> Colums
    
    ElasticSearch -> Indices -> Types ->Documents -> Fields 
    

    2 ElasticSearch的核心概念

    2.1 索引 index

    一个索引就是有相似特征的文档集合,比如用户数据索引、订单数据索引、商品数据索引。

    一个索引由一个全为小写字母的名字标识,我们在对应这个索引文档中进行索引、搜索、更新和删除的时候,都要使用到这个名字。在一个群集中可以定义任意多个索引。

    2.2 类型type

    在一个索引中,你可以定义一个或多个类型,一个类型是你的索引的一个逻辑上的分类,其语义完全由你来定。通常,会为具有一组共同字段的文档定义一个类型,比如说,我们订单数据索引中我们把订单信息作为一个类型,订单相关的物流信息做为一个类型。

    2.3 字段field

    相当于是数据表的字段,对文档根据不同的属性进行的分类标识

    2.4 映射 mapping (表结构)

    mapping是处理数据的方式和规则方面做一些限制,如某个字段的数据类型、默认值、分析器、是否被索引等等,这些都是映射里面可以设置的,其他的就是处理es里面的数据的一些使用规则设置也叫做映射,按着最优规则处理数据对性能提高很大,因此才需要建立映射,并且需要思考如何建立隐射才能对性能更好。

    2.5 文档 document

    一个文档是一个可被索引的基础单元。文档以JSON格式来表示,而JSON是一个到处存在的互联网数据交互格式。

    在一个index/type里面,你可以存储任意多的文档。

    ElasticSearch基本操作

    1 ElasticSearch语法

    mapping字段详解

    名称作用描述
    type字段数据类型,可选值参考" type可选类型"
    analyzer指定分词器,一般使用最大分词:ik_max_word
    index该字段是否会被索引和可查询 默认true
    store默认情况false,其实并不是真没有存储,_source字段里会保存一份原始文档
    normalizer字段标准化规则;如把所有字符转为小写
    boost字段权重;用于查询时评分,关键字段的权重就会高一些,默认都是1;另外查询时可临时指定权重
    coerce清理脏数据:1,字符串会被强制转换为整数 2,浮点数被强制转换为整数
    copy_to自定_all字段;指定某几个字段拼接成自定义
    doc_valuestrue 加快排序、聚合操作,但需要额外存储空间;默认true,对于确定不需要排序和聚合的字段可false
    dynamic默认true, #新字段动态添加 true:无限制 false:数据可写入但该字段不保留 ‘strict’:无法写入抛异常
    enabled默认true, 是否会被索引,但都会存储;可以针对一整个_doc
    fielddata默认false,针对text字段加快排序和聚合.此项官网建议不开启,非常消耗内存
    eager_global_ordinals默认true,是否开启全局预加载,加快查询;此参数只支持text和keyword,keyword默认可用,而text需要设置fielddata属性
    format格式化 此参数代表可接受的时间格式
    "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
    ignore_above100 指定字段索引和存储的长度最大值,超过最大值的会被忽略
    ignore_malformed默认 false,插入文档时是否忽略类型 默认是false 类型不一致无法插入
    index_optionsdocs . docs(索引文档号) \ freqs(文档号 + 词频)\ positions(文档号 + 词频 + 位置,通常用来距离查询) offsets(文档号 + 词频 + 位置 + 偏移量,通常被使用在高亮字段)
    fields可以对一个字段提供多种索引模式,使用text类型做全文检索,也可使用keyword类型做聚合和排序
    normstrue 用于标准化文档,以便查询时计算文档的相关性。建议不开启
    null_value可以让值为null的字段显式的可索引、可搜索
    position_increment_gap0,词组查询时可以跨词查询 既可变为分词查询 默认100
    properties嵌套属性,例如该字段是音乐,音乐还有歌词,类型,歌手等属性
    search_analyzer查询分词器;一般情况和analyzer对应
    similarity用于指定文档评分模型,参数有三个
    BM25 : ES和Lucene默认的评分模型
    classic: TF/IDF评分
    boolean:布尔模型评分
    term_vector默认 “no” ,不存储向量信息
    yes : term存储 (term存储)
    with_positions (term + 位置)
    with_offsets (term + 位置)
    with_positions_offsets(term + 位置 + 偏移量)
    对快速高亮fast vector highlighter能提升性能,但开启又会加大索引体积,不适合大数据量用

    type 可选类型

    类型具体值
    整数类型integer,long,short,byte
    浮点类型double,float,half_float,scaled_float
    逻辑类型boolean
    日期类型date
    范围类型range
    二进制类型binary
    数组类型array
    对象类型nested
    地理坐标类型geo_point
    地理地图geo_shape
    IP类型ip
    范围类型completion
    令牌计数类型token_count
    附件类型attachment
    抽取类型percolator

    2 通过HTTP请求创建

    2.1 仅创建索引

    请求方式选择 PUT

    请求链接在URL一级目录输入需要创建的索引

    比如我们船舰一个shop的索引

    http://127.0.0.1:9200/shop

    在这里插入图片描述

    2.2 创建索引的同时创建mapping 以及分片复制参数

    ​ 传入body参数执行

    {
      "settings": {
        "number_of_shards": 5,
        "number_of_replicas": 1,
        "refresh_interval": "30s"
      },
      "mappings": {
        "properties": {
          "shopid": {
            "type": "text",
            "store": false,
            "index": true
          },
          "shopname": {
            "type": "text",
            "store": false,
            "index": true
          },
          "shopdesc": {
            "type": "text",
            "store": false,
            "index": true
          }
        }
      }
    }
    

    postman截图

    在这里插入图片描述

    4.2.3 删除索引库

    请求方式选择Delete

    请求链接如:http://127.0.0.1:9200/shop 删除shop索引

    在这里插入图片描述

    4.2.3 向索引库中添加文档

    请求方式选 POST

    单条插入

    请求url : http://127.0.0.1:9200/shop/_doc/1 (索引/"_doc"/文档id)

    ​ 或者http://127.0.0.1:9200/shop/_doc

    文档id为Es中的文档主键id,不指定的情况下Es会给我们生成一个唯一的随机字符串,如 BU7pG24Bm2YrPBUaN0wD

    {
    	"shopid":"1234",
    	"shopname":"你的小店",
    	"shopdesc":"你的小店,只为喂饱你的胃"
    }
    

    postman截图
    在这里插入图片描述
    批量添加:

    请求url: http://127.0.0.1:9200/shop/_bulk

    { "index":{} }
    { "shopid":"1234656","shopname":"fox" ,"shopdesc":"亲承5为自己生下5个孩子 此前12个" }
    { "index":{} }
    { "shopid":"1234657","shopname":"乒联" ,"shopdesc":"国际乒联奥地利公开赛正赛展开" }
    { "index":{"_id":"iikdjsd"} }
    { "shopid":"1234658","shopname":"纷纷两连败" ,"shopdesc":"两连败+二当家伤停再遭困境 考验欧文.." }
    { "index":{"_id":"iik3325"} }
    { "shopid":"1234659","shopname":"纷纷返回" ,"shopdesc":"33+9+4+5误!这是最乔治!黑贝最.." }
    

    index可以指定参数,比如指定id,不指定则默认生成id

    postman截图:

    在这里插入图片描述

    4.2.3 删除文档

    请求方式选择Delete

    请求url : http://127.0.0.1:9200/shop/_doc/1 (索引/"_doc"/文档id)

    4.2.4 查询文档

    请求方式选择Get

    请求url : http://127.0.0.1:9200/shop/_doc/1 (索引/"_doc"/文档id)

    4.2.5 修改文档

    请求方式选择POST

    请求url : http://127.0.0.1:9200/shop/_doc/1 (索引/"_doc"/文档id)

     {
    	"shopname":"fox"		
    }
    

    4.2.6 根据关键词查询文档

    请求方式选择Get

    请求url http://127.0.0.1:9200/shop/_doc/_search (索引/"_doc"/"_search")

    请求参数query、term为固定命宁,shopdesc为指定在哪个字段查询什么关键字(支持什么样的关键字查询取决于mapping里指定的分析器,比如单个字为索引、分词索引,之前测试的语句都是标准分词,以单个字为索引,所以查询的时候只支持一个汉字,如果输入多个则查询不到数据)

    {
      "query": {
        "term": {
          "shopdesc": "店"
        }
      }
    }
    

    postman截图
    在这里插入图片描述

    4.2.7 queryString查询

    queryString是讲输入参数进行分词然后去索引库中检索。

    请求方式选择Get

    请求url http://127.0.0.1:9200/shop/_doc/_search

    请求参数

    {
      "query": {
        "query_string": {
          "default_field": "shopname",
          "query": "小店"
        }
      }
    }
    

    postman截图

    在这里插入图片描述

    4.2.8 分页查询

    ElasticSearch IK中文分词器

    1 什么是分词器?为什么要分词器?

    在上面的学习例子中我们使用的是Es默认的分词器,在中文的分词上并不友好,会将语句每个字进行分词作为索引,所以在使用Term关键字查询的时候多个汉字无法命中文档。这个时候就需要一个合理的分词规则,将一个完整的语句划分为多个比较复合表达逻辑的独立的词条。

    分词器包含三个部分:

    • character filter:分词之前的预处理,过滤掉HTML标签、特殊符号转换(例如,将&符号转换成and、将|符号转换成or)等。
    • tokenizer:分词
    • token filter:标准化

    2 ElasticSeach内置分词器

    standard分词器:(默认的)它将词汇单元转换成小写形式,并去掉停用词(a、an、the等没有实际意义的词)和标点符号,支持中文采用的方法为单字切分(例如,‘你好’切分为‘你’和‘好’)。

    simple分词器:首先通过非字母字符来分割文本信息,然后将词汇单元同一为小写形式。该分析器会去掉数字类型的字符。

    Whitespace分词器:仅仅是去除空格,对字符没有lowcase(大小写转换)化,不支持中文;并且不对生成的词汇单元进行其他的标准化处理。

    language分词器:特定语言的分词器,不支持中文。

    3 IK分词器

    3.1 IK分词器简介

    IK分词器在是一款 基于词典和规则 的中文分词器,提供了两种分词模式:ik_smart (智能模式)和ik_max_word (细粒度模式)

    输入数据

    数据:IK Analyzer是一个结合词典分词和文法分词的中文分词开源工具包。它使用了全新的正向迭代最细粒度切分算法。 
    

    智能模式效果:

    ik  analyzer  是  一个  结合  词典  分词  和  文法  分词  的  中文  分词  开源  工具包  它  使  用了  全新  的  正向  迭代  最  细粒度  切分  算法 
    

    细粒度模式:

    ik  analyzer  是  一个  一  个  结合  词典  分词  和文  文法  分词  的  中文  分词  开源  工具包  工具  包  它  使用  用了  全新  的  正向  迭代  最  细粒度  细粒  粒度  切分  切  分  算法 
    

    3.2 使用ElasticSearch中的 analyze 测试Ik分词效果

    请求方式 post

    请求url http://127.0.0.1:9200/_analyze

    请求参数:

    {
    	"analyzer":"ik_smart",
    	"text":"我们是一群牛逼的程序员"
    }
    

    输出效果

    {
      "tokens": [
        {
          "token": "我们",
          "start_offset": 0,
          "end_offset": 2,
          "type": "CN_WORD",
          "position": 0
        },
        {
          "token": "是",
          "start_offset": 2,
          "end_offset": 3,
          "type": "CN_CHAR",
          "position": 1
        },
        {
          "token": "一群",
          "start_offset": 3,
          "end_offset": 5,
          "type": "CN_WORD",
          "position": 2
        },
        {
          "token": "牛",
          "start_offset": 5,
          "end_offset": 6,
          "type": "CN_CHAR",
          "position": 3
        },
        {
          "token": "逼",
          "start_offset": 6,
          "end_offset": 7,
          "type": "CN_CHAR",
          "position": 4
        },
        {
          "token": "的",
          "start_offset": 7,
          "end_offset": 8,
          "type": "CN_CHAR",
          "position": 5
        },
        {
          "token": "程序员",
          "start_offset": 8,
          "end_offset": 11,
          "type": "CN_WORD",
          "position": 6
        }
      ]
    }
    

    ElasticSearch集群

    1 集群 cluster

    一个集群就是一个或多个节点组织在一起,他们共同持有整个库的数据,并在一起提供索引和搜索功能,一个集群由一个唯一的名字表示。所有节点通过这个集群名字,来进入这个集群。

    2 节点node

    一个节点是由集群中的一个服务器,作为集群的一部分,它存储数据,参与集群的索引和搜索功能。和集群类似,一个节点也是由一个名字来标识的,默认情况下,这个名字是一个随机的。一个节点可以通过配置集群名称的方式来加入一个指定的集群。

    3 分片和复制 shard & replicas

    分片:

    一个索引可以存储超过单个节点硬件限制的大量数据,比如说一个索引具有10亿文档,占据1T的磁盘空间,而任意一个节点都没有这样大的一个磁盘空间;或者单个节点处理搜索请求,响应太慢了,为了解决这个问题,ElasticSearch提供了将索引划分为多份的能力,每一份就叫做一个分片。当建立一个索引的时候,可以指定想要分配的分片数量。每个分片本身也是一个功能晚上并且独立的“索引”,这个“索引”可以被放置到集群中的任何节点上。分片很重要,主要体现在两方面:a、允许你水平分割/扩展你的内容容量。2) 允许你在分片之上进行分布式并行操作,从而提高性能和吞吐量

    至于分片怎么分布,查询结果怎么聚合,完全由elasticsearch管理的。开发者不需要关心。

    复制:

    在网络环境或者说分布式环境中,通讯发生失败是常有的事,所以当某个分片节点出现故障,故障转移机制是非常有必要的。因此Elasticsearch允许你船舰分片的一份或者多份拷贝,这些拷贝叫做复制分片,或者就叫复制。
    复制的存在提高了节点出现故障时的集群高可用性。因为这个原因,复制分片应注意与主分片不能在同一个节点上。
    总结的说,一个索引可以被分为多个分片,可以被复制0~N次,一旦复制了就有了主分片和复制分片之别。分片和复制的数量可以在索引创建的时候指定。在索引创建之后,复制的数量可以改变,但是分片数量不能改变。
    在这里插入图片描述
    在这里插入图片描述

    4 集群搭建

    参考上面容器化集群搭建

    5 节点的4中类型

    主节点:

    即 Master 节点。主节点的主要职责是和集群操作相关的内容,如创建或删除索引,跟踪哪些节点是群集的一部分,并决定哪些分片分配给相关的节点。稳定的主节点对集群的健康是非常重要的。默认情况下任何一个集群中的节点都有可能被选为主节点。索引数据和搜索查询等操作会占用大量的cpu,内存,io资源,为了确保一个集群的稳定,分离主节点和数据节点是一个比较好的选择。虽然主节点也可以协调节点,路由搜索和从客户端新增数据到数据节点,但最好不要使用这些专用的主节点。一个重要的原则是,尽可能做尽量少的工作。

    数据节点:

    即 Data 节点。数据节点主要是存储索引数据的节点,主要对文档进行增删改查操作,聚合操作等。数据节点对 CPU、内存、IO 要求较高,在优化的时候需要监控数据节点的状态,当资源不够的时候,需要在集群中添加新的节点。

    预处理节点:

    也称作 Ingest 节点,在索引数据之前可以先对数据做预处理操作,所有节点其实默认都是支持 Ingest 操作的,也可以专门将某个节点配置为 Ingest 节点。
    以上就是节点几种类型,一个节点其实可以对应不同的类型,如一个节点可以同时成为主节点和数据节点和预处理节点,但如果一个节点既不是主节点也不是数据节点,那么它就是负载均衡节点。具体的类型可以通过具体的配置文件来设置。

    节点类型默认配置专用节点注意事项
    主节点node.master: truenode.master: true node.data: false node.ingest: false cluster.remote.connect: falsediscovery.zen.minimum_master_nodes: 1(防止脑裂设置)
    意思是最少需要多少node.master: true 的节点集群才能工作
    建议(master_eligible_nodes / 2) + 1
    比如能node.master: true节点有6个 (6/2)+1=4
    那么如果健康节点少于4集群将不能工作
    数据节点node.data: truenode.master: false node.data: true node.ingest: false cluster.remote.connect: false建议使用SSD硬盘缓解I/O压力
    预处理节点node.ingestnode.master: false node.data: false node.ingest: true cluster.remote.connect: false节点负载将会很高,建议使用专用节点作为Ingest node

    JAVA应用集成ElasticSearch客户端

    Elasticsearch官方为Java提供了三种客户端API:
    1、TransportClient:这种方式通过TCP与Elasticsearch服务进行交互。

    2、Java Low Level REST Client: 低级别的REST客户端,通过http与集群交互,用户需自己编组请求JSON串,及解析响应JSON串。兼容所有ES版本。

    3、Java High Level REST Client: 高级别的REST客户端,基于低级别的REST客户端,增加了编组请求JSON串、解析响应JSON串等相关api。使用的版本需要保持和ES服务端的版本一致,否则会有版本问题。

    GitHub代码:Java客户端学习源码

    展开全文
  • Redis介绍 && Java客户端操作Redis

    千次阅读 2015-09-28 14:13:52
    Redis介绍 && Java客户端操作Redis本文内容 redis介绍 redis的 shell 客户端简介 redis的 java 客户端简介 环境配置 redis 2.8.17 64bit JDK1.6 redis介绍 大多数时候,我们都将 redis 称作是内存数据库,它在运行...

    Redis介绍 && Java客户端操作Redis


    本文内容

    • redis介绍
    • redis的 shell 客户端简介
    • redis的 java 客户端简介

    环境配置

    • redis 2.8.17 64bit
    • JDK1.6

    redis介绍

      大多数时候,我们都将 redis 称作是内存数据库,它在运行过程中,将键值对信息存储在内存中,同时在后台以异步的形式写入本地数据库中(默认是:dump.rdb,在 redis.conf 中配置,如果需要考虑安全的持久化需求需要开启 AOF 功能,详细介绍可以查看这篇文章 : redis持久化),redis中存储的 key 可以是任意类型,最后都会存储为 byte[] 类型;value 有多种类型 : string、list、set、sortedset、hash,基本上能够满足在开发中的键值存储需求;此外,redis还支持事务、消息系统等功能,而且提供了各种客户端的 API,如 Java、Python、Shell 等等。

    redis的 shell 客户端简介

      启动 shell 客户端之前,我们需要打开 redis 服务,redis 默认端口是6379,这个配置也是位于 redis.conf 中。登陆 redis 客户端的方法是 : redis-cli -h 127.0.0.1 -p 6379 (-h 是主机地址, -p 是 redis 服务端口号,由于本文介绍单机环境的 redis,我们可以直接采用默认的配置,那么登陆的方式可以简化为 : redis-cli),当我们打开了 shell 客户端之后,我们可以去 “Ping” 一下,如果返回 “PONG”,那么代表 redis 服务是处于健康状态的。
      Redis中每个数据库对外都是一个从0开始的递增数字命名,Redis默认支持16个数据库,可以通过配置参数databases来修改这一数字。客户端与Redis建立连接后会自动选择0号数据库,不过可以随时使用SELECT命令更换数据库。
      之前说过,redis 的 value 支持许多种类型,redis 对于每一种存储类型都有不同的 shell 客户端 api,这里,我们对各种 value 的类型 api 进行介绍:

    • String类型
    String api功能描述
    set(key, value)给数据库中名称为key的string赋予值value
    get(key)返回数据库中名称为key的string的value
    getset(key, value)给名称为key的string赋予上一次的value
    mget(key1, key2,…, key N)返回库中多个string的value
    setnx(key, value)添加string,名称为key,值为value
    setex(key, time, value)向库中添加string,设定过期时间time
    mset(key N, value N)批量设置多个string的值
    msetnx(key N, value N)如果所有名称为key i的string都不存在
    incr(key)名称为key的string增1操作
    incrby(key, integer)名称为key的string增加integer
    decr(key)名称为key的string减1操作
    decrby(key, integer)名称为key的string减少integer
    append(key, value)名称为key的string的值附加value
    substr(key, start, end)返回名称为key的string的value的子串

    • List类型
    List api功能描述
    rpush(key, value)在名称为key的list尾添加一个值为value的元素
    lpush(key, value)在名称为key的list头添加一个值为value的 元素
    llen(key)返回名称为key的list的长度
    lrange(key, start, end)返回名称为key的list中start至end之间的元素
    ltrim(key, start, end)截取名称为key的list
    lindex(key, index)返回名称为key的list中index位置的元素
    lset(key, index, value)给名称为key的list中index位置的元素赋值
    lrem(key, count, value)删除count个key的list中值为value的元素
    lpop(key)返回并删除名称为key的list中的首元素
    rpop(key)返回并删除名称为key的list中的尾元素
    blpop(key1, key2,… key N, timeout)lpop命令的block版本
    brpop(key1, key2,… key N, timeout)rpop的block版本

    • Set类型
    List api功能描述
    sadd(key, member)向名称为key的set中添加元素member
    srem(key, member)删除名称为key的set中的元素member
    spop(key)随机返回并删除名称为key的set中一个元素
    smove(srckey, dstkey, member)移到集合元素
    scard(key)返回名称为key的set的基数
    sismember(key, member)member是否是名称为key的set的元素
    sinter(key1, key2,…key N)求交集
    sunion(key1, (keys))求并集
    sdiff(key1, (keys))求差集
    sinterstore(dstkey, (keys))求交集并将交集保存到dstkey的集合
    sunionstore(dstkey, (keys))求并集并将并集保存到dstkey的集合
    sdiffstore(dstkey, (keys))求差集并将差集保存到dstkey的集合
    smembers(key)返回名称为key的set的所有元素
    srandmember(key)随机返回名称为key的set的一个元素

    • Hash类型
    Hash api功能描述
    hset(key, field, value)向名称为key的hash中添加元素field
    hget(key, field)返回名称为key的hash中field对应的value
    hmget(key, (fields))返回名称为key的hash中field i对应的value
    hmset(key, (fields))向名称为key的hash中添加元素field
    hincrby(key, field, integer)将名称为key的hash中field的value增加integer
    hexists(key, field)名称为key的hash中是否存在键为field的域
    hdel(key, field)删除名称为key的hash中键为field的域
    hlen(key)返回名称为key的hash中元素个数
    hkeys(key)返回名称为key的hash中所有键
    hvals(key)返回名称为key的hash中所有键对应的value
    hgetall(key)返回名称为key的hash中所有的键(field)及其对应的value

      除了针对 value 类型的 api 之外,还有一些常用的公共 api,如下:

    常用 api功能描述
    quit关闭连接(connection)
    type(key)返回值的类型
    del(key)删除一个key
    exists(key)确认一个key是否存在
    keys(pattern)返回满足给定pattern的所有key
    dbsize返回当前数据库中key的数目
    flushdb删除当前选择数据库中的所有key
    flushall删除所有数据库中的所有key

    redis的 Java 客户端简介

      与 Shell 客户端支持单机与集群同一接口不同,Java 客户端针对单机环境与集群环境有不一样的接口(单机环境使用 Jedis对象,集群环境使用 JedisCluster 对象),本文针对单机环境进行介绍,集群环境的话,除了配置下主机地址与端口号,其他的接口操作同 Jedis 是一样的。
      下面对 redis 提供的 Java 客户端接口进行介绍,由于代码中都有相应的注释,所以,不做详细描述:

    • 公共接口
        private static Jedis jedis;
        private static final String PREFIX = "qinyi-";
        private static final String HOST_IP = "127.0.0.1";
        private static final int HOST_PORT = 6379;
        private static final Logger logger = LoggerFactory.getLogger(RedisClient.class);
    
        public synchronized static Jedis getJedis(String host_ip, int host_port) {
            jedis = new Jedis(host_ip, host_port);
            //jedis.auth("root");  //开启密码验证(配置文件中为 requirepass root)的时候需要执行该方法
    
            return jedis;
        }
    
        public synchronized static Jedis getDefaultJedis() {
            return getJedis(HOST_IP, HOST_PORT);
        }
    
        /**
         *  清空 redis 中的所有数据
         * */
        public String flushRedis() {
            logger.debug("flush redis data");
            return getDefaultJedis().flushDB();
        }
    
        /**
         *  根据 pattern 获取 redis 中的键
         * */
        public Set<String> getKeysByPattern(String pattern) {
            return getDefaultJedis().keys(pattern);
        }
    
        /**
         *  获取 redis 中所有的键
         * */
        public Set<String> getAllKeys() {
            return getKeysByPattern("*");
        }
    
        /**
         *  判断key是否存在redis中
         * */
        public boolean exists(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().exists(PREFIX + key);
        }
    
        /**
         *  从Redis中移除一个key
         * */
        public void removeKey(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            getDefaultJedis().del(PREFIX + key);
        }
    • String类型接口
        /**
         *  存储字符串
         * */
        public void setString(String key, String value, int expireTime) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
    
            String finalKey = PREFIX + key;
            getDefaultJedis().set(finalKey, value);
            if (expireTime > 0) {
                /**
                 *  如果设置了 expireTime, 那么这个 finalKey会在expireTime秒后过期,那么该键会被自动删除
                 *  这一功能配合出色的性能让Redis可以作为缓存系统来使用,成为了缓存系统Memcached的有力竞争者
                 * */
                getDefaultJedis().expire(finalKey, expireTime);
            }
        }
    
        /**
         *  获取字符串
         * */
        public String getString(String key) throws Exception{
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().get(PREFIX + key);
        }
    • List类型接口
        /**
         *  存储 List
         * */
        public void pushList(String key, String value, String flag) throws Exception {
            if (StringUtil.IsEmpty(key) || StringUtil.IsEmpty(flag)) {
                logger.error("key or flag is null");
                throw new Exception("key or flag is null");
            }
    
            /**
             *  key代表的是链表的名字
             *  List是一个双端链表,lpush是往链表的头部插入一条数据,rpush是往尾部插入一条数据
             * */
            if (flag.equalsIgnoreCase("L")) {
                getDefaultJedis().lpush(PREFIX + key, value);
            } else if (flag.equalsIgnoreCase("R")) {
                getDefaultJedis().rpush(PREFIX + key, value);
            } else {
                logger.error("unknown flag");
                throw new Exception("unknown flag");
            }
        }
    
        /**
         *  获取 List 中的单个元素
         * */
        public String popList(String key, String flag) throws Exception {
            if (StringUtil.IsEmpty(key) || StringUtil.IsEmpty(flag)) {
                logger.error("key or flag is null");
                throw new Exception("key or flag is null");
            }
    
            if (flag.equalsIgnoreCase("L")) {
                return getDefaultJedis().lpop(PREFIX + key);
            } else if (flag.equalsIgnoreCase("R")) {
                return getDefaultJedis().rpop(PREFIX + key);
            } else {
                logger.error("unknown flag");
                throw new Exception("unknown flag");
            }
        }
    
        /**
         *  获取 List 中指定区间上的元素
         * */
        public List<String> getAppointedList(String key, long start, long end) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().lrange(PREFIX + key, start, end);
        }
    
        /**
         *  获取 List 上所有的元素
         * */
        public List<String> getList(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().lrange(PREFIX + key, 0, -1);
        }
    
        /**
         *  获取 List 的长度
         * */
        public long getListLength(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().llen(PREFIX + key);
        }
    • Set类型接口
        /**
         *  存储 Set : 单值存储
         * */
        public void addValueToSet(String key, String value) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            getDefaultJedis().sadd(PREFIX + key, value);
        }
    
        /**
         *  存储 Set : 多值存储
         * */
        public void addListToSet(String key, List<String> values) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            for (String value : values) {
                getDefaultJedis().sadd(PREFIX + key, value);
            }
        }
    
        /**
         * 删除 Set 中的某个元素
         * */
        public void deleteElementInSet(String key, String value) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            getDefaultJedis().srem(PREFIX + key, value);
        }
    
        /**
         *  获取 Set 中所有的成员
         * */
        public Set<String> getSet(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().smembers(PREFIX + key);
        }
    
        /**
         *  判断 value 是否属于 set
         * */
        public boolean isExistInSet(String key, String value) throws Exception {
            if (StringUtil.IsEmpty(key) || StringUtil.IsEmpty(value)) {
                logger.error("key or value is null");
                throw new Exception("key or value is null");
            }
            return getDefaultJedis().sismember(PREFIX + key, value);
        }
    
        /**
         *  获取 Set 中元素个数
         * */
        public long getLengthOfSet(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().scard(PREFIX + key);
        }
    
        /**
         *  取两个 Set 的交集
         * */
        public Set<String> getSetInter(String key1, String key2) throws Exception {
            if (StringUtil.IsEmpty(key1) || StringUtil.IsEmpty(key2)) {
                logger.error("key1 or key2 is null");
                throw new Exception("key1 or key2 is null");
            }
            return getDefaultJedis().sinter(PREFIX + key1, PREFIX + key2);
        }
    
        /**
         *  取两个 Set 的并集
         * */
        public Set<String> getSetUnion(String key1, String key2) throws Exception {
            if (StringUtil.IsEmpty(key1) || StringUtil.IsEmpty(key2)) {
                logger.error("key1 or key2 is null");
                throw new Exception("key1 or key2 is null");
            }
            return getDefaultJedis().sunion(PREFIX + key1, PREFIX + key2);
        }
    
        /**
         *  取两个 Set 的差集
         * */
        public Set<String> getSetDiff(String key1, String key2) throws Exception {
            if (StringUtil.IsEmpty(key1) || StringUtil.IsEmpty(key2)) {
                logger.error("key1 or key2 is null");
                throw new Exception("key1 or key2 is null");
            }
            return getDefaultJedis().sdiff(PREFIX + key1, PREFIX + key2);
        }
    • SortedSet类型接口
        /**
         *  存储有序集合 SortedSet
         * */
        public void setSortedSet(String key, double weight, String value) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            getDefaultJedis().zadd(PREFIX + key, weight, value);
        }
    
        /**
         *  获取有序集合指定区间上的元素
         * */
        public Set<String> getAppointedSortedSet(String key, long start, long end) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().zrange(PREFIX + key, start, end);
        }
    
        /**
         *  获取有序集合上的所有元素
         * */
        public Set<String> getSortedSet(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().zrange(PREFIX + key, 0, -1);
        }
    
        /**
         *  获取有序集合上某个权重区间上的元素
         * */
        public long getLengthOfSortedSetByWeight(String key, double min, double max) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().zcount(PREFIX + key, min, max);
        }
    
        /**
         *  删除有序集合上的元素
         * */
        public void deleteElementInSortedSet(String key, String value) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            getDefaultJedis().zrem(PREFIX + key, value);
        }
    
        /**
         *  获取有序集合中元素的个数
         * */
        public long getLengthOfSortedSet(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().zcard(PREFIX + key);
        }
    
        /**
         *  查看有序集合中元素的权重
         * */
        public double getWeight(String key, String value) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().zscore(PREFIX + key, value);
        }
    • Hash类型接口
        /**
         *  存储 HashMap
         * */
        public void setHashMapByFieldAndValue(String key, String field, String value) throws Exception {
            if (StringUtil.IsEmpty(key) || StringUtil.IsEmpty(field)) {
                logger.error("key or field is null");
                throw new Exception("key or field is null");
            }
            getDefaultJedis().hset(PREFIX + key, field, value);
        }
    
        /**
         *  存储 HashMap
         * */
        public void setHashMapByMap(String key, Map<String, String> map) throws Exception {
            if (StringUtil.IsEmpty(key) || map == null) {
                logger.error("key or map is null");
                throw new Exception("key or map is null");
            }
            getDefaultJedis().hmset(PREFIX + key, map);
        }
    
        /**
         *  删除 HashMap 中的键值对
         * */
        public void deleteHashMapValueByField(String key, String field) throws Exception {
            if (StringUtil.IsEmpty(key) || StringUtil.IsEmpty(field)) {
                logger.error("key or field is null");
                throw new Exception("key or field is null");
            }
            getDefaultJedis().hdel(PREFIX + key, field);
        }
    
        /**
         *  获取 HashMap 中键对应的值
         * */
        public String getHashMapValueByField(String key, String field) throws Exception {
            if (StringUtil.IsEmpty(key) || StringUtil.IsEmpty(field)) {
                logger.error("key or field is null");
                throw new Exception("key or field is null");
            }
            return getDefaultJedis().hget(PREFIX + key, field);
        }
    
        /**
         *  获取 HashMap 中所有的 key
         * */
        public Set<String> getHashMapKeys(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().hkeys(PREFIX + key);
        }
    
        /**
         *  获取 HashMap 中所有的值
         * */
        public List<String> getHashMapValues(String key) throws Exception {
            if (StringUtil.IsEmpty(key)) {
                logger.error("key is null");
                throw new Exception("key is null");
            }
            return getDefaultJedis().hvals(PREFIX + key);
        }
    
        /**
         *  判断 HashMap 中是否存在某一个键
         * */
        public boolean isFieldExistsInHashMap(String key, String field) throws Exception {
            if (StringUtil.IsEmpty(key) || StringUtil.IsEmpty(field)) {
                logger.error("key or field is null");
                throw new Exception("key or field is null");
            }
            return getDefaultJedis().hexists(PREFIX + key, field);
        }

      相对关系型数据库而言,redis 以一种非常简单的思想来存储数据,由于它将数据存储在内存中,所以,读写非常高效,同时,它将内存中的数据写入数据库中,保证数据不会丢失,每次关闭并重新打开时,再将存储在本地数据库中的键值对信息载入内存。
      redis 同时提供 Windows 和 Linux 系统的不同版本,针对不同的流行语言都有相应的 API 接口(目前来看, Java 最为活跃),方便了开发过程中的使用。
      一些经典的数据库操作,redis 中都有很好的支持,比如保证一致性的事务,减小构建数据库开销的连接池接口(JedisPool)等等。
      总的来说,使用 redis,你会感受到它的简洁与高效!

    展开全文
  • JAVA客户端访问Redis示例(入门)

    万次阅读 2012-01-29 14:20:04
    本文记录了安装Redis和从JAVA端访问Redis的步骤 从http://download.csdn.net/detail/kkdelta/4034137 下载本文所需文件. 1,在Linux上安装Redis服务. 下面的操作的base dir为 /root/4setup tar xzf redis-...
  • SpringBoot 集成WebSocket,实现后台向前端(h5 页面,java客户端)推送 什么是WebSocket? 概念: 特点: 通讯方式 服务器端代码实现 maven依赖 websocket的configuration配置文件 websocket 的发布实现: ...
  • 大家好,我是飞哥!在 TCP 连接中,客户端在发起连接请求前会先确定一个客户端端口,然后用这个端口去和服务器端进行握手建立连接。那么在 Linux 上,客户端端口到底是如何被确定下来的呢...
  • 我想在socket通信中,让server能判断clinet连上来的是谁。 通常我们写socket通信时,...如何让client链接到server的端口固定下来,不要每次都随机。 我打算用这个实现判断客户端是谁。或者有没有其他更好的办法。
  • Java中进行Socket通信,总是有两个地方可以指定duank 终于悟出了
  • SpringCloud实战小贴士:随机端口

    千次阅读 2017-06-26 14:10:42
    在之前的《Spring Cloud构建微服务架构》系列博文中,我们经常会需要启动多个实例的情况来测试注册中心、配置中心等基础设施的高可用,也会用来测试客户端负载均衡的调用等。但是,我们一个应用只能有一个端口号,这...
  • 客户程序一般采用随机端口,因此会出现两个客户端程序绑定到同样端口的可能性不大。许多服务器都使用固定的端口。当服务器进程关闭后,有可能它的端口还会被占用一段时间,如果此时立刻在同一主机上重启服务器程序...
  • I UDP 信息发送接收原理 II UDP 发送和接收端口相同 III UDP 发送信息代码示例 IV UDP 接收信息代码示例 V UDP 服务器端代码示例 VI UDP 客户端代码示例 VII 客户端服务器端通信
  • 简单的客户端和服务器套接字代码,其中套接字充当数据泵,创建一串随机数据。 套接字当前设置为端口 8000。有一个计时器运行服务器套接字发送的持续时间,在代码中设置。 数据以逗号分隔,服务器套接字字符串以 EOF ...
  • JavaWebService客户端简明攻略

    千次阅读 2003-08-05 15:24:00
    作为CSDN JavaWebService的小斑竹,很久就想写一些关于JWS的基础文章,苦于公私繁忙,一直无心下笔,所以一拖再拖,今日看了我斑块下有网友问及关于Java调用WebService之问题,遂下决心写下此文以资共勉。...
  • 主要是通过服务器监听端口,对于新访问的客户端建立一个socket长连接。每次客户端输入信息,先传到服务器,再由服务发给在线的客户端。 其功能模型如下: 运行截图: 1、需要先启动服务器端,界面如下: ...
  • java socket 编程,实现客户端和服务端接收信息 #学习笔记/编程/socket tcp/IP四层模型 链路层:数据物理层,光纤,网线之类 网络层:用于将传输的数据进行分组,分配到相应的计算机或端口 传输层:网络之间进行通信...
  • java获取request的 ip port

    千次阅读 2015-11-22 17:18:19
    java获取request的 ip port
  • Socket socket = new Socket("127.0.0.1"...new 一个ServetSocket端口为8888然后调用//调用服务器套接字对象中的accept方法 Socket accept = server.accept(); System.out.println(a...
  • (一)原理要点 数据类型:DatagramSocket与DatagramPacket ...使用构造方法public DatagramSocket()会随机绑定可用的端口。 发送数据报时需要指定目的地址和目的端口:DatagramPacket packet = ...
  • KAFKA随机产生JMX 端口指定的问题

    千次阅读 2018-08-30 10:55:04
    由于测试环境的kafka集群是在私有云的资源池上开的三台虚拟机,而且很多端口都没有开发,所以在搭建kafka服务的时候需要指定开放哪些端口,zk用的是kafka自带的zk启动的,我们在正常开放了2181、9092以及我们指定了...
  • 近日,公司项目有关于服务器对客户端进行绑定的操作。在绑定范围内的设备允许访问服务器,进行相应的服务。...即使能获取到,也要考虑用户篡改,伪造,代理等因素,所以最初的方案,向客户端获取设备信息失败...
  • 今天简单介绍一下如何用Java支持...在服务端有一个随机数生成器,可以生成随机的Integer和Guid,客户端通过服务,可以请求一个或多个随机数。同时,客户端可以向服务端发送一个或多个随机数,这些随机数会
  • run_id : Redis 服务器的随机标识符(用于 Sentinel 和集群) tcp_port : TCP/IP 监听端口 uptime_in_seconds : 自 Redis 服务器启动以来,经过的秒数 uptime_in_days : 自 Redis 服务器启动以来,经过的天数 lru_...
  • Zookeeper客户端Curator使用指南

    千次阅读 2018-10-11 15:45:48
    Curator是zookeeper分布式协调服务的java客户端库,它包装了一系列操作zk的高级API和实用库,是的操作zk变得更加容易和可靠。例如使用原生zk的API实现分布式锁的话,代码量多,复杂,使用Curator后就相对简单的多,...
  • 有些代码不理解,求各位大佬们帮帮忙。部分代码如下: 客户端: ... 服务端: ...创建多个客户端,DatagramSocket():并绑定本地地址和一个...为什么客户端的IP地址都一样,端口随机,服务端还能准确的发给每个客户端
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • Java(2)-Java IO输入输出流

    万次阅读 多人点赞 2012-04-01 11:28:55
    Java中I/O操作主要是指使用Java进行输入,输出操作.Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的...
  • 效果展示完成对这些信息的获取主要还是利用redis的一些命令,如果是win系统下安装的redis,在安装目录运行redis-cli.exe这个文件,输入info,再回车,就可以看到输出很多字段的参数,部分具体参数对应的意思如下: ...
  • 公司项目需要做web端和安卓端:web端使用ehcache做缓存,安卓端使用redis来存放token和用户登录后产生的信息(相当于session的功能);因为项目属于云平台,数据会比较多,所以单机存放压力有点大,所以...1.客户端分布

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,582
精华内容 17,032
关键字:

java客户端获取随机端口

java 订阅