简单的聊天室代码（聊天室代码java）

今天给各位分享简单的聊天室代码的知识，其中也会对聊天室代码java进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java 聊天室代码？？？
• 2、怎样用asp创建聊天室？（高分）
• 3、如何用C语言编写一个简单的聊天室程序
• 4、如何用Python编写一个聊天室
• 5、java 聊天室 源代码
• 6、求Java Socket 聊天室代码

java 聊天室代码？？？

前天帮人解决过，代码如下：public class iChat extends JFrame {

private JPanel jContentPane;

private JButton jButton1;

private JScrollPane jScrollPane1;

private JTextArea jTextArea1,jTextArea2; public iChat() {

super();

initialize();

} private void initialize() {

this.setSize(375, 364);

jTextArea1 = getJTextArea1();

this.setContentPane(getJContentPane());

this.setTitle("聊天室");

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } private JPanel getJContentPane() {

if (jContentPane == null) {

jContentPane = new JPanel();

jContentPane.setBackground(Color.BLUE);//蓝色为JPanel 。

jContentPane.setLayout(null);

jContentPane.add(getJButton1(), null);

jContentPane.add(getJTextArea2(), null);

jContentPane.add(getJScrollPane1(), null);

}

return jContentPane;

} private JTextArea getJTextArea2() {

if (jTextArea2 == null) {

jTextArea2 = new JTextArea();

jTextArea2.setBounds(new Rectangle(1, 253, 282, 73));

jTextArea2.setLineWrap(true);

jTextArea2.addKeyListener(new java.awt.event.KeyAdapter() {

public void keyTyped(java.awt.event.KeyEvent e) {

if (e.getKeyChar() == KeyEvent.VK_ENTER) {

String s = "你说：" + jTextArea2.getText();

String date = new SimpleDateFormat(

"yyyy-MM-dd HH:mm:ss").format(Calendar

.getInstance().getTime());

jTextArea1.append(date + "\n");

jTextArea1.append(s);

}

}

});

}

return jTextArea2;

} private JButton getJButton1() {

if (jButton1 == null) {

jButton1 = new JButton();

jButton1.setBounds(new Rectangle(293, 288, 62, 32));

jButton1.setText("发送");

jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent e) {

String s = "你说：" + jTextArea2.getText();

String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

.format(Calendar.getInstance().getTime());

jTextArea1.append(date + "\n");

jTextArea1.append(s + "\n");

jTextArea2.setText(""); }

});

}

return jButton1;

}

private JScrollPane getJScrollPane1() {

if (jScrollPane1 == null) {

jScrollPane1 = new JScrollPane();

jScrollPane1.setBounds(new Rectangle(0, 0, 360, 220));

jScrollPane1.setViewportView(getJTextArea1());

}

return jScrollPane1;

} private JTextArea getJTextArea1() {

if (jTextArea1 == null) {

jTextArea1 = new JTextArea();

jTextArea1.setEditable(false);

jTextArea1.setLineWrap(true);

}

return jTextArea1;

} public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() {

iChat thisClass = new iChat();

thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

thisClass.setVisible(true);

}

});

}}

怎样用asp创建聊天室？（高分）

用ASP建造自己的聊天室

聊天室想必你一定去过吧，但想不想建立自己的聊天室呢？其实这一点都不难，Active Server Script提供了Application对象和Session对象，Application对象代表了一个Active Server应用程序，也就是一个Web网页，Session对象则表示一个用户，代表一个用户对这个页面的一次访问，通过Application对象可以让访问它的所有用户共享信息，并可以在Web服务器运行期间持久地保存数据，而Session对象也可以在用户的一次访问期间持久地保持数据，利用这两个对象，就可以十分方便地建造自己的Chat应用程序。

---- 一、Application对象：

---- 1．属性：Application对象没有内置的属性，但用户可以定义自己的属性：

---- Application(“属性名称”)=值，一旦分配了属性，它就会一直存在，直到Web服务器关闭服务，而且它能被所有用户读取，所以可以用它在用户之间发送谈话内容。

