秃头猿猿
秃头猿猿

框架篇-grpc(二)-grpc四大通信模型

1. GRPC

从上述可知 grpc一共有四种通信模型，如下所示，接下来就来仔细探讨一下这四种模型

image-20210531165018938

1.1 Unary

这种通信模型也是最简单的模型，客户端发送单一请求消息，服务端回复一个单一响应

接下来实现一个经典案例，客户端向服务端发送字符串，服务端返回该字符串和uuid，如下图

image-20210604140031013

实现起来也较为简单。具体步骤如下：

  • 构建环境
  • 构建服务端
  • 构建客户端
  • 测试消息发送

接下来就挨个实现步骤

1.1.1 common

创建一个maven项目(grpc-parent)，打包方式为pom,其pom.xml内容如下：



    4.0.0

    com.tomato.wangzh
    grpc-parent
    pom
    1.0-SNAPSHOT
    
        grpc-common
        grpc-server
        grpc-client
    

    
        1.36.0
        3.3.0
        8
        8
        1.5.0.Final
    

    
        
            
                io.grpc
                grpc-protobuf
                ${grpc.version}
            
            
                io.grpc
                grpc-stub
                ${grpc.version}
            

            
                io.grpc
                grpc-netty
                ${grpc.version}

创建maven模块(grpc-common),其pom.xml如下



    
        grpc-parent
        com.tomato.wangzh
        1.0-SNAPSHOT
    
    4.0.0

    grpc-common

    
        
            io.grpc
            grpc-protobuf
        

        
            io.grpc
            grpc-stub
        
    

    
        
            
                kr.motd.maven
                os-maven-plugin
                ${os-maven.plugin.version}
            
        
        
            
                org.apache.maven.plugins
                maven-jar-plugin
            
            
                org.xolstice.maven.plugins
                protobuf-maven-plugin
                0.5.0
                
                    com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}
                    grpc-java
                    io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}
                    
                    src/main/resources/proto
                
                
                    
                        
                            compile
                            compile-custom

在grpc-common/src/main/resources下，创建proto/GrpcHello.proto，内容如下：

syntax = "proto3";

package tomato;

option java_package = "com.tomato.wangzh.grpc.common";
option java_multiple_files = true;

// 定义请求消息
message HelloRequest {
    string param = 1;
}

// 定义响应消息
message HelloResponse {
    string result = 1;
}

// 定义服务 要想远程调用就必须定义服务接口
service HelloService {
    // rpc 代表远程调用
    // sum 代表远程调用的方法
    // Request 代表远程调用要传入的参数
    // Response 代表返回的结果
    rpc hellRpcTest(HelloRequest) returns(HelloResponse) {}
}

输入mvn compile生成代码,如下图：

image-20210604140517140

打开HelloServiceGrpc，在代码中可以看到以下代码:

/**
 * 创建一个异步的stub，支持服务的所有通信类型
 * 简单理解就是这个stub可以支持所有的通信类型
 */
public static HelloServiceStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
        new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
            public HelloServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
            return new HelloServiceStub(channel, callOptions);
        }
    };
    return HelloServiceStub.newStub(factory, channel);
}

/**
 * 创建一个阻塞的stu 支持 unary 通信和服务的流式输出
 */
public static HelloServiceBlockingStub newBlockingStub(
    io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
        new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
            public HelloServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
            return new HelloServiceBlockingStub(channel, callOptions);
        }
    };
    return HelloServiceBlockingStub.newStub(factory, channel);
}

/**
 * 创建一个新的 ListenableFuture 风格的存根，支持对服务的一元调用
 */
public static HelloServiceFutureStub newFutureStub(
    io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
        new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
            public HelloServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
            return new HelloServiceFutureStub(channel, callOptions);
        }
    };
    return HelloServiceFutureStub.newStub(factory, channel);
}

同时生成的还有一个基础服务类，如下

image-20210604141446523

1.1.2 server

创建maven模块(grpc-server),其pom.xml如下



    
        grpc-parent
        com.tomato.wangzh
        1.0-SNAPSHOT
    
    4.0.0

    grpc-server

    
        8
        8
    

    
        
            com.tomato.wangzh
            grpc-common
            ${project.parent.version}
        


        
            io.grpc
            grpc-netty
        

        
            junit
            junit
            4.13
            test

创建GrpcService,内容如下：

package com.tomato.wangzh.grpc.server;

import com.tomato.wangzh.grpc.common.HelloRequest;
import com.tomato.wangzh.grpc.common.HelloResponse;
import com.tomato.wangzh.grpc.common.HelloServiceGrpc;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;

import java.util.UUID;

// Grpc 必须继承 HelloServiceImplBase
public class GrpcService extends HelloServiceGrpc.HelloServiceImplBase {

    /**
     * gprc远程调用 需要重写该方法，这个方法是在 proto文件里面定义的
     * @param request 数据请求
     * @param responseObserver 响应
     */
    @Override
    public void hellRpcTest(HelloRequest request, StreamObserver responseObserver) {
        try {
            // 获取请求参数
            String param = request.getParam();

            UUID uuid = UUID.randomUUID();
            // 创建响应对象
            HelloResponse response = HelloResponse.newBuilder().setResult(param + uuid.toString()).build();

            // 设置响应对象
            responseObserver.onNext(response);

            // 告诉客户端处理完成
            responseObserver.onCompleted();
        } catch (Exception e) {
            e.printStackTrace();

            // 异常处理
            responseObserver.onError(Status.DATA_LOSS.withDescription(e.getMessage()).asException());
        }
    }
}

封装一个Grpc的服务类GrpcServer用来进行测试，内容如下：

package com.tomato.wangzh.grpc.server;

import com.tomato.wangzh.grpc.common.HelloServiceGrpc;
import io.grpc.Server;
import io.grpc.ServerBuilder;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;


public class GrpcServer {

    private static final Logger logger = Logger.getLogger(GrpcServer.class.getName());

    /**
     * grpc server port
     */
    private Integer port;
    /**
     * grpc server
     */
    private Server server;

    /**
     * grpc service
     */
    private HelloServiceGrpc.HelloServiceImplBase service;


    public GrpcServer(Integer port,HelloServiceGrpc.HelloServiceImplBase service) {
        this(port,ServerBuilder.forPort(port),service);
    }

    public GrpcServer(Integer port, ServerBuilder builder,HelloServiceGrpc.HelloServiceImplBase service) {
        logger.info("init grpc server");
        this.port = port;
        this.service = service;
        server = builder.addService(service).build();
    }

