Unreal Python TCP 双向通信

python作为服务器,unreal客户端，unreal这边创建继承Actor的类TcpCommunication

运行结果：

//TcpCommunication.h
#pragma once

#include "CoreMinimal.h"
#include "Json.h"
#include "UObject/Object.h"

#include "Networking/Public/Networking.h"

#include "GameFramework/Actor.h"

#include "TcpCommunication.generated.h"

UCLASS()

class RTS_API ATcpCommunication : public AActor

{

	GENERATED_BODY()

public:

	// Sets default values for this actor’s properties

	ATcpCommunication();

protected:

	// Called when the game starts or when spawned

	virtual void BeginPlay() override;

	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

public:

	// Called every frame

	virtual void Tick(float DeltaTime) override;

	FSocket* ListenerSocket;

	FSocket* ConnectionSocket;

	FIPv4Endpoint RemoteAddressForConnection;

	FTimerHandle TCPSocketListenerTimerHandle;

	FTimerHandle TCPConnectionListenerTimerHandle;

	UFUNCTION(BlueprintCallable, Category = "MySocket")

	bool SocketCreate(FString IPStr, int32 port);

	UFUNCTION(BlueprintCallable, Category = "MySocket")

	void SocketSend(FString meesage);

	UFUNCTION(BlueprintPure, Category = "MySocket")

	void SocketReceive(bool& bReceive, FString& recvMessage);

	FString StringFromBinaryArray(TArray<uint8> BinaryArray);

	FSocket *SocketClient;

	FIPv4Address ip;

};

//TcpCommunication.cpp
// Fill out your copyright notice in the Description page of Project Settings.
#include "TcpCommunication.h"

#include "HLSLTypeAliases.h"
#include "Runtime/Networking/Public/Networking.h"
#include "Interfaces/IPv4/IPv4Address.h"
#include "UObject/Object.h"

ATcpCommunication::ATcpCommunication(): ListenerSocket(nullptr), ConnectionSocket(nullptr)
{
	// Set this actor to call Tick() every frame. You can turn this off to improve performance if you don’t need it.

	PrimaryActorTick.bCanEverTick = true;

	SocketClient = nullptr;
}

void ATcpCommunication::BeginPlay()
{
	Super::BeginPlay();

	const FString IPStr = "127.0.0.1";

	const int32 port = 1081;

	bool success = SocketCreate(IPStr, port);

}

void ATcpCommunication::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	Super::EndPlay(EndPlayReason);
	UWorld* World = GetWorld();
	GetWorld()->GetTimerManager().ClearTimer(TCPConnectionListenerTimerHandle);
	GetWorld()->GetTimerManager().ClearTimer(TCPSocketListenerTimerHandle);

	if (ConnectionSocket != nullptr)
	{
		ConnectionSocket->Close();
	}
	if (ListenerSocket != nullptr)
	{
		ListenerSocket->Close();
	}
	if (SocketClient)
	{
		SocketClient->Close();
		ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->DestroySocket(SocketClient);
	}
}

void ATcpCommunication::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

	FString Message = "HELLO";

	bool bReceive = false;

	FString Receivemessage = "";

	SocketReceive(bReceive,Receivemessage);

	SocketSend("HelloFromUnreal");
}

bool ATcpCommunication::SocketCreate(FString IPStr, int32 port)
{
	FIPv4Address::Parse(IPStr,ip);
	TSharedRef<FInternetAddr> addr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
	addr->SetIp(ip.Value);
	addr->SetPort(port);

	SocketClient = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateSocket(NAME_Stream,TEXT("default"),false);
	if (SocketClient->Connect(*addr))
	{
		GEngine->AddOnScreenDebugMessage(1,2.0f,FColor::Green,TEXT("Connect Success!"));

		UE_LOG(LogTemp,Warning,TEXT("Connect Success!"));

		return true;
		//UE_LOG(LogTemp, Warning, TEXT("Connect Succ!"));
	}
	GEngine->AddOnScreenDebugMessage(1, 2.0f, FColor::Green, TEXT("Connect failed!"));

	UE_LOG(LogTemp, Warning, TEXT("Connect failed!"));

	return false;
}

