Java网络编程

深藏阁楼爱情的钟 2022-03-12 03:38 129阅读 0赞

网络通讯要素:IP地址;端口号;传输协议。

package myjava.net;
     
    import static system.out.Sop.*;
    import java.net.InetAddress;
    import java.net.UnknownHostException;
     
    public class IpDemo {
        public static void main(String[] args) {
           InetAddress i = null;
           InetAddress[] ia = null;
           try {
               i = InetAddress.getLocalHost();
               ia = InetAddress.getAllByName("www.baidu.com");
           } catch (UnknownHostException e) {
               e.printStackTrace();
           }
     
           sop(i.toString());
           sop(i.getHostAddress());
           sop(i.getHostName());
     
           // sop(ia.toString());
           /*
            * sop(ia.getHostName());sop(ia.getHostAddress());
            */
           for (InetAddress ina : ia) {
               sop(ina.getHostAddress());
               sop(ina.getHostName());
           }
        }
    }

UDP:将数据及源和目的封装成数据包中,不需要建立连接;

每个数据报的大小限制在64k内;

因无连接,是不可靠协议;

不需要建立连接,速度快;

TCP:建立连接,形成传输数据的通道;

在连接中进行大数据量传输;

通过三次握手完成连接,是可靠协议;

必须建立连接,效率会低;

Socket:就是为网络服务提供的一种机制

通信的两端都有Socket

网络通信其实就是Socket间的通信

数据在两个Socket间通过IO传输

通过UDP传输方式将一段文字数据发送出去：

步骤：1.建立udpsocket服务

2.提供数据，并将数据封装到数据包中。

3.通过socket服务的发送功能，将数据包发出去。

4.关闭资源。

发送端：

package myjava.net;
     
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
     
    public class UdpDemoSender {
        public static void main(String[] args) throws Exception {
           /*
            * // 建立udp服务,通过DatagramSocket对象DatagramSocket ds = new
            * DatagramSocket(); // 确定数据,并封装成数据包.DatagramPacket(byte[] buf, int
            * length, InetAddress// address, int port) byte[] buf =
            * "udp gemen lai le".getBytes(); DatagramPacket dp = new
            * DatagramPacket(buf,buf.length,
            * InetAddress.getByName("192.168.0.194"),10000);
            * //通过socket服务,将已有的数据包发送出去,通过send方法 ds.send(dp);//关闭资源 ds.close();
            */
           DatagramSocketds = new DatagramSocket();
           BufferedReader bufr = new BufferedReader(new InputStreamReader(
                  System.in));
           String line = null;
           while ((line = bufr.readLine()) != null) {
               if ("886".equals(line))
                  break;
               byte[] buf = line.getBytes();
               DatagramPacket dp = new DatagramPacket(buf, buf.length,
                      InetAddress.getByName("192.168.1.108"), 10000);
               ds.send(dp);
           }
           ds.close();
        }
     
    }

接收端：

package myjava.net;
     
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    //import staticsystem.out.Sop.*;
    /**
     * 定义一个程序,用于接收udp协议传输的数据并处理
     *
     * @author lenovo
     *
     */
    /*
     * 步骤:1.定义udpsocket服务 2.定义一个数据包,因为要存储接收到的字节数据因为数据包对象中有更多功能可以提取字节数据中的不同数据信息
     * 3.通过socket服务的receive方法将接收到的数据存入到已经定义好的数据包中 4.通过数据包对象的特有功能,将这些不同的数据取出,打印在控制台上
     * 5.关闭资源
     */
    public class UdpDemoReceiver {
        public static void main(String[] args) throws Exception {
           /*// 创建udpsocket服务,
           DatagramSocket ds = new DatagramSocket(10000);
           // 定义数据包,用于存储数据
           byte[] buf = new byte[1024];
           DatagramPacket dp = new DatagramPacket(buf,buf.length);
           //通过udpsocket服务的方法将接收到的数据存入到定义好的数据包中
           ds.receive(dp); //阻塞式方法
           //通过数据包的方法获取其中的数据
           String data=new String(dp.getData(),0,dp.getLength());
           String ip=dp.getAddress().getHostAddress();
           int port=dp.getPort();
           sop("data::"+data);
           sop("ip::"+ip);
           sop("port::"+port);
           //关闭资源
           ds.close();*/
           DatagramSocket ds=new DatagramSocket(10000);
           while(true){
               byte[] buf=new byte[1024];
               DatagramPacket dp=new DatagramPacket(buf, buf.length);
               ds.receive(dp);
               String ip=dp.getAddress().getHostAddress();
               String data=new String(dp.getData(),0,dp.getLength());
               System.out.println("ip::"+ip+"....."+"data::"+data);
           }
        }
     
    }

改进后实现聊天程序：