    public void start() throws IOException {
        server.start();
        logger.info("start server");
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            logger.info("shut down grpc server because JVM is shuts down");
            try {
                GrpcServer.this.stop();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            logger.info("grpc server shut down");
        }));

    }

    /**
     * 关闭服务器，如果服务器关闭达到超时时间，则放弃
     * @throws InterruptedException
     */
    public void stop() throws InterruptedException {
        if (server != null) {
            // shut down grpc server
            server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
        }
    }

    /**
     * 阻塞服务器，直到服务器关闭
     * @throws InterruptedException
     */
    public void blockUntilShutdown() throws InterruptedException {
        if (server != null) {
            // blocking grpc server
            server.awaitTermination();
        }
    }

    public static void main(String[] args) {
        try {
            GrpcServer server = new GrpcServer(13452, new GrpcService());
            server.start();
            server.blockUntilShutdown();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
            // 启动服务器失败
            logger.info("failed to start server");
        }
    }
}

1.1.3 client

创建maven模块grpc-client,其pom.xml内容如下：



    
        grpc-parent
        com.tomato.wangzh
        1.0-SNAPSHOT
    
    4.0.0

    grpc-client

    
        8
        8
    

    
        
            com.tomato.wangzh
            grpc-common
            ${project.parent.version}
        

        
            io.grpc
            grpc-netty

创建GrpcClient用来连接服务端，如下：

package com.tomato.wangzh.client;

import com.tomato.wangzh.grpc.common.HelloRequest;
import com.tomato.wangzh.grpc.common.HelloResponse;
import com.tomato.wangzh.grpc.common.HelloServiceGrpc;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;

import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;


public class GrpcClient {

    private static final Logger logger = Logger.getLogger(GrpcClient.class.getName());


    // 与服务端通信通道
    private ManagedChannel channel;

    // 阻塞stub 用于服务端通信
    private HelloServiceGrpc.HelloServiceBlockingStub stub;

    public GrpcClient(Integer port, String ip) {
        this.channel =
                ManagedChannelBuilder
                        .forAddress(ip, port)
                        .usePlaintext() // 使用文本传输 这个是最简的方式
                        .build();   // 构建通信channel

        this.stub = HelloServiceGrpc.newBlockingStub(channel);
        logger.info("init client");
    }


    /**
     * 等待通道关闭直到达到超时时间放弃
     * @throws InterruptedException
     */
    public void shutdown() throws InterruptedException {
        if (channel != null) {
            channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
            logger.info("shut down client channel");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        GrpcClient client = null;
        try {
            // 创建客户端
            client = new GrpcClient(13452, "localhost");
            // 构建请求参数
            HelloRequest request = HelloRequest.newBuilder().setParam("hello world").build();

            // 远程调用方法
            HelloResponse response = client.stub.hellRpcTest(request);

            // 输出结果
            System.out.println(response.getResult());
        } finally {
          if (client != null) {
              // 关闭通道
              client.shutdown();
          }
        }
    }
}

1.1.4 测试

正常测试

先启动服务端如下：

image-20210604161709307

再启动客户端：

image-20210604161804655

可以看到客户端已经收到消息了

测试发送数据为 null

修改客户端测试代码，将请求参数设为null,如下：

image-20210604162104918

结果可以发现在客户端抛出了空指针异常

image-20210604162327424

测试服务端耗时操作

修改服务端代码，客户端代码修改正常

image-20210604162643823

重新启动客户端和服务端，可以发现客户端会进行等待，直到服务端返回信息

image-20210604162949834

这肯定是不行的，因此需要对耗时操作进行处理，修改请求等待时间，如下：

image-20210604163624109

启动后发现5s后没有响应，那么就直接报错，如下：

image-20210604164406183

注意：虽然客户端因为超时关闭了，但是这个请求还是会在服务端运行，这肯定是不允许的，一旦客户端取消了连接，那么该请求在服务端也应该取消。

在服务端增加去校代码，如下:

image-20210604173012699

再次启动客户端和服务端，如下：

image-20210604173641858

说明配置成功

1.2 Client Streaming

这种通信模型主要是客户端通过流式发送多次rpc请求给服务端，服务端对客户端进行一个简单的响应

image-20210606152020932

例如当客户端需要上传一个文件到服务端时就可以采用这种方式，客户端将文件拆分成以一个的小文件以流的方式顺序发送给服务端

服务端将这些文件接收到合并，这样比直接上传一个文件，从效率来说明显要更加快一点

因此我们就来实现是一个这样的案例，以此学习这种通信模型

1.2.1 common

在之前的grpc-common模块中继续增加protobuf文件(client_streaming.proto)，内容如下：

syntax = "proto3";

package client_streaming;

option java_multiple_files = true;
option java_package = "com.tomato.wangzh.grpc.common";

// 上传文件请求信息
message UploadFileRequest {
    // 一条包含许多字段的消息，并且最多同时设置一个字段，您可以使用其中oneof功能来强制执行此行为并节省内存
    oneof data {
        FileInfo file_info = 1;
        bytes file_data = 2;
    }
}


// 创建文件信息
message UploadFileResponse {
    string file_id = 1;
    string size = 2;
}

// 文件信息
message FileInfo {
    // 文件id
    string file_id = 1;
    // 文件类型
    string file_type = 2;
}

service UploadFileService {
    // stream 代表 客户端流
    rpc uploadFile(stream UploadFileRequest) returns (UploadFileResponse) {}
}

输入mvn clean compile生成代码，如下：

image-20210607133805328

1.2.2 client

客户端以顺序流上传一张图片到服务端，服务端保存图片信息，具体流程如下：

image-20210616170005220

代码如下：

package com.tomato.wangzh.client.upload;

import com.google.protobuf.ByteString;
import com.tomato.wangzh.grpc.common.FileInfo;
import com.tomato.wangzh.grpc.common.UploadFileRequest;
import com.tomato.wangzh.grpc.common.UploadFileResponse;
import com.tomato.wangzh.grpc.common.UploadFileServiceGrpc;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;

import java.io.IOException;
import java.io.InputStream;
import java.text.MessageFormat;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class GrpcUploadClient {

    private static final Logger logger = Logger.getLogger(GrpcUploadClient.class.getName());

    private ManagedChannel channel;

    // 注意： 与 helloword例子不同，这个用的是UploadFileServiceStub 而不是阻塞式的
    private UploadFileServiceGrpc.UploadFileServiceStub stub;

    public GrpcUploadClient(Integer port, String ip) {
        channel = ManagedChannelBuilder.forAddress(ip, port).usePlaintext().build();
        stub = UploadFileServiceGrpc.newStub(channel);
    }

    public static void main(String[] args) throws IOException {
        GrpcUploadClient client = null;
        CountDownLatch countDownLatch = new CountDownLatch(1);
        // 读取文件数据
        InputStream in = GrpcUploadClient.class.getResourceAsStream("/file/1.jpg");
        StreamObserver requestObserver = null;
        try {
            // 创建客户端
            client = new GrpcUploadClient(65534, "127.0.0.1");

            // 构建requestObserver 用来传输数据
            requestObserver =
                    client.stub.withDeadlineAfter(5,TimeUnit.SECONDS).uploadFile(new StreamObserver() {

                        @Override
                        public void onNext(UploadFileResponse value) {
                            // 获取服务端响应的结果
                            logger.log(Level.INFO, MessageFormat.format("响应的文件id: {0}", value.getFileId()));
                            logger.log(Level.INFO, MessageFormat.format("响应的文件大小: {0}", value.getSize()));
                        }

                        @Override
                        public void onError(Throwable t) {
                            logger.log(Level.SEVERE, MessageFormat.format("接受数据异常: {0}", t));
                            countDownLatch.countDown();
                        }

                        @Override
                        public void onCompleted() {
                            logger.log(Level.INFO, "上传完成");
                            countDownLatch.countDown();
                        }
                    });

            // 构建文件信息
            FileInfo fileInfo = FileInfo.newBuilder().setFileType("jpg").setFileId(UUID.randomUUID().toString()).build();
            // 根据流程图，先发送文件信息
            UploadFileRequest request = UploadFileRequest.newBuilder().setFileInfo(fileInfo).build();
            // 发送文件信息
            requestObserver.onNext(request);

            // 构建数组
            byte[] bytes = new byte[1024];
            while(true) {
                int count = in.read(bytes);
                // 如果数据读完，那么就跳出循环
                if (count <= 0) {
                    break;
                }

                // 如果传送结束或者发生异常，则结束整个方法
                if (countDownLatch.getCount() == 0) {
                    return;
                }

                request = UploadFileRequest.newBuilder().setFileData(ByteString.copyFrom(bytes)).build();
                requestObserver.onNext(request);
                logger.info(MessageFormat.format("send data size : {0}", count) );
            }
            // 执行该方法代表传送完成
            requestObserver.onCompleted();

            // 如果两秒之内没有传送完成，则发生异常
            if (countDownLatch.await(1, TimeUnit.MINUTES)) {
                logger.info("Within one minute, the data was not transmitted");
            }
        } catch (Exception e) {
          e.printStackTrace();
          logger.log(Level.SEVERE, "failed to transfer data");
          if (requestObserver != null) {
              requestObserver.onError(e);
          }
        } finally {
            if (client != null) {
                client.shutdown();
                logger.log(Level.INFO, "shuts down grpc client");
            }
            if (in != null) {
                in.close();
            }
        }

    }

    public void shutdown() {
        if (channel != null) {
            channel.shutdown();
        }
    }
}

1.2.3 server

服务端接收到客户端的数据，但是对服务端来说并不知道发送过来的数据流是文件信息还是具体的文件数据，因此在获取是需要通过DataCase进行区分处理

image-20210617102825617

代码如下：

上传文件服务(UploadService)

package com.tomato.wangzh.grpc.server.upload;

import com.tomato.wangzh.grpc.common.UploadFileRequest;
import com.tomato.wangzh.grpc.common.UploadFileResponse;
import com.tomato.wangzh.grpc.common.UploadFileServiceGrpc;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
import io.netty.util.internal.StringUtil;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.Objects;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;


public class GrpcUploadService extends UploadFileServiceGrpc.UploadFileServiceImplBase {
    private static final Logger logger = Logger.getLogger(GrpcUploadService.class.getName());

