JAVA基础 day25 网络编程 IP类 UDP，TCP传输学习 简易聊天工具 TCP并发学习

最新推荐文章于 2024-04-24 16:32:36 发布
最新推荐文章于 2024-04-24 16:32:36 发布
阅读量439 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c99463904/article/details/53000531
版权

网络编程

网络通讯要素：

IP地址（32位）：网络中设备的标识，不易记忆，可用主机名。本地回环地址:127.0.0.1,主机名：localhost

端口（0-65535）
传输协议（常用的有TCP/IP,UDP）

网络模型：

OSI参考模型，TCP/IP参考模型

学习javase主要是在传输层和网际层进行学习。
这里写图片描述

IP类

InetAddress，没有构造方法。

import java.net.*;
class IPDemo
{
    public static void main(String[]args)throws UnknownHostException
    {
        //InetAddress i=InetAddress.getLocalHost();//返回本地主机
        //System.out.println(i);
        //System.out.println(i.getHostAddress()+"---"+i.getHostName());

        InetAddress ia=InetAddress.getByName("www.baidu.com");//给定主机名返回IP地址
        System.out.println(ia);
    }
}

传输协议的区别：

UDP，不需要建立连接，直接发送就行。没接收到就丢包。QQ和视频会议之类都可以用UDP。
TCP：必须建立连接。不能丢包，例子：下载工具使用TC。P
这里写图片描述

socket传输
这里写图片描述

UDP传输协议

UDP创建发送端的步骤
1.通过DatagramSocket创建udp服务
2.通过DatagramPacket封装要发送的数据包
3.通过DatagramSocket的send方法发送数据包
4..关闭资源。

import java.net.*;
class UdpSendDemo
{
    public static void main(String[]args)throws Exception
    {
        DatagramSocket ds=new DatagramSocket();//创建udp服务
        byte[] buf="Udp send test.".getBytes();
        DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),10000);//将数据包封装
        ds.send(dp);//发送
        ds.close();//关闭资源
    }
}

UDP创建接收端
1.通过DatagramSocket创建udp服务，并且指定接收哪个端口的信息
2.通过DatagramPacket定义好一个数据包，接受数据。
3.通过DatagramSocket的receive方法接收数据包
4.通过DatagramPacket的方法将数据包中的内容提取出来。

import java.net.*;
class UdpReceiveDemo
{
    public static void main(String[]args)throws Exception
    {
        DatagramSocket ds=new DatagramSocket(10000);//监控10000端口的信息
        byte[]buf=new byte[1024];
        DatagramPacket dp=new DatagramPacket(buf,buf.length);
        ds.receive(dp);
        String s=new String(dp.getData(),0,dp.getLength());
        System.out.println(s);

    }
}

编程，编写简易的聊天工具
1.接收和发送是同时的，所以需要用到多线程

import java.io.*;
import java.net.*;
class Send implements Runnable//发送线程
{
    private DatagramSocket ds;
    Send(DatagramSocket ds)
    {
        this.ds=ds;
    }
    public void run()
    {
        try{
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String line=null;
            while (!(line=br.readLine()).equals("over"))
            {
                byte[]buf=line.getBytes();
                DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.199.112"),10008);
                ds.send(dp);
            }
            ds.close();
        }
        catch(Exception e)
        {

            throw new RuntimeException("发送失败");
        }
    }
}
class Receive implements Runnable//接收线程
{
    private DatagramSocket ds;
    Receive(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());
            System.out.println(ip+"::"+data);   
        }
        }
        catch(Exception e)
        {
            throw new RuntimeException("接收失败");
        }       
    }
}
class ChatDemo
{
    public static void main(String[]args)throws Exception
    {
        DatagramSocket sendSocket=new DatagramSocket();
        DatagramSocket receSocket=new DatagramSocket(10008);
        new Thread(new Send(sendSocket)).start();
        new Thread(new Receive(receSocket)).start();
    }
}

TCP传输

