狂神笔记—网络编程

已于 2022-05-21 11:08:44 修改
阅读量1.1k 收藏 12
点赞数
分类专栏： Java后端学习 文章标签： 网络 udp java tomcat
于 2022-01-29 11:34:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanpiyo/article/details/122741008
版权

网络编程

1.1 概述

​ 1.1.1 连接的两种方式（数据以包的形式进行传输，所以会存在丢包现象，也就是数据可能有损失）：

​ 1.打电话 - 连接 - 接了 - 通话 TCP

​ 2.发短信 - 发完了 - 接收到/没接收到 UDP

​ 1.1.2计算机网络：

​ 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及==网络通信协议==的管理和协调下，==实现资源共享==和信息传递的计算机系统。

​ 1.1.3网络编程的目的：

​ 实现传播信息交流，数据交换，通信。

​ 1.1.4如何达到这种效果：

​ 1.如何准确的定位网络是的一台主机 局域网：端口号，定位到这个计算机上的某个资源

​ 2.找到这台主机该如何传输数据？

1.2 网络通信的要素

如何实现网络通信？
​ 通信两方的地址：
​ 1.ip 和端口号：IP （将两者用：连起来即可）
​ 2.网络通信协议：udp、te 规则：网络通信的协议
都用new来new出想要的对象即可

1.3 IP

ip地址：InetAddress

  • ​ 唯一定位一台网络上计算机

  • 127.0.0.1：本机localhost

  • ip地址分类：

    • IPV4/IPV6:

      • IPV4:127.0.0.1,由4个字节组成（用.隔开），每个字节可以是0~255
      • IPV6：128位，由0123456789abcdef（十六进制）组成，4个整数为一组，用5个：分隔成6组（eg: 2002:abbb:525a:1aaa:bddd:56ab）

    • 公网（互联网）- 私网（局域网）

      • ABCD类地址
      • 192.168.xx.xx,专门给组织内部使用

  • 域名：记忆IP问题

    • IP：www.xxx.com

IP类的代码实现：InetAddress类

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

