用Python实现一个简单的聊天程序

　　学习完网络套接字之后，我产生了写一个聊天程序的想法。思路很简单，首先创建一个套接字，客户端和服务器可以通过套接字通信；然后，为了使通信变为全双工，接收信息和发送信息由两个线程分别完成；最后，我还给客户端加了一个图形界面，使它看起来不是那么丑陋。

　　得益于Python的强大，所有这些实现起来都不是特别困难。比如Python中的很多数据结构，像列表，都是线程安全的，这样就免去了处理一大堆线程锁的烦恼；Python提供了方便的图形界面接口，tkinter，使得像我这种从来没有过图形界面编程经验的人，也可以在短时间内创建一个还说得过去的界面；同时，Python还拥有大量high-level Interface，相比起那些更贴近系统的低级接口，尤其是对于那些对底层操作系统不太熟的人来说，使用起来更加方便，并且在大部分情况下，这些高级接口都能满足你的需求；Python中的垃圾回收机制，让程序员从内存管理这项繁重的劳动中解脱出来，程序员再也不用像在C中那样小心谨慎，释放掉每一块不用的内存；最后不得不提到Python简洁灵活的语法，它使得代码more readable and more close to humanity，很多语法即使你以前从来没有用过，你也很有可能猜对它该怎麽用！

　　下面来介绍一下程序的基本功能。

　　客户端提供了简单的用户登录、登出、注册、发送信息、选择联系人等功能。首先，输入服务器的IP地址，点击connect（或按回车键），在客户端与服务器之间建立连接；然后，输入用户账号（只支持6位数字），点击log in（或按回车键），如果登录成功，log in 按钮会变为log out，再点击即位登出操作。登录成功之后，用户可以在contacts一栏里边选择联系人发送信息。

　　服务器主要用来处理用户连接以及信息的转发。服务器为每个用户提供一个user-buffer，所有发给该用户的信息都先存在这个缓冲区中，由服务器统一进行转发；每一个登录的用户都享有一个独立的线程，该线程时刻监听用户的输入并把它存入合适的缓冲区中。

程序运行截图

'''
TCP Client Version 2.2
2015.12.19
'''

import selectors
import queue
import re
import threading
from socket import *
from tkinter import *
from time import ctime

BUFSIZE = 1024

#lock = threading.Lock()    # Global Lock
que = queue.Queue(4096)