这里写图片描述
Socket实现客户端套接字，ServerSocket实现服务端套接字。
当客户端和服务端连接时，就已经存在一个流。客户端通过这个流传送数据，
而服务端可以通过方法获得客户端的对象，来和客户端进行通讯。

编程：TCP传输

客户端

import java.io.*;
import java.net.*;
class TcpClient
{
    public static void main(String[]args)throws Exception
    {
        Socket s=new Socket("192.168.199.112",11000);//创建服务
        OutputStream out=s.getOutputStream();//获取输入流
        out.write("服务端你好".getBytes());//发送数据
        InputStream in=s.getInputStream();//用来接收服务端的数据
        byte[] buf=new byte[1024];
        int len=in.read(buf);
        System.out.println(new String(buf,0,len));

        s.close();

    }
}

服务端

import java.io.*;
import java.net.*;
class TcpServer
{
    public static void main(String[]args)throws Exception
    {
        ServerSocket ss=new ServerSocket(11000);//创建服务端服务
        Socket s=ss.accept();//获取客户端对象
        String ip=s.getInetAddress().getHostAddress();
        System.out.println(ip+"正在连接");
        InputStream in=s.getInputStream();//获取客户端数据
        byte[]buf=new byte[1024];
        int len=in.read(buf);
        System.out.println(new String(buf,0,len));
        OutputStream out=s.getOutputStream();//向客户端反馈数据
        out.write("服务端收到".getBytes());
        s.close();
        ss.close();
    }
}

编程：客户端输入数据，服务端将其变成大写后返回

客户端

import java.io.*;
import java.net.*;
class TextCastClient//客户端
{
    public static void main(String[]args)throws Exception
    {
        Socket s=new Socket("192.168.199.112",30000);
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        OutputStream out=s.getOutputStream();
        InputStream in=s.getInputStream();
        byte[]buf=new byte[1024];
        int num=0;
        String line=null;
        while(!(line=br.readLine()).equals("over"))
        {
            out.write(line.getBytes());
            num=in.read(buf);
            String str=new String(buf,0,num);
            System.out.println("客户端收到"+str);
        }
        s.close();
        br.close(); 
    }
}

服务端

import java.io.*;
import java.net.*;
class TextCastServer//服务端
{
    public static void main(String[]args)throws Exception
    {
        ServerSocket ss=new ServerSocket(30000);
        Socket s=ss.accept();
        InputStream in=s.getInputStream();
        OutputStream out=s.getOutputStream();
        byte[]buf=new byte[1024];
        int num=0;
        while (true)
        {
            num=in.read(buf);
            String str=new String(buf,0,num);
            System.out.println("服务端收到"+str);
            String str1=str.toUpperCase();
            out.write(str1.getBytes());
        }

    }
}

编程：TCP上传图片

import java.io.*;
import java.net.*;
class TcpPicCopyClient
{
    public static void main(String[]args)throws Exception
    {
        Socket s=new Socket("192.168.199.112",20005);
        FileInputStream f=new FileInputStream("basketball.jpeg");
        OutputStream out=s.getOutputStream();
        byte[]buf=new byte[1024];
        int num=0;
        while ((num=f.read(buf))!=-1)
        {
            out.write(buf);
        }
        s.shutdownOutput();
        InputStream in=s.getInputStream();
        byte[]buf1=new byte[100];
        int num1=in.read(buf1);
        System.out.println(new String(buf1,0,num1));
    }
}


//服务端
class TcpPicCopyServer
{
    public static void main(String[]args)throws Exception
    {
        ServerSocket ss=new ServerSocket(20005);
        Socket s=ss.accept();
        InputStream in=s.getInputStream();
        OutputStream out=s.getOutputStream();
        FileOutputStream f=new FileOutputStream("1.jpeg");
        byte[]buf=new byte[1024];
        int num=0;
        while ((num=in.read(buf))!=-1)
        {
            f.write(buf);
        }
        out.write("上传成功".getBytes());
        s.close();
        ss.close();

    }
}

