wavebeed

java网络编程实战 - 运用TCP通讯思想，手写设计实现可定制、复用和扩展的RPC服务调用框架

前言

RPC(Remote Procedure Call)远程过程调用是一种思想，也是目前微服务调用领域的主流开发模式。就底层的网络协议来说，TCP、UDP、HTTP等协议均可以设计实现我们需要的RPC。其中基于TCP协议实现的RPC框架在可靠性、性能和可伸缩性等方面都更胜一筹，其中Dubbo、GRPC为代表(虽然其基于Netty通信框架，但其底层均为TCP协议)。

RPC框架交互流程

根据以上流程我们可以形成以下开发思路：

服务定义端负责约定通用的业务接口和公共的数据结构；
服务业务实现端负责实现业务接口，并在启动时，注册到RPC注册中心；
客户端可使用代理调用业务服务；
客户端代码把调用对象、方法和参数等序列化成二进制码传输；
客户端代理与服务端通过Socket通讯传递数据报文；
服务端反序列化数据报成对象，解析方法和参数等；
服务端代理拿到对象和参数后，通过反射得到服务实例，然后调用对应接口方法；

根据以上的大体思路，我们能不能也基于TCP定制设计我们的RPC框架呢 ? 答案是肯定的。

那要手写实现一个RPC框架需要考虑哪些问题 ?

如何使我们的服务通用的问题 ;
数据对象序列化与反序列化问题；
通讯协议和机制问题 ;
服务的实例化问题 ;
服务缓存方案 ;
服务负载方案 ;
... ...

这些都是我们在一个RCP框架中需要妥善解决的问题。OK, 那我们就来一步一步实现我们的想法。

手写设计实现

第一部分服务接口定义

package com.wavebeed.serviceapi;

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：系列业务接口定义
* */

//这部分比较简单，为了不占用文章篇幅，具体代码先省略...

第二部分服务生产端部分


/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：RPC服务端框架部分
 * */