//测试IP
public class TestIP {
    public static void main(String[] args) {
        try {
            //因为没有构造方法，所以不能通过new来生成对象，但是可以通过类名来调用类的静态方法
            //查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("localhost");
            System.out.println(inetAddress1);
            InetAddress inetAddress2 = InetAddress.getLocalHost();
            System.out.println(inetAddress2);

            //查询网站ip
            InetAddress inetAddress3 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress3);//结果：www.baidu.com/183.232.231.174

            //常用方法
            System.out.println(inetAddress3.getHostAddress());//ip
            //结果：183.232.231.174
            System.out.println(inetAddress3.getCanonicalHostName());//规范的名字
            //结果：183.232.231.174
            System.out.println(inetAddress3.getHostName());//返回域名，或者自己电脑的名称
            //结果：www.baidu.com

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

1.4 端口Port

端口表示计算机上的一个程序进程

  • 不同的进程有不同的端口号，用来区分软件
  • 被规定0-65535（代表可以跑65535个程序）
  • TCP,UDP:65535 * 2,单个协议下，端口号不能冲突，如tcp用80，那udp也能用 80，因为是两个不同的协议。
  • 端口分类
    - 公有端口 0~1023
    - HTTP:80
    - HTTPS:443
    - FTP:21
    - Telent:23
    • 程序注册端口：1024~49151，分配用户或者程序
      - Tomcat：8080
      - MySOL:3306
      - Oracle：1521
      - 动态、私有：49152~65535
      - DOC命令：
      netatat -ano //查看所有端口
      netstat -ano|findstr"5900" //查看指定端口
      tasklist|findstr"8696" //查看指定端口进程

端口的代码实现：InetSocketAddress类

import java.net.InetSocketAddress;

public class TestInetSocketAddress {

    public static void main(String[] args) {
        //有构造方法，所以可以创造对象
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
        System.out.println(inetSocketAddress);//输出ip加端口：/127.0.0.1:8080

        System.out.println(inetSocketAddress.getAddress());//输出：/127.0.0.1
        System.out.println(inetSocketAddress.getHostName());//输出：127.0.0.1，获取地址
        System.out.println(inetSocketAddress.getPort());//输出：8080，获取端口
    }
}

1.5通信协议

​ 协议：约定，就好比我们现在对话用的是普通话

​ 网络通信协议：速率、传输速率、代码结构、传输控制…

​ TCP/IP协议簇：实际上是一组协议

​ 重要：

	- TCP:用户传输协议
	- UDP:用户数据协议

​ 出了名的协议：

- TCP:传输控制协议
- IP:网络互连协议

​ TCP 和 UDP对比

TCP：类比打电话

三次握手（模拟场景）：
a：可以和你连接吗
b: 真的想和我连接
a: 对的
//然后才建立连接

四次挥手（模拟场景）：
a：我要走了
b：你要走？
b：你真的要走了？
a：对，我真的要走了
//然后才断开连接
  • 客户端、服务端
  • 传输完成，释放连接，效率低

UDP:类比发信息

-  不连接，不稳定
-  客户端、服务端：没有明确的界限
-  不管准备好没，都可以发给你
-  DDOS:（饱和攻击），类似于短信轰炸，堵住传输路径

1.6 TCP

客户端

  1. 连接服务器Socket
  2. 发送信息
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {

        Socket socket = null;
        OutputStream os = null;
        try {
            //1.要知道服务器地址
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            //端口号
            int port = 9999;

            //2.创建一个socket连接
                socket = new Socket(serverIP,port);//客户端的连接器
                //3.发送信息io流
                os = socket.getOutputStream();//输出流

                os.write("你好，我是小爱".getBytes());

            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                //关闭连接，要按照顺序依次关闭
                if (os != null){
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

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

    }
}

服务器

  1. 建立服务端口ServerSocket
  2. 等待用户链接accept
  3. 接收用到的信息
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            //1、我得有一个地址,创建出来的地址为localhost:999
             serverSocket = new ServerSocket(9999);//服务端的连接器
            //2.等待客户端连接
             socket = serverSocket.accept();
            //3.读取客户端的消息
             is = socket.getInputStream();

            /*byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer)) != -1){
                String msg = new String(buffer,0,len);//从buffer里面拼，下标从0-len
                System.out.println(msg);
            }*/
            //或者用管道流
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len ;
            while((len = is.read(buffer)) != -1){
             baos.write(buffer,0,len);
            }
            System.out.println(baos.toString());//直接打印出结果


        } catch (IOException e) {
            e.printStackTrace();
        }finally {

            //关闭资源,一个一个关
            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(serverSocket!= null){
                    try {
                        serverSocket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

        }
    }
}

文件上传

1.以Socket类对象来作为客户端和服务器端的连接

2.先运行服务端，再让客户端运行，从而连接上去

3.文件传输或者信息的传输都要用到io中的管道流

4.当运行完毕后，包目录下就会有所传输的文件

客户端

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
//客户端
public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建一个socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2.创建一个输出流
        OutputStream os = socket.getOutputStream();
        //3.文件流,读取文件
        FileInputStream fis = new FileInputStream(new File("D:\\Idea\\ideaiu-2019.3.3\\workspace02\\src\\网络编程\\TCP\\1.jpg"));//文件路径写清楚
        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while((len = fis.read(buffer)) != -1){
            os.write(buffer,0,len);//写出buffer中0-len下标的元素
        }

        //通知服务器我已经结束了
        socket.shutdownOutput();//我已经传输完毕

        //确定服务器接收完毕，才能断开连接
        InputStream inputStream = socket.getInputStream();
        //String byte[],通过字符的管道流来接收服务端传输的提示信息
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while((len = inputStream.read(buffer)) != -1){
            baos.write(buffer,0,len);
        }
        System.out.println(baos.toString());

        //5.关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();

        //Process finished with exit code 0
    }
}

服务端

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 TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        Socket socket = serverSocket.accept();//阻塞式监听，会一直等待客户端连接，类比scanner.next()
        //3.获取输入流
        InputStream is = socket.getInputStream();

        //4.文件输入，用文件的管道流
        FileOutputStream fos = new FileOutputStream("recieve.jpg");
        byte[] buffer = new byte[1024];
        int len;
        while((len = is.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }

        //通知客户端我接收完毕了
        OutputStream os = socket.getOutputStream();
        os.write("我接收完了".getBytes());
        //关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }

}

