java 聊天室之 传送图片文字等功能的实现

 前几日写的一篇简陋之极的java聊天室被各位前辈说是，一塌糊涂，乌烟瘴气，只是简单的实现了需要的功能，并未做到人性化。在下痛定思痛，心想还是先学会显示功能再做美化界面，美化代码的打算！

      在奋斗了一天之后终于完成了集图片，文字，直线等功能为一体的群聊天室。先分析代码如下：

 

关于界面什么的我就不说了，笔者在前面的博客中有提过！直接附上各种功能的实现方法。

首先我们要传送信息，必须要让被传送的对象知道我们传送的是什么东西，所以在传送信息之前，我们首先要确定一个协议，比如说当客户端接收到的第一个int 值为1的时候，它接下来就要再接收4个int值，据此来画一条直线，而我服务器画一条直线的时候可以获得该直线的四个int值，但是在利用IO流发送这四个int值的时候，我首先要先发送一个1，也就是说我每次在要发送一天直线之前就要先发送一个1，当然在客户端读取的时候，我们第一次读取到的是1，就接收四个int。当读完四个int之后并画完一条直线之后我们还要读取数据，如果还是1的话，我们继续上面的操作，如果读取的是2，按照规定的协议，我们就调用相应的方法即可！！！！

现附上服务器发送直线的代码如下，该代码是写在界面类里面的内部类：

Java代码  

1. //鼠标进入事件  
2. MouseListener ms=(new MouseListener(){  
3.         public void mousePressed(MouseEvent e){  
4.           
5.          x1=e.getX();  
6.          y1=e.getY();  
7.  }                  
8.         public void mouseReleased(MouseEvent e){  
9.         int x2=e.getX();  
10.         int y2=e.getY();  
11.         g.drawLine(x1,y1,x2,y2);  
12.         ChatTools.castbyte(1);  
13.         ChatTools.castbyte(x1);  
14.         ChatTools.castbyte(y1);  
15.         ChatTools.castbyte(x2);  
16.         ChatTools.castbyte(y2);               
17.         }  
18.         public void mouseClicked(MouseEvent e){}  
19.         public void mouseEntered(MouseEvent e){}  
20.         public void mouseExited (MouseEvent e){}             
21. });  
22.     jp.addMouseListener(ms);  

 

 

当然相应的我们也要在客户端定义一个读取数据的方法，首先我们要判断发送过来的是什么东西，我设置的协议是，如果首先读到的是1，接下来就画直线，如果读到的是2，接下来就接收一张图片，如果读到的是4，接下来读到的就是一段文字。该方法是放在客户端的线程中的，并且在线程的Run方法中调用该方法。

并且在每执行完一次操作之后，便再次读取一个int值，再次判断该int值为多少，以便得到下一个执行的指令。

 

 

Java代码  

1. public void processServer(Socket client){  
2.         try{          
3.             ins=client.getInputStream();  
4.             OutputStream out=client.getOutputStream();    
5.             dis = new DataInputStream(ins);           
6.             dout=new DataOutputStream(out);  
7.         int t=dis.readInt();  
8.             while(true){  
9.                 //如果读到的是1，调用读取线段的方法  
10.             if(t==1){  
11.                 readline();  
12.             }     
13.             //读到的是2则调用接受画面的方法  
14.             if(t==2){  
15.                 readPic();  
16.             }  
17.             //如果读到的是4，则调用接受文字的方法  
18.             if(t==4){                 
19.                 readMsg();  
20.             }  
21.             t=dis.readInt();  
22.             }  
23.             }catch(Exception ef){  
24.             ef.printStackTrace();  
25.             }  
26.     }  

 

当判断int值为1的时候，我们就调用画直线的方法，该方法如下

Java代码  

