java Socket 编程

yanguz123

浏览: 556073 次
性别:
来自: 杭州

最近访客更多访客>>

strawmanTao

xway2000

binashen

yeyinzhu321

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Java EE

一，网络编程中两个主要的问题

一个是如何准确的定位网络上一台或多台主机，另一个就是找到主机后如何可靠高效的进行数据传输。

在TCP/IP协议中IP层主要负责网络主机的定位，数据传输的路由，由IP地址可以唯一地确定Internet上的一台主机。

而TCP层则提供面向应用的可靠（tcp）的或非可靠（UDP）的数据传输机制，这是网络编程的主要对象，一般不需要关心IP层是如何处理数据的。

目前较为流行的网络编程模型是客户机/服务器（C/S）结构。即通信双方一方作为服务器等待客户提出请求并予以响应。客户则在需要服务时向服务器提出申请。服务器一般作为守护进程始终运行，监听网络端口，一旦有客户请求，就会启动一个服务进程来响应该客户，同时自己继续监听服务端口，使后来的客户也能及时得到服务。

二，两类传输协议：TCP；UDP

TCP是Tranfer Control Protocol的简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。

UDP是User Datagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

比较：

UDP：1，每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。

2，UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。

3，UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方

TCP：1，面向连接的协议，在socket之间进行数据传输之前必然要建立连接，所以在TCP中需要连接

时间。

2，TCP传输数据大小限制，一旦连接建立起来，双方的socket就可以按统一的格式传输大的

数据。

3，TCP是一个可靠的协议，它确保接收方完全正确地获取发送方所发送的全部数据。

应用：

1，TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。但是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。

2，UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。例如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。

三，基于Socket的java网络编程

1，什么是Socket

网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面，一个Socket由一个IP地址和一个端口号唯一确定。

但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

2，Socket通讯的过程

Server端Listen(监听)某个端口是否有连接请求，Client端向Server 端发出Connect(连接)请求，Server端向Client端发回Accept（接受）消息。一个连接就建立起来了。Server端和Client 端都可以通过Send，Write等方法与对方通信。

对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：

　　（1）创建Socket；

　　（2）打开连接到Socket的输入/出流；

　　（3）按照一定的协议对Socket进行读/写操作；

　　（4）关闭Socket.（在实际应用中，并未使用到显示的close，虽然很多文章都推荐如此，不过在我的程序中，可能因为程序本身比较简单，要求不高，所以并未造成什么影响。）

3，创建Socket

创建Socket

java在包java.net中提供了两个类Socket和ServerSocket，分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类，使用很方便。其构造方法如下：

　　Socket(InetAddress address, int port);

　　Socket(InetAddress address, int port, boolean stream);

　　Socket(String host, int prot);

　　Socket(String host, int prot, boolean stream);

　　Socket(SocketImpl impl)

　　Socket(String host, int port, InetAddress localAddr, int localPort)

　　Socket(InetAddress address, int port, InetAddress localAddr, int localPort)

　　ServerSocket(int port);

　　ServerSocket(int port, int backlog);

　　ServerSocket(int port, int backlog, InetAddress bindAddr)

　　其中address、host和port分别是双向连接中另一方的IP地址、主机名和端口号，stream指明socket是流socket还是数据报socket，localPort表示本地主机的端口号，localAddr和 bindAddr是本地机器的地址（ServerSocket的主机地址），impl是socket的父类，既可以用来创建serverSocket又可以用来创建Socket。count则表示服务端所能支持的最大连接数。例如：学习视频网 http://www.xxspw.com

　　Socket client = new Socket("127.0.01.", 80);

　　ServerSocket server = new ServerSocket(80);

　　注意，在选择端口时，必须小心。每一个端口提供一种特定的服务，只有给出正确的端口，才能获得相应的服务。0~1023的端口号为系统所保留，例如http服务的端口号为80,telnet服务的端口号为21,ftp服务的端口号为23, 所以我们在选择端口号时，最好选择一个大于1023的数以防止发生冲突。

　　在创建socket时如果发生错误，将产生IOException，在程序中必须对之作出处理。所以在创建Socket或ServerSocket是必须捕获或抛出例外。

4，简单的Client/Server程序

1. 客户端程序

　　import java.io.*;

　　import java.net.*;

　　public class TalkClient {

　　　　public static void main(String args[]) {

　　　　　　try{

　　　　　　　　Socket socket=new Socket("127.0.0.1",4700);

　　　　　　　　//向本机的4700端口发出客户请求

　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));

　　　　　　　　//由系统标准输入设备构造BufferedReader对象

　　　　　　　　PrintWriter os=new PrintWriter(socket.getOutputStream());

　　　　　　　　//由Socket对象得到输出流，并构造PrintWriter对象

　　　　　　　　BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));

　　　　　　　　//由Socket对象得到输入流，并构造相应的BufferedReader对象

　　　　　　　　String readline;

　　　　　　　　readline=sin.readLine(); //从系统标准输入读入一字符串

　　　　　　　　while(!readline.equals("bye")){

　　　　　　　　//若从标准输入读入的字符串为 "bye"则停止循环

　　　　　　　　　　os.println(readline);

　　　　　　　　　　//将从系统标准输入读入的字符串输出到Server

　　　　　　　　　　os.flush();

　　　　　　　　　　//刷新输出流，使Server马上收到该字符串

　　　　　　　　　　System.out.println("Client:"+readline);

　　　　　　　　　　//在系统标准输出上打印读入的字符串

　　　　　　　　　　System.out.println("Server:"+is.readLine());

　　　　　　　　　　//从Server读入一字符串，并打印到标准输出上

　　　　　　　　　　readline=sin.readLine(); //从系统标准输入读入一字符串

　　　　　　　　} //继续循环

　　　　　　　　os.close(); //关闭Socket输出流

　　　　　　　　is.close(); //关闭Socket输入流

　　　　　　　　socket.close(); //关闭Socket

　　　　　　}catch(Exception e) {

　　　　　　　　System.out.println("Error"+e); //出错，则打印出错信息

　　　　　　}

　2. 服务器端程序

　　import java.io.*;

　　import java.net.*;

　　import java.applet.Applet;

　　public class TalkServer{

　　　　public static void main(String args[]) {

　　　　　　try{

　　　　　　　　ServerSocket server=null;

　　　　　　　　try{

　　　　　　　　　　server=new ServerSocket(4700);

　　　　　　　　//创建一个ServerSocket在端口4700监听客户请求

　　　　　　　　}catch(Exception e) {

　　　　　　　　　　System.out.println("can not listen to:"+e);

　　　　　　　　//出错，打印出错信息

　　　　　　　　}

　　　　　　　　Socket socket=null;

　　　　　　　　try{

　　　　　　　　　　socket=server.accept();

　　　　　　　　　　//使用accept()阻塞等待客户请求，有客户

　　　　　　　　　　//请求到来则产生一个Socket对象，并继续执行

　　　　　　　　}catch(Exception e) {

　　　　　　　　　　System.out.println("Error."+e);

　　　　　　　　　　//出错，打印出错信息

　　　　　　　　}

　　　　　　　　String line;

　　　　　　　　BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));

　　　　　　　　　//由Socket对象得到输入流，并构造相应的BufferedReader对象

　　　　　　　　PrintWriter os=newPrintWriter(socket.getOutputStream());

　　　　　　　　　//由Socket对象得到输出流，并构造PrintWriter对象

　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));

　　　　　　　　　//由系统标准输入设备构造BufferedReader对象

　　　　　　　　System.out.println("Client:"+is.readLine());

　　　　　　　　//在标准输出上打印从客户端读入的字符串

