Socket练习

第一类方法

package socketLianXi;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server1 {  
       
       public static void main(String args[]) throws IOException {  
          //为了简单起见，所有的异常信息都往外抛  
          int port = 8899;  
          //定义一个ServerSocket监听在端口8899上  
          ServerSocket server = new ServerSocket(port);  
          //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的  
          Socket socket = server.accept();  
          //跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。  
          Reader reader = new InputStreamReader(socket.getInputStream());  
          char chars[] = new char[64];  
          int len;  
          StringBuilder sb = new StringBuilder();  
          while ((len=reader.read(chars)) != -1) {  
             sb.append(new String(chars, 0, len));  
          }  
          System.out.println("from client: " + sb);  
          reader.close();  
          socket.close();  
          server.close();  
       }  
         
    }  

package socketLianXi;

import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.Socket;

public class Client1 {  
       
       public static void main(String args[]) throws Exception {  
          //为了简单起见，所有的异常都直接往外抛  
          String host = "127.0.0.1";  //要连接的服务端IP地址  
          int port = 8899;   //要连接的服务端对应的监听端口  
          //与服务端建立连接  
          Socket client = new Socket(host, port);  
          //建立连接后就可以往服务端写数据了  
          Writer writer = new OutputStreamWriter(client.getOutputStream());  
          writer.write("Hello Server.");  
          writer.flush();//写完后要记得flush  
          writer.close();  
          client.close();  
       }  
         
    }  

第二类

package socketLianXi;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.net.ServerSocket;
import java.net.Socket;

public class Server2 {  
       
    public static void main(String args[]) throws IOException {  
          //为了简单起见，所有的异常信息都往外抛  
          int port = 8899;  
          //定义一个ServerSocket监听在端口8899上  
          ServerSocket server = new ServerSocket(port);  
          //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的  
          Socket socket = server.accept();  
          //跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。  
          Reader reader = new InputStreamReader(socket.getInputStream());  
          char chars[] = new char[64];  
          int len;  
          StringBuilder sb = new StringBuilder();  
          String temp;  
          int index;  
          while ((len=reader.read(chars)) != -1) {  
             temp = new String(chars, 0, len);  
             if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收  
                sb.append(temp.substring(0, index));  
                break;  
             }  
             sb.append(temp);  
          }  
          System.out.println("from client: " + sb);  
          //读完后写一句  
          Writer writer = new OutputStreamWriter(socket.getOutputStream());
          
          writer.write("Hello Client.");  
          writer.flush();  
          writer.close();  
          reader.close();  
          socket.close();  
          server.close();  
       }  
         
    } 

package socketLianXi;

import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.net.Socket;

public class Client2 {  
       
       public static void main(String args[]) throws Exception {
          //为了简单起见，所有的异常都直接往外抛  
         String host = "127.0.0.1";  //要连接的服务端IP地址  
         int port = 8899;   //要连接的服务端对应的监听端口  
         //与服务端建立连接  
         Socket client = new Socket(host, port);  
          //建立连接后就可以往服务端写数据了  
         Writer writer = new OutputStreamWriter(client.getOutputStream());  
          writer.write("Hello Server.");  
          writer.write("eof");  
          writer.flush();  
          //写完以后进行读操作  
         Reader reader = new InputStreamReader(client.getInputStream());  
          char chars[] = new char[64];  
          int len;  
          StringBuffer sb = new StringBuffer();  
          String temp;  
          int index;  
          while ((len=reader.read(chars)) != -1) {  
             temp = new String(chars, 0, len);  
             if ((index = temp.indexOf("eof")) != -1) {  
                sb.append(temp.substring(0, index));  
                break;  
             }  
             sb.append(new String(chars, 0, len));  
          }  
          System.out.println("from server: " + sb);  
          writer.close();  
          reader.close();  
          client.close();  
       }  
         
    }

第三类  多个客户访问

package socketLianXi;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.ServerSocket;
import java.net.Socket;

public class Server4 {  
       
       public static void main(String args[]) throws IOException {  
          //为了简单起见，所有的异常信息都往外抛  
         int port = 8899;  
          //定义一个ServerSocket监听在端口8899上  
         ServerSocket server = new ServerSocket(port);  
          while (true) {  
             //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的  
             Socket socket = server.accept();  
             //每接收到一个Socket就建立一个新的线程来处理它  
             new Thread(new Task(socket)).start();  
          }  
       }  
         
