java的socket通信

所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。经常用于轻量级服务器端和客户端的通信。

 

创建一个Socket对象：
Socket clientPipe = new Socket(localhost,8080);        //连接服务器（需要知道服务器IP+监听端口号）

 

 

实例：

服务器端代码：

import java.net.*; 
import java.io.*; 

public class Server 
{ 
private ServerSocket ss; 
private Socket socket; 
private BufferedReader in; 
private PrintWriter out; 

public Server() { 
try { 
ss = new ServerSocket(10000); 
while (true) { 
socket = ss.accept();      //在有客户端连接前阻塞自己
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));       //输入流
out = new PrintWriter(socket.getOutputStream(),true);        //输出流
String line = in.readLine();          //逐行读取
out.println("you input is :" + line); 
out.close();     //关闭资源
in.close();     //关闭资源
socket.close();     //关闭资源
} 
ss.close();        //关闭资源
} 
catch (IOException e) 
{} 
} 
public static void main(String[] args) { 
new Server(); 
} 
} 

 

客户端代码：

import java.io.*; 
import java.net.*; 

public class Client { 
Socket socket; 
BufferedReader in; 
PrintWriter out; 
public Client() { 
try { 
socket = new Socket("xxx.xxx.xxx.xxx", 10000); 
in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
out = new PrintWriter(socket.getOutputStream(),true); 
BufferedReader line = new BufferedReader(new InputStreamReader(System.in)); 
out.println(line.readLine()); 
line.close(); 
out.close(); 
in.close(); 
socket.close(); 
} 
catch (IOException e) 
{} 
} 
public static void main(String[] args) { 
new Client(); 
} 
} 

 

 

对于需要持续相应客户端请求的服务器端，将相应的逻辑放到while循环中即可：

while(true){
    String reqLine = br.readLine();
    System.out.println("客户请求的消息："+reqLine+" from["+clientIP+"]");
    if(reqLine.equals("exit")){
     System.out.println("客户端退出了！！！ ["+clientIP+"]");
     break;
    }

}

 

 

最后附上可以客户端和持续响应的客户端和服务器端代码（多线程）：

客户端：

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

public class MyClient {
 static PrintWriter pw;
 static String respLine;
 static BufferedReader br ;
 static Socket clientPipe;

 public static void main(String[] args)throws Exception {
  //客户端编程
  String ip = "localhost";
  int port = 1000;
   clientPipe = new Socket(ip,port);//连接服务器（需要知道服务器IP+监听端口号）
  
  System.out.println("客户连接服务器");
  
  while(!respLine.equals("exit")){
  InputStream in =clientPipe.getInputStream();
  OutputStream out = clientPipe.getOutputStream();
  
  //先发送消息，后接收服务器响应消息
   pw = new PrintWriter(out,true);
   String reqLine = null;
  
  System.out.println("请输入您发送给服务器的信息：");
  BufferedReader key = new BufferedReader(new InputStreamReader(System.in));
  respLine = key.readLine();
  System.out.println("reqLine="+respLine);

  pw.println(reqLine);
  
   br = new BufferedReader(new InputStreamReader(in));
  String respLine = br.readLine();
  System.out.println("客户端获得响应消息："+respLine);
  
  //关闭资源
 }
  pw.close();
  br.close();
  clientPipe.close();
 }
}

 

服务器端（两个类）

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 服务器端程序，启动服务器
 * @author Administrator
 *
 */
public class MyServer {
 
 private ServerSocket server = null;
 
 public MyServer(){
  //服务器端编程
  //IP+port
  try {
   server =new ServerSocket(9999);//构造服务器对象
   System.out.println("服务器启动。。。。");
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } 
 }
 public void startServer(){  
  try {
   while(true){
    //等待客户连接
    Socket clientPipe = server.accept();//阻塞（直到客户连接上来，改方法才会返回值）
    //交给线程来服务器当前客户
    WorkerThread wt = new WorkerThread(clientPipe);
    new Thread(wt).start();
   }
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
}

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;

/**
 * 工作线程，专门服务某个客户
 * @author Administrator
 *
 */
public class WorkerThread implements Runnable{
 private Socket clientPipe;
 
 public WorkerThread(Socket clientPipe){
  this.clientPipe = clientPipe;
 }
 public void run(){
  InetAddress addr = clientPipe.getInetAddress();
  String clientIP = addr.getHostName()+":"+clientPipe.getPort();
  System.out.println("客户链接上来了。。。。"+clientIP);
  
  BufferedReader br = null;
  PrintWriter pw = null;
  
  try {
   //连接上来之后，需要接收/响应客户端消息    
   //先接收消息，后响应消息
   br = new BufferedReader(new InputStreamReader(clientPipe.getInputStream()));
   pw = new PrintWriter(clientPipe.getOutputStream(),true);
   
   //与客户多次交互
   while(true){
    String reqLine = br.readLine();
    System.out.println("客户请求的消息："+reqLine+" from["+clientIP+"]");
    if(reqLine.equals("exit")){
     System.out.println("客户端退出了！！！ ["+clientIP+"]");
     break;
    }
    
    String respLine = new StringBuilder(reqLine).reverse().toString();
    pw.println(respLine);
   }
  } catch (IOException e) {
   e.printStackTrace();
  }finally{
   //不交互，关闭之前打开的资源
   try {
    if(pw!=null){
     pw.close();
    }
    if(br!=null){
     br.close();
    }
    if(clientPipe!=null){
     clientPipe.close();
    }
   } catch (IOException e) {     
    e.printStackTrace();
   }
  }
 }
}