A股上市公司传智教育（股票代码 003032）旗下技术交流社区北京昌平校区

传智教育官网黑马程序员官网

 找回密码
 加入黑马

QQ登录

只需一步，快速开始

论坛首页 › 隐藏归类 › 黑马那些年 › 第6届JavaEE+hadoop大数据技术交流 › 正文

这题结果总不对

© 酱爆 高级黑马   /  2013-10-2 23:26  /  1302 人查看  /  2 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 酱爆 于 2013-10-3 20:19 编辑

没有抛异常， 不知道是哪不对，大家帮忙看看
  1. import java.io.*;
  2. import java.net.*;

  4. class TextClient
  5. {
  6.         public static void  main(String[] args)
  7.         {
  8.                
  9.                 Socket s = null;
  10.                 BufferedReader br = null;
  11.                
  12.                 try
  13.                 {
  14.                         s = new Socket("192.168.1.102",10001);
  15.                         System.out.println("AAAAAAAAAAAAAAAGGGGGGGGGGGGGGGGGGGFFFF");
  16.                         System.out.println(s.getInetAddress().getHostAddress());
  17.                         br = new BufferedReader(new FileReader("IPDome.java"));
  18.                         
  19.                         PrintWriter out = new PrintWriter(s.getOutputStream(),true);        
  20.                         
  21.                         String line = null;
  22.                         
  23.                         while ((line = br.readLine()) != null)
  24.                         {
  25.                                 out.println(line);
  26.                         }
  27.                         out.println("over");
  28.                         
  29.                         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
  30.                         
  31.                         String str = null;
  32.                         
  33.                         str = bufIn.readLine();
  34.                         System.out.println(str);
  35.                         
  36.                                                 
  37.                 }
  38.                 catch(Exception e)
  39.                 {
  40.                         e.printStackTrace();
  41.                 }
  42.                 finally
  43.                 {
  44.                         try
  45.                         {
  46.                                 if (br != null)
  47.                                         br.close();
  48.                                 if (s != null)
  49.                                         s.close();
  50.                         }
  51.                         catch(Exception e)
  52.                         {
  53.                                 e.printStackTrace();
  54.                         }
  55.                 }
  56.                
  57.         }
  58. }

  60. class TextServer
  61. {
  62.         public static void main(String[] args)
  63.         {
  64.                 ServerSocket ss = null;
  65.                 Socket s  = null;
  66.                 PrintWriter pw = null;
  67.                
  68.                 try
  69.                 {
  70.                         ss = new ServerSocket(10001);
  71.                         s = ss.accept();
  72.                         String ip = s.getInetAddress().getHostAddress();
  73.                         System.out.println("AAAAAAAAAAAAAAAAAAAAAAAAAAAA");
  74.                         System.out.println(ip);
  75.                         
  76.                         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
  77.                         pw = new PrintWriter(new FileWriter("D:\\123.txt"),true);
  78.                         String str = null;
  79.                         
  80.                         while ((str = bufIn.readLine()) != null)
  81.                         {
  82.                                 
  83.                                 if ("over".equals(str))
  84.                                         break;
  85.                                 pw.println(str);
  86.                         }
  87.                         

  89.                         
  90.                         PrintWriter out = new PrintWriter(s.getOutputStream(),true);
  91.                         
  92.                         out.println("上传成功！");
  93.                         
  94.                         
  95.                 }
  96.                 catch(Exception e)
  97.                 {
  98.                         e.printStackTrace();
  99.                 }
  100.                 finally
  101.                 {
  102.                         try
  103.                         {
  104.                                 if (pw != null)
  105.                                         pw.close();
  106.                                 if (s != null)
  107.                                         s.close();
  108.                                 if (ss != null)
  109.                                         ss.close();
  110.                         }
  111.                         catch(Exception e)
  112.                         {
  113.                                 e.printStackTrace();
  114.                         }
  115.                 }
  116.         }
  117. }
复制代码



评分

参与人数 1技术分 +1 收起 理由
黄文伯 + 1 赞一个!

查看全部评分

2 个回复