    @Override
    public StreamObserver uploadFile(StreamObserver responseObserver) throws FileNotFoundException {
        return new StreamObserver() {
            /**
             * 获取客户端发送过来的数据
             * @param value
             */
            long size = 0;
            // 构建文件输出流
            Integer id =  new Random().nextInt(100);
            FileOutputStream out = new FileOutputStream(id + ".jpg");


            @Override
            public void onNext(UploadFileRequest value) {
                try {
                    // 1.获取发送过来的流类型
                    UploadFileRequest.DataCase dataCase = value.getDataCase();
                    // 如果是文件信息则对文件信息处理
                    if (Objects.equals(dataCase, UploadFileRequest.DataCase.FILE_INFO)) {
                        String fileId = value.getFileInfo().getFileId();
                        String fileType = value.getFileInfo().getFileType();
                        logger.log(Level.INFO, MessageFormat.format("The id of the file sent by the client: {0}",fileId));
                        logger.log(Level.INFO, MessageFormat.format("The file type  sent by the client: {0}",fileType));
                    } else if (Objects.equals(dataCase, UploadFileRequest.DataCase.FILE_DATA)){
                        size += value.getFileData().size();
                        out.write(value.getFileData().toByteArray());
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    responseObserver.onError(Status.INTERNAL.withDescription("server write error").asRuntimeException());
                }
            }

            @Override
            public void onError(Throwable t) {
                logger.log(Level.SEVERE,MessageFormat.format("client send data error: {0}", t));
            }

            @Override
            public void onCompleted() {
                try {
                    // 传输完成，则响应客户端一个信息
                    out.flush();
                    out.close();
                    UploadFileResponse response = UploadFileResponse.newBuilder().setFileId(id.toString()).setSize(size+"").build();
                    responseObserver.onNext(response);
                    responseObserver.onCompleted();
                } catch (IOException e) {
                    e.printStackTrace();
                    responseObserver.onError(Status.DATA_LOSS.withDescription(e.getMessage()).asRuntimeException());
                }

            }
        };
    }
}

注意：因为在方法上抛出了异常，因此在父类方法中也需要抛出异常

image-20210617113519979

服务器(GrpcUploadServer)代码如下：

package com.tomato.wangzh.grpc.server.upload;

import com.tomato.wangzh.grpc.common.UploadFileServiceGrpc;
import io.grpc.Server;
import io.grpc.ServerBuilder;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;


public class GrpcServer {
    public Server server;

    private static final Logger logger = Logger.getLogger(GrpcServer.class.getName());

    public GrpcServer(Integer port, UploadFileServiceGrpc.UploadFileServiceImplBase service) {
        this(ServerBuilder.forPort(port), service);
    }

    public GrpcServer(ServerBuilder builder, UploadFileServiceGrpc.UploadFileServiceImplBase service) {
        server = builder.addService(service).build();
    }

