JAVASE_23_@网络编程-23

最新推荐文章于 2024-04-20 15:52:39 发布
最新推荐文章于 2024-04-20 15:52:39 发布
阅读量578 收藏
点赞数
分类专栏： javaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kkopopo/article/details/20444513
版权
1，概述
双方网络通信---网络要素
1，找到对方IP地址
2，端口：逻辑端口   范围 0~65536
3，定义通信规则，这个通讯规则成为协议
国际组织定义了通用协议 TCP/IP


2，IP地址---java.net   InetAddress
网络中设备的标识
不易记忆，可用主机名
本地回环地址：127.0.0.1 主机名：localhost
方法getHostAddress（）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import  java.net.InetAddress;
import  java.net.UnknownHostException;
 
public  class  IPDemo {
     public  static  void  main(String[] args)  throws  UnknownHostException{
         InetAddress i = InetAddress.getLocalHost();
         System.out.println(i.toString());
         System.out.println( "address=" +i.getHostAddress());
         System.out.println( "name=" +i.getHostName());
         
         InetAddress[] ia= InetAddress.getAllByName( "www.baidu.com" );
         for (InetAddress ip:ia){
             System.out.println(ip.toString());
         }      
     }
}
Administer-PC/ 192.168 . 0.44
address= 192.168 . 0.44
name=Administer-PC
www.baidu.com/ 61.135 . 169.105
www.baidu.com/ 61.135 . 169.125
3，端口号
用于标识进程的额逻辑地址，不同进程的标识
有效端口：0~~65535，其中0~1024系统使用或保留端口
4，传输协议
UDP---面向无连接
1.将数据及源和目的封装在数据包中，不需要建立连接
2.每个数据包的大小限制在64K内
3.因无连接，是不可靠协议
4.不需要建立连接，速度快
应用：飞秋，视频会议，视频教学，桌面共享

TCP----面向有链接
1.建立连接，形成传输数据的通道
2.在连接中进行大量数据传输
3.通过三次握手完成连接，是可靠协议
4.必须建立连接，效率会稍低
应用：相当于打电话

5，Socket(套接字)
    ------单词翻译：插座----相当于码头
    -->所谓的网络编程就是socket编程
1，Socket就是为网络服务提供的一种机制
2，通信两端都有Socket
3，网络通信其实就是Socket间的通讯
4，数据在两个Socket间通过IO传输

6，UDP
UDP----->发送端
需求：通过udp传输方式，将一段文字数据发送出去。，
定义一个udp发送端。
思路：
1，建立updsocket服务。
2，提供数据，并将数据封装到数据包中。
3，通过socket服务的发送功能，将数据包发出去。
4，关闭资源。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class   UdpSend{
     public  static  void  main(String[] args)  throws  Exception{
         //1，创建udp服务。通过DatagramSocket对象。
         DatagramSocket ds =  new  DatagramSocket( 8888 );//制定发送端端口为8888
         //2，确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port) 
         byte [] buf =  "udp ge men lai le " .getBytes();
         DatagramPacket dp = 
             new  DatagramPacket(buf,buf.length,InetAddress.getByName( "192.168.1.254" ), 10000 );
         //3，通过socket服务，将已有的数据包发送出去。通过send方法。
         ds.send(dp);
         //4，关闭资源。
         ds.close();
     }
}
图例：
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
UDP----->接收端
需求：定义一个应用程序，用于接收udp协议传输的数据并处理的。
定义udp的接收端。
思路：
1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。
 方便于明确哪些数据过来该应用程序可以处理。
2，定义一个数据包，因为要存储接收到的字节数据。
因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
3，通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
4，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
5，关闭资源。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class   UdpRece{
     public  static  void  main(String[] args)  throws  Exception{
         //1,创建udp socket，建立端点。
         DatagramSocket ds =  new  DatagramSocket( 10000 ); //接收端必须监听一个端口
         //2,定义数据包。用于存储数据。
         byte [] buf =  new  byte [ 1024 ];
         DatagramPacket dp =  new  DatagramPacket(buf,buf.length);
         //3，通过服务的receive方法将收到数据存入数据包中。
         ds.receive(dp); //阻塞式方法。
         //4，通过数据包的方法获取其中的数据。
         String ip = dp.getAddress().getHostAddress();
         String data =  new  String(dp.getData(), 0 ,dp.getLength());
         int  port = dp.getPort();
         System.out.println(ip+ "::" +data+ "::" +port);
         //5，关闭资源
         ds.close();
     }
}
7，UDP--键盘录入方式数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class   UdpSend2{
     public  static  void  main(String[] args)  throws  Exception{
         DatagramSocket ds =  new  DatagramSocket();
         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" ), 10001 );
             ds.send(dp);
         }
         ds.close();
     }
}
8，UDP-----Dos聊天室
编写一个聊天程序。
有收数据的部分，和发数据的部分。
这两部分需要同时执行。
那就需要用到多线程技术。
一个线程控制收，一个线程控制发。
因为收和发动作是不一致的，所以要定义两个run方法。
而且这两个方法要封装到不同的类中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
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 ){
                 byte [] buf = line.getBytes();
                 DatagramPacket dp = 
                     new  DatagramPacket(buf,buf.length,InetAddress.getByName( "192.168.1.255" ), 10002 );
                 ds.send(dp);
                 if ( "886" .equals(line))
                     break ;
             }
         }
         catch  (Exception e){
             throw  new  RuntimeException( "发送端失败" );
         }
     }
}
class  Rece  implements  Runnable{
     private  DatagramSocket ds;
     public  Rece(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());
 
