1. import org.junit.Test;
    3. import java.io.ByteArrayOutputStream;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.io.OutputStream;
    7. import java.net.InetAddress;
    8. import java.net.ServerSocket;
    9. import java.net.Socket;
    11. /**
    12.  * 实现TCP的网络编程
    13.  * 例子1：客户端发送信息给服务端，服务端将数据显示在控制台上
    14.  */
    15. public class TCPTest {
    17.     //客户端
    18.     @Test
    19.     public void client()  {
    20.         Socket socket = null;
    21.         OutputStream os = null;
    22.         try {
    23.             //1.创建Socket对象，指明服务器端的ip和端口号
    24.             InetAddress inet = InetAddress.getByName("192.168.14.100");
    25.             socket = new Socket(inet,8899);
    26.             //2.获取一个输出流，用于输出数据
    27.             os = socket.getOutputStream();
    28.             //3.写出数据的操作
    29.             os.write("你好，我是客户端HH".getBytes());
    30.         } catch (IOException e) {
    31.             e.printStackTrace();
    32.         } finally {
    33.             //4.资源的关闭
    34.             if(os != null){
    35.                 try {
    36.                     os.close();
    37.                 } catch (IOException e) {
    38.                     e.printStackTrace();
    39.                 }
    40.             }
    41.             if(socket != null){
    42.                 try {
    43.                     socket.close();
    44.                 } catch (IOException e) {
    45.                     e.printStackTrace();
    46.                 }
    48.             }
    49.         }
    50.     }
    51.     //服务端
    52.     @Test
    53.     public void server()  {
    55.         ServerSocket ss = null;
    56.         Socket socket = null;
    57.         InputStream is = null;
    58.         ByteArrayOutputStream baos = null;
    59.         try {
    60.             //1.创建服务器端的ServerSocket，指明自己的端口号
    61.             ss = new ServerSocket(8899);
    62.             //2.调用accept()表示接收来自于客户端的socket
    63.             socket = ss.accept();
    64.             //3.获取输入流
    65.             is = socket.getInputStream();
    67.             //不建议这样写，可能会有乱码
    68. //        byte[] buffer = new byte[1024];
    69. //        int len;
    70. //        while((len = is.read(buffer)) != -1){
    71. //            String str = new String(buffer,0,len);
    72. //            System.out.print(str);
    73. //        }
    74.             //4.读取输入流中的数据
    75.             baos = new ByteArrayOutputStream();
    76.             byte[] buffer = new byte[5];
    77.             int len;
    78.             while((len = is.read(buffer)) != -1){
    79.                 baos.write(buffer,0,len);
    80.             }
    82.             System.out.println(baos.toString());
    84.             System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");
    86.         } catch (IOException e) {
    87.             e.printStackTrace();
    88.         } finally {
    89.             if(baos != null){
    90.                 //5.关闭资源
    91.                 try {
    92.                     baos.close();
    93.                 } catch (IOException e) {
    94.                     e.printStackTrace();
    95.                 }
    96.             }
    97.             if(is != null){
    98.                 try {
    99.                     is.close();
    100.                 } catch (IOException e) {
    101.                     e.printStackTrace();
    102.                 }
    103.             }
    104.             if(socket != null){
    105.                 try {
    106.                     socket.close();
    107.                 } catch (IOException e) {
    108.                     e.printStackTrace();
    109.                 }
    110.             }
    111.             if(ss != null){
    112.                 try {
    113.                     ss.close();
    114.                 } catch (IOException e) {
    115.                     e.printStackTrace();
    116.                 }
    117.             }
    118.         }
    119.     }
    120. }
    1. import org.junit.Test;
    3. import java.io.*;
    4. import java.net.InetAddress;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    8. /**
    9.  * 实现TCP的网络编程
    10.  * 例题2：客户端发送文件给服务端，服务端将文件保存在本地。
    11.  *
    12.  * @author subei
    13.  * @create 2020-05-16 17:05
    14.  */
    15. public class TCPTest2 {
    17.     /**
    18.      * 这里涉及到的异常，应该使用try-catch-finally处理
    19.      * @throws IOException
    20.      */
    21.     @Test
    22.     public void test() throws IOException {
    23.         Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
    24.         OutputStream os = socket.getOutputStream();
    25.         FileInputStream fis = new FileInputStream(new File("164.jpg"));
    26.         byte[] buffer = new byte[1024];
    27.         int len;
    28.         while((len = fis.read(buffer)) != -1){
    29.             os.write(buffer,0,len);
    30.         }
    31.         fis.close();
    32.         os.close();
    33.         socket.close();
    34.     }
    36.     /**
    37.      * 这里涉及到的异常，应该使用try-catch-finally处理
    38.      * @throws IOException
    39.      */
    40.     @Test
    41.     public void test2() throws IOException {
    42.         ServerSocket ss = new ServerSocket(9090);
    43.         Socket socket = ss.accept();
    44.         InputStream is = socket.getInputStream();
    45.         FileOutputStream fos = new FileOutputStream(new File("1641.jpg"));
    46.         byte[] buffer = new byte[1024];
    47.         int len;
    48.         while((len = is.read(buffer)) != -1){
    49.             fos.write(buffer,0,len);
    50.         }
    51.         fos.close();
    52.         is.close();
    53.         socket.close();
    54.         ss.close();
    55.     }
    56. }
    1. import org.junit.Test;
    3. import java.io.*;
    4. import java.net.InetAddress;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    8. /**
    9.  * 实现TCP的网络编程
    10.  * 例题3：从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。
    11.  * 并关闭相应的连接。
    12.  *
    13.  */
    14. public class TCPTest3 {
    15.     /**
    16.      * 这里涉及到的异常，应该使用try-catch-finally处理
    17.      * @throws IOException
    18.      */
    19.     @Test
    20.     public void test() throws IOException {
    21.         Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
    22.         OutputStream os = socket.getOutputStream();
    23.         FileInputStream fis = new FileInputStream(new File("164.jpg"));
    24.         byte[] buffer = new byte[1024];
    25.         int len;
    26.         while((len = fis.read(buffer)) != -1){
    27.             os.write(buffer,0,len);
    28.         }
    29.         //关闭数据的输出
    30.         socket.shutdownOutput();
    32.         //5.接收来自于服务器端的数据，并显示到控制台上
    33.         InputStream is = socket.getInputStream();
    34.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    35.         byte[] bufferr = new byte[20];
    36.         int len1;
    37.         while((len1 = is.read(buffer)) != -1){
    38.             baos.write(buffer,0,len1);
    39.         }
    40.         System.out.println(baos.toString());
    42.         fis.close();
    43.         os.close();
    44.         socket.close();
    45.         baos.close();
    46.     }
    48.     /**
    49.      * 这里涉及到的异常，应该使用try-catch-finally处理
    50.      * @throws IOException
    51.      */
    52.     @Test
    53.     public void test2() throws IOException {
    54.         ServerSocket ss = new ServerSocket(9090);
    55.         Socket socket = ss.accept();
    56.         InputStream is = socket.getInputStream();
    57.         FileOutputStream fos = new FileOutputStream(new File("1642.jpg"));
    58.         byte[] buffer = new byte[1024];
    59.         int len;
    60.         while((len = is.read(buffer)) != -1){
    61.             fos.write(buffer,0,len);
    62.         }
    64.         System.out.println("图片传输完成");
    66.         //6.服务器端给予客户端反馈
    67.         OutputStream os = socket.getOutputStream();
    68.         os.write("你好，照片我已收到，风景不错！".getBytes());
    70.         fos.close();
    71.         is.close();
    72.         socket.close();
    73.         ss.close();
    74.         os.close();
    75.     }
    76. }