chatclient.java

JAVA做的QQ软件,感兴趣的可以看看,收藏依旧

	}
	
	//  用户自定义类和函数
	
	//  定义run()函数
	public void run()
	{
		//  用户进入聊天室，发送消息给服务器，通知服务器用户进入
		TransData toServerData = new TransData();
		toServerData.flag = TProtocal.ENTER_USER;
		toServerData.dataObj = (String)userID;						
		try
		{
			Socket toServer = new Socket(ServerIP.ADDRESS,ServerIP.PORT);
			ObjectOutputStream streamToServer = new ObjectOutputStream(toServer.getOutputStream());
			streamToServer.writeObject((TransData)toServerData);
			
			//  不间断的检索服务器发来的消息，并针对性地做出处理
			boolean circulate = true;
			while(circulate)
			{
				ObjectInputStream streamFromServer = new ObjectInputStream(toServer.getInputStream());
				TransData fromServerData = (TransData)streamFromServer.readObject();				
				switch(fromServerData.flag)
				{
					case TProtocal.ENTER_USER:
					{
						new Thread(new CEnterHandler((String)fromServerData.dataObj)).start();						
						break;
					}
					case TProtocal.EXIT_USER:
					{
						new Thread(new CExitHandler((String)fromServerData.dataObj)).start();
						break;
					}
					case TProtocal.TRANS_MSG_INFO:
					{
						UpdateChatTextPane((Message)fromServerData.dataObj);
						break;
					}
					case TProtocal.TRANS_FILE_INFO:
					{
						TransFileInfo fileInfo = new TransFileInfo();
						fileInfo = (TransFileInfo)fromServerData.dataObj;						
						new Thread(new TransFileDialog(this,true,fileInfo.fromUser + "发送文件：" + fileInfo.fileName + "给你！"));
					
						break;
					}
					case TProtocal.HAS_ENTERED_USER:
					{
						new Thread(new HasEnteredHandler((String)fromServerData.dataObj)).start();
						break;
					}
					case TProtocal.SIGNATURE:
					{						
						myMsgTextArea.setToolTipText("我的格言是：" + (String)fromServerData.dataObj);
						break;
					}
					case TProtocal.RETURN_MSG:
					{
						String temp = (String)fromServerData.dataObj;
						dealReturnMessage(temp);						
						break;
					}
					case TProtocal.FORBIDE_ME:
					case TProtocal.SERVER_STOP:
					{						
						new Thread(new TimerDialog(this,true,(String)fromServerData.dataObj));						
						break;
					}
					case TProtocal.SERVER_NOTICE:
					{
						noticeTextArea.setText((String)fromServerData.dataObj);
						break;
					}	
				}				
			}				
			streamToServer.close();
		}
		catch(Exception e)
		{
			System.out.println("传输数据流失败！" + e);
			throw new RuntimeException(e);
		}
	}
	
	//  定义函数dealReturnMessage
	public void dealReturnMessage(String inMsg)
	{
		String showMsg = "";
		if(inMsg.equals("Accept")) 
		{
			showMsg = "传输文件已被接收,并传输完毕！";
						
			//  发送文件到服务器		
			sendFileToTransFileServer(file);
		}
		
		if(inMsg.equals("Refuse")) showMsg = "传输文件被拒收！";
		if(inMsg.equals("Busy")) showMsg = "服务器正忙，请稍后重试！";
		JOptionPane.showMessageDialog(chatTextPane,showMsg);
	}
	
	//  定义函数sendFileToTransFileServer(File file)
	public void sendFileToTransFileServer(File file)
	{
		try
	    {	
	    	Socket toServer = new Socket(ServerIP.ADDRESS,ServerIP.TRANSE_FILE_PORT);		    
		    FileInputStream fis = new FileInputStream(file); 			    
		    OutputStream dos = new DataOutputStream(new BufferedOutputStream(toServer.getOutputStream())); 
		    
		    //  定义文件输入流fis和输出流dos之间的缓冲区buf
		    byte[] buf = new byte[2048];
		    int num = fis.read(buf);					  
		    while(num != (-1))
		    {
		    	//  判断是否读完文件，如果没读完则执行下面的命令
		    	
		    	//  通过dos把buf中的文件数据写出到套接字
                dos.write(buf,0,num);
                //  清空数据输出流dos,迫使所有输出数据被写出到套接字
                dos.flush();
                //  继续从fis中读取数据
                num = fis.read(buf);
            } 
            fis.close();
            dos.close();            		    	
	    }
	    catch(Exception e)
	    {
	    	System.out.println("传输文件到服务器失败！");
	    	e.printStackTrace();
	    }		       			
	}

	//  定义函数UpdateChatTextPane
	public void UpdateChatTextPane(Message inMsg)
	{
		Message tempMsg = new Message();
		String showMsg = "";		
		tempMsg = inMsg;		
		
		if(tempMsg.chatStyle == 0)
		{		
			showMsg = tempMsg.fromUser + "  悄悄地对" + tempMsg.toUser + "说：" + tempMsg.message + "\n";			
			setdocs(showMsg, Color.BLUE, false, 15);
		}
		if(tempMsg.chatStyle == 1)	
		{	
			showMsg = tempMsg.fromUser + "  对" + tempMsg.toUser + "说：" + tempMsg.message + "\n";
			if(tempMsg.fromUser.equals(userID) || tempMsg.toUser.equals(userID))
			{
				setdocs(showMsg, Color.BLUE, false, 15);
			}
			else
			{
				setdocs(showMsg, Color.DARK_GRAY, false, 15);
			}			
		}		
	}
	
	public void insert(String str, AttributeSet attrset) 
	{
		Document doc = chatTextPane.getDocument();		
		try 
		{
			doc.insertString(doc.getLength(), str, attrset);
		} 
		catch(BadLocationException e)
		{
			e.printStackTrace();				
		}
	}
	
	public void setdocs(String str, Color col, boolean bold, int fontsize) 
	{
		SimpleAttributeSet attrset = new SimpleAttributeSet();
		StyleConstants.setForeground(attrset, col);// 颜色
		
		if (bold == true) 
		{
			StyleConstants.setBold(attrset, true);// 字体类型
		}
		
		StyleConstants.setFontSize(attrset, fontsize);// 字体大小	
		
		insert(str, attrset);
	}		
						
	
	//  定义鼠标点击在线用户列表监听器
	
	class LoginUserListener extends	MouseAdapter
	{
		public void mouseClicked(MouseEvent evt)
		{
			String toUser = String.valueOf(login_usersList.getSelectedValue()).trim();
			boolean exist = false;		
			String existUser;
			
			for(int i = 0;i < toComboBox.getItemCount();i++)
			{
				existUser = String.valueOf(toComboBox.getItemAt(i)).trim();
				if(toUser.compareTo(existUser) == 0)
				{
					exist = true;
					break;
				}
			}
			if(!exist) toComboBox.addItem(toUser);			
					
			toComboBox.setSelectedItem(toUser);
		}
	}
	
	//  定义"退出聊天室"按钮监听器
	
	class ExitListener implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			dispose();	
		}
	}
	
	//  定义"发送消息"按钮监听器
	
	class SendMsgListener implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			Message msg = new Message();
			msg.fromUser = userID;
			msg.toUser = String.valueOf(toComboBox.getSelectedItem()).trim();
			msg.message = myMsgTextArea.getText().trim();
			if(msg.message.compareTo("") == 0)
			{
				JOptionPane.showMessageDialog(chatTextPane,"不能发送空消息！");
			}
			else if(userID.equals(msg.toUser))
			{
				JOptionPane.showMessageDialog(chatTextPane,"不能和自己聊天！");
			}
			else
			{
				if(onlyCheckBox.isSelected() && onlyCheckBox.isEnabled())
				{
					msg.chatStyle = 0;
				}
				else
				{
					msg.chatStyle = 1;
				}
				
				TransData toServerData = new TransData();
				toServerData.flag = TProtocal.TRANS_MSG_INFO;
				toServerData.dataObj = (Message)msg;
				try
				{
					Socket toServer = new Socket(ServerIP.ADDRESS,ServerIP.PORT);
					ObjectOutputStream streamToServer = new ObjectOutputStream(toServer.getOutputStream());
					streamToServer.writeObject((TransData)toServerData);
				}
				catch(Exception e)
				{
					System.out.println("发送消息到服务器失败！" + e);
					throw new RuntimeException(e);
				}				
			}
			myMsgTextArea.setText("");
		}		
	}
	
	//  定义toComboBox监听器类
	class CBoxListener implements ItemListener
	{
		public void itemStateChanged(ItemEvent evt)
		{
			if(evt.getSource() == toComboBox)
			{				
				if(toComboBox.getSelectedIndex() == 0)
				{
					onlyCheckBox.setEnabled(false);
					onlyCheckBox.setSelected(false);
				}
				else
				{
					onlyCheckBox.setEnabled(true);
				}				
			}
		}
	}
	
	//  定义"发送文件"按钮监听器类
	class TransFileListener implements ActionListener
	{

		public void actionPerformed(ActionEvent evt)
		{
			String toUser = String.valueOf(toComboBox.getSelectedItem()).trim();
			if(userID.compareTo(toUser) == 0)
			{
				JOptionPane.showMessageDialog(chatTextPane,"不能给自己发文件！");
			}
			else if(toUser.compareTo("所有人") == 0)
			{
				JOptionPane.showMessageDialog(chatTextPane,"不能给所有人发文件！");
			}
			else
			{
				//  设置文件打开对话框
				JFileChooser fileChooser = newFileChooser(); 			
				int returnVal = fileChooser.showOpenDialog(chatTextPane);
			    
			    if(returnVal == JFileChooser.CANCEL_OPTION)
			    {		    	
			    }
			    if(returnVal == JFileChooser.APPROVE_OPTION) 
			    {
			    	TransFileInfo transFileInfo = new TransFileInfo();
	    			transFileInfo.fromUser = userID;
	    			transFileInfo.toUser = toUser;
	    			transFileInfo.fileName = fileChooser.getSelectedFile().getName();
	    			file = fileChooser.getSelectedFile(); 
	    			
			    	//  发送传输文件的相关信息到服务器
			    	sendFileInfoToChatServer(transFileInfo);    		    				    
				    
			    }				
			}
		}
		
		//  定义函数sendFileInfoToChatServer(TransFileInfo transFileInfo)
		public void sendFileInfoToChatServer(TransFileInfo transFileInfo)
		{	    	
	    	TransData toServerData = new TransData();
	    	toServerData.flag = TProtocal.TRANS_FILE_INFO;
	    	toServerData.dataObj = (TransFileInfo)transFileInfo;
	    	try
	    	{
	    		Socket toServer = new Socket(ServerIP.ADDRESS,ServerIP.PORT);
	    		ObjectOutputStream streamToServer = new ObjectOutputStream(toServer.getOutputStream());
	    		streamToServer.writeObject((TransData)toServerData);
	    	}
	    	catch(Exception e)
		    {
		    	System.out.println("发送传输文件的相关信息失败！" + e);
		    	e.printStackTrace();
		    }
		}	
		
	}	
	//  定制文件打开或保存对话框
	public JFileChooser newFileChooser()
	{		
		JFileChooser fileChooser = new JFileChooser();    		
		ExamFileFilter jpgFilter = new ExamFileFilter("jpg", "JPEG Compressed Image Files");
		ExamFileFilter gifFilter = new ExamFileFilter("gif", "GIF Image Files");
		ExamFileFilter javaFilter = new ExamFileFilter(new String[] {"java", "class"}, "Java Files");		

		fileChooser.addChoosableFileFilter(gifFilter);
		fileChooser.addChoosableFileFilter(javaFilter);	
		fileChooser.addChoosableFileFilter(jpgFilter);
		fileChooser.setCurrentDirectory(new File("./TempFiles"));		
		return fileChooser;
	}
	class ShowUserInfoListener implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			if(login_usersList.getSelectedIndex() == -1)
			{
				JOptionPane.showMessageDialog(null,"请选中要显示的用户！");
			}
			else
			{
				String selectedUserID = String.valueOf(login_usersList.getSelectedValue()).trim();
				new ShowUserInfo(selectedUserID);
			}
		}
	}
}