package myjava.net;
     
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.*;
     
    public class Sender implements Runnable {
        private DatagramSocket ds;
     
        public Sender(DatagramSocket ds) {
           this.ds = ds;
        }
     
        //@Override
        public void run() {
           try {
               BufferedReader bufr = new BufferedReader(new InputStreamReader(
                      System.in));
               String line = null;
               while ((line = bufr.readLine()) != null) {
                  if (line.equals("886"))
                      break;
                  byte[] buf = line.getBytes();
                  DatagramPacket dp = new DatagramPacket(buf, buf.length,
                         InetAddress.getByName("192.168.1.255"), 10003);
                  ds.send(dp);
     
               }
           } catch (Exception e) {
               // TODO Auto-generatedcatch block
               //e.printStackTrace();
               throw new RuntimeException("发送端失败");
           }
        }
    }
     
    package myjava.net;
     
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
     
    public class Receiver implements Runnable {
        private DatagramSocket ds;
     
        public Receiver(DatagramSocket ds) {
           this.ds = ds;
        }
     
        @Override
        public void run() {
           // TODO Auto-generatedmethod stub
           try {
               while (true) {
                  byte[] buf = new byte[1024];
                  DatagramPacket dp = new DatagramPacket(buf, buf.length);
                  ds.receive(dp);
                  String ip = dp.getAddress().getHostAddress();
                  String data = new String(dp.getData(), 0, dp.getLength());
                  System.out.println("ip:" + ip + "...." + "data:" + data);
               }
           } catch (Exception e) {
               // TODO: handleexception
               throw new RuntimeException("接收端失败");
           }
        }
     
    }
     
    package myjava.net;
     
    import java.net.DatagramSocket;
     
    public class Chatdemo {
     
        /**
         * @param args
         */
        public static void main(String[] args)throws Exception {
           // TODO Auto-generatedmethod stub
           DatagramSocket sendsocket = new DatagramSocket();
           DatagramSocket recesocket = new DatagramSocket(10003);
           Thread t1 = new Thread(new Sender(sendsocket));
           Thread t2 = new Thread(new Receiver(recesocket));
           t1.start();
           t2.start();
        }
     
    }

TCP传输:

建立客户端(Socket)和服务器端(ServerSocket)

建立连接后,通过Socket中的IO流进行数据的传输

关闭socket

客户端和服务器端是两个独立的应用程序

客户端步骤:

1. 创建Socket服务并指定要连接的主机和端口。

2. 为了发送数据，应该获取socket流中的输出流

服务端步骤：

1. 建立服务端的socket通过ServerSocket建立，并监听一个端口

2. 获取连接过来的客户端对象，通过ServerSocket的accept方法（阻塞式的）

3. 客户端如果发过来的数据，那么服务端要使用对应的客户端对象，并获取到该客户对象的读取流来读取发过来的数据

4. 关闭服务端（可选操作）

package myjava.net;
     
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.Socket;
    import java.net.UnknownHostException;
     
    public class TcpClient {
     
        /**
         * @param args
         */
        public static void main(String[] args) {
           // TODO Auto-generatedmethod stub
           Socket s = null;
           try {
               // 创建Socket服务并指定要连接的主机和端口
               s = new Socket("192.168.1.108", 10000);
               // 为了发送数据,获取Socket流中的输出流
               OutputStream out = s.getOutputStream();
               out.write("tcp ge menlai le".getBytes());
           } catch (UnknownHostException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           } finally {
               if (s != null)
                  try {
                      s.close();
                  } catch (IOException e) {
                      // TODO Auto-generatedcatch block
                      e.printStackTrace();
                  }
           }
        }
     
    }
     
    package myjava.net;
     
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
     
    public class TcpServer {
     
        /**
         * @param args
         */
        public static void main(String[] args) {
           // TODO Auto-generatedmethod stub
           // 建立服务端的socket通过ServerSocket建立，并监听一个端口
           ServerSocket ss;
           Socket s = null;
           try {
               ss = new ServerSocket(10000);
               // 获取连接过来的客户端对象
               s = ss.accept();
               String ip = s.getInetAddress().getHostAddress();
               // 使用客户端对象的读取流读取数据,获取客户端发过来的数据,
               InputStream in = s.getInputStream();
               byte[] buf = new byte[1024];
               int len = in.read(buf);
               System.out.println(new String(buf, 0, len));
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           } finally {
               if(s!=null)
                  try {
                      s.close();
                  } catch (IOException e) {
                      // TODO Auto-generatedcatch block
                      e.printStackTrace();
                  }
           }
     
        }
     
    }

服务器和客户端互访:

