精华内容
下载资源
问答
  •  Dubbo中必有的核心概念只有服务提供者、服务消费者和注册中心这三,治理中心以及监控中心并非必需品。  服务提供者初始化后会向注册中心注册服务服务消费者启动时向注册中心订阅服务。注册中心在服务提供者...

    6.1 Dubbo

      6.1.1 Dubbo概述

        服务间基于RPC的方式调用。

      6.1.2 核心流程

        Dubbo中必有的核心概念只有服务提供者、服务消费者和注册中心这三个,治理中心以及监控中心并非必需品。

        服务提供者初始化后会向注册中心注册服务;服务消费者启动时向注册中心订阅服务。注册中心在服务提供者列表发生变化时将变化的内容主动通知给服务消费者。服务提供者和服务消费者在初次连通后,持有长连接,通过透明化的远程调用进行通信。

      6.1.3 注册中心

        大多数情况,Dubbo都是配合Zookeeper注册中心来使用的。

      6.1.4 负载均衡

        Dubbo采用客户端负载均衡方式,由服务消费者一方决定当前通信发送至哪个服务提供者。

        服务消费者启动时会从注册中心同步一份有效的服务提供者列表,缓存起来,当服务列表变化时,会更新。每次调用服务时,根据合适的负载均衡算法选择一个服务提供者。

        Dubbo的服务发现和负载均衡机制,有如下三个特征:

    • 弹性好:基于服务发现机制,动态、灵活、实时。
    • 高可用:去中心化的服务治理方案,注册中心挂了后,可以使用缓存。但是在注册中心挂了后,无法感知新上线的服务。
    • 性能优:服务提供者和消费者之间点对点直接连接,连接建立后无需断开。

        Dubbo支持随机、轮询(会导致大量请求阻塞在短板服务上)、最少活跃调用数和一致性哈希这四种负载均衡策略。

                   重点说一下一致性哈希:为了解决因特网中的热点(Hot spot)问题。

                    比如:有4个服务器,每个都缓存图片,当定位一个图片时,为了避免访问四次,可以用取模运算的方式来决定图片的位置。但是问题是:当服务器增加或减少时,取模运算会导致所有的图片位置都不对,缓存在短时间内全部失效,叫缓存雪崩。为了避免这种情况,提出一致性哈希算法,目的是当服务器数量增加和减少时,图片缓存的位置不变,不会发生雪崩。                    

      6.1.5 远程通信

        Dubbo通信协议采用的是Java NIO实现的多路复用。对于每一个服务消费者来说,Dubbo协议的服务提供者会创建固定数量的长连接传输消息,有效减少握手次数,Dubbo通信协议使用线程池并发处理请求来增加并发效率。由于连接复用,传输大文件时带宽占用率高可能会成为系统瓶颈,因此Dubbo通信协议适合处理高并发的小数据量互联网请求,不适合处理视频、高清照片。 

      6.1.6 限流

        Dubbo服务提供者可以设置限流。

      6.1.7 治理中心

        提供一个可视化中心,辅助做运维工作。提供了分组查询、配置更改、加权降权、禁用启用、权限控制、负责人管理等运维功能。

      6.1.8 监控中心

      6.1.9 DubboX的扩展

        DubboX由当当网开源,X是extensions一词,是对Dubbo的扩展。

        Rest协议:Dubbo缺乏对RESTful风格支持。 DubboX弥补了这一缺憾。

                  高新能序列化:序列化对远程调用的响应速度、吞吐量、网络带宽影响大。Dubbo支持的不算太好,DubboX进行了扩展。

    6.2 Spring Cloud

      提供了一套云原生开发组件。

      6.2.1 概述

        Spring Cloud是基于Spring boot的嵌入式服务治理框架,建立在工程师熟悉约定的前提下。

      6.2.2 开发脚手架Spring Boot

      自动装配:

        Spring boot对Spring 进行封装,通过约定优于配置及元注解驱动的设计理念。

        Spring Boot提供了内嵌的Web服务器简化了Spring MVC配置,提供了对数据库、NOSQL、缓存、消息中间件、REST访问、邮件发送等第三方服务的高度整合。

        启动Spring boot的入口应用仅需要一个注解和一行代码。

        @SpringBootApplication是@Configuration 、 @EnableAutoConfiguration 、@ComponentScan这三个注解的组合。

       暴露端点:

        Spring boot提供了Actuator模块用于方便地暴露应用自身的信息,以便监控与管理。 

      6.2.3 服务发现

      •  Eureka
      •  使用zookeeper
      •  使用Consul

      6.2.4 负载均衡

        Ribbon:    提供了客户端负载均衡的解决方案。自动的从Eureka中获取服务提供者列表,将负载均衡与服务发现结合起来。

      6.2.5 熔断

        Hystrix做为熔断器,并通过它实现熔断后的业务降级。

      6.2.6 远程通信

        Spring cloud采用当前较为流行的RESTful API进行服务之间交互。Feign。

    转载于:https://www.cnblogs.com/liufei1983/p/11504278.html

    展开全文
  • 小结:在点对点p2p程序中,服务器端子程序退出,子进程会主动发送信号,关闭父进程,但是这种模式导致服务器只能支持一客户端连接,本章节中使用新的框架,子进程退出,不主动发送信号关闭父进程,而是父进程安装...
    小结:在点对点p2p程序中,服务器端子程序退出,子进程会主动发送信号,关闭父进程,
    但是这种模式导致服务器只能支持一个客户端连接,本章节中使用新的框架,子进程退出,不主动发送信号关闭父进程,而是父进程安装SIGCHLD信号,wait()子进程。
    这样就支持了多客户端。

     

    僵尸进程解决方案
    1.忽略SIGCHLD信号,这样不会出现僵尸进程
    2.安装信号,父进程接收到SIGCHLD信号后,wait()子进程
    //头文件
    int server_socket();
    
    int client_socket();
    //服务器端
    #include "pub.h"
    
    int main(int arg,char *args[])
    {
        server_socket();
        return 0;
    }
    //客户端
    #include "pub.h"
    
    int main(int arg,char *args[])
    {
        client_socket();
        return 0;
    }
    //辅助类实现
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <errno.h>
    #include <sys/types.h>          /* See NOTES */
    #include <sys/socket.h>
    #include <sys/wait.h>
    #include <signal.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include "pub.h"
    
    ssize_t readn(int fd, const void *buf, ssize_t count)
    {
        if (buf == NULL)
        {
            printf("readn() params is not correct !\n");
            return -1;
        }
        //定义剩余字节数
        ssize_t lread = count;
        //定义辅助指针变量
        char *pbuf = (char *) buf;
        //定义每次读取的字节数
        ssize_t nread = 0;
        while (lread > 0)
        {
            nread = read(fd, pbuf, lread);
            if (nread == -1)
            {
                //read是可中断睡眠函数,需要屏蔽信号
                if (errno == EINTR)
                    continue;
                perror("read() err");
                return -1;
            } else if (nread == 0)
            {
                printf("peer read socket is closed !\n");
                //返回已经读取的字节数
                return count - lread;
            }
            //重置剩余字节数
            lread -= nread;
            //辅助指针后移
            pbuf += nread;
        }
        return count;
    }
    
    ssize_t writen(int fd, const void *buf, ssize_t count)
    {
        if (buf == NULL)
        {
            printf("writen() params is not correct !\n");
            return -1;
        }
        //定于剩余字节数
        ssize_t lwrite = count;
        //定义每次写入字节数
        ssize_t nwrite = 0;
        //定义辅助指针变量
        char *pbuf = (char *) buf;
        while (lwrite > 0)
        {
            nwrite = write(fd, pbuf, lwrite);
            if (nwrite == -1)
            {
                if (errno == EINTR)
                    continue;
                perror("write() err");
                return -1;
            } else if (nwrite == 0)
            {
                printf("peer write socket is closed !\n");
                return count - lwrite;
            }
            //重置剩余字节数
            lwrite -= nwrite;
            //辅助指针变量后移
            pbuf += nwrite;
        }
        return count;
    }
    
    ssize_t recv_peek(int fd, const void *buf, ssize_t count)
    {
        if (buf == NULL)
        {
            printf("recv_peek() params is not correct !\n");
            return -1;
        }
        ssize_t ret = 0;
        while (1)
        {
            //此处有多少读取多少,不一定ret==count
            ret = recv(fd, (void *)buf, count, MSG_PEEK);
            if (ret == -1 && errno == EINTR)
                continue;
            return ret;
        }
        return -1;
    }
    
    ssize_t mreadline(int fd, const void *buf, ssize_t count)
    {
        //定义剩余字节数
        ssize_t lread = count;
        //定义每次读取的字节数
        ssize_t nread = 0;
        //定义辅助指针变量
        char *pbuf = (char *) buf;
        int i = 0, ret = 0;
        while (1)
        {
            nread = recv_peek(fd, pbuf, count);
            printf("recv_peek() 执行!\n");
            if (nread == -1)
            {
                perror("recv_peek() err");
                return -1;
            } else if (nread == 0)
            {
                //注意:这里不要返回已经读取字节数,增加了调用函数的判断,直接返回-1,让调用函数当错误处理
                printf("peer socket is closed !\n");
                return -1;
            }
            for (i = 0; i < nread; i++)
            {
                if (pbuf[i] == '\n')
                {
                    //这是一段报文
                    memset(pbuf, 0, count);
                    //从socket缓存区读取i+1个字节
                    ret = readn(fd, pbuf, i + 1);
                    if (ret != i + 1)
                        return -1;
                    return ret;
                }
            }
            //如果当前socket缓存区中没有\n,
            //那么先判断自定义buf是否还有空间,如果没有空间,直接退出
            //如果有空间,先将当前socket缓存区中的数据读出来,放入buf中,清空socket缓存
            //继续recv,判断下一段报文有没有\n
            if (lread >= count)
            {
                printf("自定义buf太小了!\n");
                return -1;
            }
            //读取当前socket缓存
            ret = readn(fd, pbuf, nread);
            if (ret != nread)
                return -1;
            lread -= nread;
            pbuf += nread;
        }
        return -1;
    }
    
    void handler(int sign)
    {
        if (sign == SIGCHLD)
        {
            printf("子进程退出 !\n");
            wait(NULL);
        }
    }
    
    int server_socket()
    {
        int listenfd = socket(AF_INET, SOCK_STREAM, 0);
        if (listenfd == -1)
        {
            perror("socket() err");
            return -1;
        }
        //reuseaddr
        int optval = 1;
        if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval))
                == -1)
        {
            perror("setsockopt() err");
            return -1;
        }
        //bind
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(8080);
        addr.sin_addr.s_addr = inet_addr("127.0.0.1");
        if (bind(listenfd, (struct sockaddr *) &addr, sizeof(addr)) == -1)
        {
            perror("bind() err");
            return -1;
        }
        //listen
        if (listen(listenfd, SOMAXCONN) == -1)
        {
            perror("listen()err");
            return -1;
        }
        pid_t pid = 0;
        //忽略SIGCHLD信号
        //signal(SIGCHLD,SIG_IGN);
        //安装信号
        if (signal(SIGCHLD, handler) == SIG_ERR)
        {
            printf("signal() failed !\n");
            return -1;
        }
        while (1)
        {
            struct sockaddr_in peeraddr;
            socklen_t peerlen = sizeof(peeraddr);
            int conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen);
            printf("accept by %s\n", inet_ntoa(peeraddr.sin_addr));
            if (conn == -1)
            {
                perror("accept() err");
                return -1;
            }
            pid = fork();
            if (pid == -1)
            {
                perror("fork() err");
                return -1;
            }
            //子进程接收数据
            if (pid == 0)
            {
                //关闭监听套接字
                close(listenfd);
                char buf[1024] = { 0 };
                int ret = 0;
                while (1)
                {
                    ret = mreadline(conn, buf, 1024);
                    if (ret == -1)
                    {
                        close(conn);
                        return -1;
                    }
                    //打印客户端数据
                    fputs(buf, stdout);
                    //把数据返回给客户端
                    writen(conn, buf, ret);
                    memset(buf, 0, sizeof(buf));
                }
            } else if (pid > 0)
            {
                close(conn);
            }
        }
        return 0;
    }
    
    int client_socket()
    {
        int sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd == -1)
        {
            perror("socket() err");
            return -1;
        }
        //bind
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(8080);
        addr.sin_addr.s_addr = inet_addr("127.0.0.1");
        if(connect(sockfd,(struct sockaddr *)&addr,sizeof(addr))==-1)
        {
            perror("connect() err");
            return -1;
        }
        pid_t pid=0;
        pid=fork();
        if(pid==-1)
        {
            perror("fork() err");
            return -1;
        }
        char buf[1024]={0};
        int ret=0;
        //子进程发送数据
        if(pid==0)
        {
            while(fgets(buf,sizeof(buf),stdin)!=NULL)
            {
                ret=writen(sockfd,buf,strlen(buf));
                if(ret!=strlen(buf))
                    return -1;
                memset(buf,0,sizeof(buf));
            }
        }else if(pid>0)
        {
            //父进程接收数据
            while(1)
            {
                ret=mreadline(sockfd,buf,sizeof(buf));
                if(ret==-1)
                    return -1;
                //打印数据
                fputs(buf,stdout);
                memset(buf,0,sizeof(buf));
            }
        }
        return 0;
    }
    .SUFFIXES:.c .o
    CC=gcc
    SRCS=tec01.c\
        pub.c
    OBJS=$(SRCS:.c=.o)
    EXEC=runc
    
    SRCS1=hello.c\
        pub.c
    OBJS1=$(SRCS1:.c=.o)
    EXEC1=hello
    
    
    start:$(OBJS) $(OBJS1)
        $(CC) -o $(EXEC) $(OBJS)
        $(CC) -o $(EXEC1) $(OBJS1)
        @echo "-------OK----------"
    .c.o:
        $(CC) -Wall -g -o $@ -c $<
    clean:
        rm -f $(OBJS)
        rm -f $(EXEC)
        rm -f $(OBJS1)
        rm -f $(EXEC1)

     

    转载于:https://www.cnblogs.com/zhanggaofeng/p/6139544.html

    展开全文
  • 前一段时间项目中遇到一稍微麻烦一点的问题。 即客户要求,他在后台编辑好文章后要主动给每...群发消息服务号每月最多只能发送4条。 而客户要求的是随时随地就能发送.这4条明显不符合要求的。 怎么办呢?一度陷
  • 卓然主动防御系统分成四个模块,包含一个应用层可执行文件(.exe),四个内核层驱动(.sys),一个规则库数据库文件(.mdb),请保证六个文件在同一目录。应用层采用Visual Studio 2008(C )开发,驱动层开发环境为WDK ...
  • 本系统分成四个模块,包含一个应用层可执行文件(.exe),四个内核层驱动(.sys),一个规则库数据库文件(.mdb),请保证六个文件在同一目录。 1.1 安装服务与启动监控 程序不需要安装,双击即可打开可执行文件。...

    1 使用说明

    本系统分成四个模块,包含一个应用层可执行文件(.exe),四个内核层驱动(.sys),一个规则库数据库文件(.mdb),请保证六个文件在同一目录。

    1.1 安装服务与启动监控

    程序不需要安装,双击即可打开可执行文件。打开后,如果需要启动服务,请点击“安装服务”,请切换至“主要”标签页,接着“启动进程监控”、“启动注册表监控”、“启动文件监控”、“启动内存加载监控”,程序开始拦截系统调用。

    点击此处下载文档和源码


     

    展开全文
  • 公司机器上的Android Studio很时髦,每次都会准时接收到官方稳定版的推送。目前最新的稳定版本是1.4.1,...流传在网络上有两方案: 一、网友通过修改./bin/studio64.vmoptions文件,加入以下内容:-Djava.net.prefer

    公司机器上的Android Studio很时髦,每次都会准时接收到官方稳定版的推送。目前最新的稳定版本是1.4.1,增加了很多心动的功能。
    可是我的笔记本上的AS还在1.3.1,是时候主动将其更新了。

    目前来看,主动更新是有困难的。AS提示连接服务器失败。流传在网络上有两个方案:
    一、网友通过修改./bin/studio64.vmoptions文件,加入以下内容:

    -Djava.net.preferIPv4Stack=true
    -Didea.updates.url=http://dl.google.com/android/studio/patches/updates.xml  
    -Didea.patches.url=http://dl.google.com/android/studio/patches/ 

    虽然可以将update信息调出来,可是我这里还是无法下载。

    我只好尝试比较复杂一些的第二种方案。
    二、下载差异patch手动更新
    https://dl.google.com/android/studio/patches/updates.xml
    这里列出Android Studio的所有版本,最新的是1.5 Beta。
    “A new Android Studio 1.5 Beta is available in the canary channel.”
    我们要主动获取patch,格式如下:

     linux: AI-$FROM-$TO-patch-unix.jar
      windows: AI-$FROM-$TO-patch-win.jar
      MacOS: AI-$FROM-$TO-patch-mac.jar

    不过从1.3.1直接到1.4.1还没有相应的patch,需要过度一下。下面是我的两次升级方案:

    https://dl.google.com/android/studio/patches/AI-141.2135290-141.2288178-patch-unix.jar
    https://dl.google.com/android/studio/patches/AI-141.2288178-141.2343393-patch-unix.jar

    安装很简单,只需运行如下命令即可:

    android-studio3$ java -cp ~/Downloads/AI-141.2135290-141.2279206-patch-unix.jar com.intellij.updater.Runner install .
    ...
    android-studio3$ java -cp ~/Downloads/AI-141.2279206-141.2343393-patch-unix.jar com.intellij.updater.Runner install .



    更新完成,即刻启动新版AS对NDK开发支持的探索!

    参考:
    http://www.cnblogs.com/daemon369/archive/2013/08/18/3266264.html

    展开全文
  • Mind (

    2019-08-26 18:34:11
    28 产品体系:中观、微观、宏观 (一)中观——套路 用户画像、痛点和痒点、整体流程图...一产品只能在被动中,默默把握每一微小的主动机会,在每一接触的瞬间,每一次的交互里,让用户顺畅的深入下来。 用...
  • 计算机网络(

    2021-03-04 17:36:20
    还有一种是流量分析,攻击者只是观察和分析某一协议数据单元(PDU),以便了解所交换的数据的某种性质,但不干扰信息流。 主动攻击: 1.篡改:更改报文流。 2.恶意程序:对网络安全威胁较大的有:计算机病毒、...
  • 托管主动访问公网的应用程序 您可以将需要主动访问公网的应用程序托管在VPC中的一子网内,通过网络地址转换(NAT)网关路由其流量。通过配置SNAT规则,子网中的实例无需暴露其私网IP地址即可访问Internet,并可...
  • 六个步骤:客户端进行密码信息确认 第七个步骤:客户端服务端远程连接建立成功 每一次启动 sshd 服务时,服务器会主动去找 /etc/ssh/ssh_host* 的档案,若系统刚刚安装完成时,由于没有这些公钥档案,因此 sshd 会...
  • 作为一IT人员,应该具备种意识:客户意识,质量意识,效能意识,主动意识,团队意识,精英意识。 把客户意识放在第一位绝对是有道理的,因为客户是上帝。我觉得客户意识并不仅仅是服务人员对待客户要很有礼貌...
  • 上面的状态有10种,第11种是CLOSING,这的产生条件是当服务器和客户端同时发送关闭请求,这时候不会产生FIN_WAIT状态而是会产生CLOSING状态。只有主动发送close的一端,才会有TIME_WAIT状态。 可以使用代码来查看...
  • django 后台服务

    2017-11-06 14:50:03
    如果是 Django 不主动提示创建管理员(Django 1.9不提示)用下面的命令创建一帐号 1 python manage.py createsuperuser ,修改 admin.py  进入 blog 文件夹,修改 admin....
  • 100ask_imx6ull视频监控项目-内网穿透() •在前面的课程,Ffmpeg和Nginx都运行在开发板上 拉流端只能在同一局域网内 不能通过局域网外的互联网访问Ngnix •想在任何地方,都可以通过互联网访问Nginx,怎么办? ...
  • 简介 SpringCloudConfig就是我们通常意义上的配置中心,把应用原本放在本地文件的配置抽取出来放在中心服务器,从而能够...但客户端并不能主动感知到配置的变化,从而主动去获取新的配置,这需要每客户端通过PO...
  • 至少我眼力所及,在公司服务的10年时间里,还没见过一空降的中级管理岗。 2.做技术 的,可以转管理,可以转架构,也可以转教学。但是反过来却不成立,尤其是在一日千里的IT行业,脱离技术,最多只用3年,技术基本...
  • OnMessage返回AppSession结构体,提供Send方法,服务器可以主动向客户端发送数据 本文代码查看github: https://github.com/zboyco/go-server/tree/step-6 新建一AppSession结构体,将客户端会话放在AppSession中,方便...
  • 在该模型中,一服务器提供一个服务,该服务等待客户端主动发出的请求,接收到客户端的请求后,处理请求,然后选择性地向客户端程序发送响应。客户端程序是活动的参与者,提交请求并有效地决定了服务何时开始执行...
  • 网络攻防教材学习 TCP/IP协议栈攻击 网络攻击基本模式 截获,中断,篡改和伪造 ...篡改消息是指一合法消息的某些部分被改变、删除,消息被延迟或改变顺序,通常用以产生一未授权的效果。如修...
  • 应用消息:紧耦合和松耦合 应用消息常用的是RPC和发布/订阅,其实就是...如果采用紧耦合的RPC,则员工系统必须对服务了解,并主动调用这些服务,每新增一个服务,员工系统都要进行update。随着新服务的增加,员工系统
  • 网络服务-VSFTP

    2020-10-24 15:53:00
    文章目录一、VSFTP 概述1.1 安全特性二、 VSFTP 连接类型三、VSFTP 工作模式Port模式(主动)Passive 模式(被动)四、VSFTP 传输模式五、VSFTP 软件信息、登录验证方式七、VSFTP 实验部署 一、VSFTP 概述 FTP 是 ...
  • 【网络】()TCP的十一种状态

    千次阅读 2015-09-13 17:32:12
    1、TCP 十种状态过程描述: 0.1 服务器B和客户端A中的套接字都处于CLOSE状态(图中未标出) ...0.3 客户端A调用socket/connect函数创建一套接字后,处于SYN_SENT状态,该套接字属于主动套接字,用来发起连
  • 网络安全是指网络系统的硬件、软件及其系统受到保护,不受偶然的或者恶意的原因而遭到破坏、更改、泄漏,系统连续可靠正常运行,网络服务不被中断。网络安全的三基本属性:机密性、完整性和可用性。国际电信联盟在...
  • DNS 是一分布式数据库,提供了主机名和 IP 地址之间相互转换的服务。这里的分布式数据库是指,每 站点只保留它自己的那部分数据。 域名具有层次结构,从上到下依次为:根域名、顶级域名、二级域名。 一般采用UDP...
  • 而在这关键时刻,快递行业主动来了一场大地震——多快递公司宣布涨价。 先是中通快递宣布今年以来快递业受运输成本增加、人工成本提升、原材料价格上涨等多种因素影响,同时为了进一步提升服务质量,保障客户...
  • 在该模型中,一服务器提供一个服务,该服务等待客户端主动发出的请求,接收到客户端的请求后,处理请求,然后选择性地向客户端程序发送响应。客户端程序是活动的参与者,提交请求并有效地决定了服务何时开始执行...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 203
精华内容 81
关键字:

服务六个主动