虽能告诉我服务器端最简单的java程序？

153 服务多个客户

JabberServer可以正常工作，但每次只能为一个客户程序提供服务。在典型的服务器中，我们希望同时能处理多个客户的请求。解决这个问题的关键就是多线程处理机制。而对于那些本身不支持多线程的语言，达到这个要求无疑是异常困难的。通过第14章的学习，大家已经知道Java已对多线程的处理进行了尽可能的简化。由于Java的线程处理方式非常直接，所以让服务器控制多名客户并不是件难事。

最基本的方法是在服务器（程序）里创建单个ServerSocket，并调用accept()来等候一个新连接。一旦accept()返回，我们就取得结果获得的Socket，并用它新建一个线程，令其只为那个特定的客户服务。然后再调用accept()，等候下一次新的连接请求。

对于下面这段服务器代码，大家可发现它与JabberServerjava例子非常相似，只是为一个特定的客户提供服务的所有操作都已移入一个独立的线程类中：

//: MultiJabberServerjava

// A server that uses multithreading to handle

// any number of clients

import javaio;

import javanet;

class ServeOneJabber extends Thread {

private Socket socket;

private BufferedReader in;

private PrintWriter out;

public ServeOneJabber(Socket s)

throws IOException {

socket = s;

in =

new BufferedReader(

new InputStreamReader(

socketgetInputStream()));

// Enable auto-flush:

out =

new PrintWriter(

new BufferedWriter(

new OutputStreamWriter(

socketgetOutputStream())), true);

// If any of the above calls throw an

// exception, the caller is responsible for

// closing the socket Otherwise the thread

// will close it

start(); // Calls run()

}

public void run() {

try {

while (true) {

String str = inreadLine();

if (strequals("END")) break;

Systemoutprintln("Echoing: " + str);

outprintln(str);

}

Systemoutprintln("closing");

} catch (IOException e) {

} finally {

try {

socketclose();

} catch(IOException e) {}

}

}

}

public class MultiJabberServer {

static final int PORT = 8080;

public static void main(String[] args)

throws IOException {

ServerSocket s = new ServerSocket(PORT);

Systemoutprintln("Server Started");

try {

while(true) {

// Blocks until a connection occurs:

Socket socket = saccept();

try {

new ServeOneJabber(socket);

} catch(IOException e) {

// If it fails, close the socket,

// otherwise the thread will close it:

socketclose();

}

}

} finally {

sclose();

}

}

} ///:~

每次有新客户请求建立一个连接时，ServeOneJabber线程都会取得由accept()在main()中生成的Socket对象。然后和往常一样，它创建一个BufferedReader，并用Socket自动刷新PrintWriter对象。最后，它调用Thread的特殊方法start()，令其进行线程的初始化，然后调用run()。这里采取的操作与前例是一样的：从套扫字读入某些东西，然后把它原样反馈回去，直到遇到一个特殊的"END"结束标志为止。

同样地，套接字的清除必须进行谨慎的设计。就目前这种情况来说，套接字是在ServeOneJabber外部创建的，所以清除工作可以“共享”。若ServeOneJabber构建器失败，那么只需向调用者“掷”出一个违例即可，然后由调用者负责线程的清除。但假如构建器成功，那么必须由ServeOneJabber对象负责线程的清除，这是在它的run()里进行的。

请注意MultiJabberServer有多么简单。和以前一样，我们创建一个ServerSocket，并调用accept()允许一个新连接的建立。但这一次，accept()的返回值（一个套接字）将传递给用于ServeOneJabber的构建器，由它创建一个新线程，并对那个连接进行控制。连接中断后，线程便可简单地消失。

如果ServerSocket创建失败，则再一次通过main()掷出违例。如果成功，则位于外层的try-finally代码块可以担保正确的清除。位于内层的try-catch块只负责防范ServeOneJabber构建器的失败；若构建器成功，则ServeOneJabber线程会将对应的套接字关掉。

为了证实服务器代码确实能为多名客户提供服务，下面这个程序将创建许多客户（使用线程），并同相同的服务器建立连接。每个线程的“存在时间”都是有限的。一旦到期，就留出空间以便创建一个新线程。允许创建的线程的最大数量是由final int maxthreads决定的。大家会注意到这个值非常关键，因为假如把它设得很大，线程便有可能耗尽资源，并产生不可预知的程序错误。

