Python-RPC：RPC完整实现流程

最新推荐文章于 2024-04-17 19:45:36 发布
最新推荐文章于 2024-04-17 19:45:36 发布
阅读量768 收藏 1
点赞数
分类专栏： RPC

1. Client Stub 客户端存根

用户直接操作的对象，由client stub构造消息数据借助连接发送给服务端，并接收解析服务端的返回消息传递给用户。

class ClientStub(object):
    """
    客户端存根
    """
    def __init__(self, channel):
        self.channel = channel
        self.conn = self.channel.get_connection()

    def divide(self, num1, num2=1):
        # 构造
        proto = DivideProtocol()
        args = proto.args_encode(num1, num2)
        self.conn.sendall(args)
        result = proto.result_decode(self.conn)
        if isinstance(result, InvalidOperation):
            raise result
        else:
            return result

2. Server Stub 服务端存根

帮助服务端接收调用消息数据并解析，在本地调用程序后将结果构造返回值消息返回给客户端。

class ServerStub(object):
    def __init__(self, connection, handlers):
        """
        服务器存根
        :param connection: 与客户端的socket连接
        :param handlers: 存放被调用的方法
        """
        self._process_map = {
            'divide': self._process_divide,
        }
        self.conn = connection
        self.method_proto = MethodProtocol(self.conn)
        self.handlers = handlers

    def process(self):
        """
        被服务器调用的入口，服务器收到请求后调用该方法
        """
        # 获取解析调用请求的方法名
        name = self.method_proto.get_method_name()

        # 调用对应的处理方法
        self._process_map[name]()

    def _process_divide(self):
        """
        执行divide本地调用，并将结果返回给客户端
        """
        # 接收调用参数
        proto = DivideProtocol()
        args = proto.args_decode(self.conn)

        # 进行本地divide调用
        try:
            result = self.handlers.divide(**args)
        except InvalidOperation as e:
            result = e

        # 构造返回值消息并返回
        result = proto.result_encode(result)
        self.conn.sendall(result)

3.完善 Server

class Server(object):
    def __init__(self, host, port, handlers):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.host = host
        self.port = port
        self.sock.bind((host, port))
        self.handlers = handlers

    def serve(self):
        """
        开始服务
        """
        self.sock.listen(128)
        print("开始监听")
        while True:
            conn, addr = self.sock.accept()
            print("建立链接%s" % str(addr))
            stub = ServerStub(conn, self.handlers)
            try:
                while True:
                    stub.process()
            except EOFError:
                print("客户端关闭连接")
            # 关闭服务端连接
            conn.close()

4.测试

编写服务端 server.py

from services import Server
from services import InvalidOperation


class Handlers:
    @staticmethod
    def divide(num1, num2=1):
        """
        除法
        :param num1:
        :param num2:
        :return:
        """
        if num2 == 0:
            raise InvalidOperation()
        val = num1 / num2
        return val


if __name__ == '__main__':
    server = Server('127.0.0.1', 8000, Handlers)
    server.serve()

编写客户端 client.py

from services import ClientStub
from services import Channel
from services import InvalidOperation
import time

channel = Channel('127.0.0.1', '8000')
stub = ClientStub(channel)

for i in range(5):
    try:
        val = stub.divide(i*100, 10)
    except InvalidOperation as e:
        print(e.message)
    else:
        print(val)
    time.sleep(1)

完整代码：
服务端代码： server.py

import socket

import struct

from io import BytesIO


class InvalidOperation(Exception):
    """
    自定义非法操作异常
    """
    def __init__(self, message=None):
        self.message = message or "Invalid operation."


