代码示例1：客户端发送信息给服务端，服务端将数据显示在控制台上

  1.     //客户端
  2.     @Test
  3.     public void client()  {
  4.         Socket socket = null;
  5.         OutputStream os = null;
  6.         try {
  7.             //1.创建Socket对象，指明服务器端的ip和端口号
  8.             InetAddress inet = InetAddress.getByName("192.168.14.100");
  9.             socket = new Socket(inet,8899);
  10.             //2.获取一个输出流，用于输出数据
  11.             os = socket.getOutputStream();
  12.             //3.写出数据的操作
  13.             os.write("你好，我是客户端mm".getBytes());
  14.         } catch (IOException e) {
  15.             e.printStackTrace();
  16.         } finally {
  17.             //4.资源的关闭
  18.             if(os != null){
  19.                 try {
  20.                     os.close();
  21.                 } catch (IOException e) {
  22.                     e.printStackTrace();
  23.                 }
  25.             }
  26.             if(socket != null){
  27.                 try {
  28.                     socket.close();
  29.                 } catch (IOException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.             }
  33.         }
  34.     }
  36.     //服务端
  37.     @Test
  38.     public void server()  {
  39.         ServerSocket ss = null;
  40.         Socket socket = null;
  41.         InputStream is = null;
  42.         ByteArrayOutputStream baos = null;
  43.         try {
  44.             //1.创建服务器端的ServerSocket，指明自己的端口号
  45.             ss = new ServerSocket(8899);
  46.             //2.调用accept()表示接收来自于客户端的socket
  47.             socket = ss.accept();
  48.             //3.获取输入流
  49.             is = socket.getInputStream();
  51.             //不建议这样写，可能会乱码
  52. //        byte[] buffer = new byte[1024];
  53. //        int len;
  54. //        while((len = is.read(buffer)) != -1){
  55. //            String str = new String(buffer,0,len);
  56. //            System.out.print(str);
  57. //        }
  58.             //4.读取输入流中的数据
  59.             baos = new ByteArrayOutputStream();
  60.             byte[] buffer = new byte[5];
  61.             int len;
  62.             while((len = is.read(buffer)) != -1){
  63.                 baos.write(buffer,0,len);
  64.             }
  66.             System.out.println(baos.toString());
  68.             System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");
  70.         } catch (IOException e) {
  71.             e.printStackTrace();
  72.         } finally {
  73.             if(baos != null){
  74.                 //5.关闭资源
  75.                 try {
  76.                     baos.close();
  77.                 } catch (IOException e) {
  78.                     e.printStackTrace();
  79.                 }
  80.             }
  81.             if(is != null){
  82.                 try {
  83.                     is.close();
  84.                 } catch (IOException e) {
  85.                     e.printStackTrace();
  86.                 }
  87.             }
  88.             if(socket != null){
  89.                 try {
  90.                     socket.close();
  91.                 } catch (IOException e) {
  92.                     e.printStackTrace();
  93.                 }
  94.             }
  95.             if(ss != null){
  96.                 try {
  97.                     ss.close();
  98.                 } catch (IOException e) {
  99.                     e.printStackTrace();
  100.                 }
  101.             }
  102.         }
  103.     }

代码示例2：客户端发送文件给服务端，服务端将文件保存在本地

  1.     @Test
  2.     public void client() {
  4.         Socket socket = null;
  5.         FileInputStream fis = null;
  6.         OutputStream os = null;
  7.         try {
  8.             InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
  10.             socket = new Socket(inetAddress, 8899);
  12.             fis = new FileInputStream("bg1.jpg");
  14.             os = socket.getOutputStream();
  16.             byte[] buff = new byte[10];
  17.             int len;
  19.             while ((len = fis.read(buff)) != -1) {
  20.                 os.write(buff, 0, len);
  21.             }
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         } finally {
  25.             try {
  26.                 if (os != null)
  27.                     os.close();
  28.             } catch (IOException e) {
  29.                 e.printStackTrace();
  30.             }
  31.             try {
  32.                 if (fis != null)
  33.                     fis.close();
  34.             } catch (IOException e) {
  35.                 e.printStackTrace();
  36.             }
  37.             try {
  38.                 if (socket != null)
  39.                     socket.close();
  40.             } catch (IOException e) {
  41.                 e.printStackTrace();
  42.             }
  43.         }
  45.     }
  47.     @Test
  48.     public void server() {
  50.         ServerSocket ss = null;
  51.         Socket socket = null;
  52.         InputStream is = null;
  53.         FileOutputStream fos = null;
  54.         try {
  55.             ss = new ServerSocket(8899);
  57.             socket = ss.accept();
  59.             is = socket.getInputStream();
  61.             fos = new FileOutputStream("bg4.jpg");
  63.             byte[] buff = new byte[10];
  64.             int len;
  66.             while ((len = is.read(buff)) != -1) {
  67.                 fos.write(buff, 0, len);
  68.             }
  69.         } catch (IOException e) {
  70.             e.printStackTrace();
  71.         } finally {
  72.             try {
  73.                 if (fos != null)
  74.                     fos.close();
  75.             } catch (IOException e) {
  76.                 e.printStackTrace();
  77.             }
  78.             try {
  79.                 if (is != null)
  80.                     is.close();
  81.             } catch (IOException e) {
  82.                 e.printStackTrace();
  83.             }
  84.             try {
  85.                 if (socket != null)
  86.                     socket.close();
  87.             } catch (IOException e) {
  88.                 e.printStackTrace();
  89.             }
  90.             try {
  91.                 ss.close();
  92.             } catch (IOException e) {
  93.                 e.printStackTrace();
  94.             }
  95.         }
  97.     }

代码示例3：从客户端发送文件给服务端，服务端保存到本地并返回“发送成功”给客户端，并关闭相应的连接

  1.     @Test
  2.     public void client() {
  4.         Socket socket = null;
  5.         FileInputStream fis = null;
  6.         OutputStream os = null;
  7.         ByteArrayOutputStream baos = null;
  8.         try {
  9.             InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
  11.             socket = new Socket(inetAddress, 8899);
  13.             fis = new FileInputStream("bg1.jpg");
  15.             os = socket.getOutputStream();
  17.             byte[] buff = new byte[10];
  18.             int len;
  20.             while ((len = fis.read(buff)) != -1) {
  21.                 os.write(buff, 0, len);
  22.             }
  24.             System.out.println("图片发送完成！");
  26.             // 关闭数据的输出
  27.             socket.shutdownOutput();
  29.             InputStream is = socket.getInputStream();
  30.             baos = new ByteArrayOutputStream();
  32.             byte[] buffer = new byte[20];
  33.             int len1;
  35.             while ((len1 = is.read(buffer)) != -1) {
  36.                 baos.write(buffer, 0, len1);
  37.             }
  39.             System.out.println(baos.toString());
  40.         } catch (IOException e) {
  41.             e.printStackTrace();
  42.         } finally {
  43.             try {
  44.                 if (fis != null)
  45.                     fis.close();
  46.             } catch (IOException e) {
  47.                 e.printStackTrace();
  48.             }
  49.             try {
  50.                 if (os != null)
  51.                     os.close();
  52.             } catch (IOException e) {
  53.                 e.printStackTrace();
  54.             }
  55.             try {
  56.                 if (socket != null)
  57.                     socket.close();
  58.             } catch (IOException e) {
  59.                 e.printStackTrace();
  60.             }
  61.             try {
  62.                 if (baos != null)
  63.                     baos.close();
  64.             } catch (IOException e) {
  65.                 e.printStackTrace();
  66.             }
  67.         }
  68.     }
  70.     @Test
  71.     public void server() {
  73.         ServerSocket ss = null;
  74.         InputStream is = null;
  75.         FileOutputStream fos = null;
  76.         try {
  77.             ss = new ServerSocket(8899);
  79.             Socket socket = ss.accept();
  81.             is = socket.getInputStream();
  83.             fos = new FileOutputStream("bg7.jpg");
  85.             byte[] buff = new byte[10];
  86.             int len;
  88.             while ((len = is.read(buff)) != -1) {
  89.                 fos.write(buff, 0, len);
  90.             }
  92.             System.out.println("图片传输完成！");
  94.             OutputStream os = socket.getOutputStream();
  95.             os.write("图片已经收到了，很好看".getBytes());
  96.         } catch (IOException e) {
  97.             e.printStackTrace();
  98.         } finally {
  99.             try {
  100.                 if (fos != null)
  101.                     fos.close();
  102.             } catch (IOException e) {
  103.                 e.printStackTrace();
  104.             }
  105.             try {
  106.                 if (is != null)
  107.                     is.close();
  108.             } catch (IOException e) {
  109.                 e.printStackTrace();
  110.             }
  111.             try {
  112.                 if (ss != null)
  113.                     ss.close();
  114.             } catch (IOException e) {
  115.                 e.printStackTrace();
  116.             }
  117.         }
  119.     }