socket实现用户登陆

http://blog.csdn.net/furongkang/article/details/7020060

需求：
通过客户端键盘录入用户名，实现登录。
服务端对客户端的发送过来的用户名进行校验。
如果该用户存在，服务端显示用户登录，并回馈给客户端欢迎光临。
如果该用户不存在，服务端显示用户尝试登录，并回馈给客户端，该用户不存在。

另外，客户端最多只能尝试登录三次。
服务端也一样作此限定。

效果图（左图为客户端，右图为服务器端）：

   

思路：

客户端：
1，建立socket服务。
2，读取键盘录入。
3，将录入的一个用户名数据通过socket的输出发出，给服务端。
4，发出后，要读取服务端回馈的信息。
5，判断该信息，如果有欢迎字样表示登录成功，用户名输入结束。
因为操作的是文本，所以可以使用字符流。并加上缓冲提高效率。

 

服务端：
1，建立socket服务。
2，不断获取客户端对象。
3，将客户端对象封装到单独的线程中。
4，限定判断次数。
5，读取本地用户文件列表，对获取的用户名进行校验。
6，根据校验结果给出响应信息。

 

完整代码：

[java]  view plain  copy

1. import java.net.*;  
2. import java.io.*;  
3. /* 
4.  * 客户端： 
5.  */  
6. class  LoginClient  
7. {  
8.     public static void main(String[] args)throws Exception   
9.     {  
10.         Socket s = new Socket("192.168.137.199",8888);  
11.         //读取键盘录入，获取用户名。  
12.         BufferedReader bufr =   
13.             new BufferedReader(new InputStreamReader(System.in));  
14.   
15.         //对socket输出流进行打印。将录入的用户名发送给服务端。  
16.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
17.   
18.         //对socket输入流中的数据进行获取，其实就是在获取服务端的回馈信息。  
19.         BufferedReader bufIn =   
20.                 new BufferedReader(new InputStreamReader(s.getInputStream()));  
21.   
22.         //客户端值允许录入三次。  
23.         for(int x=0; x<3; x++)  
24.         {  
25.             //从键盘读取一行。  
26.             String username = bufr.readLine();  
27.             if(username==null)  
28.             {  
29.                 //s.shutdownOutput();  
30.                 break;  
31.             }  
32.               
33.             //将该行数据打印到socket输出流。  
34.             out.println(username);  
35.   
36.             //获取服务端反馈信息。  
37.             String info = bufIn.readLine();  
38.             System.out.println(info);  
39.             if(info.contains("欢迎"))  
40.                 break;  
41.         }  
42.   
43.         bufr.close();  
44.         s.close();  
45.     }  
46. }  
47.   
48. /* 
49.  * 服务器端： 
50.  */  
51. class  LoginServer  
52. {  
53.     public static void main(String[] args) throws Exception  
54.     {  
55.         ServerSocket ss = new ServerSocket(8888);  
56.         while(true)  
57.         {  
58.             Socket s = ss.accept();  
59.             System.out.println(s.getInetAddress().getHostAddress()+".....connected");  
60.             new Thread(new UserThread(s)).start();  
61.         }  
62.     }  
63. }  
64.   
65. class UserThread implements Runnable  
66. {  
67.     private Socket s;  
68.     UserThread(Socket s)  
69.     {  
70.         this.s = s;  
71.     }  
72.     public void run()  
73.     {  
74.         try  
75.         {  
76.             for(int x=0; x<3; x++)  
77.             {  
78.                 //判断用户名是否为空  
79.                 BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
80.                 String name = bufIn.readLine();  
81.                 if(name==null)  
82.                 {  
83.                     System.out.println("程序结束 ");  
84.                     break;  
85.                 }  
86.   
87.                 //匹配用户名并实现登陆  
88.                 BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));  
89.                 String line = null;  
90.                 PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
91.                 boolean b = false;  
92.                 while((line=bufr.readLine())!=null)  
93.                 {  
94.                     if(line.equals(name))  
95.                     {  
96.                         b = true;  
97.                         break;  
98.                     }                 
99.                 }  
100.                 if(b)  
101.                 {  
102.                     System.out.println(name+"已登录");  
103.                     out.println(name+"，欢迎光临");  
104.                 }  
105.                 else  
106.                 {  
107.                     System.out.println(name+"尝试登录");  
108.                     out.println(name+"，用户不存在");  
109.                 }  
110.             }  
111.         }  
112.         catch (Exception e)  
113.         {  
114.             System.out.println(e.toString());  
115.         }  
116.         finally  
117.         {  
118.             try  
119.             {  
120.                 if(s!=null)  
121.                     s.close();  
122.             }  
123.             catch (Exception e)  
124.             {  
125.                 System.out.println("close:"+e.toString());  
126.             }  
127.               
128.         }  
129.     }  
130. }  

总结：其实服务器就是类似这样一种程序，当用户请求服务器的时候，它首先会创建socket服务，这样客户端才能连上，第二步把客户端拿到的对象封装成线程，第三步进行数据的传输，服务端底层就是用的这三个技术socket，多线程，io，每个客户端去请求都会做这三个事情，我们就不用去写它了，服务器提供了更简单的对象让你去用。

服务器的作用就一个，不断的去处理客户端的请求并给客户端的请求有相应的应答。