java——网络编程

网络七层协议

应用层

与其它计算机进行通讯的一个应用，它是对应应用程序的通信服务的。例如，一个没有通信功能的字处理程序就不能执行通信的代码，从事字处理工作的程序员也不关心OSI的第7层。但是，如果添加了一个传输文件的选项，那么字处理器的程序员就需要实现OSI的第7层。示例：TELNET，HTTP，FTP，NFS，SMTP等。

表示层

这一层的主要功能是定义数据格式及加密。例如，FTP允许你选择以二进制或ASCII格式传输。如果选择二进制，那么发送方和接收方不改变文件的内容。如果选择ASCII格式，发送方将把文本从发送方的字符集转换成标准的ASCII后发送数据。在接收方将标准的ASCII转换成接收方计算机的字符集。示例：加密，ASCII等。

会话层

它定义了如何开始、控制和结束一个会话，包括对多个双向消息的控制和管理，以便在只完成连续消息的一部分时可以通知应用，从而使表示层看到的数据是连续的，在某些情况下，如果表示层收到了所有的数据，则用数据代表表示层。示例：RPC，SQL等。

传输层

这层的功能包括是否选择差错恢复协议还是无差错恢复协议，及在同一主机上对不同应用的数据流的输入进行复用，还包括对收到的顺序不对的数据包的重新排序功能。示例：TCP，UDP，SPX。

网络层

这层对端到端的包传输进行定义，它定义了能够标识所有结点的逻辑地址，还定义了路由实现的方式和学习的方式。为了适应最大传输单元长度小于包长度的传输介质，网络层还定义了如何将一个包分解成更小的包的分段方法。示例：IP，IPX等。

数据链路层

它定义了在单个链路上如何传输数据。这些协议与被讨论的各种介质有关。示例：ATM，FDDI等。

物理层

OSI的物理层规范是有关传输介质的特这些规范通常也参考了其他组织制定的标准。连接头、帧、帧的使用、电流、编码及光调制等都属于各种物理层规范中的内容。物理层常用多个规范完成对所有细节的定义。示例：Rj45，802.3等。

网络通信要素

IP 地址 ：网络上主机设备的唯一标识。

IP地址=网络地址+主机地址

Host的标识

Ipv4 ：32位地址，一点分十进制数

IPV6：128位地址，以： 分隔8个16进制数

端口号：（定位程序）

用于标示进程的逻辑地址，不同进程的标示。

传输协议： 定义传输规则的，

数据包：单个消息被划分为多个数据块，这些数据块称为包，它包含发送者和接受者的地址信息。

本地回环地址：127.0.0.1 （代表自己，）主机名：localhost

套接字：Socket；

TCP 和 UDP

· UDP

． 将 数 据 及 和 目 的 封装 成 数 据 包 中 ， 不 需 要 建 立 连 接
· 每 个 数 据 报 的 大 小 茬 限 制 在 64k 内
． 因 无 连 接 ， 是 不 可 靠 协 议
· 不 需 要 建 立 连 接 ， 速 度 快

· TCP

· 建 立 连 接 ， 形 成 传 输 数 据 的 通 道 。
． 在 连 接 中 进 行 大 数 据 量 传 输
通 过 三 次 握 手 完 成 连 接 ， 是 可 靠 协 议
． 必 须 建 立 连 接 ， 效 率 会 稍 低

UDP发送与接收

DatagramPacket:发送接收数据类（集装箱）
DatagramPacket(byte[] buf, int length)用于接收端
DatagramPacket(byte[] buf, int length,InetAddress itr,int port)用于发送端。多了IP和端口号
DatagramPacket(byte[] buf,int offset, int length)用于接收端,缓冲数组从offset开始
DatagramPacket(byte[] buf,int offset, int length,InetAddress itr,int port)用于发送端
DatagramSocket（码头）
DatagramSocket(int port);可以创建接受和发送端指定一个端口号
DatagramSocket(int port，InetAddress addr)；

    public static void main(String[] args) throws IOException {

        System.out.println("发送端启动......");
        /*
         * 创建UDP传输的发送端。
         * 思路：
         * 1，建立udp的socket服务。
         * 2，将要发送的数据封装到数据包中。 
         * 3，通过udp的socket服务将数据包发送出去。
         * 4，关闭socket服务。
         */
        //1,udpsocket服务。使用DatagramSocket对象。
        DatagramSocket ds = new DatagramSocket(8888);
        
        
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        String line = null;
        
        while((line=bufr.readLine())!=null){
            
            
            byte[] buf = line.getBytes();
            DatagramPacket dp = 
                    new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.100"),10000);
            ds.send(dp);
            
            if("886".equals(line))
                break;
        }
        
        //4，关闭资源。
        ds.close();
        
        
    }

}

