ネットワークプログラミングの基礎の概要
66283 ワード
， ， 。
， ， ， 。 ： ？ ， ， ， ！ ！
( ) 。 ， ， 。 ， API ， 。 ， 。
Java 。
13.1
， ， 。 ， 。
13.1.1
( ) ( ) 。
， ， ： 、 、 。
， ， ， ， 。
， ， 、 ， 。
： ， ， ， ， ， 、 。
， 《 》 ， ， ， ， 。
， ， ？ IP 。
， ， IP 。 , IP IPv4 ， IP 4 0-255 ， 10.0.120.34。 IP ， IP ， ， ， ADSL ， ， IP ， 。
IP ， ， —— (Domain Name)， sohu.com 。 IP ， IP 。 ， ， ， ， 。
， IP ， IP ， DNS ， 。 ， DNS ， IP ， IP ， 。
DNS ， IP ， 。 DNS ， IP 。 IP 。
IP ， ， —— (port)。
， ， ， ， ， ， 。 ， 。 IP ， 。
， ， ， ， ， 。
， 0-65535 ， ， 。 ， ， 。 ， ， 。
IP ， ， IP ， 。 。
， ， IP ， 。
13.1. 2
， ， ， ， ， ， 。 IP ， ， 。
“ - ” 。 ， ， ， ：
：
：XXX
：
：
：
：29
……
， ， ， ， 。 “ - ” 。 ， ， 。
， (Client) ， ， (Server) ， 。 ， ， 。
， ， QQ ， QQ QQ ， QQ ， QQ 。 / ， Client/Server ， C/S 。
C/S ， ， ， ， ， 。 ， ， ， ， ， ， ， 。
， ， ， ， / ， Browser/Server ， B/S 。
B/S ， ， ， 。 ， ， ， 。
C/S B/S ，B/S C/S 。
P2P(Point to Point) ， BT、 。P2P ， P2P ， ， BT， ( )， BT 。 ， P2P ， ， ， ， ， P2P 。
， —— (Protocol)。 ， 。 ， ， ， ， ， 。
， ， 《 》， ， ， 。 ， ， ， ， 。 ， 。
？ 。 ， 。 ， 。
， ， API ， ， 。
， ， IP 、 ， 。
13.1.3
， ：
1、 TCP( )
2、 UDP( )
， 。 ， ： 。 ， 。 ， ， 。
，TCP ， ， ， ， ， 。 UDP ， ， ， ， 。
， TCP ， UDP ， 。
TCP ， TCP ， UDP 。
， ， Java 。
13.2
， ， ， 。
13.2.1
， TCP UDP ， 。 ，B/S 。 ， ， C/S 。
： ， ， ， Java 。
13.2.1.1
(Client) ， ， ， ， ， ：
1、
。 IP ， ， ， 。
2、
， 。 ， ， ， 。
， ， 。
3、
， ， 、 ， 。
， ， 2 ， ， ， 。
13.2.1.2
(Server) ， 。 ， ， ：
1、
， ， ， 。
， IP IP 。
2、
， ， ， IP ， 。
， ， ， 。
3、
。 ， ， 。 ， ， 。
， ， 。
， 。
， 。
4、
， ， ， 。
， 10086 ， 10086 ， ， ， 10086 ， ， ， 。
，10086 ， ， ， 。
， TCP ， ， UDP ， 。
13.2.1.3
， ， ， ， ， ， 。
， ， ， API ， ， ， 。
13.2.2 Java
Java ， Java ， ， Java 。
API java.net ， ， 。 ， WEB 。 ， 。
——InetAddress 。 IP ， IP 。
， ， ：
package inetaddressdemo;
import java.net.*;
/**
* InetAddress
*/
public class InetAddressDemo {
public static void main(String[] args) {
try{
//
InetAddress inet1 = InetAddress.getByName("www.163.com");
System.out.println(inet1);
// IP
InetAddress inet2 = InetAddress.getByName("127.0.0.1");
System.out.println(inet2);
//
InetAddress inet3 = InetAddress.getLocalHost();
System.out.println(inet3);
//
String host = inet3.getHostName();
System.out.println(" ：" + host);
// IP
String ip = inet3.getHostAddress();
System.out.println("IP:" + ip);
}catch(Exception e){}
}
}
， InetAddress ， ， ：
www.163.com/220.181.28.50
/127.0.0.1
chen/192.168.1.100
：chen
IP:192.168.1.100
： ， ， 。
， InetAddress IP ， ， ， IP 。
13.2.3 TCP
， TCP UDP ， TCP ， ， ( )， ( )。 ， ， ， ， ， ， ， ， ， 。
Java ， TCP ， ， java.net.Socket ， java.net.ServerSocket 。 ， ， ， IP 。 ， Java ， Java ， Java ， ，Java IP 。 Java ， 。
TCP ， ， Java 。
， ， Java API java.net.Socket ， ， Socket ， ， ：
Socket socket1 = new Socket(“192.168.1.103”,10000);
Socket socket2 = new Socket(“www.sohu.com”,80);
，socket1 IP 192.168.1.103 10000 ， socket2 www.sohu.com 80 ， ， 。 ， ， ， 。
， ， “ - ” ， Java ， Java IO ， ， ， 。 ：
OutputStream os = socket1.getOutputStream(); //
InputStream is = socket1.getInputStream(); //
， socket1 ， ， IO ， “ - ” ， ， ， ， ， 。
， IO ， ， 。
， ， ， ， ：
socket1.close();
。 ， “Hello”， ， ， ， 。 ：
package tcp;
import java.io.*;
import java.net.*;
/**
* Socket
* ： “Hello” ，
*/
public class SimpleSocketClient {
public static void main(String[] args) {
Socket socket = null;
InputStream is = null;
OutputStream os = null;
// IP
String serverIP = "127.0.0.1";
//
int port = 10000;
//
String data = "Hello";
try {
//
socket = new Socket(serverIP,port);
//
os = socket.getOutputStream();
os.write(data.getBytes());
//
is = socket.getInputStream();
byte[] b = new byte[1024];
int n = is.read(b);
//
System.out.println(" ：" + new String(b,0,n));
} catch (Exception e) {
e.printStackTrace(); //
}finally{
try {
//
is.close();
os.close();
socket.close();
} catch (Exception e2) {}
}
}
}
IP 127.0.0.1， 10000 TCP ， ， “Hello” byte ， ， ， flush 。 ， ， IO ， ， ， ， 。
， TCP ， ， 。
， ， ：
javac –d . SimpleSocketClient.java
java tcp.SimpleSocketClient
SimpleSocketServer ， ：
：Hello
， TCP 。 ， ， 。
， ， ， 。 ：
ServerSocket ss = new ServerSocket(10000);
10000 ， ，10000 ， 。 。
。 ， Socket ， 。 ， ， ， ， 。 ， ， ， 。 ：
Socket socket = ss.accept();
。 accept IO read ， ， ， ， 。 ， ， ， 。
， ， Socket ， ， ， 。 ， ， ， 。
， ， 。 ：
ss.close();
TCP 。 echo ， 。echo “ ”，echo 。 ：
package tcp;
import java.io.*;
import java.net.*;
/**
* echo
* ：
*/
public class SimpleSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
OutputStream os = null;
InputStream is = null;
//
int port = 10000;
try {
//
serverSocket = new ServerSocket(port);
//
socket = serverSocket.accept();
//
is = socket.getInputStream();
byte[] b = new byte[1024];
int n = is.read(b);
//
System.out.println(" ：" + new String(b,0,n));
//
os = socket.getOutputStream();
os.write(b, 0, n);
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//
os.close();
is.close();
socket.close();
serverSocket.close();
}catch(Exception e){}
}
}
}
10000 Socket ， ， ， ， ， 。 ， 。
。
， TCP Java ， ， ， 。
， ， 。
1、 Socket ？
， ， ， ， ， ， 。
， ？ ， ， 。 。 ， ， ， ， ， ：
package tcp;
import java.io.*;
import java.net.*;
/**
* Socket
* ： “Hello” ，
*/
public class MulSocketClient {
public static void main(String[] args) {
Socket socket = null;
InputStream is = null;
OutputStream os = null;
// IP
String serverIP = "127.0.0.1";
//
int port = 10000;
//
String data[] ={"First","Second","Third"};
try {
//
socket = new Socket(serverIP,port);
//
os = socket.getOutputStream();
is = socket.getInputStream();
byte[] b = new byte[1024];
for(int i = 0;i < data.length;i++){
//
os.write(data[i].getBytes());
//
int n = is.read(b);
//
System.out.println(" ：" + new String(b,0,n));
}
} catch (Exception e) {
e.printStackTrace(); //
}finally{
try {
//
is.close();
os.close();
socket.close();
} catch (Exception e2) {}
}
}
}
， for ， ， data 。
， ：
java.net.SocketException: Software caused connection abort: recv failed
at java.net.SocketInputStream.socketRead0(Native Method)
at java.net.SocketInputStream.read(SocketInputStream.java:129)
at java.net.SocketInputStream.read(SocketInputStream.java:90)
at tcp.MulSocketClient.main(MulSocketClient.java:30)
：First
， ， ？ ， ， ， ， 。
， ， ， ：
package tcp;
import java.io.*;
import java.net.*;
/**
* echo
* ：
*/
public class MulSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
OutputStream os = null;
InputStream is = null;
//
int port = 10000;
try {
//
serverSocket = new ServerSocket(port);
System.out.println(" ：");
//
socket = serverSocket.accept();
//
is = socket.getInputStream();
os = socket.getOutputStream();
byte[] b = new byte[1024];
for(int i = 0;i < 3;i++){
int n = is.read(b);
//
System.out.println(" ：" + new String(b,0,n));
//
os.write(b, 0, n);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//
os.close();
is.close();
socket.close();
serverSocket.close();
}catch(Exception e){}
}
}
}
， for ， 3 ， ， 。
， ：
：First
：Second
：Third
：
：
：First
：Second
：Third
， “ - ” ， ， “First” ， “First”， ， “First”， ， “Second” ， “Second”， “Second” ， “Second”， ， 。 ， ， ， ， ， 。
， ， ， ？ ， quit， , ， 。 。
2、 ？
， ， ， ， —— 。
， ， 。 ， ， 。
，MulThreadSocketServer ， ， ，LogicThread ， run 。 ：
package tcp;
import java.net.ServerSocket;
import java.net.Socket;
/**
*
*/
public class MulThreadSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
//
int port = 10000;
try {
//
serverSocket = new ServerSocket(port);
System.out.println(" ：");
while(true){
//
socket = serverSocket.accept();
//
new LogicThread(socket);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//
serverSocket.close();
}catch(Exception e){}
}
}
}
， while ， accept ， ， ， ， LogicThread ， ， 。 ， ， 。
LogicThread ：
package tcp;
import java.io.*;
import java.net.*;
/**
*
*/
public class LogicThread extends Thread {
Socket socket;
InputStream is;
OutputStream os;
public LogicThread(Socket socket){
this.socket = socket;
start(); //
}
public void run(){
byte[] b = new byte[1024];
try{
//
os = socket.getOutputStream();
is = socket.getInputStream();
for(int i = 0;i < 3;i++){
//
int n = is.read(b);
//
byte[] response = logic(b,0,n);
//
os.write(response);
}
}catch(Exception e){
e.printStackTrace();
}finally{
close();
}
}
/**
*
*/
private void close(){
try{
//
os.close();
is.close();
socket.close();
}catch(Exception e){}
}
/**
* , echo
* @param b
* @param off
* @param len
* @return
*/
private byte[] logic(byte[] b,int off,int len){
byte[] response = new byte[len];
// response
System.arraycopy(b, 0, response, 0, len);
return response;
}
}
， ， ， ， ， run ， ， logic ， IO ， b 0， n ， ， logic ，logic echo ， response ， 。
logic ， ， ， 。
， ， ， ， ， 。
， (Thread pool) ， ， 5000 ， 。 ， ， ， 。
TCP ， UDP Java 。
TCP ， UDP 。UDP(User Datagram Protocol)， ， ， ， ， ， TCP ， 。 ， ， ， ， 1%， ， ， ( TCP )， ( UDP )。 ， TCP ， UDP 。
UDP Java ， ， Java API TCP 。 ， java.net 。
Java API ， UDP ， ， ， ：
l DatagramSocket
DatagramSocket “ ”， 。 UDP ， ，DatagramSocket ， 。 TCP ， ， 。
l DatagramPacket
DatagramPacket ， ， 。 UDP ， ， DatagramPacket ， 、 。 DatagramPacket ， ， ， 。 ， DatagramPacket ， 、 ， 。 TCP ，IO UDP ， TCP 。
UDP ， ， UDP Java 。
UDP ， TCP ， ， UDP 。
UDP 4 ： 、 、 。
UDP 。 UDP TCP ， ， IP 。 ：
DatagramSocket ds = new DatagramSocket();
， 。 ， IP ， UDP ， 。
， 。
DatagramSocket ds = new DatagramSocket(5000);
5000 。 。
， UDP 。 UDP ，IO ， ， byte ， 、 IP DatagramPacket ， ， send 。 “Hello” IP 127.0.0.1， 10001 ， ：
String s = “Hello”;
String host = “127.0.0.1”;
int port = 10001;
// byte
byte[] b = s.getBytes();
// IP InetAddress
InetAddress server = InetAddress.getByName(host);
//
DatagramPacket sendDp = new DatagramPacket(b,b.length,server,port);
//
ds.send(sendDp);
， ， byte ， IP InetAddress ， ， DatagramPacket ， UDP ， 、 IP ， DatagramPacket 。 ， ds send DatagramPacket 。
UDP ， ， ， ， ， 。
UDP ， “ - ” ， ， 。
UDP 。 ， 。 Java ： ， ， 。 DatagramPacket ， receive 。 DatagramPacket 。 ：
//
byte[] data = new byte[1024];
//
DatagramPacket received = new DatagramPacket(data,data.length);
//
ds.receive(receiveDp);
//
byte[] b = receiveDp.getData(); //
int len = receiveDp.getLength(); //
String s = new String(b,0,len);
System.out.println(s);
， data， 1024 ， ， ， ， ds receive ， Java ， String ， receive receiveDp ， receiveDp 。 ， ， DatagramPacket getData ， ， ， ， DatagramPacket getLength ， ， 。
UDP 。 UDP ， ， 。 close ， ：
ds.close();
， TCP ，UDP ， IP ， TCP 。
UDP ， UDP 。
UDP TCP ， ， ， ， ， 。
UDP ， ， ：
DatagramSocket ds = new DatagramSocket(10010);
， ， 。 10010 ， 。
， ， receive TCP accept ， ， 。
， ， ， ， IP ， 。 ：
// IP
InetAddress clientIP = receiveDp.getAddress();
//
Int clientPort = receiveDp.getPort();
， receiveDp IP ， ， 。
， ， ， close ， ：
ds.close();
UDP ， UDP 。
， ， “OK”。 ：
package udp;
import java.net.*;
import java.util.*;
/**
* UDP ，
*/
public class SimpleUDPClient {
public static void main(String[] args) {
DatagramSocket ds = null; //
DatagramPacket sendDp; //
DatagramPacket receiveDp; //
String serverHost = "127.0.0.1"; // IP
int serverPort = 10010; //
try{
//
ds = new DatagramSocket();
//
Date d = new Date(); //
String content = d.toString(); //
byte[] data = content.getBytes();
//
InetAddress address = InetAddress.getByName(serverHost);
sendDp = new DatagramPacket(data,data.length,address,serverPort);
//
ds.send(sendDp);
//
byte[] b = new byte[1024];
receiveDp = new DatagramPacket(b,b.length);
//
ds.receive(receiveDp);
// ，
byte[] response = receiveDp.getData();
int len = receiveDp.getLength();
String s = new String(response,0,len);
System.out.println(" ：" + s);
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//
ds.close();
}catch(Exception e){}
}
}
}
， UDP ， ， ， IP ， ， ds send 。 ， ， ds receive ， 。 finally 。
， ：
：OK
：
package udp;
import java.net.*;
/**
* UDP ， ，
“OK"
*/
public class SimpleUDPServer {
public static void main(String[] args) {
DatagramSocket ds = null; //
DatagramPacket sendDp; //
DatagramPacket receiveDp; //
final int PORT = 10010; //
try{
// ，
ds = new DatagramSocket(PORT);
System.out.println(" ：");
//
byte[] b = new byte[1024];
receiveDp = new DatagramPacket(b,b.length);
//
ds.receive(receiveDp);
// ，
InetAddress clientIP = receiveDp.getAddress();
int clientPort = receiveDp.getPort();
byte[] data = receiveDp.getData();
int len = receiveDp.getLength();
System.out.println(" IP：" + clientIP.getHostAddress());
System.out.println(" ：" + clientPort);
System.out.println(" ：" + new String(data,0,len));
//
String response = "OK";
byte[] bData = response.getBytes();
sendDp = new DatagramPacket(bData,bData.length,clientIP,clientPort);
//
ds.send(sendDp);
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//
ds.close();
}catch(Exception e){}
}
}
}
， 10010 ， TCP ， receive ， ， 。 ， ， ， ， IP ， “OK” ， ， ， 。
TCP ， ， ， ， 。
， UDP ， TCP ， “ ”。 ， ， ， ， ， 。
， TCP ， ， 。 ：
package udp;
import java.net.*;
import java.util.*;
/**
* UDP ，
* 3
*/
public class MulUDPClient {
public static void main(String[] args) {
DatagramSocket ds = null; //
DatagramPacket sendDp; //
DatagramPacket receiveDp; //
String serverHost = "127.0.0.1"; // IP
int serverPort = 10012; //
try{
//
ds = new DatagramSocket();
//
InetAddress address = InetAddress.getByName(serverHost);
byte[] b = new byte[1024];
receiveDp = new DatagramPacket(b,b.length);
System.out.println(" ");
// 30 ， 0.01
for(int i = 0;i < 30;i++){
//
Date d = new Date(); //
String content = d.toString(); //
byte[] data = content.getBytes();
//
sendDp = new DatagramPacket(data,data.length,address, serverPort);
//
ds.send(sendDp);
//
Thread.sleep(10);
//
ds.receive(receiveDp);
// ，
byte[] response = receiveDp.getData();
int len = receiveDp.getLength();
String s = new String(response,0,len);
System.out.println(" ：" + s);
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//
ds.close();
}catch(Exception e){}
}
}
}
， for ， ， ， 0.01 。 ， 。
：
package udp;
import java.net.*;
/**
*
* ： ， “OK”
*/
public class MulUDPServer {
public static void main(String[] args) {
DatagramSocket ds = null; //
DatagramPacket receiveDp; //
final int PORT = 10012; //
byte[] b = new byte[1024];
receiveDp = new DatagramPacket(b,b.length);
try{
// ，
ds = new DatagramSocket(PORT);
System.out.println(" ：");
while(true){
//
ds.receive(receiveDp);
//
new LogicThread(ds,receiveDp);
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//
ds.close();
}catch(Exception e){}
}
}
}
， ， LogicThread 。 。
：
package udp;
import java.net.*;
/**
*
*/
public class LogicThread extends Thread {
/** */
DatagramSocket ds;
/** */
DatagramPacket dp;
public LogicThread(DatagramSocket ds,DatagramPacket dp){
this.ds = ds;
this.dp = dp;
start(); //
}
public void run(){
try{
//
byte[] data = dp.getData();
//
int len = dp.getLength();
// IP
InetAddress clientAddress = dp.getAddress();
//
int clientPort = dp.getPort();
//
System.out.println(" IP：" + clientAddress.getHostAddress());
System.out.println(" ：" + clientPort);
System.out.println(" ：" + new String(data,0,len));
//
byte[] b = "OK".getBytes();
DatagramPacket sendDp = new DatagramPacket(b,b.length,clientAddress,clientPort);
//
ds.send(sendDp);
}catch(Exception e){
e.printStackTrace();
}
}
}
， UDP ， ， ， ， ， “OK”。
UDP ， 。 ， 。
UDP ， 。
， 。 ？
。 ， TCP/IP ， 《TCP/IP 》 ， TCP/IP ， 。
， ， ， 。
， 。 “ ” 《 》 ， ， ：
， 。
， ：
：4
：( ， )，
：
：( ， )，
， 。 ， ， ， 。
， 。 ： 。 ， ， 。 ， ： ， 。
， 12 432， ， “12+432”， ， ， ， ， ， ：
“12，432，+” ： ， ，
“12，+，432” ： ， ，
， ， ， “，” 。
， 0 +，1 ，2 ，3 ， ， ：
“12，432，0”
。
， ， ， ， 。 ， ， ， “ ”。 ：
：“1,111,1” ：”-110”
：“123，23，0” ：“146”
：“1，2，5” ：“ ”
， ， ， ， “ 、 、 ” 。
， ， ， QQ ， ， ： 、 、 ， 。 ， ， 。
， ， ， ： ， ， 。 。
， ， ， ， 。
：
1、
2、
：
1、
2、
， ， ， 。 ， 。
， ， ， ， ， 。
， 。
， HTTP(Hyper Text Transfer Protocol， )、FTP(File Transfer Protocol， )，SMTP(Simple Mail Transfer Protocol， ) ， ， RFC 。
， ， ， ， ， ， 。
13.2.6
， ， Java ， ， TCP UDP Java 。
， ， 。
“ ”， ， ， ， ， 。
13.3.1
， ， ， ， ， 。
： 2， 1 。 2 ， ， 。
， ：
1、 ：
a)
b)
c)
d)
e)
f) ，
2、 ：
a)
b)
c)
d) ，
e)
， ， ， 。
：
， byte 。
16， “16”， getBytes byte 。
“quit”
：
1 。 0 ，1 ，2 。
12， 1， 13 0， 0 2。
， ， 。
TCP UDP ， 。 ， 。 UDP ， quit 。
TCP ：
package example1;
import java.io.*;
import java.net.*;
/**
* TCP
*/
public class TCPPrimeClient {
static BufferedReader br;
static Socket socket;
static InputStream is;
static OutputStream os;
/** IP*/
final static String HOST = "127.0.0.1";
/** */
final static int PORT = 10005;
public static void main(String[] args) {
init(); //
while(true){
System.out.println(" ：");
String input = readInput(); //
if(isQuit(input)){ //
byte[] b = "quit".getBytes();
send(b);
break; //
}
if(checkInput(input)){ //
//
send(input.getBytes());
//
byte[] data = receive();
//
parse(data);
}else{
System.out.println(" ， ！");
}
}
close(); //
}
/**
*
*/
private static void init(){
try {
br = new BufferedReader(
new InputStreamReader(System.in));
socket = new Socket(HOST,PORT);
is = socket.getInputStream();
os = socket.getOutputStream();
} catch (Exception e) {}
}
/**
*
*/
private static String readInput(){
try {
return br.readLine();
} catch (Exception e) {
return null;
}
}
/**
* quit
* @param input
* @return true ，false
*/
private static boolean isQuit(String input){
if(input == null){
return false;
}else{
if("quit".equalsIgnoreCase(input)){
return true;
}else{
return false;
}
}
}
/**
*
* @param input
* @return true ，false
*/
private static boolean checkInput(String input){
if(input == null){
return false;
}
try{
int n = Integer.parseInt(input);
if(n >= 2){
return true;
}else{
return false;
}
}catch(Exception e){
return false; //
}
}
/**
*
* @param data
*/
private static void send(byte[] data){
try{
os.write(data);
}catch(Exception e){}
}
/**
*
* @return
*/
private static byte[] receive(){
byte[] b = new byte[1024];
try {
int n = is.read(b);
byte[] data = new byte[n];
//
System.arraycopy(b, 0, data, 0, n);
return data;
} catch (Exception e){}
return null;
}
/**
*
* @param data
*/
private static void parse(byte[] data){
if(data == null){
System.out.println(" ！");
return;
}
byte value = data[0]; // byte
//
switch(value){
case 0:
System.out.println(" ");
break;
case 1:
System.out.println(" ");
break;
case 2:
System.out.println(" ");
break;
}
}
/**
*
*/
private static void close(){
try{
br.close();
is.close();
os.close();
socket.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
， ， ， main 。
TCP ：
package example1;
import java.net.*;
/**
* TCP
*/
public class TCPPrimeServer {
public static void main(String[] args) {
final int PORT = 10005;
ServerSocket ss = null;
try {
ss = new ServerSocket(PORT);
System.out.println(" ：");
while(true){
Socket s = ss.accept();
new PrimeLogicThread(s);
}
} catch (Exception e) {}
finally{
try {
ss.close();
} catch (Exception e2) {}
}
}
}
package example1;
import java.io.*;
import java.net.*;
/**
*
*/
public class PrimeLogicThread extends Thread {
Socket socket;
InputStream is;
OutputStream os;
public PrimeLogicThread(Socket socket){
this.socket = socket;
init();
start();
}
/**
*
*/
private void init(){
try{
is = socket.getInputStream();
os = socket.getOutputStream();
}catch(Exception e){}
}
public void run(){
while(true){
//
byte[] data = receive();
//
if(isQuit(data)){
break; //
}
//
byte[] b = logic(data);
//
send(b);
}
close();
}
/**
*
* @return
*/
private byte[] receive(){
byte[] b = new byte[1024];
try {
int n = is.read(b);
byte[] data = new byte[n];
//
System.arraycopy(b, 0, data, 0, n);
return data;
} catch (Exception e){}
return null;
}
/**
*
* @param data
*/
private void send(byte[] data){
try{
os.write(data);
}catch(Exception e){}
}
/**
* quit
* @return true， false
*/
private boolean isQuit(byte[] data){
if(data == null){
return false;
}else{
String s = new String(data);
if(s.equalsIgnoreCase("quit")){
return true;
}else{
return false;
}
}
}
private byte[] logic(byte[] data){
//
byte[] b = new byte[1];
//
if(data == null){
b[0] = 2;
return b;
}
try{
//
String s = new String(data);
int n = Integer.parseInt(s);
//
if(n >= 2){
boolean flag = isPrime(n);
if(flag){
b[0] = 0;
}else{
b[0] = 1;
}
}else{
b[0] = 2; //
System.out.println(n);
}
}catch(Exception e){
e.printStackTrace();
b[0] = 2;
}
return b;
}
/**
*
* @param n
* @return
*/
private boolean isPrime(int n){
boolean b = true;
for(int i = 2;i <= Math.sqrt(n);i++){
if(n % i == 0){
b = false;
break;
}
}
return b;
}
/**
*
*/
private void close(){
try {
is.close();
os.close();
socket.close();
} catch (Exception e){}
}
}
， ， logic ， ， ， ， ， 。
。 ： ， 【0，50】 ， ， ， ， ， ， 5 ， ， ”quit” 。
， ， ， 。 ： ， ， 。 。
：
1、
2、
3、
4、
：
1、
2、
3、
4、
5、
， ， 。
：
1、 ， byte
2、 “quit”
：
1、 1 ， 0 ( )，1 ，2 ， 。
， 。
：
package guess;
import java.net.*;
import java.io.*;
/**
*
*/
public class TCPClient {
public static void main(String[] args) {
Socket socket = null;
OutputStream os = null;
InputStream is = null;
BufferedReader br = null;
byte[] data = new byte[2];
try{
//
socket = new Socket(
"127.0.0.1",10001);
//
os= socket.getOutputStream();
//
is = socket.getInputStream();
//
br = new BufferedReader(
new InputStreamReader(System.in));
//
while(true){
System.out.println(" ：");
//
String s = br.readLine();
//
if(s.equals("quit")){
os.write("quit".getBytes());
break;
}
//
boolean b = true;
try{
Integer.parseInt(s);
}catch(Exception e){
b = false;
}
if(b){ //
//
os.write(s.getBytes());
//
is.read(data);
//
switch(data[0]){
case 0:
System.out.println(" ！ ！");
break;
case 1:
System.out.println(" ！");
break;
case 2:
System.out.println(" ！");
break;
default:
System.out.println(" ！");
}
//
System.out.println(" " + data[1] + " ！");
// 5
if(data[1] >= 5){
System.out.println(" ！");
//
os.write("quit".getBytes());
//
break;
}
}else{ //
System.out.println(" ！");
}
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//
br.close();
is.close();
os.close();
socket.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
， IP 127.0.0.1 10001 ， ， while ， 。 ， quit ， ， quit， ， “ ！” ， ， 。 ， 。
， ：
package guess;
import java.net.*;
/**
* TCP
* ： ，
*/
public class TCPServer {
public static void main(String[] args) {
try{
//
ServerSocket ss = new ServerSocket(10001);
System.out.println(" ：");
//
while(true){
//
Socket s = ss.accept();
//
new LogicThread(s);
}
}catch(Exception e){
e.printStackTrace();
}
}
}
package guess;
import java.net.*;
import java.io.*;
import java.util.*;
/**
*
*/
public class LogicThread extends Thread {
Socket s;
static Random r = new Random();
public LogicThread(Socket s){
this.s = s;
start(); //
}
public void run(){
// [0，50]
int randomNumber = Math.abs(r.nextInt() % 51);
//
int guessNumber = 0;
InputStream is = null;
OutputStream os = null;
byte[] data = new byte[2];
try{
//
is = s.getInputStream();
//
os = s.getOutputStream();
while(true){ //
//
byte[] b = new byte[1024];
int n = is.read(b);
String send = new String(b,0,n);
//
if(send.equals("quit")){
break;
}
// 、
try{
int num = Integer.parseInt(send);
//
guessNumber++; // 1
data[1] = (byte)guessNumber;
//
if(num > randomNumber){
data[0] = 1;
}else if(num < randomNumber){
data[0] = 2;
}else{
data[0] = 0;
//
guessNumber = 0; //
randomNumber = Math.abs(r.nextInt() % 51);
}
//
os.write(data);
}catch(Exception e){ //
data[0] = 3;
data[1] = (byte)guessNumber;
os.write(data); //
break;
}
os.flush(); //
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
is.close();
os.close();
s.close();
}catch(Exception e){}
}
}
}
， 。 ， ， 。 ， ， ， ， ， ， ， 。
， ， ， ， 。