//: MultiJabberClientjava

// Client that tests the MultiJabberServer

// by starting up multiple clients

import javanet;

import javaio;

class JabberClientThread extends Thread {

private Socket socket;

private BufferedReader in;

private PrintWriter out;

private static int counter = 0;

private int id = counter++;

private static int threadcount = 0;

public static int threadCount() {

return threadcount;

}

public JabberClientThread(InetAddress addr) {

Systemoutprintln("Making client " + id);

threadcount++;

try {

socket =

new Socket(addr, MultiJabberServerPORT);

} catch(IOException e) {

// If the creation of the socket fails,

// nothing needs to be cleaned up

}

try {

in =

new BufferedReader(

new InputStreamReader(

socketgetInputStream()));

// Enable auto-flush:

out =

new PrintWriter(

new BufferedWriter(

new OutputStreamWriter(

socketgetOutputStream())), true);

start();

} catch(IOException e) {

// The socket should be closed on any

// failures other than the socket

// constructor:

try {

socketclose();

} catch(IOException e2) {}

}

// Otherwise the socket will be closed by

// the run() method of the thread

}

public void run() {

try {

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

outprintln("Client " + id + ": " + i);

String str = inreadLine();

Systemoutprintln(str);

}

outprintln("END");

} catch(IOException e) {

} finally {

// Always close it:

try {

socketclose();

} catch(IOException e) {}

threadcount--; // Ending this thread

}

}

}

public class MultiJabberClient {

static final int MAX_THREADS = 40;

public static void main(String[] args)

throws IOException, InterruptedException {

InetAddress addr =

InetAddressgetByName(null);

while(true) {

if(JabberClientThreadthreadCount()

< MAX_THREADS)

new JabberClientThread(addr);

ThreadcurrentThread()sleep(100);

}

}

} ///:~

JabberClientThread构建器获取一个InetAddress，并用它打开一个套接字。大家可能已看出了这样的一个套路：Socket肯定用于创建某种Reader以及／或者Writer（或者InputStream和／或OutputStream）对象，这是运用Socket的唯一方式（当然，我们可考虑编写一、两个类，令其自动完成这些操作，避免大量重复的代码编写工作）。同样地，start()执行线程的初始化，并调用run()。在这里，消息发送给服务器，而来自服务器的信息则在屏幕上回显出来。然而，线程的“存在时间”是有限的，最终都会结束。注意在套接字创建好以后，但在构建器完成之前，假若构建器失败，套接字会被清除。否则，为套接字调用close()的责任便落到了run()方法的头上。

threadcount跟踪计算目前存在的JabberClientThread对象的数量。它将作为构建器的一部分增值，并在run()退出时减值（run()退出意味着线程中止）。在MultiJabberClientmain()中，大家可以看到线程的数量会得到检查。若数量太多，则多余的暂时不创建。方法随后进入“休眠”状态。这样一来，一旦部分线程最后被中止，多作的那些线程就可以创建了。大家可试验一下逐渐增大MAX_THREADS，看看对于你使用的系统来说，建立多少线程（连接）才会使您的系统资源降低到危险程度。

1、首先建立一个包，用户创建一个游标类型create or replace package pkg_query as

type cur_query is ref cursor;

end pkg_query;2、创建存储过程CREATE OR REPLACE PROCEDURE prc_query

(p_tableName in varchar2, --表名

p_strWhere in varchar2, --查询条件

p_orderColumn in varchar2, --排序的列

p_orderStyle in varchar2, --排序方式

p_curPage in out Number, --当前页

p_pageSize in out Number, --每页显示记录条数

p_totalRecords out Number, --总记录数

p_totalPages out Number, --总页数

v_cur out pkg_querycur_query) --返回的结果集

IS

v_sql VARCHAR2(1000) := ''; --sql语句

v_startRecord Number(4); --开始显示的记录条数

v_endRecord Number(4); --结束显示的记录条数

BEGIN

--记录中总记录条数