class DivideProtocol(object):
    """
    float divide(1: int num1, 2: int num2=1)
    """
    conn = None

    def _read_all(self, size):
        """
        读取指定长度的字节
        :param size: 长度
        :return: 读取出的二进制数据
        """
        if isinstance(self.conn, BytesIO):
            # BytesIO 类型 用于演示
            buff = b''
            have = 0
            while have < size:
                chunk = self.conn.read(size - have)
                have += len(chunk)
                buff += chunk
            return buff
        else:
            # socket 类型
            buff = b''
            have = 0
            while have < size:
                chunk = self.conn.recv(size - have)
                have += len(chunk)
                buff += chunk
                # 客户端关闭了连接
                if len(chunk) == 0:
                    raise EOFError()
            return buff

    def args_encode(self, num1, num2=1):
        """
        对调用参数进行编码
        :param num1:  int
        :param num2:  int
        :return: 编码后的二进制数据
        """
        # 处理参数 num1， 4字节整型
        buff = struct.pack("!B", 1)
        buff += struct.pack("!i", num1)

        # 处理参数 num2, 4 字节整型，如为 默认值 1 就不再放到消息中
        if num2 != 1:
            buff += struct.pack("!B", 2)
            buff += struct.pack('!i', num2)

        # 处理消息总长度 4 字节无符号整型
        length = len(buff)

        # 处理方法名 字符串类型
        name = "divide"
        # 字符串长度 4 字节无符号整型
        msg = struct.pack('!I', len(name))
        msg += name.encode()

        msg += struct.pack('!I', length) + buff

        return msg

    def args_decode(self, connection):
        """
        获取调用参数并进行解码
        :param connection: 传输工具对象，如socket对象或者BytesIO对象，从中可以读取消息数据
        :return: 解码后的参数字典
        """
        # 保存到当前对象中，供_read_all方式使用
        self.conn = connection
        param_name_map = {
            1: 'num1',
            2: 'num2',
        }
        param_len_map = {
            1: 4,
            2: 4,
        }
        # 用于保存解码后的参数字典
        args = dict()

        # 读取消息总长度，4字无节符号整数
        buff = self._read_all(4)
        length = struct.unpack('!I', buff)[0]

        # 记录已读取的长度
        have = 0

        # 读取第一个参数，4字节整型
        buff = self._read_all(1)
        have += 1
        param_seq = struct.unpack('!B', buff)[0]
        param_len = param_len_map[param_seq]
        buff = self._read_all(param_len)
        have += param_len
        args[param_name_map[param_seq]] = struct.unpack('!i', buff)[0]

        if have >= length:
            return args

        # 读取第二个参数，4字节整型
        buff = self._read_all(1)
        have += 1
        param_seq = struct.unpack('!B', buff)[0]
        param_len = param_len_map[param_seq]
        buff = self._read_all(param_len)
        have += param_len
        args[param_name_map[param_seq]] = struct.unpack('!i', buff)[0]

        return args

    def result_encode(self, result):
        """
        对调用的结果进行编码
        :param result: float 或 InvalidOperation对象
        :return: 编码后的二进制数据
        """
        if isinstance(result, float):
            # 没有异常，正常执行
            # 处理结果类型，1字节无符号整数
            buff = struct.pack('!B', 1)

            # 处理结果值, 4字节float
            buff += struct.pack('!f', result)
        else:
            # 发生了InvalidOperation异常
            # 处理结果类型，1字节无符号整数
            buff = struct.pack('!B', 2)

            # 处理异常结果值, 字符串
            # 处理字符串长度, 4字节无符号整数
            buff += struct.pack('!I', len(result.message))
            # 处理字符串内容
            buff += result.message.encode()

        return buff

    def result_decode(self, connection):
        """
        对调用结果进行解码
        :param connection: 传输工具对象，如socket对象或者BytesIO对象，从中可以读取消息数据
        :return: 结果数据
        """
        self.conn = connection

        # 取出结果类型, 1字节无符号整数
        buff = self._read_all(1)
        result_type = struct.unpack('!B', buff)[0]
        if result_type == 1:
            # float的结果值， 4字节float
            buff = self._read_all(4)
            result = struct.unpack('!f', buff)[0]
            return result
        else:
            # InvalidOperation对象
            # 取出字符串长度, 4字节无符号整数
            buff = self._read_all(4)
            str_len = struct.unpack('!I', buff)[0]
            buff = self._read_all(str_len)
            message = buff.decode()
            return InvalidOperation(message)


