java网络编程

1. 网络编程概述

网络编程中有两个主要的问题：

  1. 如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
  2. 找到主机后如何可靠高效地进行数据传输

2. 网络通信要素概述

网络编程中的两个要素：

  1. 对应问题一：IP和端口号
  2. 对应问题二：提供网络通信协议：TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层）

3. 通信要素1：IP和端口号

  1. IP:唯一的标识 Internet 上的计算机（通信实体）

  2. 在Java中使用InetAddress类代表IP

  3. IP分类：IPv4 和 IPv6 ; 公网地址(万维网使用)和私有地址(局域网使用)。192.168. 开头的就是私有址址，范围即为192.168.0.0—192.168.255.255，专门为组织机 构内部使用

  4. 域名: www.baidu.com www.mi.com www.sina.com www.jd.com www.vip.com

  5. 本地回路地址：127.0.0.1 对应着：localhost

  6. 如何实例化InetAddress:两个方法：getByName(String host) 、 getLocalHost()
    两个常用方法：getHostName() / getHostAddress()

    1. public class InetAddressTest {
    3.  public static void main(String[] args) {
    5.      try {
    6.          //File file = new File("hello.txt");
    7.          InetAddress inet1 = InetAddress.getByName("192.168.10.14");
    9.          System.out.println(inet1);
    11.          InetAddress inet2 = InetAddress.getByName("www.atguigu.com");
    12.          System.out.println(inet2);
    14.          InetAddress inet3 = InetAddress.getByName("127.0.0.1");
    15.          System.out.println(inet3);
    17.          //获取本地ip
    18.          InetAddress inet4 = InetAddress.getLocalHost();
    19.          System.out.println(inet4);
    21.          //getHostName()
    22.          System.out.println(inet2.getHostName());
    23.          //getHostAddress()
    24.          System.out.println(inet2.getHostAddress());
    26.      } catch (UnknownHostException e) {
    27.          e.printStackTrace();
    28.      }
    29.  }
    30. }

  1. 端口号：标识正在计算机上运行的进程（程序）

    • 要求：不同的进程有不同的端口号
    • 范围：被规定为一个 16 位的整数 0~65535。
  2. 端口号与IP地址的组合得出一个网络套接字：Socket

4. 通信要素2：网络协议

5. TCP网络编程

例题1：客户端发送内容给服务端，服务端将内容打印到控制台上。

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

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

  1. /**
  2.  *
  3.  * 实现TCP的网络编程
  4.  * 例题2：客户端发送文件给服务端，服务端将文件保存在本地。
  5.  *
  6.  * @author shkstart
  7.  * @create 2019 下午 3:53
  8.  */
  9. public class TCPTest2 {
  11.     /*
  12.     这里涉及到的异常，应该使用try-catch-finally处理
  13.      */
  14.     @Test
  15.     public void client() throws IOException {
  16.         //1.
  17.         Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
  18.         //2.
  19.         OutputStream os = socket.getOutputStream();
  20.         //3.
  21.         FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
  22.         //4.
  23.         byte[] buffer = new byte[1024];
  24.         int len;
  25.         while((len = fis.read(buffer)) != -1){
  26.             os.write(buffer,0,len);
  27.         }
  28.         //5.
  29.         fis.close();
  30.         os.close();
  31.         socket.close();
  32.     }
  34.     /*
  35.     这里涉及到的异常，应该使用try-catch-finally处理
  36.      */
  37.     @Test
  38.     public void server() throws IOException {
  39.         //1.
  40.         ServerSocket ss = new ServerSocket(9090);
  41.         //2.
  42.         Socket socket = ss.accept();
  43.         //3.
  44.         InputStream is = socket.getInputStream();
  45.         //4.
  46.         FileOutputStream fos = new FileOutputStream(new File("beauty1.jpg"));
  47.         //5.
  48.         byte[] buffer = new byte[1024];
  49.         int len;
  50.         while((len = is.read(buffer)) != -1){
  51.             fos.write(buffer,0,len);
  52.         }
  53.         //6.
  54.         fos.close();
  55.         is.close();
  56.         socket.close();
  57.         ss.close();
  59.     }
  60. }

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

  1. /**
  2.  * 实现TCP的网络编程
  3.  * 例题3：从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。
  4.  * 并关闭相应的连接。
  5.  * @author shkstart
  6.  * @create 2019 下午 4:13
  7.  */
  8. public class TCPTest3 {
  10.     /*
  11.         这里涉及到的异常，应该使用try-catch-finally处理
  12.          */
  13.     @Test
  14.     public void client() throws IOException {
  15.         //1.
  16.         Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
  17.         //2.
  18.         OutputStream os = socket.getOutputStream();
  19.         //3.
  20.         FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
  21.         //4.
  22.         byte[] buffer = new byte[1024];
  23.         int len;
  24.         while((len = fis.read(buffer)) != -1){
  25.             os.write(buffer,0,len);
  26.         }
  27.         //关闭数据的输出
  28.         socket.shutdownOutput();
  30.         //5.接收来自于服务器端的数据，并显示到控制台上
  31.         InputStream is = socket.getInputStream();
  32.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  33.         byte[] bufferr = new byte[20];
  34.         int len1;
  35.         while((len1 = is.read(buffer)) != -1){
  36.             baos.write(buffer,0,len1);
  37.         }
  39.         System.out.println(baos.toString());
  41.         //6.
  42.         fis.close();
  43.         os.close();
  44.         socket.close();
  45.         baos.close();
  46.     }
  48.     /*
  49.     这里涉及到的异常，应该使用try-catch-finally处理
  50.      */
  51.     @Test
  52.     public void server() throws IOException {
  53.         //1.
  54.         ServerSocket ss = new ServerSocket(9090);
  55.         //2.
  56.         Socket socket = ss.accept();
  57.         //3.
  58.         InputStream is = socket.getInputStream();
  59.         //4.
  60.         FileOutputStream fos = new FileOutputStream(new File("beauty2.jpg"));
  61.         //5.
  62.         byte[] buffer = new byte[1024];
  63.         int len;
  64.         while((len = is.read(buffer)) != -1){
  65.             fos.write(buffer,0,len);
  66.         }
  68.         System.out.println("图片传输完成");
  70.         //6.服务器端给予客户端反馈
  71.         OutputStream os = socket.getOutputStream();
  72.         os.write("你好，美女，照片我已收到，非常漂亮！".getBytes());
  74.         //7.
  75.         fos.close();
  76.         is.close();
  77.         socket.close();
  78.         ss.close();
  79.         os.close();
  81.     }
  82. }

