26 - UDP&TCP

IP地址：用来唯一表示我们自己的电脑的，是一个网络标示
端口号：用来区别当前电脑中的应用程序的
UDP: 传送速度快，但是容易丢数据，如视频聊天，语音聊天
TCP: 传送稳定，不会丢失数据，如文件的上传、下载

package cn.itcast.demo;

import java.net.InetAddress;
import java.net.UnknownHostException;

/*
 *  表示互联网中的IP地址
 *    java.net.InetAddress
 *  静态方法
 *    static InetAddress  getLocalHost()   LocalHost本地主机
 *    返回本地主机,返回值InetAddress对象
 *    
 *    static InetAddress getByName(String hostName)传递主机名,获取IP地址对象
 *    
 *  非静态方法
 *     String getHoustAddress()获取主机IP地址
 *     String getHoustName()获取主机名
 *    
 */
public class InetAddressDemo {
    public static void main(String[] args)throws UnknownHostException {
        function_1();
    }
    /*
     * static InetAddress getByName(String hostName)传递主机名,获取IP地址对象
     */
    public static void function_1()throws UnknownHostException {
        InetAddress inet = InetAddress.getByName("www.baidu.com");
        System.out.println(inet);
    }
    
    /*
     *  static InetAddress  getLocalHost()   LocalHost本地主机
     */
    public static void function() throws UnknownHostException{
        InetAddress inet = InetAddress.getLocalHost();
        //输出结果就是主机名,和 IP地址
        System.out.println(inet.toString());
        
        String ip = inet.getHostAddress();
        String name = inet.getHostName();
        System.out.println(ip+"   "+name);
        
        /*String host = inet.toString();
        String[] str = host.split("/");
        for(String s : str){
            System.out.println(s);
        }*/
    }
}

 

1. UDP程序交互的流程

    发送端
        1,创建DatagramSocket对象
        2，创建DatagramPacket对象，并封装数据
        3，发送数据
        4，释放流资源
    接收端
        1,创建DatagramSocket对象
        2,创建DatagramPacket对象
        3,接收数据存储到DatagramPacket对象中
        4,获取DatagramPacket对象的内容
        5,释放流资源

package cn.itcast.demo1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/*
 *  实现UDP接收端
 *    实现封装数据包 java.net.DatagramPacket 将数据接收
 *    实现输出传输     java.net.DatagramSocket 接收数据包
 *    
 *  实现步骤:
 *     1. 创建DatagramSocket对象,绑定端口号
 *         要和发送端端口号一致
 *     2. 创建字节数组,接收发来的数据
 *     3. 创建数据包对象DatagramPacket
 *     4. 调用DatagramSocket对象方法
 *        receive(DatagramPacket dp)接收数据,数据放在数据包中
 *     5. 拆包
 *          发送的IP地址
 *            数据包对象DatagramPacket方法getAddress()获取的是发送端的IP地址对象
 *            返回值是InetAddress对象
 *          接收到的字节个数
 *            数据包对象DatagramPacket方法 getLength()
 *          发送方的端口号
 *            数据包对象DatagramPacket方法 getPort()发送端口
 *     6. 关闭资源
 */
public class UDPReceive {
    public static void main(String[] args)throws IOException {
        //创建数据包传输对象DatagramSocket 绑定端口号
        DatagramSocket ds = new DatagramSocket(6000);
        //创建字节数组
        byte[] data = new byte[1024];
        //创建数据包对象,传递字节数组
        DatagramPacket dp = new DatagramPacket(data, data.length);
        //调用ds对象的方法receive传递数据包
        ds.receive(dp);
        
        //获取发送端的IP地址对象
        String ip=dp.getAddress().getHostAddress();
        
        //获取发送的端口号
        int port = dp.getPort();
        
        //获取接收到的字节个数
        int length = dp.getLength();
        System.out.println(new String(data,0,length)+"..."+ip+":"+port);
        ds.close();
    }
}

package cn.itcast.demo1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
 *  实现UDP协议的发送端:
 *    实现封装数据的类 java.net.DatagramPacket  将你的数据包装
 *    实现数据传输的类 java.net.DatagramSocket  将数据包发出去
 *    
 *  实现步骤:
 *    1. 创建DatagramPacket对象,封装数据, 接收的地址和端口
 *    2. 创建DatagramSocket
 *    3. 调用DatagramSocket类方法send,发送数据包
 *    4. 关闭资源
 *    
 *    DatagramPacket构造方法:
 *      DatagramPacket(byte[] buf, int length, InetAddress address, int port) 
 *      
 *    DatagramSocket构造方法:
 *      DatagramSocket()空参数
 *      方法: send(DatagramPacket d)
 *      
 */
