java学习第二十四天之TCP、UDP

聊天室

package cn.network.demo;

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

public class ChatTest {
    /**
    * @param args
    * 通过UDP协议
    * 完成一个聊天程序
    * 一个负责发送数据的任务，一个负责接收数据的任务。两个任务需要同时执行
    * 可以使用多线程技术
     * @throws IOException 
    */
    public static void main(String[] args) throws IOException {
        /**
         * 通过UDP协议，完成一个聊天程序。一个负责发动数据的服务。一个负责接收数据的任务。两个任务需要同时进行。可以使用多线程技术
         * 创建socket服务
         * 发送端
         */
        DatagramSocket send=new DatagramSocket(8888);
        DatagramSocket rec=new DatagramSocket(10002);

        new Thread(new Send(send)).start();
        new Thread(new Rece(rec)).start();

    }
}

//负责发送的任务
class Send implements Runnable{
//  任务对象一建立 ，需要socket对象
    private DatagramSocket  ds;
    public Send(DatagramSocket ds) {
        super();
        this.ds = ds;
    }

    @Override
    public void run() {
//      具体的发送数据的任务内容
//      1.要发送的数据来自哪里?键盘录入
        BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));

//      读取数据
        String line=null;
        try {
            while((line=bufferedReader.readLine())!=null){

//              将数据变成字节数组，封装到数据不保
//              将数据封装到数据包中
                byte[] buf=line.getBytes();
                DatagramPacket datagramPacket=new DatagramPacket(buf, buf.length,
                        InetAddress.getByName("192.168.1.155"),10002);
                ds.send(datagramPacket);

                if("over".equals(line)){
                    System.exit(0);
                    break;

                }
            }
            ds.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
//      2.将数据封装到数据包中
//      3.将数据包发送出去




    }

}


//负责接收的任务
class Rece implements Runnable{
    private DatagramSocket ds;

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

    @Override
    public void run() {
        while(true){
//          接收的具体的任务的内容
//          因为接受的数据最终会存储到数据包中，而数据包中必须有字节数组
            byte[] buf=new byte[1024];

//          创建数据包对象
            DatagramPacket datagramPacket=new DatagramPacket(buf, buf.length);

//          将收到的数据存储到数据包中
            try {
                ds.receive(datagramPacket);
            } catch (IOException e) {
                e.printStackTrace();
            }
//          获取数据
            String ip=datagramPacket.getAddress().getHostAddress();
            String data=new String(datagramPacket.getData(),0 , datagramPacket.getLength());

            if("over".equals(data)){
                System.out.println(ip+"离开聊天室");
            }
            System.out.println(ip+":"+data);
        }
    }
}

获取IP基本信息

package cn.network.demo;

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

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

        InetAddress ip=InetAddress.getLocalHost();
        System.out.println(ip);
//      获取其他主机信息
        ip=InetAddress.getByName("www.sina.com.cn");

        String address=ip.getHostAddress();
        String name=ip.getHostName();


        System.out.println(address);
        System.out.println(name);
    }
}

UDP

/**
 * 
 */
package cn.network.demo;

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

/**
 * @author john5
 *
 */
public class UDPReceDemo {
    /**
    * @param args
    * 创建udp的接收端
    * 思路：
    *   1、创建socket服务，明确一个端口
    *   2、、收数据
    *   3、将其中所需的数据取出来， ipdata 端口
    *   4、关闭资源
     * @throws IOException 
    */
    public static void main(String[] args) throws IOException {
        System.out.println("UDP接收端启动了......");
//      创建socket服务
        DatagramSocket dSocket=new DatagramSocket(10000);
    /*  
        2、使用socket的接收方法。接收数据。需要将收到的数据存储到数据包中
        可以通过数据包对象的方法对收到的数据进行解析
    */
        byte[] buf=new byte[1024];
        DatagramPacket datagramPacket=new DatagramPacket(buf, buf.length);
        dSocket.receive(datagramPacket);

//      通过数据包对象解析收到的数据，使用数据包的方法
        String ip=datagramPacket.getAddress().getHostAddress();
        int port=datagramPacket.getPort();
//      获取文字数据

        String string=new String(datagramPacket.getData(),0,datagramPacket.getLength());
        System.out.println(ip+"："+port+"-----"+string);
    }
}