---- 2．方法：当两个用户同时对Application属性的值进行写入操作时，会出现一方的修改被另一方的操作直接覆盖掉的情况，为了避免这种现象，用户可以调用Lock方法进行锁定，这样只有当前用户才能够对Application的属性进行操作，用户完成操作后调用Unlock方法解锁，使得其他用户也可以修改Application的属性。

---- 3．事件：创建Active Server应用程序需要在Web服务器上存放应用程序的虚拟主目录下创建Global.asa文件，它含有Application对象和Session对象的事件处理例程，通常，Application_Onstart事件用来定义应用级的属性。

---- 二、创建一个Chat应用程序：程序运行时如下图所示(略)

---- 1．设置应用程序的变量：这里需建立两个应用程序级的变量，gchars数组用来存放用户的谈话内容，gcounter用做计数器，控制页面的显示行数，在这里我们让页面最多显示最近的10行谈话内容。当应用程序启动时这些变量必须进行初始化，所以它们的创建都要在Global.asa文件中的Application_onstart事件中：

script language="vbscript" runat="server"

sub application_onstart()

dim lchars(10)

application("gchars")=lchars

application("gcounter")=0

end sub

/script

---- 2．确定处理ASP的方式：当用户第一次请求这个ASP文件时，用的是GET方法，然后，当用户输入完谈话内容后提交时用的是POST方法，在这里表单是向自身提交的，所以这个ASP文件会被再次请求，我们通过测试Request . ServerVariales(“Request_Method”)变量来确定文件被请求的方式：IF Request . ServerVariales(“Request_Method”)=“POST” then

---- 3．确定讲话者：当用户第一次提交谈话内容时需输入自己的姓名，一旦在txtname框中输入数据后，程序将建立一个会话级变量来存放用户姓名，并自动显示在txtname框中，用户就不需再次输入了，除非你想用另一个名字加入会谈。

IF len(request(“txtname”)) 0 then

Session(“ssname”)=request(“txtname”)

End if

h5 您的姓名：

input type=“type” name=“txtname”

length=“20” value= %=session(“ssname”)%

----

---- 4．处理用户的谈话内容：首先要确定已经为Chat写入的谈话行数，为方便阅读，在这里将显示行数限定为10行，如果Application(“gcounter”)大于9，则将其置为0，然后将谈话者姓名和内容一起存放到Application(“gchars”)数组中：

Application(“gchars”)

(Application(“gcounter”))=Session(“ssname”)

“:” request(txttalk)

然后将计数器加1:Application(“gcounter”) =Application(“gcounter”)+1

---- 5．将数组内容写入到客户的浏览器中：用户提交谈话内容后，程序必须将数组内容写到客户的浏览器中，让聊天室中的所有人都能看到被提交的谈话内容：

if application("gcounter")=0 then

lstemp=application("gchars")(0)

else

for x=0 to application("gcounter")-1

lstemp=lstemp " br " application("gchars")(x)

next

end if

---- 最后，用Response.write方法将lstemp变量的值写到客户的浏览器中去：

response.write lstemp

---- 下面给出Default.asp的完整代码：

%response.expires=0

response.buffer=true%

html head title Chat sample /title /head

body center

h3 我的聊天室 /h3 /center hr

% if request.servervariables("request_method")="POST" then

if len(request("txtname")) 0 then

session("ssname")=request("txtname")

end if

application.lock

mcounter=application("gcounter")

mchars=application("gchars")

if mcounter 9 then

mcounter=0

end if

mchars(mcounter)=session("ssname")

":" request("txttalk")

mcounter=mcounter+1

application("gcounter")=mcounter

application("gchars")=mchars

application.unlock

end if %

% if application("gcounter")=0 then

lstemp=application("gchars")(0)

else

for x=0 to application("gcounter")-1

lstemp=lstemp " br " application("gchars")(x)

next

end if

response.write lstemp %

hr center

form action="default.asp" method=post name="aspform"

b a href="default.asp"

更新显示 /a /b

h5 发言:

input type="text" name="txttalk" size="70" br

h5 您的姓名:

input type="text" name="txtname" length="20"

value= %=session("ssname")%

input type="submit" name="cmdpost" default="true" value="发送"

/form /center /body /html

---- 以上代码在NT4.0、IIS4.0、IE4.0中和Pwin98、PWS、IE4.0中分别运行通过。

