javaserverclient_java socket編程中sever和client互相傳送數字

『壹』 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伺服器端：

C/S又稱Client/Server或客戶/伺服器模式。伺服器通常採用高性能的PC、工作站或小型機，並採用大型資料庫系統，如ORACLE、SYBASE、InfORMix或 SQL Server。客戶端需要安裝專用的客戶端軟體。
傳統的C/S體系結構雖然採用的是開放模式，但這只是系統開發一級的開放性，在特定的應用中無論是Client端還是Server端都還需要特定的軟體支持。由於沒能提供用戶真正期望的開放環境，C/S結構的軟體需要針對不同的操作系統系統開發不同版本的軟體，加之產品的更新換代十分快，已經很難適應百台電腦以上區域網用戶同時使用。而且代價高，效率低。
Client/Server結構是20世紀80年代末提出的。這種結構的系統把較復雜的計算和管理任務交給網路上的高檔機器——伺服器，而把一些頻繁與用戶打交道的任務交給前端較簡單的計算機—客戶機。通過這種方式，將任務合理分配到客戶端和伺服器端，既充分利用了兩端硬體環境的優勢，又實現了網路上信息資源的共享。由於這種結構比較適於區域網運行環境，因此逐漸得到了廣泛的應用。
在Client/Server結構的系統中，應用程序分為客戶端和伺服器端兩大部分。客戶端部分為每個用戶所專有，而伺服器端部分則由多個用戶共享其信息與功能。客戶端部分通常負責執行前台功能，如管理用戶介面、數據處理和報告請求等；而伺服器端部分執行後台服務，如管理共享外設、控制對共享資料庫的操作等。這種體系結構由多台計算機構成，它們有機地結合在一起，協同完成整個系統的應用，從而達到系統中軟、硬體資源最大限度的利用。
任何一個應用系統，不管是簡單的單機系統還是復雜的網路系統，都由3個部分組成：顯示邏輯部分(表示層)、事務處理邏輯部分(功能層)和數據處理邏輯部分(數據層)。顯示邏輯部分的功能是與用戶進行交互；事務處理邏輯部分的功能是進行具體的運算和數據的處理；數據處理邏輯部分的功能是對資料庫中的數據進行查詢、修改和更新等。在兩層模式的Client/Server結構中，顯示邏輯部分和事務處理邏輯部分均被放在客戶端，數據處理邏輯部分和資料庫被放在伺服器端。這樣就使得客戶端變得很「胖」，成為胖客戶機，而伺服器端的任務相對較輕，成為瘦伺服器。
這種傳統的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();
	}
}

導航:首頁 > 編程語言 > javaserverclient

javaserverclient

與javaserverclient相關的資料