class GUI(object):
    '''
    This is the top module. It interacts with users. When a button is clicked
    or Return is pressed, a corresbonding event trigered. Connect is used to 
    estanblish a TCP connection with server while Log In tells server a user
    comes. We also provide an Add button, which allows user to add contacts.
    All the contacts will be displayed in a list box, and a double click on
    each contact will direct the user's message to a specific contact.
    Note that this module is based on other modules like Send and Recv, so it
    is not concerned with send and receive details. In fact it is wisdom to
    throw this burden to others. We just do what we can and do it perfectly.
    '''
    def __init__(self):
        self.root = Tk()
        self.root.title('Chat')

        self.frame_lft = Frame(self.root)
        self.frame_rgt = Frame(self.root)
        self.frame_lft.grid(row=0, column=0)
        self.frame_rgt.grid(row=0, column=1)

        self.entry_msg = Entry(self.frame_lft, width=46)    # entry, collect input
        self.entry_msg.grid(row=1, column=0)
        self.entry_msg.bind('<Return>', self.send_method)

        self.scrollbar_txt = Scrollbar(self.frame_lft, width=1)
        self.scrollbar_txt.grid(row=0, column=2, sticky=W+N+S)

        #self.button_qit = Button(self.root, text='Quit', command=self.root.quit)
        #self.button_qit.pack()

        self.text_msg = Text(self.frame_lft, state=DISABLED, width=49, wrap=WORD)    # text, display message
        self.text_msg.config(font='Fixedsys')
        self.text_msg.grid(row=0, column=0, columnspan=2, sticky=W+N+S+E)
        self.text_msg.config(yscrollcommand=self.scrollbar_txt.set)
        self.scrollbar_txt.config(command=self.text_msg.yview)
        
        self.entry_IP = Entry(self.frame_rgt, width=14)   # an IP address is supposed to input here
        self.entry_IP.grid(row=0, column=0, padx=5, pady=0)
        self.entry_IP.bind('<Return>', self.connect_method)

        self.button_cnt = Button(self.frame_rgt, text='connect', command=self.connect_method)    # click this button to connect
        self.button_cnt.config(height=1, width=8)
        self.button_cnt.grid(row=0, column=1, padx=0, pady=0)
        
        self.button_snd = Button(self.frame_lft, height=1, text='send', command=self.send_method)
        self.button_snd.config(width=8)
        self.button_snd.grid(row=1, column=1)

        ## New features in version 2.2 ##
        self.entry_log = Entry(self.frame_rgt, width=14)    # log in
        self.entry_log.grid(row=1, column=0, padx=5, pady=0)
        self.entry_log.bind('<Return>', self.login_method)  

        self.button_log = Button(self.frame_rgt, text='log in', command=self.login_method)  # first click means log in, second means log out
        self.button_log.config(width=8)
        self.button_log.grid(row=1, column=1, sticky=W)

        self.listbox_cat = Listbox(self.frame_rgt, height=17, width=24)
        self.listbox_cat.insert(END, '000000')
        self.listbox_cat.grid(row=3, column=0, columnspan=2, padx=5, sticky=N+S+E)
        self.listbox_cat.bind('<Double-1>', self.contact_method)

        self.scrollbar_cat = Scrollbar(self.frame_rgt, width=1)
        self.scrollbar_cat.grid(row=3, column=2, sticky=W+N+S)
        self.scrollbar_cat.config(command=self.listbox_cat.yview)
        self.listbox_cat.config(yscrollcommand=self.scrollbar_cat.set)

        self.entry_add = Entry(self.frame_rgt, width=14)
        self.entry_add.grid(row=4, column=0, padx=5, pady=0)
        self.entry_add.bind('<Return>', self.add_method)

        self.button_add = Button(self.frame_rgt, width=8, text='add')
        self.button_add.config(command=self.add_method)
        self.button_add.grid(row=4, column=1)

        self.label_cat = Label(self.frame_rgt, text='Contacts')
        self.label_cat.grid(row=2, column=0, sticky=W)

    def send_method(self, ev=None):
        data = self.entry_msg.get()
        self.entry_msg.delete(0, END)
        if not data:
            pass
        else:
            self.text_msg.config(state=NORMAL)
            self.text_msg.insert(END, data+'\n')
            self.text_msg.config(state=DISABLED)
            self.text_msg.see(END)
            self.send.send(data)

    def recv_method(self):
        try:
            data = que.get(block=False)
        except:
            pass
        else:
            self.text_msg.config(state=NORMAL)
            self.text_msg.insert(END, data+'\n')
            self.text_msg.config(state=DISABLED)
            self.text_msg.see(END)
            if re.match(r'^FROME', data):    # log in failed
                self.entry_log.config(state=NORMAL)
                self.button_log.config(text='log in', command=self.login_method)

        self.root.after(200, self.recv_method)    # runs every 200ms

    def connect_method(self, ev=None):
        IP = self.entry_IP.get()
        self.connt = Connt(IP)    # make an instance of Connt class
        self.connt()              # establish connection
        self.button_cnt.config(state=DISABLED)
        self.entry_IP.config(state=DISABLED)
        self.send = Send(self.connt.tcpCliSock)    # make an instance of Send class
        self.recv = Recv(self.connt.tcpCliSock)    # make an instance of Recv class
        self.recv_thread = threading.Thread(target=self.recv)  # a new thread, dealing with receiving
        self.recv_thread.daemon = True
        self.recv_thread.start()
        self.root.after(200, self.recv_method)

    def login_method(self, ev=None):
        ID = self.entry_log.get()
        if re.match(r'^[0-9]{6}$', ID) == None:
            pass
        else:
            self.send.send(ID)        # this action is infalliable
            self.button_log.config(text='log out', command=self.logout_method)
            self.entry_log.config(state=DISABLED)

    def logout_method(self, ev=None):
        self.send.send('::LOG OUT')
        self.button_log.config(text='log in', command=self.login_method)
        self.entry_log.config(state=NORMAL)

    def contact_method(self, ev=None):
        ID = self.listbox_cat.get(self.listbox_cat.curselection())
        self.send.send('::'+ID)
        self.text_msg.delete(1.0, END)     # delete all text
        self.text_msg.config(state=NORMAL)
        self.text_msg.insert(END, '[to '+ID+' '+ctime()+']\n')
        # if this contact action fails, server will send an error message.

    def add_method(self, ev=None):
        ID = self.entry_add.get()
        if re.match(r'[0-9]{6}', ID) == None:
            pass
        else:
            self.listbox_cat.insert(END, ID)
    
