黑马程序员技术交流社区

标题: TCP协议传输字符流问题 [打印本页]
作者: 浅一蓝    时间: 2014-3-12 15:35
标题: TCP协议传输字符流问题
使用TCP协议完成一个客户端一个服务器。客户端从键盘输入读取一个字符串，发送到服务器。
服务器接收客户端发送的字符串，反转之后发回客户端。客户端接收并打印。
作者: 上官睿鹏    时间: 2014-3-12 16:48
本帖最后由 上官睿鹏 于 2014-3-12 16:53 编辑

这应该是黑马基础测试题里面的吧?我记得之前做过~客户端：
  1. import java.io.DataInputStream;
  2. import java.io.DataOutputStream;
  3. import java.io.IOException;
  4. import java.net.Socket;
  5. import java.util.Scanner;

  7. public class Client {
  8.        public static void main(String[] args) {
  9.               launchClient();
  10.        }

  12.        private static void launchClient() {
  13.              Socket s = null;
  14.              DataOutputStream dos = null;
  15.              DataInputStream dis = null;
  16.              Scanner sc = null;
  17.                
  18.       try {
  19.            while(true) {
  20.                      s = new Socket("127.0.0.1", 9999); //创建请求指定服务器的Socket对象
  21.                      dos = new DataOutputStream(s.getOutputStream()); //创建数据输出流
  22.                                 
  23.                      System.out.println("请输入:");
  24.                      sc = new Scanner(System.in);
  25.                      String str = sc.next();   //得到键盘输入的数据
  26.                     dos.writeUTF(str);    //将数据写入
  27.                                 
  28.                    dis = new DataInputStream(s.getInputStream());//创建输入流
  29.                    System.out.println("反转之后：" + dis.readUTF()); //接受并打印经服务器反转之后的字符串
  30.              }
  31.        } catch (IOException e) {
  32.                   e.printStackTrace();
  33.        } finally {
  34.                   try {
  35.                         dos.close();
  36.                   } catch (IOException e) {
  37.                         e.printStackTrace();
  38.                   }
  39.                         
  40.                  sc.close();
  41.                         
  42.                 try {
  43.                         s.close();
  44.                 } catch (IOException e) {
  45.                         e.printStackTrace();
  46.                       }
  47.                }
  48.          }
  49. }
复制代码


服务器端：
  1. import java.io.DataInputStream;
  2. import java.io.DataOutputStream;
  3. import java.io.IOException;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;

  7. public class Server {
  8.         public static void main(String[] args) {
  9.                 launchServer();
  10.         }

  12.         private static void launchServer() {
  13.                 ServerSocket server = null;
  14.                 Socket s = null;
  15.                 DataInputStream dis = null;
  16.                 DataOutputStream dos = null;
  17.                 while(true) {
  18.                         try {
  19.                                 server = new ServerSocket(9999);     //创建绑定端口9999的ServerSocket对象
  20.                                 
  21.                                 System.out.println("服务器已启动！");
  22.                                 
  23.                                 s = server.accept();              //接收客户端请求，得到Socket
  24.                                 dis = new DataInputStream(s.getInputStream()); //创建数据输入流
  25.                                 String m = dis.readUTF();         //读取客户端发送的数据并返回一个String类型的对象
  26.                                 
  27.                                 StringBuffer sb = new StringBuffer(m);   //将String类型转换成StringBuffer类型便已反转
  28.                                 m = sb.reverse().toString();                        //将从客服端接受的字符串反转
  29.                                 
  30.                                 dos = new DataOutputStream(s.getOutputStream()); //穿件数据输出流
  31.                                 dos.writeUTF(m);       //将反转之后的字符串写入内存让客户端读取
  32.                                 
  33.                         } catch (IOException e) {
  34.                                 e.printStackTrace();
  35.                         } finally {
  36.                                 try {
  37.                                         dis.close();
  38.                                         s.close();
  39.                                         server.close();
  40.                                 } catch (IOException e) {
  41.                                         e.printStackTrace();
  42.                                 }
  43.                         }
  44.                         
  45.                 }
  46.         }
  47. }
复制代码

作者: 黄翔    时间: 2014-3-12 17:07
客户端
import java.io.*;
import java.net.*;
class  TransClient{
        public static void main(String[] args) throws Exception{
                Socket s = new Socket("192.168.1.100",10005);
               
                //定义读取键盘数据的流对象
                BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
               
                //定义目的，将数据写入到socket输出流，发给服务端
        BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

                //定义一个socket读取流，读取服务端返回的大写信息
                BufferedReader bufIn =
                        new BufferedReader(new InputStreamReader(s.getInputStream()));

                String line = null;
                while((line=bufr.readLine())!=null){
                        if("over".equals(line))
                                break;
                        bufOut.write(line);
                        bufOut.newLine();
                        bufOut.flush();

                        String str = bufIn.readLine();
                        System.out.println("Server:"+str);
                }
                bufr.close();
                s.close();
        }       
}
作者: 黄翔    时间: 2014-3-12 17:08
服务端
class  TransServer{
        public static void main(String[] args) throws Exception{
                ServerSocket ss = new ServerSocket(10005);
                Socket s = ss.accept();
                String ip = s.getInetAddress().getHostAddress();
                System.out.println(ip+".....connected");

                //读取socket读取流中的数据
                BufferedReader bufIn =
                        new BufferedReader(new InputStreamReader(s.getInputStream()));
               
                //目的，socket输出流，将大写数据写入到socket输出流，并发送给客户端
                BufferedWriter bufOut =
                        new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
               
                String line = null;
                while((line=bufIn.readLine())!=null){
                        System.out.println(line);
                        bufOut.write(line.toUpperCase());
                        bufOut.newLine();
                        bufOut.flush();
                }
                s.close();
                ss.close();
        }
}
作者: 浅一蓝    时间: 2014-3-13 09:25
谢谢米娜



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2