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

1.如何准确定位到网络上的一台主机或者多台主机
2.找到主机之后如何进行通信

2.网络编程中的要素

1.ip 和 端口号
2.网络通信协议 udp ，tcp

3.IP

ip 在java中有个 类：InetAddress
123.0.0.1是本机的ip地址
ip地址的分类
ipv4 和 ipv6
ipv4: 127.0.0.1 0~255 共40亿个
ipv6:128位，8个无符号整数

4.TCP/IP

1.TCP/IP简介

TCP：场景：打电话
面向连接的可靠的传输协议
三次握手。四次挥手
客户端服务端
传输完成，释放连接 ，效率低
UDP场景：发短信
不连接，不稳定的
客户端。服务端没有明确的界限
不管有没有准备好，都可以发给你

2.案例1TCP实现的聊天

基于TCP实现的网络编程
总结来说就是
客户端：1.需要得到服务端的ip地址和端口号，通过套接字，创建连接
2.通过套接字创建输出流将自己想传输的数据传输给指定的服务端
服务端：1.需要创建一个指定端口号的serverSocket，
2.等待客户端连接。使用accpt监听连接的客户端，返回值是一个socket
3.通过这个socket读入客户端发送过来的数据。
客户端

  1. /**
  2.  * @Author Rookie Coder
  3.  * @Description 客户端
  4.  * @Date
  5.  **/
  6. public class ClientSocket {
  8.     public static void main(String[] args) {
  9.         OutputStream outputStream = null;
  10.         Socket socket = null;
  12.         // 获取服务端ip地址
  13.         try {
  14.            InetAddress in1 = InetAddress.getByName("127.0.0.1");
  15.             // 获取服务端端口号
  16.             int port = 8080;
  17.             // 创建一个socket
  18.              socket = new Socket(in1,port);
  19.              outputStream = socket.getOutputStream();
  20.             for (int i = 0; i < 50; i++) {
  21.                 outputStream.write("你好客户端，我是小柒".getBytes());
  22.             }
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         }finally {
  26.            if (outputStream!=null){
  27.                try {
  28.                    outputStream.close();
  29.                } catch (IOException e) {
  30.                    e.printStackTrace();
  31.                }
  32.            }
  33.            if (socket!=null){
  34.                try {
  35.                    socket.close();
  36.                } catch (IOException e) {
  37.                    e.printStackTrace();
  38.                }
  39.            }
  40.         }
  42.     }
  45. }