class Send(object):
    '''
    This module deals with every detail in sending bytes through a socket, 
    such as lock, encode, blocking, etc, and provide a send interface for
    GUI module.
    '''
    def __init__(self, fd):
        self.fd = fd
        self.sel = selectors.DefaultSelector()
        self.sel.register(self.fd, selectors.EVENT_WRITE)

    def send(self, data):
        self.sel.select()    # wait until the socket is ready to write
        #if lock.acquire():
        self.fd.send(data.encode('utf-8'))
            #lock.release()
        #else:
        #    pass

class Recv(object):
    '''
    This module deals with every detail in receiving bytes from a socket,
    and providing a friendly recv interface for GUI module.
    '''
    def __init__(self, fd):
        self.fd = fd
        self.sel = selectors.DefaultSelector()
        self.sel.register(self.fd, selectors.EVENT_READ)

    def recv(self):
        while True:
            self.sel.select()
            #if lock.acquire():
            byte = self.fd.recv(BUFSIZE)
            que.put(byte.decode('utf-8'))
            #    lock.release()
            #else:
            #    pass

    def __call__(self):
        self.recv()

class Connt(object):
    '''
    This module deals with establishing a TCP connection with host.
    '''
    def __init__(self, IP):
        self.HOST = IP
        self.PORT = 21567
        self.ADDR = (self.HOST, self.PORT)
        self.tcpCliSock = socket(AF_INET, SOCK_STREAM)

    def connect(self):
        self.tcpCliSock.connect(self.ADDR)
        
    def __call__(self):
        self.connect()

def main():
    gui = GUI()
    gui.root.mainloop()

if __name__ == '__main__':
    main()
    

'''
TCP Server Version 2.2
2015.12.19
'''
import selectors
import threading
import queue
import re
from socket import *
from time import ctime

BUFSIZE = 1024
HOST = input('HOST: ')
PORT = 21567
ADDR = (HOST, PORT)
tcpServSock = socket(AF_INET, SOCK_STREAM)
tcpServSock.bind(ADDR)
tcpServSock.listen(100)

user_list = []    # all registered users
user_buff = {}    # each user has a buffer
acti_user = []    # once a user logs in, he/she becomes active
acti_user_list = []

sel = selectors.DefaultSelector()
lock = threading.Lock()

