java私聊
Ⅰ 用java做個簡單的私聊程序
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;
public class ChatClient extends Frame {
Socket s = null;
DataInputStream dis = null;
DataOutputStream dos = null;
private boolean bconnected = false;
TextField tf = new TextField();
TextArea ta = new TextArea();
public static void main(String[] args) {
new ChatClient().launchFrame();
}
public void launchFrame() {
setBounds(400,300,300,300);
add(tf,BorderLayout.SOUTH);
add(ta,BorderLayout.NORTH);
addWindowListener (new WindowAdapter() {
public void windowClosing(WindowEvent e) {
disConnect();
System.exit(0);
}
});
tf.addActionListener(new TFText());
setVisible(true);
connect();
new Thread(new ReceiveThread()).start();
}
public void connect() {
try {
s = new Socket("127.0.0.1", 8888);
dis = new DataInputStream (s.getInputStream());
dos = new DataOutputStream (s.getOutputStream());
System.out.println("connect");
bconnected = true;
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public void disConnect() {
try {
dis.close();
dos.close();
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private class TFText implements ActionListener {
public void actionPerformed(ActionEvent e) {
String str = tf.getText().trim();
tf.setText("");
try {
dos.writeUTF (str);
dos.flush ();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
private class ReceiveThread implements Runnable {
public void run() {
try {
while (bconnected) {
String str = dis.readUTF();
ta.setText(ta.getText()+str+'\n');
}
} catch (SocketException e) {
System.out.println("退出了");
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
import java.io.*;
import java.net.*;
import java.util.*;
public class ChatServer {
ServerSocket ss = null;
boolean started = false;
List<Client> clients = new ArrayList<Client>();
public static void main(String[] args) {
new ChatServer().start();
}
public void start() {
try {
ss = new ServerSocket(8888);
started = true;
} catch (BindException e) {
System.out.println(" 埠已經被佔用");
System.exit(0);
}
catch (IOException e) {
e.printStackTrace();
}
try {
while (started) {
Socket s = ss.accept();
Client c = new Client (s);
System.out.println("a client is connected");
new Thread(c).start();
clients.add(c);
}
} catch (IOException e) {
e.printStackTrace();
}
finally {
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class Client implements Runnable {
private Socket s = null;
private DataInputStream dis = null;
private DataOutputStream dos = null;
private boolean bConnected = false;
Client (Socket s) {
this.s = s;
try {
dis = new DataInputStream (s.getInputStream());
dos = new DataOutputStream (s.getOutputStream());
bConnected = true;
} catch(IOException e) {
e.printStackTrace();
}
}
public void send (String str) {
try {
dos.writeUTF(str);
} catch(IOException e) {
clients.remove(this);
System.out.println("對方已經退出了");
}
}
public void run() {
try {
while (bConnected) {
String str = dis.readUTF();
System.out.println(str);
for (int i=0; i<clients.size(); i++) {
Client c = clients.get(i);
c.send(str);
}
}
} catch (EOFException e) {
System.out.println("client is closed!");
}
catch (IOException e) {
e.printStackTrace();
}
finally {
try {
if (dis != null) dis.close();
if (dos != null) dos.close();
if (s != null) s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
你需要啟動2個客戶端
Ⅱ 怎麼用java實現聊天室的私聊功能
不知道你們群聊是不是這么實現的？
一個用戶群聊/一個用戶要看到所有人發的信息，版都需要通過伺服器權來轉發。而群聊就是伺服器把每一個用戶說的話都轉發給你看。
那麼私聊就是
客戶端發送 ip/私聊的話，發給伺服器 伺服器按一定格式進行拆分。拆完成單獨的 IP和 私聊的話。然後發送給那個指定Ip。
Ⅲ 如何用java來實現QQ的私聊，本人新手，求詳細點的，謝謝
你的意思是否是寫一個想QQ那樣的通訊工具，那就要用到swing，net包了，server socket thread等類可以完成
Ⅳ java如何實現私聊
自己編寫一個能聊天的程序就行了，設置ip地址和埠號就行了，不過這樣的不太顯示，每回次聊天必須答是知道對方ip和埠號，對樣又必須在線，而且現在多數是adsl上網，區域網內很簡單，廣域樣內這樣聊天必須綁定ip，所以不太現實，不過我寫過這樣的程序，可以聊天，傳文件的被我刪除了，需要的話向我要就可以啦。
Ⅳ 請問各位，在java中聊天系統私聊功能是怎麼樣實現
一般不是用兩復客戶端的～這樣既製做伺服器有做客戶端麻煩
先做一個服務端～服務端接受所有客戶端發送的信息，然後轉發到所有客戶端，負責接受和轉發
客戶端則連接服務端，並在要發送的消息的時候發送消息給服務端就可以了，並建立線程，不斷接受來自伺服器的轉發內容
私聊也一樣啊～發送的時候指定發送人和內容，伺服器根據發送人來單獨發送給那個人消息
Ⅵ Java聊天室如何實現私聊
我用dwr做過在線客服，dwr框架可以實現
Ⅶ java如何實現QQ私聊
這很簡單吧，在伺服器端維持一個hashtable<IP,Socket>之類的
私聊不就是兩個對應IP的Socket通信問題
Ⅷ 如何用java實現群聊私聊
簡單的區域網聊天可以使用UDP組播的方式，向某個埠發送和接受UDP報文，詳細設計可以看java的網路編程模塊，主要涉及類：DatagramSocket,DatagramPack
如果要實現公網聊天，需要搭建公網伺服器，TCP，客戶端發送消息給伺服器，伺服器根據消息轉發給指定的客戶端，同樣，詳細設計可以看java的網路編程模塊，主要涉及類：ServerSocket，Socket，InputStream，OutputStream
Ⅸ java 實現群聊和 私聊 群聊會實現 但是私聊
伺服器 端 使用個鏈表把在線用戶賬號和他對應的鏈接保存起來。例如 soket。
之後 定義一個協議，
在 客戶端發出來的 聊天信息前面添加一個頭。
例如，1表示群聊，2表示私聊，3表示添加好友，等等。每一個行為對應一個編碼超過10個可以使用字母。
群聊的話，沒什麼好說，每個人發一個；
私聊，那麼接下來的一個字元可以表示，私聊對象的賬戶名 的長度，比如 tom的 長度就是3，
之後，根據長度，截取 第3到第5個字元，截取到 此次 私聊信息是發送給 tom 的。
這條發送給伺服器，希望他轉發給tom的 消息就應該是
"23tom你好！"
之後去鏈表裡面找tom 的soket 鏈接。打開他的 輸出流，給他傳送 聊天信息。
歡迎追問。
Ⅹ 用Java實現一個人和幾個不同的人私聊，用Socket實現
package API_Day09;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
/**
* 控制台聊天程序
* 客戶端應用程序
* @author Jacob
*
*/
public class chatClient
{
//客戶端用於與服務端連接的Socket
private Socket clientSocket;
/**
* 構造方法，客戶端初始化
*/
public chatClient()
{
try
{
/*
* socket(String host, int port)
* 地址： IP地址，用來定位網路上的計算機
* 埠： 用來找到遠端計算機上用來連接的服務端應用程序
*/
clientSocket = new Socket("localhost",12580);
}
catch (Exception e)
{
e.printStackTrace();
}
}
/**
* 客戶端昵稱驗證方法
* @param 為Scanner
*/
private void inputNickName(Scanner scan) throws Exception
{
String nickName = null;
//創建輸出流
PrintWriter pw = new PrintWriter(
new OutputStreamWriter(clientSocket.getOutputStream(),
"UTF-8"),true);
//創建輸入流
BufferedReader br = new BufferedReader(
new InputStreamReader(
clientSocket.getInputStream(),"UTF-8"));
while(true)
{
System.out.println("請創建您的昵稱：");
nickName = scan.nextLine();
if (nickName.trim().equals(""))
{
System.out.println("昵稱不得為空");
}
else
{
pw.println(nickName);
String pass = br.readLine();
if(pass!=null&&!pass.equals("OK"))
{
System.out.println("昵稱已經被佔用，請更換！");
}
else
{
System.out.println("你好！"+nickName+"可以開始聊天了");
break;
}
}
}
}
/*
* 客戶端啟動的方法
*/
public void start()
{
try
{
/*
* 創建Scanner，讀取用戶輸入內容
* 目的是設置客戶端的昵稱
*/
Scanner scanner = new Scanner(System.in);
inputNickName(scanner);
/*
* 將用於接收伺服器端發送過來的信息的線程啟動
*/
Runnable run = new GetServerMsgHandler();
Thread t = new Thread(run);
t.start();
/*
* 建立輸出流，給服務端發信息
*/
OutputStream os = clientSocket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(os,"UTF-8");
PrintWriter pw = new PrintWriter(osw,true);
while(true)
{
pw.println(scanner.nextLine());
}
}
catch(Exception e)
{
e.printStackTrace();
}
finally
{
if(clientSocket !=null)
{
try
{
clientSocket.close();
}
catch(IOException e)
{
e.printStackTrace();
}
}
}
}
/**
* 該線程體用來循環讀取服務端發送過來的信息
* 並輸出到客戶端的控制台
* @param args
*/
class GetServerMsgHandler implements Runnable
{
@Override
public void run()
{
try
{
InputStream is = clientSocket.getInputStream();
InputStreamReader isr = new InputStreamReader(is,"UTF-8");
BufferedReader br = new BufferedReader(isr);
String msgString = null;
while((msgString = br.readLine())!= null)
{
System.out.println("服務端提示："+ msgString);
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
chatClient client = new chatClient();
client.start();
}
}
package API_Day09;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 控制台聊天程序
* 服務端應用程序
* @author Jacob
*
*/
public class chatServer
{
/**
* ServerSocket 是運行在服務端的Socket
* 用來監聽埠，等待客戶端的連接，
* 一旦連接成功就會返回與該客戶端通信的Socket
*/
private ServerSocket serverSocket;
/**
* 創建線程池來管理客戶端的連接線程
* 避免系統資源過度浪費
*/
private ExecutorService threadPool;
/**
* 該屬性用來存放客戶端之間私聊的信息
*/
private Map<String,PrintWriter> allOut;
/**
* 構造方法，服務端初始化
*/
public chatServer()
{
try
{
/*
* 創建ServerSocket，並申請服務埠
* 將來客戶端就是通過該埠連接服務端程序的
*/
serverSocket = new ServerSocket(12580);
/*
* 初始化Map集合，存放客戶端信息
*/
allOut = new HashMap<String, PrintWriter>();
/*
* 初始化線程池，設置線程的數量
*/
threadPool = Executors.newFixedThreadPool(10);
/*
* 初始化用來存放客戶端輸出流的集合，
* 每當一個客戶端連接，就會將該客戶端的輸出流存入該集合；
* 每當一個客戶端斷開連接，就會將集合中該客戶端的輸出流刪除；
* 每當轉發一條信息，就要遍歷集合中的所有輸出流(元素)
* 因此轉發的頻率高於客戶端登入登出的頻率，
* 還是應該使用ArrayList來存儲元素，僅限群聊，私聊不行
* allOut = new ArrayList<PrintWriter>();
*/
}
catch (Exception e)
{
e.printStackTrace();
}
}
/*
* 將客戶端的信息以Map形式存入集合中
*/
private void addOut(String key,PrintWriter value)
{
synchronized(this)
{
allOut.put(key, value);
}
}
/*
* 將給定的輸出流從共享集合中刪除
* 參數為客戶端nickName,作為Map的key鍵
*/
private synchronized void removeOut(String key)
{
allOut.remove(key);
System.out.println("當前在線人數為："+ allOut.size());
}
/*
* 將給定的消息轉發給所有客戶端
*/
private synchronized void sendMsgToAll(String message)
{
for(PrintWriter out: allOut.values())
{
out.println(message);
System.out.println("當前在線人數為："+ allOut.size());
}
}
/*
* 將給定的消息轉發給私聊的客戶端
*/
private synchronized void sendMsgToPrivate(String nickname,String message)
{
PrintWriter pw = allOut.get(nickname); //將對應客戶端的聊天信息取出作為私聊內容發送出去
if(pw!=null)
{
pw.println(message);
System.out.println("當前在線私聊人數為："+ allOut.size());
}
}
/**
* 服務端啟動的方法
*/
public void start()
{
try
{
while(true)
{
/*
* 監聽10086埠
*/
System.out.println("等待客戶端連接... ... ");
/*
* Socket accept() 這是一個阻塞方法，會一直在10086埠進行監聽
* 直到一個客戶端連接上，此時該方法會將與這個客戶端進行通信的Socket返回
*/
Socket socket = serverSocket.accept();
System.out.println("客戶端連接成功！ ");
/*
* 啟動一個線程，由線程來處理客戶端的請求，這樣可以再次監聽
* 下一個客戶端的連接了
*/
Runnable run = new GetClientMsgHandler(socket);
threadPool.execute(run); //通過線程池來分配線程
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
/**
* 該線程體用來處理給定的某一個客戶端的消息，循環接收客戶端發送
* 的每一個字元串，並輸出到控制台
* @author Jacob
*
*/
class GetClientMsgHandler implements Runnable
{
/*
* 該屬性是當前線程處理的具體的客戶端的Socket
* @see java.lang.Runnable#run()
*/
private Socket socket;
/*
* 獲取客戶端的地址信息
* private String hostIP;
*/
/*
* 獲取客戶端的昵稱
*/
private String nickName;
/*
* 創建構造方法
*/
public GetClientMsgHandler(Socket socket)
{
this.socket = socket;
/*
* 獲取遠端客戶的Ip地址信息
* 保存客戶端的IP地址字元串
* InetAddress address = socket.getInetAddress();
* hostIP = address.getHostAddress();
*/
}
/*
* 創建內部類來獲取昵稱
*/
private String getNickName() throws Exception
{
try
{
//服務端的輸入流讀取客戶端發送來的昵稱輸出流
InputStream iin = socket.getInputStream();
InputStreamReader isr =
new InputStreamReader(iin,"UTF-8");
BufferedReader bReader = new BufferedReader(isr);
//服務端將昵稱驗證結果通過自身的輸出流發送給客戶端
OutputStream out = socket.getOutputStream();
OutputStreamWriter iosw =
new OutputStreamWriter(out,"UTF-8");
PrintWriter ipw = new PrintWriter(iosw,true);
//讀取客戶端發來的昵稱
String nameString = bReader.readLine();
while(true)
{
if(nameString.trim().length()==0)
{
ipw.println("FAIL");
}
if(allOut.containsKey(nameString))
{
ipw.println("FAIL");
}
else
{
ipw.println("OK");
return nameString;
}
nameString = bReader.readLine();
}
}
catch(Exception e)
{
throw e;
}
}
@Override
public void run()
{
PrintWriter pw = null;
try
{
/*
* 通過客戶端的Socket獲取客戶端的輸出流
* 用來將消息發送給客戶端
*/
OutputStream os = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(os,"UTF-8");
pw = new PrintWriter(osw,true);
/*
* 將客戶昵稱和其所說的話作為元素存入共享集合HashMap中
*/
nickName = getNickName();
addOut(nickName, pw);
Thread.sleep(100);
/*
* 服務端通知所有客戶端，某用戶登錄
*/
sendMsgToAll("[系統通知]：歡迎**"+nickName+"**登陸聊天室!");
/*
* 通過客戶端的Socket獲取輸入流
* 讀取客戶端發送來的信息
*/
InputStream is = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(is,"UTF-8");
BufferedReader br = new BufferedReader(isr);
String msgString = null;
while((msgString = br.readLine())!=null)
{
//驗證是否是私聊
if(msgString.startsWith("@"))
{
/*
* 私聊格式：@昵稱：內容
*/
int index = msgString.indexOf(":");
if(index >=0)
{
//獲取昵稱
String name = msgString.substring(1,index);
String info = msgString.substring(index+1,msgString.length());
info = nickName + "對你說："+ info;
//將私聊信息發送出去
sendMsgToPrivate(name, info);
//服務端不在廣播私聊的信息
continue;
}
}
/*
* 遍歷所有輸出流，將該客戶端發送的信息轉發給所有客戶端
*/
System.out.println(nickName+"說："+ msgString);
sendMsgToAll(nickName+"說："+ msgString);
}
}
catch (Exception e)
{
/*
* 因為Win系統用戶的客戶端斷開連接後，br.readLine()方法讀取
* 不到信息就會拋出異常，而Linux系統會持續發送null；
* 因此這里就不在將捕獲的異常拋出了。
*/
}
finally
{
/*
* 當執行到此處時，說明客戶端已經與服務端斷開連接
* 則將該客戶端存在共享集合中的輸出流刪除
*/
removeOut(nickName);
/*
* 通知所有客戶端，某某客戶已經下線
*/
sendMsgToAll("[系統通知]："+nickName + "已經下線了。");
/*
* 關閉socket，則通過Socket獲取的輸入輸出流也一同關閉了
*/
if(socket!=null)
{
try
{
socket.close();
}
catch(IOException e)
{
e.printStackTrace();
}
}
}
}
}
public static void main(String[] args)
{
chatServer server = new chatServer();
server.start();
}
}
我的作業，供你參考