void ATcpCommunication::SocketSend(FString meesage)
{
	TCHAR *seriallizedChar = meesage.GetCharArray().GetData();

	int32 size = FCString::Strlen(seriallizedChar) + 1;

	int32 sent = 0;
	if (SocketClient->Send((uint8*)TCHAR_TO_UTF8(seriallizedChar), size, sent))
	{
		GEngine->AddOnScreenDebugMessage(1, 2.0f, FColor::Green, TEXT("_____Send Succ!"));
		UE_LOG(LogTemp, Warning, TEXT("_____Send Succ!"));
	}
	else
	{
		GEngine->AddOnScreenDebugMessage(1, 2.0f, FColor::Green, TEXT("_____Send failed!"));
		UE_LOG(LogTemp, Warning, TEXT("_____Send failed!"));
	}
	
}

void ATcpCommunication::SocketReceive(bool& bReceive, FString& recvMessage)
{
	recvMessage = "";
	bReceive = false;
	if (!SocketClient)
	{
		return;
	}
	TArray<uint8>  ReceiveData;
	uint32 size;
	uint8 element = 0;
	while (SocketClient->HasPendingData(size))
	{
		ReceiveData.Init(element,FMath::Min(size,65507u));
		int32 read = 0;
		SocketClient->Recv(ReceiveData.GetData(),ReceiveData.Num(),read);
	}
	if (ReceiveData.Num()<=0)
	{
		return;
	}
	FString log = "Total Data read!num:" + FString::FromInt(ReceiveData.Num()<=0);

	GEngine->AddOnScreenDebugMessage(1, 2.0f, FColor::Green, log);

	UE_LOG(LogTemp, Warning, TEXT("Recv log:  %s"), *log);

	const FString ReceiveUE4String = StringFromBinaryArray(ReceiveData);

	log = "Server:" + ReceiveUE4String;
	bReceive = true;
	
}

FString ATcpCommunication::StringFromBinaryArray(TArray<uint8> BinaryArray)
{
	return FString(ANSI_TO_TCHAR(reinterpret_cast<const char*>(BinaryArray.GetData())));
}

Python：

#encoding=utf-8
# 创建一个 TCP 服务器程序，这个程序会把客户发送过来的字
# 符串加上一个时间戳（格式：'[时间]数据'）返回给客户。
from socket import *
from time import ctime

host = '127.0.0.1'
port = 1081
bufsiz = 2048
addr = (host,port)

#创建tcp套接字，绑定，监听
tcpServerSock = socket(AF_INET,SOCK_STREAM)#创建TCP Socket
#AF_INET 服务器之间网络通信
#socket.SOCK_STREAM 流式socket , for TCP
tcpServerSock.bind(addr)#将套接字绑定到地址,
#在AF_INET下,以元组（host,port）的形式表示地址.
tcpServerSock.listen(5)#操作系统可以挂起的最大连接数量，至少为1，大部分为5

while True:
    print ('waiting for connection')
    # udp中是recvfrom(buffersize),tcp这里用accept()；
    # tcp这里接收到的是客户端的sock对象，后面接受数据时使用socket.recv()
    tcpClientSock, addr2 = tcpServerSock.accept() #接受客户的连接
#接受TCP连接并返回（conn,address）,其中conn是新的套接字对象，
#可以用来接收和发送数据。
#address是连接客户端的地址。
    print ('connected from :',addr2)
    while True:
        data = tcpClientSock.recv(bufsiz) #接收客户端发来的数据
        if not data:
            break
        print(data.decode())
        msg= "hellooooooo"
        if not msg:
            break;
        tcpClientSock.send(msg.encode()) #返回给客户端数据
    tcpClientSock.close()
tcpServerSock.close()