class MethodProtocol(object):
    """解析方法名的实现 """
    def __init__(self, connection):
        self.conn = connection

    def _read_all(self, size):
        """
        读取指定长度的字节
        :param size: 长度
        :return: 读取出的二进制数据
        """
        if isinstance(self.conn, BytesIO):
            # BytesIO类型，用于演示
            buff = b''
            have = 0
            while have < size:
                chunk = self.conn.read(size - have)
                have += len(chunk)
                buff += chunk

            return buff

        else:
            # socket类型
            buff = b''
            have = 0
            while have < size:
                print('have=%d size=%d' % (have, size))
                chunk = self.conn.recv(size - have)
                have += len(chunk)
                buff += chunk

                if len(chunk) == 0:
                    raise EOFError()

            return buff

    def get_method_name(self):
        # 获取方法名
        # 读取字符串长度，4字节无符号整型
        buff = self._read_all(4)
        str_len = struct.unpack('!I', buff)[0]

        # 读取字符串
        buff = self._read_all(str_len)
        name = buff.decode()
        return name


class ClientStub(object):
    """
    客户端存根
    """
    def __init__(self, channel):
        self.channel = channel
        self.conn = self.channel.get_connection()

    def divide(self, num1, num2=1):
        # 构造
        proto = DivideProtocol()
        args = proto.args_encode(num1, num2)
        self.conn.sendall(args)
        result = proto.result_decode(self.conn)
        if isinstance(result, InvalidOperation):
            raise result
        else:
            return result


class ServerStub(object):
    def __init__(self, connection, handlers):
        """
        服务器存根
        :param connection: 与客户端的socket连接
        :param handlers: 存放被调用的方法
        """
        self._process_map = {
            'divide': self._process_divide,
        }
        self.conn = connection
        self.method_proto = MethodProtocol(self.conn)
        self.handlers = handlers

    def process(self):
        """
        被服务器调用的入口，服务器收到请求后调用该方法
        """
        # 获取解析调用请求的方法名
        name = self.method_proto.get_method_name()

        # 调用对应的处理方法
        self._process_map[name]()

    def _process_divide(self):
        """
        执行divide本地调用，并将结果返回给客户端
        """
        # 接收调用参数
        proto = DivideProtocol()
        args = proto.args_decode(self.conn)

        # 进行本地divide调用
        try:
            result = self.handlers.divide(**args)
        except InvalidOperation as e:
            result = e

        # 构造返回值消息并返回
        result = proto.result_encode(result)
        self.conn.sendall(result)


class Server(object):
    """socket 服务器"""
    def __init__(self, host, port, handlers):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.host = host
        self.port = port
        self.sock.bind((host, port))
        self.handlers = handlers

    def serve(self):
        """
        开始服务
        """
        self.sock.listen(128)
        print("开始监听")
        while True:
            conn, addr = self.sock.accept()
            print("建立链接%s" % str(addr))
            stub = ServerStub(conn, self.handlers)
            try:
                while True:
                    stub.process()
            except EOFError:
                print("客户端关闭连接")
            # 关闭服务端连接
            conn.close()


class Handlers:
    @staticmethod
    def divide(num1, num2=1):
        """
        除法
        :param num1:
        :param num2:
        :return:
        """
        if num2 == 0:
            raise InvalidOperation()
        val = num1 / num2
        return val


if __name__ == '__main__':
    # 开启服务端进程
    server = Server('127.0.0.1', 8888, Handlers)
    server.serve()

客户端代码： client.py

import socket
import struct
import time
from io import BytesIO


class InvalidOperation(Exception):
    """
    自定义非法操作异常
    """
    def __init__(self, message=None):
        self.message = message or "Invalid operation."
        

class Channel(object):
    """
    连接通道
    """
    def __init__(self, host, port):
        self.host = host
        self.port = port

    def get_connection(self):
        """
        获取一个 tcp 连接
        :return:
        """
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect((self.host, self.port))
        return sock