v_sql := 'SELECT TO_NUMBER(COUNT()) FROM ' || p_tableName || ' WHERE 1=1';

IF p_strWhere IS NOT NULL or p_strWhere <> '' THEN

v_sql := v_sql || p_strWhere;

END IF;

EXECUTE IMMEDIATE v_sql INTO p_totalRecords;

--验证页面记录大小

IF p_pageSize < 0 THEN

p_pageSize := 0;

END IF;

--根据页大小计算总页数

IF MOD(p_totalRecords,p_pageSize) = 0 THEN

p_totalPages := p_totalRecords / p_pageSize;

ELSE

p_totalPages := p_totalRecords / p_pageSize + 1;

END IF;

--验证页号

IF p_curPage < 1 THEN

p_curPage := 1;

END IF;

IF p_curPage > p_totalPages THEN

p_curPage := p_totalPages;

END IF;

--实现分页查询

v_startRecord := (p_curPage - 1) p_pageSize + 1;

v_endRecord := p_curPage p_pageSize;

v_sql := 'SELECT FROM (SELECT A, rownum r FROM ' ||

'(SELECT FROM ' || p_tableName;

IF p_strWhere IS NOT NULL or p_strWhere <> '' THEN

v_sql := v_sql || ' WHERE 1=1' || p_strWhere;

END IF;

IF p_orderColumn IS NOT NULL or p_orderColumn <> '' THEN

v_sql := v_sql || ' ORDER BY ' || p_orderColumn || ' ' || p_orderStyle;

END IF;

v_sql := v_sql || ') A WHERE rownum <= ' || v_endRecord || ') B WHERE r >= '

|| v_startRecord;

DBMS_OUTPUTput_line(v_sql);

OPEN v_cur FOR v_sql;

END prc_query;3、JAVA代码里取出结果集String sql= "{ call prc_query(,,,,,,,,) }";

CallableStatement call = conprepareCall(sql);// ……中间数据设置及注册省略callregisterOutParameter(9, OracleTypesCURSOR);// 取出结果集(ResultSet) callgetObject(9);

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

一、建立服务器类

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

ServerSocket server = new ServerSocket(9998)

这条语句创建了一个服务器对象，这个服务器使用9998号端口即在端口9998上注册服务，这里稍微要注意的是端口的分配必须是唯一的。因为端口是为了唯一标识每台计算机唯一服务的，另外端口号是从0~65535之间的，前1024个端口已经被Tcp/Ip 作为保留端口，因此你所分配的端口只能是1024个之后的。当一个客户端程序建立一个Socket连接，所连接的端口号为9998时，服务器对象server便响应这个连接，并且serveraccept()方法会创建一个Socket对象。服务器端便可以利用这个Socket对象与客户进行通讯。

Socket incoming = serveraccept() ; // 监听窗口,等待连接

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

BufferedReader in = new BufferedReader(new

InputStreamReader(incominggetInputStream()));

/

当读取文件时，先把内容读到缓存中，当调用inreadLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。

/

PrintWriter ut = new PrintWriter(incominggetOutputStream(),true);

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

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

outclose();

inclose();

二、建立客户端代码

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

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

或：

Socket socket = new Socket(InetAddressgetLocalHost(),5678); // 向主机名为InetAddressgetLocalHost()的服务器申请连接

客户机必须知道有关服务器的IP地址，对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供，它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法。

in = new BufferedReader(new InputStreamReader(socketgetInputStream()));

out = new PrintWriter(socketgetOutputStream(),true);

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

三、实例分析

服务方:

import javaio;

import javanet;

public class MyServer {

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

ServerSocket server=new ServerSocket(5678); //在端口5678上注册服务

Socket client=serveraccept(); // 监听窗口,等待连接

BufferedReader in=new BufferedReader(new InputStreamReader(clientgetInputStream()));

BufferedReader serverInput=new BufferedReader(new InputStreamReader(Systemin));

PrintWriter ut=new PrintWriter(clientgetOutputStream());

while(true){

String str=inreadLine(); //// 读取从client传来的数据信息

str = serverInputreadLine(); // 读取用户键盘输入的字符串

Systemoutprintln(str); //服务器控制台输出数据信息

outprintln("has receive"); //服务器向客户端发送信息:has receive

outflush();

if(strequals("end"))

break;

}

clientclose();

}

}