package cn.network.demo;

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

public class UDPSendDemo {
    /**
    * @param args
    * 需求：建立udp的发送端
    * 思路：
    *   1、建立可以实现udp传输的socket服务
    *   2、明确具体发送的数据
    *   3、通过socket服务将具体的数据发送出去
    *   4、关闭服务
     * @throws IOException 
    */
    public static void main(String[] args) throws IOException {
        System.out.println("UDP发送端启动......");
//      创建udp服务
        DatagramSocket datagramSocket=new DatagramSocket(8888);
//      明确数据
        String string="注意啦！UDP来啦！";

//      发送数据，将数据封装到数据包中
//      3、1将数据封装到数据包对象中。数据包会明确目的地址和端口
        byte[] buf=string.getBytes();
        DatagramPacket dPacket=new DatagramPacket(buf, buf.length,
                InetAddress.getByName("192.168.1.136"),10000);
//      3、2发送
        datagramSocket.send(dPacket);

//      3、3关闭
        datagramSocket.close();
    }
}

TCP

package cn.network.demo;

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

public class TCPClient {
    /**
    * @param args
    * tcp客户端的建立
    * 思路：
    *   1、建立TCP客户端
    *   1、1因为是面向连接的，必须有连接才可以进行通信
    *   1、2在创建客户端时，就必须明确目的地址 和端口
    *   2、一旦连接建立,就有了传输数据的通道，就可以在通道中金属数据传输
    *   这个传输其实就是通过流实现的。这个流就是socket io 流
    *   3、只要获取socket io中的鞋动作就可以将数据写到socket流中发给服务端
    *   4、关闭资源
     * @throws IOException 
     * @throws UnknownHostException 
    */
    public static void main(String[] args) throws UnknownHostException, IOException {
        System.out.println("客户端启动....");
//      创建客户端对象，明确目的和端口
        Socket socket=new Socket("192.168.1.136", 10004);

//      获取socket流中的输出流，将数据发送给服务端
        OutputStream outputStream=socket.getOutputStream();

//      通过输出流写数据
        outputStream.write("TCP来啦".getBytes());

//      关闭资源
        socket.close();
    }
}

package cn.network.demo;

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


public class TCPServer {
    /**
    * @param args
    * 创建TCP服务端
    * 思路：
    *   1、创建socket服务器端服务 。服务器端为了让客户端可以连上，必须提供端口，监听一个端口
    *   2、获取客户端对象，通过客户端的socket流和对应的客户端进行通讯
    *   3、获取客户端的socket流的读取流
    *   4、读取数据并显示在服务器端
    *   5、关闭资源
     * @throws IOException 
    *   
    */
    public static void main(String[] args) throws IOException {
        System.out.println("服务器端启动..........");
        //创建服务器对象
        ServerSocket serverSocket=new ServerSocket(10004);

        //获取客户端对象
        Socket socket=serverSocket.accept();
        String ip=socket.getInetAddress().getHostAddress();
        System.out.println(ip+".........connected");

//      通过客户端对象获取socket流的读取流
        InputStream inputStream=socket.getInputStream();

        byte[] buf=new byte[1024];
        int len=inputStream.read(buf);

        String string=new String(buf, 0, len);
        System.out.println(string);

        socket.close();
    }
}

TCP2

package cn.network.demo;

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

public class TCPClient2 {
    /**
    * @param args
    * 需求：客户端发送数据给服务端，并读取服务端反馈的数据
     * @throws IOException 
     * @throws UnknownHostException 
    * 
    */
    public static void main(String[] args) throws UnknownHostException, IOException {
        System.out.println("客户端2启动....");
//      创建socket客户端
        Socket socket=new Socket("192.168.1.136", 10005);

//      获取socket输出流，写数据
        OutputStream out=socket.getOutputStream();

        out.write("服务端我来了！".getBytes());

//      获取socket的读取流，读取服务端发回的数据
        InputStream inputStream=socket.getInputStream();

        byte[] buf=new byte[1024];
        int len=inputStream.read(buf);
        String strs=new String(buf, 0, len);

        System.out.println(strs);
        socket.close();

    }
}