在实际运行中，当两个客户端同时连接服务端时，获得一个对象，第一个客户端没运行完，第二个客户端是获取不到对象的，所以需要开启多线程。

编程：Tcp并发上传图片

//客户端
import java.io.*;
import java.net.*;
class PicClient
{
    public static void main(String[]args)throws Exception
    {
        File file=new File(args[0]);
        Socket s=new Socket("192.168.199.112",20010);
        FileInputStream fis=new FileInputStream(file);
        OutputStream out=s.getOutputStream();
        InputStream in=s.getInputStream();
        byte[]buf=new byte[1024];
        int num=0;
        while((num=fis.read(buf))!=-1)
        {
            out.write(buf,0,num);
        }
        s.shutdownOutput();
        byte[]buf1=new byte[1024];
        int num1=in.read(buf1);
        System.out.println(new String(buf1,0,num1));
        fis.close();
        s.close();
    }
}


//服务端，要并发上传
class PicThread implements Runnable
{
    private Socket s;
    PicThread(Socket s)
    {
        this.s=s;
    }
    public void run()
    {
        int count=1;
        String ip=s.getInetAddress().getHostAddress();
        try{
        System.out.println(ip+"--正在连接");
        File file=new File(ip+".jpeg");//当文件存在时，用原文件名+（数字）进行创建，不覆盖
        while(file.exists())
            file=new File(ip+"("+(count++)+")"+".jpeg");
        FileOutputStream fos=new FileOutputStream(file);
        InputStream in=s.getInputStream();
        OutputStream out=s.getOutputStream();
        byte[]buf=new byte[1024];
        int num;
        while((num=in.read(buf))!=-1)
        {
            fos.write(buf,0,num);
        }
        out.write("上传成功".getBytes());
        fos.close();
        s.close();
        }
        catch(Exception e)
        {
            System.out.println("上传失败");
        }

    }
}
class PicServer
{
    public static void main(String[]args)throws Exception
    {
        ServerSocket ss=new ServerSocket(20010);
        while(true)
        {
        Socket s=ss.accept();
        new Thread(new PicThread(s)).start();
        }

    }

}

编程：TCP并发登陆
只能登陆三次，登陆成功客户端显示 欢迎光临，失败显示用户不存在。
登陆成功服务端显示已登陆，失败显示尝试登陆。

import java.io.*;
import java.net.*;
class LoginClient//客户端
{
    public static void main(String[]args)throws Exception
    {
        Socket s=new Socket("192.168.199.112",25000);
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));//读取键盘输入
        PrintStream ps=new PrintStream(s.getOutputStream(),true);
        BufferedReader br1=new BufferedReader(new InputStreamReader(s.getInputStream()));
        for(int x=0;x<3;x++)
        {
            String line=br.readLine();//读取键盘
            if(line==null)
                break;
            ps.println(line);//发送到服务端
            String info=br1.readLine();//接收反馈
            System.out.println(info);
            if(info.contains("欢迎"))//如果登陆成功，就不再循环
                break;
        }
        br.close();
        s.close();
    }
}