       /** 
        * 用来处理Socket请求的 
       */  
       static class Task implements Runnable {  
       
          private Socket socket;  
            
          public Task(Socket socket) {  
             this.socket = socket;  
          }  
            
          public void run() {  
             try {  
                handleSocket();  
             } catch (Exception e) {  
                e.printStackTrace();  
             }  
          }  
            
          /** 
           * 跟客户端Socket进行通信 
          * @throws Exception 
           */  
          private void handleSocket() throws Exception {  
             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
             StringBuilder sb = new StringBuilder();  
             String temp;  
             int index;  
             while ((temp=br.readLine()) != null) {  
                System.out.println(temp);  
                if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收  
                 sb.append(temp.substring(0, index));  
                    break;  
                }  
                sb.append(temp);  
             }  
             System.out.println("from client: " + sb);  
             //读完后写一句  
           Writer writer = new OutputStreamWriter(socket.getOutputStream());  
             writer.write("Hello Client.");  
             writer.write("eof\n");  
             writer.flush();  
             writer.close();  
             br.close();  
             socket.close();  
          }  
       }  
    }  

package socketLianXi;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.Socket;

public class Client4 {  
      
       public static void main(String args[]) throws Exception {  
          //为了简单起见，所有的异常都直接往外抛  
         String host = "127.0.0.1";  //要连接的服务端IP地址  
         int port = 8899;   //要连接的服务端对应的监听端口  
         //与服务端建立连接  
         Socket client = new Socket(host, port);  
          //建立连接后就可以往服务端写数据了  
         Writer writer = new OutputStreamWriter(client.getOutputStream());  
          writer.write("Hello Server.");  
          writer.write("eof\n");  
          writer.flush();  
          //写完以后进行读操作  
         BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));  
          StringBuffer sb = new StringBuffer();  
          String temp;  
          int index;  
          while ((temp=br.readLine()) != null) {  
             if ((index = temp.indexOf("eof")) != -1) {  
                sb.append(temp.substring(0, index));  
                break;  
             }  
             sb.append(temp);  
          }  
          System.out.println("from server: " + sb);  
          writer.close();  
          br.close();  
          client.close();  
       }  
    }  

另外的写法

package socketLianXi;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class MyServer3 { 

public static void main(String[] args) throws IOException{ 

ServerSocket server=new ServerSocket(5679); 

Socket client=server.accept(); 

BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream())); 

PrintWriter out=new PrintWriter(client.getOutputStream()); 
Scanner wt=new Scanner(System.in);
String num="";
while(true){ 
String str=in.readLine(); 
System.out.println("客户说:"+str); 
System.out.print("服务输入:");
num=wt.nextLine();
out.println(num); 
out.flush(); 
if(num.equals("end")) 
break; 
} 
client.close(); 
} 

} 

package socketLianXi;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

public class Client3{ 

static Socket server; 

 

public static void main(String[] args)throws Exception{ 

server=new Socket(InetAddress.getLocalHost(),5679); 

BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream())); 

PrintWriter out=new PrintWriter(server.getOutputStream()); 

//BufferedReader wt=new BufferedReader(new InputStreamReader(System.in)); 
Scanner wt=new Scanner(System.in);
while(true){ 
System.out.println("客户");
String str=wt.nextLine(); 
out.println(str); 
out.flush(); 
if(str.equals("end")){ 
break; 
} 
System.out.println("服务说："+in.readLine()); 
} 
server.close(); 
} 

}

另外方法多客户访问

public class MultiUser extends Thread{ 

private Socket client; 

 

public MultiUser(Socket c){ 

this.client=c; 

} 

 

public void run(){ 

try{ 

BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream())); 

PrintWriter out=new PrintWriter(client.getOutputStream()); 

//Mutil User but can't parallel 

while(true){ 

String str=in.readLine(); 

System.out.println(str); 

out.println("has receive."); 

out.flush(); 

if(str.equals("end")) 

break; 

} 

client.close(); 

}catch(IOException ex){ 

}finally{ 

} 

} 

 

public static void main(String[] args)throws IOException{ 

ServerSocket server=new ServerSocket(5678); 

while(true){ 

//transfer location change Single User or Multi User 

MultiUser mu=new MultiUser(server.accept()); 

mu.start(); 

} 

} 

}