    public void start() throws IOException {
        if (server != null) {
            server.start();
        }
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            GrpcServer.this.stop();
        }));
    }

    public void stop()  {
        try {
            if (server != null) {
                server.shutdown().awaitTermination(5, TimeUnit.SECONDS);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            logger.log(Level.SEVERE,"failed to start grpc server");
        }
    }

    public void await() {
        try {
            if (server != null) {
                server.awaitTermination();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            logger.log(Level.SEVERE,"failed to start grpc server");
        }
    }

    public static void main(String[] args) throws IOException {
        GrpcServer server = new GrpcServer(65534, new GrpcUploadService());
        server.start();
        logger.info("started grpc server successfully");
        server.await();
    }
}

启动后，结果如下：

image-20210617113953153

可以看到客户端中得到了响应，服务端响应如下：

image-20210617114045537

同时也可以看到文件保存下来：

image-20210617114120711

自此 cleint-stream模型完成

1.2.4 测试

先后启动服务端和客户端，就会看到数据，客户端不断的发送数据过去，最后服务端只响应了一个结果

image-20210704203106384

1.3 Server Streaming

这种通信模型与Client Streaming很相似，客户端发送一个请求过去，服务端不断以流的形式不断返回数据给客户端，如下：

image-20210617141354843

例如，当客户端发送一个数字给服务端，服务端不停的返回该数字的倍数给客户端，直到返回的数是大于100为止。这样就可以用这种通信模型。

这种案例就是服务端不停的返回数据给客户端，用Server Streaming这种通信模型刚刚好

1.3.1. common

在之前的grpc-common模块中继续增加protobuf文件(server_streaming.proto)，内容如下：

syntax = "proto3";

package server_streaing;

option java_multiple_files = true;
option java_package = "com.tomato.wangzh.grpc.common";

// 定义请求的消息
message Request {
    uint32 number = 1;
}

// 定义响应的消息
message Response {
    uint32 result = 1;
}

// 定义请求
service ServerStreamingService {
    rpc getResult(Request) returns (stream Response);
}

1.3.2 server

服务端主要是接收客户端发送过来的数字，并且以流的形式返回多个数据给客户端，如下图所示：

image-20210705173210552

在grpc-server中定义NumberService,用来处理给客户端返回消息，具体代码如下：

package com.tomato.wangzh.grpc.server.number;

import com.tomato.wangzh.grpc.common.Request;
import com.tomato.wangzh.grpc.common.Response;
import com.tomato.wangzh.grpc.common.ServerStreamingServiceGrpc;
import io.grpc.Context;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;

public class NumberService extends ServerStreamingServiceGrpc.ServerStreamingServiceImplBase {
    @Override
    public void getResult(Request request, StreamObserver responseObserver) {
        int number = request.getNumber();
        if (Context.current().isCancelled()) {
            responseObserver.onError(Status.CANCELLED.withDescription("request is cancelled").asRuntimeException());
            return;
        }
        for(int i = 1; i <= 100; i++) {
            if (i % number == 0) {
                Response response = Response.newBuilder().setResult(i).build();
                responseObserver.onNext(response);
            }
        }
        responseObserver.onCompleted();

    }
}

定义GRPCServer服务器，如下：

package com.tomato.wangzh.grpc.server.number;

import com.tomato.wangzh.grpc.common.ServerStreamingServiceGrpc;
import io.grpc.Server;
import io.grpc.ServerBuilder;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;


public class GRPCSever {

    public static Logger logger = Logger.getLogger(GRPCSever.class.getName());
    public static Server server;

    public GRPCSever(Integer port, ServerStreamingServiceGrpc.ServerStreamingServiceImplBase service)  {
        this(ServerBuilder.forPort(port),service);
    }

    public GRPCSever(ServerBuilder serverBuilder,ServerStreamingServiceGrpc.ServerStreamingServiceImplBase service) {
        server = serverBuilder.addService(service).build();
    }

    public void start() throws IOException {
        server.start();
        logger.info("started server");
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                GRPCSever.this.stop();
        }));
    }

    public void stop()  {
        if (server != null) {
            server.shutdown();
        }
    }

    public void await() throws InterruptedException {
        if (server != null) {
            server.awaitTermination();
        }
    }

    public static void main(String[] args) throws InterruptedException, IOException {
        GRPCSever grpcSever = new GRPCSever(65533, new NumberService());
        grpcSever.start();
        grpcSever.await();
    }
}

1.3.3 client

客户端发送一个数字给服务端，服务端接受到数字以后，返回该数字的倍数，直到数大于100，如下图所示:

image-20210705175333391

在grpc-client新建GRPCClient,代码如下：

package com.tomato.wangzh.client.number;

import com.tomato.wangzh.grpc.common.Request;
import com.tomato.wangzh.grpc.common.Response;
import com.tomato.wangzh.grpc.common.ServerStreamingServiceGrpc;
import io.grpc.Channel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;

import java.text.MessageFormat;
import java.util.logging.Level;
import java.util.logging.Logger;

public class GRPCClient {
    public static final Logger logger = Logger.getLogger(GRPCClient.class.getName());

    private Channel channel = null;

    /**
     * 只要不是简单通信模型，都是采用这种类型的stub
     */
    private ServerStreamingServiceGrpc.ServerStreamingServiceStub stub;

    public GRPCClient(String ip,Integer port) {
        // usePlaintext 代表使用普通文本传输，不采用加密方式
        channel = ManagedChannelBuilder.forAddress(ip,port).usePlaintext().build();
        stub = ServerStreamingServiceGrpc.newStub(channel);
    }

    public static void main(String[] args) {
        GRPCClient grpcClient = new GRPCClient("127.0.0.1", 65533);
        grpcClient.stub.getResult(Request.newBuilder().setNumber(5).build(), new StreamObserver() {
            @Override
            public void onNext(Response response) {
                logger.info(MessageFormat.format("服务端发送过来的数字:{0}" , response.getResult()));
            }

            @Override
            public void onError(Throwable throwable) {
                logger.log(Level.WARNING,MessageFormat.format("数据发送错误:{0}",throwable.getMessage()));
            }

            @Override
            public void onCompleted() {
                logger.info("数据传送完成");
            }
        });
    }
}

1.3.4 测试

先后启动服务端和客户端，可以看到客户端接受到了多次结果，如下：

[图片上传失败...(image-1d5d9-1625559692582)]

1.4 Bidirectional Streaming

这种通信模型相当于Client Streaming 与 Server Streaming的结合体，因此这种模型也叫双向流模型

即客户端以流的形式发送数据给服务端，而服务端也是以流的形式响应数据数据给客户端

如下图所示:

image-20210706095614162

实际开发过程中，经常会有以下场景:

客户端发送多个商品id向服务端查询商品，服务端接收客户端的id，并且去数据库查询商品

这种场景下，如果采用之前的的三种模型，在一次请求中做到基本上是不太可能，而如果采用Bidirectional Streaming则是可以做到

因此接下来采用该模型来实现上述案例

1.4.1 common

还是在之前的项目的common模块，增加bidirectional_streaming.proto文件，内容如下：

syntax = "proto3";

package bidirectional_streaming;