class DivideProtocol(object):
    """
    float divide(1: int num1, 2: int num2=1)
    """
    conn = None

    def _read_all(self, size):
        """
        读取指定长度的字节
        :param size: 长度
        :return: 读取出的二进制数据
        """
        if isinstance(self.conn, BytesIO):
            # BytesIO 类型 用于演示
            buff = b''
            have = 0
            while have < size:
                chunk = self.conn.read(size - have)
                have += len(chunk)
                buff += chunk
            return buff
        else:
            # socket 类型
            buff = b''
            have = 0
            while have < size:
                chunk = self.conn.recv(size - have)
                have += len(chunk)
                buff += chunk
                # 客户端关闭了连接
                if len(chunk) == 0:
                    raise EOFError()
            return buff

    def args_encode(self, num1, num2=1):
        """
        对调用参数进行编码
        :param num1:  int
        :param num2:  int
        :return: 编码后的二进制数据
        """
        # 处理参数 num1， 4字节整型
        buff = struct.pack("!B", 1)
        buff += struct.pack("!i", num1)

        # 处理参数 num2, 4 字节整型，如为 默认值 1 就不再放到消息中
        if num2 != 1:
            buff += struct.pack("!B", 2)
            buff += struct.pack('!i', num2)

        # 处理消息总长度 4 字节无符号整型
        length = len(buff)

        # 处理方法名 字符串类型
        name = "divide"
        # 字符串长度 4 字节无符号整型
        msg = struct.pack('!I', len(name))
        msg += name.encode()

        msg += struct.pack('!I', length) + buff

        return msg

    def args_decode(self, connection):
        """
        获取调用参数并进行解码
        :param connection: 传输工具对象，如socket对象或者BytesIO对象，从中可以读取消息数据
        :return: 解码后的参数字典
        """
        # 保存到当前对象中，供_read_all方式使用
        self.conn = connection
        param_name_map = {
            1: 'num1',
            2: 'num2',
        }
        param_len_map = {
            1: 4,
            2: 4,
        }
        # 用于保存解码后的参数字典
        args = dict()

        # 读取消息总长度，4字无节符号整数
        buff = self._read_all(4)
        length = struct.unpack('!I', buff)[0]

        # 记录已读取的长度
        have = 0

        # 读取第一个参数，4字节整型
        buff = self._read_all(1)
        have += 1
        param_seq = struct.unpack('!B', buff)[0]
        param_len = param_len_map[param_seq]
        buff = self._read_all(param_len)
        have += param_len
        args[param_name_map[param_seq]] = struct.unpack('!i', buff)[0]

        if have >= length:
            return args

        # 读取第二个参数，4字节整型
        buff = self._read_all(1)
        have += 1
        param_seq = struct.unpack('!B', buff)[0]
        param_len = param_len_map[param_seq]
        buff = self._read_all(param_len)
        have += param_len
        args[param_name_map[param_seq]] = struct.unpack('!i', buff)[0]

        return args

    def result_encode(self, result):
        """
        对调用的结果进行编码
        :param result: float 或 InvalidOperation对象
        :return: 编码后的二进制数据
        """
        if isinstance(result, float):
            # 没有异常，正常执行
            # 处理结果类型，1字节无符号整数
            buff = struct.pack('!B', 1)

            # 处理结果值, 4字节float
            buff += struct.pack('!f', result)
        else:
            # 发生了InvalidOperation异常
            # 处理结果类型，1字节无符号整数
            buff = struct.pack('!B', 2)

            # 处理异常结果值, 字符串
            # 处理字符串长度, 4字节无符号整数
            buff += struct.pack('!I', len(result.message))
            # 处理字符串内容
            buff += result.message.encode()

        return buff

    def result_decode(self, connection):
        """
        对调用结果进行解码
        :param connection: 传输工具对象，如socket对象或者BytesIO对象，从中可以读取消息数据
        :return: 结果数据
        """
        self.conn = connection

        # 取出结果类型, 1字节无符号整数
        buff = self._read_all(1)
        result_type = struct.unpack('!B', buff)[0]
        if result_type == 1:
            # float的结果值， 4字节float
            buff = self._read_all(4)
            result = struct.unpack('!f', buff)[0]
            return result
        else:
            # InvalidOperation对象
            # 取出字符串长度, 4字节无符号整数
            buff = self._read_all(4)
            str_len = struct.unpack('!I', buff)[0]
            buff = self._read_all(str_len)
            message = buff.decode()
            return InvalidOperation(message)


class ClientStub(object):
    """
    客户端存根
    """
    def __init__(self, channel):
        self.channel = channel
        self.conn = self.channel.get_connection()

    def divide(self, num1, num2=1):
        # 构造
        proto = DivideProtocol()
        args = proto.args_encode(num1, num2)
        self.conn.sendall(args)
        result = proto.result_decode(self.conn)
        if isinstance(result, InvalidOperation):
            raise result
        else:
            return result
        

channel = Channel('127.0.0.1', 8888)
stub = ClientStub(channel)