倒序浏览
straw 中级黑马 2013-10-3 12:29:44
| 只看该作者
沙发
又一个敲代码不写注释的!苦啊  哥们  不过还好你这功能是常见的,要不就不好读了.
1,在客户端里当你写完数据流的时候一定关闭套接字符流s.shutdownOutPut();这步很关键的,如果不执行的话,服务端是受不到数据流的.
2,在服务端里,在向客户端写完数据流时也要关闭套接字符流,否则客户端会认为服务端还有数据要写,所以客户端是接受不到服务端的数据流的.
如果你还看不懂的话,我下面的代码跟你的要求是类似的,你看下就知道了:
  1. package day23;

  3. /*
  4. * 多线程  tcp传输图片
  5. *
  6. * */
  7. import java.net.*;
  8. import java.io.*;

  10. public class TcpImage {
  11.         public static void main(String[] ages) {
  12.                 // 客户端
  13.                 new Thread(new Runnable() {
  14.                         //创建服务端套接字
  15.                         Socket sk = null;
  16.                         //定义文件读取流
  17.                         FileInputStream fis = null;
  18.                         public void run() {
  19.                                 try {
  20.                                         sk = new Socket(InetAddress.getByName("192.168.128.1"),
  21.                                                         2008);
  22.                                         OutputStream os = sk.getOutputStream();
  23.                                         //将服务获取的读取流转换成字符流
  24.                                         BufferedReader bisr = new BufferedReader(
  25.                                                         new InputStreamReader(sk.getInputStream()));
  26.                                         //获取原文件的读取流
  27.                                         fis = new FileInputStream("E:\\a.txt");
  28.                                         byte[] bt = new byte[1024];
  29.                                         int end;
  30.                                         while ((end = fis.read(bt)) != -1) {
  31.                                                 os.write(bt, 0, end);
  32.                                         }
  33.                                         //关闭客服端的写入流  这不非常重要 如果没有关闭该流  则数据不会发送到服务端
  34.                                         sk.shutdownOutput();
  35.                                         String line;
  36.                                         while ((line = bisr.readLine()) != null) {
  37.                                                 System.out.println(line);
  38.                                         }
  39.                                 } catch (Exception e) {
  40.                                         throw new RuntimeException("客户端异常退出");
  41.                                 } finally {
  42.                                         if (fis != null) {
  43.                                                 try {
  44.                                                         fis.close();
  45.                                                 } catch (IOException e) {
  46.                                                         throw new RuntimeException("客户端服务关闭异常");
  47.                                                 }
  48.                                         }

  50.                                         if (sk != null) {
  51.                                                 try {
  52.                                                         sk.close();
  53.                                                 } catch (IOException e) {
  54.                                                         throw new RuntimeException("客户端服务关闭异常");
  55.                                                 }
  56.                                         }
  57.                                 }
  58.                         }
  59.                 }).start();
  60.                 // 服务端
  61.                 new Thread(new Runnable(){
  62.                         //创建一个服务套接字
  63.                         ServerSocket ssk = null;
  64.                         FileOutputStream fos = null;
  65.                         public void run() {
  66.                                 try {
  67.                                         ssk = new ServerSocket(2008);
  68.                                         fos = new FileOutputStream("F:\\a.txt");
  69.                                         //获取服务端接受到的客户套接字
  70.                                         Socket sk = ssk.accept();
  71.                                         //获取客户套接字的读取流对象
  72.                                         InputStream br = sk.getInputStream();
  73.                                         BufferedWriter bw = new BufferedWriter(
  74.                                                         new OutputStreamWriter(sk.getOutputStream()));
  75.                                         byte[] bt = new byte[1024];
  76.                                         int endr;
  77.                                         while ((endr = br.read(bt)) != -1) {
  78.                                                 fos.write(bt, 0, endr);
  79.                                         }
  80.                                         bw.write(sk.getInetAddress()+"成功上传");
  81.                                         bw.newLine();
  82.                                         bw.flush();
  83.                                         //关闭服务端接受的客户端套接字的写入流  这个步骤也非常重要 如果没有该步 那么服务端线程将处于线程等待机制
  84.                                         sk.shutdownOutput();
  85.                                 } catch (IOException e) {
  86.                                         throw new RuntimeException("服务端异常退出");
  87.                                 } finally {
  88.                                         if (fos != null) {
  89.                                                 try {
  90.                                                         fos.close();
  91.                                                 } catch (IOException e) {
  92.                                                         throw new RuntimeException("服务写入流关闭异常");
  93.                                                 }
  94.                                         }
  95.                                         if (ssk != null) {
  96.                                                 try {
  97.                                                         ssk.close();
  98.                                                 } catch (IOException e) {
  99.                                                         throw new RuntimeException("服务关闭异常");
  100.                                                 }
  101.                                         }
  102.                                 }
  103.                         }
  104.                 }).start();
  105.         }
  106. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
黄文伯 + 1 神马都是浮云

查看全部评分

回复 使用道具 举报
酱爆 高级黑马 2013-10-3 20:18:59
| 只看该作者
藤椅
straw 发表于 2013-10-3 12:29
又一个敲代码不写注释的!苦啊  哥们  不过还好你这功能是常见的,要不就不好读了.
1,在客户端里当你写完数据 ...

哈哈，我会改正的！解决了，是ip出了问题，谢谢！！！
回复 使用道具 举报
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 加入黑马