                 if ( "886" .equals(data)){
                     System.out.println(ip+ "....离开聊天室" );
                     break ;
                 }
                 System.out.println(ip+ ":" +data);
             }
         }
         catch  (Exception e){
             throw  new  RuntimeException( "接收端失败" );
         }
     }
}
 
 
class   ChatDemo{
     public  static  void  main(String[] args)  throws  Exception{
         DatagramSocket sendSocket =  new  DatagramSocket();
         DatagramSocket receSocket =  new  DatagramSocket( 10002 );
 
         new  Thread( new  Send(sendSocket)).start();
         new  Thread( new  Rece(receSocket)).start();
 
     }
}
9，TCP
1,tcp分客户端和服务端。
2，客户端对应的对象是Socket
     服务端对应的对象是ServerSocket
TCP----->客户端
通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机。
因为tcp是面向连接的。所以在建立socket服务时，
就要有服务端存在，并连接成功。形成通路后，在该通道进行数据的传输。
需求：给服务端发送给一个文本数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
步骤：
1 ，创建Socket服务。并指定要连接的主机和端口
2,为了发送数据，应该获取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.254" , 10003 );
         //为了发送数据，应该获取socket流中的输出流。
         OutputStream out = s.getOutputStream();
         out.write( "tcp ge men lai le " .getBytes());
         s.close();
     }
}
TCP---服务端
步骤：
1，建立服务端的socket服务。ServerSocket(); ， 并监听一个端口。 
2，获取连接过来的客户端对象。
 通过ServerSokcet的 accept方法。没有连接就会等，所以这个方法阻塞式的。
3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。
 并打印在控制台。