如何用C语言编写一个简单的聊天室程序

这样：

#include stdlib.h

#include stdio.h

#include errno.h

#include string.h

#include unistd.h

#include netdb.h

#include sys/socket.h

#include netinet/in.h

#include sys/types.h

#include arpa/inet.h

#include pthread.h

#define MAXLINE 100;

void *threadsend(void *vargp);

void *threadrecv(void *vargp);

int main()

{

int *clientfdp;

clientfdp = (int *)malloc(sizeof(int));

*clientfdp = socket(AF_INET,SOCK_STREAM,0);

struct sockaddr_in serveraddr;

struct hostent *hp;

bzero((char *)serveraddr,sizeof(serveraddr));

serveraddr.sin_family = AF_INET;

serveraddr.sin_port = htons(15636);

serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");

if(connect(*clientfdp,(struct sockaddr *)serveraddr,sizeof(serveraddr)) 0){

      printf("connect error\n");

      exit(1);

}

pthread_t tid1,tid2;

printf("connected\n");

while(1){

pthread_create(tid1,NULL,threadsend,clientfdp);

pthread_create(tid2,NULL,threadrecv,clientfdp);

}

return EXIT_SUCCESS;

}

void *threadsend(void * vargp)

{

//pthread_t tid2;

int connfd = *((int *)vargp);

int idata;

char temp[100];

while(1){

//printf("me: \n ");

fgets(temp,100,stdin);

send(connfd,temp,100,0);

printf("          client send OK\n");

}

printf("client send\n");

return NULL;

}

void *threadrecv(void *vargp)

{

char temp[100];

int connfd = *((int *)vargp);

while(1){

int idata = 0;

idata = recv(connfd,temp,100,0);

if(idata 0){

printf("server :\n%s\n",temp);

}

}

return NULL;

}

扩展资料：

注意事项

linux下编译多线程代码时，shell提示找不到 pthread_create函数，原因是 pthread.h不是linux系统默认加载的库文件，应该使用类似如下gcc命令进行编译：

gcc echoserver.c -lpthread -o echoserver

只要注意 -lpthread参数就可以了。

如何用Python编写一个聊天室

python聊天室(python2.7版本)：

暂时先给出两种版本的,tcp+udp

都是分别运行server.py和client.py，就可以进行通讯了。

别外还有websocket版本，这个是有web界面的和基本web服务的，如果需要的话，我会把基本的代码贴一版上来。

TCP版本：

socket-tcp-server.py（服务端）:

#-*- encoding:utf-8 -*-

#socket.getaddrinfo(host,  port, family=0, socktype=0, proto=0, flags=0)

#根据给定的参数host/port，相应的转换成一个包含用于创建socket对象的五元组，

#参数host为域名，以字符串形式给出代表一个IPV4/IPV6地址或者None.

#参数port如果字符串形式就代表一个服务名，比如“http”"ftp""email"等，或者为数字，或者为None

#参数family为地主族，可以为AF_INET  ，AF_INET6 ，AF_UNIX.

#参数socktype可以为SOCK_STREAM(TCP)或者SOCK_DGRAM(UDP)

#参数proto通常为0可以直接忽略

#参数flags为AI_*的组合，比如AI_NUMERICHOST，它会影响函数的返回值

#附注：给参数host,port传递None时建立在C基础，通过传递NULL。

#该函数返回一个五元组(family, socktype, proto, canonname, sockaddr)，同时第五个参数sockaddr也是一个二元组(address, port)

#更多的方法及链接请访问

# Echo server program

from socket import *

import sys

import threading

from time import ctime

from time import localtime

import traceback

import time

import subprocess

reload(sys)

sys.setdefaultencoding("utf8")

HOST='127.0.0.1'

PORT=8555  #设置侦听端口

BUFSIZ=1024