Tomcat

服务端

  • 自定义服务端 S
  • Tomcat服务器S: java后台开发

客户端

  • 自定义客户端 C
  • 浏览器 B

1.7 UDP

发送信息

服务端：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
//服务端
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9000);
        //接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet);//阻塞接收

        System.out.println(packet.getAddress().getHostAddress());//输出地址
        System.out.println(new String(packet.getData(),0,packet.getLength()));//输出传输内容

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

客户端:不需要与服务端建立连接也可以发送

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
//客户端
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1.创建一个Socket连接
        DatagramSocket socket = new DatagramSocket();
        //2.建个包
        String msg = "你好，服务器";

        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9000;
        //参数分别为：数据（要转换为字符数组），数据长度，要发送给谁（地址和端口号）
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //3.发送包
        socket.send(packet);

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

聊天（单向聊天）

发送方：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.util.Scanner;

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8888);

        //准备数据作为参数传进datagramPacket，所以要从控制台进行读取System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while(true){
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            //数据要以byte[]的形式传入
            DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));
            //发送数据包
            socket.send(packet);
			
            //当发送bye时断开连接
            if(data.equals("bye")){
                break;
            }
        }

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

接收方：

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

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(6666);

        while(true) {

            //准备包接收
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);

            //断开连接
            byte[] data = packet.getData();
            //trim不用的话会打印出很多方格
            String receivedatas = new String(data, 0, data.length).trim();
            System.out.println(receivedatas);

            if (receivedatas.equals("bye")) {
                break;//当传入的数据是bye的时候就会断开连接
            }

        }

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

聊天（互相聊天）

以老师和学生聊天为例（多线程实现）：

老师和学生每人都应有一个接收端和发送端

接收信息端：

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

public class TalkReceive implements Runnable{
    DatagramSocket socket = null;
    private int port;
    private String msg;