public class UDPSend {
    public static void main(String[] args) throws IOException{
        //创建数据包对象,封装要发送的数据,接收端IP,端口
        byte[] date = "你好UDP".getBytes();
        //创建InetAddress对象,封装自己的IP地址
        InetAddress inet = InetAddress.getByName("127.0.0.1");
        DatagramPacket dp = new DatagramPacket(date, date.length, inet,6000);
        //创建DatagramSocket对象,数据包的发送和接收对象
        DatagramSocket ds = new DatagramSocket();
        //调用ds对象的方法send,发送数据包
        ds.send(dp);
        //关闭资源
        ds.close();
    }
}

=======================

package cn.itcast.demo2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/*
 *  实现UDP接收端
 *  永不停歇的接收端
 */
public class UDPReceive {
    public static void main(String[] args)throws IOException {
        //创建数据包传输对象DatagramSocket 绑定端口号
        DatagramSocket ds = new DatagramSocket(6000);
        //创建字节数组
        byte[] data = new byte[1024];
        //创建数据包对象,传递字节数组
        while(true){
        DatagramPacket dp = new DatagramPacket(data, data.length);
        //调用ds对象的方法receive传递数据包
        ds.receive(dp);
        
        //获取发送端的IP地址对象
        String ip=dp.getAddress().getHostAddress();
        
        //获取发送的端口号
        int port = dp.getPort();
        
        //获取接收到的字节个数
        int length = dp.getLength();
        System.out.println(new String(data,0,length)+"..."+ip+":"+port);
        }
        //ds.close();
    }
}

package cn.itcast.demo2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

/*
 * 实现UDP发送,键盘输入的形式
 * 输入完毕,发送给接收端      
 */
public class UDPSend {
    public static void main(String[] args) throws IOException{
        Scanner sc = new Scanner(System.in);
        DatagramSocket ds = new DatagramSocket();
        InetAddress inet = InetAddress.getByName("127.0.0.1");
        while(true){
        String message = sc.nextLine();
        /*if("886".equals(message)){
            break;
        }*/
        byte[] date = message.getBytes();
        DatagramPacket dp = new DatagramPacket(date, date.length, inet,6000);
        ds.send(dp);
        }
    //    ds.close();
    }
}

 

2. TCP程序交互的流程

    客户端
        1,创建客户端的Socket对象
        2,获取Socket的输出流对象
        3,写数据给服务器
        4,获取Socket的输入流对象
        5，使用输入流，读反馈信息
        6,关闭流资源
    服务器端
        1，创建服务器端ServerSocket对象，指定服务器端端口号
        2，开启服务器，等待着客户端Socket对象的连接，如有客户端连接，返回客户端的Socket对象
        3, 通过客户端的Socket对象，获取客户端的输入流，为了实现获取客户端发来的数据
        4, 通过客户端的输入流，获取流中的数据
        5, 通过客户端的Socket对象，获取客户端的输出流，为了实现给客户端反馈信息
        6, 通过客户端的输出流，写数据到流中
        7, 关闭流资源

package cn.itcast.demo3;

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

/*
 *  实现TCP服务器程序
 *  表示服务器程序的类 java.net.ServerSocket
 *  构造方法:
 *    ServerSocket(int port) 传递端口号
 *  
 *  很重要的事情: 必须要获得客户端的套接字对象Socket
 *    Socket  accept()
 */
public class TCPServer {
    public static void main(String[] args) throws IOException{
        ServerSocket server = new ServerSocket(8888);
        //调用服务器套接字对象中的方法accept() 获取客户端套接字对象
        Socket socket = server.accept();
        //通过客户端套接字对象,socket获取字节输入流,读取的是客户端发送来的数据
        InputStream in = socket.getInputStream();
        byte[] data = new byte[1024];
        int len = in.read(data);
        System.out.println(new String(data,0,len));
        
        //服务器向客户端回数据,字节输出流,通过客户端套接字对象获取字节输出流
        OutputStream out = socket.getOutputStream();
        out.write("收到,谢谢".getBytes());
        
        socket.close();
        server.close();
    }
}

package cn.itcast.demo3;

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

/*
 *  实现TCP客户端,连接到服务器
 *  和服务器实现数据交换
 *  实现TCP客户端程序的类 java.net.Socket
 *  
 *  构造方法:
 *      Socket(String host, int port)  传递服务器IP和端口号
 *      注意:构造方法只要运行,就会和服务器进行连接,连接失败,抛出异常
 *      
 *    OutputStream  getOutputStream() 返回套接字的输出流
 *      作用: 将数据输出,输出到服务器
 *      
 *    InputStream getInputStream() 返回套接字的输入流
 *      作用: 从服务器端读取数据
 *      
 *    客户端服务器数据交换,必须使用套接字对象Socket中的获取的IO流,自己new流,不行
 */
public class TCPClient {
    public static void main(String[] args)throws IOException {
        //创建Socket对象,连接服务器
        Socket socket = new Socket("127.0.0.1", 8888);
        //通过客户端的套接字对象Socket方法,获取字节输出流,将数据写向服务器
        OutputStream out = socket.getOutputStream();
        out.write("服务器OK".getBytes());
        
        //读取服务器发回的数据,使用socket套接字对象中的字节输入流
        InputStream in = socket.getInputStream();
        byte[] data = new byte[1024];
        int len = in.read(data);
        System.out.println(new String(data,0,len));
        
        socket.close();
    }
}

