package Chat;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;
import java.util.ArrayList;
public class ChatServer {
public static void main(String[] args){
try {
ServerSocket server=new ServerSocket(8088);
Socket socket=null;
List<Socket> sockets=new ArrayList<Socket>();
TongJiNum tj=new TongJiNum();
tj.start();
System.out.println("聊天室启动.....");
while(true){
socket=server.accept();
String come=socket.getRemoteSocketAddress().toString();
String comeStr[]=come.split("/");
System.out.println(comeStr[1]+"进来了");
ServerThread st=new ServerThread(socket,sockets,comeStr[1]);
st.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ServerThread extends Thread{
private Socket socket;
private static List<Socket> sockets;
private BufferedReader br;
private PrintWriter pw;
private String message;
public static byte[] o=new byte[0];
protected static int online;
public ServerThread(Socket socket,List<Socket> sockets,String come){
synchronized(o){
try{
System.out.println(come+"进来了");
for(int i=0;i<sockets.size();i++){
PrintWriter pw=MyUtil.getPrintWriter(sockets.get(i));
pw.println(come+"进来了");
pw.flush();
}
sockets.add(socket);
}catch(Exception e){
}
}
online++;
this.socket=socket;
this.sockets=sockets;
try{
this. br=MyUtil.getNetStream(this.socket);
this.pw=MyUtil.getPrintWriter(this.socket);
}catch(Exception e){
System.out.println(e.getMessage());
}
}
public static void chatToOne(Socket socket,Socket socketto){
new ChatToOne(socket,socketto).start();
}
public static void chatToMul(Socket socket,List<Socket> sockets){
new ChatToMul(socket,sockets).start();
}
public static List<Socket> findSockets(String ss,Socket socket){
String addsource[]=ss.split("#");
String tempMessage="";
List<Socket> finds=new ArrayList<Socket>();
for(int j=0;j<addsource.length;j++){
for(int i=0;i<sockets.size();i++){
String add[]=sockets.get(i).getRemoteSocketAddress().toString().split("/");
if(addsource[j].equals(add[1])){
finds.add(sockets.get(i));
tempMessage=sockets.get(i).toString();
PrintWriter pw;
try {
pw = MyUtil.getPrintWriter(socket);
pw.println("已连接的socket:"+tempMessage);
pw.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
return finds;
}
public static Socket findSocket(String ss,Socket socket){
String tempMessage="";
for(int i=0;i<sockets.size();i++){
String add[]=sockets.get(i).getRemoteSocketAddress().toString().split("/");
if(add[1].equals(ss)){
tempMessage=sockets.get(i).toString();
PrintWriter pw;
try {
pw = MyUtil.getPrintWriter(socket);
pw.println("已连接的socket"+tempMessage);
pw.flush();
} catch (Exception e) {
e.printStackTrace();
}
return sockets.get(i);
}
}
return new Socket();
}
public void run(){
try{//处理的每一个部分都需要加锁，synchronized（this.o）
//对用户发送过来的消息进行处理,循环处理，也就是监听
while(true){
message=br.readLine();
if(message==null){
synchronized(o){
continue;
}
}else if(message.trim().equals("close")){
synchronized(o){
break;
}
}else if(message.trim().equals("chatmy")){
PrintWriter pw=MyUtil.getPrintWriter(socket);
synchronized(o){
String who=socket.getRemoteSocketAddress().toString();
String ss[]=who.split("/");
pw.println(ss[1]);
pw.flush();
}
}else if(message.trim().equals("chatlist")){
PrintWriter pw=MyUtil.getPrintWriter(socket);
for(int i=0;i<sockets.size();i++){
synchronized(o){//刚才把锁放在循环外部
String who=sockets.get(i).getRemoteSocketAddress().toString();
String ss[]=who.split("/");
pw.println(ss[1]);
pw.flush();
}
}
}else if(message.matches("chatto@\\w+([-:.@#$|]\\w+)*")){
//chatto@m@127.0.0.1:6789#127.0.0.1:6677#127.0.0.1:8888
//chatto@s@127.0.0.1:6789
String ss[]=message.split("@");
if(ss[1].equals("s")){
if(ss[2].matches("\\w+([-+.:]\\w+)*:\\w*")){
//进入1对1聊天，必须输入quit才能退出
chatToOne(this.socket,findSocket(ss[2],this.socket));
}
}else if(ss[1].equals("m")){
//进入1对n聊天，必须输入quit才能退出
chatToMul(this.socket,findSockets(ss[2],this.socket));
}else{
System.out.println("命令格式出错");
}
}else{
for(int i=0;i<sockets.size();i++){
synchronized(o){
PrintWriter pw=MyUtil.getPrintWriter(sockets.get(i));
String who=socket.getRemoteSocketAddress().toString();
String ss[]=who.split("/");
pw.println(ss[1]+"说："+message);
pw.flush();
}
}
}
}
}catch(Exception e){
}finally{
//处理离开的用户，并对online减1，和通知每一个在线用户
//先在服务器中打印谁离开，再通知所有人，谁离开了
synchronized(o){
String who=socket.getRemoteSocketAddress().toString();
String ss[]=who.split("/");
System.out.println(ss[1]+"离开了");
//通知所有人，谁离开了
try{
for(int i=0;i<sockets.size();i++){
PrintWriter pw=MyUtil.getPrintWriter(sockets.get(i));
pw.println(ss[1]+"离开了");
pw.flush();
}
online--;
socket.close();
}catch(Exception e){
e.printStackTrace();
}finally{
sockets.remove(socket);
}
}
}
}
}
class TongJiNum extends Thread{
public void run(){
while(true){
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("当前聊天室"+ServerThread.online+"人在线");
}
}
}
package Chat;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
public class ChatClient {
//public static Object o=new Object();
public static byte[] o=new byte[0];
public final static BufferedReader jianpan=MyUtil.getInputStream();
private static WriteMessage wm;
private static ReceiveMessage rm;
private static Socket socket;
public static void main(String[] args) {
System.out.println("请输入ip地址和端口号");
System.out.println("例如：127.0.0.1=8088");
System.out.println("输入chathelp命令，获取聊天室的帮助");
try{
String message=jianpan.readLine();
while(message==null||message.trim().length()==0){
System.out.println("请输入ip地址和端口号");
System.out.println("例如：127.0.0.1=8088");
message=jianpan.readLine();
}
String ss[]=message.split("=");
socket=connect(ss);//在内部定义了socket，没有关联
wm=new WriteMessage(socket,jianpan);
wm.start();
rm=new ReceiveMessage(socket);
rm.start();
System.out.println("启动了");
}catch(Exception e){
System.out.println(e.getMessage());
}
}
public static Socket connect(String[] ss)throws Exception{
try {
Socket socket=new Socket(ss[0],Integer.parseInt(ss[1]));
return socket;
} catch (NumberFormatException e) {
System.out.println("请输入正确的端口号");
throw new Exception("聊天室异常……");
} catch (UnknownHostException e) {
System.out.println("找不到主机地址");
throw new Exception("聊天室异常……");
} catch (IOException e) {
System.out.println("连接出错");
throw new Exception("聊天室异常……");
}
}
}
class MyUtil{
//输入流
public static BufferedReader getInputStream(){
return new BufferedReader(new InputStreamReader(System.in));
}
//获取网络流
public static BufferedReader getNetStream(Socket socket)throws Exception{
return new BufferedReader(new InputStreamReader(socket.getInputStream()));
}
//发送消息
public static PrintWriter getPrintWriter(Socket socket) throws Exception{
return new PrintWriter(socket.getOutputStream());
}
}
class ReceiveMessage extends Thread{
private BufferedReader br;
public ReceiveMessage(Socket socket){
try {
this.br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
public void run(){
String message="";
try{
while(true){
message=this.br.readLine();
if(message==null){
break;
}
System.out.println(message);
}
}catch(Exception e){
}finally{
synchronized(ChatClient.o){
System.out.println("客户端在5秒后关闭");
try{
Thread.sleep(5000);
}catch(Exception e){
e.printStackTrace();
}
System.out.println("客户端关闭");
System.exit(1);
}
}
}
}
class WriteMessage extends Thread{
private PrintWriter pw;
private BufferedReader jianpan;
public WriteMessage(Socket socket,BufferedReader jianpan){
super();
this.jianpan=jianpan;
try {
this.pw=MyUtil.getPrintWriter(socket);
} catch (Exception e) {
e.printStackTrace();
}
}
public void run(){
String message=null;
System.out.println("-----请发言-----");
try{
while(true){
message=this.jianpan.readLine();
if(message==null){
continue;
}else if(message.length()==0){
System.out.println("请不要发送空消息，静止发言5秒");
Thread.sleep(5000);
System.out.println("可以发言了");
continue;
}else if(message.equals("chathelp")){
System.out.println("退出聊天室：close");
System.out.println("查看全部人ip：chatlist");
System.out.println("查看自己的ip：chatmy");
System.out.println("指定的多人聊：");
System.out.println("chatto@m@127.0.0.1:6789#127.0.0.1:6677#127.0.0.1:8888");
System.out.println("私聊");
System.out.println("chatto@s@127.0.0.1:6789");
System.out.println("退出私聊：quit");
continue;
}else if(message.equals("close")){
this.pw.println(message);
this.pw.flush();
break;
}else if(message.matches("chatto@\\w+([-:.@#$|]\\w+)*")){
System.out.println("单人私聊（按s）：请输入要私聊的ip地址：端口号");
System.out.println("多人私聊（按m）：请输入要私聊的\"ip1地址：端口号|ip2地址：端口号|...\"");
this.pw.println(message);
this.pw.flush();
}else{
pw.println(message);
pw.flush();
}
}
}catch(Exception e){
}finally{
synchronized(ChatClient.o){
System.out.println("客户端在3秒后离开");
try{
Thread.sleep(3000);
}catch(Exception e){
}
System.out.println("客户端已经关闭");
System.exit(1);
}
}
}
}
package Chat;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.List;
public class ChatToOne {
private Socket socket;
private Socket socketto;
public ChatToOne(Socket socket,Socket socketto){
this.socket=socket;
this.socketto=socketto;
}
public void start(){
while(true){
try {
if(!socket.isConnected()){
System.out.println("该socket已经关闭");
socket.close();
return;
}
String message=MyUtil.getNetStream(socket).readLine();
if(message.equals("quit")){
Thread.yield();
break;
}
PrintWriter pw=MyUtil.getPrintWriter(socket);
PrintWriter pwto=MyUtil.getPrintWriter(socketto);
pw.println(socket.getRemoteSocketAddress().toString()+"对"+
socketto.getRemoteSocketAddress().toString()+"说："+message);
pw.flush();
pwto.println(socket.getRemoteSocketAddress().toString()+"对"+
socketto.getRemoteSocketAddress().toString()+"说："+message);
pwto.flush();
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}catch(Exception e){
}
}
}
}
//把线程类改为普通类，就不会出现那种交替发送，一次发给私聊的用户，一次发给群聊的
class ChatToMul{
private Socket socket;
private List<Socket> sockets;
public ChatToMul(Socket socket,List<Socket> sockets){
this.socket=socket;
this.sockets=sockets;
}
public void start(){
while(true){
try {
String message=MyUtil.getNetStream(socket).readLine();
if(message.equals("quit")){
Thread.yield();
break;
}
for(Socket socketto:sockets){
PrintWriter pw=MyUtil.getPrintWriter(socket);
PrintWriter pwto=MyUtil.getPrintWriter(socketto);
pw.println(socket.getRemoteSocketAddress().toString()+"对"+
socketto.getRemoteSocketAddress().toString()+"说："+message);
pw.flush();
pwto.println(socket.getRemoteSocketAddress().toString()+"对"+
socketto.getRemoteSocketAddress().toString()+"说："+message);
pwto.flush();
}
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}catch(Exception e){
}
}
}
}
分享到：
相关推荐
根据给定的信息，“Dos下的局域网聊天室”这一标题及描述主要介绍了一种在DOS环境下实现的局域网聊天应用。该应用支持群聊和私聊功能，并且能够容纳多个用户同时在线交流。接下来将对这个项目的几个关键知识点进行...
标题中的“毕业设计论文-局域网聊天室系统的设计与实现.rar”表明这是一个关于局域网聊天室系统的毕业设计项目，通常包含详细的设计文档和可能的源代码。这个压缩包可能包含了作者在完成该设计时的研究、分析、设计...
本项目是一个基于MFC的局域网聊天室客户端，具备群聊和私聊功能，同时也支持用户屏蔽其他用户的消息。接下来，我们将深入探讨这个项目中的关键技术和实现方法。 1. **网络通信基础** - TCP/IP协议：作为局域网聊天...
C语言编写，采用CS模型，TCP、UDP网络协议实现的内网多人聊天室。 服务器：采用多线程以及线程锁处理客户端的所有请求以及信息转发任务。服务端实时显示客户的登录与登出信息；保存客户上传的共享文件（网盘功能）；...
在本项目中，"Java代码写的局域网多线程TCP、Socket多人聊天室winsock.zip" 是一个基于Java实现的局域网多用户聊天应用。这个应用利用了TCP（Transmission Control Protocol）协议和Socket编程，同时采用了多线程...
利用C#.NET框架，我们可以构建功能丰富的局域网聊天室，实现群聊、私聊以及在线会议等功能。这个项目的关键知识点包括网络编程、多线程处理、数据传输安全以及用户界面设计。 1. **网络编程**：在C#.NET中，可以...
Java局域网聊天室和文件夹发送是一款基于UDP和TCP协议开发的应用，它允许用户在同一个局域网内的设备之间进行实时的文本聊天和文件交换。这个应用的主要特点包括群聊、私聊功能以及能够发送单个文件或整个文件夹。在...
综上所述，"C# Winform IP MSG 类似功能 还可以 聊天室一样群聊 私聊 局域网内部通信 发消息 聊天"这个项目涵盖了网络编程、UI设计、数据传输、安全性和用户体验等多个方面的知识。通过这个项目，开发者可以深入学习...
在IT领域，局域网聊天室是一个常见的项目，它基于Java Socket编程技术，允许在同一局域网内的用户进行实时通信，包括群聊和私聊功能，并且支持表情的使用。这个项目的核心在于网络编程和多线程技术的应用，下面将...
综上所述，这份局域网聊天室课程设计不仅涵盖了理论知识的学习，更重要的是通过实践让学生掌握了网络编程的基础技能，尤其是在Java环境下实现TCP/IP协议的具体方法。通过这样的实践项目，学生不仅能深入了解网络通信...
标题 "基于Socket技术的局域网聊天室" 描述了一个使用C#编程语言构建的局域网聊天室项目。这个项目充分利用了Socket技术，允许在同一网络内的用户进行实时的通信，包括私聊、群聊以及文件传输。数据库采用的是SQL ...
UDP是一种无连接的、不可靠的传输层协议，它不保证数据包的顺序到达或重传丢失的包，但因其低延迟和高效性，在局域网聊天室这种实时性要求较高的场景中常被选用。 1. UDP基本功能分析： - 聊天室的核心功能包括...
【MFC局域网聊天室】是一个基于C++编程语言，使用Microsoft Foundation Classes (MFC)库开发的简单网络通信应用。MFC是微软提供的一套面向对象的类库，它使得开发者能够更容易地利用Windows API来构建Windows应用...
局域网聊天工具是一种在局域网环境下实现通信的应用程序，它允许在同一网络中的多台计算机之间进行实时的文本、语音甚至是视频交流。这类工具在企业和机构内部、学校或者家庭网络环境中尤为常见，因为它们无需互联网...
本次设计是一个简易的局域网聊天室，功能设计主要分为群聊和私聊两部分，每部分都支持基础聊天以及文件传输功能。参考了《Qt及Qt Quick开发实战精解》中的群聊实例，并在群聊的基础设计了私聊这部分内容以及其他一些...
总的来说，【Java局域网聊天室】是一个很好的学习和实践网络编程、多线程和并发控制的项目。它不仅涉及到基础的Socket通信，还包括了线程管理、数据序列化和反序列化、网络状态监测等多个方面的知识。通过这个项目，...
这个"JAVA综合实验2聊天室"项目旨在让学生理解网络编程的基本原理，特别是如何利用Java实现客户端和服务器之间的通信，以及如何设计多用户交互的系统。下面，我们将详细分析这个项目的各个方面。 首先，Java是一种...
在本项目中，我们主要探讨如何使用C语言来构建一个具备基本聊天功能的聊天室，包括私聊、群聊、用户登录与注册、查看在线联系人以及退出等操作。此外，用户信息会存储在一个数据库中，这涉及到数据库的管理和访问。...
2. **多人参与**：支持多个用户同时在线，进行群聊或私聊。 3. **文件传输**：用户之间可以方便地发送和接收文件，实现资料的快速共享。 4. **用户管理**：服务器端可对用户进行添加、删除等基本管理操作。 **技术...
2. 聊天室：用户可以加入聊天室进行群聊，也可以创建私聊对话。 3. 消息发送与接收：实现文本消息、表情、文件等的实时传输。 4. 用户状态管理：在线/离线状态显示，好友列表维护。 5. 错误处理：包括网络中断、数据...