//服务端
class LoginThread implements Runnable
{
    private Socket s;
    LoginThread(Socket s)
    {
        this.s=s;
    }
    public void run()
    {
        try{

         for (int x=0;x<3;x++)
         {
            BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
            BufferedReader br1=new BufferedReader(new FileReader("user.txt"));
            PrintStream out=new PrintStream(s.getOutputStream());//获取客户端发送的数据
            String name=br.readLine();
            if(name==null)
                break;
            String line=null;
            boolean flag=false;
            while((line=br1.readLine())!=null)//读取的数据和文件里数据对比
            {
                if(name.equals(line))
                {
                    flag=true;
                    break;
                }
            }
            if (flag)
            {
                System.out.println(name+"已登陆");
                out.println((name+"欢迎光临"));
                break;
            }
            else
            {
                System.out.println(name+"尝试登陆");
                out.println((name+"用户名不存在"));
            }   
          }

          s.close();
         }
        catch(Exception e)
        {
            throw new RuntimeException("错误");
        }

    }
}
class LoginServer
{
    public static void main(String[]args)throws Exception
    {
        ServerSocket ss=new ServerSocket(25000);
        while(true)
        {
        Socket s=ss.accept();
        new Thread(new LoginThread(s)
        ).start();
        }
    }
}
春水上行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Day24_8 Java学习之线程池、网络编程及TCP通信程序
weixin_43717536的博客
08-24 390
解析：1.通过前面的文章讲述想必大家都知道了什么是线程，由于在使用线程时，若我们并发的线程及多，一个线程完成一个任务之后就死亡销毁，这样频繁的创建销毁是非常的消耗时间资源的，会极大的降低程序运行效率。2.为了解决上述的问题，就有了线程池。线程池：就是根据程序的运行需求先创建好N条线程放在线程池中等待，在需要时才随机的从池中抽取线程进行任务，任务完成后又回到线程池变成等待的空闲状态，这样会极大的提高效率。3.合理利于线程池带来的好处：3.1降低资源消耗。
1.16 第二章+第三章 TCP和UDP基础通信模型day2+TCP并发服务器day1
01-16
1.16 第二章+第三章 TCP和UDP基础通信模型day2+TCP并发服务器day1
端口扫描forAndroid
01-24
端口扫描forAndroid 端口扫描forAndroid 端口扫描forAndroid 端口扫描forAndroid 端口扫描forAndroid
Day40 网络编程（二） InetAddress类, Socket ,TCP编程，UDP编程
最新发布
yjp1240201821的博客
04-24 1246
本节讲解网络编程（二）InetAddress类、Socket 、TCP编程、UDP编程，从其相关概念、经验，理解，示例等等帮助深刻理解网络编程
【网络编程】Day4 TCP并发服务器
wangxiasun的博客
07-08 226
3. 多线程代码写一遍，能否将newfd定义成全局（不行，找原因）发送方：memberSend.c。发送方：boardSend.c。接收方：boardrRcv.c。接收方：memberRcv.c。1. 广播，组播代码重新写一遍。2. 多进程通过模型自己写一遍。4. 上传下载写完。
网络编程(OSI模型、TCP/IP模型、UDP及TCP通信、并发服务器、I/O多路复用与线程池、组播及广播)笔记-day14
weixin_47409584的博客
05-04 1501
摘要：网络体系结构（OSI 七层模型、TCP/IP 四层模型、IP地址(点分制、整型)及字节序转序、端口号）；UDP及TCP通信（发送与接受端、服务器与客户端）；循环服务器模型（多线程并发服务器、I/O多路复用与线程池）；组播及广播
java网络编程示例
07-02
Java网络编程是Java开发中的重要领域，主要用于实现设备间的通信，包括本地网络和互联网上的通信。本示例主要探讨如何构建一个基本的客户机-服务器架构，其中客户机能够发送消息给服务器，而服务器则负责转发这些...
day12-网络编程1
08-04
综上所述，网络编程涉及多个层面，从基础的IP地址识别到端口的管理和协议的选择，都是实现网络通信的关键。理解并掌握这些概念对于进行网络编程至关重要，无论是开发网络应用、服务器程序还是进行网络诊断，都有着...
day11_网络编程2
08-08
【网络编程基础】 1. IP地址概念：IP地址（Internet Protocol Address）是互联网上的设备的唯一标识，类似于现实世界中的邮政地址。它是由32位二进制数组成，通常用点分十进制的形式表示，例如192.168.1.1。IP地址...
JAVA简易版坦克大战
春水上行的博客
11-18 2802
package mytankgame; import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter;
JAVA基础 day21 字节流的输入和输出 字节流的缓冲区 （自己实现BufferedInputStream） 键盘输入 转换流的用法 改变标准输入输出设备 IO流操作的基本规律
春水上行的博客
10-21 1362
字节流： OutputStream:字节流写入基类。字节流并不需要刷新操作，因为字符流底层是将传入的字节先存放在一个数组中，然后去查表得到字符，所以需要刷新。而字节流是直接将数据传送到目标位置。FileOutputStream 文件字节写入操作类import java.io.*; class FileOutputStreamDemo { public static void main(S
JAVA基础 day24 GUI的学习 事件监听机制 编写简易的记事本 jar包双击执行
春水上行的博客
10-28 1153
GUI：图形用户接口JAVA为GUI提供的对象都在java.Awt和javax.Swing两个包里。java.Awt：Abstract Window ToolKit（抽象窗口工具包），需要调用本地系统方法实现功能。属于重量级控件。javax.Swing：在AWT的基础上，建立的一套图形界面系统。其中提供了很多的组件，完全由java实现。增强了移植性，属轻量级控件。继承关系。 GUI布局 创建图形
JAVA基础 day22 File类的方法和应用 利用递归获取目录下的所有文件 Properties类的应用（和IO技术结合，存取配置文件） 打印流和合并流等功能类的学习应用 切割文件练习
春水上行的博客
10-23 1003
File类 将已存在的或者未存在的文件封装成对象。 封装文件的三种构造方法，只是封装，并不创建。import java.io.*; class FileDemo1 { public static void main(String[]args) { File f1=new File("file1.txt"); File f2=new File("c:
JAVA基础day07 继承 final关键字 抽象类 接口 的学习
春水上行的博客
09-12 817
继承：关键字 extends class 子类 extends 父类{}； 提高了代码的复用性 让类与类之间有了关系，有了这个关系，才有了多态的特性。 java只支持单继承。因为多继承将会带来安全隐患，例如 类A和类B有相同名称的方法时，类C同时继承A，B，将不确定会运行哪个方法。子类和父类拥有非私有的同名变量时，可以用super访问父类变量。 this是本类的引用。supe
JAVA基础 day19 IO流概述 字符流：FileWriter类和FileReader类的使用 BufferedWriter和BufferedReader类的使用
春水上行的博客
10-19 796
IO流：用来处理设备之间的数据传输 流按操作数据分为两种：字节流和字符流 按流向分为：输入流和输出流字节流的抽象基类：InputStream，OutputStream 字符流的抽象基类：Reader，WriterFileWriter类： 创建该类对象时，该对象一被初始化就必须明确要被操作的文件，如果文件不存在，则会在指定目录下创建该文件，如果指定目录下有该文件，那么就会覆盖掉原来的文件。im
JAVA基础day04 数组学习 排序和查找基本算法
春水上行的博客
09-08 792
定义数组 int []arr=new int[n]; int []arr=new int[]{1,2,3}; 数组名称.length 获取数组的长度。选择排序：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访
JAVA基础day05 面向对象思想 成员变量和方法 封装 构造方法和this的使用
春水上行的博客
09-10 791
面向对象三个特征：封装，继承，多态。匿名对象 new 类().成员变量. 当对对象的方法只调用一次时，使用匿名对象比较简化。 匿名对象还可以作为实际参数传递。 例如： /* main（）{ show（new 类（））； } public static void show（类 c） { } */权限修饰符 public，private，protected， 封装原则：把不
JAVA基础day06 static关键字 静态方法的运用 java程序文档的制作
春水上行的博客
09-11 760
被static修饰的静态变量。即可以直接用对象调用，也可以使用类名调用。例如，类名.变量。static修饰的数据存储在共享区（方法区或者数据区）static特点：随着类的加载而加载普通成员变量也叫实例变量，静态成员变量也叫类变量，因为可以直接通过类名调用。静态方法只能访问静态成员，非静态方法即可以访问静态成员，也可以访问非静态， 静态方法中不可以使用this，super关键字，因为静态优先于对象先
网络编程基础：TCP/IP协议与套接字解析
TCP/IP协议作为互联网的基础，由传输控制协议(TCP)和因特网互联协议(IP)组成，它定义了计算机如何接入互联网及数据传输标准。TCP/IP协议采用了四层模型，分别是应用层、传输层、网络层和数据链路层，每一层都有其...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值