=================

package cn.itcast.demo4;

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

/*
 *  TCP图片上传服务器
 *   1. ServerSocket套接字对象,监听端口8000
 *   2. 方法accept()获取客户端的连接对象
 *   3. 客户端连接对象获取字节输入流,读取客户端发送图片
 *   4. 创建File对象,绑定上传文件夹
 *       判断文件夹存在, 不存,在创建文件夹
 *   5. 创建字节输出流,数据目的File对象所在文件夹
 *   6. 字节流读取图片,字节流将图片写入到目的文件夹中
 *   7. 将上传成功会写客户端
 *   8. 关闭资源
 *       
 */
public class TCPServer {
    public static void main(String[] args) throws IOException{
        ServerSocket server = new ServerSocket(8000);
        Socket socket = server.accept();
        //通过客户端连接对象,获取字节输入流,读取客户端图片
        InputStream in = socket.getInputStream();
        //将目的文件夹封装到File对象
        File upload = new File("d:\\upload");
        if(!upload.exists())
            upload.mkdirs();
        
        //防止文件同名被覆盖,从新定义文件名字
        //规则:  域名+毫秒值+6位随机数
        String filename="itcast"+System.currentTimeMillis()+new Random().nextInt(999999)+".jpg";
        //创建字节输出流,将图片写入到目的文件夹中                         
        FileOutputStream fos = new FileOutputStream(upload+File.separator+filename);
        //读写字节数组
        byte[] bytes = new byte[1024];
        int len = 0 ;
        while((len = in.read(bytes))!=-1){
            fos.write(bytes, 0, len);
        }
        //通过客户端连接对象获取字节输出流
        //上传成功写回客户端
        socket.getOutputStream().write("上传成功".getBytes());
        
        fos.close();
        socket.close();
        server.close();
    }
}

package cn.itcast.demo4;

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

/*
 *  实现TCP图片上传客户端
 *  实现步骤:
 *    1. Socket套接字连接服务器
 *    2. 通过Socket获取字节输出流,写图片
 *    3. 使用自己的流对象,读取图片数据源
 *         FileInputStream
 *    4. 读取图片,使用字节输出流,将图片写到服务器
 *       采用字节数组进行缓冲
 *    5. 通过Socket套接字获取字节输入流
 *       读取服务器发回来的上传成功
 *    6. 关闭资源
 */
public class TCPClient {
    public static void main(String[] args) throws IOException{
        Socket socket = new Socket("127.0.0.1", 8000);
        //获取字节输出流,图片写到服务器
        OutputStream out = socket.getOutputStream();
        //创建字节输入流,读取本机上的数据源图片
        FileInputStream fis = new FileInputStream("c:\\t.jpg");
        //开始读写字节数组
        int len = 0 ;
        byte[] bytes = new byte[1024];
        while((len = fis.read(bytes))!=-1){
            out.write(bytes, 0, len);
        }
        //给服务器写终止序列
        socket.shutdownOutput();
        
        //获取字节输入流,读取服务器的上传成功
        InputStream in = socket.getInputStream();

        len = in.read(bytes);
        System.out.println(new String(bytes,0,len));
        
        fis.close();
        socket.close();
    }
}

package cn.itcast.demo4;

import java.io.IOException;

import java.net.ServerSocket;
import java.net.Socket;

public class TCPThreadServer {
    public static void main(String[] args) throws IOException{
        ServerSocket server = new ServerSocket(8000);
        while(true){
        //获取到一个客户端,必须开启新线程
        Socket socket = server.accept();
        new Thread( new Upload(socket) ).start();
        }
        
        
    }
}

 

package cn.itcast.demo4;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

public class Upload implements Runnable{
    
    private Socket socket;
    
    public Upload(Socket socket){this.socket=socket;}
    
    public void run() {
        try{
        //通过客户端连接对象,获取字节输入流,读取客户端图片
        InputStream in = socket.getInputStream();
        //将目的文件夹封装到File对象
        File upload = new File("d:\\upload");
        if(!upload.exists())
            upload.mkdirs();
        
        //防止文件同名被覆盖,从新定义文件名字
        //规则:  域名+毫秒值+6位随机数
        String filename="itcast"+System.currentTimeMillis()+new Random().nextInt(999999)+".jpg";
        //创建字节输出流,将图片写入到目的文件夹中                         
        FileOutputStream fos = new FileOutputStream(upload+File.separator+filename);
        //读写字节数组
        byte[] bytes = new byte[1024];
        int len = 0 ;
        while((len = in.read(bytes))!=-1){
            fos.write(bytes, 0, len);
        }
        //通过客户端连接对象获取字节输出流
        //上传成功写回客户端
        socket.getOutputStream().write("上传成功".getBytes());
        
        fos.close();
        socket.close();
        }catch(Exception ex){
            
        }
    }
    
}