2つのクライアントソケットを接続します
Javaには2種類のソケットがあるとしましょう。
- サーバーソケット「ServerSocket」
- クライアントソケットまたは単に「ソケット」
2つのプロセスの状況を想像してみてください。
X =クライアント
Y =サーバー
サーバープロセスY：には、TCPポートをリッスンしている "ServerSocket"があります
クライアントプロセスX：「ソケット」を介してYに接続要求を送信します。
Y：次に、accept()メソッドは新しいクライアントタイプ "Socket"を返します。
発生すると、2つのソケットが「相互接続」されます。
つまり、クライアントプロセスのソケットは、サーバープロセスのソケットに接続されています。
次に、ソケットXを介した読み取り/書き込みは、ソケットYを介した読み取り/書き込みに似ています。
これで、2つのClientソケットが相互接続されます!!
だが...
同じプロセスで2つのクライアントソケットを作成し、それらを「相互接続」したい場合はどうなりますか？
...可能ですか？
中間のServerSocketを使用せずに2つのクライアントソケットを相互接続する方法を考えてみましょう。
Aを継続的に読み取ってBを書き込むためのスレッドと、Bを読み取ってAを書き込むためのスレッドを2つ作成することで、これを解決しました。
しかし、私はもっと良い方法かもしれないと思います...（これらの世界のエネルギーを消費するスレッドはクライアントサーバーアプローチでは必要ありません）
どんな助けやアドバイスもいただければ幸いです！ありがとう
編集：
アプリケーションの例：「既存のサーバーアプリケーションをクライアントアプリケーションに変換できます」、たとえば、VNCサーバーでは、1つのクライアントソケットがVNCサーバーに接続し、他のクライアントソケットが作成され（中間サーバーに接続するため）、アプリケーションが作成されます。 2つのクライアントを相互接続すると、VNCサーバーがクライアントアプリケーションになります。そして、パブリックIPは必要ありません。
VNCServer --- MyApp ---> |中間サーバー| <---ユーザー
まず、受け入れられたクライアント（サーバー側）のソケットをClient Socketと呼ばないでください。それは非常に紛らわしいです。
中間のServerSocketを使用せずに2つのクライアントソケットを相互接続する方法を考えてみましょう。
それは不可能。クライアントを受け入れることができるサーバー側を常に作成する必要があります。ここで問題となるのは、接続のどちら側をサーバー側にする必要があるかということです。
この決定によってあなたが考えなければならないこと：
- サーバーには静的パブリックIPが必要です。
- ルーターが接続された後のサーバーは、「ポート転送」を実行する必要があります。 （ PnP を参照）
- クライアントは、接続する必要のあるホストを知っている必要があります（パブリックIP）
ミドルサーバー
VNCServerにすぐに接続しないのはなぜですか？
しかし、本当に必要な場合は、次のような状況を作成できます。
/VNCServer（サーバー実行中）<---。 | | LAN- | VNCServerに接続します | | \MyApp（実行中のサーバー->中間サーバーから受け入れる）<------。 | （ルーター経由） | 中間サーバー（サーバーの実行->クライアントを受け入れる）--->アプリに接続します ^ | （ルーター経由） | クライアント->ミドルサーバーに接続します-°
そして、これは3番目のサーバーがない場合の外観です（私がお勧めするもの）：
/VNCServer（サーバー実行中）<---。 | | LAN- | VNCServerに接続します | | \MyApp（サーバー実行中->クライアントを受け入れる）<------。 | （ルーター経由） | クライアント-> MyAppに接続--------------------------°
編集：
私は今それを手に入れたと思います：
次のように状況を視覚化する必要があります。
メインサーバー（ミドルサーバーと呼ばれるもの） （1）| | （2） /⁻⁻⁻⁻⁻⁻⁻⁻⁻⁻⁻⁻⁻⁻⁻⁻⁻⁻/ \⁻⁻⁻⁻⁻⁻ 。] | | VNCServer <---------------------------->クライアント （5）（3 ）
(1)VNCServerはメインサーバーに接続します。したがって、メインサーバーはVNCServerにそのIPを取得しました。(2)クライアントはメインサーバーに接続します。(3)これで、メインサーバーはサーバーとクライアントの場所を認識します。次に、サーバーがあるクライアントに送信します。次に、クライアントはメインサーバーから受信したIPに接続します。もちろん、これはVNCServerからのIPです。(5)実行中のVNCServerは、クライアントを受け入れるサーバーです。
これで、デスクトップ共有を開始できます。
これがあなたが持つことができる最も推奨される状況だと思います。
もちろん、Javaで書くのはあなた次第です。
なぜあなたはそれをする必要があるのですか？
「ピアツーピア」タイプのシステムが必要な場合は、各クライアントにクライアントとサーバーソケット（他のクライアントからの接続を受け入れるためのサーバーソケットと他のクライアントへの接続を確立するためのクライアントソケット）の両方を実行させるだけです。
ETA：元の質問で何を尋ねているのかは完全には明確ではありませんでしたが、編集してから、ある種の プロキシサーバー を作成しようとしているようです。
この例では、アプリは2つのクライアントソケットを作成します。1つはVNCServerに接続し、もう1つは「中間サーバー」に接続します。 「中間サーバー」には2つのサーバーソケットがあります（1つはアプリが接続するため、もう1つはユーザーが接続するためです。内部的には、これらのソケットを一致させ、2つの間でデータをシャトルする方法を知る必要があります。
これは、2つのSocketをServerSocketなしで接続したコードです。
_package primary;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
public class Main {
private static Object locker;
public static void main(String[] args) {
locker = new Object();
final int[][] a = new int[6][];
final int[][] b = new int[6][];
final int[][] c;
a[0] = new int[] {12340, 12341};
a[1] = new int[] {12342, 12344};
a[2] = new int[] {12342, 12343};
a[3] = new int[] {12340, 12345};
a[4] = new int[] {12344, 12345};
a[5] = new int[] {12341, 12343};
b[0] = new int[] {22340, 22341};
b[1] = new int[] {22342, 22344};
b[2] = new int[] {22342, 22343};
b[3] = new int[] {22340, 22345};
b[4] = new int[] {22344, 22345};
b[5] = new int[] {22341, 22343};
c = a;
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
Client client1 = new Client("client1", c[0], c[1]);
client1.exe();
client1.setLocation(0, 200);
client1.setVisible(true);
client1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
});
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
Client client2 = new Client("client2", c[2], c[3]);
client2.exe();
client2.setLocation(400, 200);
client2.setVisible(true);
client2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
});
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
Client client3 = new Client("client3", c[4], c[5]);
client3.exe();
client3.setLocation(800, 200);
client3.setVisible(true);
client3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
});
}
}
__package primary;
import Java.io.EOFException;
import Java.io.IOException;
import Java.io.ObjectInputStream;
import Java.io.ObjectOutputStream;
import Java.net.InetAddress;
import Java.net.ServerSocket;
import Java.net.Socket;
import Java.net.UnknownHostException;
import Java.util.concurrent.*;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
public class Client extends JFrame implements Runnable {
private final String myName;
private ServerSocket listener;
private Socket connection1;
private Socket connection2;
private ObjectOutputStream output1;
private ObjectOutputStream output2;
private ObjectInputStream input1;
private ObjectInputStream input2;
private Object receiveObject;
private Object1 sendObject1;
private Object2 sendObject2;
private final int[] myLocalPort;
private final int[] connectionPort;
private ExecutorService service;
private Future<Boolean> future1;
private Future<Boolean> future2;
public Client(final String myName, int[] myLocalPort, int[] connectionPort) {
super(myName);
this.myName = myName;
this.myLocalPort = myLocalPort;
this.connectionPort = connectionPort;
sendObject1 = new Object1("string1", "string2", myName);
sendObject2 = new Object2("string1", 2.5, 2, true, myName);
initComponents();
}
public void exe() {
ExecutorService eService = Executors.newCachedThreadPool();
eService.execute(this);
}
@Override
public void run() {
try {
displayMessage("Attempting connection\n");
try {
connection1 = new Socket(InetAddress.getByName("localhost"), connectionPort[0], InetAddress.getByName("localhost"), myLocalPort[0]);
displayMessage(myName + " connection1\n");
} catch (Exception e) {
displayMessage("failed1\n");
System.err.println("1" + myName + e.getMessage() + "\n");
}
try {
connection2 = new Socket(InetAddress.getByName("localhost"), connectionPort[1], InetAddress.getByName("localhost"), myLocalPort[1]);
displayMessage(myName + " connection2\n");
} catch (Exception e) {
displayMessage("failed2\n");
System.err.println("2" + myName + e.getMessage() + "\n");
}
displayMessage("Connected to: " + connection1.getInetAddress().getHostName() + "\n\tport: "
+ connection1.getPort() + "\n\tlocal port: " + connection1.getLocalPort() + "\n"
+ connection2.getInetAddress().getHostName() + "\n\tport: " + connection2.getPort()
+ "\n\tlocal port: " + connection2.getLocalPort() + "\n\n");
output1 = new ObjectOutputStream(connection1.getOutputStream());
output1.flush();
output2 = new ObjectOutputStream(connection2.getOutputStream());
output2.flush();
input1 = new ObjectInputStream(connection1.getInputStream());
input2 = new ObjectInputStream(connection2.getInputStream());
displayMessage("Got I/O stream\n");
setTextFieldEditable(true);
service = Executors.newFixedThreadPool(2);
future1 = service.submit(
new Callable<Boolean>() {
@Override
public Boolean call() throws Exception {
try {
processConnection(input1);
displayMessage("input1 finished");
} catch (IOException e) {
displayMessage("blah");
}
return true;
}
});
future2 = service.submit(
new Callable<Boolean>() {
@Override
public Boolean call() throws Exception {
try {
processConnection(input2);
displayMessage("input2 finished");
} catch (IOException e) {
displayMessage("foo");
}
return true;
}
});
} catch (UnknownHostException e) {
displayMessage("UnknownHostException\n");
e.printStackTrace();
} catch (EOFException e) {
displayMessage("EOFException\n");
e.printStackTrace();
} catch (IOException e) {
displayMessage("IOException\n");
e.printStackTrace();
} catch(NullPointerException e) {
System.err.println("asdf " + e.getMessage());
} finally {
try {
displayMessage("i'm here\n");
if((future1 != null && future1.get()) && (future2 != null && future2.get())) {
displayMessage(future1.get() + " " + future2.get() + "\n");
displayMessage("Closing Connection\n");
setTextFieldEditable(false);
if(!connection1.isClosed()) {
output1.close();
input1.close();
connection1.close();
}
if(!connection2.isClosed()) {
output2.close();
input2.close();
connection2.close();
}
displayMessage("connection closed\n");
}
} catch (IOException e) {
displayMessage("IOException on closing");
} catch (InterruptedException e) {
displayMessage("InterruptedException on closing");
} catch (ExecutionException e) {
displayMessage("ExecutionException on closing");
}
}
}//method run ends
private void processConnection(ObjectInputStream input) throws IOException {
String message = "";
do {
try {
receiveObject = input.readObject();
if(receiveObject instanceof String) {
message = (String) receiveObject;
displayMessage(message + "\n");
} else if (receiveObject instanceof Object1) {
Object1 receiveObject1 = (Object1) receiveObject;
displayMessage(receiveObject1.getString1() + " " + receiveObject1.getString2()
+ " " + receiveObject1.toString() + "\n");
} else if (receiveObject instanceof Object2) {
Object2 receiveObject2 = (Object2) receiveObject;
displayMessage(receiveObject2.getString1() + " " + receiveObject2.getD()
+ " " + receiveObject2.getI() + " " + receiveObject2.toString() + "\n");
}
} catch (ClassNotFoundException e) {
displayMessage("Unknown object type received.\n");
}
displayMessage(Boolean.toString(message.equals("terminate\n")));
} while(!message.equals("terminate"));
displayMessage("finished\n");
input = null;
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
dataField = new javax.swing.JTextField();
sendButton1 = new javax.swing.JButton();
sendButton2 = new javax.swing.JButton();
jScrollPane1 = new javax.swing.JScrollPane();
resultArea = new javax.swing.JTextArea();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
dataField.setEditable(false);
dataField.addActionListener(new Java.awt.event.ActionListener() {
public void actionPerformed(Java.awt.event.ActionEvent evt) {
dataFieldActionPerformed(evt);
}
});
sendButton1.setText("Send Object 1");
sendButton1.addActionListener(new Java.awt.event.ActionListener() {
public void actionPerformed(Java.awt.event.ActionEvent evt) {
sendButton1ActionPerformed(evt);
}
});
sendButton2.setText("Send Object 2");
sendButton2.addActionListener(new Java.awt.event.ActionListener() {
public void actionPerformed(Java.awt.event.ActionEvent evt) {
sendButton2ActionPerformed(evt);
}
});
resultArea.setColumns(20);
resultArea.setEditable(false);
resultArea.setRows(5);
jScrollPane1.setViewportView(resultArea);
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
.addComponent(jScrollPane1)
.addComponent(dataField, javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.LEADING, layout.createSequentialGroup()
.addComponent(sendButton1)
.addGap(18, 18, 18)
.addComponent(sendButton2)
.addGap(0, 115, Short.MAX_VALUE)))
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(dataField, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(sendButton1)
.addComponent(sendButton2))
.addGap(18, 18, 18)
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 144, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
);
pack();
}// </editor-fold>
private void dataFieldActionPerformed(Java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
sendData(evt.getActionCommand());
dataField.setText("");
}
private void sendButton1ActionPerformed(Java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
sendData(sendObject1);
}
private void sendButton2ActionPerformed(Java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
sendData(sendObject2);
}
/**
* @param args the command line arguments
*/
private void displayMessage(final String messageToDisplay) {
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
resultArea.append(messageToDisplay);
}
});
}
private void setTextFieldEditable(final boolean editable) {
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
dataField.setEditable(editable);
}
});
}
private void sendData(final Object object) {
try {
output1.writeObject(object);
output1.flush();
output2.writeObject(object);
output2.flush();
displayMessage(myName + ": " + object.toString() + "\n");
} catch (IOException e) {
displayMessage("Error writing object\n");
}
}
// Variables declaration - do not modify
private javax.swing.JTextField dataField;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea resultArea;
private javax.swing.JButton sendButton1;
private javax.swing.JButton sendButton2;
// End of variables declaration
}
_ここで、_Object1_と_Object2_は2つのSerializableオブジェクトです。すべてのソケットが完全に接続されているようです。ソケットとその入力、出力ストリーム、および再実行に対してclose()メソッドを呼び出さずにSystem.exit（）を実行しても、正常に機能します。しかし、close()メソッドが呼び出されていることを確認してSystem.exit（）を実行し、再度実行すると、次のようになります。
_1client2Address already in use: connect
1client3Address already in use: connect
2client3Address already in use: connect
asdf null
1client1Connection refused: connect
2client2Connection refused: connect
asdf null
2client1Connection refused: connect
asdf null
_私は何度も何度も再実行しますが、これを取得し続けます。ただし、一定の時間待ってから再実行しない限り、最初と同じように正常に機能します。
ServerSocketを使用すると、特定のポートで接続をリッスンできます。サーバーソケットが接続を受け入れると、別のスレッドが生成され、接続が別のポートに移動されるため、元のポートは引き続き追加の接続をリッスンできます。
クライアントは、既知のポートで接続を開始します。次に、通常、クライアントが何らかの要求を送信し、サーバーが応答します。これは、通信が完了するまで繰り返されます。これは、Webが使用する単純なクライアント/サーバーアプローチです。
このメカニズムが不要で、リクエストがいつでもどちらかのソケットから送信される可能性がある場合は、リーダースレッドとライタースレッドを適切な方法で実装します。
内部的には、引き続き待機メカニズムを使用しているため、データの到着を待機している間、CPU使用率はそれほど高くありません。
クライアントソケットに接続を受け入れさせることは不可能だと思うので、サーバーソケットとして一方の端が必要だと思います。 ClientSocketは、接続を必要とするTCPを意味します。 UDPを意味するDatagramSocketを使用した場合、接続なしでクライアント間通信を行うことができます。
私はあなたが何を求めているのか理解しています-サーバーが動的IPを備えたマスカレードファイアウォールの背後にある状況で同じ問題を解決する必要がありました。私は、無料で入手できる小さなプログラム javaProxy を使用してソリューションを提供しました。これにより、サーバーがクライアントソケットとして表示されます。内部的にはサーバーのままですが、javaProxyは、サーバーから「から」クライアント接続を作成する転送プログラム（例ではMy App）を提供します。また、2つのクライアントエンド（サーバーから転送されたクライアントソケットと、サーバーに接続しようとしている実際のクライアントからのクライアントソケット）を結合するためのプロキシを中間（例ではミドルサーバー）に提供します。
ミドルサーバーは、ファイアウォールの外側の既知のIPでホストされています。 （サーバーソケットなしでこれを行うふりをすることはできますが、各接続にはクライアントとサーバーエンドが関係している必要があるため、ミドルサーバーがクライアントが到達できるIP上にあることを確認します。）私の場合は、単純なものを使用しました。シェルからJava）を実行させてくれるホスティングプロバイダー。
この設定により、NAT動的IPを備えたファイアウォールの背後で実行されているリモートデスクトップおよびその他のサービスへのアクセスを提供でき、自宅のマシンからのアクセスもNAT動的IPを使用。私が知る必要のあるIPアドレスは、ミドルサーバーのIPだけでした。
スレッド化に関しては、javaproxyライブラリはほぼ確実にスレッドを使用して実装され、クライアントソケット間でデータをポンプしますが、これらはI/Oの待機をブロックしている間、CPUリソース（または電力）を消費しません。 Java 7が非同期I/Oをサポートしてリリースされた場合、クライアントソケットペアごとに1つのスレッドは必要ありませんが、これはパフォーマンスと最大スレッド数（スタック）の制限の回避に関するものです。スペース）消費電力ではなく。
同じプロセスで2つのクライアントソケットを使用してこれを自分で実装する場合、JavaがI/Oのブロックに依存している限り、スレッドを使用する必要があります。モデルは読み取り側からプルされ、プッシュ先書き込み側なので、読み取り側からプルするためにスレッドが必要です（読み取り側からプッシュ、つまり非同期I/Oがある場合、ソケットペアごとに専用のスレッドは必要ありません）。
socket（ネットワーク用語で）は、2つのエンドポイント（クライアントとサーバーアプリ）と2つのstreamsで構成されます。クライアントの出力ストリームはサーバーの入力ストリームであり、その逆も同様です。
ここで、スレッドがストリームに大量のデータを書き込み、誰も読み取らない場合にどうなるかを想像してみてください...バッファはありますが、確かに、無制限ではなく、サイズが異なる場合があります。最終的に、書き込みスレッドはバッファーの制限に達し、誰かがバッファーを解放するまでブロックします。
そうは言っても、これにはストリームごとに少なくとも2つの異なるスレッドが必要になることに注意する必要があります。1つは書き込みバイトを書き込み、もう1つは書き込まれたバイトを読み取ります。
プロトコルが要求/応答スタイルの場合、ソケットごとに2つのスレッドを使用できますが、それ以下ではありません。
アプリケーションのネットワーク部分を置き換えてみることができます。次のように、ネットワーク部分全体を非表示にできる抽象的なインターフェイスを作成するだけです。
interface MyCommunicator{
public void send(MyObject object);
public void addReader(MyReader reader);
}
interface MyReader{ //See Observer Pattern for more details
public void received(MyObject object);
}
このようにして、ネットワーク全体（オブジェクトのエンコードとデコードなどを含む）を簡単に削除し、スレッド化を最小限に抑えることができます。
データバイナリが必要な場合は、代わりにパイプを使用するか、独自のストリームを実装してスレッド化を防ぐことができます。ビジネスロジックまたは処理ロジックはソケットについて認識してはなりません。ストリームは十分に低レベルであり、多分多すぎます。
しかし、どちらの方法でも、スレッドを使いすぎない限り、スレッドは悪くありません。
モックソケットを作成しようとしていますか？その場合、パイプの両側をモックすることは、必要以上に複雑になる可能性があります。
一方、2つのスレッド間にデータパイプを作成するだけの場合は、PipedInputStreamとPipedOutputStreamを使用できます。
ただし、何を達成しようとしているのかについての詳細がなければ、これらの選択肢のいずれかが適切かどうか、または他の何かがより良いかどうかはわかりません。
peer-to-peer接続が必要な場合は、UDPの使用を検討することをお勧めします。
UDPは、最初に接続を確立しなくても何からでも受信できますが、データの受信元をクライアントに通知するサーバーが必要です。
これがお役に立てば幸いです。
Cでは、socketpair（2）を呼び出して、接続されたソケットのペアを取得できますが、Javaに組み込みの方法があるかどうかはわかりません。同じこと。
なぜミドルサーバーが必要なのですか？ VNCServerを公開したいだけの場合。次のようなアーキテクチャを試してみませんか
VNCServer(S) <-> (C)MyApp(S) <-> (C) User
(S) represents a server socket
(C) represents a client socket
この場合、MyAppはクライアント（VNCServerの場合）とサーバー（ユーザーの場合）の両方として機能します。したがって、MyAppにクライアントソケットとサーバーソケットの両方を実装してから、データを中継する必要があります。
編集： VNCServerと通信するには、MyAppはVNCServerのIPを知っている必要があります。ユーザーはMyAppとのみ通信し、MyAppのIPアドレスを知っているだけで済みます。ユーザーはVNCServerのIPアドレスを必要としません。
一般的に、クライアントTCPソケットには2つの端（ローカルと「リモート」）があり、サーバーTCPソケットには1つの端があります（待機しているため）クライアントがサーバーに接続すると、サーバーは内部でクライアントソケットを生成して、通信チャネルを表す接続されたクライアントソケットのペアを形成します。各ソケットはチャネルを一方の端から見るため、これはペアです。どのようにTCP動作するか（高レベルで）。
低レベルの接続プロトコルはそのように機能しないため、TCPで2つのクライアントソケットを相互に接続することはできません。 （接続されたソケットのペアをUnixでそのように作成することはできますが、Javaで公開されておらず、TCPソケットではありません。） can doは、接続を受け入れたらサーバーソケットを閉じることです。単純なケースでは、それで十分かもしれません。
もちろん、UDPソケットは異なりますが、ストリームではなくデータグラムで機能します。これは非常に異なるコミュニケーションモデルです。