java网络编程Socket

最新推荐文章于 2023-02-05 23:20:09 发布

bingo_liu

最新推荐文章于 2023-02-05 23:20:09 发布

阅读量323

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/bingo_liu/article/details/55224411

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

概述

用Java语言实现计算机间数据的信息传递和资源共享

三要素

    1. IP地址
    2. 端口
        应用程序的标识。范围：0-65535。其中0-1024不建议使用。
    3. 协议
        UDP:数据打包,有限制,不连接,效率高,不可靠
        TCP:建立数据通道,无限制,效率低,可靠

IP地址

网络中计算机的唯一标识

组成：网络号段+主机号段

A类：第一号段为网络号段+后三段的主机号段
    一个网络号：256*256*256 = 16777216
B类：前二号段为网络号段+后二段的主机号段
    一个网络号：256*256 = 65536
C类：前三号段为网络号段+后一段的主机号段
    一个网络号：256

分类：

A类  1.0.0.1---127.255.255.254   
    1) 10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)
    2) 127.X.X.X是保留地址，用做循环测试用的。
B类  128.0.0.1---191.255.255.254
    172.16.0.0---172.31.255.255是私有地址
    169.254.X.X是保留地址
C类  192.0.0.1---223.255.255.254 
    192.168.X.X是私有地址
D类  224.0.0.1---239.255.255.254     
E类  240.0.0.1---247.255.255.254

特殊的IP地址：
    127.0.0.1 回环地址(表示本机)
    x.x.x.255 广播地址
    x.x.x.0 网络地址

端口号：

正在运行的程序的标识。
有效端口：0~65535，其中0~1024系统使用或保留端口。

协议（通信的规则）：

UDP：
    把数据打包
    数据有限制
    不建立连接
    速度快
    不可靠

TCP：
    建立连接通道
    数据无限制
    速度慢
    可靠

举例：
    UDP：发短信
    TCP：打电话

Socket机制

A:通信两端都应该有Socket对象
B:所有的通信都是通过Socket间的IO进行操作的

UDP协议发送和接收数据

发送：
    创建UDP发送端的Socket对象
    创建数据并把数据打包
    发送数据
    释放资源
接收：
    创建UDP接收端的Socket对象
    创建数据包用于接收数据
    接收数据
    解析数据包
    释放资源

TCP协议发送和接收数据

发送：
    创建TCP客户端的Socket对象
    获取输出流，写数据
    释放资源
接收：
    创建TCP服务器端的Socket对象
    监听客户端连接
    获取输入流，读取数据
    释放资源

UDP案例

/*
 * 聊天程序
 */
public class ChatRoom {
    public static void main(String[] args) throws IOException {
        DatagramSocket dsSend = new DatagramSocket();
        DatagramSocket dsReceive = new DatagramSocket(12306);

        SendThread st = new SendThread(dsSend);
        ReceiveThread rt = new ReceiveThread(dsReceive);

        Thread t1 = new Thread(st);
        Thread t2 = new Thread(rt);

        t1.start();
        t2.start();
    }
}

public class SendThread implements Runnable {
    private DatagramSocket ds;
    public SendThread(DatagramSocket ds) {
        this.ds = ds;
    }
    @Override
    public void run() {
        try {
            // 封装键盘录入数据
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String line = null;
            while ((line = br.readLine()) != null) {
                if ("886".equals(line)) {
                    break;
                }
                // 创建数据并打包
                byte[] bys = line.getBytes();
                // DatagramPacket dp = new DatagramPacket(bys, bys.length,
                // InetAddress.getByName("192.168.12.92"), 12345);
                DatagramPacket dp = new DatagramPacket(bys, bys.length,
                        InetAddress.getByName("192.168.12.255"), 12306);
                // 发送数据
                ds.send(dp);
            }
            // 释放资源
            ds.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class ReceiveThread implements Runnable {
    private DatagramSocket ds;
    public ReceiveThread(DatagramSocket ds) {
        this.ds = ds;
    }
    @Override
    public void run() {
        try {
            while (true) {
                // 创建一个包裹
                byte[] bys = new byte[1024];
                DatagramPacket dp = new DatagramPacket(bys, bys.length);
                // 接收数据
                ds.receive(dp);
                // 解析数据
                String ip = dp.getAddress().getHostAddress();
                String s = new String(dp.getData(), 0, dp.getLength());
                System.out.println("from " + ip + " data is : " + s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

TCP案例

public class UserThread implements Runnable {
    private Socket s;

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

    @Override
    public void run() {
        try {
            // 封装通道内的流
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));

            // 为了防止名称冲突
            String newName = System.currentTimeMillis() + ".java";
            BufferedWriter bw = new BufferedWriter(new FileWriter(newName));

            String line = null;
            while ((line = br.readLine()) != null) { // 阻塞
                bw.write(line);
                bw.newLine();
                bw.flush();
            }

            // 给出反馈
            BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
            bwServer.write("文件上传成功");
            bwServer.newLine();
            bwServer.flush();

            // 释放资源
            bw.close();
            s.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class UploadClient {
    public static void main(String[] args) throws IOException {
        // 创建客户端Socket对象
        Socket s = new Socket("192.168.12.92", 11111);

        // 封装文本文件
        BufferedReader br = new BufferedReader(new FileReader("ReceiveDemo.java"));
        // 封装通道内流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line = null;
        while ((line = br.readLine()) != null) { // 阻塞
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        // Socket提供了一个终止，通知服务器我没有数据过来了
        s.shutdownOutput();

        // 接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String client = brClient.readLine(); // 阻塞
        System.out.println(client);

        // 释放资源
        br.close();
        s.close();
    }
}

public class UploadServer {
    public static void main(String[] args) throws IOException {
        // 创建服务器Socket对象
        ServerSocket ss = new ServerSocket(11111);

        while (true) {
            Socket s = ss.accept();
            new Thread(new UserThread(s)).start();
        }
    }
}