1. //定义一个读取线段的方法  
2.     public void readline() {  
3.             try {  
4.                 int x1=dis.readInt();  
5.                 int y1=dis.readInt();  
6.                 int x2=dis.readInt();  
7.                 int y2=dis.readInt();  
8.                 g.drawLine(x1,y1,x2,y2);  
9.             } catch (IOException e) {  
10.                 e.printStackTrace();  
11.             }  
12.     }  

 

 

 

当然，我们需要在客户端和服务器都要定义相同功能的传送和接收方法。

现在我们再写一个文字的接收方法，首先我们会在文本输入框中输入字符，并获得该文本内容，每当按下发送这个按钮时便调用消息的传送方法，将该消息发送出去！

 

 

 

Java代码  

1. ActionListener al=(new ActionListener(){  
2. public void actionPerformed(ActionEvent e){  
3.         String s=e.getActionCommand();  
4.         if(s.equals("创建")){  
5.   
6.             Chatserver cs=new Chatserver(9090,jta,dout,g);                        
7.             cs.start();  
8.         }  
9.         //将服务器消息发给每个人  
10.         if(s.equals("发送")){                           
11.             String msg=jte1.getText();  
12.             ChatTools.castMsg(msg);  
13.             jta.append("服务器说："+msg+"\r\n");  
14.             jte1.setText("");  
15.         }  

 

其中ChatTools.castMsg();是一个消息群发的方法，该方法在队列类里面定义的，代码如下

Java代码  

1. //将一个消息发送给所有人  
2. ublic static void castMsg(String str){    
3. ChatTools.castbyte(4);  
4. for(int i=0;i<list.size();i++){            
5.     ServerThread st=list.get(i);              
6.     st.sendMs(i+"说："+str);  
7. }  

Java代码  

1.    

 而sendMsg();则是一个消息的发送方法。该方法如下

Java代码  

1.         //将发送消息的代码包装到一个方法中  
2.     public void sendMs(String msg){  
3.             try{  
4.                 msg+="\r\n";  
5.                 dout.write(msg.getBytes());  
6.                 //强制输出  
7.                 dout.flush();         
8.             }catch(Exception ef){}  
9. }     

 

实现字符串传输的重中之重便是读取的方法，我们会首先获得一个为4的int值，然后我们就要调用字符串的读取方法

Java代码  

1.     public void readMsg(){  
2.         try{  
3.             brd=new BufferedReader(new InputStreamReader(ins));  
4.             String input=brd.readLine();  
5.             jta.append(input +"\r\n");    
6.         }catch(Exception ef){}  
7. }     

 我使用的BufferedReader缓冲流，实现整行读取的方式，该方式不会产生乱码，所以还是不错的。

 

 

而我今天要重点讲的便是图片从文件中读取和传送的方法。

首先我们要获得图片，再者我们要获取图片的宽度和高度，在循环遍历每个像素点，获取该点的颜色值，接着我们便在画布中调用画线的方法，依次画出每个像素点，并相应的给每个点附上相应的颜色即可。这样一张图片就在自己的画布上显示出来了！代码如下

Java代码  

1. ActionListener al=(new ActionListener(){  
2.         public void actionPerformed(ActionEvent e){  
3.             String s=e.getActionCommand();  
4.             if(s.equals("创建")){  
5.   
6.             Chatserver cs=new Chatserver(9090,jta,dout,g);                        
7.             cs.start();  
8.                     }  
9.                     //将服务器消息发给每个人  
10.             if(s.equals("发送")){                           
11.             String msg=jte1.getText();  
12.             ChatTools.castMsg(msg);  
13.             jta.append("服务器说："+msg+"\r\n");  
14.             jte1.setText("");  
15.             }  
16.             if(s.equals("图片")){  
17.                           
18.             try {  
19.             BufferedImage image = ImageIO.read(new File("2.jpg"));  
20.             int m=image.getHeight();  
21.             int n=image.getWidth();  
22.                               
23.             for(int i=0;i<n;i++){  
24.             for(int j=0;j<m;j++){  
25.             rgb=image.getRGB(i,j);  
26.             System.out.println(i);  
27.             System.out.println(j);                                        
28.             Color color=new Color(rgb);                                           
29.             g.setColor(color);  
30.             g.drawLine(i,j,i,j);  
31.             ChatTools.castbyte(2);  
32.             ChatTools.castbyte(rgb);  
33.              ChatTools.castbyte(i);  
34.                     ChatTools.castbyte(j);  
35.         }     
36.                                       
37.     }  
38. } catch (IOException e1) {  
39.         e1.printStackTrace();  
40.     }  

 

能画出图片，当然我们就能发送图片，我们就能相应的读取图片，在发送图片信息的时候，我们每取出一个点，就能获得该店的颜色，我们就把该点横坐标和纵坐标以及颜色值发送过去。在接收端，我们会首先读到一个为2的int值，然后程序会调用图片的读取方法。方法如下

Java代码  

1. //图片的读取方法  
2. public void readPic(){  
3.         int rgb;  
4.     try {  
5.         rgb = dis.readInt();      
6.         int i=dis.readInt();  
7.         int j=dis.readInt();          
8.         Color color =new Color(rgb);  
9.         g.setColor(color);  
10.         g.drawLine(i,j,i,j);  
11.   
12.     } catch (IOException e) {  
13.   
14.         e.printStackTrace();  
15.     }  
16.     }  

 值此，我们就实现了图片的发送功能了。我的代码也差不多了，至于如果有什么需要改进的地方请各位多多指教，本人是新手，迫切渴望成长，我也知道我的代码可定有很多漏洞，望不吝赐教！！！！！！！！！！！

 

现在附上具体的代码：服务器的四个类

界面类

Java代码  

1. import java.awt.Color;  
2. import java.awt.Graphics;  
3. import java.awt.event.ActionEvent;  
4. import java.awt.event.ActionListener;  
5. import java.awt.event.MouseEvent;  
6. import java.awt.event.MouseListener;  
7. import java.awt.image.BufferedImage;  
8. import java.io.DataOutputStream;  
9. import java.io.File;  
10. import java.io.IOException;  
11.   
12. import javax.imageio.ImageIO;  
13. import javax.swing.JButton;  
14. import javax.swing.JFrame;  
15. import javax.swing.JPanel;  
16. import javax.swing.JTextArea;  
17. import javax.swing.JTextField;  
18.       
19.     public class MainServer {     
20.             private int x1;  
21.             private int y1;  
22.             private Graphics g;  
23.             private DataOutputStream dout;  
24.             private int rgb;  
25.               
26.             public void ShowUI(){  
27.                 JFrame jf=new JFrame();  
28.                 jf.setTitle("       服务器");  
29.                 jf.setSize(600,600);  
30.                 jf.setLayout(null);  
31.                 jf.setDefaultCloseOperation(3);  
32.                 JButton jb=new JButton("创建");  
33.                 jb.setBounds(0,0,60,30);  
34.                 final JButton jm = new JButton("图片");// 实例化菜单栏的对象  
35.                 jm.setBounds(70,0,60,30);  
36.                 jf.add(jm);  
37.                 JButton jb1=new JButton("发送");  
38.                 jb1.setBounds(0,40,60,30);  
39.                 final JTextField jte1=new JTextField(30);  
40.                 jte1.setBounds(70,45,300,20);  
41.                 final JTextArea jta=new JTextArea(20,30);  
42.                 jta.setBounds(0,80,600,150);  
43.                 final JPanel jp=new JPanel();  
44.                 jp.setBounds(0,250,600,600);  
45.                 jf.add(jb);  
46.                 jf.add(jb1);  
47.                 jf.add(jte1);  
48.                 jf.add(jta);  
49.                 jf.add(jp);  
50.                 jf.setVisible(true);                  
51.                 jp.setBackground(Color.gray);  
52.                 this.g=jp.getGraphics();  
53.                                   
54.             ActionListener al=(new ActionListener(){  
55.             public void actionPerformed(ActionEvent e){  
56.                 String s=e.getActionCommand();  
57.                 if(s.equals("创建")){  
58.   
59.                 Chatserver cs=new Chatserver(9090,jta,dout,g);                        
60.                 cs.start();  
61.                         }  
62.                         //将服务器消息发给每个人  
63.                 if(s.equals("发送")){                           
64.                 String msg=jte1.getText();  
65.                 ChatTools.castMsg(msg);  
66.                 jta.append("服务器说："+msg+"\r\n");  
67.                 jte1.setText("");  
68.                 }  
69.                 if(s.equals("图片")){  
70.                               
71.                 try {  
72.                 BufferedImage image = ImageIO.read(new File("2.jpg"));  
73.                 int m=image.getHeight();  
74.                 int n=image.getWidth();  
75.                                   
76.                 for(int i=0;i<n;i++){  
77.                 for(int j=0;j<m;j++){  
78.                 rgb=image.getRGB(i,j);  
79.                 System.out.println(i);  
80.                 System.out.println(j);                                        
81.                 Color color=new Color(rgb);                                           
82.                 g.setColor(color);  
83.                 g.drawLine(i,j,i,j);  
84.                 ChatTools.castbyte(2);  
85.                 ChatTools.castbyte(rgb);  
86.                 ChatTools.castbyte(i);  
87.                 ChatTools.castbyte(j);  
88.             }     
89.                                           
90.         }  
91.     } catch (IOException e1) {  
92.             e1.printStackTrace();  
93.         }  
94.                               
95.                     }  
96.                 }  
97.                 });  
98.                 jm.addActionListener(al);  
99.                 jb.addActionListener(al);  
100.                 jb1.addActionListener(al);  
101.                   
102.             //鼠标进入事件  
103.             MouseListener ms=(new MouseListener(){  
104.                     public void mousePressed(MouseEvent e){  
105.                       
106.                      x1=e.getX();  
107.                      y1=e.getY();  
108.              }                  
109.                     public void mouseReleased(MouseEvent e){  
110.                     int x2=e.getX();  
111.                     int y2=e.getY();  
112.                     g.drawLine(x1,y1,x2,y2);  
113.                     ChatTools.castbyte(1);  
114.                     ChatTools.castbyte(x1);  
115.                     ChatTools.castbyte(y1);  
116.                     ChatTools.castbyte(x2);  
117.                     ChatTools.castbyte(y2);               
118.                     }  
119.                     public void mouseClicked(MouseEvent e){}  
120.                     public void mouseEntered(MouseEvent e){}  
121.                     public void mouseExited (MouseEvent e){}             
122.             });  
123.                 jp.addMouseListener(ms);  
124.             }  
125.         public static void main(String[] args){  
126.                 MainServer ms=new MainServer();  
127.                 ms.ShowUI();  
128.             }  
129.             }  

 

处理客户机连接的两个线程类

Java代码  

1. import java.awt.Graphics;  
2. import java.io.DataOutputStream;  
3. import java.net.ServerSocket;  
4. import java.net.Socket;  
5.   
6. import javax.swing.JTextArea;  
7.   
8. public class Chatserver extends Thread{  
9.         private Graphics g;  
10.         private int port;  
11.         private JTextArea jta;  
12.         private DataOutputStream dout;//输出流  
13.         private ServerSocket ss;  
14.           
15.         public Chatserver(int port,JTextArea jta,DataOutputStream dout,Graphics g){  
16.             this.port=port;  
17.             this.jta=jta;  
18.             this.dout=dout;  
19.             this.g=g;  
20.         }  
21.       
22.         public void run(){  
23.                 setUpServer(port);  
24.         }  
25.             //在指定端口上创建一个服务器  
26.     public void setUpServer(int port){  
27.         try{  
28.             ss = new ServerSocket(port);  
29.             System.out.println("服务器创建成功");  
30.             //等待客户机连接，并设置成循环等待状态  
31.         while(true){                  
32.                 Socket client=ss.accept();  
33.                 System.out.println("欢迎进入我的服务器");              
34.                 //启动一个线程去处理该对象  
35.                 ServerThread st=new ServerThread(client,jta,dout,g);  
36.                 st.start();  
37.                 ChatTools.add(st);  
38.                 ChatTools.castMsg("有人上线！！目前在线人数"+ChatTools.getsize());  
39.             }  
40.         }catch(Exception ef){  
41.             ef.printStackTrace();  
42.         }  
43.     }  
44. }  
45.   
46.       

 

Java代码  

1. import java.awt.Color;  
2. import java.awt.Graphics;  
3. import java.io.BufferedReader;  
4. import java.io.DataInputStream;  
5. import java.io.DataOutputStream;  
6. import java.io.IOException;  
7. import java.io.InputStream;  
8. import java.io.InputStreamReader;  
9. import java.io.OutputStream;  
10. import java.net.Socket;  
11.   
12. import javax.swing.JTextArea;  
13.   
14. public class ServerThread extends Thread{  
15.             private Socket client;//线程中处理的客户对象  
16.             private DataOutputStream dout;//输出流  
17.             private OutputStream out;//输出流  
18.             private DataInputStream dis;//  
19.             private JTextArea jta;  
20.             private BufferedReader brd;   
21.             private InputStream ins;  
22.               
23.   
24.             //创建线程对象时要传入他要处理的连接对象  
25.             private Graphics g;  
26.     public ServerThread(Socket client,JTextArea jta,DataOutputStream dout,Graphics g){  
27.             this.client=client;       
28.             this.jta=jta;  
29.             this.dout=dout;  
30.             this.g=g;             
31.             }  
32.       
33.       
34.     public void readMsg(){  
35.         try{  
36.             brd=new BufferedReader(new InputStreamReader(ins));  
37.             String input=brd.readLine();              
38.             jta.append("客户说："+input +"\r\n");     
39.             ChatTools.castMsg(input);  
40.         }catch(Exception ef){}  
41. }  
42.             //将发送消息的代码包装到一个方法中  
43.     public void sendMs(String msg){  
44.             try{  
45.                 msg+="\r\n";  
46.                 dout.write(msg.getBytes());  
47.                 //强制输出  
48.                 dout.flush();         
49.             }catch(Exception ef){}  
50. }     
51.       
52.   
53.       
54.     public void run(){  
55.         //在线程中 调用处理链接的方法  
56.         processChat(this.client);  
57.           
58.     }  
59.       
60.       
61.     //处理客户机进入的连接对象  
62.     public void processChat(Socket client){  
63.         try{          
64.             ins=client.getInputStream();  
65.             out=client.getOutputStream();     
66.             dis = new DataInputStream(ins);           
67.             dout=new DataOutputStream(out);  
68.         int t=dis.readInt();  
69.             while(true){  
70.             if(t==1){  
71.                 readline();  
72.             }     
73.             if(t==2){  
74.                 readPic();  
75.             }  
76.             if(t==4){                 
77.                 readMsg();  
78.             }  
79.             t=dis.readInt();  
80.             }  
81.             }catch(Exception ef){  
82.             ef.printStackTrace();  
83.             }  
84.     }  
85.       
86.     //发送int型值得方法  
87. public void sendbyte(int x1){         
88.         try{  
89.             dout.writeInt(x1);  
90.             dout.flush();  
91.         }catch(Exception e){}  
92.     }  
93.     //图片的读取方法  
94. public void readPic(){  
95.         int rgb;  
96.     try {  
97.         rgb = dis.readInt();      
98.         int i=dis.readInt();  
99.         int j=dis.readInt();          
100.         Color color =new Color(rgb);  
101.         g.setColor(color);  
102.         g.drawLine(i,j,i,j);  
103.     } catch (IOException e) {  
104.         e.printStackTrace();  
105.     }  
106.     }  
107.     //定义一个读取线段的方法  
108. public void readline() {  
109.             try {  
110.                 int x1=dis.readInt();  
111.                 int y1=dis.readInt();  
112.                 int x2=dis.readInt();  
113.                 int y2=dis.readInt();  
114.                 g.drawLine(x1,y1,x2,y2);  
115.             } catch (IOException e) {  
116.                 e.printStackTrace();  
117.             }  
118.     }  
119.   
120. }  

 一个队列类，用来存储连接进服务器的客户机对象类

Java代码  

1. import java.util.ArrayList;  
2. import java.util.List;  
3.   
4.   
5. public class ChatTools {  
6.         //保存处理线程的队列对象  
7.     static List<ServerThread> list=new ArrayList<ServerThread>();  
8.       
9.     private ChatTools(){  
10.           
11.     }//不需要创建引类对象，构造器则私有  
12.     //取得保存保存处理线程对象的队列  
13.     public static List<ServerThread> getAllthread(){  
14.         return list;  
15.     }  
16.         //将一个客户对应的处理线程对象加入到队列中   
17.     public static void add(ServerThread st){  
18.         //通知有人上线了  
19.           
20.         list.add(st);  
21. }  
22.       
23.     public static int getsize(){  
24.         int i=list.size();  
25.         return i;  
26.     }  
27.         //将一个消息发送给所有人  
28.     public static void castMsg(String str){   
29.         ChatTools.castbyte(4);  
30.         for(int i=0;i<list.size();i++){            
31.             ServerThread st=list.get(i);              
32.             st.sendMs(i+"说："+str);  
33.         }  
34.     }  
35.     //定义一个字节群发的方法  
36.     public static void castbyte(int x1){          
37.         for(int i=0;i<list.size();i++){            
38.             ServerThread st=list.get(i);  
39.             st.sendbyte(x1);  
40.         }  
41.     }  
42. }  

 

 

接下来便是客户机的两个类

界面类

Java代码  

1. package 多人聊天室客户端;  
2.   
3.   
4. import java.awt.Color;  
5. import java.awt.Graphics;  
6. import java.awt.event.ActionEvent;  
7. import java.awt.event.ActionListener;  
8. import java.awt.event.MouseEvent;  
9. import java.awt.event.MouseListener;  
10. import java.awt.image.BufferedImage;  
11. import java.io.File;  
12. import java.io.IOException;  
13. import java.io.InputStream;  
14.   
15. import javax.imageio.ImageIO;  
16. import javax.swing.JButton;  
17. import javax.swing.JFrame;  
18. import javax.swing.JPanel;  
19. import javax.swing.JTextArea;  
20. import javax.swing.JTextField;  
21.   
22.   
23.   
24. public class Mainchat {  
25.   
26.     private MainchatThread mt;  
27.     private Graphics g;  
28.     private int x1;  
29.     private int y1;  
30.     private InputStream ins;  
31.     private int rgb;  
32.       
33.     public void ShowUI(){  
34.           
35.         JFrame jf=new JFrame();  
36.         jf.setTitle("        客户机");  
37.         jf.setSize(600,500);  
38.         jf.setLocation(700,0);  
39.         jf.setLayout(null);  
40.         jf.setDefaultCloseOperation(3);  
41.         JButton jb=new JButton("连接");  
42.         jb.setBounds(0,0,60,30);  
43.         final JButton jm = new JButton("图片");// 实例化菜单栏的对象  
44.         jm.setBounds(70,0,60,30);  
45.         jf.add(jm);  
46.         JButton jb1=new JButton("发送");  
47.         jb1.setBounds(0,40,60,30);  
48.         final JTextField jte1=new JTextField(30);  
49.         jte1.setBounds(70,45,300,20);  
50.         final JTextArea jta=new JTextArea(20,30);  
51.         jta.setBounds(0,80,600,150);  
52.         JPanel jp=new JPanel();  
53.         jp.setBounds(0,250,600,400);  
54.         jf.add(jb);  
55.         jf.add(jb1);  
56.         jf.add(jte1);  
57.         jf.add(jta);  
58.         jf.add(jp);  
59.         jf.setVisible(true);  
60.           
61.         jp.setBackground(Color.gray);  
62.         this.g=jp.getGraphics();  
63.           
64.         ActionListener al=(new ActionListener(){  
65.             public void actionPerformed(ActionEvent e){  
66.                 String s=e.getActionCommand();  
67.                 if(s.equals("连接")){  
68.                     try {         
69.                      mt=new MainchatThread("localhost",9090,jta,g,ins);   
70.                      if(mt.runing()){  
71.                          mt.start();                           
72.                      }  
73.                     } catch (Exception e1) {                      
74.                         e1.printStackTrace();  
75.                     }                         
76.                 }  
77.                 //将消息发给别人  
78.                 if(s.equals("发送")){  
79.                     String msg=jte1.getText();                    
80.                     jta.append("我说："+msg+"\r\n");     
81.                     MainchatThread.sendbyte(4);  
82.                     mt.sendMsg(msg);  
83.                     System.out.println("消息已经发送");  
84.                     jte1.setText("");  
85.                 }  
86.                 if(s.equals("图片")){                   
87.                     try {  
88.                     BufferedImage image = ImageIO.read(new File("2.jpg"));  
89.                     int m=image.getHeight();  
90.                     int n=image.getWidth();                                   
91.                     for(int i=0;i<n;i++){  
92.                     for(int j=0;j<m;j++){  
93.                     rgb=image.getRGB(i,j);  
94.                     System.out.println(i);  
95.                     System.out.println(j);                                        
96.                     Color color=new Color(rgb);                                           
97.                     g.setColor(color);  
98.                     g.drawLine(i,j,i,j);  
99.                     MainchatThread.sendbyte(2);  
100.                     MainchatThread.sendbyte(rgb);  
101.                     MainchatThread.sendbyte(i);  
102.                     MainchatThread.sendbyte(j);  
103.                 }                                                 
104.             }  
105.         } catch (IOException e1) {  
106.                 e1.printStackTrace();  
107.     }                                 
108. }                 
109.         }  
110.         });  
111.         jm.addActionListener(al);  
112.         jb.addActionListener(al);  
113.         jb1.addActionListener(al);            
114.         jf.setVisible(true);  
115.         MouseListener ms=(new MouseListener(){  
116.             public void mousePressed(MouseEvent e){           
117.              x1=e.getX();  
118.              y1=e.getY();  
119.              System.out.println(x1);  
120.          }  
121.   
122.             
123.             public void mouseReleased(MouseEvent e){  
124.             int x2=e.getX();  
125.             int y2=e.getY();  
126.             g.drawLine(x1,y1,x2,y2);  
127.             MainchatThread.sendbyte(1);  
128.             MainchatThread.sendbyte(x1);  
129.             MainchatThread.sendbyte(y1);  
130.             MainchatThread.sendbyte(x2);  
131.             MainchatThread.sendbyte(y2);  
132.             }  
133.             public void mouseClicked(MouseEvent e){}  
134.             public void mouseEntered(MouseEvent e){}  
135.             public void mouseExited (MouseEvent e){}             
136.     });  
137.             jp.addMouseListener(ms);  
138.     }   
139.   
140.     public static void main(String[] args){  
141.         Mainchat ms=new Mainchat();                               
142.         ms.ShowUI();  
143.     }  
144.       
145. }  

 

线程类，用来运行客户机读取服务器发来的信息

Java代码  

1. package 多人聊天室客户端;  
2.   
3. import java.awt.Color;  
4. import java.awt.Graphics;  
5. import java.io.BufferedReader;  
6. import java.io.DataInputStream;  
7. import java.io.DataOutputStream;  
8. import java.io.IOException;  
9. import java.io.InputStream;  
10. import java.io.InputStreamReader;  
11. import java.io.OutputStream;  
12. import java.net.Socket;  
13. import javax.swing.JTextArea;  
14.   
15.   
16. public class MainchatThread extends Thread{  
17.     private static DataOutputStream dout;  
18.     private InputStream ins;  
19.     private BufferedReader brd;   
20.     private int port;  
21.     private String ip;  
22.     private JTextArea jta;  
23.     private Graphics g;  
24.     private DataInputStream dis;  
25.     private Socket socket;  
26.   
27.   
28.     public MainchatThread(String ip,int port,JTextArea jta,Graphics g,InputStream ins){  
29.         this.jta=jta;  
30.         this.ip=ip;  
31.         this.port=port;  
32.         this.g=g;  
33.         this.ins=ins;  
34.     }  
35.   
36.     public boolean runing(){  
37.         try{  
38.             socket=new Socket(this.ip,this.port);         
39.             System.out.println("连接成功");  
40.             InputStream ins=socket.getInputStream();  
41.             OutputStream out=socket.getOutputStream();  
42.             dis=new DataInputStream(ins);  
43.             dout=new DataOutputStream(out);           
44.         return true;  
45.         }catch (Exception e){  
46.             e.printStackTrace();  
47.         }return false;  
48.         }  
49.     //图片的读取方法  
50. public void readPic(){  
51.         int rgb;  
52.     try {  
53.         rgb = dis.readInt();      
54.         int i=dis.readInt();  
55.         int j=dis.readInt();          
56.         Color color =new Color(rgb);  
57.         g.setColor(color);  
58.         g.drawLine(i,j,i,j);  
59.   
60.     } catch (IOException e) {  
61.   
62.         e.printStackTrace();  
63.     }  
64.     }  
65.     //发送信息  
66.     public void sendMsg(String msg){  
67.         try{  
68.             msg+="\r\n";  
69.             dout.write(msg.getBytes());  
70.             dout.flush();  
71.         }catch(Exception ef){}  
72. }  
73.     public static void sendbyte(int i){  
74.         try{  
75.             dout.writeInt(i);  
76.             dout.flush();  
77.         }catch(Exception ef){}  
78. }  
79.       
80.     //读取服务端信息的方法  
81.     public void readMsg(){  
82.         try{  
83.             brd=new BufferedReader(new InputStreamReader(ins));  
84.             String input=brd.readLine();  
85.             jta.append(input +"\r\n");    
86.         }catch(Exception ef){}  
87. }     
88.   
89.     public void readline(){  
90.         try{  
91.                 int x1=dis.readInt();  
92.                 int y1=dis.readInt();  
93.                 int x2=dis.readInt();  
94.                 int y2=dis.readInt();  
95.                 g.drawLine(x1,y1,x2,y2);  
96.         }catch(Exception ef){}  
97. }     
98.   
99.       
100.     public void processServer(Socket client){  
101.         try{          
102.             ins=client.getInputStream();  
103.             OutputStream out=client.getOutputStream();    
104.             dis = new DataInputStream(ins);           
105.             dout=new DataOutputStream(out);  
106.         int t=dis.readInt();  
107.             while(true){  
108.                 //如果读到的是1，调用读取线段的方法  
109.             if(t==1){  
110.                 readline();  
111.             }     
112.             //读到的是2则调用接收图片的方法  
113.             if(t==2){  
114.                 readPic();  
115.             }  
116.             //如果读到的是4，则调用接受文字的方法  
117.             if(t==4){                 
118.                 readMsg();  
119.             }  
120.             t=dis.readInt();  
121.             }  
122.             }catch(Exception ef){  
123.             ef.printStackTrace();  
124.             }  
125.     }  
126.     public void run(){  
127.         processServer(socket);  
128. }  
129.       
130. }  

 

 

至此完结！！！