Java基础22：网络基础

关键字：UDP；TCP

一、网络编程(概述)

    1、网络模型
        (1)、OSI参考模型，
        (2)、TCP/IP参考模型
    2、网络通讯要素
        (1)、IP地址
        (2)、端口号
        (3)、传输协议
    3、过程
        (1)、找到对方 IP
        (2)、数据要发到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行了标识。为了方便称呼这个数字，叫做端口。（逻辑端口）
        (3)、定义通信规则。这个通讯规则成为协议。国际组织定义了通用协议TCP/IP。

    简单来说：这种过程就是通过楼号（相当于IP），房间号（相当于端口号）来进行查找。

二、网络编程(概述2)
    端口：0-65535
    系统:0-1024
    本机地址：127.0.0.1
三、网络编程(网络模型
   
四、网络编程(IP地址)
    1、IP地址：InetAddress
        (1)、网络中设备的标识
        (2)、不易记忆，可用主机名
        (3)、本地回环地址：127.0.0.1 主机名：localhost
    2、端口号
        (1)、用于标识进程的逻辑地址，不同进程的标识
        (2)、有效端口：0~65535，其中0~1024系统使用或保留端口
    3、传输协议
        (1)、通讯的规则
        (2)、常见协议：TCP，UDP

类InetAddress:此类表示互联网协议（IP）地址。此类没有构造方法，所有不能用new创建此类。
static InetAddress getLocalHost() 返回本地主机。 
String getHostAddress() 返回 IP 地址字符串（以文本表现形式）。 
 String getHostName() 获取此 IP 地址的主机名。 

 static InetAddress getByName(String host) 在给定主机名的情况下确定主机的 IP 地址。 

 import java.net.*;public class Demo{    public static void main(String[] args) throws Exception{        //InetAddress i = InetAddress.getLocalHost();本机        //InetAddress i = InetAddress.getByName("192.168.1.100");//根据地址获取对象        InetAddress i = InetAddress.getByName("www.baidu.com");//根据地址获取对象        sop(i.getHostAddress());//ip地址        sop(i.getHostName());//主机名    }    public static void sop(Object obj){        System.out.println(obj);    }}

五、网络编程(TCP和UDP)
    1、UDP
        (1)、将数据及源和目的封装成数据包中，不需要建立连接
        (2)、每个数据包的大小限制在64k内
        (3)、因无连接，是不可靠协议
        (4)、不需要建立连接，速度快
    2、TCP
        (1)、建立连接，形成传输数据的通道
        (2)、在连接中进行大数据量传输
        (3)、通过三次捂手完成连接，是可靠协议
        (4)、必须建立连接，效率会稍低

   注意：UDP相当于发短信；TCP相当于打电话。

六、网络编程(Socket)
    1、Socket就是为网络服务提供的一种机制
    2、通信的两端都有Socket
    3、网络通信其实就是Soket间的通信
    4、数据在两个Socket间通过IO传输
七、网络编程(Udp-发送端)
    1、DatagramSocket与DatagramPacket
    2、简历发送端，接收端
    3、建立数据包
    4、调用Socket的发送接收方法
    5、关闭Socket
    发送端与接收端是两个独立运行的程序
public class DatagramSocketextends Object 此类表示用来发送和接收数据报包的套接字。
public final class DatagramPacketextends Object 此类表示数据报包。
八、网络编程(Udp-接收端)

/*需求：通过udp阐述方式，将一段文字数据发送出去思路：1、建立udpsocket服务2、提供数据，并将数据封装到数据包中3、通过socket服务的发送功能，将数据包发送出去4、关闭资源需求：定义一个应用程序，用于接收udp协议传输的数据并处理要定义udp接收端思路：1、创建udpsocket服务，通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识，方便于明确哪些数据过来该应用可以处理2、定义一个数据包，因为要存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息3、通过socket服务的receive方法将收到的数据存入到已定义好的数据包中4、通过数据包对象的特有功能。将这些不同的数据取出，打印在控制台上。5、关闭资源*/import java.net.*;public class Demo{    public static void main(String[] args) throws Exception{        new UdpRece().start();        new UdpSend().start();    }    public static void sop(Object obj){        System.out.println(obj);    }}class UdpSend extends Thread{    public void run(){        try{            //1、创建UDP服务，通过DatagramSocket对象            DatagramSocket ds = new DatagramSocket();//可设置端口            //2、确定数据，并封装成数据包  DatagramPacket(byte[] buf, int length, InetAddress address, int port)            byte[] buf = "udp ge men lai le".getBytes();            DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10000);            //3、通过socket服务，将已有的数据包发送出去，通过send方法            ds.send(dp);            //4、关闭资源            ds.close();        }catch(Exception e){                    }    }}class UdpRece extends Thread{    public void run(){        try{            //1、创建UDP服务，建立端点。            DatagramSocket ds = new DatagramSocket(10000);            //2、定义一个数据包，因为要存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息 DatagramPacket(byte[] buf, int length)             byte[] buf = new byte[1024];            DatagramPacket dp = new DatagramPacket(buf,buf.length);            //3、通过socket服务的receive方法将收到的数据存入到已定义好的数据包中            ds.receive(dp);            //4、通过数据包对象的特有功能。将这些不同的数据取出，打印在控制台上。            String ip = dp.getAddress().getHostAddress();            String data = new String(dp.getData(),0,dp.getLength());            int port = dp.getPort();            Demo.sop(ip+"::"+data+"::"+port);            //5、关闭资源            ds.close();        }catch(Exception e){                    }    }}

九、网络编程(UDP-键盘录入方式数据)

 

/*需求：通过udp阐述方式，将一段文字数据发送出去思路：1、建立udpsocket服务2、提供数据，并将数据封装到数据包中3、通过socket服务的发送功能，将数据包发送出去4、关闭资源需求：定义一个应用程序，用于接收udp协议传输的数据并处理要定义udp接收端思路：1、创建udpsocket服务，通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识，方便于明确哪些数据过来该应用可以处理2、定义一个数据包，因为要存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息3、通过socket服务的receive方法将收到的数据存入到已定义好的数据包中4、通过数据包对象的特有功能。将这些不同的数据取出，打印在控制台上。5、关闭资源*/import java.net.*;import java.io.*;public class Demo{    public static void main(String[] args) throws Exception{        new UdpRece().start();        new UdpSend().send();    }    public static void sop(Object obj){        System.out.println(obj);    }}class UdpSend{    public void send() throws Exception{        //1、创建UDP服务，通过DatagramSocket对象        DatagramSocket ds = new DatagramSocket();        //2、确定数据，并封装成数据包  DatagramPacket(byte[] buf, int length, InetAddress address, int port)        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("127.0.0.1"),10000);//如果改为192.168.1.255，广播，则都能收到            //3、通过socket服务，将已有的数据包发送出去，通过send方法            ds.send(dp);        }                //4、关闭资源        ds.close();    }}class UdpRece extends Thread{    public void run(){        try{            while(true){                //1、创建UDP服务，建立端点。                DatagramSocket ds = new DatagramSocket(10000);                //2、定义一个数据包，因为要存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息 DatagramPacket(byte[] buf, int length)                 byte[] buf = new byte[1024];                DatagramPacket dp = new DatagramPacket(buf,buf.length);                //3、通过socket服务的receive方法将收到的数据存入到已定义好的数据包中                ds.receive(dp);                //4、通过数据包对象的特有功能。将这些不同的数据取出，打印在控制台上。                String ip = dp.getAddress().getHostAddress();                String data = new String(dp.getData(),0,dp.getLength());                int port = dp.getPort();                Demo.sop(ip+"::"+data+"::"+port);                //5、关闭资源                ds.close();            }        }catch(Exception e){                    }    }}

十、网络编程(UDP-聊天)

 

/*编写一个聊天程序有收数据的部分，和发数据的部分这两部分需要同时执行那就需要用到多线程技术一个线程控制收，一个线程控制发因为收和发动作是不一致的，所以要定义两个run方法而且这两个方法要封装到不同的类中*/import java.net.*;import java.io.*;public class Demo{    public static void main(String[] args) throws Exception{        DatagramSocket sendSocket = new DatagramSocket();        DatagramSocket receSocket = new DatagramSocket(10000);        new Thread(new Send(sendSocket)).start();        new Thread(new Rece(receSocket)).start();    }    public static void sop(Object obj){        System.out.println(obj);    }}class Send implements Runnable{    private DatagramSocket ds;    Send(DatagramSocket ds){        this.ds = ds;    }    public void run(){        try{            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,0,buf.length,InetAddress.getByName("192.168.1.255"),10000);                ds.send(dp);            }        }catch(Exception e){            throw new RuntimeException("发送失败");        }finally{            ds.close();        }    }}class Rece implements Runnable{    private DatagramSocket ds;    Rece(DatagramSocket ds){        this.ds = ds;    }    public void run(){        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());                Demo.sop(ip+"::"+data);            }        }catch(Exception e){            throw new RuntimeException("接收失败");        }finally{            ds.close();        }    }}

十一、网络编程(TCP传输)
    1、Socket和ServerSocket
    2、建立客户端和服务器端
    3、建立连接后，通过Socket中的IO流进行数据的传输
    4、关闭Socket
    同样，客户端和服务器端是两个独立的应用程序

/*演示TCP传输1、Tcp分客户端和服务端2、客户端对应的是Socket，服务端对应的是ServerSocket客户端通过查阅 Socket 对象，发现在该对象建立时，就可以去连接指定主机因为tcp是面向连接的，所以在建立socket服务时，就要有服务端存在，并连接成功，形成通路后，在该通道进行数据的传输步骤：1、创建Socket服务，并制定要连接的主机和端口。需求：给服务端发送一个文本数据步骤*/import java.net.*;import java.io.*;public class Demo{    public static void main(String[] args) throws Exception{            }    public static void sop(Object obj){        System.out.println(obj);    }}class TcpClient{    public static void main(String[] args) throws Exception{        //创建客户端的Socket服务，指定目的主机和端口        Socket s = new Socket("127.0.0.1",10000);                //为了发送数据，应该获取socket流中的输出流        OutputStream out = s.getOutputStream();                out.write("tcp ge men lai le ".getBytes());        s.close();    }}/*需求：定义端点接收数据并打印在控制台上服务端：1、建立服务端的socket服务，ServerSocket();    并监听一个端口2、获取连接过来的客户段对象    通过ServerSocket 的 accept方法，所以这个方法是阻塞式的3、客户端如果发过来数据，服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据4、关闭服务.(可选)*/class TcpServer{    public static void main(String[] args) throws Exception{        //建立服务端socket服务，并监听一个端口        ServerSocket ss = new ServerSocket(10000);        //通过accept方法获取链接过来的客户端对象        Socket s = ss.accept();                String ip = s.getInetAddress().getHostAddress();                Demo.sop(ip);                //获取客户端发过来的数据，那么要使用客户端对象的读取刘来读取数据        InputStream in = s.getInputStream();        byte[] buf = new byte[1024];        int len = in.read(buf);        Demo.sop(new String(buf,0,len));        s.close();        ss.close();    }}

十二、网络编程(TCP传输2)

/*演示TCP的传输的客户端和服务端的互访需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。*/import java.net.*;import java.io.*;public class Demo{    public static void main(String[] args) throws Exception{            }    public static void sop(Object obj){        System.out.println(obj);    }}/*客户端1、建立socket服务，指定要连接主机和端口。2、获取socket流中的输出流，将数据写到该流中，通过网络发给服务端。3、获取socket流中的输入流，将服务端反馈的数据获取到，并打印。*/class TcpClient{    public static void main(String[] args) throws Exception{        //创建客户端的Socket服务，指定目的主机和端口        Socket s = new Socket("127.0.0.1",10000);                //为了发送数据，应该获取socket流中的输出流        OutputStream out = s.getOutputStream();                out.write("服务端，你好".getBytes());        byte[] buf = new byte[1024];        InputStream in = s.getInputStream();        int len = in.read(buf);        Demo.sop(new String(buf,0,len));        s.close();    }}/*需求：定义端点接收数据并打印在控制台上服务端：1、建立服务端的socket服务，ServerSocket();    并监听一个端口2、获取连接过来的客户段对象    通过ServerSocket 的 accept方法，所以这个方法是阻塞式的3、客户端如果发过来数据，服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据4、关闭服务.(可选)*/class TcpServer{    public static void main(String[] args) throws Exception{        //建立服务端socket服务，并监听一个端口        ServerSocket ss = new ServerSocket(10000);        //通过accept方法获取链接过来的客户端对象        Socket s = ss.accept();                String ip = s.getInetAddress().getHostAddress();                Demo.sop(ip);                //获取客户端发过来的数据，那么要使用客户端对象的读取刘来读取数据        InputStream in = s.getInputStream();        byte[] buf = new byte[1024];        int len = in.read(buf);        Demo.sop(new String(buf,0,len));                OutputStream out = s.getOutputStream();        out.write("哥们收到，你也好".getBytes());        s.close();        ss.close();    }}

十三、网络编程(TCP练习）

 

/*需求：建立一个文本转换服务器客户端给服务端发送文本，服务端会将文本转换成大写再返回给客户端而且客户端可以不断的进行文本转换，当客户端输入over时，转换结束分析：    客户端;        既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考        源：键盘录入        目的：网络设备，网络输出流        而且操作的是文本数据，可以选择字符流    步骤：        1、建立服务        2、获取键盘录入        3、将数据发给服务端        4、打印出服务端返回的大写数据        5、结束，关资源    都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。    该例子出现的问题，现象：客户端和服务端都在莫名的等待，为什么：因为客户端和服务端都有阻塞式的方法，这些方法都没有读到结束标记，那么就一直等，而导致两端，都在等待        可以使用 PrintWriter PrintReader  ，自动刷新*/import java.net.*;import java.io.*;public class Demo{    public static void main(String[] args) throws Exception{            }    public static void sop(Object obj){        System.out.println(obj);    }}/*客户端1、建立socket服务，指定要连接主机和端口。2、获取socket流中的输出流，将数据写到该流中，通过网络发给服务端。3、获取socket流中的输入流，将服务端反馈的数据获取到，并打印。*/class TransClient{    public static void main(String[] args) throws Exception{        //创建客户端的Socket服务，指定目的主机和端口        Socket s = new Socket("127.0.0.1",10004);                //为了发送数据，应该获取socket流中的输出流        OutputStream out = s.getOutputStream();        //定义读取键盘数据的流对象        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));        //定义目的，将数据写入到socket输出流，发给服务端        BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));        //定义一个Socket读取流，读取服务端返回的大写信息        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));        String line = null;                while((line=bufr.readLine())!=null){            if("over".equals(line)){                break;            }            bufOut.write(line);            bufOut.newLine();            bufOut.flush();            String str = bufIn.readLine();            Demo.sop("server:"+str);        }        bufr.close();        s.close();//当socket调用close时，会发送一个数据-1给服务端，服务器也就结束掉了    }}/*服务端源socket读取流目的，socket'输出流都是文本。装饰*/class TransServer{    public static void main(String[] args) throws Exception{        //建立服务端socket服务，并监听一个端口        ServerSocket ss = new ServerSocket(10004);        //通过accept方法获取链接过来的客户端对象        Socket s = ss.accept();        Demo.sop(s.getInetAddress().getHostAddress()+"  已接入");        //读取socket读取流中数据        BufferedReader bufIn= new BufferedReader(new InputStreamReader(s.getInputStream()));        //目的，socket输出流，将大写数据写入到socket输出流，并发送给客户端        BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));        String line= null;        Demo.sop("等待接受数据。。。");        while((line=bufIn.readLine())!=null){//根据readLine（）判断回车符，来判断结束            bufOut.write(line.toUpperCase());            bufOut.newLine();//这是结束标记            bufOut.flush();//缓冲区        }        s.close();        ss.close();    }}

十四、网络编程(TCP复制文件)

/*void shutdownOutput()  禁用此套接字的输出流。 关闭*/import java.net.*;import java.io.*;public class Demo{    public static void main(String[] args) throws Exception{            }    public static void sop(Object obj){        System.out.println(obj);    }}class TextClient{    public static void main(String[] args) throws Exception{        Socket s = new Socket("127.0.0.1",10006);        BufferedReader bufr = new BufferedReader(new FileReader("Demo.java"));        PrintWriter out = new PrintWriter(s.getOutputStream(),true);        String line = null;        while((line=bufr.readLine())!=null){            out.println(line);        }        //out.println("over");//人工做标记，停止        s.shutdownOutput();//关闭客户端的输出流，相当于给流中加入一个结束标记，相当于给流中加入一个结束标记 -1        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));        String info = bufIn.readLine();        Demo.sop(info);        bufr.close();        bufIn.close();    }}class TextServer{    public static void main(String[] args) throws Exception{        ServerSocket ss = new ServerSocket(10006);        Socket s = ss.accept();        Demo.sop(s.toString());        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));        FileWriter fw = new FileWriter("Demo.txt");        BufferedWriter bufw= new BufferedWriter(fw);        String line = null;        while((line=bufIn.readLine())!=null){            //if("over".equals(line))                //break;//人工做标记，停止            bufw.write(line);            bufw.newLine();            bufw.flush();        }        PrintWriter pw = new PrintWriter(s.getOutputStream(),true);        pw.println("上传成功");        bufIn.close();        bufw.close();        pw.close();    }}