public class ProducerFramework {
    //服务监听端口
    private final int port;
    //服务在服务端缓存
    private final static Map> cachedService = new ConcurrentHashMap<>();
    //服务处理任务池
    private final static ExecutorService taskPool = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors()+1);
    public ProducerFramework(int port) {this.port = port;}

    /**
     * 注册服务核心业务
     * @param service 服务接口类
     * @param serviceImpl 服务实现类
     */
    public void register(Class service, Class serviceImpl) {
        InputStream inputStream = null;
        OutputStream outputStream = null;
        Socket socket = new Socket();
        try {
            //连接注册中心
            socket.connect(new InetSocketAddress(Constant.REG_CENTER_HOST, Constant.REG_CENTER_PORT));
            //服务名称
            String serviceName = service.getName();
            outputStream = new ObjectOutputStream(socket.getOutputStream());
            ((ObjectOutputStream) outputStream).writeUTF(serviceName);
            //标记服务注册
            ((ObjectOutputStream) outputStream).writeBoolean(false);
            //服务所在主机
            ((ObjectOutputStream) outputStream).writeUTF(Constant.SERVER_HOST);
            //服务监听端口
            ((ObjectOutputStream) outputStream).writeInt(this.port);
            //刷服务到注册中心
            outputStream.flush();
            //获取注册结果
            inputStream = new ObjectInputStream(socket.getInputStream());
            if (((ObjectInputStream) inputStream).readBoolean()) {
                //缓存在服务端
                cachedService.put(serviceName, serviceImpl);
                System.out.println("服务[" + serviceName + "],注册成功!");
            } else {
                System.out.println("服务[" + serviceName + "],注册失败，请查看日志!");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != inputStream) {
                    inputStream.close();
                    inputStream = null;
                }
                if (!socket.isClosed()) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            socket = null;
        }
    }

    /**
     * 服务运行
     */
    public void run() throws IOException {
        ServerSocket serverSocket = new ServerSocket();
        try {
            serverSocket.bind(new InetSocketAddress(this.port));
            System.out.println("服务器端口：["+this.port+"]开始运行..");
            for (;;){
                Socket socket = serverSocket.accept();
                taskPool.execute(new ServiceRunTask(socket));
            }
        } catch (IOException e) {
            //停止服务
            this.stop();
            e.printStackTrace();
        }finally {
            if(!serverSocket.isClosed()){
                serverSocket.close();
            }
            serverSocket = null;
        }
    }

    /**
     * 停止服务
     */
    public void stop(){
        try {
            cachedService.clear();
            taskPool.shutdown();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     *服务运行池化任务
     * @param consumer 消费端连接
     */
    private static class ServiceRunTask implements Runnable{
        //消费端连接
        private Socket consumer = null;
        public ServiceRunTask(Socket consumer) {this.consumer = consumer;}

        /**
         * 服务运行核心业务
         */
        @Override
        public void run() {
            try(InputStream inputStream = new ObjectInputStream(this.consumer.getInputStream());
                OutputStream outputStream = new ObjectOutputStream(this.consumer.getOutputStream())){
                //服务名
                String name = ((ObjectInputStream) inputStream).readUTF();
                //方法名称
                String methodName = ((ObjectInputStream) inputStream).readUTF();
                //方法参数类型
                Class[] parmTypes = (Class[])((ObjectInputStream) inputStream).readObject();
                //方法参数
                Object[] args = (Object[]) ((ObjectInputStream) inputStream).readObject();
                //本地服务缓存
                Class serviceClass = cachedService.get(name);
                if(null == serviceClass){
                    throw new ClassNotFoundException("服务:["+name+"] 不存在或过期");
                }

                //服务方法
                Method method = serviceClass.getMethod(methodName, parmTypes);
                //调用结果
                Object result = method.invoke(serviceClass.newInstance(), args);
                //回刷处理结果到对端
                ((ObjectOutputStream) outputStream).writeObject(result);
                outputStream.flush();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(null != this.consumer){
                    if(!this.consumer.isClosed()){
                        try {
                            this.consumer.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    this.consumer = null;
                }
            }
        }
    }
}

package com.wavebeed.producer.service;

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：系列服务实现部分
* */
//这部分比较简单，为了不占用文章篇幅，具体代码先省略...

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：RPC服务启动器
 * */
public class ProducerStarter {
    //============业务服务端口配置(推荐放到配置介质中)======================
    //微信服务监听端口
    private static final int WX_SERV_PORT = 9000;
    //报表服务监听端口1
    private static final int RPT_SERV_PORT1  = 9001;
    //报表服务监听端口2
    private static final int RPT_SERV_PORT2  = 9002;
    /**
     * 注册和运行相关服务
     * @param args
     */
    public static void main(String[] args) {
        //(1)微信服务注册和运行
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    ProducerFramework framework = new ProducerFramework(WX_SERV_PORT);
                    framework.register(SendWeiXinService.class, SendWeiXinServiceImpl.class);
                    framework.run();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //(2)报表服务注册和运行1
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //报表服务1
                    ProducerFramework framework = new ProducerFramework(RPT_SERV_PORT1);
                    framework.register(ReportingService.class, ReportingServiceImpl.class);
                    framework.run();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //(3)报表服务注册和运行2
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //报表服务2
                    ProducerFramework framework2 = new ProducerFramework(RPT_SERV_PORT2);
                    framework2.register(ReportingService.class, ReportingServiceImpl.class);
                    framework2.run();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

第三部分服务注册中心

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：注册中心核心实现
 * 服务提供者启动时将服务端的服务注册到注册中心以及服务的管理等
 * */
public class RegisterCenterFramework {
    //注册中心监听端口
    private final int port;
    //注册中心服务池，负责维护注册的服务(这里只做简要的实现，提供思路)
    private final static Map> servicePool = new ConcurrentHashMap<>();
    //定义服务任务池，负责执行服务
    private final static ExecutorService taskPool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()+1);
    public RegisterCenterFramework(int port) {this.port=port;}

    /**
     * 启动服务
     */
    public void start(){
        try {
            ServerSocket serverSocket = new ServerSocket();
            serverSocket.bind(new InetSocketAddress(this.port));
            System.out.println("注册中心服务开始运行...");
            for (;;){
                 Socket socket = serverSocket.accept();
                 taskPool.execute(new RegisteTask(socket));
            }
        } catch (IOException e) {
            //停止服务
            this.stop();
            e.printStackTrace();
        }
    }

    /**
     * 停止服务
     */
    public void stop(){
        try {
            servicePool.clear();
            taskPool.shutdown();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 注册服务
     * */
    private static void registeService(String name, ServiceAddress address){
        Lock lock = new ReentrantLock();
        try{
            lock.lock();
            Set service = servicePool.get(name);
            if(null == service){
                service = new HashSet<>();
                servicePool.put(name, service);
            }
            service.add(address);
            System.out.println("服务:["+name+"]注册完成");
        }finally {
            lock.unlock();
        }
    }
    /**
     * 获取服务
     * */
    private static Set getService(String name){
       return servicePool.get(name);
    }

    /**
     * 处理服务注册请求
     */
    private static class RegisteTask implements Runnable {
        private Socket register = null;

        public RegisteTask(Socket register) {
            this.register = register;
        }

        /**
         * 实现服务注册核心业务
         */
        @Override
        public void run() {
            try (InputStream inputStream = new ObjectInputStream(this.register.getInputStream());
                 OutputStream outputStream = new ObjectOutputStream(this.register.getOutputStream())) {
                 //服务名称
                 String name = ((ObjectInputStream) inputStream).readUTF();
                //检查当前请求是否获取
                 boolean isGet = ((ObjectInputStream) inputStream).readBoolean();
                 if(isGet){
                     //获取存在服务信息
                     Set service = getService(name);
                     //回写消费端
                     ((ObjectOutputStream) outputStream).writeObject(service);
                     outputStream.flush();
                     System.out.println("服务["+name+"]信息已返回消费端!");
                 }
                 //服务注册
                 else{
                     //服务端主机
                     String serviceHost = ((ObjectInputStream) inputStream).readUTF();
                     //服务端
                     int servicePort = ((ObjectInputStream) inputStream).readInt();
                     //注册
                     registeService(name, new ServiceAddress(serviceHost,servicePort));
                     ((ObjectOutputStream) outputStream).writeBoolean(true);//已注册
                     outputStream.flush();//刷消息到对端
                 }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if(null != this.register){
                    if(!this.register.isClosed()){
                        try {
                            this.register.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    this.register = null;
                }
            }
        }
    }
}

package com.wavebeed.regcenter;

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：注册中心启动服务类
 */
public class RegisterCenterStarter {
    //注册中心监听端口, 这里推荐从配置获取
    public static final int REG_CENTER_PORT = 8888;

    public static void main(String[] args) {
        new Thread(new Runnable(){
            public void run() {
                new RegisterCenterFramework(REG_CENTER_PORT).start();
            }
        }).start();
    }
}

第四部分服务消费端部分

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：服务消费端框架部分
 * */
public class ConsumerFramework {
    /**
     * 获取远程服务对象
     * @param serviceInterface 服务接口类
     * @param  服务类型
     * @return 服务对象
     */
     public static  T getServiceObject(Class serviceInterface){
         InetSocketAddress address = new InetSocketAddress(Constant.REG_CENTER_HOST, Constant.REG_CENTER_PORT);
         T instance = (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(),
                                            new Class[]{serviceInterface},
                                            new ServiceInvocationHandler(serviceInterface, address));
         return instance;
     }
     
    /**
     * 远程服务代理核心业务
     */
    private static class ServiceInvocationHandler implements InvocationHandler {
          //请求的服务接口类
          private Class serviceInterface = null;
          //注册中心地址
          private InetSocketAddress centerAddress = null;

          //服务地址(同一个服务可在不同端口部署多份)
          private ServiceAddress[] serviceAddresses = null;

         public ServiceInvocationHandler(Class serviceInterface, InetSocketAddress centerAddress) {
             this.serviceInterface = serviceInterface;
             this.centerAddress = centerAddress;
         }

        /**
         * 代理核心业务实现
         * @param proxy 代理对象
         * @param method 调用方法
         * @param args 方法参数
         * @return 方法返回
         * @throws Throwable
         */
         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
             Socket socket = null;
             try {
                 //从注册中心获取服务
                 if (null == this.serviceAddresses) {
                     socket = new Socket();
                     socket.connect(this.centerAddress);
                     if (socket.isConnected()) {
                         try (OutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
                              InputStream inputStream = new ObjectInputStream(socket.getInputStream())) {
                             //服务名
                             ((ObjectOutputStream) outputStream).writeUTF(this.serviceInterface.getName());
                             //注册标记
                             ((ObjectOutputStream) outputStream).writeBoolean(true);
                             //刷到注册中心
                             outputStream.flush();

                             //获取注册结果
                             Set result = (Set) ((ObjectInputStream) inputStream).readObject();
                             //缓存结果
                             this.serviceAddresses = new ServiceAddress[result.size()];
                             result.toArray(this.serviceAddresses);
                         } finally {
                             if (!socket.isClosed()) {
                                 socket.close();
                             }
                             socket = null;
                         }
                     }
                 }
                 /**
                  * 访问对应服务
                  * 若同一服务在多个服务器或端口部署，推荐采用负载算法，这里为了演示暂随机获取一台访问
                  */
                 int servIndex = new Random().nextInt(this.serviceAddresses.length);
                 String servHost = this.serviceAddresses[servIndex].getHost();
                 int servPort = this.serviceAddresses[servIndex].getPort();
                 InetSocketAddress servAddress = new InetSocketAddress(servHost, servPort);
                 socket = new Socket();
                 socket.connect(servAddress);
                 if (socket.isConnected()) {
                     try (OutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
                          InputStream inputStream = new ObjectInputStream(socket.getInputStream())) {
                         if (socket.isConnected()) {
                             //服务名
                             ((ObjectOutputStream) outputStream).writeUTF(this.serviceInterface.getName());
                             //方法名
                             ((ObjectOutputStream) outputStream).writeUTF(method.getName());
                             //方法参数类型
                             ((ObjectOutputStream) outputStream).writeObject(method.getParameterTypes());
                             //方法参数
                             ((ObjectOutputStream) outputStream).writeObject(args);
                             outputStream.flush();

                             //获取返回结果
                             return ((ObjectInputStream) inputStream).readObject();
                         }
                     } finally {
                         if (!socket.isClosed()) {
                             socket.close();
                         }
                         socket = null;
                     }
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
             return null;
         }
     }
}

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：服务消费者调用入口
 * */
public class ConsumerCaller {
    /**
     * 服务调用入口
     * @param args
     */
    public static void main(String[] args) {
        try {
            //(1)访问发送微信服务
            SendWeiXinService wxService = ConsumerFramework.getServiceObject(SendWeiXinService.class);
            boolean result = wxService.send(new UserInfo(1,"andychen", 99));
            System.out.println("Rpc远程调用发送微信服务返回:"+result+" ...");

            //(2)访问报表服务
            ReportingService rptService = ConsumerFramework.getServiceObject(ReportingService.class);
            ReportingVO vo = new ReportingVO();
            vo.setIp("192.168.3.12");
            vo.setUv(10000);
            vo.setPv(30000);
            vo.setTitle("系统第二季度访问统计");

            //访问接口1
            rptService.setReportInfo(vo);
            System.out.println("Rpc远程调用设置报表信息服务已返回 ...");

            //访问接口2
            rptService.setReportStat(50000, 60000);
            System.out.println("Rpc远程调用报表服务统计报表信息已返回 ...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    };
}

频繁验证后效果

结论和思考

以上基于TCP协议的RPC框架设计实现，在经过细节完善和充分测试后，可作为轻量级远程调用框架，在微服务调用场景中使用。虽基于TCP协议实现，但毕竟采用的是阻塞式IO模型，相比NIO和IO 多路复用模型等，在性能和高并发场景，存在固有的缺陷；可采用后者对其进行改造。接一下来，我们也会在NIO和IO多路复用模型(包括Netty框架)上设计更多的实现，给大家在java网络编程方面提供不同的思路和体验。

微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
腾讯云技术深度探索：构建高效云原生微服务架构我的运维人生云原生架构腾讯云运维开发技术共享
腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
06选课支付模块之基于消息队列发送支付通知消息 echo 云清学成在线 java rabbitmq 消息队列支付通知学成在线
消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istio istio 云原生服务发现
Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
网关gateway学习总结猪猪365 学习总结学习总结
一微服务概述:微服务网关就是一个系统!通过暴露该微服务的网关系统,方便我们进行相关的鉴权,安全控制,日志的统一处理,易于监控的相关功能!实现微服务网关技术都有哪些呢?1nginx:nginx是一个高性能的http和反向代理web的服务器,同事也提供了IMAP/POP3/SMTP服务.他可以支撑5万并发链接,并且cpu,内存等资源消耗非常的低,运行非常的稳定!2Zuul:Zuul是Netflix公司
探索Zebra4J：构建高效企业级Web应用的微服务框架叶准鑫Natalie
探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
从单体到微服务：FastAPI ‘挂载’子应用程序的转变黑金IT fastapi 微服务 fastapi 架构
在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
Sentinel 眼泪落在琴弦 springcloud java java
Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
SpringBoot整合ES搜索引擎实现网站热搜词及热度计算码踏云端 springboot Elasticsearch spring boot elasticsearch 后端热搜词热度计算 java
博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
软件测试/测试开发/全日制 |利用Django REST framework构建微服务霍格沃兹-慕漓 django 微服务 sqlite
霍格沃兹测试开发学社推出了《Python全栈开发与自动化测试班》。本课程面向开发人员、测试人员与运维人员，课程内容涵盖Python编程语言、人工智能应用、数据分析、自动化办公、平台开发、UI自动化测试、接口测试、性能测试等方向。为大家提供更全面、更深入、更系统化的学习体验，课程还增加了名企私教服务内容，不仅有名企经理为你1v1辅导，还有行业专家进行技术指导，针对性地解决学习、工作中遇到的难题。让找
Dubbo架构概览：服务注册与发现、远程调用、监控与管理木南曌 dubbo 架构
Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
以太坊DApp开发指南 Kirn
DApp架构设计DApp架构.png如上图，DApp的架构我们可以简单分为以上三种类型：轻钱包模式、重钱包模式和兼容模式。轻钱包模式轻钱包模式下我们需要有一个开放HttpRPC协议的节点与钱包通信，这个节点可以是任意链上的节点。轻钱包通常会作为一个浏览器插件存在，插件在运行时会自动注入Web3框架，DApp可以通过Web3与区块链节点通信。当DApp只是单纯的获取数据时是不需要钱包介入的，但是当D
nfs服务搭建 GHope
nfs是什么？基哥度娘网络文件系统(NFS)是sun微系统最初开发的分布式文件系统协议,[1]允许客户端计算机上的用户通过计算机网络访问文件很像本地存储被访问。NFS与许多其他协议一样,在开放网络计算远程过程调用(很久以前RPC)系统上建立。NFS是在请求注释(RFC)中定义的开放标准,允许任何人实现协议。NFSNFS优势：节省本地存储空间，将常用的数据存放在一台NFS服务器上且可以通过网络访问，
面试常见题之Spring Cloud 拾光编程 java面试面试 spring cloud 职场和发展
在Java软件工程师的面试中，关于SpringCloud的题目旨在考察候选人对微服务架构的理解、SpringCloud各组件的掌握程度、以及如何在实际项目中应用这些技术来构建可扩展、可靠和高效的服务。本文将概括性地列出20个关于SpringCloud的面试题目，并为每个题目提供一个简要的回答框架或关键点，以便你根据需要进行扩展。1.SpringCloud是什么？它解决了什么问题？回答框架：Spri
springcloud — 微服务鉴权管理Spring Security原理解析(二) RachelHwang springcloud spring java spring security oauth2 springcloud
引言：回顾之前介绍的OAuth2简单分析与介绍，微服务鉴权管理之OAuth2原理解析(一)，前面的部分，我们关注了SpringSecurity是如何完成认证工作的，但是另外一部分核心的内容：过滤器，一直没有提到，我们已经知道SpringSecurity使用了springSecurityFilterChain作为了安全过滤的入口，这一节主要分析一下这个过滤器链都包含了哪些关键的过滤器，并且各自的使命
微服务架构 | nacos - [自动刷新配置方式 & 失效排查] 问仙长何方蓬莱微服务 java技术 SpringCloud 微服务 java nacos
INDEX§1配置方式§1.1springboot配置§1.2springcloud配置§2失效排查§2.1常见失效场景§2.1.1配置不配套§2.1.2自动刷新未开启§2.1.3依赖冲突§2.1.4改错了配置文件§2.2未知情况关键排查点§1配置方式nacos的配置中心主要有两套配置方式，配置方式不互相共通，需要配套配置springbootspringcloud§1.1springboot配置依
Spring Cloud: Hystrix请求队列线程不足 MeazZa
在SpringCloud中，Feign可以实现本地化的微服务API调用，Hystrix可以实现调用失败时的fallback处理。问题描述：在实际生产环境中使用时，我们遇到了这样一个错误："...,stacktrace:[com.netflix.hystrix.exception.HystrixRuntimeException:QueryNodeImpalaBdService#getQueryRes
当前最流行的架构设计模式 turingbooks
《微服务设计（第2版）》最可贵的地方在于，不光具备理论性与系统性，更为注重实践性与可操作性。全书勾勒出一幅从宏观到细节，再到组织落地的微服务架构整体实施蓝图。无论是对关注微服务领域的工程师与架构师，还是对寻求架构升级的管理者与决策者来说，本书都可以作为指导手册。——沈剑，快狗打车CTO《微服务设计（第2版）》萨姆·纽曼|著钟健鑫张沙沙智伟|译软件开发大神MartinFowler如此推荐本书：“微服
等保测评中的关键技术挑战与应对策略亿林数据网络安全等保测评
在信息安全领域，等保测评（信息安全等级保护测评）作为确保信息系统安全性的重要手段，其过程中不可避免地会遇到一系列技术挑战。这些挑战不仅考验着企业的技术实力，也对其安全管理水平提出了更高要求。本文将深入探讨等保测评中的关键技术挑战，并提出相应的应对策略。一、等保测评中的关键技术挑战1.复杂系统架构的评估难度随着信息技术的快速发展，企业信息系统的架构日益复杂，包括分布式系统、微服务架构、云计算环境等。
深入解析 Dubbo 的 attachments 机制及其应用场景 molashaonian dubbo attachments 隐式传参
背景在分布式系统中，服务之间的调用（RPC调用）是非常常见的。而在这种服务调用过程中，常常需要在不同服务之间传递一些上下文信息，比如用户身份信息、请求追踪ID、客户端IP等。Dubbo提供的attachments机制，能够帮助开发者在RPC调用时隐式传递这些数据，而不需要修改接口方法签名。通过分析架构图，我们可以看到，在服务调用链路中，使用Dubbo的attachments机制可以简化上下文信息的
【大模型】triton inference server idiotyi 大模型自然语言处理语言模型人工智能
前言：tritoninferenceserver常用于大模型部署，可以采用http或GRPC调用，支持大部分的backend，单GPU、多GPU都可以支持，CPU也支持。本文主要是使用tritoninferenceserver部署大模型的简单流程示例。目录1.整体流程2.搭建本地仓库3.服务端代码4.启动服务5.客户端调用1.整体流程搭建模型仓库模型配置服务端调用代码docker启动服务客户端调用
Nacos 与 Eureka 的区别 litGrey 微服务 eureka
随着微服务架构的流行，服务发现成为了构建分布式系统的关键技术之一。在众多服务发现工具中，Nacos和Eureka是两个非常受欢迎的选择。本文将深入探讨这两者的区别，帮助你在选择适合自己的服务发现解决方案时做出明智的决策。如果你不懂得怎么选择，请记得看最后一点小建议！1.基础对比1.1.架构设计：集中式vs分布式Eureka采用的是客户端-服务器（Client-Server,CS）架构。Eureka
自己实现一个简易RPC调用框架殷俊杰
最近在看dubbo，去创始人之一梁飞大神的博客搂了几眼，找到这个demo自己实现了一下，关于dubbo就不再介绍了，快速开始、框架设计、设计原则官网都有，有兴趣可以自己看Dubbo官网1.服务接口packagecom.yjj.my.api;/***@Description:*@Author:yinjunjie*@CreateDate:2018/8/713:16*@Version:1.0*/publ
微服务治理：Nacos, Zookeeper, consul, etcd, Eureka等 5 个常用微服务注册工具对比 surfirst 架构微服务 zookeeper consul
当然！下面是Nacos、Zookeeper、Consul、etcd和Eureka这五个常用的注册中心的详细对比：Nacos：Nacos是由HashiCorp开发的高度可扩展和可靠的服务发现、配置管理和服务网格解决方案。它的架构基于一组服务器代理形成的共识组和与服务器交互的许多客户端代理。主要特点包括：服务发现：服务在Nacos中注册，客户端可以通过DNS或HTTPAPI发现服务及其位置。健康检查：
docker镜像的批量备份和加载小卡车555 docker
随着微服务的不断发展，docker在微服务的部署中也占着不可缺少的角色，有这样一种场景，需要将服务器上的若干个最新的镜像打成tar.gz做一个备份或者异地部署。针对此问题尝试写了如下shell脚本#vimsaveImages.sh脚本内容如下：#当前需要打包的版本号version=xxx.0.0.1-RELEASE#仓库rep=defaultRep#名称name=defaultNameforiin
论微服务架构及应用凋零的老树架构微服务云原生
2021年初，我所在的公司承担了某能源集团化工产业部的化工生产运营综合管控系统，简称运营管控系统。我有幸担任了该项目的系统架构师，主要负责系统的体系架构、架构评估和研发管理工作。随着国内外化工行业日新月异的繁荣与发展，化工产业部在数字化、网络化、信息化方面要求不提提高。传统管理方式和技术手段也越来越难以适用瞬息万变的市场情况了。加上原来化工产业部原来建设的信息系统大多部署困难，升级麻烦，扩展性差等
微服务之服务注册与发现：Etcd、Zookeeper、Consul 与 Nacos 比较陌北v1 微服务 etcd zookeeper Consul Nacos
在微服务架构中，服务注册与发现是实现服务动态管理和负载均衡的关键。本文将对四款主流的服务注册与发现工具——Etcd、Zookeeper、Consul、Nacos进行深入对比，从功能、性能、一致性、生态集成、应用场景等多个维度展开分析，帮助您选择最适合的工具。核心概念服务注册：服务实例启动时将自身信息（IP地址、端口、健康状态等）注册到注册中心。服务发现：服务消费者通过注册中心查询所需服务的地址列表
论文分享系列（二）——论微服务架构及其应用马斯洛金字塔下的小灵猴儿 #软考高项架构师论微服务架构及其应用论文
论微服务架构及其应用摘要2023年5月，我司启动了精彩购电商系统的开发工作，该项目组中我担任系统架构师岗位，主要负责整体架构设计与中间件选型。本文以该电商平台为例，将介绍微服务架构的特点、应用场景以及实现方法。系统以SpringCloud微服务框架开发，分为前端Web服务、平台保障服务、业务服务三部分。前端Web服务由负载均衡与服务器集群结合，实现高并发的前台界面；平台保障服务以Eureka为中心
微服务架构下的服务治理实现方案详解星辰@Sea 系统架构架构微服务云原生
在微服务架构中，服务治理是确保系统稳定运行、提高服务间通信效率和灵活性的关键环节。它涉及服务的发现、负载均衡、容错、监控等多个方面。本文将深入探讨几种常见的服务治理实现方案：Zookeeper、Nacos、Consul、以及Eureka，分析它们的特点、工作原理及应用场景，帮助开发者根据实际需求选择合适的工具。一、服务治理概述服务治理，简而言之，就是对微服务架构中的服务进行有效管理的过程，包括服务
项目内部调用的远程接口开发 cyt涛 java OpenFeign 远程调用 FeignClient 内部调用同步调用远程接口
编写一个项目内部调用的远程接口通常是为了在分布式系统或者微服务架构中，实现各个服务之间的通信和数据交换。这样的远程接口专门用于服务之间的调用，而不是直接暴露给外部用户或前端。项目内部的远程接口统一放在api工程首先进入api编写接口，注意使用@FeignClient注解进入服务提供者微服务，编写接口实现类1.在api工程中编写接口在api工程中，定义远程调用的接口。这个接口将通过Feign进行服务
关于旗正规则引擎规则中的上传和下载问题何必如此文件下载压缩 jsp 文件上传
文件的上传下载都是数据流的输入输出，大致流程都是一样的。一、文件打包下载 1.文件写入压缩包 string mainPath="D:\upload\"; 下载路径 string tmpfileName=jar.zip; &n
【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析 bit1129 Stream
以如下代码为例（SocketInputDStream）： Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
spark master web ui 端口8080被占用解决方法 daizj 8080 端口占用 spark master web ui
spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法： 1、cd SPARK_HOME/sbin 2、vi start-master.sh 3、定位到下面部分
oracle_执行计划_谓词信息和数据获取周凡杨 oracle 执行计划
oracle_执行计划_谓词信息和数据获取(上) 一：简要说明在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
spring中datasource配置 g21121 dataSource
datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： http://baike.baidu.com/view/920062.htm  <bean name="propertiesConfig" class="org.springframework.b
web报表工具FineReport使用中遇到的常见报错及解决办法（三）老A不折腾 finereport FAQ 报表软件
这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 1、repeated column width is largerthan paper width：这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
mysql 用户管理墙头上一根草 linux mysql user
1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
关于使用Spring导致c3p0数据库死锁问题 aijuans spring Spring 入门 Spring 实例 Spring3 Spring 教程
这个问题我实在是为整个 springsource 的员工蒙羞如果大家使用 spring 控制事务，使用 Open Session In View 模式， com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
百度词库联想 annan211 百度
<!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>RunJS</title&g
int数据与byte之间的相互转换实现代码百合不是茶位移 int转byte byte转int 基本数据类型的实现
在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来; 主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029 int转byte; byte转int; /** * 字节转成int,int转成字节 * @author Administrator *
简单模拟实现数据库连接池 bijian1013 java thread java多线程简单模拟实现数据库连接池
简单模拟实现数据库连接池实例1： package com.bijian.thread; public class DB { //private static final int MAX_COUNT = 10; private static final DB instance = new DB(); private int count = 0; private i
一种基于Weblogic容器的鉴权设计 bijian1013 java weblogic
服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： String vuser_id = "weblogic"; String vuse
【RPC框架Hessian二】Hessian 对象序列化和反序列化 bit1129 hessian
任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。 1. 定义三个POJO Person类 package com.tom.hes
【Hadoop十四】Hadoop提供的脚本的功能 bit1129 hadoop
1. hadoop-daemon.sh 1.1 启动HDFS ./hadoop-daemon.sh start namenode ./hadoop-daemon.sh start datanode 通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
中国互联网走在“灰度”上 ronin47 管理灰度
中国互联网走在“灰度”上（转）文/孕峰第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 bylijinnan java
public class PrintMatrixClockwisely { /** * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。例如：如果输入如下矩阵： 1 2 3 4 5 6 7 8 9
mongoDB 用户管理开窍的石头 mongoDB用户管理
1:添加用户第一次设置用户需要进入admin数据库下设置超级用户（use admin） db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]}); 第一个参数用户的名字第二个参数
[游戏与生活]玩暗黑破坏神3的一些问题 comsci 生活
暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气 &nb
java 二维数组如何存入数据库 cuiyadll java
using System; using System.Linq; using System.Text; using System.Windows.Forms; using System.Xml; using System.Xml.Serialization; using System.IO; namespace WindowsFormsApplication1 {
本地事务和全局事务Local Transaction and Global Transaction(JTA) darrenzhu java spring local global transaction
Configuring Spring and JTA without full Java EE http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ Spring doc -Transaction Management http://docs.spring.io/spri
Linux命令之alias - 设置命令的别名，让 Linux 命令更简练 dcj3sjt126com linux alias
用途说明设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常用的长命令行变短，强制执行命令时询问等。常用参数格式：alias 格式：ali
yii2 restful web服务[格式响应] dcj3sjt126com PHP yii2
响应格式当处理一个 RESTful API 请求时，一个应用程序通常需要如下步骤来处理响应格式：确定可能影响响应格式的各种因素，例如媒介类型，语言，版本，等等。这个过程也被称为 content negotiation。资源对象转换为数组，如在 Resources 部分中所描述的。通过 [[yii\rest\Serializer]]
MongoDB索引调优（2）——[十] eksliang mongodb MongoDB索引优化
转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方二、索引内嵌文档可以在嵌套文档的键上建立索引，方式与正常
当滑动到顶部和底部时，实现Item的分离效果的ListView gundumw100 android
拉动ListView，Item之间的间距会变大，释放后恢复原样； package cn.tangdada.tangbang.widget; import android.annotation.TargetApi; import android.content.Context; import android.content.res.TypedArray; import andr
程序员用HTML5制作的爱心树表白动画 ini JavaScript jquery Web html5 css
体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" > <ti
预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版 kakajw ThinkPad 预装改装 windows 7 windows 8
该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！缘由小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
Nginx学习笔记 mcj8089 nginx
一、安装nginx 1、在nginx官方网站下载一个包，下载地址是： http://nginx.org/download/nginx-1.4.2.tar.gz 2、WinSCP(ftp上传工
mongodb 聚合查询每天论坛链接点击次数 qiaolevip 每天进步一点点学习永无止境 mongodb 纵观千象
/* 18 */ { "_id" : ObjectId("5596414cbe4d73a327e50274"), "msgType" : "text", "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
java术语（PO/POJO/VO/BO/DAO/DTO） Luob. DAO POJO DTO po VO BO
PO(persistant object) 持久对象在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作. VO(value object) 值对象通
算法复杂度 Wuaner Algorithm
Time Complexity & Big-O： http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o http://bigocheatsheet.com/ http://www.sitepoint.com/time-complexity-algorithms/

java网络编程实战 - 运用TCP通讯思想，手写设计实现可定制、复用和扩展的RPC服务调用框架

你可能感兴趣的:(RPC,远程过程调用,微服务)