网络编程

最新推荐文章于 2024-03-17 22:29:15 发布
最新推荐文章于 2024-03-17 22:29:15 发布
阅读量733 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jeremyl/article/details/112546823
版权

对象流的使用

  1. ObjectInputStream 和 ObjectOutputStream
  2. 作用：
    ObjectOutputStream: 内存中的对象–>存储中的文件、通过网络传输出去：序列化过程
    ObjectInputStream: 存储中的文件、通过网络接收过来 -->内存中的对象：反序列化过程
  3. 要想一个对象可序列化，必须要实现Serializable
  4. 序列化机制：
    对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久保存在硬盘上，或通过网络将这种二进制流传输到另一个网络节点。当其他程序获取了这种二进制流，就可以恢复成原来的Java对象

序列化

/*
    * 序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
    * 使用ObjectOutputStream实现
    * */
    @Test
    public void testObjectOutputStream(){
        ObjectOutputStream oos= null;
        try {
            //1.
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
            //2.
            oos.writeObject(new String("china"));

            oos.flush();

            oos.writeObject(new Person("lee",22));

            oos.flush();

            oos.writeObject(new Person("v",21,new Account(5000)));

            oos.flush();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.
            if (oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

反序列化

/*
    * 反序列化：将磁盘文件中的对象还原为内存层面的一个java对象
    * */
    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois= null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));

            Object obj = ois.readObject();
            String str=(String)obj;

            Person p=(Person)ois.readObject();
            Person p1=(Person)ois.readObject();

            System.out.println(str);
            System.out.println(p);
            System.out.println(p1);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
  1. 实现序列化对象所属的类需要满足：
    1. 需要实现接口：Serializable
    2. 当前类提供一个全局常量：serialVersionUID
    3. 除了当前类需要实现Serializable接口外，还必须保证其内部的所有属性可序列化（默认情况下，基本数据类型可序列化）

补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员

RandomAccessFile

  1. RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
  2. RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
  3. 如果RandomAccessFile作为输出流时，
    写出的文件不存在，直接创建
    写出的文件存在，从头覆盖
  4. 可以通过相关的操作，实现RandomAccessFile"输入"数据的情况。 seek(int pos)
    @Test
    public void test1()  {

        RandomAccessFile raf1= null;
        RandomAccessFile raf2= null;
        try {
            raf1 = new RandomAccessFile(new File("2101608177836_.pic_hd.jpg"),"r");
            raf2 = new RandomAccessFile(new File("2.jpg"),"rw");

            byte[] buffer=new byte[1024];
            int len;
            while ((len=raf1.read(buffer))!=-1){
                raf2.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (raf1!=null){
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (raf2!=null){
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    /*
    * 使用RandomAccessFile实现数据的插入效果
    * */
    @Test
    public void test3() throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile(new File("hello.txt"),"r");

        raf1.seek(3); // 将指针调到角标为3的位置
        // 保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder=new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer=new byte[20];
        int len;
        while ((len=raf1.read(buffer))!=-1){
            builder.append(new String(buffer,0,len));
        }
        // 调回指针，写入xyz
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        // 将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());

        raf1.close();
    }

网络编程

一、网络编程中有两个主要的问题：

  1. 如何准确定位网络上一台或多台主句：定位主机上特定的应用
  2. 找到主机后如何可靠高效地进行传输

二、网络编程的两个要素：

  1. 对应问题一：IP和端口号
  2. 对应问题二：提供网络通信协议：TCP/IP参考模型（应用层，传输层，网络层，物理+数据链路层）

三、通信要素一：IP和端口号

  1. IP: 唯一的标识 Internet上的计算机（通信实体）
  2. 在Java中使用InetAddress类代表IP
  3. IP分类：IPv4, IPv6; 万维网，局域网
  4. 域名：www.baidu.com
  5. 本地回路地址:127.0.0.1 对应：localhost

InetAddress类：此类的一个对象就代表一个具体的IP地址

  1. 如何实例化InetAddress: 两个方法：getByName(String host), getLocalHost()
    两个常用方法：getHostName()/ getHostAddress()
  2. 端口号：正在计算机上运行的进程
    要求：不同进程有不同的端口号
    范围：被规定为一个16位的整数0~65535
  3. 端口号和IP地址组合得出一个网络套接字：Socket

网络通信协议

  1. 分型模型
    在这里插入图片描述
  2. TCP, UDP的区别
    在这里插入图片描述

例子1：客户端发送信息给服务端，服务端将数据显示在控制台

/**
 * 实现TCP的网络编程
 * 例子1：客户端发送信息给服务端，服务端将数据显示在控制台上
 * @create 2021-01-12 下午2:36
 */
public class TCPTest1 {
    //客户端
    @Test
    public void client() {
        Socket socket= null;
        OutputStream os= null;
        try {
            //1. 创建Socket对象，指明服务器端的ip和端口号
            InetAddress inet=InetAddress.getByName("127.0.0.1");
            socket = new Socket(inet,8899);
            //2. 获取一个输出流，用于输出数据
            os = socket.getOutputStream();
            //3. 写出数据的操作
            os.write("hi,客户端".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4. 资源的关闭
            if (os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //服务端
    @Test
    public void server() {
        ServerSocket ss = null;
        Socket socket= null;
        InputStream is= null;
        ByteArrayOutputStream baos= null;
        try {
            //1. 创建服务器端的ServerSocket,指明自己的端口号
            ss = new ServerSocket(8899);
            //2. 调用accept()表示接收来自于客户端的socket
            socket = ss.accept();
            //3. 获取输入流
            is = socket.getInputStream();

            //不建议这样，会有乱码
//        byte[] buffer=new byte[20];
//        int len;
//        while ((len=is.read())!=-1){
//            String str=new String(buffer,0,len);
//            System.out.print(str);
//        }

            //4. 读取输入流中的数据
            baos = new ByteArrayOutputStream();
            byte[] buffer=new byte[5];
            int len;
            while ((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);
            }
            System.out.println(baos.toString());
            System.out.println("收到了来自于："+socket.getInetAddress().getHostAddress()+" 的数据");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5. 关闭资源
            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss!=null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

例子2：客户端给服务器端发文件，服务器端保存到本地

/**
 *
 * 实现TCP的网络编程
 * 例题2：客户端发送文件给服务端，服务端将文件保存在本地
 *
 * @create 2021-01-12 下午4:41
 */
public class TCPTest2 {
    @Test
    public void client() throws IOException {
        //1
        Socket socket=new Socket(InetAddress.getByName("127.0.0.1"),9090);
        //2
        OutputStream os = socket.getOutputStream();
        //3
        FileInputStream fis=new FileInputStream("pic.png");
        //4
        byte[] buffer=new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer);
        }
        //5
        fis.close();
        os.close();
        socket.close();

    }

    @Test
    public void server() throws IOException {
        //1. 造一个服务端的接口
        ServerSocket ss=new ServerSocket(9090);
        //2. 获取客户端的接口
        Socket socket=ss.accept();
        //3. 获取输入流
        InputStream is = socket.getInputStream();
        //4. 造一个输出流
        FileOutputStream fos=new FileOutputStream(new File("pic1.png"));
        //5. 输出到本地
        byte[] buffer=new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        //6. 关闭资源
        fos.close();
        is.close();
        socket.close();
    }
}

例子3：从客户端发送文件给服务端，服务端保存到本地并返回"发送成功"给客户端。

public class TCPTest3 {
    @Test
    public void client() throws IOException {
        //1
        Socket socket=new Socket(InetAddress.getByName("127.0.0.1"),9090);
        //2
        OutputStream os = socket.getOutputStream();
        //3
        FileInputStream fis=new FileInputStream("pic.png");
        //4
        byte[] buffer=new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer);
        }
        //关闭数据的输出
        socket.shutdownOutput();

        //5. 接收来自服务器端的数据，并显示到控制台
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos=new ByteArrayOutputStream();
        byte[] buffer2=new byte[20];
        int len1;
        while ((len1=is.read(buffer2))!=-1){
            baos.write(buffer2,0,len1);
        }
        System.out.println(baos.toString());

        //6.
        fis.close();
        os.close();
        socket.close();
        baos.close();

    }

    @Test
    public void server() throws IOException {
        //1. 造一个服务端的接口
        ServerSocket ss=new ServerSocket(9090);
        //2. 获取客户端的接口
        Socket socket=ss.accept();
        //3. 获取输入流
        InputStream is = socket.getInputStream();
        //4. 造一个输出流
        FileOutputStream fos=new FileOutputStream(new File("pic2.png"));
        //5. 输出到本地
        byte[] buffer=new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }

        //6. 服务器端给客户端反馈
        OutputStream os = socket.getOutputStream();
        os.write("发送成功".getBytes());

        //7. 关闭资源
        fos.close();
        is.close();
        socket.close();
        os.close();
    }
}

URL

URL网络编程

  1. URL:统一资源定位符，对应着互联网的某一资源地址
  2. 格式：
    http://localhost:8000/examples/pic.jpg?username=tom
    协议 主机名 端口号 资源地址 参数列表
  3. 实例化：
URL url=new URL("http://localhost:8000/examples/pic.jpg?username=tom");
Jeremy202109
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java网络编程抓取指定网页信息--UrlHtml(java源码)
01-14
package com.hexiang.io; import java.io.DataInputStream; import java.io.IOException; import java.net.MalformedURLException; import java.net.URL; public class UrlHtml { @SuppressWarnings("deprecation") public static void main(String[] s) throws IOException{ try { URL url = new URL("http://www.kum.net.cn"); DataInputStream in = new DataInputStream(url.openStream()); String inputStream = null; inputStream = in.readLine(); while(inputStream!=null){ System.out.println(inputStream); inputStream = in.readLine(); } } catch (MalformedURLException e) { // TODO 自动生成 catch 块 e.printStackTrace(); } } }
Java-day27（IO流与网络编程）
weixin_44742328的博客
10-22 317
对象流( ObjectInputStream和OjbectOutputSteam ) Person类： package com.acoffee.java1; import java.io.Serializable; /** * Person需要满足下列的要求才能满足序列化 * 1.需要实现接口：Serializable * 2.当前类提供一个全局变量：serialVersionUID * 3.除了当前Person类需要实现Serializable接口之外， * 还必须保证其内部所有
[笔面] Java IO和网络编程相关面试
weixin_30639719的博客
10-14 157
1.网络编程时的同步、异步、阻塞、非阻塞？ 同步：函数调用在没得到结果之前，没有调用结果，不返回任何结果。异步：函数调用在没得到结果之前，没有调用结果，返回状态信息。阻塞：函数调用在没得到结果之前，当前线程挂起。得到结果后才返回。非阻塞：函数调用在没得到结果之前，当前线程不会挂起，立即返回结果。 2.Java如何实现无阻塞方式的Socket编程？ NIO有效解决了多线程服务器存在的线程开销问...
java通过一个url读取网站的源代码 储存到本地文件中
网络改变中国
09-15 2665
import java.io.*; import java.net.URL; import javax.swing.JTextArea; public class Test { static BufferedReader reader; static JTextArea tPage; static URL url; static String wenben; public sta
java.io.Serializable（序列化）接口详细总结
热门推荐
麦田里的码农
12-29 4万+
一、前言  在参加工作后，做的第一个项目是电商项目。当时不会做项目，只能照猫画虎。其中一个VO类为何要实现Serializable接口一直没有理解，不实现这个Serializable，会报错。如下是随手写的一个VO类Person.java：import java.io.Serializable; public class Person implements Serializable { pr
TCPIP网络编程
03-16
最适合入门的网络编程入门书，初学者必看
C++网络编程文档
03-16
C++网络编程是计算机科学中的一个重要领域，它允许开发者创建能够通过网络进行通信的应用程序。这份"C++网络编程文档"涵盖了这一主题的广泛内容，旨在帮助程序员深入理解并掌握网络编程的基本概念和技术。 首先，...
java 07 对象序列化流
fly
03-24 288
2.8serialVersionUID&transient【应用】 serialVersionUID 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？ 会出问题，会抛出InvalidClassException异常 如果出问题了，如何解决呢？ 重新序列化 给对象所属的类加一个serialVersionUID private static fina...
java.io.Serializable 初探序列化
me94me的窝
03-03 617
java.io.Serializable 初探序列化       Hibernate并不要求持久化类实现java.io.Serializable接口，但是对于采用分布式结构的Java应用当Java对象在不同进程 结点之间传输时，这个对象所属的类必须实现java.io.Serializable接口，此外在Java Web应用中，如果希望对HttpSession中存放的Java对象进行持久化，
关于序列化：java.io.Serializable
zy408710468的专栏
05-12 1216
java.io.Serializable引发的问题——什么是序列化？在什么情况下将类序列化？    序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，imple
Java——谈谈框架中经常见到的序列化与反序列化技术
★★光亭★★
05-16 7376
Java——谈谈框架中经常见到的序列化与反序列化技术
java.io.Serializable浅析
weixin_34245082的博客
10-10 198
java.io.Serializable浅析   　　Java API中java.io.Serializable接口源码： 1 public interface Serializable { 2 } 　　类通过实现java.io.Serializable接口可以启用其序列化功能。未实现次接口的类无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口...
如何将一个对象保存为文件,并从文件中读取Java对象呢?
weixin_65229471的博客
07-24 609
1.声明私有变量 id,name,age,并构造有参,无参,getter和setter方法以及同toStiring()方法我们在使用Dubbo远程调用服务框架时，需要把传输的Java对象实现Serializable接口，即让Java对象序列化，因为这样才能让对象在网络上传输。同时方便在类中添加属性配置完成之后鼠标放在Student类上,然后实例化完成..然后使用直接写入st就行,,然后它默认创建在项目中 ,最后对象就保存在文件中。
【Java IO流】缓冲流和对象流的解析和应用实例
最新发布
StuLearn-LJC的博客
03-17 1119
Java 中的高级流指的是建立在基本字节流或字符流之上的流，它们提供了更高级别的功能以简化 I/O 操作。除缓冲流和对象流外，常见的高级流还有：数据流、打印流、压缩流、转换流等。
【原创】序列化类添加UID,@java.io.Serial标红之解决方案
RubyXun's-Blog
11-18 8058
@java.io.Serial标红怎么破？进来学姿势~ IDEA默认jkd16，而当前使用的并非jkd16不支持注解这个特性所以爆红！ 两个选项调为一致即可 完美解决 RubyXun 推荐起始页 adomain.gq 推荐小程序
java newfile() bug_java-运行类时,它将生成一个0kb的空白文件.有人可以指出我的错误之处吗？...
weixin_30350469的博客
02-24 701
我尝试将一些内容写入文件名“ aq.txt”.目录没有问题.FileOutputStream fos= null;try{String xyz= "You should stop using xyz";fos= new FileOutputStream("aq.txt");Writer wrt= new BufferedWriter(new OutputStreamWriter(fos));wrt...
java序列化
M的博客
06-04 221
文章目录 1、什么是java序列化，如何实现java序列化？2、保存(持久化)对象及其状态到内存或者磁盘3、序列化对象以字节数组保持-静态成员不保存4、序列化用户远程对象传输5、Serializable 实现序列化6、writeObject 和 readObject 自定义序列化策略7、序列化 ID8、序列化并不保存静态变量9、Transient 关键字阻止该变量被序列化到文件中10、序列化（深 clone 一中实现） 1、什么是java序列化，如何实现java序列化？ 序列化就是一种用来处理对象.
java学习第二十九天
qq_54364082的博客
06-19 2297
2020080605004大数据2005 黄满 编写程序，计算并输出所有的水仙花数。水仙花数是这样的三位数，它的各位数字的立方和等于这个三位数本身，例如371=33+73+13，371就是一个水仙花数。 package hm; public class Shuixianhua { public static void main(String[] args) { int a = 0; int b = 0; int c = 0; for (int i = 100; i <
Beej's Guide to Network Programming.pdf
09-19
这本书主要介绍了如何使用 Internet Sockets 进行网络编程，是网络编程初学者和进阶者的宝贵资料。 在书中，作者首先介绍了网络编程的基础概念，包括网络通信的基本原理，如TCP/IP协议栈、端口号和IP地址等。他详细...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值