for i in range(20):
    try:
        val = stub.divide(i*100, 10)
    except InvalidOperation as e:
        print(e.message)
    else:
        print(val)
    time.sleep(1)
feiyy404
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python XML-RPC 实现简单的远程调用过程
m0_72444380的博客
09-28 991
RPC 是 Remote Procedure Call 的缩写，翻译成中文为：远程方法调用。在 Python 中，我们可以使用 XML-RPC 协议创建自己的跨平台，独立于语言的服务器。XML Remote Procedure Call，即 XML 远程方法调用。XML-RPC 是一种远程过程调用方法，它使用通过 HTTP 传递的 XML 作为载体。 有了它，客户端可以在远程服务器上调用带参数的方法（服务器以 URI 命名）并获取结构化的数据。简单的理解是：将数据定义为 XML 格式，通过 HTTP 协议进
【python】第三方库-python-jsonrpc框架
weixin_37008947的博客
10-19 3901
文章目录JsonRPC简介调用的json格式输出的接送格式python-jsonrp框架安装简单使用示例HTTP Client 示例HTTP Server 示例CGI(通用网关接口) 示例框架使用示例CherryPy 示例 JsonRPC简介 json-rpc是基于json的跨语言远程调用协议，比xml-rpc、webservice等基于文本的协议传输数据格小，相对hessian、java-rpc等而金种子协议便于调试、实现、扩展，是非常优秀的一种远程调用协议 调用的json格式 { "metho
Python- JSON-RPC创建一个远程过程调用
青衫客36的博客
10-11 1312
我们使用JSON-RPC创建一个远程过程调用的例子，我们将使用库和Flask框架创建一个后端服务，并使用作为客户端。
Python-RPC：RPC的基本知识总结
Enjolras_fuu的博客
07-17 693
什么是 RPC 远程过程调用（英语：Remote Procedure Call，缩写为 RPC，也叫远程程序调用）是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。如果涉及的软件采用面向对象编程，那么远程过程调用亦可称作远程调用或远程方法调用。 类比单机 在单台计算机中，我们可以通过程序调用来传递控制和数据；或者说通过程序调用，...
python实现基于RPC协议的接口自动化测试_python调用rpc接口
2401_84240742的博客
04-17 811
业务是积分兑换，该接口的参数是一个对象，对象类型对应后台java代码中的某个类cn.testfan.dubbo.model.ExchangeRequest，这个类对象对应的属性如下，这些属性其实就是我们的参数。注意在公司里你们的grpc服务可能并不是采用python去实现的，课上咱们为了测试grpc的接口，使用python先创建grpc的服务接口。业务是抽奖，参数有两个，都是数字，没有参数名称，按照顺序，第一个表示参与的活动id，第二个表示用户id。以下代码就是调用第一步中的grpc接口的。
NFS问题mount clntudp_create: RPC: Port mapper failure - RPC: Unable to receive
liuzhilong的博客
05-28 1115
在搭建nfs的时候，showmount报错如下 [root@yzlc1 ~]# showmount -e 192.xx.xx.151 mount clntudp_create: RPC: Port mapper failure - RPC: Unable to receive 源端查看nfs是否打开 [root@LZL ~]# exportfs -rv exporting *:/backup 源端/backup目录已经在exporting状态了 检查发现本地防火墙，selinux都已经..
Python-RPC: 多线程 RPC 服务器
Enjolras_fuu的博客
07-18 970
RPC 服务器 在前面的实现中，我们只实现了RPC服务器的最简易模型——单进程单线程。 为了能让RPC服务器同时处理多个客户端的请求，提升性能，我们可以改写服务器，采用多线程、多进程等。 在此我们仅实现多线程模型，其余不再赘述。 多线程服务器 import threading class ThreadServer(object): def __init__(self, host, por...
Python-RPC：RPC传输
Enjolras_fuu的博客
07-17 892
在构造好RPC消息数据后，就可以通过网络在调用双方进行传递了。 传递消息数据常用的有两种方式：TCP 和 HTTP 1. TCP 由于TCP的可靠性，所以TCP是最常用的方式。我们可以直接借助socket工具进行TCP开发。 TCP服务端编写： sock = socket.socket() # 创建一个套接字 sock.bind() # 绑定端口 sock.listen() # 监听连接 s...
Python-RPC: Thrift 架构与使用方法
Enjolras_fuu的博客
07-18 817
如果现在要实现一个除法divide的RPC接口服务： float divide(1:int num1, 2:int num2=1) => InvalidOperation 如何使用Thrift来进行实现呢？ Thrift的基础库程序中已经提供了用于RPC通讯的底层基本消息协议和传输工具，也就是调用双方如何传输str、int、float等不同基本类型的数据无需我们自己再实现了。 但是对于不同...
python实现RPC
weixin_40301728的博客
10-11 6368
使用python的socket实现RPC
python jsonrpc_python-jsonrpc框架实现JsonRPC协议的web服务
weixin_39790877的博客
12-04 311
一、JsonRPC介绍json-rpc是基于json的跨语言远程调用协议，比xml-rpc、webservice等基于文本的协议传输数据格小；相对hessian、Java-rpc等二进制协议便于调试、实现、扩展，是非常优秀的一种远程调用协议。二、JsonRPC简单说明1、调用的Json格式向服务端传输数据格式如下：{ "method": "方法名", "params": [“参数数组”], "id...
python-ubus:用于通过JSON-RPC访问ubus的Python库
05-17
适用于Ubus的Python接口 该软件包提供了一个pythonic接口，用于通过其单独打包的JSON-RPC接口访问ubus < >。 图书馆使用 Ubus类是访问此软件包所有功能的入口点，它提供对可用接口的访问： ubus = Ubus('router....
json-rpc::repeat_button:JSON-RPC 12传输实现。 支持python 23和pypy
05-13
json-rpc 和传输规范实现。 支持Python 2.6 +，Python 3.3 +，PyPy。 具有可选的Django和Flask支持。 200多个测试。特征此实现没有任何传输功能实现，只有协议。 根据当前代码，任何客户端或服务器实现都很容易，...
neo-python-rpc:适用于NEO区块链的Python RPC客户端
05-14
新python-rpc 适用于NEO区块链的轻量级Python RPC客户端 免费软件：MIT许可证文档： : 。安装pip install neo-python-rpc 基本用法获取区块链的高度>>> from neorpc.Client import RPCClient>>> client = RPCClient...
django-modern-rpc：适用于现代Django的简单XML-RPC和JSON-RPC服务器
02-04
django-modern-rpc：适用于现代Django的简单XML-RPC和JSON-RPC服务器
python-ajsonrpc:异步JSON-RPC 2.0协议+服务器
03-19
python-ajsonrpc:异步JSON-RPC 2.0协议+服务器
WX小程序源码运动健身
最新发布
05-28
WX小程序源码运动健身提取方式是百度网盘分享地址
sja1314.x86_64.tar.gz
05-28
SQLyong 各个版本，免费下载 SQLyog是业界著名的Webyog公司出品的一款简洁高效、功能强大的图形化MySQL数据库管理工具。使用SQLyog可以快速直观地让您从世界的任何角落通过网络来维护远端的MySQL数据库。
智能交通辅助 - 基于MATLAB的车牌识别系统设计资源下载
05-28
基于MATLAB的车牌识别系统设计资源是一款专业的车牌检测和识别工具包，它利用MATLAB强大的计算和图像处理能力，为用户提供了一套完整的车牌识别解决方案。该系统特别适合智能交通管理系统、停车场自动化以及安全监控等领域。以下是该车牌识别系统的主要特点： 图像预处理：集成图像去噪、灰度化和二值化等预处理功能，提高识别准确性。 车牌定位：采用先进的图像识别算法，快速定位图像中的车牌区域。 字符分割：精确分割车牌中的每个字符，为识别提供清晰的输入。 字符识别：应用机器学习技术，实现对车牌上字符的高准确度识别。 MATLAB兼容：完全基于MATLAB环境开发，易于集成和扩展。 用户界面友好：提供直观的用户界面，便于操作和监控识别过程。 实时处理：支持实时视频流处理，适用于动态交通监控场景。 可定制开发：可根据特定需求进行定制开发，满足不同应用场景。 文档和示例：提供详细的开发文档和示例代码，帮助用户快速理解和应用。 基于MATLAB的车牌识别系统设计资源是智能交通领域开发者的理想选择。立即下载，为您的项目增添强大的车牌识别功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值