# 微服务_RPC模块_Python实现

**Repository Path**: hubertshelley/microservice--rpc-module

## Basic Information

- **Project Name**: 微服务_RPC模块_Python实现
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2021-03-28
- **Last Updated**: 2021-05-24

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

### 示例代码
该微服务实现仅为个人理解，并不代表可以投入实际生产，希望能有大佬指点一二或者同好共同学习:)

服务端：
```python
import time

from RPC.server import Server, registerFunctionOnService

server = Server('127.0.0.1', 8080)


@registerFunctionOnService(server)
def testFunction():
    print('testFunction')
    return {'testFunction': 'test'}


@registerFunctionOnService(server)
def testTimeout():
    time.sleep(5)
    return {'testFunction': 'test'}


if __name__ == '__main__':
    # server.register(testFunction)
    rtn = server.request('testFunction')
    print(f'result:{rtn}')
    server.start()
    while True:
        time.sleep(1)
```
客户端：
```python
import threading
from datetime import datetime

from RPC.client import Client


def testAsync(_client, times: int):
    datetimeOld = datetime.now()
    _client.setServerAddresses([('127.0.0.1', 8080)])
    try:
        result = _client.handleRequest('testFunction')
    except Exception as _e:
        print(f'第 {times + 1} 次非异步请求-{_e.__str__()}')
        return
    datetimeNew = datetime.now()
    datetimeDelta = (datetimeNew - datetimeOld).microseconds
    print(f'第 {times + 1} 次非异步请求-开始时间：{datetimeOld}-结束时间：{datetimeNew}-请求结果：{result}, 消耗时间：{datetimeDelta / 1000}毫秒')


def test(_client, times: int):
    datetimeOld = datetime.now()
    _client.setServerAddresses([('127.0.0.1', 8080)])
    try:
        result = _client.handleRequest('testFunction', isAsync=True)
    except Exception as _e:
        print(f'第 {times + 1} 次异步请求-{_e.__str__()}')
        return
    datetimeNew = datetime.now()
    datetimeDelta = (datetimeNew - datetimeOld).microseconds
    print(f'第 {times + 1} 次异步请求-开始时间：{datetimeOld}-结束时间：{datetimeNew}-请求结果：{result}, 消耗时间：{datetimeDelta / 1000}毫秒')


if __name__ == '__main__':
    client = Client()
    for index in range(5000):
        try:
            threading.Thread(target=test, args=(client, index)).start()
        except Exception as e:
            print(e)
    for index in range(5000):
        try:
            threading.Thread(target=testAsync, args=(client, index)).start()
        except Exception as e:
            print(e)
    try:
        timeoutResult = client.handleRequest('testTimeout')
        print(timeoutResult)
    except Exception as e:
        print(e)
```