class TcpServer():

    def __init__(self):

        self.ADDR=(HOST, PORT)

        try:

            self.sock=socket(AF_INET, SOCK_STREAM)

            print '%d is open' % PORT

            self.sock.bind(self.ADDR)

            self.sock.listen(5)

            #设置退出条件

            self.STOP_CHAT=False

            # 所有监听的客户端

            self.clients = {}

            self.thrs = {}

            self.stops = []

        except Exception,e:

            print "%d is down" % PORT

            return False

    def IsOpen(ip, port):

        s = socket(AF_INET, SOCK_STREAM)

        try:

            s.connect((ip, int(port)))

            # s.shutdown(2)

            # 利用shutdown()函数使socket双向数据传输变为单向数据传输。shutdown()需要一个单独的参数，

            # 该参数表示s了如何关闭socket。具体为：0表示禁止将来读；1表示禁止将来写；2表示禁止将来读和写。

            print '%d is open' % port

            return True

        except:

            print '%d is down' % port

            return False

    def listen_client(self):

        while not self.STOP_CHAT:

            print(u'等待接入，侦听端口:%d' % (PORT))

            self.tcpClientSock, self.addr=self.sock.accept()

            print(u'接受连接，客户端地址：',self.addr)

            address = self.addr

            #将建立的client socket链接放到列表self.clients中

            self.clients[address] = self.tcpClientSock

            #分别将每个建立的链接放入进程中，接收且分发消息

            self.thrs[address] = threading.Thread(target=self.readmsg, args=[address])

            self.thrs[address].start()

            time.sleep(0.5)

    def readmsg(self,address):

        #如果地址不存在，则返回False

        if address not in self.clients:

            return False

        #得到发送消息的client socket

        client = self.clients[address]

        while True:

            try:

                #获取到消息内容data

                data=client.recv(BUFSIZ)

            except:

                print(e)

                self.close_client(address)

                break

            if not data:

                break

            #python3使用bytes，所以要进行编码

            #s='%s发送给我的信息是:[%s] %s' %(addr[0],ctime(), data.decode('utf8'))

            #对日期进行一下格式化

            ISOTIMEFORMAT='%Y-%m-%d %X'

            stime=time.strftime(ISOTIMEFORMAT, localtime())

            s=u'%s发送给我的信息是:%s' %(str(address),data.decode('utf8'))

            #将获得的消息分发给链接中的client socket

            for k in self.clients:

                self.clients[k].send(s.encode('utf8'))

                self.clients[k].sendall('sendall:'+s.encode('utf8'))

                print str(k)

            print([stime], ':', data.decode('utf8'))

            #如果输入quit(忽略大小写),则程序退出

            STOP_CHAT=(data.decode('utf8').upper()=="QUIT")

            if STOP_CHAT:

                print "quit"

                self.close_client(address)

                print "already quit"

                break

    def close_client(self,address):

        try:

            client = self.clients.pop(address)

            self.stops.append(address)

            client.close()

            for k in self.clients:

                self.clients[k].send(str(address) + u"已经离开了")

        except:

            pass

        print(str(address)+u'已经退出')

if __name__ == '__main__':

    tserver = TcpServer()

    tserver.listen_client()

 ——————————华丽的分割线——————————       

 socket-tcp-client.py （客户端）：

#-*- encoding:utf-8 -*-

from socket import *

import sys

import threading

import time

reload(sys)

sys.setdefaultencoding("utf8")

#测试，连接本机

HOST='127.0.0.1'

#设置侦听端口

PORT=8555

BUFSIZ=1024

class TcpClient:

    ADDR=(HOST, PORT)

    def __init__(self):

        self.HOST = HOST

        self.PORT = PORT

        self.BUFSIZ = BUFSIZ

        #创建socket连接

        self.client = socket(AF_INET, SOCK_STREAM)

        self.client.connect(self.ADDR)

        #起一个线程，监听接收的信息

        self.trecv = threading.Thread(target=self.recvmsg)

        self.trecv.start()

    def sendmsg(self):

        #循环发送聊天消息，如果socket连接存在则一直循环，发送quit时关闭链接

        while self.client.connect_ex(self.ADDR):

            data=raw_input(':')

            if not data:

                break

            self.client.send(data.encode('utf8'))

            print(u'发送信息到%s：%s' %(self.HOST,data))

            if data.upper()=="QUIT":

                self.client.close()

                print u"已关闭"

                break

    def recvmsg(self):

        #接收消息，如果链接一直存在，则持续监听接收消息

        try:

            while self.client.connect_ex(self.ADDR):

                data=self.client.recv(self.BUFSIZ)

                print(u'从%s收到信息：%s' %(self.HOST,data.decode('utf8')))

        except Exception,e:

            print str(e)