4，关闭服务端(可选)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class   TcpServer{
     public  static  void  main(String[] args)  throws  Exception{
         //建立服务端socket服务。并监听一个端口。
         ServerSocket ss =  new  ServerSocket( 10003 );
         //通过accept方法获取连接过来的客户端对象。
         while ( true ){
         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();
     }
}
10，TCP---客户端和服务端的互访
TCP---客户端
1，建立socket服务。指定要连接主机和端口。
2，获取socket流中的输出流。将数据写到该流中。通过网络发送给服务端。
3，获取socket流中的输入流，将服务端反馈的数据获取到，并打印。
4，关闭客户端资源
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class  TcpClient2 {
     public  static  void  main(String[] args) throws  Exception {
         Socket s =  new  Socket( "192.168.1.254" , 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();
     }
}
TCP----服务端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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+ "....connected" );
         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();
         Thread.sleep( 10000 );
         out.write( "哥们收到,你也好" .getBytes());
         s.close();
         ss.close();
     }
}
11，TCP练习----文本转换器
该例子出现的问题。
现象：客户端和服务端都在莫名的等待。
为什么呢？
因为客户端和服务端都有阻塞式方法。这些方法么没有读到结束标记。那么就一直等
而导致两端，都在等待。
需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。
而且客户度可以不断的进行文本转换。当客户端输入over时，转换结束。
分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入。
目的：网络设备，网络输出流。
而且操作的是文本数据。可以选择字符流。
步骤
1，建立服务。
2，获取键盘录入。
3，将数据发给服务端。
4，获取服务端返回的大写数据。
5，结束，关资源。
都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class   TransClient{
     public  static  void  main(String[] args)  throws  Exception{
         Socket s =  new  Socket( "192.168.1.254" , 10005 );
         //定义读取键盘数据的流对象。
         BufferedReader bufr = 
             new  BufferedReader( new  InputStreamReader(System.in));
         //定义目的，将数据写入到socket输出流。发给服务端。
         //BufferedWriter bufOut = 
             //new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
         PrintWriter out =  new  PrintWriter(s.getOutputStream(), true );
         //定义一个socket读取流，读取服务端返回的大写信息。
         BufferedReader bufIn = 
             new  BufferedReader( new  InputStreamReader(s.getInputStream()));
         String line =  null ;
         while ((line=bufr.readLine())!= null ){
             if ( "over" .equals(line))
                 break ; 
             out.println(line);
//          bufOut.write(line);
//          bufOut.newLine();
//          bufOut.flush();
             String str =bufIn.readLine();
             System.out.println( "server:" +str);     
         }
         bufr.close();
         s.close();
     }
}
服务端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class   TransServer{
     public  static  void  main(String[] args)  throws  Exception{
         ServerSocket ss =  new  ServerSocket( 10005 );
         Socket s = ss.accept();
         String ip = s.getInetAddress().getHostAddress();
         System.out.println(ip+ "....connected" );
         //读取socket读取流中的数据。
         BufferedReader bufIn =
             new  BufferedReader( new  InputStreamReader(s.getInputStream()));
         //目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。
         //BufferedWriter bufOut = 
             //new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
         PrintWriter out =  new  PrintWriter(s.getOutputStream(), true );
         String line =  null ;
         while ((line=bufIn.readLine())!= null ){
             System.out.println(line);
             out.println(line.toUpperCase());
//          bufOut.write(line.toUpperCase());
//          bufOut.newLine();
//          bufOut.flush();
         }
         s.close();
         ss.close();
     }
}
12，TCP练习----复制文件
注意事项：
1，服务器端的readLine( )如何结束循环?
可以自定义循环标记，over或者加入时间，前提是你得让服务器知道这个标记
也可以用shutdownOutput()，用Socket中的方法加入一个结束后标记
2，实际的文件在网络中传输复制是哪样的？
客户端先发给服务端一个要复制的文件的名字，服务端先建立好
然后再传输数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class   TextClient{
     public  static  void  main(String[] args)  throws  Exception{
         Socket s =  new  Socket( "192.168.1.254" , 10006 );
         BufferedReader bufr = 
             new  BufferedReader( new  FileReader( "IPDemo.java" ));
         PrintWriter out =  new  PrintWriter(s.getOutputStream(), true );
         String line =  null ;
         while ((line=bufr.readLine())!= null ){
             out.println(line);
         }
         s.shutdownOutput(); //关闭客户端的输出流。相当于给流中加入一个结束标记-1.       
         BufferedReader bufIn =  new  BufferedReader( new  InputStreamReader(s.getInputStream()));
         String str = bufIn.readLine();
         System.out.println(str);
         bufr.close();
         s.close();
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class   TextServer{
     public  static  void  main(String[] args)  throws  Exception{
         ServerSocket ss =  new  ServerSocket( 10006 );
         Socket s = ss.accept();
         String ip = s.getInetAddress().getHostAddress();
         System.out.println(ip+ "....connected" );
         BufferedReader bufIn =  new  BufferedReader( new  InputStreamReader(s.getInputStream()));
         PrintWriter out  =  new  PrintWriter( new  FileWriter( "server.txt" ), 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( "上传成功" );
         out.close();
         s.close();
         ss.close();
     }
}
一枚用户
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE_7_网络编程
02-09
网络编程，TPC程序，ECHO程序，UDP程序
JAVASE-基础 - 网络编程
07-30
介绍了网络编程的概念，网络编程的代码实现
JavaSE_网络编程
最新发布
2301_78085386的博客
04-20 1999
计算机网络： 把分布在不同地理区域的具有独立功能的计算机,通过通信设备与线路 连接起来，由功能完善的软件实现资源共享和信息传递的系统。有人说，20世纪最伟大的发明不是计算机，而是计算机网络。还有人说，如果你买了计算机而没有联网，就等于买了电话机而没有接 电话 线一样● Java是 Internet 上的语言，它从语言级上提供了对网络应用程序的 支持，程序员能够很容易开发常见的网络应用程序。
JavaSE_ 网络编程 目录(26)
diaoji9561的博客
06-03 91
JavaSE学习总结第26天_网络编程26.01 网络编程概述26.02 网络模型概述和图解26.03 网络编程三要素概述26.04 网络编程三要素之IP概述126.05 InetAddress类的概述和使用26.06 网络编程三要素之端口26.07 网络编程三要素之协议26.08 Socket通信原理26.09 UDP协议发送数据26.10 UDP协议接收数据26....
JavaSE_网络编程_IP
pre_eminent的JAVA学习园地
11-04 789
import java.net.InetAddress; import java.net.UnknownHostException; public class InetAddressDemo { public static void main(String[] args) throws UnknownHostException { /*方法说明: *public class InetA
【JavaSE基础】09-网络编程
用编程认知世界，Just coding....
05-01 2090
JavaSE 网络 Socket，TCP/IP 网络协议和模型、UDP 等
JavaSE_13网络编程
圆静居士的专栏
09-05 223
JavaSE_13网络编程
基于UDP协议的Socket通信.rar_UDP_javase_网络编程
09-15
在IT行业中，网络编程是构建分布式系统和网络应用的基础，而Socket编程是网络通信的核心。本教程主要聚焦于使用Java SE（标准版）环境下的UDP（User Datagram Protocol）Socket通信。UDP是一种无连接的传输层协议，...
02-Java语言进阶_javase_
10-01
2. **常用API**：Java API包含了大量预定义的类和接口，如集合框架、IO流、网络编程、多线程等。掌握这些API是提升开发效率的关键。 3. **缓冲流、转换流、序列化流**： - **缓冲流**：BufferedInputStream和...
Core Java SE.zip_JavaSE_API_java文档
09-20
它提供了丰富的API，包括集合框架、I/O流、多线程、网络编程、数据库连接（JDBC）、XML处理、GUI组件等，覆盖了软件开发的各个方面。 API（Application Programming Interface）文档是程序员在使用特定库或框架时的...
JAVASE_03_for循环
junshengluo
01-23 865
1.无线循环的最简表达式 小面试题里可能有 for( ; ; ) {} while(true){} 2.break和continue
集合变数组---------集合变数组
junshengluo
03-06 831
作者:ljs 创作时间:2014-03-06 17:18 说明:以后有时间详细写作 遗留问题: 1,返回的列表是可序列化的，并且实现了 RandomAccess??这句话怎么理解  Object[ ] toArray()---------返回包含此 collection 中所有元素的数组(Collection接口的中的方法) static  List
字节流中write探讨问题!
junshengluo
03-07 701
作者:ljs 创作时间:2014-03-06 17:18 说明:以后有时间详细写作 遗留问题: 1,探讨这2个方法有啥不同? 在SequenceInputStream遇到问题,具体问题见笔记! void write(byte[] b)           将 b.length 个字节从指定 byte 数组写入此文件输出流中。  void
JAVASE_06天_@面向对象_构造和静态和单例设计模式
junshengluo
03-04 699
1.关键字static 1.1静态:static      用法:是一个修饰符,用于修饰成员(成员变量,,成员函数)------------静态的成员变量,也叫类变量，类方法 1. 静态内容被类的所有对象所共享..--放在了方法区(共享区,数据区)， 2.局部变量无法使用static修饰符
JAVASE_17_反射的深入讲解
junshengluo
03-04 636
1，反射：反射的基石---Class类 -------------java1.2就有的特性 1，反射的基石---Class类，代表一类什么样的事物？ 描述java程序中的各个java类 2，Class类的实例对象是什么？ Class clx = 字节码； Class的实例对象就是某个类的字节码. Class类中没
JAVASE_20_#java高级IO_File对象和IO包中的其他类
junshengluo
03-04 606
1，File类             ------File的实例：--文件或者文件夹              ------用来将文件或者文件夹封装成对象                         方便对文件与文件夹的属性信息进行操作             -------File对象可以作为参数传递给流的构造函数 1.1，创建File对象---三种构造方法
JAVASE_19_#java高级IO_BufferedReader和BufferedWriter
junshengluo
03-04 582
1，字符流的缓冲区 BufferedWriter：字符写入流缓冲区 BufferedReader：字符读取流缓冲区 缓冲区的出现是为了提高流的操作效率而出现的， 所以在创建缓冲区之前，必须要现有流对象 1.1，BufferedWriter：字符写入流缓冲区 该缓冲区中提供了一个跨平台的换行符。 newLi
JAVASE_07天_@面向对象_extends与interface
junshengluo
03-04 576
1.继承         1.提高了代码的复用性         2.让类与类之间产生了关系,有了这个关系,才有了多态的特性 java语言中:             1.java只支持单继承,不支持多继承,(接口与接口之间可以实现多继承) 因为多继承容易带来安全隐患: 当多个父类定义了相同的功能,当功能的内容不同时,子类对象不确定要运行哪一个             但是j
javase网络编程
08-16
Java SE网络编程包括InetAddress类、URL类和TCP通信。 InetAddress类用于表示IP地址和域名，可以通过getByName(String host)方法根据主机名或IP地址字符串获取InetAddress实例，也可以通过getLocalHost()方法获取本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值