服务端：

  1. /**
  2.  * @Author Rookie Coder
  3.  * @Description 服务端
  4.  * @Date
  5.  **/
  6. public class MyServerSocket {
  8.     public static void main(String[] args) {
  9.         ServerSocket serverSocket = null;
  10.         InputStream inputStream = null;
  11.         ByteArrayOutputStream bos = null;
  12.         Socket socket = null;
  13.         try{
  14.             // 创建一个服务端 端口号为8080
  15.             serverSocket = new ServerSocket(8080) ;
  16.             while (true){
  17.                 // 持续监听接收到的客户端
  18.                  socket = serverSocket.accept();
  19.                 // 获取客户端发来的消息
  20.                 inputStream = socket.getInputStream();
  21.                 // 建立一个管道流
  22.                 bos = new ByteArrayOutputStream();
  23.                 byte[] bytes = new byte[1024];
  24.                 int len;
  25.                 while ((len=inputStream.read(bytes))!=-1){
  26.                      bos.write(bytes,0,len);
  27.                 }
  28.                 System.out.println(bos);
  30.             }
  32.         } catch (Exception e) {
  33.             e.printStackTrace();
  34.         }finally {
  35.             if (bos!=null){
  36.                 try {
  37.                     bos.close();
  38.                 } catch (IOException e) {
  39.                     e.printStackTrace();
  40.                 }
  41.             }
  42.             if (inputStream!=null){
  43.                 try {
  44.                     inputStream.close();
  45.                 } catch (IOException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.             }
  50.             if (socket!=null){
  51.                 try {
  52.                     socket.close();
  53.                 } catch (IOException e) {
  54.                     e.printStackTrace();
  55.                 }
  56.             }
  57.         }
  60.     }
  63. }

3.案例2：TCP实现文件上传

客户端：

  1. **
  2.  * @Author Rookie Coder
  3.  * @Description 文件上传客户端
  4.  * @Date
  5.  **/
  6. public class MyClientSocket {
  8.     public static void main(String[] args) {
  9.         // 1.创建一个socket，传入服务端ip 和服务端 端口号
  10.         Socket socket = null;
  11.         OutputStream outputStream = null;
  12.         FileInputStream fi1 = null;
  13.         try  {
  14.              socket = new Socket(InetAddress.getByName("127.0.0.1"),8081);
  15.             // 2.创建输入流，读取要上传的文件
  16.              fi1 = new FileInputStream(new File("D:/JAVAStudy/IDEAWorkSpace/javaSECode/JavaSEReview/java_9netword/src/2.jpg"));
  17.             // 3.创建输出流，输出给服务端
  18.              outputStream = socket.getOutputStream();
  19.             byte[] bytes = new byte[1024];
  20.             int len;
  21.                 while ((len=fi1.read(bytes))!=-1){
  22.                 outputStream.write(bytes,0,len);
  23.             }
  24.         } catch (UnknownHostException e) {
  25.             e.printStackTrace();
  26.         } catch (IOException e) {
  27.             e.printStackTrace();
  28.         }finally {
  29.             if (outputStream!=null){
  30.                 try {
  31.                     outputStream.close();
  32.                 } catch (IOException e) {
  33.                     e.printStackTrace();
  34.                 }
  35.             }
  36.             if (fi1!=null){
  37.                 try {
  38.                     fi1.close();
  39.                 } catch (IOException e) {
  40.                     e.printStackTrace();
  41.                 }
  42.             }
  43.             if (socket!=null){
  44.                 try {
  45.                     socket.close();
  46.                 } catch (IOException e) {
  47.                     e.printStackTrace();
  48.                 }
  49.             }
  50.         }
  53.     }
  56. }
  57. **
  58.  * @Author Rookie Coder
  59.  * @Description 文件上传客户端
  60.  * @Date
  61.  **/
  62. public class MyClientSocket {
  64.     public static void main(String[] args) {
  65.         // 1.创建一个socket，传入服务端ip 和服务端 端口号
  66.         Socket socket = null;
  67.         OutputStream outputStream = null;
  68.         FileInputStream fi1 = null;
  69.         try  {
  70.              socket = new Socket(InetAddress.getByName("127.0.0.1"),8081);
  71.             // 2.创建输入流，读取要上传的文件
  72.              fi1 = new FileInputStream(new File("D:/JAVAStudy/IDEAWorkSpace/javaSECode/JavaSEReview/java_9netword/src/2.jpg"));
  73.             // 3.创建输出流，输出给服务端
  74.              outputStream = socket.getOutputStream();
  75.             byte[] bytes = new byte[1024];
  76.             int len;
  77.                 while ((len=fi1.read(bytes))!=-1){
  78.                 outputStream.write(bytes,0,len);
  79.             }
  80.         } catch (UnknownHostException e) {
  81.             e.printStackTrace();
  82.         } catch (IOException e) {
  83.             e.printStackTrace();
  84.         }finally {
  85.             if (outputStream!=null){
  86.                 try {
  87.                     outputStream.close();
  88.                 } catch (IOException e) {
  89.                     e.printStackTrace();
  90.                 }
  91.             }
  92.             if (fi1!=null){
  93.                 try {
  94.                     fi1.close();
  95.                 } catch (IOException e) {
  96.                     e.printStackTrace();
  97.                 }
  98.             }
  99.             if (socket!=null){
  100.                 try {
  101.                     socket.close();
  102.                 } catch (IOException e) {
  103.                     e.printStackTrace();
  104.                 }
  105.             }
  106.         }
  109.     }
  112. }

服务端：

  1. /**
  2.  * @Author Rookie Coder
  3.  * @Description 文件上传服务端
  4.  * @Date
  5.  **/
  6. public class MyServerSocket {
  8.     public static void main(String[] args) {
  9.         // 1. 创建一个Serversocket
  10.         Socket accept = null;
  11.         InputStream inputStream = null;
  12.         FileOutputStream f1 = null;
  13.         ServerSocket serverSocket = null;
  14.         try {
  15.              serverSocket = new ServerSocket(8081);
  16.             // 监听发送数据的客户端
  17.              accept = serverSocket.accept();
  18.              // 输出客户端所传输过来的数据
  19.             inputStream = accept.getInputStream();
  20.              // 创建一个管道流
  21.              f1 = new FileOutputStream(new File("revice.jpg"));
  22.             byte[] bytes = new byte[1024];
  23.             int len;
  24.             while ((len=inputStream.read(bytes))!=-1){
  25.                 f1.write(bytes,0,len);
  26.             }
  27.             System.out.println(f1);
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.         }finally {
  31.             if (f1 !=null){
  32.                 try {
  33.                     f1.close();
  34.                 } catch (IOException e) {
  35.                     e.printStackTrace();
  36.                 }
  37.             }
  38.             if (inputStream!=null){
  39.                 try {
  40.                     inputStream.close();
  41.                 } catch (IOException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.             if (accept!=null){
  46.                 try {
  47.                     accept.close();
  48.                 } catch (IOException e) {
  49.                     e.printStackTrace();
  50.                 }
  51.             }
  52.             if (serverSocket!=null){
  53.                 try {
  54.                     serverSocket.close();
  55.                 } catch (IOException e) {
  56.                     e.printStackTrace();
  57.                 }
  58.             }
  60.         }
  62.     }
  64. }