if __name__ == '__main__':

    client=TcpClient()

    client.sendmsg()

UDP版本：

socket-udp-server.py

# -*- coding:utf8 -*-

import sys

import time

import traceback

import threading

reload(sys)

sys.setdefaultencoding('utf-8')

import socket

import traceback

HOST = "127.0.0.1"

PORT = 9555

CHECK_PERIOD = 20

CHECK_TIMEOUT = 15

class UdpServer(object):

    def __init__(self):

        self.clients = []

        self.beats = {}

        self.ADDR = (HOST,PORT)

        try:

            self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

            self.sock.bind(self.ADDR)       # 绑定同一个域名下的所有机器

            self.beattrs = threading.Thread(target=self.checkheartbeat)

            self.beattrs.start()

        except Exception,e:

            traceback.print_exc()

            return False

    def listen_client(self):

        while True:

            time.sleep(0.5)

            print "hohohohohoo"

            try:

                recvData,address = self.sock.recvfrom(2048)

                if not recvData:

                    self.close_client(address)

                    break

                if address in self.clients:

                    senddata = u"%s发送给我的信息是:%s" %(str(address),recvData.decode('utf8'))

                    if recvData.upper() == "QUIT":

                        self.close_client(address)

                    if recvData == "HEARTBEAT":

                        self.heartbeat(address)

                        continue

                else:

                    self.clients.append(address)

                    senddata = u"%s发送给我的信息是:%s" %(str(address),u'进入了聊天室')

                for c in self.clients:

                    try:

                        self.sock.sendto(senddata,c)

                    except Exception,e:

                        print str(e)

                        self.close_client(c)

            except Exception,e:

                # traceback.print_exc()

                print str(e)

                pass

    def heartbeat(self,address):

        self.beats[address] = time.time()

    def checkheartbeat(self):

        while True:

            print "checkheartbeat"

            print self.beats

            try:

                for c in self.clients:

                    print time.time()

                    print self.beats[c]

                    if self.beats[c] + CHECK_TIMEOUT time.time():

                        print u"%s心跳超时，连接已经断开" %str(c)

                        self.close_client(c)

                    else:

                        print u"checkp%s,没有断开" %str(c)

            except Exception,e:

                traceback.print_exc()

                print str(e)

                pass

            time.sleep(CHECK_PERIOD)

    def close_client(self,address):

        try:

            if address in self.clients:

                self.clients.remove(address)

                if self.beats.has_key(address):

                    del self.beats[address]

                print self.clients

            for c in self.clients:

                self.sock.sendto(u'%s已经离开了' % str(address),c)

            print(str(address)+u'已经退出')

        except Exception,e:

            print str(e)

            raise

if __name__ == "__main__":

    udpServer = UdpServer()

    udpServer.listen_client()

——————————华丽的分割线——————————    

socket-udp-client.py:

# -*- coding:utf8 -*-

import sys

import threading

import time

reload(sys)

sys.setdefaultencoding('utf-8')

import socket

HOST = "127.0.0.1"

PORT = 9555

#BEAT_PORT = 43278

BEAT_PERIOD = 5

class UdpClient(object):

    def __init__(self):

        self.clientsock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

        self.HOST = HOST

        self.ADDR = (HOST,PORT)

        self.clientsock.sendto(u'请求建立链接',self.ADDR)

        self.recvtrs = threading.Thread(target=self.recvmsg)

        self.recvtrs.start()

        self.hearttrs = threading.Thread(target=self.heartbeat)

        self.hearttrs.start()

    def sendmsg(self):

        while True:

            data = raw_input(":")

            if not data:

                break

            self.clientsock.sendto(data.encode('utf-8'),self.ADDR)

            if data.upper() == 'QUIT':

                self.clientsock.close()

                break

    def heartbeat(self):

        while True:

            self.clientsock.sendto('HEARTBEAT',self.ADDR)

            time.sleep(BEAT_PERIOD)

    def recvmsg(self):

        while True:

            recvData,addr = self.clientsock.recvfrom(1024)

            if not recvData:

                break

            print(u'从%s收到信息：%s' %(self.HOST,recvData.decode('utf8')))

