package com.ccsu.xie.net;

import java.io.*;
import java.net.*;

public class TcpDemo {
        public static void main(String[] args) throws Exception {

                //建立服务器端服务
                ServerSocket ss = new ServerSocket(10000);
                new Thread(new StringFormat(ss)).start();
               
                //建立客户端Socket服务
                Socket socket = new Socket("127.0.0.1",10000);
                new Thread(new Writer(socket)).start();
               
               
               
        }

}


//服务端:用来接收数据并转换(小写变大写) 再传给客户端
class StringFormat implements Runnable{
        private ServerSocket ss = null;
        public StringFormat(ServerSocket ss){
                this.ss = ss;
        }
        @Override
        public void run() {
                /*
                 * 为什么放在whiel循环外面可以正常运行，
                 * Socket s=null;
                try {
                        s = ss.accept();
                } catch (Exception e) {
                        // TODO: handle exception
                }
               
                */
                while(true){
                        //放这里就不能正常运行了呢????????????????
                        Socket s=null;
                        try {
                                s = ss.accept();
                        } catch (Exception e) {
                                // TODO: handle exception
                        }
                        try {
                                System.out.println("服务器断正在等待数据.....");
                                System.out.println("Connected successed");
                                //获取输入流
                                InputStream is =s.getInputStream();
                                byte [] buf = new byte[1024];
                                int len = is.read(buf);
                                String info = new String(buf,0,len);
                                System.out.println("服务器端收到数据: "+info);
                                if("over".equals(info))
                                        break;
                                //获取输出流
                                OutputStream os = s.getOutputStream();
                                info ="Server: "+ info;
                                os.write(info.toUpperCase().getBytes());
                               
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }
                try {
                        ss.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }       
        }       
}


//客户端:用来接收键盘输入数据，传给服务端，并接收服务端返回的信息
class Writer implements Runnable{
        private Socket socket=null;
        public Writer(Socket socket){
                this.socket = socket;
        }
        @Override
        public void run() {
                OutputStream os=null;
                InputStream is =null;
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                while(true){
                        System.out.println("请输入你想要转换的字符串");
                        String line = null;
                    try {
                                line = br.readLine();
                                System.out.println(line);
                                //获取socket输出流，并将键盘录入字符串发送到服务器端
                                os = socket.getOutputStream();
                                os.write(line.getBytes());
                                if("over".equals(line))
                                        break;
                                //获取socket输入流
                                is = socket.getInputStream();
                                byte [] sInfo = new byte[1024];
                                int len = is.read(sInfo);
                                System.out.println("客户端收到数据: "+new String(sInfo,0,len));
                                Thread.sleep(100);
                        } catch (Exception e) {
                                e.printStackTrace();
                               
                        }
                       
                }
                //关闭socket流对象s
                try {
                        socket.close();
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }finally{
                        try{
                                br.close();
                        } catch (IOException e1) {
                                e1.printStackTrace();
                        }
                }
               
        }
       
}

张学林 发表于 2013-3-8 11:13
第46行有说明,我把客户端单独拿出来的,以便验证

对啊。。每次连接都重新获取socket对象。。应该可以正常运行

第46行有说明,我把客户端单独拿出来的,以便验证

1. 
   
2. import java.io.*;
   
3. import java.net.*;
   
4. 
   
5. public class TcpDemo {
   
6.         public static void main(String[] args) throws Exception {
   
7. 
   
8.                 //建立服务器端服务
   
9.                 ServerSocket ss = new ServerSocket(10000);
   
10.                 new Thread(new StringFormat(ss)).start();
    
11.                
    
12.                 //建立客户端Socket服务
    
13. //                Socket socket = new Socket("127.0.0.1",10000);
    
14. //                new Thread(new Writer(socket)).start();
    
15.                
    
16.                
    
17.                
    
18.         }
    
19. 
    
20. }
    
21. 
    
22. 
    
23. //服务端:用来接收数据并转换(小写变大写) 再传给客户端
    
24. class StringFormat implements Runnable{
    
25.         private ServerSocket ss = null;
    
26.         public StringFormat(ServerSocket ss){
    
27.                 this.ss = ss;
    
28.         }
    
29.         @Override
    
30.         public void run() {
    
31. //                 Socket s=null;
    
32. //                try {
    
33. //                        s = ss.accept();
    
34. //                } catch (Exception e) {
    
35. //                        // TODO: handle exception
    
36. //                }
    
37. //               
    
38.                
    
39.                 while(true){
    
40.                         //放这里就不能正常运行了呢????????????????
    
41.                         Socket s=null;
    
42.                         System.out.println("aaaaaaaaaaaafdsaf");
    
43.                         try {
    
44.                                 s = ss.accept();
    
45.                                 System.out.println(s.getInetAddress().getHostAddress()+"...."+s.getPort());
    
46.                                 //这句话可以验证,当你把它放在里面的时候,s = null会把你的客户端端口关闭s = ss.accpet( )会
    
47.                                 //重新开个接收的端口
    
48.                      } catch (Exception e) {
    
49.                                 // TODO: handle exception
    
50.                         }
    
51.                         try {
    
52.                                 System.out.println("服务器断正在等待数据.....");
    
53.                                 
    
54.                                 System.out.println(s.getInetAddress().getHostAddress()+"  Connected successed  "+s.getPort());
    
55.                                 //获取输入流
    
56.                                 InputStream is =s.getInputStream();
    
57.                                 byte [] buf = new byte[1024];
    
58.                                 int len = is.read(buf);
    
59.                                 String info = new String(buf,0,len);
    
60.                                 System.out.println("服务器端收到数据: "+info);
    
61.                                 if("over".equals(info))
    
62.                                         break;
    
63.                                 //获取输出流
    
64.                                 OutputStream os = s.getOutputStream();
    
65.                                 info ="Server: "+ info;
    
66.                                 os.write(info.toUpperCase().getBytes());
    
67.                                 
    
68.                         } catch (Exception e) {
    
69.                                 e.printStackTrace();
    
70.                         }
    
71.                 }
    
72.                 try {
    
73.                         ss.close();
    
74.                 } catch (IOException e) {
    
75.                         e.printStackTrace();
    
76.                 }        
    
77.         }        
    
78. }
    
79. 
    
80. 
    
81. //客户端:用来接收键盘输入数据，传给服务端，并接收服务端返回的信息
    
82. class Writer /*implements Runnable*/{
    
83.         public static void main(String[] args) {
    
84.                
    
85.                 Socket socket=null;
    
86.                 try {
    
87.                         socket = new Socket("127.0.0.1",10000);
    
88.                         System.out.println(socket.getPort()+"~~~~~~~~~~~~~~~~~");
    
89.                 } catch (UnknownHostException e2) {
    
90.                         // TODO Auto-generated catch block
    
91.                         e2.printStackTrace();
    
92.                 } catch (IOException e2) {
    
93.                         // TODO Auto-generated catch block
    
94.                         e2.printStackTrace();
    
95.                 }
    
96. //        private Socket socket=null;
    
97. //        public Writer(Socket socket){
    
98. //                this.socket = socket;
    
99. //        }
    
100. //        @Override
     
101. //        public void run() {
     
102.                 OutputStream os=null;
     
103.                 InputStream is =null;
     
104.                 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
     
105.                 while(true){
     
106.                         System.out.println("请输入你想要转换的字符串");
     
107.                         String line = null;
     
108.                     try {
     
109.                             System.out.println("333333333333333");
     
110.                                 line = br.readLine();
     
111. //                                System.out.println(line);
     
112.                                 //获取socket输出流，并将键盘录入字符串发送到服务器端
     
113.                                 os = socket.getOutputStream();
     
114.                                 os.write(line.getBytes());
     
115.                                 if("over".equals(line))
     
116.                                         break;
     
117.                                 //获取socket输入流
     
118.                                 is = socket.getInputStream();
     
119.                                 byte [] sInfo = new byte[1024];
     
120.                                 int len = is.read(sInfo);
     
121.                                 System.out.println("客户端收到数据: "+new String(sInfo,0,len));
     
122.                                 Thread.sleep(100);
     
123.                         } catch (Exception e) {
     
124.                                 e.printStackTrace();
     
125.                                 
     
126.                         }
     
127.                         
     
128.                 }
     
129.                 //关闭socket流对象s
     
130.                 try {
     
131.                         socket.close();
     
132.                 } catch (IOException e) {
     
133.                         // TODO Auto-generated catch block
     
134.                         e.printStackTrace();
     
135.                 }finally{
     
136.                         try{
     
137.                                 br.close();
     
138.                         } catch (IOException e1) {
     
139.                                 e1.printStackTrace();
     
140.                         }
     
141.                 }
     
142.                
     
143. //        }
     
144.         
     
145. }
     
146. }

复制代码

夏晓彤 发表于 2013-3-7 21:29
为我没看到问题

//放这里就不能正常运行了呢????????????????
                 Socket socket = ss.accept();

放在while循环里面客户端就只能传输一次数据，之后就好像死锁了.

为我没看到问题