// 代表生成java文件在哪个包底下
option java_package = "com.tomato.wangzh.grpc.common";

// 代表生成多个文件
option java_multiple_files = true;

// 定义请求消息
message ProductRequest {
    string id = 1;
}

// 定义响应消息
message ProductResponse {
    Product product = 1;
}

// 定义响应消息内容
message Product {
    string id = 1;
    string name =  2;
    double price = 3;
}

// 定义远程调用服务
service ProductService {
    rpc getProductById(stream ProductRequest) returns(stream ProductResponse) {}
}

跟之前一样，通过输入mvn clean compile生成代码

1.4.2 server

服务端用来接受客户端发送过来的多个id，并且进行处理响应，如图：

image-20210706105530327

在之前的grpc-server中，新增ProductService.java用来处理获取商品服务，内容如下：

package com.tomato.wangzh.grpc.server.product;

import com.tomato.wangzh.grpc.common.Product;
import com.tomato.wangzh.grpc.common.ProductRequest;
import com.tomato.wangzh.grpc.common.ProductResponse;
import com.tomato.wangzh.grpc.common.ProductServiceGrpc;
import io.grpc.Context;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;

import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ProductService extends ProductServiceGrpc.ProductServiceImplBase {
    /**
     * 模拟数据库
     */
    public static final Map map = new ConcurrentHashMap(){{
        put("12343",Product.newBuilder().setId("12343").setName("衣服").setPrice(53.2).build());
        put("45678",Product.newBuilder().setId("45678").setName("裤子").setPrice(65.5).build());
        put("78797",Product.newBuilder().setId("78797").setName("鞋子").setPrice(33.3).build());
        put("91067",Product.newBuilder().setId("91067").setName("帽子").setPrice(898).build());
    }};

    public static final Logger logger = Logger.getLogger(ProductService.class.getName());


    @Override
    public StreamObserver getProductById(StreamObserver responseObserver) {
        return new StreamObserver() {
            @Override
            public void onNext(ProductRequest productRequest) {
                // 接收客户端消息
                logger.info(MessageFormat.format("接受客户端的数据:{0}",productRequest.getId()));

                // 处理客户端取消连接问题
                if (Context.ROOT.isCancelled()) {
                    responseObserver.onError(Status.CANCELLED.withDescription("客户端取消了链接").asRuntimeException());
                    responseObserver.onCompleted();
                    return;
                }

                // 根据id查询数据
                Product product = map.get(productRequest.getId());
                // 响应客户端数据，接受一个数据响应一个数据
                ProductResponse response = ProductResponse.newBuilder().setProduct(product).build();
                responseObserver.onNext(response);
            }

            @Override
            public void onError(Throwable throwable) {
                logger.log(Level.WARNING,"接受数据发生了异常");
                responseObserver.onError(Status.CANCELLED.withDescription(MessageFormat.format("接受数据发生了异常:{0}",throwable.getMessage())).asRuntimeException());
                responseObserver.onCompleted();
            }

            @Override
            public void onCompleted() {
                // 数据接受完成，即响应完成
                responseObserver.onCompleted();
            }
        };
    }
}

接下来构建BidirectionalServer.java用来接受客户端发送过来的数据，代码如下：

package com.tomato.wangzh.grpc.server.product;

import com.tomato.wangzh.grpc.common.ProductServiceGrpc;
import io.grpc.Server;
import io.grpc.ServerBuilder;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;

public class BidirectionalServer {

    private Server server;

    public static final Logger logger = Logger.getLogger(BidirectionalServer.class.getName());

    public BidirectionalServer(Integer port, ProductServiceGrpc.ProductServiceImplBase service) {
        this(ServerBuilder.forPort(port),service);
    }

    public BidirectionalServer(ServerBuilder builder, ProductServiceGrpc.ProductServiceImplBase service) {
        server = builder.addService(service).build();
    }