if __name__ == "__main__":

    udpClient = UdpClient()

    udpClient.sendmsg()

java 聊天室 源代码

【ClientSocketDemo.java 客户端Java源代码】

import java.net.*;

import java.io.*;

public class ClientSocketDemo

{

//声明客户端Socket对象socket

Socket socket = null;

//声明客户器端数据输入输出流

DataInputStream in;

DataOutputStream out;

//声明字符串数组对象response，用于存储从服务器接收到的信息

String response[];

//执行过程中，没有参数时的构造方法，本地服务器在本地，取默认端口10745

public ClientSocketDemo()

{

try

{

//创建客户端socket，服务器地址取本地，端口号为10745

socket = new Socket("localhost",10745);

//创建客户端数据输入输出流，用于对服务器端发送或接收数据

in = new DataInputStream(socket.getInputStream());

out = new DataOutputStream(socket.getOutputStream());

//获取客户端地址及端口号

String ip = String.valueOf(socket.getLocalAddress());

String port = String.valueOf(socket.getLocalPort());

//向服务器发送数据

out.writeUTF("Hello Server.This connection is from client.");

out.writeUTF(ip);

out.writeUTF(port);

//从服务器接收数据

response = new String[3];

for (int i = 0; i response.length; i++)

{

response[i] = in.readUTF();

System.out.println(response[i]);

}

}

catch(UnknownHostException e){e.printStackTrace();}

catch(IOException e){e.printStackTrace();}

}

//执行过程中，有一个参数时的构造方法，参数指定服务器地址，取默认端口10745

public ClientSocketDemo(String hostname)

{

try

{

//创建客户端socket，hostname参数指定服务器地址，端口号为10745

socket = new Socket(hostname,10745);

in = new DataInputStream(socket.getInputStream());

out = new DataOutputStream(socket.getOutputStream());

String ip = String.valueOf(socket.getLocalAddress());

String port = String.valueOf(socket.getLocalPort());

out.writeUTF("Hello Server.This connection is from client.");

out.writeUTF(ip);

out.writeUTF(port);

response = new String[3];

for (int i = 0; i response.length; i++)

{

response[i] = in.readUTF();

System.out.println(response[i]);

}

}

catch(UnknownHostException e){e.printStackTrace();}

catch(IOException e){e.printStackTrace();}

}

//执行过程中，有两个个参数时的构造方法，第一个参数hostname指定服务器地址

//第一个参数serverPort指定服务器端口号

public ClientSocketDemo(String hostname,String serverPort)

{

try

{

socket = new Socket(hostname,Integer.parseInt(serverPort));

in = new DataInputStream(socket.getInputStream());

out = new DataOutputStream(socket.getOutputStream());

String ip = String.valueOf(socket.getLocalAddress());

String port = String.valueOf(socket.getLocalPort());

out.writeUTF("Hello Server.This connection is from client.");

out.writeUTF(ip);

out.writeUTF(port);

response = new String[3];

for (int i = 0; i response.length; i++)

{

response[i] = in.readUTF();

System.out.println(response[i]);

}

}

catch(UnknownHostException e){e.printStackTrace();}

catch(IOException e){e.printStackTrace();}

}

public static void main(String[] args)

{

String comd[] = args;

if(comd.length == 0)

{

System.out.println("Use localhost(127.0.0.1) and default port");

ClientSocketDemo demo = new ClientSocketDemo();

}

else if(comd.length == 1)

{

System.out.println("Use default port");

ClientSocketDemo demo = new ClientSocketDemo(args[0]);

}

else if(comd.length == 2)

{

System.out.println("Hostname and port are named by user");

ClientSocketDemo demo = new ClientSocketDemo(args[0],args[1]);

}

else System.out.println("ERROR");

}

}

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

【ServerSocketDemo.java 服务器端Java源代码】

import java.net.*;

import java.io.*;

public class ServerSocketDemo