这个程序的主要目的在于服务器不断接收客户机所写入的信息只到，客户机发送"End"字符串就退出程序，并且服务器也会做出"Receive"为回应，告知客户机已接收到消息。

客户机代码:

import javanet;

import javaio;

public class Client{

static Socket server;

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

server=new Socket(InetAddressgetLocalHost(),5678); // 向主机名为InetAddressgetLocalHost()的服务器申请连接

BufferedReader in=new BufferedReader(new InputStreamReader(servergetInputStream())); //客户端建立输入流并进行封装

PrintWriter ut=new PrintWriter(servergetOutputStream());

BufferedReader wt=new BufferedReader(new InputStreamReader(Systemin)); //客户端从键盘输入信息

while(true){

String str=wtreadLine(); //客户端读取（获得）键盘的字符串

String str1=inreadLine(); // 从服务器获得字符串

outprintln(str); //客户端向服务器发送信息

outflush();

if(strequals("end")){

break;

}

Systemoutprintln(inreadLine());

}

serverclose();

}

}

客户机代码则是接受客户键盘输入,并把该信息输出，然后输出"End"用来做退出标识。

这个程序只是简单的两台计算机之间的通讯，如果是多个客户同时访问一个服务器呢？你可以试着再运行一个客户端，结果是会抛出异常的。那么多个客户端如何实现呢

其实,简单的分析一下，就可以看出客户和服务通讯的主要通道就是Socket本身，而服务器通过accept方法就是同意和客户建立通讯这样当客户建立Socket的同时。服务器也会使用这一根连线来先后通讯，那么既然如此只要我们存在多条连线就可以了。那么我们的程序可以变为如下:

服务器:

import javaio;

import javanet;

public class MyServer {

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

ServerSocket server=new ServerSocket(5678);

while(true){

Socket client=serveraccept();

BufferedReader in=new BufferedReader(new InputStreamReader(clientgetInputStream()));

PrintWriter ut=new PrintWriter(clientgetOutputStream());

while(true){

String str=inreadLine();

Systemoutprintln(str);

outprintln("has receive");

outflush();

if(strequals("end"))

break;

}

clientclose();

}

}

}

这里仅仅只是加了一个外层的While循环，这个循环的目的就是当一个客户进来就为它分配一个Socket直到这个客户完成一次和服务器的交互，这里也就是接受到客户的"End"消息那么现在就实现了多客户之间的交互了。但是问题又来了，这样做虽然解决了多客户,可是是排队执行的。也就是说当一个客户和服务器完成一次通讯之后下一个客户才可以进来和服务器交互，无法做到同时服务，那么要如何才能同时达到既能相互之间交流又能同时交流呢？很显然这是一个并行执行的问题了。所以线程是最好的解决方案。

那么下面的问题是如何使用线程首先要做的事情是创建线程并使得其可以和网络连线取得联系。然后由线程来执行刚才的操作，要创建线程要么直接继承Thread要么实现Runnable接口，要建立和Socket的联系只要传递引用就可以了而要执行线程就必须重写run方法，而run方法所做的事情就是刚才单线程版本main所做的事情，因此我们的程序变成了这样:

import javanet;

import javaio;

public class MultiUser extends Thread{

private Socket client;

public MultiUser(Socket c){

thisclient=c;

}

public void run(){

try{

BufferedReader in=new BufferedReader(new InputStreamReader(clientgetInputStream()));

PrintWriter ut=new PrintWriter(clientgetOutputStream());

//Mutil User but can't parallel

while(true){

String str=inreadLine();

Systemoutprintln(str);

outprintln("has receive");

outflush();

if(strequals("end"))

break;

}

clientclose();

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

mustart();

}

}

}

我的类直接从Thread类继承了下来并且通过构造函数传递引用和客户Socket建立了联系，这样每个线程就有了。一个通讯管道同样我们可以填写run方法，把之前的操作交给线程来完成，这样多客户并行的Socket就建立起来了。