public static void main(String[] args) throws IOException {

        System.out.println("接收端启动......");
        /*
         * 建立UDP接收端的思路。
         * 1，建立udp socket服务,因为是要接收数据，必须要明确一个端口号。
         * 2，创建数据包，用于存储接收到的数据。方便用数据包对象的方法解析这些数据.
         * 3，使用socket服务的receive方法将接收的数据存储到数据包中。
         * 4，通过数据包的方法解析数据包中的数据。
         * 5，关闭资源 
         */
        
        //1,建立udp socket服务。
        DatagramSocket ds = new DatagramSocket(10000);
        
        while(true){
        
        //2,创建数据包。
        byte[] buf = new byte[1024];
        DatagramPacket dp = new DatagramPacket(buf,buf.length);     //3,使用接收方法将数据存储到数据包中。
        ds.receive(dp);//阻塞式的。
        //4，通过数据包对象的方法，解析其中的数据,比如，地址，端口，数据内容。
        String ip = dp.getAddress().getHostAddress();
        int port = dp.getPort();
        String text = new String(dp.getData(),0,dp.getLength());    
        System.out.println(ip+":"+port+":"+text);   
        }
        //5,关闭资源。
        ds.close(); 
    }
}

聊天案例

package cn.itcast.net.p3.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class Send implements Runnable {

    private DatagramSocket ds;
    
    public Send(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){
                
                
                byte[] buf = line.getBytes();
                DatagramPacket dp = 
                        new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10001);
                ds.send(dp);
                
                if("886".equals(line))
                    break;
            }
            
            ds.close();
        } catch (Exception e) {
        }
    }

}

package cn.itcast.net.p3.chat;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class Rece implements Runnable {

    private DatagramSocket ds;

    public Rece(DatagramSocket ds) {
        this.ds = ds;
    }

    @Override
    public void run() {
        try {
            while (true) {

                // 2,创建数据包。
                byte[] buf = new byte[1024];
                DatagramPacket dp = new DatagramPacket(buf, buf.length);

                // 3,使用接收方法将数据存储到数据包中。
                ds.receive(dp);// 阻塞式的。

                // 4，通过数据包对象的方法，解析其中的数据,比如，地址，端口，数据内容。
                String ip = dp.getAddress().getHostAddress();
                int port = dp.getPort();
                String text = new String(dp.getData(), 0, dp.getLength());
                
                System.out.println(ip + "::" + text);
                if(text.equals("886")){
                    System.out.println(ip+"....退出聊天室");
                }

            }
        } catch (Exception e) {

        }
    }
}

    public static void main(String[] args) throws IOException {

        
        DatagramSocket send = new DatagramSocket();
        
        DatagramSocket rece = new DatagramSocket(10001);
        new Thread(new Send(send)).start();
        new Thread(new Rece(rece)).start();
        
    }

TCP客户与服务

package cn.itcast.net.p4.tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClientDemo2 {



    public static void main(String[] args) throws UnknownHostException, IOException {
        //客户端发数据到服务端
        /*
         * Tcp传输，客户端建立的过程。
         * 1，创建tcp客户端socket服务。使用的是Socket对象。
         *      建议该对象一创建就明确目的地。要连接的主机。 
         * 2，如果连接建立成功，说明数据传输通道已建立。
         *      该通道就是socket流 ,是底层建立好的。 既然是流，说明这里既有输入，又有输出。
         *      想要输入或者输出流对象，可以找Socket来获取。 
         *      可以通过getOutputStream(),和getInputStream()来获取两个字节流。
         * 3，使用输出流，将数据写出。 
         * 4，关闭资源。 
         */
        
        
        
        Socket socket = new Socket("192.168.1.100",10002);
        
        
        OutputStream out = socket.getOutputStream();    
        
        
        out.write("tcp演示：哥们又来了!".getBytes());
        
        
        
        //读取服务端返回的数据,使用socket读取流。 
        InputStream in = socket.getInputStream();
        byte[] buf = new byte[1024];
        
        int len = in.read(buf);
        
        String  text = new String(buf,0,len);
        
        System.out.println(text);
        
        
        
        //关闭资源。
        socket.close();
        
        
        
        
        
        
    }

}

package cn.itcast.net.p4.tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo2 {


    public static void main(String[] args) throws IOException {
//      服务端接收客户端发送过来的数据，并打印在控制台上。 
        /*
         * 建立tcp服务端的思路：
         * 1，创建服务端socket服务。通过ServerSocket对象。
         * 2，服务端必须对外提供一个端口，否则客户端无法连接。
         * 3，获取连接过来的客户端对象。
         * 4，通过客户端对象获取socket流读取客户端发来的数据 
         *      并打印在控制台上。
         * 5，关闭资源。关客户端，关服务端。 
         */
        
        //1创建服务端对象。
        ServerSocket ss = new ServerSocket(10002);
        
        //2,获取连接过来的客户端对象。
        Socket s = ss.accept();
        
        String ip = s.getInetAddress().getHostAddress();
        
        //3，通过socket对象获取输入流，要读取客户端发来的数据
        InputStream in = s.getInputStream();
        
        byte[] buf = new byte[1024];
        
        int len = in.read(buf);
        String text = new String(buf,0,len);
        System.out.println(ip+":"+text);
        
        
        
        //使用客户端socket对象的输出流给客户端返回数据
        OutputStream out = s.getOutputStream();
        out.write("收到".getBytes());
        
        s.close();
        ss.close(); 
    }
}

