Java网络编程超详细笔记

最新推荐文章于 2024-08-28 13:31:21 发布

oo77771

最新推荐文章于 2024-08-28 13:31:21 发布

阅读量713

点赞数 12

分类专栏：程序员文章标签： java 网络笔记

本文链接：https://blog.csdn.net/F1814397/article/details/137360954

版权

程序员专栏收录该内容

599 篇文章 1 订阅

订阅专栏

byte[] bytes = new byte[1024] ;

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

//3)接收

ds.receive(dp);

//解析数据

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

//获取ip地址

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

System.out.println(“IP:”+ip+“发送的内容是:”+s);

//关闭资源

ds.close();

}

6.4 案例_无限发送

需求：

发送端发送数改为"键盘录入"使用BufferedReader流的方式，

自定义一个结束条件"byt bye /886"

接收端不断的去接收消息不关闭

//发送端

public class DemoSend {

public static void main(String[] args) throws IOException {

//创建发送端的DatagramSocket对象

DatagramSocket ds = new DatagramSocket();

//发送端不断的键盘录入

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

String line = null;

while((line = br.readLine())!= null){

if(“886”.equals(line)){

break;

}

//创建数据报包对象

byte[] bytes = line.getBytes();

DatagramPacket dp = new DatagramPacket(bytes, bytes.length,InetAddress.getByName(“10.12.151.138”),10086);

//发送数据

ds.send(dp);

}

//关闭资源

ds.close();

}

//接收端

public class DemoReceived {

public static void main(String[] args) throws IOException {

//创建接收的socket对象

DatagramSocket ds = new DatagramSocket(10086);

while(true){

//创建数据接收包，接收容器

byte[] bytes = new byte[1024];

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

//接收数据

ds.receive(dp);

//解析数据

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

//解析IP

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

System.err.println(“from:”+ip +“data is :” +s);

}

6.5 案例_多线程同一窗口

需求：

将UDP协议发送端和接收端在一个窗口下进行聊天

步骤：

开启两个子线程：分别实现Runnable接口并且重写run方法

sendDemo:发送端

ReceiveDemo:接收端

开启两个子线程 :Thread(Runnable target)

//接收端

public class ReceiveDemo implements Runnable{

private DatagramSocket ds ;

public ReceiveDemo(DatagramSocket ds) {

this.ds = ds ;

}

@Override

public void run() {

//不断的接收数据

//创建数据报包

try {

while(true) {

byte[] bytes = new byte[1024] ;

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

//接收

ds.receive(dp);

//解析数据

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

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

System.out.println(“ip is:”+ip+“data is:”+s);

}

} catch (IOException e) {

e.printStackTrace();

}

//接收端模拟真实场景,不需要关闭

}

//发送端

public class SendDemo implements Runnable {

private DatagramSocket ds ;

public SendDemo(DatagramSocket ds) {

this.ds = ds ;

}

@Override

public void run() {

//键盘录入数据

try {

BufferedReader br = new BufferedReader(

new InputStreamReader(System.in)) ;

String line = null ;

while((line=br.readLine())!=null) {

//自定义结束条件

if(“886”.equals(line)) {

break ;

}

//创建数据报包对象

byte[] bytes = line.getBytes() ;

DatagramPacket dp = new DatagramPacket(bytes, bytes.length,InetAddress.getByName(“10.12.151.138”), 12345) ;

//发送数据

ds.send(dp);

}

} catch (IOException e) {

e.printStackTrace();

}finally {

//释放资源

if(ds!=null) {

ds.close();

}

//主方法

public class ChatRoom {

//主线程

public static void main(String[] args) {

try {

//创建一个DataSocket对象

DatagramSocket ds = new DatagramSocket() ;

DatagramSocket ds2 = new DatagramSocket(12345) ;

//创建发送端资源类对象

SendDemo sd = new SendDemo(ds) ;

//创建接收端资源类对象

ReceiveDemo rd = new ReceiveDemo(ds2);

Thread t1 = new Thread(sd) ;

Thread t2 = new Thread(rd) ;

//开启线程

t1.start();

t2.start();

} catch (SocketException e) {

e.printStackTrace();

}

7. TCP传输

============================================================================

建立客户端和服务器端，属于安全连接；建立连接后，通过Socket中的IO流进行数据的传输；

Socket和ServerSocket

7.1 TCP客户端

步骤：

创建Socket套接字对象 Socket(String host,int port)

获取连接通道内的字节输出流对象 public OutputStream getOutputStream()

通过该字节输出流对象写数据 write(byte[] bytes)

释放资源

public class ClientDemo {

public static void main(String[] args) throws IOException {

//创建客户端的流套接字对象

Socket socket = new Socket(“10.12.151.138”,10086);

//获取通道内的字节输出流对象

OutputStream out = socket.getOutputStream();

//写数据

out.write(“你好Java”.getBytes());

//关闭资源

socket.close();

}

7.2 TCP服务端

步骤：

创建ServerSocket套接字对象 ServerSocket(int port)

侦听客户端连接 public Socket accept() 阻塞式方法

获取通道内字节输入流对象 public InputStream getInputStream()

一次读取一个字节数组public int read(byte[] bytes)

展示数据 public InetAddress getInetAddress():获取ip地址对象

释放资源

public class ServerDemo {

public static void main(String[] args) throws IOException {

//创建ServerSocket服务套接字

ServerSocket ss = new ServerSocket(10086);

//监听客户端连接：阻塞式方法

//返回的就是当前客户端对象

Socket socket = ss.accept();

//获取通道内字节输入流对象

InputStream in = socket.getInputStream();

//读取通道流的数据

byte[] bytes = new byte[1024];

int len = in.read(bytes);

String str = new String(bytes,0,len);

//展示数据

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

System.out.println(“ip地址是:”+ip+“,发送的数据是:”+str);

//关闭资源

ss.close();

}

7.3 案例_服务端反馈客户端

需求：客户端发消息服务端给出反馈

//客户端

public class ClientTest {

public static void main(String[] args) throws IOException {

//创建客户端的Socket对象

Socket s = new Socket(“10.12.151.138”,11111);

//获取通过的内存输出流对象

OutputStream out = s.getOutputStream();

out.write(“你好！”.getBytes());

//客户端的接收服务器的反馈

//获取通道内的输入流对象

InputStream in = s.getInputStream();

//一次读取一个字节

byte[] bytes = new byte[1024];

int len = in.read(bytes);

String serverMsg = new String(bytes,0,len);

System.out.println(serverMsg);

//释放资源

out.close();

}

//服务端

public class ServerTest {

public static void main(String[] args) throws IOException {

//创建服务端的Socket对象

ServerSocket ss = new ServerSocket(11111);

//监听客户端连接

Socket socket = ss.accept();

//获取通道内的输入流对象

InputStream in = socket.getInputStream();

//一次读取一个字节数组

byte[] bytes = new byte[1024];

int len = in.read(bytes);

String str = new String(bytes,0,len);

//展示客户端发送的数据

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

System.out.println(“客户端的ip:”+ip+“,发送的内容:”+str);

//服务器反馈

//获取当前绑定的端口为11111的客户端通道内的字节输出流

OutputStream out = socket.getOutputStream();

out.write(“收到信息”.getBytes());

//释放资源

ss.close();

}

7.4 案例_无限发送

需求：客户端不断键盘录入数据,(BufferedReader),客户端一旦录入"886"结束，服务器端将客户端录入的数据展示在控制台上!

//客户端

public class ClientDemo {

public static void main(String[] args) throws IOException {

//创建客户端的Socket对象

Socket s = new Socket(“10.12.151.138”,33333);

//创建BufferedReader字符缓冲输入流对象

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

//将通过内的流封装成BufferedWriter

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

String line = null;

while((line = br.readLine())!= null){

if(“886”.equals(line)){

break;

}

//字符输入流读取一行

//就给当前通过内的流写一行

bw.write(line);

bw.newLine();

bw.flush();

}

//释放资源

s.close();

bw.close();

}

//服务端

public class ServerDemo {

public static void main(String[] args) throws IOException{

//创建服务器端的Socket对象

ServerSocket ss = new ServerSocket(33333);

//监听客户端

Socket socket = ss.accept();

//封装通过通道内的字节输入流对象

BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

//不断读数据，在控制台显示

String line = null;

while((line = br.readLine())!= null){

System.out.println(line);

}

7.5 案例_客户端键盘录入服务端输出文件

需求：客户端不断键盘录入(使用BufferReader流的方式),自定义结束条件，服务器端输出一个文本文件

//客户端

public class ClientDemo {

public static void main(String[] args) throws IOException {

//创建客户端的Socket对象

Socket socket = new Socket(“10.12.151.138”,22222);

//键盘录入

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

//封装通道内的字节输出流

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())) ;

String line = null ;

while((line=br.readLine())!=null) {

if(“over”.equals(line)) {

break ;

}

bw.write(line);

bw.newLine();

bw.flush();

}

//关闭资源

bw.close();

socket.close();

}

//服务端

public class ServerDemo {

public static void main(String[] args) throws IOException {

//创建服务端的Socket对象

ServerSocket ss = new ServerSocket(22222);

//监听客户端的连接

Socket socket = ss.accept();

//封装通道内的字节输入流

BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

//创建字符缓冲输出流对象

BufferedWriter bw = new BufferedWriter(new FileWriter(“a.txt”));

//一次读取一行

String line = null;

while((line = br.readLine())!= null){

bw.write(line);

bw.newLine();

bw.flush();

}

//关闭资源

bw.close();

ss.close();

}

7.6 案例_客户端读取文件服务端输出在控制台

需求：客户端读取文本文件，服务器将文本文件的内容输出到控制台，优先使用字符流

//客户端

public class ClientTest {

public static void main(String[] args) throws IOException {

//创建客户端的Socket对象

Socket socket = new Socket(“192.168.1.110”,22222);

//封装文本文件

BufferedReader br = new BufferedReader(new FileReader(“a.txt”));

//封装通道内的字节输出流

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())) ;

//一次读一行数据（文件）

String line = null;

while((line = br.readLine())!= null){

bw.write(line);

bw.newLine();

bw.flush();

}

//关闭资源

br.close();

socket.close();

}

//服务端

public class ServerTest {

public static void main(String[] args) throws IOException {

//创建服务器ServerSocket对象

ServerSocket ss = new ServerSocket(22222);

//监听客户端连接

Socket socket = ss.accept();

//封装通道内的字节输入流

BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

//一次读取一行

String line = null;

while((line = br.readLine())!= null){

System.out.println(line);

}

ss.close();

}

7.7 案例_客户端读入文件服务端复制该文件

需求：客户端文本文件，服务器端输出一个文本文件（将客户端的文本文件中的内容复制到该文件中）

//客户端

public class ClientDemo {

public static void main(String[] args) throws IOException {

//创建Socket对象

Socket s = new Socket(“10.12.151.138”,11111);

//封装文本文件

BufferedReader br = new BufferedReader(new FileReader(“a.txt”));

//封装通过的内字节流

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

//一次读一行

String line = null;

while((line = br.readLine())!= null){

bw.write(line);

bw.newLine();

bw.flush();

}

//释放资源

br.close();

s.close();

}

//服务端

public class ServerDemo {

public static void main(String[] args) throws IOException {

//创建服务器端Socket

ServerSocket ss = new ServerSocket(11111);

//侦听客户端

Socket s = ss.accept();

//封装通道内字节流输入流对象

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

//封装文本文件

BufferedWriter bw = new BufferedWriter(new FileWriter(“copy.txt”));

//读一行，在copy中写一行

String line = null;

while((line = br.readLine())!=null){

bw.write(line);

bw.newLine();

bw.flush();

}

//释放资源

bw.close();

s.close();

}

7.8 案例_客户端读入文件服务端输出文件并给出反馈

需求：客户端的文本文件,服务器端复制文本文件的内容到Copy.java中并且服务器加入反馈操作

readLine()方法通过返回是否null只是判断文件是否读完，服务器端通过内流的不知道文件是否已经读完了那么就会相互等待

解决：

在客户端告诉服务器端,没有数据了,自定义一个"字符串"作为结束标记

public void shutdownOutput()：告诉服务器,客户端没有数据了

//客户端

public class ClientDemo {

public static void main(String[] args) throws IOException {

//创建客户端的Socket对象

Socket s = new Socket(“10.12.151.138”,11111);

//封装文本文件

BufferedReader br = new BufferedReader(new FileReader(“a.txt”));

//封装通过的内字节输出流

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

//读内容,写进流

String line = null;

while((line=br.readLine())!=null){

bw.write(line);

bw.newLine();

bw.flush();

}

//自定义一个结束标记,作为客户端给服务器通知,文件已经读完了

/*bw.write(“over”);

bw.newLine();

bw.flush();*/

//告诉服务器端客户端没有数据了

s.shutdownOutput();

//接收服务器端的反馈信息

//获取通过内的字节输入流,封装成字符流

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

//利用readLine

String serverMsg = clientBr.readLine();

System.out.println(“serverMsg:”+serverMsg);

//关闭

br.close();

s.close();

}

//服务端

public class ServerDemo {

public static void main(String[] args) throws IOException {

ServerSocket ss = new ServerSocket(11111);

//监听

Socket s = ss.accept();

//封装通过的内字节输入流对象

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

//封装被输出的文本文件Copt.txt

BufferedWriter bw = new BufferedWriter(new FileWriter(“copy.txt”));

//读取通过的流的内容，写的copy中

String line = null;

while((line = br.readLine())!= null){

/*//加入一个判断

if(“over”.equals(line)) {

break ;//结束

}*/

bw.write(line);

bw.newLine();

bw.flush();

}

//给客户端发送反馈信息

//服务器端获取通过的字节输出流对象(封装成字符流)

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

bw2.write(“数据已经收到了”);

bw2.newLine();

bw2.flush();

//关闭

bw.close();

s.close();

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

Java架构进阶面试及知识点文档笔记

这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理

Java分布式高级面试问题解析文档

其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！

互联网Java程序员面试必备问题解析及文档学习笔记

Java架构进阶视频解析合集
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

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

bw2.write(“数据已经收到了”);

bw2.newLine();

bw2.flush();

//关闭

bw.close();

s.close();

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-qfONyhFh-1712160307471)]

[外链图片转存中…(img-JjUa3YX8-1712160307472)]

[外链图片转存中…(img-4ioDfWhv-1712160307472)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

Java架构进阶面试及知识点文档笔记

这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理

[外链图片转存中…(img-erQGu3Og-1712160307472)]

Java分布式高级面试问题解析文档

其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！

[外链图片转存中…(img-slLTteLB-1712160307473)]

互联网Java程序员面试必备问题解析及文档学习笔记

[外链图片转存中…(img-6mP9MBfp-1712160307473)]

Java架构进阶视频解析合集
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

oo77771

关注

12
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录