package myjava.net;
     
    import java.io.*;
    import java.net.*;
     
    public class TcpClient2 {
     
        /**
         * @param args
         */
        public static void main(String[] args) {
           // TODO Auto-generatedmethod stub
           Socket s = null;
           try {
               s = new Socket("192.168.1.108", 10002);
               OutputStream out = s.getOutputStream();
               out.write("Hello,服务端你好".getBytes());
               InputStream in = s.getInputStream();
               byte[] buf = new byte[1024];
               int len = in.read(buf);
               System.out.println(new String(buf, 0, len));
           } catch (UnknownHostException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           } finally {
               if(s!=null)
                  try {
                      s.close();
                  } catch (IOException e) {
                      // TODO Auto-generatedcatch block
                      e.printStackTrace();
                  }
           }
     
        }
     
    }
     
    package myjava.net;
     
    import java.io.*;
    import java.net.*;
     
    public class TcpServer2 {
     
        /**
         * @param args
         */
        public static void main(String[] args) {
           // TODO Auto-generatedmethod stub
     
           ServerSocket ss = null;
           Socket s = null;
           try {
               ss = new ServerSocket(10002);
               s = ss.accept();
               String ip = s.getInetAddress().getHostAddress();
               System.out.println(ip);
               InputStream in = s.getInputStream();
               byte[] buf = new byte[1024];
               int len = in.read(buf);
               System.out.println(new String(buf, 0, len));
               OutputStream out = s.getOutputStream();
               out.write("收到,哥们你也好".getBytes());
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           } finally {
               if (s != null)
                  try {
                      s.close();
                  } catch (IOException e) {
                      // TODO Auto-generatedcatch block
                      e.printStackTrace();
                  }
               if (ss != null)
                  try {
                      ss.close();
                  } catch (IOException e) {
                      // TODO Auto-generatedcatch block
                      e.printStackTrace();
                  }
           }
     
        }
    }

Tcp练习:建立一个文本转换服务器,要求客户端给服务器端发送文本,服务器端将文本转成大写在返回给客户端,而且客户端可以不断的进行文本转换,当客户端输入over时,转换结束。

package myjava.net;
     
    import java.io.*;
    import java.net.*;
     
    public class TcpClient {
        public static void main(String[] args) {
           // TODO Auto-generatedmethod stub
           Socket s = null;
           try {
               // 创建Socket服务并指定要连接的主机和端口
               s = new Socket("192.168.1.108", 10000);
               // 为了发送数据,获取Socket流中的输出流
               OutputStream out = s.getOutputStream();
               out.write("tcp ge menlai le".getBytes());
           } catch (UnknownHostException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           } finally {
               if (s != null)
                  try {
                      s.close();
                  } catch (IOException e) {
                      // TODO Auto-generatedcatch block
                      e.printStackTrace();
                  }
           }
        }
     
    }
    package myjava.net;
     
    import java.io.*;
    import java.net.*;
     
    public class TcpServer {
        public static void main(String[] args) {
           // TODO Auto-generatedmethod stub
           // 建立服务端的socket通过ServerSocket建立，并监听一个端口
           ServerSocket ss;
           Socket s = null;
           try {
               ss = new ServerSocket(10000);
               // 获取连接过来的客户端对象
               s = ss.accept();
               String ip = s.getInetAddress().getHostAddress();
               // 使用客户端对象的读取流读取数据,获取客户端发过来的数据,
               InputStream in = s.getInputStream();
               byte[] buf = new byte[1024];
               int len = in.read(buf);
               System.out.println(new String(buf, 0, len));
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           } finally {
               if (s != null)
                  try {
                      s.close();
                  } catch (IOException e) {
                      // TODO Auto-generatedcatch block
                      e.printStackTrace();
                  }
           }
        }
    }

上传文件：

