javaserverclient

‘壹’ java socket编程中sever和client互相传送数字

importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.OutputStream;
importjava.io.PrintStream;
importjava.net.InetAddress;
importjava.net.Socket;
importjava.net.UnknownHostException;

/**
*测试客户端类
*/
publicclassASCIIClient
{
	Stringstr=null;

	SocketClientsc=null;

	BufferedReaderbr=null;

	publicASCIIClient()
	{
		sc=newSocketClient("localhost",8080);
		br=newBufferedReader(newInputStreamReader(System.in));
		while(true)
		{
			try
			{
				str=br.readLine();
				if(!str.matches("^([0-9]|[1-9]\d|1[01]\d|12[0-7]|-1)$"))
				{
					System.out.println("Pleaseinput-1~127");
				}
				elseif("-1".equals(str))
				{
					sc.sendRequest(str);
					System.out.println("
closing...");
					sc.destroy();
					System.exit(0);
					break;
				}
				else
				{
					sc.sendRequest(str);
					sc.getResponse();
				}
			}
			catch(Exceptione)
			{
				System.err.println(e.toString());
				sc.destroy();
				System.exit(-1);
			}
		}
	}

	publicstaticvoidmain(Stringargs[])
	{
		newASCIIClient();
	}
}

classSocketClient
{
	Socketsocket=null;

	PrintStreamps=null;

	BufferedReaderbr=null;

	OutputStreamos=null;

	InputStreamis=null;

	publicSocketClient(Stringip,intport)
	{
		try
		{
			socket=newSocket(ip,port);
			InetAddressaddr=socket.getLocalAddress();
			System.out.println("addr="+addr.getHostName()+"/"+addr.getHostAddress());
			System.out.println("socket="+socket);
			os=socket.getOutputStream();
			is=socket.getInputStream();
			ps=newPrintStream(os);
			br=newBufferedReader(newInputStreamReader(is));
		}
		catch(UnknownHostExceptione)
		{
			System.err.println("未知服务器地址..."+e.toString());
			destroy();
			System.exit(-1);
		}
		catch(IOExceptione)
		{
			System.err.println("连接服务器失败..."+e.toString());
			destroy();
			System.exit(-1);
		}
	}

	publicvoidsendRequest(Stringrequest)
	{
		ps.println(request);
		System.out.print("Sent:"+request);
	}

	publicStringgetResponse()
	{
		Stringresponse=null;
		try
		{
			response=br.readLine();
			System.out.println("Received:"+response);
		}
		catch(IOExceptione)
		{
			System.err.println("获取响应失败..."+e.toString());
			System.exit(-1);
		}
		returnresponse;
	}

	publicvoiddestroy()
	{
		try
		{
			if(null!=br)
			{
				br.close();
			}
			if(null!=is)
			{
				is.close();
			}
			if(null!=ps)
			{
				ps.close();
			}
			if(null!=os)
			{
				os.close();
			}
			if(null!=socket)
			{
				socket.close();
			}
		}
		catch(IOExceptionignore)
		{}
	}
}


///////////////////////////////////////////////////////////////


importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.OutputStream;
importjava.io.PrintStream;
importjava.net.ServerSocket;
importjava.net.Socket;

/**
*测试服务器类
*/
publicclassASCIIServer
{
	SocketServerss=null;

	BufferedReaderbr=null;

	Stringrequest="";

	publicASCIIServer()
	{
		ss=newSocketServer("localhost",8080);
		br=newBufferedReader(newInputStreamReader(System.in));
		try
		{
			while(true)
			{
				request=ss.getRequest();
				if("-1".equals(request))
				{
					System.out.println("
closing...");
					ss.destroy();
					System.exit(0);
					break;
				}
				else
				{
					charc=(char)(Integer.parseInt(request));
					ss.sendResponse(c+"");
				}
			}
		}
		catch(Exceptione)
		{
			System.err.println(e.toString());
			ss.destroy();
			System.exit(-1);
		}
	}

	publicstaticvoidmain(Stringargs[])
	{
		newASCIIServer();
	}
}

classSocketServer
{
	ServerSocketserverSocket=null;

	SocketclientSocket=null;

	PrintStreamps=null;

	OutputStreamos=null;

	InputStreamis=null;

	BufferedReaderbr=null;

	publicSocketServer(Stringip,intport)
	{
		try
		{
			serverSocket=newServerSocket(port);
			System.out.println("ServerStarted:"+serverSocket);
			clientSocket=serverSocket.accept();
			System.out.println("Connectionaccepted:"+clientSocket);
			os=clientSocket.getOutputStream();
			is=clientSocket.getInputStream();
			ps=newPrintStream(os);
			br=newBufferedReader(newInputStreamReader(is));
		}
		catch(Exceptione)
		{
			System.err.println(e.toString());
			destroy();
			System.exit(-1);
		}
	}

	publicStringgetRequest()
	{
		Stringrequest=null;
		try
		{
			request=br.readLine();
			System.out.print("Received:"+request);
		}
		catch(IOExceptione)
		{
			System.err.println("无法读取端口..."+e.toString());
			System.exit(-1);
		}
		returnrequest;
	}

	publicvoidsendResponse(Stringresponse)
	{
		try
		{
			ps.println(response);
			System.out.println("Sent:"+response);
		}
		catch(Exceptione)
		{
			System.err.println("写入端口失败..."+e.toString());
			System.exit(-1);
		}
	}

	publicvoiddestroy()
	{
		try
		{
			if(null!=br)
			{
				br.close();
			}
			if(null!=is)
			{
				is.close();
			}
			if(null!=ps)
			{
				ps.close();
			}
			if(null!=os)
			{
				os.close();
			}
			if(null!=clientSocket)
			{
				clientSocket.close();
			}
			if(null!=serverSocket)
			{
				serverSocket.close();
			}
		}
		catch(IOExceptionignore)
		{}
	}
}

‘贰’ Java 和其它语言之间怎么进行Socket通信用JAVA编写server，C语言编写Client，可以实现吗怎么实现

本答案提交时间：2011-6-12 17:17

Java 和其它语言之间进行Socket通信使用Socket和ServerSocket类。
用JAVA编写server，C语言编写Client，当然可以实现通信（示例在最后）。

1、Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket 是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。
重要的Socket API：
java.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，使用频繁的三个方法：
. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。
. getInputStream方法获得网络连接输入，同时返回一个IutputStream对象实例，。
. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。
注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。
2.如何开发一个Server-Client模型的程序
开发原理：
服务器，使用ServerSocket监听指定的端口，端口可以随意指定（由于1024以下的端口通常属于保留端口，在一些操作系统中不可以随意使用，所以建议使用大于1024的端口），等待客户连接请求，客户连接后，会话产生；在完成会话后，关闭连接。
客户端，使用Socket对网络上某一个服务器的某一个端口发出连接请求，一旦连接成功，打开会话；会话完成后，关闭Socket。客户端不需要指定打开的端口，通常临时的、动态的分配一个1024以上的端口。

下面这个程序用JAVA建立了一个服务器，它一直监听10000端口，等待用户连接，而用户端则可以使用C写的程序来连接该服务器。
本程序在建立连接后给客户端返回一段信息，然后结束会话。这个程序一次只能接受一个客户连接。

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

‘叁’ Java中每当server给client发一条消息，client的JTextArea如何同步该消息

因为JTextArea中声明是这样的：
JTextArea mytxtarea = new JTextArea();
所以当client收到server端发过来的消息之后，在方法中调用：
mytxtarea.setText(server_message);

这样信息就会显示在JTextArea中。

‘肆’ 用Java中的Server-Client来相互发送消息，把消息包装成对象来发送。

importjava.io.InputStream;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.OutputStream;
importjava.net.ServerSocket;
importjava.net.Socket;
//服务端
publicclassTCPServerDemo{

	publicstaticvoidmain(String[]args)throwsException{
		ServerSocketss=newServerSocket(5000);
		Sockets=ss.accept();
		InputStreamin=s.getInputStream();
		OutputStreamout=s.getOutputStream();
		ObjectOutputStreamoos=newObjectOutputStream(out);
		ObjectInputStreamois=newObjectInputStream(in);
		SocketMessagemessage=newSocketMessage();
		message.setMessageId(1);
		message.setContent("服务器消息1");
		oos.writeObject(message);
		oos.flush();
		SocketMessagetemp=(SocketMessage)ois.readObject();
		System.out.println("收到客户端消息="+temp);
	}

}
importjava.io.InputStream;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.OutputStream;
importjava.net.Socket;
//客户端
publicclassTCPClientDemo{

	publicstaticvoidmain(String[]args)throwsException{
		Sockets=newSocket("localhost",5000);
		InputStreamin=s.getInputStream();
		OutputStreamout=s.getOutputStream();
		ObjectOutputStreamoos=newObjectOutputStream(out);
		ObjectInputStreamois=newObjectInputStream(in);
		SocketMessagemessage=newSocketMessage();
		message.setMessageId(2);
		message.setContent("客户端消息2");
		oos.writeObject(message);
		oos.flush();
		SocketMessagetemp=(SocketMessage)ois.readObject();
		System.out.println("收到服务端消息="+temp);
		
	}

}
importjava.io.Serializable;
//消息对象
{

	=1L;

	privateStringcontent;
	privatelongmessageId;

	publicStringgetContent(){
		returncontent;
	}

	publicvoidsetContent(Stringcontent){
		this.content=content;
	}

	publiclonggetMessageId(){
		returnmessageId;
	}

	publicvoidsetMessageId(longmessageId){
		this.messageId=messageId;
	}

	
	@Override
	publicStringtoString(){
		returngetClass().getSimpleName()+"[id="+getMessageId()+",content="+getContent()+"]";
	}
}

‘伍’ 那个Java通信能在说的详细点吗server是如何和Client_A和B同时通信呢谢谢。

将client_A和B都存在map集合里面，用名字作为键，之后只要在A请求的时候，将要通讯的B的名字传过去，从集合里面找B的socket，就对它发送A的发送内容，就可以了，

如果要server同时对A和B通讯，直接遍历集合就可以了
细节你再去优化

‘陆’ java开发中svr的client是什么意思

client是客户端，在java中c/s结构，c是client客户端，s是server服务器端：

1. C/S又称Client/Server或客户/服务器模式。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如ORACLE、SYBASE、InfORMix或 SQL Server。客户端需要安装专用的客户端软件。

2. 传统的C/S体系结构虽然采用的是开放模式，但这只是系统开发一级的开放性，在特定的应用中无论是Client端还是Server端都还需要特定的软件支持。由于没能提供用户真正期望的开放环境，C/S结构的软件需要针对不同的操作系统系统开发不同版本的软件， 加之产品的更新换代十分快，已经很难适应百台电脑以上局域网用户同时使用。而且代价高， 效率低。

3. Client/Server结构是20世纪80年代末提出的。这种结构的系统把较复杂的计算和管理任务交给网络上的高档机器——服务器，而把一些频繁与用户打交道的任务交给前端较简单的计算机—客户机。通过这种方式，将任务合理分配到客户端和服务器端，既充分利用了两端硬件环境的优势，又实现了网络上信息资源的共享。由于这种结构比较适于局域网运行环境，因此逐渐得到了广泛的应用。

4. 在Client/Server结构的系统中，应用程序分为客户端和服务器端两大部分。客户端部分为每个用户所专有，而服务器端部分则由多个用户共享其信息与功能。客户端部分通常负责执行前台功能，如管理用户接口、数据处理和报告请求等；而服务器端部分执行后台服务，如管理共享外设、控制对共享数据库的操作等。这种体系结构由多台计算机构成，它们有机地结合在一起，协同完成整个系统的应用，从而达到系统中软、硬件资源最大限度的利用。

5. 任何一个应用系统，不管是简单的单机系统还是复杂的网络系统，都由3个部分组成：显示逻辑部分(表示层)、事务处理逻辑部分(功能层)和数据处理逻辑部分(数据层)。显示逻辑部分的功能是与用户进行交互；事务处理逻辑部分的功能是进行具体的运算和数据的处理；数据处理逻辑部分的功能是对数据库中的数据进行查询、修改和更新等。在两层模式的Client/Server结构中，显示逻辑部分和事务处理逻辑部分均被放在客户端，数据处理逻辑部分和数据库被放在服务器端。这样就使得客户端变得很“胖”，成为胖客户机，而服务器端的任务相对较轻，成为瘦服务器。

6. 这种传统的Client/Server结构比较适合于在小规模、用户数较少(≤100)、单一数据库且有安全性和快速性保障的局域网环境下运行，所以得到了广泛的应用。但随着应用系统的大型化，以及用户对系统性能要求的不断提高，两层模式(2-Tier)的Client/Server结构越来越满足不了用户需求。这主要体现在程序开发量大、系统维护困难、客户机负担过重、成本增加及系统的安全性难以保障等方面。

‘柒’ 我是java新手 聊天程序 现在还只写了一个client端和一个server端

写了个最简单的例子...注意的是client向server发送数据的时候我习惯性用了println,我记得这个是因为server用了readline这样的方法去读取.
package server;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
    public static void main(String[] args) {
        Socket s = null;
        ServerSocket ss = null;
           
        try {
            ss = new ServerSocket(9999);
               
            System.out.println("listinning...");
            s = ss.accept();
            System.out.println("get the one ...");
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
               
            while(true){
                System.out.print("read:");
                System.out.println(br.readLine());
                   
            }
               
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(s!=null){
                try {
                    s.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(ss!=null){
                try {
                    ss.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
           
           
    }
}
package client;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
    public static void main(String[] args) {
        Socket s = null;
        try {
            s = new Socket("127.0.0.1",9999);
               
            PrintWriter pw = new PrintWriter(s.getOutputStream());
               
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
               
            while(true){
                System.out.print("input something:");
                pw.println(br.readLine());
                pw.flush();
            }
               
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally{
            if(s!=null){
                try {
                    s.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

‘捌’ JVM client模式和Server模式的区别

这里向大家描述一下JVMclient模式和Server模式两者的区别和联系，JVM如果不显式指定是-Server模式还是-client模式，JVM能够根据下列原则进行自动判断（适用于Java5版本或者Java以上版本）。

JVM client模式和Server模式

JVM Server模式与client模式启动，最主要的差别在于：-Server模式启动时，速度较慢，但是一旦运行起来后，性能将会有很大的提升。JVM如果不显式指定是-Server模式还是-client模式，JVM能够根据下列原则进行自动判断（适用于Java5版本或者Java以上版本）。

前段时间有个同事给我发了个java跟c++性能比较的文章，其中有个对比图引起了我的兴趣，意外的是，我感兴趣的不是java和c++的对比，而是java -Server模式和java -client模式的对比。从来没想到两者间的性能有如此巨大的差别。而在后来自己的亲身测试中发现确实如此。

下面是我看到的那个对比图：

JVM工作在Server模式可以大大提高性能，但应用的启动会比client模式慢大概10%。当该参数不指定时，虚拟机启动检测主机是否为服务器，如果是，则以Server模式启动，否则以client模式启动，J2SE5.0检测的根据是至少2个CPU和最低2GB内存。

当JVM用于启动GUI界面的交互应用时适合于使用client模式，当JVM用于运行服务器后台程序时建议用Server模式。
JVM在client模式默认-Xms是1M，-Xmx是64M；JVM在Server模式默认-Xms是128M，-Xmx是1024M。我们可以通过运行:java -version来查看jvm默认工作在什么模式。

‘玖’ 用java 写出一个Server 和Client 能实现Client发送的消息显示在服务端上，Server发送的信息显示在客户端上

你好！
我写的很简单，你可以在此基础上完善，好了，废话不多说，直入正题。
首先，建立一个项目名为TestChat，然后建两个包，分别为server和client。
server包下建立一个类为Server，一个类为ServerListen。
client包建立一个类Client，一个类为ClentListen。
由于我时间仓促，你自行参考哈。

***********************************************************************

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

/*
* Server.java
*
* Created on 2011-5-8, 16:37:13
*/

package server;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author Study
*/
public class Server extends javax.swing.JFrame {

/** Creates new form Server */
public Server() {
initComponents();
try {
ss = new ServerSocket(8888);
s = ss.accept();
in = new ObjectInputStream(getS().getInputStream());
out = new ObjectOutputStream(getS().getOutputStream());
this.startListen();
} catch (IOException ex) {
Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
}
}

/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jScrollPane1 = new javax.swing.JScrollPane();
messageShow = new javax.swing.JTextArea();
messageInput = new javax.swing.JTextField();
sendBtn = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("服务器");

messageShow.setColumns(20);
messageShow.setEditable(false);
messageShow.setRows(5);
jScrollPane1.setViewportView(messageShow);

sendBtn.setText("发送");
sendBtn.addMouseListener(new java.awt.event.MouseAdapter() {
public void mousePressed(java.awt.event.MouseEvent evt) {
sendBtnMousePressed(evt);
}
});

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 400, Short.MAX_VALUE)
.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 400, Short.MAX_VALUE)
.addComponent(messageInput, javax.swing.GroupLayout.DEFAULT_SIZE, 400, Short.MAX_VALUE)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap(333, Short.MAX_VALUE)
.addComponent(sendBtn)
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 300, Short.MAX_VALUE)
.addGroup(layout.createSequentialGroup()
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 201, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addComponent(messageInput, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addComponent(sendBtn)
.addContainerGap(19, Short.MAX_VALUE))
);

pack();
}// </editor-fold>

private void sendBtnMousePressed(java.awt.event.MouseEvent evt) {
this.sendMessage();
this.messageInput.setText("");
}

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Server().setVisible(true);
}
});
}

// Variables declaration - do not modify
protected javax.swing.JScrollPane jScrollPane1;
protected javax.swing.JTextField messageInput;
protected javax.swing.JTextArea messageShow;
protected javax.swing.JButton sendBtn;
// End of variables declaration

private ServerSocket ss;
private Socket s;
private ObjectOutputStream out;
private ObjectInputStream in;

private void startListen() {
ServerListen listen = new ServerListen(this);
Thread t = new Thread(listen);
t.start();
}

/**
* @return the s
*/
public Socket getS() {
return s;
}

/**
* @return the out
*/
public ObjectOutputStream getOut() {
return out;
}

/**
* @return the in
*/
public ObjectInputStream getIn() {
return in;
}

/**
* @return the messageShow
*/
public javax.swing.JTextArea getMessageShow() {
return messageShow;
}

private void sendMessage() {
try {
out.writeObject("服务器说");
out.flush();
out.writeObject(this.messageInput.getText().trim());
out.flush();
} catch (IOException ex) {
Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
}
}

}

‘拾’ 用java编写Client和Server程序，实现Client和Server的数据通信。

服务端代码：

importjava.io.IOException;
importjava.io.InputStream;
importjava.net.InetAddress;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.net.UnknownHostException;

publicclassServer{

	publicstaticvoidmain(String[]args)throwsUnknownHostException,IOException{
		
		ServerSocketserver=newServerSocket(2408,5,InetAddress.getByName("localhost"));
		
		while(true){
		
			//等待客户端的连接
			SocketclientSocket=server.accept();
			
			//为每个连接的客户端分配一个线程，与客户端通信
			newThread(newClientThread(clientSocket)).start();
		}
	}
}

{

	privateSocketclientSocket;
	
	publicClientThread(Socketsocket){
		this.clientSocket=socket;
	}
	
	@Override
	publicvoidrun(){
		
		try{
			
			InputStreaminput=clientSocket.getInputStream();
			
			byte[]buffer=newbyte[1024];
			
			booleanexit=false;
			
			while(!exit){
				
				intlen=input.read(buffer);
				Stringmessage=newString(buffer,0,len);
				
				if("bye".equals(message)){
					exit=true;
				}
				
				System.out.println(clientSocket.getRemoteSocketAddress()+":"+message);
			}
			
			clientSocket.close();
			
		}catch(IOExceptione){
			e.printStackTrace();
		}
	}
}

客户端代码：

importjava.io.IOException;
importjava.io.OutputStream;
importjava.net.InetAddress;
importjava.net.Socket;
importjava.net.UnknownHostException;
importjava.util.Scanner;

publicclassClient{

	publicstaticvoidmain(String[]args)throwsUnknownHostException,IOException{
		
		Scannerscanner=newScanner(System.in);
		
		Socketsocket=newSocket(InetAddress.getByName("localhost"),2408);
		
		OutputStreamoutput=socket.getOutputStream();
		
		booleanexit=false;
		
		while(!exit){
		
			Stringmessage=scanner.nextLine();
			
			if("bye".equals(message)){
				exit=true;
			}
			
			byte[]data=message.getBytes();
			
			output.write(data);
			output.flush();
		}
		
		socket.close();
	}
}