โ ์์ผ ํ๋ก๊ทธ๋๋ฐ์ด๋?
- ํ๋ก์ธ์ค ๊ฐ์ ํต์ ์ ์ฌ์ฉ๋๋ ์ ๋๋จ(endpoint)์ธ ์์ผ์ ์ด์ฉํ ํต์ ํ๋ก๊ทธ๋๋ฐ
- ํ๋ก์ธ์ค๋ผ๋ฆฌ๋ ํต์ ์ ํ ๋, ๊ฐ ํ๋ก์ธ์ค์ ์์ผ๋ผ๋ฆฌ ์ฐ๊ฒฐํ๊ณ , ์์ผ์ ํตํด ํต์ ํ๋ค.
- ์์ผ๋ผ๋ฆฌ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ์ฐ๊ฒฐํต๋ก๋ ์ ๋ ฅ์คํธ๋ฆผ๊ณผ ์ถ๋ ฅ์คํธ๋ฆผ์ด๋ค.
- ํต์ ํ๋ ๋ ์์ผ์ ์ ์ถ๋ ฅ์คํธ๋ฆผ์ ๊ต์ฐจ ์ฐ๊ฒฐ๋์ด, ํ์ชฝ ์์ผ์ ์ถ๋ ฅ์ด ๋ค๋ฅธ์ชฝ ์์ผ์ ์ ๋ ฅ์ด ๋๋ค.
โ TCP socket programming ํน์ง
- ์์ผ๋ผ๋ฆฌ ๋จผ์ ์ฐ๊ฒฐํ๊ณ ๋์ ํต์ ์ ์์ํ๋ค. (connection-oriented)
- ํด๋ผ์ด์ธํธ์ ์๋ฒ๋ 1:1๋ก ํต์ ํ๋ค.
- ๋ฐ์ดํฐ๋ฅผ byte-stream์ผ๋ก ์ฃผ๊ณ ๋ฐ๋๋ค.
- ์ ๋ขฐ์ฑ ์๋ ๋ฐ์ดํฐ ์ ์ก์ ํ๋ค.
- ์๋ฐ์์๋ TCP ์์ผ ํ๋ก๊ทธ๋๋ฐ์ ์ํด Socket, ServerSocket ํด๋์ค๋ฅผ ์ด์ฉํ๋ค.
โ ํด๋ผ์ด์ธํธ์ ์๋ฒ ๊ฐ์ ํต์ ๊ณผ์
1) ์๋ฒ ํ๋ก๊ทธ๋จ: ์๋ฒ ์์ผ์ ์์ฑํ๊ณ ํด๋ผ์ด์ธํธ์ ์ฐ๊ฒฐ ์์ฒญ์ ๊ธฐ๋ค๋ฆฐ๋ค.
ServerSocket serverSocket = new ServerSocket(portNumber);
2) ํด๋ผ์ด์ธํธ ํ๋ก๊ทธ๋จ: ์ ์ํ ์๋ฒ์ ip์ฃผ์์ ์๋ฒ์ ํฌํธ๋ฒํธ๋ฅผ ๊ฐ์ง๊ณ ์์ผ์ ์์ฑํ์ฌ ์๋ฒ์ ์ฐ๊ฒฐ์ ์์ฒญํ๋ค.
Socket socket = new Socket(hostIP, portNumber);
3) ์๋ฒ ์์ผ: ํด๋ผ์ด์ธํธ์ ์ฐ๊ฒฐ ์์ฒญ์ ๋ฐ์ผ๋ฉด, ์๋ฒ๋ ์๋ก์ด ์์ผ์ ์์ฑํด์ ํด๋ผ์ด์ธํธ์ ์์ผ๊ณผ ์ฐ๊ฒฐํ๋ค.
Socket newSocket = serverSocket.accept(); // ์๋ฒ๊ฐ ์์ฑํ ์๋ก์ด ์์ผ
4) ์๋ก ์์ฑ๋ ์๋ฒ์ ์์ผ๊ณผ ํด๋ผ์ด์ธํธ ์์ผ์ด ์ฐ๊ฒฐ๋์ด ์๋ก ํต์ ํ๋ค.
โ
์๋ฒ ์์ผ(ServerSocket)์ ์ญํ
- ์๋ฒ์ ํฌํธ์ bindingํ๊ณ ์์ผ๋ฉฐ, ํฌํธ๋ฅผ ํตํด ํด๋ผ์ด์ธํธ์ ์ฐ๊ฒฐ ์์ฒญ์ ๊ธฐ๋ค๋ฆฐ๋ค.
- ์ฐ๊ฒฐ ์์ฒญ์ด ๋ค์ด์ค๋ฉด ์๋ก์ด ์์ผ์ ์์ฑํ์ฌ, ์ฐ๊ฒฐ์ ์์ฒญํ ํด๋ผ์ด์ธํธ์ ์์ผ๊ณผ ํต์ ๊ฐ๋ฅํ๋๋ก ์ฐ๊ฒฐ์์ผ์ค๋ค.
- ์ฆ, ์ค์ ํต์ ์ ์๋ฒ ์์ผ๊ณผ ํ๋ ๊ฒ์ด ์๋๋ค.
- ์ค์ ํต์ ์ ์๋ฒ ์์ผ์ด ๋ง๋ค์ด์ค ์๋ก์ด ์๋ฒ์ธก์ ์์ผ์ด ํ๋ค.
- ์๋๋ ํ๋์ ํฌํธ๋ฅผ ์ฌ๋ฌ ๊ฐ์ ์์ผ์ด ๊ณต์ ํ์ฌ ์ฌ์ฉํ ์ ์์ง๋ง, ์๋ฒ ์์ผ์ ํฌํธ๋ฅผ ๋
์ ํ์ฌ ์ฌ์ฉํ๋ค.
- ์๋ฒ ์์ผ์ด ์ฌ๋ฌ ๊ฐ๋ฉด, ํด๋ผ์ด์ธํธ ์ธก์์ ์ด๋ ๊ณณ์ ์ฐ๊ฒฐ์ ์์ฒญํด์ผ ํ ์ง ๋ชจ๋ฅด๋๊น!!
โ ๊ฐ๋จํ ์์ผ ํ๋ก๊ทธ๋๋ฐ ์์
- ํด๋ผ์ด์ธํธ๊ฐ ์๋ฒ์๊ฒ ๋ฐ์ดํฐ๋ฅผ ๋ณด๋ด๊ณ , ์๋ฒ๋ ๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ํฐ๋ฏธ๋์ ์ถ๋ ฅํ๋ ์๋ฐ ํ๋ก๊ทธ๋จ์ ์์ฑํด ๋ณด์๋ค.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) {
try {
// ์๋ฒ ์์ผ์ ์์ฑํ๊ณ , ํด๋ผ์ด์ธํธ์ ์ฐ๊ฒฐ ์์ฒญ์ ๊ธฐ๋ค๋ฆฐ๋ค.
ServerSocket serverSocket = new ServerSocket(1234);
System.out.println("์๋ฒ ์ฐ๊ฒฐ ์์ฒญ์ ๊ธฐ๋ค๋ฆฌ๋ ์ค...");
// ์ฐ๊ฒฐ ์์ฒญ์ด ๋ค์ด์ค๋ฉด ํด๋ผ์ด์ธํธ์ ์ฐ๊ฒฐ์์ผ์ค ์๋ก์ด ์์ผ์ ์์ฑํ๋ค.
Socket socket = serverSocket.accept();
System.out.println("ํด๋ผ์ด์ธํธ์ ์ฐ๊ฒฐ๋์์ต๋๋ค.");
// ์์ผ์ ์
๋ ฅ์คํธ๋ฆผ
BufferedReader socketIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line;
while ((line = socketIn.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e){
e.printStackTrace();
}
}
}
import java.io.*;
import java.net.Socket;
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 1234);
System.out.println("์๋ฒ์ ์ฐ๊ฒฐ๋์์ต๋๋ค.");
// ํฐ๋ฏธ๋ ์
๋ ฅ๋ฐ์ ๋ฒํผ
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// ์์ผ์ ์ถ๋ ฅ์คํธ๋ฆผ
BufferedWriter socketOut = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
// ํฐ๋ฏธ๋๋ก๋ถํฐ ์
๋ ฅ๋ฐ์ ๋ฌธ์์ด์ ์๋ฒ ์์ผ์ผ๋ก ์ ์กํ๋ค.
String input;
while ((input = reader.readLine()) != null) {
socketOut.write(input);
socketOut.write("\n");
socketOut.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
'๊ฐ์ธ ๊ณต๋ถ > Java, Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] Reflection (0) | 2023.11.17 |
---|---|
[Java] equals(), hashCode() (0) | 2023.10.25 |
[Java] BlockingQueue (0) | 2023.10.18 |
[Java] ์๋ฐ ๋ก๊น (Logging) (0) | 2023.09.06 |
๊ฐ์ฒด์งํฅ์ ํน์ง (0) | 2023.07.24 |