黑马程序员_JAVA笔记23——网络编程

最新推荐文章于 2024-07-24 23:34:03 发布

五里一徘徊孔雀东南飞

最新推荐文章于 2024-07-24 23:34:03 发布

阅读量972

点赞数

CC 4.0 BY-SA版权

分类专栏： JAVA基础笔记文章标签：网络编程 java

本文链接：https://blog.youkuaiyun.com/u011453546/article/details/10893585

JAVA基础笔记专栏收录该内容

25 篇文章

订阅专栏

本文介绍了网络编程的基本概念，包括网络模型、网络通讯要素、常用协议TCP与UDP的区别，以及Socket编程的具体实现方法。通过实例展示了UDP与TCP的服务端与客户端如何进行数据传输。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

------- android培训、 java培训、期待与您交流！ ----------

一、网络编程

1、网络模型

OSI参考模型，数据封包，发送数据时，从上往下每一层都加一层信息，最后形成数据封包；到物理层时就传递给目标。目标接收到数据包后，从下往上依次拆包，每拆一包每层都获得相关层信息。

应用层

表示层

会话层

传输层（TCP UDP）

网络层(给数据IP地址)

数据链路层

物理层（看得见摸得到的设备，如网线）

TCP/IP参考模型

应用层 http ftp web开发

传输层网络编程

网际层网络编程

主机至网络层

2、网络通讯要素

IP地址，网络中设备的标识，不易记忆，可用主机名，本地回环地址：127.0.0.1 主机名：localhost

端口号，

数据要发到指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识，为了方便称呼这个数字，叫做端口。逻辑端口。

传输协议，定义的通讯规则。国际组织定义了通用的协议TCP/IP

特殊地址：默认的127.0.0.1，网卡的，可以ping127.0.0.1来测试网卡是否好。

192.168.xx.xx,保留的，可以用于局域网

由于计算机越来越多，IPV6出现，包括数字和字母

3、端口：0-1024，系统保留的，尽量不去用

端口范围：0-65535

web：80.......tomcat:8086

import java.net.*;

class IPDemo

