Java网络编程学习笔记

最新推荐文章于 2024-06-09 16:06:06 发布
最新推荐文章于 2024-06-09 16:06:06 发布
阅读量101 收藏
点赞数
分类专栏： Java学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44375810/article/details/109695190
版权

网络编程

1.TCP消息发送

1.1客户端

  1. 连接服务器Socket

  2. 发送消息

package com.chen.net;

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

public class Customer {
    public static void main(String[] args) {
        Socket s=null;
        OutputStream os=null;
        try{
            //获取地址
            InetAddress ia=InetAddress.getByName("localhost");
            int port=8888;
            //建立连接
            s=new Socket(ia,port);
            //发送消息 IO流
            os=s.getOutputStream();
            os.write("hello~".getBytes());
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally{
            if(os!=null)
                try{
                    os.close();
                }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            if(s!=null)
                try{
                    s.close();
                }
            catch (Exception e)
            {
                e.printStackTrace();
            }

        }
    }
}

1.2服务器

  1. 建立服务端口ServerSocket

  2. 等待用户连接accept

  3. 接受客户端消息

package com.chen.net;

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

public class Service {
    public static void main(String[] args) throws IOException {
        ServerSocket ss=null;
        Socket s=null;
        InputStream is=null;
        ByteArrayOutputStream bao=null;
        try{
            //设置地址
            ss=new ServerSocket(8888);
            //等待客户端连接过来
            while(true){
                try{
                    ss.setSoTimeout(50000);
                }
                catch (Exception e)
                {
                    break;
                }
                s=ss.accept();
                is=s.getInputStream();
                //读取客户端消息
                byte[] ac=new byte[1024];
                int len;
                //管道流
                bao=new ByteArrayOutputStream();
                while((len=is.read(ac))!=-1)
                {
                    bao.write(ac,0,len);
                }
                System.out.println(bao.toString());
            }

        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally{
            if(bao!=null)
                try
                {
                    bao.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            if(is!=null)
                try
                {
                    is.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            if(s!=null)
                try
                {
                    s.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            if(ss!=null)
                try
                {
                    ss.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            System.out.println("通信结束！");
        }
    }
}

2.TCP实现文件上传

类似TCP实现聊天

2.1服务器

package com.chen.net;

        import java.io.*;
        import java.net.ServerSocket;
        import java.net.Socket;

public class Service {
    public static void main(String[] args) throws IOException {
        ServerSocket ss=null;
        Socket s=null;
        InputStream is=null;
        FileOutputStream bao=null;
        try {
                //1.设置地址
                ss = new ServerSocket(8888);
               while(true) {

                //2.等待客户端连接
                s = ss.accept();

                //3.获取输入流
                is = s.getInputStream();
                byte[] ac = new byte[1024];
                int len;
                
                //4.文件输出
                bao = new FileOutputStream("service.JPG");
                while ((len = is.read(ac)) != -1) {
                    bao.write(ac, 0, len);
                }

                //5.通知客户端我收到了文件
                OutputStream outputStream = s.getOutputStream();
                outputStream.write("我收到了，可以关闭连接了~".getBytes());
                
                //6.通知客户端我的消息传输完毕
                s.shutdownOutput();
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally{
            if(bao!=null)
                try
                {
                    bao.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            if(is!=null)
                try
                {
                    is.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            if(s!=null)
                try
                {
                    s.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            if(ss!=null)
                try
                {
                    ss.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            System.out.println("通信结束！");
        }
    }
}

2.2客户端

package com.chen.net;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

public class Customer {
    public static void main(String[] args) {
        Socket s=null;
        OutputStream os=null;
        try{
            //1.获取地址
            InetAddress ia=InetAddress.getByName("localhost");
            int port=8888;

            //2.建立连接
            s=new Socket(ia,port);

            //3.上传文件
            os=s.getOutputStream();
            FileInputStream fis=new FileInputStream("src/test.JPG");
            byte[] buffer=new byte[1024];
            int len;
            while((len=fis.read(buffer))!=-1)
            {
                os.write(buffer,0,len);
            }

            //4.通知服务器端我已经传输完了
            s.shutdownOutput();

            //5.确认服务器接收完毕
            InputStream inputStream=s.getInputStream();
            ByteArrayOutputStream bao=new ByteArrayOutputStream();
            byte[] buffer2=new byte[1024];
            int len1;
            while((len1=inputStream.read(buffer2))!=-1)
            {
                bao.write(buffer2,0,len1);
            }
            System.out.println(bao.toString());
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally{
            if(os!=null)
                try{
                    os.close();
                }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            if(s!=null)
                try{
                    s.close();
                }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

3.UDP消息发送

3.1发送端

  1. 建立DatagramSocket

  2. 新建包

  3. 发送包

package com.chen.net.udp;

import java.io.IOException;
import java.net.*;

public class udpClientDemo {
    public static void main(String[] args) throws IOException {
        //1.建立DatagramSocket
        DatagramSocket ds=new DatagramSocket();

        //2.建立包
        String msg="你好,服务器~";
        InetAddress ia=InetAddress.getByName("localhost");
        int port=8090;

        //数据、起点、长度、发送给谁
        DatagramPacket dp=new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,ia,port);

        //3.发送包
        ds.send(dp);
        ds.close();
    }
}

3.2接收端

  1. 开放端口
  2. 接收数据包
package com.chen.net.udp;

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

public class udpServerDemo {
    public static void main(String[] args) throws IOException {
        //1.开放端口
        DatagramSocket ds=new DatagramSocket(8090);
        //2.接收数据包
        byte[] buffer=new byte[1024];
        DatagramPacket dp=new DatagramPacket(buffer,0,buffer.length);
        ds.receive(dp);  //阻塞接收
        System.out.println(dp.getAddress().toString());
        System.out.println(new String(buffer,0,buffer.length));
        ds.close();
    }
}

4.UDP实现文件上传

4.1发送端

package com.chen.net.udp;

import java.io.IOException;
import java.net.*;

public class udpClientDemo {

    public static void main(String[] args) throws IOException {
        DatagramSocket ds=null;
        DatagramPacket dp=null;
        try
        {
            //1.建立DatagramSocket
            ds=new DatagramSocket();

            //2.建立包
            byte[] buffer=IoUtils.fileToByteArray("src/test.JPG");
            InetAddress ia=InetAddress.getByName("localhost");
            int port=8090;

            //数据、起点、长度、发送给谁
            dp = new DatagramPacket(buffer, 0,buffer.length, ia, port);

            //3.发送包
            ds.send(dp);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(ds!=null)
                try{

                }
            catch (Exception e)
            {
                ds.close();
            }
        }
    }
}

4.2接收端

package com.chen.net.udp;

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

public class udpServerDemo {
    public static void main(String[] args) {
        DatagramSocket ds=null;
        try{
            //1.开放端口
            ds=new DatagramSocket(8090);

            //2.接收数据包
            byte[] buffer=new byte[1024*60];
            DatagramPacket dp=new DatagramPacket(buffer,0,buffer.length);
            ds.receive(dp);  //阻塞接收
            IoUtils.byteArrayToFile(dp.getData(),"msg.JPG");
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally {
            if(ds!=null)
            try{
                ds.close();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }

    }
}

4.3工具类

package com.chen.net.udp;

import java.io.*;

public class IoUtils {
    public static byte[] fileToByteArray(String filePath){
        FileInputStream is=null;
        ByteArrayOutputStream baos=null;
        try
        {
            is=new FileInputStream(filePath);
            baos=new ByteArrayOutputStream();
            byte[] buffer=new byte[1024];
            int len;
            while((len=is.read(buffer))!=-1)
            {
                baos.write(buffer,0,len);
            }
            baos.flush();
        }
       catch(Exception e)
       {
           e.printStackTrace();
       }
        finally {
            if(is!=null)
                try{
                    is.close();
                }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            if(baos!=null)
                try{
                    baos.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
        }
        return baos.toByteArray();
    }
    public static void byteArrayToFile(byte[] buffer,String filePath) {
        ByteArrayInputStream bais=null;
        FileOutputStream fos=null;
        try
        {
            bais=new ByteArrayInputStream(buffer);
            fos=new FileOutputStream(filePath);
            byte[] tmp=new byte[1024];
            int len;
            while((len=bais.read(tmp))!=-1)
            {
                fos.write(tmp,0,len);
            }
            fos.flush();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally{
            if(bais!=null)
                try
                {
                    bais.close();   
                }
               catch(Exception e)
               {
                   e.printStackTrace();
               }
          if(fos!=null)
              try
              {
                  fos.close();
              }
          catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

4.4备注

一、 while((len=bais.read(tmp))!=-1)
{
fos.write(tmp,0,len);
}

read方法的参数tmp为一次读取数据量

二、DatagramPacket dp=new DatagramPacket(buffer,0,buffer.length);
该构造器最后一个参数限定了接收数据量的大小，要避免分配空间过小导致文件失败

5.Socket与DatagramSocket的区别

Socket:使用TCP连接，需要连接成功后才能进行通信

DatagramSocket:使用UDP连接，客户端不需要连接服务端，可以直接向指定服务端发送数据

6.UDP在线咨询

核心：两个人都既是发送方，又是接收方

重点：多线程的使用

6.1发送类

package com.chen.net.realChart;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.reflect.Executable;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class Sender implements Runnable{
    private String toIp;
    private int toPort;
    private DatagramSocket socket=null;
    private BufferedReader br=null;
    public Sender(String toIp, int toPort)
    {
        try
        {
            socket=new DatagramSocket();
            br=new BufferedReader(new InputStreamReader(System.in));
            this.toIp=toIp;
            this.toPort=toPort;
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try
        {
            while(true)
            {
                String message=br.readLine();
                byte[] buffer=message.getBytes();
                DatagramPacket dp=new DatagramPacket(buffer,0,buffer.length,new InetSocketAddress(toIp,toPort));
                socket.send(dp);
                if(message.trim().equals("bye"))
                {
                    break;
                }
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(br!=null)
                try
                {
                    br.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            if(socket!=null)
                try{
                    socket.close();
                }
            catch (Exception e)
            {
                e.printStackTrace();
            }

        }

    }
}

6.2接收类

package com.chen.net.realChart;

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

public class Receiver implements Runnable{
    private DatagramSocket socket=null;
    private String fromName=null;
    public Receiver(int port, String fromName)
    {
        try
        {
            this.socket=new DatagramSocket(port);
            this.fromName=fromName;
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try
        {
            while(true)
            {
                byte[] received=new byte[1024];
                DatagramPacket dp=new DatagramPacket(received,0,received.length);
                socket.receive(dp);

                byte[] tmp=dp.getData();
                String message=new String(tmp,0,tmp.length);
                System.out.println(fromName+":"+message);
                if(message.trim().equals("bye"))
                {
                    break;
                }

            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally {
            if(socket!=null)
                try{
                    socket.close();
                }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

6.3咨询对象一：老师

package com.chen.net.realChart;

public class Teacher {
    private static String talker="学生";
    public static void main(String[] args)
    {
        new Thread(new Sender("localhost",1234)).start();
        new Thread(new Receiver(9494,talker)).start();
    }
}

6.4咨询对象二：学生

package com.chen.net.realChart;

public class Student {
    private static String talker="老师";
    public static void main(String[] args)
    {
        new Thread(new Sender("localhost",9494)).start();
        new Thread(new Receiver(1234,talker)).start();
    }
}

7.利用URL下载文件

package com.chen.net.downFile;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class urlDown{
    public static void main(String[] args) throws IOException {
        //1.获取URL
        URL url=new URL("https://webfs.yun.kugou.com/202010241707/7df53cca785a2d34d113623e9da22466/part/0/960931/G112/M01/06/00/EIcBAFw0EIqAUjs5AClSIVJy_ec396.mp3");

        //2.打开连接
        HttpURLConnection connection=(HttpURLConnection)url.openConnection();

        InputStream inputStream=connection.getInputStream();

        FileOutputStream fos=new FileOutputStream("f2.mp3");

        //3.下载
        byte[] buffer=new byte[1024];
        int len;
        while((len=inputStream.read(buffer))!=-1)
        {
            fos.write(buffer,0,len);
        }
        fos.close();
        inputStream.close();
        connection.disconnect();
    }
}
一壶烈酒可慰风尘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习笔记---网络编程
乌云的博客
12-03 460
1、概念：两台设备之间通过网络实现数据传输2、网络通信：将数据通过网络从一台设备传输到另一台设备3、java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信1、概念：两台或多台设备通过一定物理设备连接起来构成了网络2、根据网络的覆盖范围不同，对网络进行分类 局域网：覆盖范围最小，仅仅覆盖一间教室或者一个机房 城域网：覆盖范围较大，可以覆盖一个城市 广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表1、概念：用于唯一标识网络中的每台计算机/主机2、查
java中的基础网络编程学习笔记
weixin_44585687的博客
03-08 302
一、InetAddress类的使用 1. 网络编程中有两个主要的问题： 1.如何准确地定位网络上的一台或多台主机；定位主机上的特定应用 2.找到主机后如何可靠高效地进行数据传输 2. 网络通信的两个要素： 1.对应问题一：IP和端口号 2.对应问题二：提供网络通信协议：TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层） 3. 通信要素一：IP和端口号 3.1 IP的理解 IP：唯一的标识Internet上的计算机（通信实体） 在Java中使用InetAddress类代表IP IP的分类：IP
文件数据储存之内部储存
热门推荐
计蒙不吃鱼的博客
03-01 1万+
Android官方API：在设备内存中存储私有数据。 内部储存：Android的内部储存位于系统中，是在手机内存中的文件，！！！不是SD卡（外部存储器）中的文件。内部储存文件默认的存放位置是data/data/files目录下，并且是私有的(private)。可以把它设置为公有的（public），则可以被其他的App访问。当一个应用卸载后，内部储存中的文件会被删除。 使用：内部储存空间十分有限，主...
ByteArrayOutputStream
weixin_30954607的博客
10-27 2213
ByteArrayInputStream:https://www.cnblogs.com/zhangj-ymm/p/9842657.html ByteArrayOutputStream是字节数组输出流,它把数据写入到自己的数组中,数组的大小会随着数据的不断增加而自动增长. 通过ByteArrayOutputStream()创建的"字节数组输出流"对应的字节数组大小是32 通过Byte...
IO流的读写
xinmulee的博客
03-05 166
测试了一些用普通的BufferReader读太慢了，还是用字节数组输出流比较快，测试nio比它还慢几十毫秒如果读写8M的txt文件示例代码：String newpath=""; //long start = System.currentTimeMillis(); Map<String, MapBean> map = XmlReader.viewXML(""); File oldf...
网络编程笔记
weixin_41062965的博客
04-09 442
​ 端口 端口表示计算机上的一个程序的进程 不同的进程有不同的端口号，用来区分软件！ 被规定0~65535 TCP,UDP：65535*2 tcp80和udp80不冲突 端口分类 公有端口 0~1023 HTTP：80 HTTPS：443 FTP：21 Telnet：23 程序注册端口：1024~49151，分配用户或者程序 Tomc...
outs.write(baos.toByteArray()) 内存溢出
星空之旅1995
01-04 3099
ByteArrayOutputStream baos = makePdfByJson(result.toString(), “”); if (baos.size() > 0) { txtFilePath.setText(filePath.toString());
Java并发编程学习笔记
04-11
本文档主要内容如下： 1、线程安全和锁 Synchronized 底层实现原理 2、可重入锁与 Synchronized 的其他特性 3、ThreadLocal 的底层实现与使用 4、ReentrantLock底层实现和如何使用 5、Condition源码分析 ...
网络编程学习笔记.md
05-08
网络编程 （狂神说Java）学习笔记 + 自己的一些理解
Java面向对象编程学习笔记.pdf
12-01
"Java面向对象编程学习笔记.pdf" Java面向对象编程学习笔记是Java程序设计语言中面向对象编程（Object-Oriented Programming，OOP）的一份学习笔记。面向对象编程是一种软件设计方法，它强调使用对象和类来模拟现实...
网络编程-狂神说Java学习笔记
07-20
网络编程—狂神说Java学习笔记
计算机Java核心编程学习笔记
10-28
计算机Java核心编程学习笔记
java byte 数组打印_Java ByteArrayOutputStream write()方法
weixin_30610771的博客
02-21 1720
Java ByteArrayOutputStream write()方法java.io.ByteArrayOutputStream.write(int b)用于将指定的字节写入字节数组输出流。1 语法public void write(int b)2 参数b：指定的字节为整数，范围为0-2553 返回值无4 示例package com.yiidian;/*** 一点教程网： http://www...
I/O(七)内存流ByteArrayInputStream和ByteArrayOutputStream
daicaho的专栏
03-13 497
所谓内存流就是往内存中写，从内存中读写，内存就是指的是一个字节数组，有的时候我们用I/O的方式去操作这个字节数组，就使用一个I/O流指向这个字节数组，如果往里面写就write进去，如果从里面读，就read出来。还有的时候我们进行网络通信，通信的内容要在本地保存一份，这时候也要用到内存流。 在后面类加载的时候会用到，先记住语法。 public static void main(String[] 
IO操作(read,write,flush)备忘
weixin_33749242的博客
04-24 425
1 场景：通过url读取远程图片文件并返回一个byte[],将来这些byte可以通过HttpClient上传到远程机器。 1.1 如果将这些的byte[]上传之后，发现图片只能显示一部分。最终怀疑是上传工具HttpClient由于网络的问题导致上传不全，但多次尝试发现问题可能是读url获取byte[]的方法有问题。 错误：使用BufferedInputStream和read方法 ...
自己动手写http服务器---java版
AJAXHu的专栏
10-05 304
最简单的http服务器，可下载源码：http://download.csdn.net/detail/ajaxhu/6356885 大概介绍一下原理吧，浏览器打开网页可以简单分为3个阶段： 1.通过socket向服务器发送一个符合一定格式的请求字符串（里面包含了用户输入的网址），比如： Accept text/html,application/xhtml+xml,appli...
IO流（三）之IO包其他功能流及字符编码详解
lsh609912726的专栏
11-27 508
-------android培训、java培训、期待与您交流！ ---------- 打印流（PrintStream和PrintWriter） 该流提供了打印方法，可以将各种数据类型的数据都原样打印 字节打印流：PrintStream 构造函数可以接受的参数类型 a） File对象 File b） 字符串路径。String c） 字节输出流。Outpu
baos bais 意义
weixin_30757793的博客
11-20 131
import java.io.BufferedInputStream; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import org.junit.Test; ...
简单的项目部署脚本（转载）
最新发布
u010230019的博客
06-09 625
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
java并发编程学习笔记
08-30
嗨！很高兴回答你关于Java并发编程的问题。...这些只是一些基本的学习笔记和建议，Java并发编程是一个庞大而复杂的领域，需要不断的实践和深入学习才能掌握。希望对你有所帮助！如果你有更具体的问题，欢迎继续提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值