6. UDP网络编程

  1. /**
  2.  * UDP协议的网络编程
  3.  * @author shkstart
  4.  * @create 2019 下午 4:34
  5.  */
  6. public class UDPTest {
  8.     //发送端
  9.     @Test
  10.     public void sender() throws IOException {
  12.         DatagramSocket socket = new DatagramSocket();
  16.         String str = "我是UDP方式发送的导弹";
  17.         byte[] data = str.getBytes();
  18.         InetAddress inet = InetAddress.getLocalHost();
  19.         DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);
  21.         socket.send(packet);
  23.         socket.close();
  25.     }
  26.     //接收端
  27.     @Test
  28.     public void receiver() throws IOException {
  30.         DatagramSocket socket = new DatagramSocket(9090);
  32.         byte[] buffer = new byte[100];
  33.         DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
  35.         socket.receive(packet);
  37.         System.out.println(new String(packet.getData(),0,packet.getLength()));
  39.         socket.close();
  40.     }
  41. }

7. URL编程

URL(Uniform Resource Locator)：统一资源定位符，它表示 Internet 上某一 资源的地址。它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate 这个资源。

  1. /**
  2.  * URL网络编程
  3.  * 1.URL:统一资源定位符，对应着互联网的某一资源地址
  4.  * 2.格式：
  5.  *  http://localhost:8080/examples/beauty.jpg?username=Tom
  6.  *  协议   主机名    端口号  资源地址           参数列表
  7.  *
  8.  * @author shkstart
  9.  * @create 2019 下午 4:47
  10.  */
  11. public class URLTest {
  13.     public static void main(String[] args) {
  15.         try {
  17.             URL url = new URL("http://localhost:8080/examples/beauty.jpg?username=Tom");
  19. //            public String getProtocol(  )     获取该URL的协议名
  20.             System.out.println(url.getProtocol());
  21. //            public String getHost(  )           获取该URL的主机名
  22.             System.out.println(url.getHost());
  23. //            public String getPort(  )            获取该URL的端口号
  24.             System.out.println(url.getPort());
  25. //            public String getPath(  )           获取该URL的文件路径
  26.             System.out.println(url.getPath());
  27. //            public String getFile(  )             获取该URL的文件名
  28.             System.out.println(url.getFile());
  29. //            public String getQuery(   )        获取该URL的查询名
  30.             System.out.println(url.getQuery());
  31.         } catch (MalformedURLException e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  35. }
  1. public class URLTest1 {
  3.     public static void main(String[] args) {
  5.         HttpURLConnection urlConnection = null;
  6.         InputStream is = null;
  7.         FileOutputStream fos = null;
  8.         try {
  9.             URL url = new URL("http://localhost:8080/examples/beauty.jpg");
  11.             urlConnection = (HttpURLConnection) url.openConnection();
  13.             urlConnection.connect();
  15.             is = urlConnection.getInputStream();
  16.             fos = new FileOutputStream("day10\\beauty3.jpg");
  18.             byte[] buffer = new byte[1024];
  19.             int len;
  20.             while((len = is.read(buffer)) != -1){
  21.                 fos.write(buffer,0,len);
  22.             }
  24.             System.out.println("下载完成");
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         } finally {
  28.             //关闭资源
  29.             if(is != null){
  30.                 try {
  31.                     is.close();
  32.                 } catch (IOException e) {
  33.                     e.printStackTrace();
  34.                 }
  35.             }
  36.             if(fos != null){
  37.                 try {
  38.                     fos.close();
  39.                 } catch (IOException e) {
  40.                     e.printStackTrace();
  41.                 }
  42.             }
  43.             if(urlConnection != null){
  44.                 urlConnection.disconnect();
  45.             }
  46.         }
  47.     }
  48. }