1. 
   
2. /**
   
3. 
   
4. 10、 使用TCP协议完成一个客户端一个服务器。客户端从键盘输入读取一个字符串，发送到服务器。
   
5. 服务器接收客户端发送的字符串，反转之后发回客户端。客户端接收并打印。
   
6. @author
   
7. 
   
8. 思路：
   
9. 步骤：
   
10. 
    
11. */
    
12. import java.io.*;
    
13. import java.net.*;
    
14. import java.util.Scanner;
    
15. class TcpServer//服务端
    
16. {
    
17.         public static void main(String[] args)throws Exception
    
18.         {
    
19.                 Socket s=null;
    
20.                 try{
    
21.                         while(true)
    
22.                         {
    
23.                                 ServerSocket serverSocket=new ServerSocket(10001);
    
24.                                 s=serverSocket.accept();
    
25.                                 BufferedReader server_buf=new BufferedReader(new InputStreamReader(s.getInputStream()));
    
26.                                 String str=server_buf.readLine();
    
27.                                 System.out.println("服务端接受到数据...");
    
28.                                 Thread.sleep(10000);
    
29.                                 PrintStream pri=new PrintStream(s.getOutputStream());
    
30.                                 System.out.println("服务端将字符串反转后发送给客户端...");
    
31.                                 pri.println(new StringBuffer(str).reverse());//将反转后的字符串打印到客户端屏幕上
    
32.                         }
    
33.                 }
    
34.                 catch(Exception e)
    
35.                 {
    
36.                         e.printStackTrace();
    
37.                 }
    
38.                 finally{
    
39.                         if(s!=null){
    
40.                                 try{
    
41.                                         s.close();
    
42.                                 }
    
43.                                 catch(Exception e)
    
44.                                 {
    
45.                                         e.printStackTrace();
    
46.                                 }
    
47.                         }
    
48.                 }
    
49.         }
    
50. }
    
51. 
    
52. class TcpClient//客户端
    
53. {
    
54.         public static void main(String[] args)throws Exception
    
55.         {
    
56.                 Socket s=null;
    
57.                 try
    
58.                 {
    
59.                         s=new Socket(InetAddress.getLocalHost(),10001);
    
60.                         while(true){
    
61.                                 BufferedReader client_buf=new BufferedReader(new InputStreamReader(s.getInputStream()));
    
62.                                 PrintStream pri=new PrintStream(s.getOutputStream());
    
63.                                 Scanner sc=new Scanner(System.in);
    
64.                                 System.out.println("请输入一个字符串:");
    
65.                                 String str=sc.nextLine();
    
66.                                 System.out.println("正在向服务器发送数据...");
    
67.                                 pri.println(str);
    
68.                                 System.out.println("接受来自服务器反转的字符串...");
    
69.                                 System.out.println(client_buf.readLine());       
    
70.                                 sc.close();
    
71.                         }
    
72.                 }
    
73.                 catch(Exception e)
    
74.                 {
    
75.                                 e.printStackTrace();
    
76.                 }
    
77.                 finally{
    
78.                         if(s!=null){
    
79.                                 try{
    
80.                                         s.close();
    
81.                                 }
    
82.                                 catch(Exception e)
    
83.                                 {
    
84.                                         e.printStackTrace();
    
85.                                 }
    
86.                         }
    
87.                 }       
    
88.         }
    
89. }
    

复制代码

运行结果是这样的：


求大神解决这是什么错误？
只能完成一次字符串的发送和接受，我写的死循环，可是运行一次后就抛异常了。求解决！

好牛!!!!

感谢大神分享

给顶了，都是大神

向阳泪无痕 发表于 2014-4-16 21:28
服务端
ServerSocket serverSocket=new ServerSocket(10001);
放在while 外面 只须建立 一次连接即可。

大神啊，还是感觉这样好多了！

多一点 发表于 2014-4-16 21:46
import java.io.*;
import java.net.*;
import java.util.Scanner;

可以放在try{}里面 不能放在while里面！谢谢我改了下就可以了！

向阳泪无痕 发表于 2014-4-16 21:28
服务端
ServerSocket serverSocket=new ServerSocket(10001);
放在while 外面 只须建立 一次连接即可。

原来如此！

import java.io.*;
import java.net.*;
import java.util.Scanner;

public class TcpServer1// 服务端
{
        public static void main(String[] args) throws Exception {
                //這兩個都放在外面，
                ServerSocket serverSocket = new ServerSocket(10001);
                Socket s = serverSocket.accept();//客服端一直和服务器通信 连接一次就够了
                try {
                        while (true) {

                                BufferedReader server_buf = new BufferedReader(
                                                new InputStreamReader(s.getInputStream()));
                                String str = server_buf.readLine();
                                System.out.println("服务端接受到数据...");
                                Thread.sleep(2000);
                                PrintStream pri = new PrintStream(s.getOutputStream(), true);
                                System.out.println("服务端将字符串反转后发送给客户端...");
                                pri.println(new StringBuffer(str).reverse());// 将反转后的字符串打印到客户端屏幕上
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                } finally {
                        if (s != null) {
                                try {
                                        s.close();
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }
}

class TcpClient// 客户端
{
        public static void main(String[] args) throws Exception {
                Socket s = null;
                BufferedReader client_buf = null;
                PrintStream pri = null;
                Scanner sc = null;
                try {
                        s = new Socket(InetAddress.getLocalHost(), 10001);
                        while (true) {
                                client_buf = new BufferedReader(new InputStreamReader(
                                                s.getInputStream()));
                                 pri = new PrintStream(s.getOutputStream(), true);
                                 sc = new Scanner(System.in);
                                 System.out.println("请输入一个字符串:");
                                 String str = sc.nextLine();
                                        System.out.println("正在向服务器发送数据...");
                                        pri.println(str);
                                System.out.println("接受来自服务器反转的字符串...");
                                System.out.println(client_buf.readLine());
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                } finally {
                        if (s != null) {
                                try {
                                        s.close();
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }
}
//声明最好都方法try{} 或循环的外面 这个是我的习惯

服务端
ServerSocket serverSocket=new ServerSocket(10001);
放在while 外面 只须建立 一次连接即可。