package cn.network.demo;

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

public class TCPServer2 {
    /**
    * @param args
    * 服务端收到客户端的数据并反馈数据给客户端。应答
     * @throws IOException 
    * 
    */
    public static void main(String[] args) throws IOException {
        System.out.println("服务器端启动");
//      创建服务端socket对象
        ServerSocket sSocket=new ServerSocket(10005);

//      获取客户端对象
        Socket socket=sSocket.accept();
        String ip=socket.getInetAddress().getHostAddress();
        System.out.println(ip+"......connected");

//      获取socket读取流
        InputStream inputStream=socket.getInputStream();

        byte[] buf=new byte[1024];
        int len=inputStream.read(buf);
        String strs=new String(buf, 0, len);
        System.out.println(strs);

//      给客户端反馈数据，socket输出流
        OutputStream outputStream=socket.getOutputStream();
        outputStream.write("已连接".getBytes());
        socket.close();
        sSocket.close();

    }
}

上传图片

package cn.network.demo;

import java.io.File;
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 UploadPicCllient {
    /**
    * @param args
     * @throws IOException 
     * @throws UnknownHostException 
    */
    public static void main(String[] args) throws UnknownHostException, IOException {
        System.out.println("上传图片的客户端已开启......");
        Socket socket=new Socket("192.168.1.136", 18079);

        File picFile=new File("1.jpg");

        FileInputStream fileInputStream=new FileInputStream(picFile);
        OutputStream outputStream=socket.getOutputStream();

        byte[] buf=new byte[1024];
        int len=fileInputStream.read(buf);
        while((len=fileInputStream.read(buf))!=-1){
            outputStream.write(buf,0,len);
        }
        socket.shutdownOutput();


//      读取服务器端的数据
        InputStream inputStream=socket.getInputStream();
        byte[] bufIn=new byte[1024];
        int lenIn=inputStream.read(bufIn);
        String strs=new String(bufIn, 0, lenIn);
        System.out.println(strs);

        fileInputStream.close();
        socket.close();

    }
}

package cn.network.demo;

import java.io.File;
import java.io.FileInputStream;
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 {
        System.out.println("上传图片服务端已开启........");
        ServerSocket serverSocket=new ServerSocket(18078);

        Socket socket=serverSocket.accept();
        String ip=socket.getInetAddress().getHostAddress();
        System.out.println(ip+"......connected");

        InputStream iStream=socket.getInputStream();

        File file = getfile("D:\\java\\workspace\\Stage2\\Pic",ip);
//      FileInputStream fInputStream=new FileInputStream(file);
        FileOutputStream fOutputStream=new FileOutputStream(file);

        byte[] buf=new byte[1024];
        int  len=0;

        while((len=iStream.read(buf))!=-1){
            fOutputStream.write(buf, 0, len);
        }

//      回馈客户端数据
        OutputStream oStream=socket.getOutputStream();
        oStream.write("上传图片成功".getBytes());

        fOutputStream.close();
        socket.close();
        serverSocket.close();
    }

    private static File getfile(String dir,String ip) throws IOException {
        File pic_dir=new File(dir);
        if(!pic_dir.exists()){
            pic_dir.mkdir();
        }
        File file=new File(pic_dir,ip+".jpg");//创建失败？？？
        int count=0;
        if(file.exists()){
            file=new File(ip,"("+count+").jpg");
        }else{
            file.createNewFile();
        }
        return file;
    }
}

上传文件

package cn.network.demo;

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

