给你一个我写的示例，用的是基于TCP的Socket技术，你锻炼一下，改一改，不会改再找我！
客户端：
import java.net.Socket;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class TcpClient {
public static void main(String[] args) throws Exception
{
//创建客户端Socket服务，并且制定主机和ank
Socket s = new Socket("192.168.1.104",10002);//连接固定的主机和端口
//为了发送数据，获取Socket中的输入输出流
OutputStream out = s.getOutputStream();
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String line = null;
//读取服务器发过来的数据
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
while((line = br.readLine())!=null)
{
out.write(line.getBytes());
if("886".equals(line))
break;
int len = in.read(buf);
String content = new String(buf,0,len);
System.out.println("Server:"+content);
}
s.close();
}
}
服务器：
/*
* 需求分析：
* 使用TCP协议，写服务器端。做到服务器能收到客户端的信息，也能向客户端发送信息
* */
package JavaNetProgramming;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class TcpServer {
public static void main(String[] args) throws Exception
{
//建立服务器的Socket服务，并且监听一个端口
ServerSocket ss = new ServerSocket(10002);
Socket s = ss.accept();
InputStream is = s.getInputStream();
//从服务器端向客户端发送数据
OutputStream out = s.getOutputStream();
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String line = null;
while(true)
{
//通过accept()方法获得客户端传过来的Socket对象
// System.out.println("getByNanme():"+s.getInetAddress());
System.out.print("getHostAddress():"+s.getInetAddress().getHostAddress());
//获取客户端发过来的数据，就要使用客户端对象的读取流来读取数据
byte[] buf = new byte[1024];
int len = is.read(buf);//把流中数据读到字节数组中
String content = new String(buf,0,len);
System.out.println(" "+content);
if("886".equals(content))
break;
while((line = br.readLine())!=null)
{
out.write(line.getBytes());
break;
}
}
s.close(); //循环内有判断语句,这句话才不出错
ss.close();
}
}
㈡ 求教编程做出一个两人多人之间简单的聊天程序
制作人: CK.y ，汇成建筑企业管理Q：610089144
仅供参考，大家要学会自己制作，很有成就感的啊！！ 用 Java 作后台，开发一个 C / S 架构的多人聊天程序。首先，设计用户界面。
一、界面设计
界面的元件全部使用 Flash CS3 自带的组件：
首先，放入 TextInput 组件（实例名 input_txt），作为用户输入；
再放入 Button 组件（实例名 submit_btn），用于提交输入的信息；
最后放入 TextArea 组件（实例名 output_txt），显示聊天信息。
二、组件参数初始化
由于客户端代码不是很多，我们这次就写在动作帧上：
// ************ 组件参数初始化 ************
submit_btn.label = "发送消息";
output_txt.editable = false;
// 设置各组件中字体的大小
input_txt.setStyle("textFormat", new TextFormat(null, 15));
output_txt.setStyle("textFormat", new TextFormat(null, 15));
submit_btn.setStyle("textFormat", new TextFormat(null, 15, null, true));
// 当按下回车或点击 submit_btn 按钮后调用事件处理函数
submit_btn.addEventListener(MouseEvent.CLICK, sendMessage);
addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
// 事件处理函数
function onKeyDown(evt:KeyboardEvent):void {
if (evt.keyCode == Keyboard.ENTER) {
sendMessage(null);
}
}
function sendMessage(evt:Event):void {
// 测试：将 input_txt 的内容输出到 output_txt 中
output_txt.appendText(input_txt.text + "\n");
// 清空 input_txt，并设置焦点到 input_txt
input_txt.text = "";
stage.focus = input_txt;
}
三、编写客户端 Socket
1. 首先，Socket 连接非常简单：
var socket:Socket = new Socket();
socket.connect("127.0.0.1", 8888);
其中 connect() 方法中的两个参数分别为是主机名和端口号（端口号尽量用 1024 以上）。好了，这样就连接上了。接下来是读写的问题。
2. 向服务器端写入字符串：我们在 sendMessage() 方法中进行写入操作，注意写出的字串必需以回车（\n）结束：
function sendMessage(evt:Event):void {
var bytes:ByteArray = new ByteArray();
bytes.writeUTFBytes(input_txt.text + "\n");
socket.writeBytes(bytes);
socket.flush();
// 清空 input_txt，并设置焦点到 input_txt
input_txt.text = "";
stage.focus = input_txt;
}
3. 读取服务器端写回的字符串：最后将服务器发回的字符串输出到 output_txt 文本域中：
// 当客户端 socket 收到数据后会调用 readMessage() 函数
socket.addEventListener(ProgressEvent.SOCKET_DATA, readMessage);
function readMessage(evt:ProgressEvent):void {
output_txt.appendText(socket.readUTF() + "\n");
}
四、Flash 客户端全部脚本
// ************ 组件参数初始化 ************
submit_btn.label = "发送消息";
output_txt.editable = false;
input_txt.setStyle("textFormat", new TextFormat(null, 15));
output_txt.setStyle("textFormat", new TextFormat(null, 15));
submit_btn.setStyle("textFormat", new TextFormat(null, 15, null, true));
submit_btn.addEventListener(MouseEvent.CLICK, sendMessage);
addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
function onKeyDown(evt:KeyboardEvent):void {
if (evt.keyCode == Keyboard.ENTER) {
sendMessage(null);
}
}
function sendMessage(evt:Event):void {
var bytes:ByteArray = new ByteArray();
bytes.writeUTFBytes(input_txt.text + "\n");
socket.writeBytes(bytes);
socket.flush();
input_txt.text = "";
stage.focus = input_txt;
}
// ************ 客户端 Socket ************
var socket:Socket = new Socket();
socket.connect("127.0.0.1", 8888);
socket.addEventListener(ProgressEvent.SOCKET_DATA, readMessage);
function readMessage(evt:ProgressEvent):void {
output_txt.appendText(socket.readUTF() + "\n");
}
五、编写 Java 服务器端 Socket
最后，我们需要编写 Java 后台服务器端的代码。
首先，创建一个 ServerSocket 作为Socket 服务器。当有客户端连接后通过 accept() 方法即可得到客户端的 Socket：
ServerSocket socketServer = new ServerSocket(8888);
System.out.println("服务器已启动，等待客户端连接");
// accept() 方法是阻塞式的，当有客户端连接成功后才继续执行
Socket socket = socketServer.accept();
System.out.println("客户端连接成功");
然后得到与客户端的输入流和输出流（输入流是客户端连接到服务器的管道，输出流则是服务器到客户端的管道）：
// 获得输入流和输出流，输入流为 BufferedReader 类型，输出流为 DataOutputStream 类型
BufferedReader reader =
new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
DataOutputStream writer = new DataOutputStream(socket.getOutputStream());
拿到输入输出流以后，就可以通过输入流（InputStream）读取 Flash 客户端发来的字符串，通过输出流（OutputStream）向 Flash 客户端写字符串：
while (true) {
// readLine() 方法也是阻塞式的，当客户端有消息发来就读取，否则就一直等待
String msg = reader.readLine();
// 当客户端发送的字符串为 null 时，说明客户端已经关闭，此时退出循环
if (msg == null) {
System.out.println("客户端已离开");
break;
}
// 将读入的信息加工后再写回客户端
writer.writeUTF("写回客户端的" + msg);
}
以上是ServerSocket 与 AS 3 Socket 通信的基本原理。在实际应用中，会有多个客户端连接这个ServerSocket，因此要创建一个多线程的 Socket 服务器。
下面简述一下多线程 Socket 服务器原理：当socketServer.accept() 之后就需要实例化一个线程对象，在该对象中持有socketServer.accept() 返回的 Socket 对象，然后让线程跑起来执行读写操作。如果再来一个客户端就再跑一个线程，同样执行读写操作。同时，用一个 List 容器来管理这些对象。
最终服务器端的代码如下：
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class FlashScoket {
private List<Client> clientList = new ArrayList<Client>();
public static void main(String[] args) {
new FlashScoket().runSocket();
}
private void runSocket() {
try {
ServerSocket socketServer = new ServerSocket(8888);
System.out.println("服务器已启动，等待客户端连接");
while (true) {
// accept() 方法是阻塞式的，当有客户端连接成功后才继续执行
Socket socket = socketServer.accept();
System.out.println("客户端连接成功");
// 实例化一个 Client 对象，并启动该线程
Client client = new Client(socket);
clientList.add(client);
client.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
class Client extends Thread {
private Socket socket;
private BufferedReader reader;
private DataOutputStream writer;
private Client(Socket socket) {
this.socket = socket;
try {
// 获得输入流和输出流，输入流为 BufferedReader 类型，输出流为 DataOutputStream 类型
reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
writer = new DataOutputStream(socket.getOutputStream());
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
try {
while (true) {
// readLine() 方法也是阻塞式的，当客户端有消息发来就读取，否则就一直等待
String msg = reader.readLine();
// 当客户端发送的字符串为 null 时，说明客户端已经关闭，此时退出循环
if (msg == null) {
clientList.remove(this);
System.out.println("客户端已离开");
break;
}
// 将读入的内容写给每个客户端
for (Iterator<Client> it = clientList.iterator(); it.hasNext();) {
Client client = it.next();
client.getWriter().writeUTF(msg);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭 socket 及相关资源
try {
if (reader != null) {
reader.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (writer != null) {
writer.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (socket != null) {
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
public DataOutputStream getWriter() {
return writer;
}
}
}
六、补充技术
1. 如何测试？
* 首先要编译FlashScoket —— javac FlashScoket
* 然后启动FlashScoket —— java FlashScoket
* 最后将 Flash 发布为 exe 文件格式，同时开启多个即可。
2. 自动跟踪到最后一行：当收到新的消息时自动滚动到最后一行，在 readMessage() 方法中加入：
output_txt.verticalScrollBar.scrollPosition = output_txt.verticalScrollBar.maxScrollPosition;
3. 当出现输入/输出错误并导致发送或加载操作失败时提示用户，加入对IO_ERROR 的侦听：
socket.addEventListener(IOErrorEvent.IO_ERROR, socketIOError);
function socketIOError(evt:IOErrorEvent):void {
output_txt.appendText("服务器端尚未开启，请稍后再试\n");
}
4. 在sendMessage() 中加入对空字符串的验证，如果为空则 return：
if (input_txt.text == "") {
return;
}
5. 在消息前面显示用户名：大家可以制作一个登录页面，输入用户名，假设已将输入的用户名存放在 userName 变量中，在写入时加进去：
var userName:String = "FL 车在臣";
在 sendMessage() 中相应改为：
bytes.writeUTFBytes(userName + " : " + input_txt.text + "\n");
6. 使用output_txt .htmlText 输出文字，那么相应的写入格式可以调整为：
bytes.writeUTFBytes("<font color='#0000FF'>" + userName + " : </font>" + input_txt.text + "\n");
㈢ mfc socket 编程的流程是怎么样的
初始化socket
首先需要调用AfxSocketInit()函数来初始化我们的socket环境。
为了初始化sockets，我们需要调用AfxSocketInit()函数。它通常是在MFC中的InitInstance()函数中被调用的。如果我们用程序向导来创建socket程序的话，查看“use Windows Sockets”这个选项，然后选中它。它将会自动的为我们创建这个步骤了。（如果我们没有选中这个选项的话，我们也可以手动添加这些代码的。）这个函数的返回值显示这个函数的调用成功或失败。
BOOL CServerApp::InitInstance()
{....
if( AfxSocketInit() == FALSE)
{
AfxMessageBox("Sockets Could Not Be Initialized");
return FALSE;
}
...
}
创建Server Sockets
为了创建一个Server Socket，我们需要声明一个CAyncSocket的变量或者我们自己定制的一个从AyncSocket或是Cscket继承来的类的类型的变量。然后调用Create()函数，同时指定监听的端口。这个函数的返回值显示这个函数的调用成功或失败。
UpdateData(TRUE);
m_sListener.Create(m_port);
if(m_sListener.Listen()==FALSE)
{
AfxMessageBox("Unable to Listen on that port,please try another port");
m_sListener.Close();
return;
}
创建Client Sockets
为了创建Client socket类，我们需要声明一个CAyncSocket的变量或者我们自己定制的一个从AyncSocket或是Cscket继承来的类的类型的变量。然后调用Create()函数，同时指定监听的端口。这个函数的返回值显示这个函数的调用成功或失败。
m_sConnected.Create();
m_sConnected.Connect("server ip",port);
监听客户端的连接
创建了server socket以后，我们要进行监听。调用Listen()函数。这个函数的返回值显示这个函数的调用成功或失败。
if( m_sListener.Listen()== FALSE)
{
AfxMessageBox("Unable to Listen on that port,please try another port");
m_sListener.Close();
return;
}
接受连接
连接请求要被接受accept，是用另外的socket，不是正在监听的socket。请参看代码。
void CXXXDlg::OnAccept()
{
CString strIP;
UINT port;
if(m_sListener.Accept(m_sConnected))
{
m_sConnected.GetSockName(strIP,port); //应该是GetPeerName，获取对方的IP和port
m_status="Client Connected,IP :"+ strIP;
m_sConnected.Send("Connected To Server",strlen("Connected To Server"));
UpdateData(FALSE);
}
else
{
AfxMessageBox("Cannoot Accept Connection");
}
}
发送数据
数据放在一个buffer中或是结构体中，调用send()函数发送。
m_sConnected.Send(pBuf,iLen);
接受数据
调用receive()接受数据。
void CXXXrDlg::OnReceive()
{
char *pBuf =new char [1025];
CString strData;
int iLen;
iLen=m_sConnected.Receive(pBuf,1024);
if(iLen == SOCKET_ERROR)
{
AfxMessageBox("Could not Recieve");
}
else
{
pBuf[iLen]=NULL;
strData=pBuf;
m_recieveddata.Insert(m_recieveddata.GetLength(),strData);
//display in server
UpdateData(FALSE);
m_sConnected.Send(pBuf,iLen); //send the data back to the Client
delete pBuf;
}
}
关闭连接
m_sConnected.ShutDown(0); 停止发送数据
m_sConnected.ShutDown(1); 停止接受数据
m_sConnected.ShutDown(2); 停止发送接受数据
m_sConnected.Close();
编写自己的socket类
在class view中选择添加一个新类，设置它的基类为CAsyncSocket，在类向导的帮助下添加如下的一些函数。
class MySocket : public CAsyncSocket
{ // Attributes
public:
// Operations
public:
MySocket();
virtual ~MySocket();
// Overrides
public:
void SetParentDlg(CDialog *pDlg);// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(MySocket)
public:
virtual void OnAccept(int nErrorCode);
virtual void OnClose(int nErrorCode);
virtual void OnConnect(int nErrorCode);
virtual void OnOutOfBandData(int nErrorCode);
virtual void OnReceive(int nErrorCode);
virtual void OnSend(int nErrorCode);
//}}AFX_VIRTUAL // Generated message map functions
//{{AFX_MSG(MySocket)
// NOTE - the ClassWizard will add and remove member functions here. //}}AFX_MSG
protected:
private:
CDialog * m_pDlg;
};
设置“Parent Dialog”
调用这个socket类的SetParentDlg函数，保证当socket事件发生的时候这个窗体能接收到。
m_sListener.SetParentDlg(this);
m_sConnected.SetParentDlg(this);
建立Socket 事件和窗体成员函数之间的联系
在这个窗体类中添加一些函数，比如void OnReceive(); void OnClose(); void OnAccept(); void OnConnect()等，它们会在我们编写的的socket类中调用到。
void MySocket::OnAccept(int nErrorCode)
{
// TODO: Add your specialized code here and/or call the base class
if(nErrorCode==0)
{
((CServerDlg*)m_pDlg)->OnAccept();
}
CAsyncSocket::OnAccept(nErrorCode);
}