    /**
     * 启动方法
     */
    public void start()  {
        if (server != null) {
            try {
                server.start();
                Runtime.getRuntime().addShutdownHook(new Thread(BidirectionalServer.this::stop));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 阻塞方法
     */
    public void stop() {
        if (server != null) {
            try {
                server.shutdown().awaitTermination(3, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 阻塞方法
     */
    public void await() {
        if (server != null) {
            try {
                server.awaitTermination();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        BidirectionalServer server = new BidirectionalServer(65511,new ProductService());
        server.start();
        server.await();
    }
}

1.4.3 client

客户端主要是向服务端发送多个商品id，并且接受服务端返回来的商品数据，如下图所示：

image-20210706111917063

在grpc-client中新增ProductClient.java,用来向服务端发送数据以及接收付服务端的数据，内容如下:

package com.tomato.wangzh.client.product;

import com.tomato.wangzh.grpc.common.Product;
import com.tomato.wangzh.grpc.common.ProductRequest;
import com.tomato.wangzh.grpc.common.ProductResponse;
import com.tomato.wangzh.grpc.common.ProductServiceGrpc;
import io.grpc.Channel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;

import static java.text.MessageFormat.format;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.logging.Logger;


public class ProductClient {
    /**
     * 连接通道
     */
    private Channel channel;

    /**
     * 通信的客户端
     */
    private ProductServiceGrpc.ProductServiceStub stub;

    private static final Logger logger = Logger.getLogger(ProductClient.class.getName());

    /**
     * 存放多个商品id
     */
    private List ids = new CopyOnWriteArrayList(){{
       add("12343");
       add("91067");
    }};


    public ProductClient(String ip, Integer port) {
        channel = ManagedChannelBuilder.forAddress(ip, port).usePlaintext().build();
        stub = ProductServiceGrpc.newStub(channel);
    }

    public static void main(String[] args) throws InterruptedException {
        ProductClient client = new ProductClient("127.0.0.1", 65511);
        CountDownLatch countDownLatch = new CountDownLatch(1);

        // 得到发送服务端消息的流
        StreamObserver requestStreamObserver = client.stub.getProductById(new StreamObserver() {
            @Override
            public void onNext(ProductResponse productResponse) {
                // 接受服务端发送过来的消息
                Product product = productResponse.getProduct();
                logger.info(format("product信息:\n\tid:{0},name:{1},price:{1}", product.getId(), product.getName(), product.getPrice()));
            }

            @Override
            public void onError(Throwable throwable) {
                logger.warning(format("接受服务端消息发生错误:{0}", throwable.getMessage()));
                countDownLatch.countDown();
            }

            @Override
            public void onCompleted() {
                countDownLatch.countDown();
            }
        });
        client.ids.forEach(t -> {
            // 不停的向服务端发送数据
            ProductRequest request = ProductRequest.newBuilder().setId(t).build();
            requestStreamObserver.onNext(request);
        });
        // 循环结束代表发送完成
        requestStreamObserver.onCompleted();
        countDownLatch.await();

    }
}

1.4.4 测试

先后启动服务端和客户端，结果如下：

image-20210706113819308

自此四种通信模型就全部了解完毕，实际开发中使用什么模型需要取决于具体的通信模型

你可能感兴趣的:(框架篇-grpc(二)-grpc四大通信模型)

  • 【Python】一文详细介绍 py格式 文件 高斯小哥 Python基础【高质量合集】python新手入门学习
    【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
  • 亲子日记之祝姑姥姥生日快乐（282） 冰心雨露_d504
    2021年7月18日，周日，晴周日上班的不上班，上学的不上学，全家都属于休息状态，洗衣做饭是上午的主要任务，中午休息一会儿，下午比较晚了出去给梦怡买了二年级上册的口算题卡，然后去参加姑姑的生日聚餐，本来姑姑应该是周一生日，因为周一都要上班，就提前到周日过了，说是过生日其实就是想借此机会一家人聚聚，毕竟平常都忙，没有时间聚在一起，梦怡还给姑姥姥做了生日贺卡，虽然长相一般，重在心意。生日快乐
  • 100天30本书读书计划（2018-06-11）DAY 62 一个姜姜
    【书名】当我谈跑步时，我谈些什么【作者】村上春树【读书页数】51--128/187【读书时间】2018年6月11日【精彩句子】01肌肉难长，易消。赘肉易长，难消。P5502肌肉也同有血有肉的动物一般无二，它也愿意过更舒服的日子，不继续给它负荷，它便会心安理得地将记忆出去。想再度输入的话，必须得从头开始，将同样的模式重复一遍。P7703不管怎样，反正得坚持跑步。每天跑步对我来说好比生命线，不能说忙就
  • Android和IOS应用开发-Flutter应用让屏幕在 app 运行期间保持常亮的方法 江上清风山间明月 FlutterandroidiosflutterKeepAlive屏幕常亮wakelock熄屏
    文章目录Flutter应用让屏幕在app运行期间保持常亮的方法方法一：使用系统插件方法二：使用Widgets注意事项Flutter应用让屏幕在app运行期间保持常亮的方法在Flutter开发中，可以使用以下两种方法让屏幕在app运行期间保持常亮：方法一：使用系统插件Flutter社区中已经有很多相关插件可供使用，比如wakelock:https://pub.dev/packages/wakeloc
  • 【OpenModelica】4命令行大全 Wumbuk python开发语言modelica
    命令行大全文章目录命令行大全一、SummaryofCommandsfortheInteractiveSessionHandler二、Runningthecompilerfromcommandline一、SummaryofCommandsfortheInteractiveSessionHandler以下是交互式会话处理器中当前可用命令的完整列表。•simulate(modelname)：翻译一个名为
  • 5月8日盘前提示：维持短期可以操作到下周二左右的判断，重个股轻指数 九命_猫妖
    大盘：消息面。取消境外投资者额度限制，这个长线利好股市，短期影响不大，因为3000亿额度只用了1/3。额度本来就够用。走势看，昨天缩量横盘，走的还算中规中矩，近期一直弱势的次新股走势较强，前期强势股京威股份、光大嘉宝等跌停，由此判断市场还是存量博弈的市场，震荡是市场的主基调。维持短期可以操作到下周二左右的判断。下周后半段震荡回调的概率较高。思路：短期重个股轻指数行业和个股：物联网行业有利好，关注下
  • word字号和mathtype磅值关系及批量修改 小铁匠-Ma office小技巧经验分享
    word字号和mathtype磅值关系及批量修改1.字号与磅值关系字号「八号」对应磅值5字号「七号」对应磅值5.5字号「小六」对应磅值6.5字号「六号」对应磅值7.5字号「小五」对应磅值9字号「五号」对应磅值10.5字号「小四」对应磅值12字号「四号」对应磅值14字号「小三」对应磅值15字号「三号」对应磅值16字号「小二」对应磅值18字号「二号」对应磅值22字号「小一」对应磅值24字号「一号」对应
  • 自律计划：从早睡早起开始 犀首公孫衍
    今天天气十分不错，阳光明媚。下午趁着阳光充足，想去田野里走一走。两个多月了，几乎都是在家待着，大门不出二门不迈。上大学以来，可几乎不怎么去到田间地头看一看。3月正是油菜花开放的季节，满地的金黄色，草木也开始生出了绿色的芽儿。眼前的景儿，让人眼明心亮。一年之计在于春，春天是最美好的季节。这样一个特殊的春天，让我暂时脱离了学校，也算有了一些新的收获吧。开始有了一些好的改变，开始坚持每天读书，保持较好的
  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
  • php 把一个数组分成有n个元素的二维数组的算法 风清扬-独孤九剑 phpphp算法
    一、第一种解法0){$columns_map[$position]++;//这个地方格外注意,$position与$columns比较$position=($position<$columns-1)?++$position:0;$array_length--;}foreach($columns_mapas$val){$newarray[]=array_splice($array,0,$val);}
  • 花气袭人知昼暖 柒侠传
    花气袭人知昼暖高一七班黄韵熹37号花袭人，原名花珍珠，位列金陵十二钗又副册中的第二位。“袭人”这一称呼源于“花气袭人知昼暖”这一诗句，是宝玉给起的。想起来便觉得暖融融的，一如花袭人温柔的笑容。但花袭人着实是令人又爱又怕的角色。第二十一回的回目将她赞作“贤袭人”，脂砚斋在一旁批道“当得起”。花袭人对宝玉的确是一片真心。她为劝宝玉收敛他那成日在大观园里与姐姐妹妹“厮混”的性子，假借家人赎回的机会，软语
  • python 推导式(派生、衍生) sanduo112 人工智能pythonwindows开发语言
    python推导式一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。2.列表(list)推导式3.字典(dict)推导式4.集合(set)推导式5.元组(tuple)推导式二、代码概述一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。Python支持各种数
  • 为什么说仪式和习惯非常重要？ 章鱼老师zy
    这是章鱼姐第【40】篇原创文章，日更计划第【37/100】天。阅读张萌萌姐【精力管理手册】第【6/7】章。一阅读摘要这一章萌姐讲到了习惯的重要性，为什么说养成一个习惯很重要？如何养成一个好习惯？如何建立自己的仪式感？二金句精力管理最重要的是产生什么效果。当你想做却没有动力去做一件事情时，你就应该把它养成习惯。习惯可以帮我们创造稳定框架。对于那些特别考验意志的事情，我们应该先行后思。三思考题，萌姐讲
  • 2022-10-02 朗月斋主
    肿瘤溶解病毒（OVs）作为一种新型的免疫治疗和治疗辅助剂，在制药行业中越来越受到关注，因为它们能够通过多种机制诱导和提高抗肿瘤免疫力。首先，OVs能够利用宿主免疫系统的内在机制（例如，逃避免疫检测）可以使肿瘤的免疫逃逸机制失效。第二，许多类型的OVs已被证明可以直接裂解肿瘤细胞，从而诱导出由肿瘤相关抗原和危险信号分子释放介导的肿瘤特异性T细胞反应。第三，表达免疫刺激治疗基因的武装OV可以在肿瘤组织
  • 1.计算机处理器架构+嵌入式处理器架构及知识 vv 啊 arm-linux学习linux系统架构
    目录一：x86-64处理器架构二：Intel80386处理器（i386）1.i3862.i686三：嵌入式Linux知识：1.MinGW2.GNU计划2.1GNU工具链概述此次只分享英特尔和ADM处理器有关于x86的架构，至于嵌入式处理器架构请查看https://en.wikipedia.org/wiki/List_of_ARM_processors一：x86-64处理器架构x86-64，也称为x
  • 夫子庙前的金子招牌 光中的cici
    古城都不乏老招牌，比如苏杭，比如南京。随便一个都有久远的年代。夫子庙前，乌衣巷口，店肆成市招牌林立繁华重归来。难为我一个外地人，究竟该喝谁家的那碗鸭血粉丝汤呢？在网上研究了半天，选了秦淮人家。只因为三点：一，临河就着秦淮河喝鸭血汤就着秦淮河喝鸭血汤二，装修较其他一溜大白墙的店算讲究的了，我特别吃环境，没办法～三，有鸭血汤鸭血汤倒是有，夹杂在一套所谓的套餐里，不允许单独点菜。我是为了这秦淮河买的单，
  • 2021.12.13 自律日记 夏舒帅然a
    深感时光转瞬即逝，如指缝流金！自律、习惯养成、执行力提高迫在眉睫！今天是什么日子：平日艳阳天起床：7：50任务清单（明日）1.起床：7:302.就寝：10：103.读书30分钟4.打两套太极5.两次静坐（每次15分钟）昨日完成的任务情况，最重要的三件事一.读书30分。未完成二.就寝10：00完成三.起床7：30未完成四.打两套太极未完成五.两次静坐（每次15分钟）未完成习惯养成：早睡早起、每日读书
  • ＜商务世界＞《第25课 餐桌上的礼仪-简单的流程》 Ealser 商务世界中国餐桌礼节
    第一：迎客席座一般的程序是主人给客人邀请函——日子到了，主人到门外迎客——客人到了，问候几句——带着可人到0客厅小坐一会儿，给客人茶点——带客人入席坐好！第二：入座与座次首先要请客人中长者或地位高的先入座，再按身份地位依次入座，入座时要从椅子左边进入。（正对门口的为上座，一般是根据对方的.身份地位来安排）。入座后不要动筷子，更不要弄出什么响声来，也不要起身走动。如果有什么事要向主人打招呼！（做小辈
  • yarn的安装和使用全网最详细教程 zxj19880502 yarnnpm
    一、yarn的简介：Yarn是facebook发布的一款取代npm的包管理工具。二、yarn的特点：速度超快。Yarn缓存了每个下载过的包，所以再次使用时无需重复下载。同时利用并行下载以最大化资源利用率，因此安装速度更快。超级安全。在执行代码之前，Yarn会通过算法校验每个安装包的完整性。超级可靠。使用详细、简洁的锁文件格式和明确的安装算法，Yarn能够保证在不同系统上无差异的工作。三、yarn的
  • 知道这些概念，你会变得越来越聪明 金海波
    证实性偏差我们倾向于选择那些证实了我们的预期和假设的信息，同时倾向于忽视相反的信息。证实性偏见是选择性关注的实例。比如：从前有个人，丢了一把斧子。他怀疑是邻居家的儿子偷去了，便观察那人，那人走路的样子，像是偷斧子的;看那人的脸色表情，也像是偷斧子的;听他的言谈话语，更像是偷斧子的，那人的一言一行，一举一动，无一不像偷斧子的。不久后，丢斧子的人在上山的时候发现了他的斧子，第二天又见到邻居家的儿子，就
  • 中国最美的100个地方，待“软禁”结束后，满血复活去一次旅行！ 是北河二1995
    【阅读原文，请点击：原文，硬核100个】离成为一个倾国倾城、走路带风的女子还有365天！大家好，我是小草们的北河二~一转眼，2020年已过1/4，突如其来的病毒，搅得人心惶惶。原本的3月里，景区爆满、街道拥堵、小吃铺做无缺席。然而，地球妈妈不会一直宠着我们，给了我们好几个警告。如今，连CCTV-1播出的《人与自然》，我都可以看上好一会儿......高山、流水、湖泊、森林、大海.....它们也在这初
  • #D174-读书会作业-《财务自由之路》3 白洲笔记
    最近沉迷于写作营，一直就没时间去弄读书会的作业，书的第二遍也就看了个开头，趁着日更的时间，赶紧把作业做了，这次是15到21课。【1.印象最深刻的部分】(本周所读内容中印象最深刻的部分)*活在未来，最正确的方法是什么？用正确的方法做正确的事情，判断什么是正确的？逻辑。学会思考。"作对事情"永远比“把事情作对“重要的多。”长远思考，耐心验证，小心总结提炼“证明自己正确并不是学习的任务和目标，时刻成长，
  • 账务处理又出错？资深会计来教你，学会效率翻倍！共同学习 小橘子要努力吖
    作为一名会计，在实际工作中会遇到各种麻烦的账务处理问题。那么，最常用的会计处理方法都有哪些呢？今天小编为大家带来了从业二十六年的资深老会计分享的十四中会计常用的账务处理问题的解决方案，快来看看吧！一、促销品的账务处理在促销时公司经常会把一些商品按进价赠送给消费者使用二、款已付清但发票未到的账务处理三、购买材料发生不合理损耗的账务处理问题公司在购买材料时，常常会发生一些不合理的损耗，那么这种问题该怎
  • Jenkins安装 lettger
    1.第一步sudowget-O/etc/yum.repos.d/jenkins.repohttps://pkg.jenkins.io/redhat/jenkins.reposudorpm--importhttps://pkg.jenkins.io/redhat/jenkins.io.key2.第二步sudoyuminstalljenkins3.第三步servicejenkinsstatus|sta
  • 搜索，动态规划，二叉树的时间复杂度计算通用公式 鸭蛋蛋_8441
    搜索的时间复杂度：O(答案总数*构造每个答案的时间)举例：Subsets问题，求所有的子集。子集个数一共2^n，每个集合的平均长度是O(n)的，所以时间复杂度为O(n*2^n)，同理Permutations问题的时间复杂度为：O(n*n!)动态规划的时间复杂度：O(状态总数*计算每个状态的时间复杂度)举例：triangle，数字三角形的最短路径，状态总数约O(n^2)个，计算每个状态的时间复杂度为
  • 地缚少年花子君，一个小小的甜甜圈，源光看见了源辉内心的小秘密 ACGN安乐
    大家好我是小安，很高兴又和大家见面了，话不多说我们直接进入正题，不知大家对日本动画《地缚少年花子君》中海鸥学院高等部二年级生，学生会的会长源辉了解多少呢？源辉从第一集中就已经登场，他是源光的哥哥，也是八寻宁宁的理想对象之一，源辉除了有学生这层身份之外和他的弟弟源光一样都是拔除师，也就是我们统称的除妖师，从表面来看源辉是个高颜值帅哥，脾气很好同时也有很多女孩子想做他的女朋友，但金无足赤人无完人大家也
  • 2.5 项目讲解流程 王守谦26 项目资料数据库
    一、项目讲解1、自我介绍2、项目流程-===============================二、自我介绍（一）、学员自我介绍，讲解存在的问题比如：讲解年份、卡顿、重点学历、忘记（二）自我规则内容1、开场白：礼貌用语2、时间：自我介绍1-2分钟以内3、内容：姓名、籍贯、毕业院校、（拉进面试官距离）4、技能：功能测试、接口测试、自动化测试、app测试、性能测试、安全测试黑盒测试、白盒测试、灰盒
  • MyBatis高级面试题-2024 my_styles mybatisjava开发语言面试题
    MyBatis的核心组件有哪些？首先第一个是，SqlSessionFactory，它就像是一个会话工厂。它的任务是创建SqlSession对象，这个对象是我们与数据库交互的主要途径。SqlSessionFactory的作用很重要，因为它可以帮我们配置数据库连接信息和事务管理等。一旦这个工厂被建立起来，它就会加载一些必要的配置和映射文件，为后续的数据库操作提供一个可靠的基础。第二个是SqlSessi
  • 如何把大象装进冰箱的思考 210624 大丁_初心生活
    央视春晚曾有个小品，宋丹丹问赵本山，如何把大象装进冰箱。赵本山说不知道。宋丹丹得意地说，第一步，把冰箱门打开。第二步，把大象装进去。第三步，把冰箱门关上。我相信很多人看了都是一笑了之，我们也从潜意识上给出了否定的答案。樊登老师给出了不一样的解读，他认为这其实是解决问题的经典方法。“把大象装冰箱”，目标十分明确，宋丹丹给出的执行步骤也十分清晰。可赵本山却不会？难道赵本山不知道这三个步骤吗？肯定知道。
  • 2018-12-02 子分小
    姓名：张颖公司：菲尔德国际英语【反省总结第146天，始于20180709今天是20181202】【知～学习】六项精进大纲背诵3遍每天十个单词坚持第181天每天学习一篇英文文章第94天英语流利说课程第71天学习30分钟【行～实践】一、修身：（对自己个人）步行5000步二、齐家：（对家庭和家人）无三、建功：（对工作)完成与Arti活动课和两节Demo准备开班事宜｛积善｝：发愿从2018年7月9日起1年
  • 辗转相处求最大公约数 沐刃青蛟 C++漏洞
    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！   为此，总结一下以方便日后忘了好查找。   1.输入要比较的两个数a,b   忽略：2.比较大小（因为后面要的是大的数对小的数做%操作）   3.辗转相除（用循环不停的取余，如a%b,直至b=0）   4.最后的a为两数的最大公约数 &
  • F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5负载均衡
    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
  • Object.equals方法：重载还是覆盖 Cwind javagenericsoverrideoverload
    本文译自StackOverflow上对此问题的讨论。 原问题链接   在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
  • 初始线程 15700786134
          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。            既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
  • Linux的tcpdump 被触发 tcpdump
    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 实用命令实例 默认启动 tcpdump 普通情况下，直
  • 安卓程序listview优化后还是卡顿 肆无忌惮_ ListView
    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
  • 扩展easyUI tab控件，添加加载遮罩效果 知了ing jquery
    (function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
  • gradle上传jar到nexus 矮蛋蛋 gradle
    原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations {     deployerJars } dependencies {     deployerJars "org.apache.maven.wagon
  • 千万条数据外网导入数据库的解决方案。 alleni123 sqlmysql
    从某网上爬了数千万的数据，存在文本中。 然后要导入mysql数据库。 悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。 于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
  • JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作 字符流
    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流   字节流和字符的难点：a,怎么将读到的数据
  • MO、MT解读 bijian1013 GSM
    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
  • 五个JavaScript基础问题 bijian1013 JavaScriptcallapplythisHoisting
    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 问题1：Scope作用范围 考虑下面的代码：  (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？  回答：         上面的代码会打印 5。 &nbs
  • 【Thrift二】Thrift Hello World bit1129 Hello world
    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程   1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
  • 【Avro一】Avro入门 bit1129 入门
    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。   1. 添加Maven依赖   <?xml version="1.0" encoding="UTF-8"?> <proj
  • 安装nginx+ngx_lua支持WAF防护功能 ronin47
    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
  • java-5.查找最小的K个元素-使用最大堆 bylijinnan java
    import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
  • TCP的TIME-WAIT bylijinnan socket
    原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记 说明： 主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
  • jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
       checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值   <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
  • Apache集群乱码和最高并发控制 cuisuqiang apachetomcat并发集群乱码
    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
  • websocket dalan_123 websocket
    一、低延迟的客户端-服务器 和 服务器-客户端的连接 很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。   通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
  • 菜鸟分析网络执法官 dcj3sjt126com 网络
      最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
  • Android相对布局属性全集 dcj3sjt126com android
    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
  • Tomcat内存设置详解 eksliang jvmtomcattomcat内存设置
    Java内存溢出详解   一、常见的Java内存溢出有以下三种：   1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 可以利用JVM提
  • Java6 JVM参数选项 greatwqs javaHotSpotjvmjvm参数JVM Options
    Java 6 JVM参数选项大全（中文版）   作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！   本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
  • weblogic创建JMC i5land weblogicjms
    进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 系统包括几个独立的部分： 使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子； 使用 PHP CI 框架开发的简易网站； 搜索引擎目前直接使用的 MySQL，将来可以考虑使
  • sql添加、删除表中的列 macroli sql
    添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
  • PHP中二维数组的排序方法 abc123456789cba 排序二维数组PHP
    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
  • hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hivehive优化
    一、    控制hive任务中的map数: 1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。 主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
  • Spring Boot 1.2.4 发布 wiselyman spring boot
    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。   这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。   Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他