{

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

{

InetAddress i = InetAddress . getLocalHost();//获取IP地址主机名和IP值

System.out.println(i);

System.out.println(i.getHostAddress());//得到本地IP地址

System.out.println(i.getHostName());//获得本地主机名

//拿到任意一台主机对象

InetAddress ia = InetAddress .getByName("192.168.1.106");

InetAddress ia = InetAddress.getByName("www.baidu.com");

System.out.println(ia.getHostAddress());

System.out.println(ia.getHostName());

注意：如果IP与主机名的一对一关系没有在网上，那么通过上述方法得到的主机名也是IP地址

}

4、常用协议TCP UDP

UDP

将数据及源和目的封装成数据包中，不需要建立连接

每个数据包的大小限制在64k以内

因无连接，是不可靠协议

不需要建立连接，速度快

TCP

建立连接，形成传输数据的通道

在连接中进行大数据量传输

通过三次握手完成连接，是可靠协议

必须建立连接，效率会稍低

Socket

Socket就是为网络服务提供的一种机制

通信的两端都有Socket

网络通信其实就是Socket间的通信

数据在两个Socket间通过IO传输

5、public class DatagramSocket extends Object,此类表示用来发送和接收数据报包的套接字

public class DatagramPacket,此类表示数据报包，数据报包用来实现无连接包投递服务，每条报文仅根据该包中包含的信息从一台机器路由到另一台机器，从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达，不对包投递做出保证

构造函数：

DatagramPacket(byte[] buf,int length),用来接收长度为length的数据包

DatagramPacket(byte[] buf,int length,InetAddress address,int port),构造数据报包，用来将长度为length的包发送到指定主机上的指定端口号

import java.net*;

定义udp发送端

需求：通过udp传输方式，将一段问题数据发送出去

1、必须要建立udp socket服务

2、提供数据，并将数据封装到数据报包中

3、通过socket服务的发送功能将数据包发送出去

4、关闭资源

//发送端其实也有数字标识，这是系统随机产生的

import java.net.*;

class UDPSend

{

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

{

//创建udp服务，通过DatagramSocket

DatagramSocket ds = new DatagramSocket(8888);//这里可以指定发送端的端口，若不写系统随机产生

//确定数据，并封装成数据包

byte[] buf= "udp ge men lai le".getBytes();

DatagramPacket dp = //"192.168.0.101"为目标地址，这里的是本机地址。10000是端口号

new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.0.101"),10000);

//通过socket服务将已有的数据包发送出去，通过send方法

ds.send(dp);

//关闭资源

ds.close();

}

因为发送与接收是两个独立的应用程序，因此需要放在两个.java文件中

定义UDP的接收端，通常都会监听一个端口，其实就是给这个接收网络应用程序定义数字标识，方便于明确哪些数据过来该应用程序可以处理

需求：定义一个应用程序，用于接收udp协议传输的数据并处理

1、定义udp socket服务

2、定义一个数据包，因为要存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

3、通过socket服务的receive方法将受到的数据存入到已经定义好的数据包中

4、根据数据包对象的特有功能，将这些不同的数据取出，打印在控制台上

5、关闭资源

import java.net.*;

class UDPReceive

{

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

{

//创建udp服务，建立端点，通过DatagramSocket. 监听端口10000

DatagramSocket ds = new DatagramSocket(10000);//避免两次服务用一个端口，否则异常

//定义数据包，用于存储数据

while(true)//表示一直可以接收数据

{

byte[] buf = new byte[1023];

DatagramPacket dp = new DatagramPacket(buf,buf.length);

//通过服务的receive方法将受到的数据存入数据包中

ds.receive(dp);//阻塞式方法，来一次收一次，没数据就等待

//通过数据包的方法提取数据包中的数据

String ip = dp.getAddress().getHostAddress();

String data=new String (dp.getData(),0,dp.getLength());

int port = dp.getPort();

System.out.println(ip+"....."+"data"+"......"+port);

}

//关闭资源

ds.close();

}

键盘录入方式：

import java.net.*;

class UDPSend2

{

public static void main(String[] args)

{

DatagramSocket ds = new DatagramSocket();

BufferedReader bufr =

new BufferedReader(new InputStreamReader(System.in));

String line = null;

while((line=bufr.readLine())!=null)

{

if("886".equals(line))

breaks;

byte[] buf = line.getBytes();

DatagramPacket dp =

new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.0.101"),10001);

ds.send(dp);

}

ds.close();

}

import java.net.*;

class UDPReceive2

{

public static void main(String[] args)

{

DatagramSocket ds = new DatagramSocket(10001);

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);

}

192.168.1.0//代表这个网络段

192.168.1.255//代表广播，表示给这个网段的所有机器发信息，所有机器都可以收到这个信息，要求同一端口

练习：聊天程序

编写一个聊天程序。

有收数据的部分，有发数据的部分，这两部分需要同时执行，那就需要多线程，一个线程控制收，一个线程控制发

因为收和发动作不一致，所以要定义两个run方法，封装到两个不同类中。

import java.io.*;

import java.net.*;

class Send implements Runnable

{

private DatagramSocket ds;

public Send(DatagramSocket ds)

{

this.ds = ds;

}

public void run()

{

try

{

BufferedReader bufr =

new BufferedReader(new InputStreamReader(System.in));

String line = null;

while((line = bufr.readLine())!=null)

{

if("886".equals(line))

break;

byte[] buf = line.getBytes();

DataGramPacket dp =

new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10002);

ds.send(dp);

}

catch(Exception e)

{

throw new RuntimeException("sender failed");

}

class Receive implements Runnable

{

private DatagramSocket ds;

public 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()

{

}

class Demo

{

public static void main(String[] args)

{

DatagramSocket sendSocket = new DatagramSocket();

DatagramSocket receiveSocket = new DatagramSocket(10002);

new Thread(new Send(sendSocket)).start();

new Thread(new Receive(receiveSocket)).start();

}

6、TCP传输

Socket和ServerSocket

建立客户端和服务器端

建立连接后，通过Socket中的IO流进行数据的传输

关闭socket

同样，客户端与服务器端是两个独立的应用程序

客户端：在Socket对象建立时就可以连接指定主机，因为TCP是面向连接的，所以在建立socket服务时，就要有服务端存在并连接成功，形成通路后，在该通道进行数据的传输。

步骤：

创建socket服务，并指定要连接的主机和端口。

import java.io.*;

import java.net.*;

class TcpClient

{

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

{

//创建客户端的socket服务，指定目的主机和端口

Socket s = new Socket("192.168.1.101",10005);

//为了发送数据，应该获取socket流中的输出流

OutputStream out = s.getOutputStream();

out.write("tcp ge men lai le".getBytes());

s.close();

}

需求：定义端点接收数据并打印在控制台上

服务端
建立服务端的socket服务，用ServerSocket();并监听一个端口。

获取连接过来的客户端对象，通过ServerSocket的accept方法，所以该方法是阻塞式的，没有连接就等。

客户端如果发过来数据，那么服务端要使用对应的客户端对象，获取到该客户端对象的读取流来读取发过来的数据

关闭服务器（可选）

class TCPServer

{

public static void main(String[] args)

{

//建立服务单socket服务，并监听一个端口

ServerSocket ss = new ServerSocket(10005);

//通过accept方法获取连接过来的客户端对象

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip+"........connected");

//获取客户端发送过来的数据，那么服务端要使用客户端对象的读取流方法来读取数据

InputStream in = s.getInputStream();

byte[] buf = new byte[1024];

int len = in.read(buf);

System.out.println(new String(buf,0,len));

s.close();

ss.close();//可选，这里表示服务一次就关闭，如果是N多次就不能关闭

}

演示tcp传输的客户端和服务端的互访

需求：客户端给服务端发送数据，服务端收到后给客户端反馈in系

客户端：

建立socket服务，指定要连接的主机和端口

获取socket流中的输出流，将数据写到该流中，通过网络发送给服务端

获取socket流中的输入流，将服务端返回的数据获取到，并打印

关闭客户端

class TcpClient2

{

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

{

Socket s = new Socket("192.168.0.101",10004);

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();

}

class TcpServer2

{

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

{

ServerSocket ss = new ServerSocket(10004);

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());

}

练习：

建立一个文本转换器

客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。

而且客户端可以不断的进行文本转换，当客户端输入over时，转换结束。

分析：

客户端:

既然是操作设备上的数据，那么就可以使用io技术，并按照io操作规律来思考

源：键盘录入

目的：网络输出流

而且操作的是文本数据，可以选择字符流

步骤

建立服务

获取键盘录入

将数据发给服务端

获取服务端返回的大写数据

结束，关闭资源。

都是文本数据，因此可以使用字符流而且可以加入缓冲

import java.io.*;

import java.net.*;

class TranClient

{

public static void main(String[] args)

{

//建立客户端端点

Socket s = new Socket("192.168.0.101",100006);

//读取键盘输入的数据

BufferedReader bufr =

new BufferedReader(new InputStreamReader(System.in));

//将键盘读取的数据输出到端点输出流中

BufferedWriter bufout =

new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

//读取服务端返回的数据

BufferedReader bufin =

new BufferedReader(new InputStreamReader(s.getInputStream()));

String line = null;

while((line = bufr.readLine())!=null)

{

if("over".equals(line))

break;

bufout.write(line);//将数据写到缓冲区，需要flush。发的是回车符之前的数据

bufout.newLine();//readLine()需要读到回车符才能结束，否则等待，newLine就是换行。

bufout.flush();//将缓冲区数据刷到服务端

String str = bufin.readLine();//读取服务端发来的数据。

Sytem.out.println(str);

}

bufr.close();

s.close();

}

class TranServer

{

public static void main(String[] args)

{

//建立服务端端点

ServerSocekt ss = new ServerSocket(10006);

//获取客户端对象

Socket s =ss.accept();

//获取客户端ip

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip)

//读取客户端发过来的信息

BufferedReader bufin =

new BufferedReader(new InputStream(s.getInputStream()));

//给客户端发数据

BufferedWriter bufout =

new BufferedWriter(new OutputStream(s.getOutStream()));

String line = null;

While((line = bufin.readLine())!=null)

{

bufout.write(line.toUpperCase());//将数据转大写后发给客户端，此时数据写到缓冲区了

bufout.newLine();//对面readLine需要回车符才能结束等待，newLine是回车

bufout.flush();//将缓冲区数据刷到客户端

}

s.close();

ss.close();

}

问题总结：

现象：客户端和服务端都在莫名的等待，应为客户端和服务端都有阻塞式的方法，这些方法都没有读到结束标记，那么就一直等，而导致两端都在等待。readLine()是阻塞方法，没有读到数据就等待，读数据时只有读到回车符才算结束，而write()方法发送的是回车符之前的数据，因此需要加上“\r\n”或者newLine()才可以。而write后的数据是写到缓冲区的需要flush才能发到目的地。

练习：从客服端传文本文件到服务端

import java.io.*;

import java.net.*;

class TextClient

{

public static void main(String[] args)

{

//创建客户端端点

Socket s = new Socket("192.168.0.101",10007);

//创建通道，读取被传送的文本文件

BufferedReader bufr =

new BufferedReader(new FileReader("Demo.java"));

//向文本输出流打印对象的格式化表示形式，true表示自动刷新

PrintWriter out = new PrintWriter(s.getOutputStream(),true);

//DataOutputStream dos = DataOutputStream(s.getOutputStream());

// long time = System.currentTimeMillis();

//out.println(time);

//dos.writeLong(time);

String line = null;

//读取文本文件

while((line=bufr.readLine())!=null)

{

//将读取的数据打印到输出流中，并刷新到服务端

//这里的println表示刷新，而不是输入数据时的回车符

out.println(line);

}

// out.println("over");

//dos.writeLong(time);

s.shutdownOutput();//关闭客户端的输出流，相当于给流中加入一个结束标记-1

//另一种方法是自定义标记，我告诉你个标记，你读到这个标记就结束

//接收服务端返回的数据

BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));

String str = bufin.readLine();

System.out.println(str);

bufr.close();

s.close();

}

class TextServer

{

public static void main(String[] args)

{

//创建服务端端点

ServerSocket ss = new ServerSocket(10007);

//在服务端获取客户端对象

Socket s = ss.accept();

//获取服务端ip

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip);

// DataInputStream dis = new DataInputStream(s.getInputStream()));

// long l = dis .readLong();

//读取客户端发来的数据

BufferedReader bufin =

new BufferedReader(new InputStreamReader(s.getInputStream()));

//将数据格式化写到文件server.java中

PrintWriter out = new PrintWriter(new FileWriter("server.java"),true);

String line = null;

while((line = bufin.readLine())!=null)

{

// if("over".equals(line))

// break;

out.println(line);//读取一行写一行，并刷新

}

//向客户端返回数据

PrintWriter pw = new PrintWriter(s.getOutputStream(),true);

pw.println("unload succeed");

out.close();

s.close();

ss.close();

}

public class PrintWriter extends Writer

向文本输出流打印对象的格式化表示形式，如果启用了自动刷新，则只有在调用println printf或format的其中一个方法时才可能完成操作，而不是每当正好输出换行时才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。

此类中的方法不会抛出IO异常，尽管其某些构造方法可能抛出异常，客户端可能会查询调用checkError()是否出现错误。

PrintWriter(OutputStream out,boolean autoFlush)根据现有的OutputStream创建新的PrintWriter，ture为自动刷新。

练习：上传图片

客户端

建立端点

读取图片文件

通过socket输出流将数据发给服务端

读取服务端反馈信息

关闭

服务端

import java.io.*;

import java.net.*;

class PicClient

{

public static void main(String[] args)

{

Socket s = new Socket("192.168.0.101",10008);

FileInputStream fis = new FileInputStream("1.bmp");

OutputStream out = s.getOutputStream();

byte[] buf = new byte[1024];

int len = 0;

while((len = fis.read(buf))!=-1)

{

out.write(buf,0,len);

}

//告诉服务端数据已写完

s.shutdownOutput();

InputStream in = s.getInputStream();

byte[] bufin = new byte[1024];

int num = in.read(bufin);

System.out.println(new String(bufin,0,num));

in.close();

dis.close();

s.close();

}

服务端

class PicServer

{

public static void main(String[] args)

{

ServerSocket ss = new ServerSocket(10008);

Socket s = ss.accept();

InputStream in = s.getInputStream();

FileOutputStream fos = new FileOutputStream("serve.bmp");

byte[] buf = new byte[1024];

int len = 0;

while((len = in.read(buf))!=-1)

{

fos.write(buf,0,len);

}

OutputStream out = s.getOutputStream();

out.write("upload succeed".getBytes());

fos.close();

s.close();

ss.close();

}

练习：服务端并发上传图片

当A客户端连接上以后，被服务器获取到，服务端执行具体流程。这时B客户端连接只有等待。

因为服务端还没有处理完A客户端的请求，还没有循环回来执行下一次accept方法，所以暂时获取不到B客户端对象

那么为了可以让多个客户端同时并发访问服务端

那么服务端最好就是将每个客户端封装到一个单独的线程中，这样就可以同时处理多个客户端请求

如何定义线程，明确每一个客户端要在服务端执行的代码，将该代码存入run方法中。

import java.io.*;

import java.net.*;

class PicClient

{

public static void main(String[] args)

{

Socket s = new Socket("192.168.0.101",10008);

FileInputStream fis = new FileInputStream("1.bmp");

OutputStream out = s.getOutputStream();

byte[] buf = new byte[1024];

int len = 0;

while((len = fis.read(buf))!=-1)

{

out.write(buf,0,len);

}

//告诉服务端数据已写完

s.shutdownOutput();

InputStream in = s.getInputStream();

byte[] bufin = new byte[1024];

int num = in.read(bufin);

System.out.println(new String(bufin,0,num));

in.close();

fis.close();

s.close();

}

class PicThread implements Runnable

{

private Socket s;

PicThread(Socket s)

{

this.s= s ;

}

public void run()

{

String ip = s.getInetAddress().getHostAddress();

int count =1;

try

{

System.out.println(ip);

InputStream in = s.getInputStream();

File file = new File(ip+"("+(count++)+")");

while(file.exists())

{

file = new File(ip+"("+(count++)+")");

}

              FileOutputStream fos = new FileOutputStream(file);

              byte[] buf = new byte[1024];

              int len = 0;

              while((len = in.read(buf))!=-1)

              {

                      fos.write(buf,0,len);

                }

              OutputStream out = s.getOutputStream();

              out.write("upload succeed".getBytes());

              fos.close();

              s.close();

              ss.close();