zoukankan      html  css  js  c++  java
  • 网络编程

    1.1 网络概念

    计算机通过物理线路连接起来,就形成了网络。目的在于交换数据和共享信息。

    1.1.1 网络通信的三要素

    1IP地址:唯一标识网络上的每一台计算机。两台计算机之间通信的必备有素

    2】端口号:计算机中应用的标号(代表一个应用程序)

    0-1024系统使用或保留端口

    常见端口:http:80 stmp: 25 ftp:21

        有效端口0-65536,开发者可以的端口是1025-65536之间一些第三方引用mysql:3306 oracle:1251

    3】通信协议:通信的规则 TCP,UDP

    1.1.2 网络通信模型

     

    IP地址分类

    特殊IP

    • 0.0.0.0:本机
    • 127.0.0.1:本机回环地址,用于本机测试
    • 255.255.255.255:当前子网,一般用于向当前子网广播信息

    1.2 InetAddress

    InetAddress 表示IP地址。

     1 public class Test01 {
     2 
     3 public static void main(String[] args) {
     4 
     5 // 获取本机IP地址
     6 
     7 InetAddress ip1;
     8 
     9 try {
    10 
    11 ip1 = InetAddress.getLocalHost();
    12 
    13 // USER-20180113BT/192.168.2.56
    14 
    15 System.out.println(ip1.toString());
    16 
    17  
    18 
    19 // 获取主机名称
    20 
    21 System.out.println(ip1.getHostName());
    22 
    23 System.out.println(ip1.getHostAddress());
    24 
    25  
    26 
    27 } catch (UnknownHostException e) {
    28 
    29 e.printStackTrace();
    30 
    31 }
    32 
    33 }
    34 
    35 }

    1.3 TCP 编程

    TCP编程中,如果要完成通信,通信双方必须创建socket,通过socket完成通信

    TCP通信步骤

    [1] 服务器启动ServerSocket作为通信的Server端,等待客户端链入。

    [2] 客户端创建Socket作为通信的Client

    [3] Client链入Server后建立可靠的双向的持续性的点对点的通讯连接,即可通信

    案例:完成一次单向通信。

    服务器

     1 package cn.sxt01.net01;
     2 
     3  
     4 
     5 import java.io.IOException;
     6 
     7 import java.io.OutputStream;
     8 
     9 import java.net.ServerSocket;
    10 
    11 import java.net.Socket;
    12 
    13  
    14 
    15 public class Server01 {
    16 
    17 public static void main(String[] args) {
    18 
    19  
    20 
    21 System.out.println("服务器启动...");
    22 
    23  
    24 
    25 // 【1】创建server socket
    26 
    27 ServerSocket serverSocket = null;
    28 
    29 Socket clientSocket = null;
    30 
    31 try {
    32 
    33  
    34 
    35 serverSocket = new ServerSocket(8000);
    36 
    37 // 【2】等待客户端的链入->阻塞式函数->监听8000端口,看是否有client链入
    38 
    39 clientSocket = serverSocket.accept();
    40 
    41  
    42 
    43 System.out.println(clientSocket.getInetAddress().getHostAddress()+"链入!");
    44 
    45  
    46 
    47 // 【3】给客户端主动发信息
    48 
    49 OutputStream out = clientSocket.getOutputStream();
    50 
    51  
    52 
    53 String msg = "hello 兄弟";
    54 
    55 byte[] buf = msg.getBytes("UTF-8");
    56 
    57 out.write(buf);
    58 
    59 clientSocket.shutdownOutput();
    60 
    61  
    62 
    63 out.close();
    64 
    65  
    66 
    67  
    68 
    69 } catch (IOException e) {
    70 
    71 e.printStackTrace();
    72 
    73 }
    74 
    75 }
    76 
    77 }

    客户端

     1 package cn.sxt02.net01;
     2 
     3  
     4 
     5 import java.io.IOException;
     6 
     7 import java.io.InputStream;
     8 
     9 import java.net.Socket;
    10 
    11  
    12 
    13 public class Client01 {
    14 
    15 public static void main(String[] args) {
    16 
    17 System.out.println("客户端运行...");
    18 
    19  
    20 
    21 // 【1】创建客户端socket
    22 
    23 Socket socket = null;
    24 
    25 try {
    26 
    27 socket = new Socket("192.168.2.56", 8000);
    28 
    29  
    30 
    31 // 【2】接收来自服务器的消息
    32 
    33 InputStream in = socket.getInputStream();
    34 
    35 byte[] buf = new byte[1024];
    36 
    37 int len = in.read(buf);
    38 
    39  
    40 
    41 String msg = new String(buf, 0, len, "UTF-8");
    42 
    43 System.out.println(msg);
    44 
    45  
    46 
    47 } catch (IOException e) {
    48 
    49 e.printStackTrace();
    50 
    51 }
    52 
    53 }
    54 
    55 }

    常见问题

    [1] 端口被占用

    java.net.BindException: Address already in use: JVM_Bind
        at java.net.DualStackPlainSocketImpl.bind0(Native Method)
        at java.net.DualStackPlainSocketImpl.socketBind(DualStackPlainSocketImpl.java:106)
        at java.net.AbstractPlainSocketImpl.bind(AbstractPlainSocketImpl.java:387)
        at java.net.PlainSocketImpl.bind(PlainSocketImpl.java:190)
        at java.net.ServerSocket.bind(ServerSocket.java:375)
        at java.net.ServerSocket.<init>(ServerSocket.java:237)
        at java.net.ServerSocket.<init>(ServerSocket.java:128)
        at cn.sxt01.net02.Server01.main(Server01.java:19)

    [2] 服务器未启动

    java.net.ConnectException: Connection refused: connect
    
    at java.net.DualStackPlainSocketImpl.connect0(Native Method)
    
    at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:79)
    
    at cn.sxt02.net02.Client01.main(Client01.java:15)

    [3] 连接超时异常 SocketTimeoutException

    网速很慢时,可能发生连接超时异常。

    需求:上传图片到服务器

    需求:控制台输入用户名和密码,如果输入正确提示登录成功,否则登录失败。

    1.1 UDP 编程

    UDP编程中,如果要完成通信,通信双方必须创建DatagramSocket,通过DatagramSocket完成通信

    数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器

    UDP步骤:

    [1] 创建一个DatagramSocket用于表示发送端,通过send方法发送数据报

    [2] 创建一个DatagramSocket用于表示接收端,通过receive方法发送数据报

    需求:完成一次单向的UDP通信。

    发送端

      1 1.4UDP 编程
      2 UDP编程中,如果要完成通信,通信双方必须要创建DatagramSocket,通过DatagramSocket完成通信。
      3 
      4 数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器
      5 
      6 UDP步骤:
      7 [1] 创建一个DatagramSocket用于表示发送端,通过send方法发送数据报
      8 [2] 创建一个DatagramSocket用于表示接收端,通过receive方法发送数据报
      9 
     10 需求:完成一次单向的UDP通信。
     11 发送端
     12 public static void main(String[] args) {
     13         
     14         // 发送端:主动发送信息
     15         System.out.println("发送端开始发送信息...");
     16         // 【1】创建socket并指定发送数据的端口
     17         DatagramSocket socket = null;
     18         try {
     19             socket = new DatagramSocket(8000);
     20             
     21             // 【2】创建数据报包
     22             String msg = "hello B";
     23             byte[] buf = msg.getBytes("UTF-8");
     24             DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 9000);
     25             
     26             // 【3】发送
     27             socket.send(dp);
     28             
     29             // 【4】关闭
     30             socket.close();
     31         } catch (SocketException e) {
     32             e.printStackTrace();
     33         } catch (UnsupportedEncodingException e) {
     34             e.printStackTrace();
     35         } catch (UnknownHostException e) {
     36             e.printStackTrace();
     37         } catch (IOException e) {
     38             e.printStackTrace();
     39         }
     40     }
     41 
     42 接收端
     43 public static void main(String[] args) {
     44         // 接收端:接收信息
     45         System.out.println("启动接收端...");
     46         // 【1】创建一个 DatagramSocket
     47         DatagramSocket socket = null;
     48         try {
     49             socket = new DatagramSocket(9000);
     50             // 【2】接收消息
     51             byte[] buf = new byte[1024];
     52             DatagramPacket dp = new DatagramPacket(buf, buf.length);
     53             System.out.println("等待接收信息...");
     54             socket.receive(dp);
     55             System.out.println("接收完成...");
     56             
     57             // 处理接收的信息
     58             String msg = new String(buf, 0, dp.getLength(), "UTF-8");
     59             System.out.println(msg);
     60             
     61         } catch (SocketException e) {
     62             e.printStackTrace();
     63         } catch (IOException e) {
     64             e.printStackTrace();
     65         }
     66     }
     67 
     68 需求:实现双向通信
     69 发送端
     70 public static void main(String[] args) {
     71         
     72         // 发送端:主动发送信息
     73         System.out.println("发送端开始发送信息...");
     74         Scanner sc = new Scanner(System.in);
     75         // 【1】创建socket并指定发送数据的端口
     76         DatagramSocket socket = null;
     77         try {
     78             socket = new DatagramSocket(8000);
     79             
     80             for(;;) {
     81                 System.out.print("A说:");
     82                 String msg = sc.nextLine();
     83                 byte[] buf = msg.getBytes("UTF-8");
     84                 DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 9000);
     85                 
     86                 // 【3】发送
     87                 socket.send(dp);
     88                 
     89                 
     90                 // 接收消息
     91                 byte[] revBuf = new byte[1024];
     92                 DatagramPacket revDp = new DatagramPacket(revBuf,revBuf.length);
     93                 socket.receive(revDp);
     94                 String revStr = new String(revBuf, 0, revDp.getLength(), "UTF-8");
     95                 System.out.println(dp.getAddress().getHostName()+":"+revStr);
     96             }
     97             
     98         } catch (SocketException e) {
     99             e.printStackTrace();
    100         } catch (UnsupportedEncodingException e) {
    101             e.printStackTrace();
    102         } catch (UnknownHostException e) {
    103             e.printStackTrace();
    104         } catch (IOException e) {
    105             e.printStackTrace();
    106         }finally {
    107             // 【4】关闭
    108             socket.close();
    109         }
    110     }
    111 
    112 
    113 接收端
    114     public static void main(String[] args) {
    115         // 接收端:接收信息
    116         System.out.println("启动接收端...");
    117         Scanner sc = new Scanner(System.in);
    118         // 【1】创建一个 DatagramSocket
    119         DatagramSocket socket = null;
    120         
    121         try {
    122             socket = new DatagramSocket(9000);
    123             
    124             for(;;) {
    125                 // 接收信息
    126                 byte[] buf = new byte[1024];
    127                 DatagramPacket dp = new DatagramPacket(buf, buf.length);
    128                 socket.receive(dp);
    129                 String msg = new String(buf, 0, dp.getLength(), "UTF-8");
    130                 System.out.println(dp.getAddress().getHostName()+":"+msg);
    131                 
    132                 // 发送信息
    133                 System.out.println("B说:");
    134                 String sendMsg = sc.nextLine();
    135                 byte[] sendBuf = sendMsg.getBytes("UTF-8");
    136                 DatagramPacket sendDp = new DatagramPacket(sendBuf, 0, sendBuf.length, dp.getAddress(), dp.getPort());
    137                 socket.send(sendDp);
    138             }
    139             
    140         } catch (SocketException e) {
    141             e.printStackTrace();
    142         } catch (IOException e) {
    143             e.printStackTrace();
    144         }finally {
    145             socket.close();
    146         }
    147     }

    接收端

     1 public static void main(String[] args) {
     2 
     3 // 接收端:接收信息
     4 
     5 System.out.println("启动接收端...");
     6 
     7 // 【1】创建一个 DatagramSocket
     8 
     9 DatagramSocket socket = null;
    10 
    11 try {
    12 
    13 socket = new DatagramSocket(9000);
    14 
    15 // 【2】接收消息
    16 
    17 byte[] buf = new byte[1024];
    18 
    19 DatagramPacket dp = new DatagramPacket(buf, buf.length);
    20 
    21 System.out.println("等待接收信息...");
    22 
    23 socket.receive(dp);
    24 
    25 System.out.println("接收完成...");
    26 
    27  
    28 
    29 // 处理接收的信息
    30 
    31 String msg = new String(buf, 0, dp.getLength(), "UTF-8");
    32 
    33 System.out.println(msg);
    34 
    35  
    36 
    37 } catch (SocketException e) {
    38 
    39 e.printStackTrace();
    40 
    41 } catch (IOException e) {
    42 
    43 e.printStackTrace();
    44 
    45 }
    46 
    47 }

    需求:实现双向通信

    发送端

     1 public static void main(String[] args) {
     2 
     3  
     4 
     5 // 发送端:主动发送信息
     6 
     7 System.out.println("发送端开始发送信息...");
     8 
     9 Scanner sc = new Scanner(System.in);
    10 
    11 // 【1】创建socket并指定发送数据的端口
    12 
    13 DatagramSocket socket = null;
    14 
    15 try {
    16 
    17 socket = new DatagramSocket(8000);
    18 
    19  
    20 
    21 for(;;) {
    22 
    23 System.out.print("A说:");
    24 
    25 String msg = sc.nextLine();
    26 
    27 byte[] buf = msg.getBytes("UTF-8");
    28 
    29 DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 9000);
    30 
    31  
    32 
    33 // 【3】发送
    34 
    35 socket.send(dp);
    36 
    37  
    38 
    39  
    40 
    41 // 接收消息
    42 
    43 byte[] revBuf = new byte[1024];
    44 
    45 DatagramPacket revDp = new DatagramPacket(revBuf,revBuf.length);
    46 
    47 socket.receive(revDp);
    48 
    49 String revStr = new String(revBuf, 0, revDp.getLength(), "UTF-8");
    50 
    51 System.out.println(dp.getAddress().getHostName()+":"+revStr);
    52 
    53 }
    54 
    55  
    56 
    57 } catch (SocketException e) {
    58 
    59 e.printStackTrace();
    60 
    61 } catch (UnsupportedEncodingException e) {
    62 
    63 e.printStackTrace();
    64 
    65 } catch (UnknownHostException e) {
    66 
    67 e.printStackTrace();
    68 
    69 } catch (IOException e) {
    70 
    71 e.printStackTrace();
    72 
    73 }finally {
    74 
    75 // 【4】关闭
    76 
    77 socket.close();
    78 
    79 }
    80 
    81 }

    接收

     1 public static void main(String[] args) {
     2 
     3 // 接收端:接收信息
     4 
     5 System.out.println("启动接收端...");
     6 
     7 Scanner sc = new Scanner(System.in);
     8 
     9 // 【1】创建一个 DatagramSocket
    10 
    11 DatagramSocket socket = null;
    12 
    13  
    14 
    15 try {
    16 
    17 socket = new DatagramSocket(9000);
    18 
    19  
    20 
    21 for(;;) {
    22 
    23 // 接收信息
    24 
    25 byte[] buf = new byte[1024];
    26 
    27 DatagramPacket dp = new DatagramPacket(buf, buf.length);
    28 
    29 socket.receive(dp);
    30 
    31 String msg = new String(buf, 0, dp.getLength(), "UTF-8");
    32 
    33 System.out.println(dp.getAddress().getHostName()+":"+msg);
    34 
    35  
    36 
    37 // 发送信息
    38 
    39 System.out.println("B说:");
    40 
    41 String sendMsg = sc.nextLine();
    42 
    43 byte[] sendBuf = sendMsg.getBytes("UTF-8");
    44 
    45 DatagramPacket sendDp = new DatagramPacket(sendBuf, 0, sendBuf.length, dp.getAddress(), dp.getPort());
    46 
    47 socket.send(sendDp);
    48 
    49 }
    50 
    51  
    52 
    53 } catch (SocketException e) {
    54 
    55 e.printStackTrace();
    56 
    57 } catch (IOException e) {
    58 
    59 e.printStackTrace();
    60 
    61 }finally {
    62 
    63 socket.close();
    64 
    65 }
    66 
    67 }
  • 相关阅读:
    mybatis的注意事项一
    java代码操作word模板生成PDF文件
    使用mybatis框架实现带条件查询多条件(传入实体类)
    MyBatis框架ResultMap节点
    优化mybatis框架中的查询用户记录数的案例
    Mybatis框架联表查询显示问题解决
    使用mybatis框架实现带条件查询单条件
    [DB] 如何彻底卸载删除MySQL 【MYSQL】
    [DB] MySQL窗口输入密码后消失问题 【MYSQL】
    [acm] 曾经 刷题记录 [只有正确的坚持才是胜利]
  • 原文地址:https://www.cnblogs.com/qq308015824/p/10847130.html
Copyright © 2011-2022 走看看