public class UploadTextClient {
    /**
    * @param args
    * 上传文本的客户端。读取本地的文本数去，发送给服务端，服务端接收完毕后，回馈“上传成功字样”
    * 客户端 socket
     * @throws IOException 
     * @throws UnknownHostException 
    */
    public static void main(String[] args) throws UnknownHostException, IOException {
        System.out.println("上传客户端启动了......");
//      客户端socket
        Socket socket=new Socket("192.168.1.136", 8887);

//      确定数据源，本地文件
        BufferedReader bufferedReader=new BufferedReader(new FileReader("client.txt"));//高效

//      确定数据流，socket输出
        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        PrintWriter out=new PrintWriter(socket.getOutputStream(),true);//true代表刷新

        String line=null;
        while((line=bufferedReader.readLine())!=null){
            out.println(line);
        }

//      给服务器端发送标记
        out.println("over");


//      上面的over  使用socket的禁用输出流方法
        socket.shutdownOutput();

//      通过socket读取流获取服务器端返回的数据
        BufferedReader bufferedIn=new BufferedReader(new InputStreamReader(socket.getInputStream()));

        String lineIn=bufferedIn.readLine();
        System.out.println(lineIn);

//      关闭
        bufferedReader.close();
        socket.close();
    }
}

package cn.network.demo;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
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 UploadTextServer {
    /**
    * @param args
    * 上传文本的服务端，接受文本数据，并存储到文件中，服务器端接收完毕以后，回馈“上传成功”字样
     * @throws IOException 
    */
    public static void main(String[] args) throws IOException {
        /*File file=new File("client.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        BufferedReader bufferedReader=new BufferedReader(new FileReader("client.txt"));//高效
        String line=null;
        while((line=bufferedReader.readLine())!=null){
            System.out.println(line);
        }
    */
        System.out.println("上传服务端启动了........");
//      1、服务端对象
        ServerSocket serverSocket=new ServerSocket(8887);

//      2、获取客户端
        Socket socket=serverSocket.accept();
        String ip=socket.getInetAddress().getHostAddress();
        System.out.println(ip+"....connected");

        //3、获取读取流，确定源，网络socket
        BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(socket.getInputStream()));

//  4、确定目的。文件
        PrintWriter printWriter=new PrintWriter(new FileWriter("server.txt",true));

//  5、频繁读写
        String line=null;
        while((line=bufferedReader.readLine())!=null){
            if("over".equals(line))
                break;
            printWriter.println(line);
        }

        printWriter.println("over");

//  6、给客户端返回信息
        PrintWriter out=new PrintWriter(socket.getOutputStream(),true);
        out.println("上传成功");

        printWriter.close();
        serverSocket.close();
        serverSocket.close();
    }
}

多次上传

package cn.network.demo;

import java.io.File;
import java.io.FileInputStream;
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 UploadThreads {
    public static void main(String[] args) throws IOException {
        System.out.println("上传图片服务端已开启........");
        ServerSocket serverSocket=new ServerSocket(18079);
        while(true){
            Socket socket=serverSocket.accept();

            new Thread(new UploadPic(socket)).start();
        }
    }
}

package cn.network.demo;

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

public class UploadPic implements Runnable {
    private Socket socket;

    public UploadPic(Socket s) {
        super();
        this.socket = s;
    }

    @Override
    public void run() {
        String ip=socket.getInetAddress().getHostAddress();
        File file= getfile("D:\\java\\workspace\\Stage2\\Pic",ip);

        System.out.println(ip+"......connected");

        InputStream iStream;
        try {
            iStream=socket.getInputStream();
            FileOutputStream fOutputStream=new FileOutputStream(file);

            byte[] buf=new byte[1024];
            int  len=0;

            while((len=iStream.read(buf))!=-1){
                fOutputStream.write(buf, 0, len);
            }

//          回馈客户端数据
            OutputStream oStream=socket.getOutputStream();
            oStream.write("上传图片成功".getBytes());

            fOutputStream.close();
            socket.close();
        } catch (Exception e) {
            // TODO: handle exception
        }



    }

    private static File getfile(String dir,String ip) throws IOException {
        File pic_dir=new File(dir);
        if(!pic_dir.exists()){
            pic_dir.mkdir();
        }
        File file=new File(pic_dir,ip+".jpg");//创建失败？？？
        int count=0;
        if(file.exists()){
            file=new File(ip,"("+count+").jpg");
        }else{
            file.createNewFile();
        }
        return file;
    }
}