    public TalkReceive(int port,String msg)  {

        try {
            this.port = port;
            this.msg = msg;
            socket = new DatagramSocket(port);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
    while(true) {

        try {
            //准备包接收
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);

            //断开连接
            byte[] data = packet.getData();
            //trim不用的话会打印出很多方格
            String receivedatas = new String(data, 0, data.length).trim();
            System.out.println(msg + ":" + receivedatas);

            if (receivedatas.equals("bye")) {
                break;//当传入的数据是bye的时候就会断开连接
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

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


}

发送信息端：

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

public class TalkSend implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;
    private int fromPort;//我自己的IP
    private String toIP;//对方的地址
    private int toPort;//对方的端口号

    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(fromPort);
            //准备数据作为参数传进datagramPacket，所以要从控制台进行读取System.in
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    @Override
    public void run() {

        while(true){

            try {
                String  data = reader.readLine();
                byte[] datas = data.getBytes();
                //数据要以byte[]的形式传入
                DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toPort));
                //发送数据包
                socket.send(packet);

                if(data.equals("bye")){
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }

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

然后是老师和学生的类：

老师：

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(4321,"localhost",8888)).start();
        //port代表该接收器端口号是9999，接收的包为学生传输的包
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

学生：

public class TalkStu {
    public static void main(String[] args) {
        //topot代表发送到xxxx端口号
        new Thread(new TalkSend(1234,"localhost",9999)).start();
        //port代表该接收器端口号是8888，接收的包为老师传输的包
        new Thread(new TalkReceive(8888,"老师")).start();

    }
}

即可实现双方的对话：

​ 老师：

在这里插入图片描述

​ 学生：

在这里插入图片描述

URL

eg：https://www.baidu.com/

统一资源定位符：定位资源的，定位互联网上的某一个资源

DNS域名解析：将www.xxxx.com转换为xxx.x…x…xx

协议://ip地址:端口/项目名/资源

URL类的基本使用：

import java.net.MalformedURLException;
import java.net.URL;

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("https://blog.csdn.net/hanpiyo?type=blog");
        System.out.println(url.getProtocol());//获取协议名
        System.out.println(url.getHost());//获取主机ip
        System.out.println(url.getPort());//获取端口号
        System.out.println(url.getPath());//获取文件
        System.out.println(url.getFile());//获取全路径
        System.out.println(url.getQuery());//获取查询的名字，参数
    }
}

使用URL类下载网络资源：

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

public class UrlDown {
    public static void main(String[] args) throws Exception {

        //1.下载地址
        URL url = new URL("https://p1.music.126.net/VTZde5VdBm_u2WH0Pc9HQQ==/109951165561227373.jpg?param=130y130");
        //2.连接到这个下载地址   HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();//打开连接

        InputStream inputStream = urlConnection.getInputStream();
        FileOutputStream fos = new FileOutputStream("109951165561227373.jpg");//参数是文件名称

        byte[] buffer = new byte[1024];
        int len;
        while((len = inputStream.read(buffer)) != -1){
            fos.write(buffer,0,len);//写出这个数据
        }

        //关闭资源
        fos.close();
        inputStream.close();
        urlConnection.disconnect();//断开连接
    }
}

下载完之后便会看到所下载好的资源：
在这里插入图片描述

秃头的二哈
关注
专栏目录
【狂神说笔记—— Java基础11-网络编程】
weixin_46055348的博客
07-11 492
【狂神说笔记—— Java基础11-网络编程】
狂神说笔记内容.zip
08-15
以上内容只是基础部分，完整的"狂神说Java入门笔记"可能还涉及更高级的主题，如网络编程、数据库连接、Swing或JavaFX图形界面开发、XML处理等。这份资料对Java初学者来说是一份宝贵的资源，能够系统地引导他们步入...
网络编程学习笔记.md
05-08
网络编程 （狂神说Java）学习笔记 + 自己的一些理解
第38天学习打卡（网络编程 ）
doudoutj的博客
02-15 225
网络编程 1.1概述 地球村 计算机网络： 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 网络编程的目的： 无线电台…传播交流信息，数据交换。通信 想要达到这个效果需要什么： 1.如何准确的定位网络上的一台主机 192.168.16.124：端口，定位到这个计算机上的某个资源 2.找到了这个主机，如何传输数据呢？ javaweb:网页编程 B/S 网络编程 ：TCP/I
java网络编程
qq_45316925的博客
09-01 266
网络编程 1.1 概述 计算机网络： 计算机网络是指将 地理位置 不同的具有 独立功能 的多台 计算机 及其 外部设备 ，通过 通信线路 连接起来，在 网络操作系统 网络管理软件 及 网络通信协议 的管理和协调下，实现 资源共享 和 信息传递 的计算机系统 网络编程的目的： 传播交流信息，数据交换。通信 想要达到这个效果需要什么： 1.2网络通信的要素 如何实现网络的通信？ 通信双方地址： ip 端口号 规则：网络通信的协议 TCP/IP参考模型： 小结： 网络编程中有两个主要的问题 如何准确的定
狂神网络编程学习笔记
qq_44758926的博客
04-10 625
网络编程 概述 计算机网络 ​ 计算器网络是将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协商下，实现资源共享和信息传递功能的计算机系统 网络编程的目的 数据交换，通信 想要达到这个效果需要什么： 如何准确地定位网络上的一台主机：IP地址和端口，定位到这个计算机上的某些资源 找到了主机。怎么传输数据？ TCP/IP通信 网络通信的要素 如何实现网络的通信？ ​ 通信双方的地址： IP 端口号 规则：网络
跟着狂神学网络编程
qq_40649503的博客
10-31 736
跟着狂神学网络编程
狂神笔记.md文件.zip
06-17
【狂神笔记】系列是针对Java开发者的一套深入学习指南，涵盖了myBatis、Spring、SpringMVC等关键框架的详细知识。这份压缩包文件包含了多个Markdown格式的笔记，包括了SpringMVC、SSM整合、Mybatis以及Spring的基础...
狂神笔记，b站狂神说课程笔记大全(最新)
09-19
12、JavaSE：网络编程 13、JavaSE：Gui编程 14、JavaSE：注解和反射 15、MySQL和JDBC 16、前端：Html5 17、前端：CSS3 18、前端：JavaScript、jQuery 19、JavaWeb 20、MyBatis 21、Spring 22、SpringMVC 23、大前端...
网络编程-狂神说Java学习笔记
最新发布
07-20
"狂神说Java学习笔记"提供了深入理解和实践网络编程的宝贵资源。本笔记主要涵盖了以下几个关键知识点： 1. **Java网络编程基础**：Java通过Socket API提供了网络通信的能力。Socket代表了网络上的两个应用程序之间...
狂神Java学习笔记————前端入门——html、css、JavaScript学习代码
06-17
此资源为我跟着B站up主【遇见狂神说】java系列视频中前端入门部分学习过程中所写 大部分和视频保持一致，有一些自己的理解和一些扩展的部分
狂神springcloud学习笔记加代码
03-24
狂神springcloud学习笔记加代码 笔记可以看：https://www.kuangstudy.com/bbs/1374942542566551554#header4 视频链接：https://www.bilibili.com/video/BV1jJ411S7xr
【狂神】网络编程笔记
QinLaoDeMaChu的博客
03-29 1186
目录1. 概述2. 网络通信的要素3. IP4. 端口5. 通信协议 1. 概述 计算机网络： 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统 网络编程的目的： 传播交流信息，数据交换，通信 要求： 1.如何准确的定位网络上的一台主机？ —> IP地址+端口 2.找到主机，如何进行数据传输？ javaweb 是指网页编程，B/S； 网络编程主要是指 TCP/IP
【狂神说Java】Java网络编程详细笔记(全)
Martin-share的博客
01-15 838
【狂神说Java】Java网络编程笔记
Java 网络编程
m0_53354306的博客
05-08 802
1.1概述 Java是Internet上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的 网络应用程序。Java提供的网络类库，可以实现无痛的网络连接，联网的底层细节被隐藏在 Java 的本机 安装系统里，由JVM进行控制。并且Java实现了一个跨平台的网络库，程序员面对的是一个统一的网络 编程环境。 计算机网络： 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大，功能强的网络系统， 从而使众多的计算机可以方便地互相传递信息，共享硬..
[Java语言基础]网络编程
Hi~ 土拨鼠
12-04 320
网络编程 概述： 网络编程从大的方面说就是对信息的发送到接收，中间传输为物理线路的作用。 UDP 只发送，不管连没连接 TCP/IP 先连接，再发送 C/S 客户端/服务端 目的： 网络编程最主要的工作就是在发送端把信息通过规定好的协议进行组装包，在接收端按照规定好的协议把包进行解析，从而提取出对应的信息，达到通信的目的。 网络通信的要素 如何实现网...
Java狂神说网络编程笔记
qq_45911278的博客
01-27 666
IP import java.net.InetAddress; import java.net.UnknownHostException; public class Hello {// // 测试IP public static void main(String[] args) { try { //返回主机 InetAddress inetAddress = InetAddress.getByName("127.0....
【网络编程】狂神说笔记
passnight的博客
02-17 290
TCP模型 初识TCP 服务端代码 import java.io.BufferedReader; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; class ClientThread exten
Java网络编程详细全套笔记（附各类实现代码片段）
Neillllll^的博客
04-13 1604
Java网络编程 1.1、概述 想要达到网络通讯效果需要什么： 如何准确定位网上的一台主机，192.168.16.124: 端口，定位到这个计算机的某个资源 找到了这个主机，如何传播数据 JavaWeb与网络编程的区别 JavaWeb：网页编程 B/C. (Brower/Server) 网络编程：TCP/IP 使用 C/S 架构 (Client/Server) 1.2、 网络通讯的要...
Java网络编程：TCP连接详解
"这篇网络编程学习笔记主要基于狂神说Java系列进行整理，涵盖了TCP连接的基本操作，包括客户端和服务器端的实现。" 在计算机网络编程中，TCP（Transmission Control Protocol）是一种面向连接的、可靠的传输协议。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值