　　　　　　　　line=sin.readLine();

　　　　　　　　//从标准输入读入一字符串

　　　　　　　　while(!line.equals("bye")){

　　　　　　　　//如果该字符串为 "bye"，则停止循环

　　　　　　　　　　os.println(line);

　　　　　　　　　　//向客户端输出该字符串

　　　　　　　　　　os.flush();

　　　　　　　　　　//刷新输出流，使Client马上收到该字符串

　　　　　　　　　　System.out.println("Server:"+line);

　　　　　　　　　　//在系统标准输出上打印读入的字符串

　　　　　　　　　　System.out.println("Client:"+is.readLine());

　　　　　　　　　　//从Client读入一字符串，并打印到标准输出上

　　　　　　　　　　line=sin.readLine();

　　　　　　　　　　//从系统标准输入读入一字符串

　　　　　　　　} 　//继续循环

　　　　　　　　os.close(); //关闭Socket输出流

　　　　　　　　is.close(); //关闭Socket输入流

　　　　　　　　socket.close(); //关闭Socket

　　　　　　　　server.close(); //关闭ServerSocket

　　　　　　}catch(Exception e){

　　　　　　　　System.out.println("Error:"+e);

　　　　　　　　//出错，打印出错信息

　　　　　　}

5，支持多客户的client/server程序

前面的Client/Server程序只能实现Server和一个客户的对话。在实际应用中，往往是在服务器上运行一个永久的程序，它可以接收来自其他多个客户端的请求，提供相应的服务。为了实现在服务器方给多个客户提供服务的功能，需要对上面的程序进行改造，利用多线程实现多客户机制。服务器总是在指定的端口上监听是否有客户请求，一旦监听到客户请求，服务器就会启动一个专门的服务线程来响应该客户的请求，而服务器本身在启动完线程之后马上又进入监听状态，等待下一个客户的到来。

多线程Socket编程

1.服务端
package sterning;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.*;
import java.util.concurrent.*;

public class MultiThreadServer {
    private int port=8821;
    private ServerSocket serverSocket;
    private ExecutorService executorService;//线程池
    private final int POOL_SIZE=10;//单个CPU线程池大小