上传C/B

package cn.itcast.net.p6.uploadtext;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadServer {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        System.out.println("上传服务端。。。。。。。。。");
        
        //1
        ServerSocket ss = new ServerSocket(10005);
        
        //2,
        Socket s = ss.accept();
        
        System.out.println(s.getInetAddress().getHostAddress()+".....connected");
        
        //3,
        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
        
        //4,
        BufferedWriter bufw = new BufferedWriter(new FileWriter("c:\\server.txt"));
        
        String line = null;
        
        while((line=bufIn.readLine())!=null){
            
//          if("over".equals(line))
//              break;
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
        }
        
        
        PrintWriter out = new PrintWriter(s.getOutputStream(),true);
        out.println("上传成功");
        
        bufw.close();
        
        s.close();
        ss.close();
        
        
    }

}

package cn.itcast.net.p6.uploadtext;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class UploadClient {

    /**
     * @param args
     * @throws IOException 
     * @throws UnknownHostException 
     */
    public static void main(String[] args) throws UnknownHostException, IOException {

        System.out.println("上传客户端。。。。。。");
        
        File file = new File("c:\\client.txt");
        System.out.println(file.exists());
        
        
        //1
        Socket s = new Socket("192.168.1.100",10005);
        
        //2
        BufferedReader bufr =
                new BufferedReader(new FileReader(file));
        
        //3,
        PrintWriter out = new PrintWriter(s.getOutputStream(),true);
        
        
        String line = null;
        while((line=bufr.readLine())!=null){
            
            out.println(line);
        }
        
        //告诉服务端，客户端写完了。
        s.shutdownOutput();
//      out.println("!@#$%^&*(");
        
        //4,
        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
        
        String str = bufIn.readLine();
        System.out.println(str);
        
        bufr.close();
        s.close();  
    }
}

上传图片

package cn.itcast.net.p1.uploadpic;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class UploadTask implements Runnable {

    private static final int SIZE = 1024*1024*2;
    private Socket s;

    public  UploadTask(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {

        int count = 0;
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip + ".....connected");
        
        try{

        // 读取客户端发来的数据。
        InputStream in = s.getInputStream();

        // 将读取到数据存储到一个文件中。
        File dir = new File("c:\\pic");
        if (!dir.exists()) {
            dir.mkdirs();
        }
        File file = new File(dir, ip + ".jpg");
        //如果文件已经存在于服务端 
        while(file.exists()){
            file = new File(dir,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);
            
            if(file.length()>SIZE){
                System.out.println(ip+"文件体积过大");
                
                fos.close();
                s.close();
                
                
                System.out.println(ip+"...."+file.delete());
                
                return ;
            }
        }

        // 获取socket输出流，将上传成功字样发给客户端。
        OutputStream out = s.getOutputStream();
        out.write("上传成功".getBytes());

        fos.close();
        s.close();
        }catch(IOException e){
            
        }

    }

}

package cn.itcast.net.p1.uploadpic;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadPicServer {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
            
        //创建tcp的socket服务端。
        ServerSocket ss = new ServerSocket(10006);
        
        while(true){
            Socket s = ss.accept();         
            
            new Thread(new UploadTask(s)).start();      
            
        }
        //获取客户端。
        
        
//      ss.close();
        
        
    }

}

package cn.itcast.net.p1.uploadpic;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class UploadPicClient {

    /**
     * @param args
     * @throws IOException 
     * @throws UnknownHostException 
     */
    public static void main(String[] args) throws UnknownHostException, IOException {

        
        //1,创建客户端socket。
        Socket s = new Socket("192.168.1.100",10006);
        
        //2,读取客户端要上传的图片文件。
        FileInputStream fis = new FileInputStream("c:\\0.bmp");
        
        //3,获取socket输出流，将读到图片数据发送给服务端。
        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 lenIn = in.read(buf);
        String text = new String(buf,0,lenIn);
        System.out.println(text);
        fis.close();
        s.close();  
    }
}

InetAddress 该类用于封装一个IP地址提供一系列IP地址相关的方法

TCP/IP四层分别是：应用层，传输层，网络层，链路层
链路层：物理传输通道
网络层：传输的数据进行分组，分组数据发送到目标或者网络
传输层：网络程序进行通信
应用层：主要负责应用程序的协议
UDP/TCP
传输层两个重要的高级协议
UDP：用户数据报协议
是无连接通信协议，数据的发送端和接收端不建立逻辑连接，就是发送端不会确认接收端是否存在就会发出数据所以重要数据不建议使用UDP协议
TCP：传输控制协议
是面向连接的通信协议 ，建立逻辑连接，“三次握手”“安全

网络通讯要素