def recv():
    global tcpServSock
    while True:
        lock.acquire(blocking=True)
        ret = sel.select(timeout=1)
        lock.release()
        for key, event in ret:    # some socket is readable
            if key.fileobj == tcpServSock:    # a new connection comes
                new_socket, new_addr = tcpServSock.accept()
                print('connected from %s [%s]' %(new_addr, ctime()))
                lock.acquire(blocking=True)
                sel.register(new_socket, selectors.EVENT_READ)
                lock.release()
            else:    # some one clicked Log In
                try:
                    ID = key.fileobj.recv(BUFSIZE).decode('utf-8')
                except:
                    print('%s disconnected' %(key.fileobj))
                    lock.acquire(blocking=True)
                    sel.unregister(key.fileobj)
                    lock.release()
                    continue
                if ID not in user_list:
                    user_list.append(ID)
                    acti_user_list.append(ID)
                    user_buff[ID] = queue.Queue(4096)
                    print('%s signed up [%s]' %(ID, ctime()))
                else:
                    if ID in acti_user_list:  # already logged in, deny
                        server_msg = 'FROME SERVER: already logged in'
                        key.fileobj.send(server_msg.encode('utf-8'))
                        continue
                    else:
                        acti_user_list.append(ID)
                    print('%s logged in [%s]' %(ID, ctime()))
                user = User(key.fileobj, ID)    # create an instance for logged in user
                acti_user.append(user)
                user()
                lock.acquire(blocking=True)
                sel.unregister(key.fileobj)
                lock.release()


def forward():
    while True:
        for eachUser in acti_user:
            if eachUser.zombie == True:    # this user has logged out
                lock.acquire(blocking=True)
                sel.register(eachUser.socket, selectors.EVENT_READ)  # after user's loging out,
                                                                     # recv_thread will take over the socket and listen to it
                lock.release()
                acti_user.remove(eachUser)
                del(eachUser)
                continue
            if eachUser.death == True:
                acti_user.remove(eachUser)
                del(eachUser)
                continue
            while user_buff[eachUser.ID].qsize():
                msg = user_buff[eachUser.ID].get()
                ## some ckecking is desired, for the socket may not be writable
                eachUser.socket.send(msg.encode('utf-8'))


class User(object):
    def __init__(self, socket, ID):
        self.socket = socket
        self.ID = ID
        self.zombie = False
        self.death = False
        self.contact = None
        self.sel = selectors.DefaultSelector()
        self.sel.register(self.socket, selectors.EVENT_READ)
    def recv(self):
        while True:
            self.sel.select()
            try:
                msg = self.socket.recv(BUFSIZE).decode('utf-8')
            except:
                print('%s disconnected' %(self.socket))
                acti_user_list.remove(self.ID)
                self.death = True
                return None
            if re.match(r'^::[0-9]{6}', msg):
                # user wants to contact with some one
                contact = msg[2:]
                if contact not in user_list:
                    server_msg = 'FROME SERVER: no such user'
                    self.socket.send(server_msg.encode('utf-8'))
                else:
                    self.contact = msg[2:]
            elif msg == '::LOG OUT':
                # user wants to log out
                acti_user_list.remove(self.ID)
                print('%s logged out [%s]' %(self.ID, ctime()))
                self.zombie = True
                print(self.zombie)
                return None
            else:
                if self.contact != None:
                    msg = '[' + 'frome ' + self.ID + ' ' + ctime() + ']\n' + msg
                    user_buff[self.contact].put(msg)
                else:
                    server_msg = 'FROME SERVER: choose a contact first'
                    self.socket.send(server_msg.encode('utf-8'))
    
    def __call__(self):
        self.recv_thread = threading.Thread(target=self.recv)
        self.recv_thread.daemon = True
        self.recv_thread.start()


def main():
    fd = open(r'.\user.txt', 'r+')
    for eachUser in fd:
        user_list.append(eachUser[0:6])
        user_buff[eachUser[0:6]] = queue.Queue(4096)
    print(user_list)
    
    sel.register(tcpServSock, selectors.EVENT_READ)

    recv_thread = threading.Thread(target=recv)
    recv_thread.daemon = True
    recv_thread.start()

    forward_thread = threading.Thread(target=forward)
    forward_thread.daemon = True
    forward_thread.start()

    while True:
        pass    # infinate loop

if __name__ == '__main__':
    main()