{

//声明ServerSocket类对象

ServerSocket serverSocket;

//声明并初始化服务器端监听端口号常量

public static final int PORT = 10745;

//声明服务器端数据输入输出流

DataInputStream in;

DataOutputStream out;

//声明InetAddress类对象ip，用于获取服务器地址及端口号等信息

InetAddress ip = null;

//声明字符串数组对象request，用于存储从客户端发送来的信息

String request[];

public ServerSocketDemo()

{

request = new String[3]; //初始化字符串数组

try

{

//获取本地服务器地址信息

ip = InetAddress.getLocalHost();

//以PORT为服务端口号，创建serverSocket对象以监听该端口上的连接

serverSocket = new ServerSocket(PORT);

//创建Socket类的对象socket，用于保存连接到服务器的客户端socket对象

Socket socket = serverSocket.accept();

System.out.println("This is server:"+String.valueOf(ip)+PORT);

//创建服务器端数据输入输出流，用于对客户端接收或发送数据

in = new DataInputStream(socket.getInputStream());

out = new DataOutputStream(socket.getOutputStream());

//接收客户端发送来的数据信息，并显示

request[0] = in.readUTF();

request[1] = in.readUTF();

request[2] = in.readUTF();

System.out.println("Received messages form client is:");

System.out.println(request[0]);

System.out.println(request[1]);

System.out.println(request[2]);

//向客户端发送数据

out.writeUTF("Hello client!");

out.writeUTF("Your ip is:"+request[1]);

out.writeUTF("Your port is:"+request[2]);

}

catch(IOException e){e.printStackTrace();}

}

public static void main(String[] args)

{

ServerSocketDemo demo = new ServerSocketDemo();

}

}

求Java Socket 聊天室代码

两个类，实现交互

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

public class MutiChat

{

public static void main(String[] args)

{

MutiChat mc = new MutiChat();

mc.receive().start();

mc.send().start();

}

/**

* 接收信息

*

* @return

*/

private Thread receive()

{

return new Thread()

{

public void run()

{

ServerSocket server_socket = null;

Socket sk = null;

BufferedReader in = null;

try

{

server_socket = new ServerSocket(7777);

sk = server_socket.accept();

in = new BufferedReader(new InputStreamReader(sk

.getInputStream()));

while (true)

{

String str = in.readLine();

System.out.println(str);

}

} catch (Exception e)

{

e.printStackTrace();

}

}

};

}

private Thread send()

{

return new Thread()

{

public void run()

{

Socket client_socket = null;

BufferedReader in = null;

PrintWriter out = null;

while (true)

{

try

{

client_socket = new Socket("127.0.0.1", 8888);

in = new BufferedReader(

new InputStreamReader(System.in));

out = new PrintWriter(new BufferedWriter(

new OutputStreamWriter(client_socket

.getOutputStream())), true);

while (true)

{

String str = in.readLine();

out.println(str);

}

} catch (Exception e)

{

try

{

Thread.sleep(1000);

} catch (Exception ex)

{

ex.printStackTrace();

}

}

}

}

};

}

}

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

public class MutiChat2

{

public static void main(String[] args)

{

MutiChat2 mc = new MutiChat2();

mc.receive().start();

mc.send().start();

}

/**

* 接收信息

*

* @return

*/

private Thread receive()

{

return new Thread()

{

public void run()

{

ServerSocket server_socket = null;

Socket sk = null;

BufferedReader in = null;

try

{

server_socket = new ServerSocket(8888);

sk = server_socket.accept();

in = new BufferedReader(new InputStreamReader(sk

.getInputStream()));

while (true)

{

String str = in.readLine();

System.out.println(str);

}

} catch (Exception e)

{

e.printStackTrace();

}

}

};

}

private Thread send()

{

return new Thread()

{

public void run()

{

Socket client_socket = null;

BufferedReader in = null;

PrintWriter out = null;

while (true)

{

try

{

client_socket = new Socket("127.0.0.1", 7777);

in = new BufferedReader(

new InputStreamReader(System.in));

out = new PrintWriter(new BufferedWriter(

new OutputStreamWriter(client_socket

.getOutputStream())), true);

while (true)

{

String str = in.readLine();

out.println(str);

}

} catch (Exception e)

{

try

{

Thread.sleep(1000);

} catch (Exception ex)

{

ex.printStackTrace();

}

}

}

}

};

}

}

关于简单的聊天室代码和聊天室代码java的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。