    public MultiThreadServer() throws IOException{
        serverSocket=new ServerSocket(port);
        //Runtime的availableProcessor()方法返回当前系统的CPU数目.
        executorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*POOL_SIZE);
        System.out.println("服务器启动");
    }

    public void service(){
        while(true){
            Socket socket=null;
            try {
                //接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接
                socket=serverSocket.accept();
                executorService.execute(new Handler(socket));

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        new MultiThreadServer().service();
    }

}

class Handler implements Runnable{
    private Socket socket;
    public Handler(Socket socket){
        this.socket=socket;
    }
    private PrintWriter getWriter(Socket socket) throws IOException{
        OutputStream socketOut=socket.getOutputStream();
        return new PrintWriter(socketOut,true);
    }
    private BufferedReader getReader(Socket socket) throws IOException{
        InputStream socketIn=socket.getInputStream();
        return new BufferedReader(new InputStreamReader(socketIn));
    }
    public String echo(String msg){
        return "echo:"+msg;
    }
    public void run(){
        try {
            System.out.println("New connection accepted "+socket.getInetAddress()+":"+socket.getPort());
            BufferedReader br=getReader(socket);
            PrintWriter pw=getWriter(socket);
            String msg=null;
            while((msg=br.readLine())!=null){
                System.out.println(msg);
                pw.println(echo(msg));
                if(msg.equals("bye"))
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(socket!=null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.客户端
package sterning;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadClient {

    public static void main(String[] args) {
        int numTasks = 10;

        ExecutorService exec = Executors.newCachedThreadPool();

        for (int i = 0; i < numTasks; i++) {
            exec.execute(createTask(i));
        }

}

    // 定义一个简单的任务
    private static Runnable createTask(final int taskID) {
        return new Runnable() {
            private Socket socket = null;
            private int port=8821;

            public void run() {
                System.out.println("Task " + taskID + ":start");
                try {
                    socket = new Socket("localhost", port);
                    // 发送关闭命令
                    OutputStream socketOut = socket.getOutputStream();
                    socketOut.write("shutdown/r/n".getBytes());

                    // 接收服务器的反馈
                    BufferedReader br = new BufferedReader(
                            new InputStreamReader(socket.getInputStream()));
                    String msg = null;
                    while ((msg = br.readLine()) != null)
                        System.out.println(msg);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

};
}
}

第一步　充分理解Socket

　　 1.什么是socket

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

　　以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。

　　重要的Socket API：

　　 java.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。

　　 . Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。

　　 . getInputStream方法获得网络连接输入，同时返回一个IutputStream对象实例，。

　　 . getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。

　　注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。

　　 2.如何开发一个Server-Client模型的程序

　　开发原理：

　　服务器，使用ServerSocket监听指定的端口，端口可以随意指定（由于1024以下的端口通常属于保留端口，在一些操作系统中不可以随意使用，所以建议使用大于1024的端口），等待客户连接请求，客户连接后，会话产生；在完成会话后，关闭连接。

　　客户端，使用Socket对网络上某一个服务器的某一个端口发出连接请求，一旦连接成功，打开会话；会话完成后，关闭Socket。客户端不需要指定打开的端口，通常临时的、动态的分配一个1024以上的端口。

　　｛建立服务器｝

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();

}

　　这个程序建立了一个服务器，它一直监听10000端口，等待用户连接。在建立连接后给客户端返回一段信息，然后结束会话。这个程序一次只能接受一个客户连接。

　　｛建立客户端｝

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();

}

　　这个客户端连接到地址为xxx.xxx.xxx.xxx的服务器，端口为10000，并从键盘输入一行信息，发送到服务器，然后接受服务器的返回信息，最后结束会话。

第二步　多个客户同时连接

　　在实际的网络环境里，同一时间只对一个用户服务是不可行的。一个优秀的网络服务程序除了能处理用户的输入信息，还必须能够同时响应多个客户端的连接请求。在java中，实现以上功能特点是非常容易的。

　　设计原理：

　　主程序监听一端口，等待客户接入；同时构造一个线程类，准备接管会话。当一个Socket会话产生后，将这个会话交给线程处理，然后主程序继续监听。运用Thread类或Runnable接口来实现是不错的办法。

　　｛实现消息共享｝

import java.io.*;

import java.net.*;

public class Server extends ServerSocket

{

private static final int SERVER_PORT = 10000;

public Server() throws IOException

{

super(SERVER_PORT);

try

{

while (true)

{

Socket socket = accept();

new CreateServerThread(socket);

}

catch (IOException e)

{}

finally

{

close();

}

//--- CreateServerThread

class CreateServerThread extends Thread

{

private Socket client;

private BufferedReader in;

private PrintWriter out;

public CreateServerThread(Socket s) throws IOException

{

client = s;

in = new BufferedReader(new InputStreamReader(client.getInputStream(), "GB2312"));

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

out.println("--- Welcome ---");

start();

}

public void run()

{

try

{

String line = in.readLine();

while (!line.equals("bye"))

{

String msg = createMessage(line);

out.println(msg);

line = in.readLine();

}

out.println("--- See you, bye! ---");

client.close();

}

catch (IOException e)

{}

}

private String createMessage(String line)

{

xxxxxxxxx;

}

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

{

new Server();

}

　　这个程序监听10000端口，并将接入交给CreateServerThread线程运行。CreateServerThread线程接受输入，并将输入回应客户，直到客户输入"bye"，线程结束。我们可以在createMessage方法中，对输入进行处理，并产生结果，然后把结果返回给客户。第三步实现信息共享:在Socket上的实时交流

　　网络的伟大之一也是信息共享，Server可以主动向所有Client广播消息，同时Client也可以向其它Client发布消息。下面看看如何开发一个可以实时传递消息的程序。

设计原理：

　　服务器端接受客户端的连接请求，同时启动一个线程处理这个连接，线程不停的读取客户端输入，然后把输入加入队列中，等候处理。在线程启动的同时将线程加入队列中，以便在需要的时候定位和取出。

　　｛源码｝

import java.io.*;

import java.net.*;

import java.util.*;

import java.lang.*;

public class Server extends ServerSocket

{

private static ArrayList User_List = new ArrayList();

private static ArrayList Threader = new ArrayList();

private static LinkedList Message_Array = new LinkedList();

private static int Thread_Counter = 0;

private static boolean isClear = true;

protected static final int SERVER_PORT = 10000;

protected FileOutputStream LOG_FILE = new FileOutputStream("d:/connect.log", true);

public Server() throws FileNotFoundException, IOException

{

super(SERVER_PORT);

new Broadcast();

//append connection log

Calendar now = Calendar.getInstance();

String str = "[" + now.getTime().toString() + "] Accepted a connection\015\012";

byte[] tmp = str.getBytes();

LOG_FILE.write(tmp);

try

{

while (true)

{

Socket socket = accept();

new CreateServerThread(socket);

}

finally

{

close();

}

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

{

new Server();

}

//--- Broadcast

class Broadcast extends Thread

{

public Broadcast()

{

start();

}

public void run()

{

while (true)

{

if (!isClear)

{

String tmp = (String)Message_Array.getFirst();

for (int i = 0; i < Threader.size(); i++)

{

CreateServerThread client = (CreateServerThread)Threader.get(i);

client.sendMessage(tmp);

}

Message_Array.removeFirst();

isClear = Message_Array.size() > 0 ? false : true;

}

//--- CreateServerThread

class CreateServerThread extends Thread

{

private Socket client;

private BufferedReader in;

private PrintWriter out;

private String Username;

public CreateServerThread(Socket s) throws IOException

{

client = s;

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

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

out.println("--- Welcome to this chatroom ---");

out.println("Input your nickname:");

start();

}

public void sendMessage(String msg)

{

out.println(msg);

}

public void run()

{

try

{

int flag = 0;

Thread_Counter++;

String line = in.readLine();

while (!line.equals("bye"))

{

if (line.equals("l"))

{

out.println(listOnlineUsers());

line = in.readLine();

continue;

}

if (flag++ == 0)

{

Username = line;

User_List.add(Username);

out.println(listOnlineUsers());

Threader.add(this);

pushMessage("[< " + Username + " come on in >]");

}

else

{

pushMessage("<" + Username + ">" + line);

}

line = in.readLine();

}

out.println("--- See you, bye! ---");

client.close();

}

catch (IOException e)

{}

finally

{

try

{

client.close();

}

catch (IOException e)

{}

Thread_Counter--;

Threader.remove(this);

User_List.remove(Username);

pushMessage("[< " + Username + " left>]");

}

private String listOnlineUsers()

{

String s ="-+- Online list -+-\015\012";

for (int i = 0; i < User_List.size(); i++)

{

s += "[" + User_List.get(i) + "]\015\012";

}

s += "-+---------------------+-";

return s;

}

private void pushMessage(String msg)

{

Message_Array.addLast(msg);

isClear = false;

}

多线程Java Socket编程示例

这篇做为学习孙卫琴<<Java网络编程精解>>的学习笔记吧.其中采用Java 5的ExecutorService来进行线程池的方式实现多线程,模拟客户端多用户向同一服务器端发送请求.

1.服务端

package sterning;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.net.*;

import java.util.concurrent.*;

public class MultiThreadServer {

private int port=8821;

private ServerSocket serverSocket;

private ExecutorService executorService;//线程池

private final int POOL_SIZE=10;//单个CPU线程池大小

public MultiThreadServer() throws IOException{

serverSocket=new ServerSocket(port);

//Runtime的availableProcessor()方法返回当前系统的CPU数目.

executorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*POOL_SIZE);

System.out.println("服务器启动");

}

public void service(){

while(true){

Socket socket=null;

try {

//接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接

socket=serverSocket.accept();

executorService.execute(new Handler(socket));

} catch (Exception e) {

e.printStackTrace();

}

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

new MultiThreadServer().service();

}

class Handler implements Runnable{

private Socket socket;

public Handler(Socket socket){

this.socket=socket;

}

private PrintWriter getWriter(Socket socket) throws IOException{

OutputStream socketOut=socket.getOutputStream();

return new PrintWriter(socketOut,true);

}

private BufferedReader getReader(Socket socket) throws IOException{

InputStream socketIn=socket.getInputStream();

return new BufferedReader(new InputStreamReader(socketIn));

}

public String echo(String msg){

return "echo:"+msg;

}

public void run(){

try {

System.out.println("New connection accepted "+socket.getInetAddress()+":"+socket.getPort());

BufferedReader br=getReader(socket);

PrintWriter pw=getWriter(socket);

String msg=null;

while((msg=br.readLine())!=null){

System.out.println(msg);

pw.println(echo(msg));

if(msg.equals("bye"))

break;

}

} catch (IOException e) {

e.printStackTrace();

}finally{

try {

if(socket!=null)

socket.close();

} catch (IOException e) {

e.printStackTrace();

}

2.客户端

package sterning;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.net.Socket;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class MultiThreadClient {

public static void main(String[] args) {

int numTasks = 10;

ExecutorService exec = Executors.newCachedThreadPool();

for (int i = 0; i < numTasks; i++) {

exec.execute(createTask(i));

}

// 定义一个简单的任务

private static Runnable createTask(final int taskID) {

return new Runnable() {

private Socket socket = null;

private int port=8821;

public void run() {

System.out.println("Task " + taskID + ":start");

try {

socket = new Socket("localhost", port);

// 发送关闭命令

OutputStream socketOut = socket.getOutputStream();

socketOut.write("shutdown\r\n".getBytes());

// 接收服务器的反馈

BufferedReader br = new BufferedReader(

new InputStreamReader(socket.getInputStream()));

String msg = null;

while ((msg = br.readLine()) != null)

System.out.println(msg);

} catch (IOException e) {

e.printStackTrace();

}

};

}

从而实现了多个客户端向服务器端发送请求,服务器端采用多线程的方式来处理的情况.再结合我之前的例子---Java基于Socket文件传输示例,就可以实现多线程文件的传输了

java Socket

端口：每个端口对应一个服务。如：web服务(apache)占用80端口，ftp服务占用21端口，SMTP服务（发送邮件）占用25端口...

套接字：隐藏建立网络连接和在连接上发送数据的复杂问题。

c/s结构：分客户端，服务器端。

Socket类：构建一个套接字。

*getInputStream方法

*getOutputStream方法

获取从套接字而来的数据流读取数据，以及向套接字写入数据流。

*close方法：断开客户端的连接。

ServerSocket类：负责监控某个端口的服务器套接字。

*accept方法：等待建立连接。

例子：

TestClient

-------------------------------------------------------

package com.javaSocket;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.Socket;

import java.net.UnknownHostException;

public class TestClient {

/**

* @param args

public static void main(String[] args) {

try {

Socket s = new Socket("localhost", 9099);

try{

BufferedReader in1 = new BufferedReader(new InputStreamReader(s.getInputStream()));

while(true){

String input = in1.readLine();

if(input == null || input.equals("")){

System.out.println("over.");

break;

}else{

System.out.println(input);

}

}finally{

s.close();

}

} catch (UnknownHostException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

-------------------------------------------------------

TestServer2

-------------------------------------------------------

package com.javaSocket;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Scanner;

public class TestServer2 {

/**

* @param args

public static void main(String[] args) {

try {

ServerSocket s = new ServerSocket(9099);

Socket incoming = s.accept();

try{

InputStream inStream = incoming.getInputStream();

OutputStream outStream = incoming.getOutputStream();

PrintWriter out = new PrintWriter(outStream, true);

out.println("hello！enter bye to exit");

Scanner can = new Scanner(inStream);

boolean isRun = true;

while(isRun && can.hasNextLine()){

String str = can.nextLine();

if(str.equals("bye")){

isRun = false;

out.println("over");

}else{

out.println("try once more...");

}

}finally{

incoming.close();

}

} catch (IOException e) {

e.printStackTrace();

}

套接字超时

1）连接超时

Socket s = new Socket();

s.connect(new InetSocketAddress(host, port), timeout);

2）读/写数据超时

Socket s= new Socket(host, port);

s.setSoTimeout(timeout);

可中断套接字？？

当连接到一个套接字时，当前线程会被阻塞直到建立连接或产生超时为止；

当通过套接字读数据或写数据时，当前线程也会被阻塞直到操作成功或产生超时为止。

调用线程的interrupt方法无法解除一般的Socket阻塞，此时需要使用特殊的套接字--可中断的套接字SocketChannel

SocketChannel channel = SocketChannel.open(new InetSocketAddress(host, port));

半关闭

当客户端程序发送一个请求给服务器时，服务器必须能够确定这个请求何时结束，如：请求中包含一个消息头用于指明请求数据的大小...

半关闭指的是通过关闭一个套接字的输出流来表示发送给服务器的请求数据已经结束，但是输入流必须打开，输入流用来读取服务器返回的响应信息。

关闭一个套接字，就立刻断开了与服务器的连接。

Socket socket = new Socket(host, port);

socket.shutdownOutput();//半关闭，关闭了输出流。

socket.close();//关闭套接字

因特网地址

InetAddress address = InetAddress.getByName(host);//返回任意一个ip

InetAddress[] addresses = InetAddress.getAllByName(host);//一个域名可以对应多个ip

InetAddress address = InetAddress.getLocalHost();//本地主机的因特网地址

例子：

package com.javaSocket;

import java.net.*;

public class TestInetAddress {

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

try {

String ip = InetAddress.getLocalHost().getHostAddress();

System.out.println("ip=" + ip);

} catch (UnknownHostException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

结果：

ip=192.168.0.100（而不是127.0.0.1）

Connection reset by peer的常见原因：

1）服务器的并发连接数超过了其承载量，服务器会将其中一些连接关闭；

如果知道实际连接服务器的并发客户数没有超过服务器的承载量，则有可能是中了病毒或者木马，引起网络流量异常。可以使用netstat -an查看网络连接情况。

2）客户关掉了浏览器，而服务器还在给客户端发送数据；

3）浏览器端按了Stop；

这两种情况一般不会影响服务器。但是如果对异常信息没有特别处理，有可能在服务器的日志文件中，重复出现该异常，造成服务器日志文件过大，影响服务器的运行。可以对引起异常的部分，使用try...catch捕获该异常，然后不输出或者只输出一句提示信息，避免使用e.printStackTrace();输出全部异常信息。

4）防火墙的问题；

如果网络连接通过防火墙，而防火墙一般都会有超时的机制，在网络连接长时间不传输数据时，会关闭这个TCP的会话，关闭后在读写，就会导致异常。如果关闭防火墙，解决了问题，需要重新配置防火墙，或者自己编写程序实现TCP的长连接。实现TCP的长连接，需要自己定义心跳协议，每隔一段时间，发送一次心跳协议，双方维持连接。

5）JSP的buffer问题。

JSP页面缺省缓存为8k，当JSP页面数据比较大的时候，有可能JSP没有完全传递给浏览器。这时可以适当调整buffer的大小。 <%@ page buffer="100k"%>

常见网络异常（转自http://www.cnblogs.com/kaixin110/archive/2008/04/11/1148671.html）：

第1个异常是java.net.BindException:Address already in use: JVM_Bind。该异常发生在服务器端进行new ServerSocket

(port)（port是一个0，65536的整型值）操作时。异常的原因是以为与port一样的一个端口已经被启动，并进行监听。此时用

netstat –an命令，可以看到一个Listending状态的端口。只需要找一个没有被占用的端口就能解决这个问题。

第2个异常是java.net.ConnectException: Connection refused: connect。该异常发生在客户端进行 new Socket(ip, port)

操作时，该异常发生的原因是或者具有ip地址的机器不能找到（也就是说从当前机器不存在到指定ip路由），或者是该ip存在

，但找不到指定的端口进行监听。出现该问题，首先检查客户端的ip和port是否写错了，如果正确则从客户端ping一下服务器

看是否能 ping通，如果能ping通（服务服务器端把ping禁掉则需要另外的办法），则看在服务器端的监听指定端口的程序是否

启动，这个肯定能解决这个问题。

第3个异常是java.net.SocketException: Socket is closed，该异常在客户端和服务器均可能发生。异常的原因是己方主动关

闭了连接后（调用了Socket的close方法）再对网络连接进行读写操作。

第4个异常是java.net.SocketException: （Connection reset或者 Connect reset by peer:Socket write error）。该异常

在客户端和服务器端均有可能发生，引起该异常的原因有两个，第一个就是如果一端的Socket被关闭（或主动关闭或者因为异

常退出而引起的关闭），另一端仍发送数据，发送的第一个数据包引发该异常 (Connect reset by peer)。另一个是一端退出

，但退出时并未关闭该连接，另一端如果在从连接中读数据则抛出该异常（Connection reset）。简单的说就是在连接断开后

的读和写操作引起的。

第5个异常是java.net.SocketException: Broken pipe。该异常在客户端和服务器均有可能发生。在第4个异常的第一种情况中

（也就是抛出SocketExcepton:Connect reset by peer:Socket write error后），如果再继续写数据则抛出该异常。前两个异

常的解决方法是首先确保程序退出前关闭所有的网络连接，其次是要检测对方的关闭连接操作，发现对方关闭连接后自己也要

关闭该连接。

Java Socket的api可能很多人会用，但是Java Socket的参数可能很多人都不知道用来干嘛的，甚至都不知道有这些参数。

backlog

用于ServerSocket，配置ServerSocket的最大客户端等待队列。等待队列的意思，先看下面代码

public class Main {

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

int port = 8999;

int backlog = 2;

ServerSocket serverSocket = new ServerSocket(port, backlog);

Socket clientSock = serverSocket.accept();

System.out.println("revcive from " + clientSock.getPort());

while (true) {

byte buf[] = new byte[1024];

int len = clientSock.getInputStream().read(buf);

System.out.println(new String(buf, 0, len));

}

这段测试代码在第一次处理一个客户端时，就不会处理第二个客户端，所以除了第一个客户端，其他客户端就是等待队列了。所以这个服务器最多可以同时连接3个客户端，其中2个等待队列。大家可以telnet localhost 8999测试下。

这个参数设置为-1表示无限制，默认是50个最大等待队列，如果设置无限制，那么你要小心了，如果你服务器无法处理那么多连接，那么当很多客户端连到你的服务器时，每一个TCP连接都会占用服务器的内存，最后会让服务器崩溃的。

另外，就算你设置了backlog为10，如果你的代码中是一直Socket clientSock = serverSocket.accept(),假设我们的机器最多可以同时处理100个请求，总共有100个线程在运行，然后你把在100个线程的线程池处理clientSock，不能处理的clientSock就排队，最后clientSock越来越多，也意味着TCP连接越来越多，也意味着我们的服务器的内存使用越来越高(客户端连接进程，肯定会发送数据过来，数据会保存到服务器端的TCP接收缓存区)，最后服务器就宕机了。所以如果你不能处理那么多请求，请不要循环无限制地调用serverSocket.accept(),否则backlog也无法生效。如果真的请求过多，只会让你的服务器宕机(相信很多人都是这么写，要注意点)

TcpNoDelay

禁用纳格算法，将数据立即发送出去。纳格算法是以减少封包传送量来增进TCP/IP网络的效能，当我们调用下面代码，如:

Socket socket = new Socket();

socket.connect(new InetSocketAddress(host, 8000));

InputStream in = socket.getInputStream();

OutputStream out = socket.getOutputStream();

String head = "hello ";

String body = "world\r\n";

out.write(head.getBytes());

out.write(body.getBytes());

我们发送了hello，当hello没有收到ack确认(TCP是可靠连接，发送的每一个数据都要收到对方的一个ack确认，否则就要重发)的时候，根据纳格算法，world不会立马发送，会等待，要么等到ack确认(最多等100ms对方会发过来的)，要么等到TCP缓冲区内容>=MSS，很明显这里没有机会，我们写了world后再也没有写数据了，所以只能等到hello的ack我们才会发送world，除非我们禁用纳格算法，数据就会立即发送了。

纳格算法参考:http://zh.wikipedia.org/wiki/%E7%B4%8D%E6%A0%BC%E7%AE%97%E6%B3%95

另外有一篇讲解纳格算法和delay ack的文章(挺不错的):http://blog.csdn.net/frankggyy/article/details/6624401

SoLinger

当我们调用socket.close()返回时，socket已经write的数据未必已经发送到对方了，例如

Socket socket = new Socket();

socket.connect(new InetSocketAddress(host, 8000));

InputStream in = socket.getInputStream();

OutputStream out = socket.getOutputStream();

String head = "hello ";

String body = "world\r\n";

out.write(head.getBytes());

out.write(body.getBytes());

socket.close();

这里调用了socket.close()返回时,hello和world未必已经成功发送到对方了，如果我们设置了linger而不小于0，如:

bool on = true;

int linger = 100;

....

socket.setSoLinger(boolean on, int linger)

......

socket.close();

那么close会等到发送的数据已经确认了才返回。但是如果对方宕机，超时，那么会根据linger设定的时间返回。

UrgentData和OOBInline

TCP的紧急指针，一般都不建议使用，而且不同的TCP/IP实现，也不同，一般说如果你有紧急数据宁愿再建立一个新的TCP/IP连接发送数据，让对方紧急处理。

所以这两个参数，你们可以忽略吧，想知道更多的，自己查下资料。

SoTimeout

设置socket调用InputStream读数据的超时时间，以毫秒为单位，如果超过这个时候，会抛出java.net.SocketTimeoutException。

KeepAlive

keepalive不是说TCP的常连接，当我们作为服务端，一个客户端连接上来，如果设置了keeplive为true，当对方没有发送任何数据过来，超过一个时间(看系统内核参数配置)，那么我们这边会发送一个ack探测包发到对方，探测双方的TCP/IP连接是否有效(对方可能断点，断网)，在Linux好像这个时间是75秒。如果不设置，那么客户端宕机时，服务器永远也不知道客户端宕机了，仍然保存这个失效的连接。

SendBufferSize和ReceiveBufferSize

TCP发送缓存区和接收缓存区,默认是8192，一般情况下足够了，而且就算你增加了发送缓存区，对方没有增加它对应的接收缓冲，那么在TCP三握手时，最后确定的最大发送窗口还是双方最小的那个缓冲区，就算你无视，发了更多的数据，那么多出来的数据也会被丢弃。除非双方都协商好。

以上的参数都是比较重要的Java Socket参数了，其他就不另外说明了。

　Socket是网络上运行的两个程序间双向通讯的一端，它既可以接受请求，也可以发送请求，利用它可以较为方便的编写网络上数据的传递。在Java中，有专门的Socket类来处理用户的请求和响应。利用Socket类的方法，就可以实现两台计算机之间的通讯。这里就介绍一下在Java中如何利用Socket进行网络编程。

　　　　在Java中Socket可以理解为客户端或者服务器端的一个特殊的对象，这个对象有两个关键的方法，一个是getInputStream方法，另一个是getOutputStream方法。getInputStream方法可以得到一个输入流，客户端的Socket对象上的getInputStream方法得到的输入流其实就是从服务器端发回的数据流。GetOutputStream方法得到一个输出流，客户端Socket对象上的getOutputStream方法返回的输出流就是将要发送到服务器端的数据流，（其实是一个缓冲区，暂时存储将要发送过去的数据）。

　　　　程序可以对这些数据流根据需要进行进一步的封装。本文的例子就对这些数据流进行了一定的封装（关于封装可以参考Java中流的实现部分）。

　　　　为了更好的说明问题，这里举了一个网上对话的例子，客户端启动以后，服务器会启动一个线程来与客户进行文字交流。

　　　　要完成这个工作，需要完成三个部分的工作，以下依次说明：

　　　　一、建立服务器类

　　　　Java中有一个专门用来建立Socket服务器的类，名叫ServerSocket,可以用服务器需要使用的端口号作为参数来创建服务器对象。

　　ServerSocket server = new ServerSocket(9998)

　　　　这条语句创建了一个服务器对象，这个服务器使用9998号端口。当一个客户端程序建立一个Socket连接，所连接的端口号为9998时，服务器对象server便响应这个连接，并且server.accept()方法会创建一个Socket对象。服务器端便可以利用这个Socket对象与客户进行通讯。

　　Socket incoming = server.accept()

　　　　进而得到输入流和输出流,并进行封装

　　BufferedReader in = new BufferedReader(new

　　　　　　　　InputStreamReader(incoming.getInputStream()));

　　PrintWriter out = new PrintWriter(incoming.getOutputStream(),true);

　　　　随后，就可以使用in.readLine()方法得到客户端的输入，也可以使用out.println()方法向客户端发送数据。从而可以根据程序的需要对客户端的不同请求进行回应。

　　　　在所有通讯结束以后应该关闭这两个数据流，关闭的顺序是先关闭输出流，再关闭输入流，即使用

　　out.close();

　　in.close();

　　二、建立客户端代码

　　　　相比服务器端，客户端要简单一些，客户端只需用服务器所在机器的ip以及服务器的端口作为参数创建一个Socket对象。得到这个对象后，就可以用"建立服务器"部分介绍的方法实现数据的输入和输出。

　　Socket socket = new Socket("168.160.12.42",9998);

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

　　out = new PrintWriter(socket.getOutputStream(),true);

　　　　以上的程序代码建立了一个Socket对象，这个对象连接到ip地址为168.160.12.42的主机上、端口为9998的服务器对象。并且建立了输入流和输出流，分别对应服务器的输出和客户端的写入。

　　　　三、建立用户界面

　　　　读者可以根据自己的喜好建立自己的用户界面，这不是本文的重点。

　　　　经过以上三个步骤，就可以建立一个比较简单的对话程序。但是，为了使这个程序更加完善，应进行以下几个改进：

　　　　一、现在服务器只能服务一个客户，也就是单线程的。可以将它改进为多线程服务器。

　　try

　　{ file://建立服务器

　　　ServerSocket server = new ServerSocket(9998);

　　　int i=1;

　　　for(;;)

　　　{

　　　　Socket incoming = server.accept();

　　　　new ServerThread(incoming,i).start();

　　　　i++;

　　　}

　　}catch (IOException ex){ ex.printStackTrace(); }

　　　　循环检测是否有客户连接到服务器上，如果有，则创建一个线程来服务这个客户，这个线程的名称是ServerThread，这个类扩展了Thread类，它的编写方法与前述的服务器的写法相同。

　　　　二、为了可以随时得到对方传送过来的消息，可以在服务器以及客户端各建立一个独立的线程来察看输入流，如果输入流中有输入，则可以即时显示出来。代码如下：

　　new Thread()

　　{

　　　public void run()

　　　{

　　　　try

　　　　{　

　　　　　while(true)

　　　　　{

　　　　　　checkInput();

　　　　　　sleep(1000);//每1000毫秒检测一次

　　　　　}

　　　　}catch (InterruptedException ex)

　　　{

　　　}catch(IOException ex)

　　　{

　　　　}

　　}.start();

　　其中的checkInput()方法为

　　private void checkInput() throws IOException

　　{

　　　String line;

　　　if((line=in.readLine())!=null) file://检测输入流中是否有新的数据

　　　　t.setPartner(line); file://将数据流中的消息显示出来

　　}

　　　　通过以上改进，程序就可以比较好的运行了。

　　附：服务器的实现代码

　　import java.net.*;

　　import java.io.*;

　　import java.awt.event.ActionEvent;

　　import java.awt.event.ActionListener;

　　public class talkServer

　　{ public static void main(String[] args)

　　　{ try

　　　　{ file://建立服务器

　　　　　ServerSocket server = new ServerSocket(9998);

　　　　　int i=1;

　　　　　for(;;)

　　　　　　{ Socket incoming = server.accept();

　　　　　　　new ServerThread(incoming,i).start();

　　　　　　　i++;

　　　　　　}

　　　　　}catch (IOException ex){

　　　　　ex.printStackTrace();

　　　　}

　　class ServerThread extends Thread implements ActionListener

　　{

　　　private int threadNum;

　　　private Socket socket;

　　　talkServerFrm t;

　　　BufferedReader in;

　　　PrintWriter out;

　　　private boolean talking=true;

　　　public ServerThread(Socket s,int c)

　　　{ threadNum = c;

　　　　socket = s;

　　　}

　　public void actionPerformed(ActionEvent e)

　　{ Object source = e.getSource();

　　　try{

　　　　if(source==t.btnSend)

　　　　　{ out.println(t.getTalk());

　　　　　　t.clearTalk();

　　　　}else

　　　　if(source==t.btnEnd)

　　　　　{ out.println("谈话过程被对方终止");

　　　　　　out.close();

　　　　　　in.close();

　　　　　　talking = false;

　　　　　}

　　　}catch(IOException ex){

　　　}

　　public void run()

　　{ try{

　　　　t=new talkServerFrm(new Integer(threadNum).toString(),this);

　　　　t.setSize(500,500);

　　　　t.show();

　　　　in = new BufferedReader(new

　　　　　　　 InputStreamReader(socket.getInputStream()));

　　　　out = new PrintWriter(socket.getOutputStream(),true);

　　}catch(Exception e){

　　}

　　　new Thread()

　　　{ public void run()

　　　　{ try{

　　　　　　while(true)

　　　　　　{ checkInput();

　　　　　　　sleep(1000);

　　　　}

　　　}catch (InterruptedException ex){

　　　}catch(IOException ex){

　　　}

　　　}.start();

　　　while(talking)

　　　{ }

　　　t.dispose();

　　　}

　　private void checkInput() throws IOException

　　{ String line;

　　　if((line=in.readLine())!=null)

　　　　t.setPartner(line); file://这是界面类里的方法，

　　　　file://用来将line的内容输出到用户界面

　　　}

直接贴代码，不解释

1 主服务，用来侦听端口

package org.javaren.proxy;

import java.net.ServerSocket;

import java.net.Socket;

public class SocketProxy {

/**

* @param args

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

ServerSocket serverSocket = new ServerSocket(8888);

while (true) {

Socket socket = null;

try {

socket = serverSocket.accept();

new SocketThread(socket).start();

} catch (Exception e) {

e.printStackTrace();

}

2 核心代码，处理链接的代理线程

内部设计了Socket的认证，自己看吧

001

package org.javaren.proxy;

002

003

import java.io.IOException;

004

import java.io.InputStream;

005

import java.io.OutputStream;

006

import java.net.Socket;

007

008

public class SocketThread extends Thread {

009

private Socket socketIn;

010

private InputStream isIn;

011

private OutputStream osIn;

012

013

private Socket socketOut;

014

private InputStream isOut;

015

private OutputStream osOut;

016

017

public SocketThread(Socket socket) {

018

this.socketIn = socket;

019

}

020

021

private byte[] buffer = new byte[4096];

022

private static final byte[] VER = { 0x5, 0x0 };

023

private static final byte[] CONNECT_OK = { 0x5, 0x0, 0x0, 0x1, 0, 0, 0, 0, 0, 0 };

024

025

public void run() {

026

try {

027

System.out.println("\n\na client connect " + socketIn.getInetAddress() + ":" + socketIn.getPort());

028

isIn = socketIn.getInputStream();

029

osIn = socketIn.getOutputStream();

030

int len = isIn.read(buffer);

031

System.out.println("< " + bytesToHexString(buffer, 0, len));

032

osIn.write(VER);

033

osIn.flush();

034

System.out.println("> " + bytesToHexString(VER, 0, VER.length));

035

len = isIn.read(buffer);

036

System.out.println("< " + bytesToHexString(buffer, 0, len));

037

// 查找主机和端口

038

String host = findHost(buffer, 4, 7);

039

int port = findPort(buffer, 8, 9);

040

System.out.println("host=" + host + ",port=" + port);

041

socketOut = new Socket(host, port);

042

isOut = socketOut.getInputStream();

043

osOut = socketOut.getOutputStream();

044

045

for (int i = 4; i <= 9; i++) {

046

CONNECT_OK[i] = buffer[i];

047

}

048

osIn.write(CONNECT_OK);

049

osIn.flush();

050

System.out.println("> " + bytesToHexString(CONNECT_OK, 0, CONNECT_OK.length));

051

SocketThreadOutput out = new SocketThreadOutput(isIn, osOut);

052

out.start();

053

SocketThreadInput in = new SocketThreadInput(isOut, osIn);

054

in.start();

055

out.join();

056

in.join();

057

} catch (Exception e) {

058

System.out.println("a client leave");

059

} finally {

060

try {

061

if (socketIn != null) {

062

socketIn.close();

063

}

064

} catch (IOException e) {

065

e.printStackTrace();

066

}

067

}

068

System.out.println("socket close");

069

}

070

071

public static String findHost(byte[] bArray, int begin, int end) {

072

StringBuffer sb = new StringBuffer();

073

for (int i = begin; i <= end; i++) {

074

sb.append(Integer.toString(0xFF & bArray[i]));

075

sb.append(".");

076

}

077

sb.deleteCharAt(sb.length() - 1);

078

return sb.toString();

079

}

080

081

public static int findPort(byte[] bArray, int begin, int end) {

082

int port = 0;

083

for (int i = begin; i <= end; i++) {

084

port <<= 16;

085

port += bArray[i];

086

}

087

return port;

088

}

089

090

// 4A 7D EB 69

091

// 74 125 235 105

092

public static final String bytesToHexString(byte[] bArray, int begin, int end) {

093

StringBuffer sb = new StringBuffer(bArray.length);

094

String sTemp;

095

for (int i = begin; i < end; i++) {

096

sTemp = Integer.toHexString(0xFF & bArray[i]);

097

if (sTemp.length() < 2)

098

sb.append(0);

099

sb.append(sTemp.toUpperCase());

100

sb.append(" ");

101

}

102

return sb.toString();

103

}

104

}

3 读取线程，负责外面读数据，写入到请求端

package org.javaren.proxy;

/**

* * 从外部读取，向内部发送信息

import java.io.InputStream;

import java.io.OutputStream;

public class SocketThreadInput extends Thread {

private InputStream isOut;

private OutputStream osIn;

public SocketThreadInput(InputStream isOut, OutputStream osIn) {

this.isOut = isOut;

this.osIn = osIn;

}

private byte[] buffer = new byte[409600];

public void run() {

try {

int len;

while ((len = isOut.read(buffer)) != -1) {

if (len > 0) {

System.out.println(new String(buffer, 0, len));

osIn.write(buffer, 0, len);

osIn.flush();

}

} catch (Exception e) {

System.out.println("SocketThreadInput leave");

}

4 写入线程，负责读取请求端数据，写入到目标端

查看源码打印?

package org.javaren.proxy;

import java.io.InputStream;

import java.io.OutputStream;

/**

* 从内部读取，向外部发送信息

* @author zxq

public class SocketThreadOutput extends Thread {

private InputStream isIn;

private OutputStream osOut;

public SocketThreadOutput(InputStream isIn, OutputStream osOut) {

this.isIn = isIn;

this.osOut = osOut;

}

private byte[] buffer = new byte[409600];

public void run() {

try {

int len;

while ((len = isIn.read(buffer)) != -1) {

if (len > 0) {

System.out.println(new String(buffer, 0, len));

osOut.write(buffer, 0, len);

osOut.flush();

}

} catch (Exception e) {

System.out.println("SocketThreadOutput leave");

}

当客户程序需要与服务器程序通讯的时候，客户程序在客户机创建一个socket对象，Socket类有几个构造函数。

两个常用的构造函数是 Socket(InetAddress addr, int port) 和 Socket(String host, int port)，两个构造函数都创建了一个基于Socket的连接服务器端流套接字的流套接字。对于第一个InetAddress子类对象通过addr参数获得服务器主机的IP地址，对于第二个函数host参数包被分配到InetAddress对象中，如果没有IP地址与host参数相一致，那么将抛出UnknownHostException异常对象。两个函数都通过参数port获得服务器的端口号。假设已经建立连接了，网络API将在客户端基于Socket的流套接字中捆绑客户程序的IP地址和任意一个端口号，否则两个函数都会抛出一个IOException对象。

如果创建了一个Socket对象，那么它可能通过调用Socket的 getInputStream()方法从服务程序获得输入流读传送来的信息，也可能通过调用Socket的 getOutputStream()方法获得输出流来发送消息。在读写活动完成之后，客户程序调用close()方法关闭流和流套接字，下面的代码创建了一个服务程序主机地址为198.163.227.6，端口号为13的Socket对象，然后从这个新创建的Socket对象中读取输入流，然后再关闭流和Socket对象。

Socket s = new Socket ("198.163.227.6", 13);

InputStream is = s.getInputStream ();

// Read from the stream.

is.close ();

s.close ();

接下面我们将示范一个流套接字的客户程序，这个程序将创建一个Socket对象，Socket将访问运行在指定主机端口10000上的服务程序，如果访问成功客户程序将给服务程序发送一系列命令并打印服务程序的响应。List2使我们创建的程序SSClient的源代码：

Listing 2: SSClient.java

// SSClient.java

import java.io.*;

import java.net.*;

class SSClient

{

　public static void main (String [] args)

　{

　　String host = "localhost";

　　// If user specifies a command-line argument, that argument

　　// redivsents the host name.

　　if (args.length == 1)

　　　host = args [0];

　　BufferedReader br = null;

　　PrintWriter pw = null;

　　Socket s = null;

　　try

　　{

　　　// Create a socket that attempts to connect to the server

　　　// program on the host at port 10000.

　　　s = new Socket (host, 10000);

　　　// Create an input stream reader that chains to the socket's

　　　// byte-oriented input stream. The input stream reader

　　　// converts bytes read from the socket to characters. The

　　　// conversion is based on the platform's default character

　　　// set.

　　　InputStreamReader isr;

　　　isr = new InputStreamReader (s.getInputStream ());

　　　// Create a buffered reader that chains to the input stream

　　　// reader. The buffered reader supplies a convenient method

　　　// for reading entire lines of text.

　　　br = new BufferedReader (isr);

　　　// Create a print writer that chains to the socket's byte-

　　　// oriented output stream. The print writer creates an

　　　// intermediate output stream writer that converts

　　　// characters sent to the socket to bytes. The conversion

　　　// is based on the platform's default character set.

　　　pw = new PrintWriter (s.getOutputStream (), true);

　　　// Send the DATE command to the server.

　　　pw.println ("DATE");

　　　// Obtain and print the current date/time.

　　　System.out.println (br.readLine ());

　　　// Send the PAUSE command to the server. This allows several

　　　// clients to start and verifies that the server is spawning

　　　// multiple threads.

　　　pw.println ("PAUSE");

　　// Send the DOW command to the server.

　　　pw.println ("DOW");

　　　// Obtain and print the current day of week.

　　　System.out.println (br.readLine ());

　　　// Send the DOM command to the server.

　　　pw.println ("DOM");

　　　// Obtain and print the current day of month.

　　　System.out.println (br.readLine ());

　　　// Send the DOY command to the server.

　　　pw.println ("DOY");

　　　// Obtain and print the current day of year.

　　　System.out.println (br.readLine ());

　　}

　　catch (IOException e)

　　{

　　　System.out.println (e.toString ());

　　}

　　finally

　　{

　　　try

　　　{

　　　　if (br != null)

　　　　　br.close ();

　　　　if (pw != null)

　　　　　pw.close ();

　　　　if (s != null)

　　　　　s.close ();

　　　}

　　　catch (IOException e)

　　　{

　　　　}

运行这段程序将会得到下面的结果：

Tue Jan 29 18:11:51 CST 2002

TUESDAY

SSClient创建了一个Socket对象与运行在主机端口10000的服务程序联系，主机的IP地址由host变量确定。SSClient将获得Socket的输入输出流，围绕BufferedReader的输入流和PrintWriter的输出流对字符串进行读写操作就变得非常容易，SSClient个服务程序发出各种date/time命令并得到响应，每个响应均被打印，一旦最后一个响应被打印，将执行Try/Catch/Finally结构的Finally子串，Finally子串将在关闭Socket之前关闭BufferedReader 和 PrintWriter。

1.Socket传输模式

　　Sockets有两种主要的操作方式:面向连接的和无连接的。面向连接的sockets操作就像一部电话，他们必须建立一个连接和一人呼叫。所有的事情在到达时的顺序与它们出发时的顺序时一样。无连接的sockets操作就像是一个邮件投递，没有什么保证,多个邮件可能在到达时的顺序与出发时的顺序不一样。

　　到底用哪种模式是邮应用程序的需要决定的。假如可靠性更重要的话,用面向连接的操作会好一些.比如文件服务器需要他们的数据的正确性和有序性.假如一些数据丢失了,系统的有效性将会失去。一些服务器，比如间歇性地发送一些数据块.假如数据丢了的话,服务器并不想要再重新发过一次，因为当数据到达的时候,它可能已经过时了.确保数据的有序性和正确性需要额外的操作的内存消耗,额外的费用将会降低系统的回应速率.

　　无连接的操作使用数据报协议.一个数据报是一个独立的单元,它包含了所有的这次投递的信息.把它想象成一个信封吧,它有目的地址和要发送的内容.这个模式下的socket不需要连接一个目的的socket,它只是简单地投出数据报.无连接的操作是快速的和高效的,但是数据安全性不佳.

　　面向连接的操作使用TCP协议.一个这个模式下的socket必须在发送数据之前与目的地的socket取得一个连接.一旦连接建立了,sockets就可以使用一个流接口:打开-读-写-关闭.所有的发送的信息都会在另一端以同样的顺序被接收.面向连接的操作比无连接的操作效率更低,但是数据的安全性更高.

　　SUN一直是网络建设的支持者,所以在java中支持sockets就不足为奇了.实际上,Java降低了建立一个sockets程序的难度.每一个传输模式都被封装到了不同的类中.面向连接的类将会首先被我们讨论.

　　到底用哪种模式是邮应用程序的需要决定的.假如可靠性更重要的话,用面向连接的操作会好一些.比如文件服务器需要他们的数据的正确性和有序性.假如一些数据丢失了,系统的有效性将会失去.一些服务器,比如间歇性地发送一些数据块.假如数据丢了的话,服务器并不想要再重新发过一次.因为当数据到达的时候,它可能已经过时了.确保数据的有序性和正确性需要额外的操作的内存消耗,额外的费用将会降低系统的回应速率.

　　SUN一直是网络建设的支持者,所以在Java中支持sockets就不足为奇了.实际上,Java降低了建立一个sockets程序的难度.每一个传输模式都被封装到了不同的类中.面向连接的类将会首先被我们讨　　

　　2.Java面向连接的类

　　Sockets有两种主要的操作方式:面向连接的和无连接的.面向连接的sockets操作就像一部电话,他们必须建立一个连接和一人呼叫.所有的事情在到达时的顺序与它们出发时的顺序时一样.无连接的sockets操作就像是一个邮件投递,,没有什么保证,多个邮件可能在到达时的顺序与出发时的顺序不一样.

　　SUN一直是网络建设的支持者,所以在Java中支持sockets就不足为奇了.实际上,Java降低了建立一个sockets程序的难度.每一个传输模式都被封装到了不同的类中.面向连接的类将会首先被我们讨论

　　在Java中面向连接的类有两种形式,它们分别是客户端和服务器端.客户端这一部分是最简单的,所以我们先讨论它.

　　列表9.1列出了一个简单的客户端的程序.它向一个服务器发出一个请求,取回一个Html文档,并把它显示在控制台上.

　　9.1一个简单的socket客户端

在SSClient源代码编译完成后，可以输入java SSClient 来执行这段程序，如果有合适的程序运行在不同的主机上，采用主机名/IP地址为参数的输入方式，比如www.sina.com.cn是运行服务器程序的主机，那么输入方式就是java SSClient www.sina.com.cn。

技巧

Socket类包含了许多有用的方法。比如getLocalAddress()将返回一个包含客户程序IP地址的InetAddress子类对象的引用;getLocalPort()将返回客户程序的端口号;getInetAddress()将返回一个包含服务器IP地址的InetAddress子类对象的引用；getPort()将返回服务程序的端口号。

服务器端：

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Date;

public class SocketServer {

public static void main(String[] args) {

SocketServer socketServer = new SocketServer();

socketServer.server();

}

public void server(){

ServerSocket server = null;

try {

server = new ServerSocket(6789);

while(true){

Socket socket = server.accept();

new Thread(new SocketService(socket)).start();

}

} catch (IOException e) {

e.printStackTrace();

}

class SocketService implements Runnable{

Socket socket ;

public SocketService(Socket socket){

this.socket = socket;

}

@Override

public void run() {

try{

DataInputStream in = null;

DataOutputStream out = null;

in = new DataInputStream(socket.getInputStream());

int receiveTag = corvertBigEndianToLittle(in.readInt());

System.out.println("Server receiveTag: " + receiveTag);

int contentLen = corvertBigEndianToLittle(in.readInt());

System.out.println("Server contentLen: " + contentLen);

int receiveStatus = corvertBigEndianToLittle(in.readInt());

System.out.println("Server receiveStatus: " + receiveStatus);

byte[] buffer = new byte[contentLen];

in.read(buffer);

String receiveJson = new String(buffer);

System.out.println("Server receiveJson: " + receiveJson);

out = new DataOutputStream(socket.getOutputStream());

out.writeInt(0);

String jsonStr = "Server send " + new Date() + " " + Math.random();

int reqContentLen = jsonStr.getBytes().length;

int contentLength = corvertBigEndianToLittle(reqContentLen);

System.out.println("Server contentLength: " + contentLength);

out.writeInt(contentLength);

out.writeInt(0);

out.write(jsonStr.getBytes("UTF-8"));

out.flush();

}catch(Exception e){

e.printStackTrace();

}

public static int corvertBigEndianToLittle(int D) {

return ((D << 24) | ((D << 8) & 0x00FF0000) | ((D >>> 8) & 0x0000FF00) | (D >>> 24));

}

客户端：

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.net.Socket;

import java.net.UnknownHostException;

import java.util.Date;

public class SocketClient {

public static void callServerSocket() {

Socket socket = null;

DataOutputStream dout = null;

DataInputStream in = null;

try {

socket = new Socket("172.16.25.30", 6789);

if (socket.isConnected()) {

System.out.println("Connect to serverSocket sucess.");

}

OutputStream netOut = socket.getOutputStream();

dout = new DataOutputStream(netOut);

in = new DataInputStream(socket.getInputStream());

// start send request to server

dout.writeInt(0);

String jsonStr = "Client send " + new Date() + " " + Math.random();

int reqContentLen = jsonStr.getBytes("UTF-8").length;

System.out.println("reqContentLength: " + reqContentLen);

int contentLength = corvertBigEndianToLittle(reqContentLen);

System.out.println("Client contentLength: " + contentLength);

dout.writeInt(contentLength);

dout.writeInt(0);

dout.write(jsonStr.getBytes("UTF-8"));

dout.flush();

// start receive response

int receiveTag = corvertBigEndianToLittle(in.readInt());

System.out.println("Client receiveTag: " + receiveTag);

int contentLen = corvertBigEndianToLittle(in.readInt());

System.out.println("Client contentLen:" + contentLen);

int receiveStatus = corvertBigEndianToLittle(in.readInt());

System.out.println("Client receiveStatus: " + receiveStatus);

byte[] buffer = new byte[contentLen];

in.read(buffer);

String receiveJson = new String(buffer);

System.out.println("Client receiveJson: " + receiveJson);

} catch (UnknownHostException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} finally {

if (socket != null) {

try {

socket.close();

} catch (IOException e) {

}

if (null != dout) {

try {

dout.close();

} catch (IOException e) {

e.printStackTrace();

}

if (null != in) {

try {

in.close();

} catch (IOException e) {

e.printStackTrace();

}

public static int corvertBigEndianToLittle(int D) {

return ((D << 24) | ((D << 8) & 0x00FF0000) | ((D >>> 8) & 0x0000FF00) | (D >>> 24));

}

public static void main(String[] args) {

try {

callServerSocket();

} catch (Exception e) {

}

分享到：

java Derby 介绍 | 打jar包

2013-02-28 15:25
浏览 2149
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论