package myjava.net;
     
    import java.io.*;
    import java.net.*;
     
    public class TextClient {
        public static void main(String[] args) {
           Socket s = null;
           try {
               s = new Socket("192.168.1.108", 10005);
           } catch (UnknownHostException e) {
               e.printStackTrace();
           } catch (IOException e) {
               throw new RuntimeException("连接服务器失败");
           }
           // 文件读取流
           BufferedReader bufr = null;
           try {
               bufr = new BufferedReader(new FileReader(
                      "C:\\Users\\lenovo\\Desktop\\BlackHorse.txt"));
            } catch(FileNotFoundException e) {
               throw new RuntimeException("文件未找到");
           }
           PrintWriter out = null;
           try {
               out = new PrintWriter(s.getOutputStream(), true);
           } catch (IOException e) {
               throw new RuntimeException("socket输出流创建失败");
           }
           String line;
           try {
               while ((line = bufr.readLine()) != null) {
                  // 从文件中读取数据,发送到给服务器端
                  out.println(line);
               }
               // 关闭客户端的输出流,相当于给流中加入一个结束标记-1
               s.shutdownOutput();
           } catch (IOException e) {
               throw new RuntimeException("文件读取失败");
           }
           // socket读取流,获取服务端发来的数据
           BufferedReader bufin;
           try {
               bufin = new BufferedReader(
                      new InputStreamReader(s.getInputStream()));
           } catch (IOException e1) {
               throw new RuntimeException("socket输入流失败");
           }
           String str = null;
           try {
               str = bufin.readLine();
               System.out.println(str);
           } catch (IOException e) {
               throw new RuntimeException("读取服务器信息失败");
           }
     
           try {
               bufr.close();
           } catch (IOException e) {
               throw new RuntimeException("文件流关闭失败");
           }
           try {
               s.close();
           } catch (IOException e) {
               throw new RuntimeException("socket服务关闭失败");
           }
        }
     
    }
    package myjava.net;
     
    import java.io.*;
    import java.net.*;
     
    public class TextServer {
        public static void main(String[] args) {
           ServerSocket ss = null;
           try {
               ss = new ServerSocket(10005);
           } catch (IOException e) {
               e.printStackTrace();
           }
           Socket s = null;
           try {
               s = ss.accept();
               String ip = s.getInetAddress().getHostAddress();
               System.out.println(ip + "......connected");
           } catch (IOException e) {
               e.printStackTrace();
           }
            // 定义输入流,读取客户端发来的数据
           BufferedReader bufr = null;
           try {
               bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           }
           // 定义输出流,将客户端发来的数据存入文件
           PrintWriter out = null;
           try {
               out = new PrintWriter(new FileWriter(
                      "C:\\Users\\lenovo\\Desktop\\BlackHorsecopy.txt"), true);
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           }
           String line = null;
           try {
               while ((line = bufr.readLine()) != null) {
                  /*
                   *if("over".equals(line)) break;
                   */
                  out.println(line);
               }
           } catch (IOException e) {
               throw new RuntimeException("往文件中写入数据失败");
           }
           // 定义socket输出流,发送信息给客户端
           PrintWriter pw = null;
           try {
               pw = new PrintWriter(s.getOutputStream(),true);
           } catch (IOException e) {
               e.printStackTrace();
           }
           pw.println("上传成功");
           out.close();
           try {
               s.close();
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           }
           try {
               ss.close();
           } catch (IOException e) {
               // TODO Auto-generatedcatch block
               e.printStackTrace();
           }
        }
     
    }

TCP-客户端并发上传图片程序:

客户端:

package myjava.net;
     
    import java.io.*;
    import java.net.*;
    /*
     * 客户端
    1.服务端点
    2.读取客户端已有的图片数据
    3.通过socket输出流将数据发给服务端
    4.读取服务端反馈信息
    5,关闭
    */
     
    public class PicClient {
    public static void main(String[] args) throws Exception{
        Socket s=new Socket("192.168.0.167",10000);
        File file=new File("E:\\相册\\tan.jpg");
        FileInputStream fis=new FileInputStream(file);
        OutputStream out=s.getOutputStream();
        byte[] buf=new byte[1024];
        int len=0;
        while((len=fis.read(buf))!=-1){
           out.write(buf,0,len);
        }
        s.shutdownOutput();
        InputStream in=s.getInputStream();
        byte[] bufin=new byte[1024];
        int num=0;
        while((num=in.read(bufin))!=-1){
           System.out.println(new String(bufin,0,num));
        }
        fis.close();
        s.close();
    }
    }

服务器端:

package myjava.net;
     
    import java.io.*;
    import java.net.*;
     
    public class PicServer {
        public static void main(String[] args) throws Exception {
           ServerSocket ss = new ServerSocket(10000);
           while (true) {
               Socket s = ss.accept();
               new Thread(new PicThread(s)).start();
           }
           // ss.close();
        }
    }
    并发线程:
    package myjava.net;
     
    import java.net.*;
    import java.io.*;
     
    public class PicThread implements Runnable {
        private Socket s;
     
        PicThread(Socket s) {
           this.s = s;
        }
     
        @Override
        public void run() {
           String ip = s.getInetAddress().getHostAddress();
           int count= 1;
           InputStream in;
           try {
               in = s.getInputStream();
               File file = new File("C:\\Users\\lenovo\\Desktop\\" + ip + "("
                      + count + ")" + ".jpg");
               while (file.exists())
                  file = new File("C:\\Users\\lenovo\\Desktop\\" + ip + "("
                         + (count++) + ")" + ".jpg");
               FileOutputStream fos = new FileOutputStream(file);
               byte[] buf = new byte[1024];
               int len = 0;
               while ((len = in.read(buf)) != -1) {
                  fos.write(buf, 0, len);
               }
     
               OutputStream out = s.getOutputStream();
               out.write("上传成功".getBytes());
               fos.close();
               s.close();
           } catch (IOException e) {
               throw new RuntimeException(ip + "上传失败");
           }
     
        }
     
    }