Java网络编程概述
1、网络的相关概念
2、InetAddress类的介绍
3、基于TCP协议的网络通信
4、基于UDP协议的网络通信
5、基于URL的网络通信
一、网络的相关概念
1.网络通信
概念: 多台设备之间通过网络进行数据传输
对于程序员讲,我们要做的 就是 通过一定的方法,将数据从一台设备传输到另一台设备或
接受另一台设备传输过来的数据
java.net包中提供了一系列用于网络中数据传输的方法
2、网络
概念:多台设备之间通过一定的物理设备连接起来就构成了网络
分类:按覆盖范围不同
局域网:覆盖范围最小
城域网:覆盖范围居中
广域网:覆盖范围最大
典型的代表:万维网
3、IP地址
概念:网络中每台计算机的唯一标识号
表示形式:点分十进制
xx.xx.xx.xx
每一个十进制的范围:0~255
组成:网络地址+主机地址
分类:
第一个十进制数 网络地址 主机地址
A 0~126 第一位 后三位
B 128~191 前两位 后两位
C 192~223 前三位 后一位
D 科研、测试
E 保留
4、域名
概念:为了方便记忆对方设备的地址,将ip地址一一对应成域名
手机电话簿中:
联系人姓名————联系人电话
域名 ————ip
5、端口号
概念:某台设备中的指定网络程序的标识号
表示形式:0~65535之间的整数
其中0~1024已经被占用
常见的端口号:
tomcat:8080
oracle:1521
mysql:3306
6、传输协议
基于TCP的传输:
1、面向连接的,安全可靠
“三次握手”
第一次握手:确保 发送和接受设备没问题
第二次握手:确保 接收端可以正常接受数据
第三次握手:确保 发送端可以正常发送数据
2、传输的速率较低
3、传输的数据没有字节限制
4、必须释放连接资源
基于UDP的传输:
1、面向无连接,不安全可靠
2、传输的速率较高
3、传输的数据有字节限制 64k
4、不需要释放连接资源
二、InetAddress类的特点和使用
特点
代表一个IP地址对象,有两个子类Inet4Address和Inet6Address
常见方法
getLocalHost()获取本机IP地址对象
getByName(主机名或ip地址):根据指定主机名获取ip地址对象
getHostName():获取主机名
getHostAddress():获取ip地址
三、基于TCP协议的网络通信
基于客户端/服务端 c/s架构模型
1.客户端向服务端发送链接请求(服务端接受链接请求)
2.客户端向服务端发送数据
3.服务端接受客户端的数据
四、基于UDP协议的网络通信
基于发送端/接收端的架构模型
1.发送端向接收端发送数据
2.接收端接受数据,并向发送端回应数据
3.发送端接受回应过来的数据
五、基于URL的网络通信
URL的理解
//1.创建URL对象
URL url = new URL("http://192.168.26.60:8080/cang.jpg?name=john");
//2.调用方法,获取url的各部分
System.out.println(url.getProtocol());
System.out.println(url.getHost());
System.out.println(url.getPort());
System.out.println(url.getPath());
System.out.println(url.getFile());
基于URL的网络通信
//测试基于URL的网络通信——下载url指定的资源
@Test
public void test2() throws IOException {
//1.创建url对象
URL url = new URL("http://192.168.26.60:8080/cang.jpg");
//2.打开连接
URLConnection connection = url.openConnection();
//3.读数据(下载)
InputStream inputStream = connection.getInputStream();
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src\\cang.jpg"));
//边读边写
bos.write(StreamUtils.streamToByteArray(inputStream));
//4.关闭
bos.close();
inputStream.close();
}
图解Java网络编程
网络编程概述
Java是 Internet 上的语言,它从语言级上提供了对网络应用程序的支持,程序员能够很容易开发常见的网络应用程序。
Java提供的网络类库,可以实现无痛的网络连接,联网的底层细节被隐藏在 Java 的本机安装系统里,由 JVM 进行控制。并且 Java 实现了一个跨平台的网络库,程序员面对的是一个统一的网络编程环境。
网络通信要素
如何实现网络中的主机互相通信:
通信双方地址
一定的规则(有两套参考模型)
OSI参考模型:模型过于理想化,未能在因特网上进行广泛推广
TCP/IP参考模型(或TCP/IP协议):事实上的国际标准。
网络通信协议
通讯要素1:IP 和 端口号
IP 地址:InetAddress
唯一的标识 Internet 上的计算机
本地回环地址(hostAddress):127.0.0.1 主机名(hostName):localhost
不易记忆
端口号标识正在计算机上运行的进程(程序)
不同的进程有不同的端口号
被规定为一个 16 位的整数 065535。其中,01023被预先定义的服务通信占用(如http占用端口80,Tomcat占用端口8080,MySql占用端口3306,Oracle占用端口1521等)。除非我们需要访问这些特定服务,否则,就应该使用 1024~65535 这些端口中的某一个进行通信,以免发生端口冲突。
端口号与IP地址的组合得出一个网络套接字:Socket。
InetAddress类
Internet上的主机有两种方式表示地址:
域名(hostName):www.atguigu.com
IP 地址(hostAddress):202.108.35.210
InetAddress类主要表示IP地址,两个子类:Inet4Address、Inet6Address。
InetAddress 类对象含有一个 Internet 主机地址的域名和IP地址:www.atguigu.com 和 202.108.35.210。
域名容易记忆,当在连接网络时输入一个主机的域名后,域名服务器(DNS)负责将域名转化成IP地址,这样才能和主机建立连接。 -------域名解析
InetAdress 代码示例
通讯要素2:网络通信协议
网络通信协议
计算机网络中实现通信必须有一些约定,即通信协议,对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。
通信协议分层的思想
由于结点之间联系很复杂,在制定协议时,把复杂成份分解成一些简单的成份,再将它们复合起来。最常用的复合方式是层次方式,即同层间可以通信、上一层可以调用下一层,而与再下一层不发生关系。各层互不影响,利于系统的开发和扩展。
TCP/IP协议簇
传输层协议中有两个非常重要的协议:
传输控制协议TCP(Transmission Control Protocol)
用户数据报协议UDP(User Datagram Protocol)。
TCP/IP 以其两个主要协议:传输控制协议(TCP)和网络互联协议(IP)而得名,实际上是一组协议,包括多个具有不同功能且互为关联的协议。
IP(Internet Protocol)协议是网络层的主要协议,支持网间互连的数据通信。
TCP/IP协议模型从更实用的角度出发,形成了高效的四层体系结构,即物理链路层、IP层、传输层和应用层。
TCP 和 UDP
TCP协议:
使用TCP协议前,须先建立TCP连接,形成传输数据通道
传输前,采用“三次握手”方式,是可靠的
TCP协议进行通信的两个应用进程:客户端、服务端
在连接中可进行大数据量的传输
传输完毕,需释放已建立的连接,效率低
UDP协议:
将数据、源、目的封装成数据包,不需要建立连接
每个数据报的大小限制在64K内
因无需连接,故是不可靠的
发送数据结束时无需释放资源,速度快
Socket
利用套接字(Socket)开发网络应用程序早已被广泛的采用,以至于成为事实上的标准。
通信的两端都要有Socket,是两台机器间通信的端点
网络通信其实就是Socket间的通信。
Socket允许程序把网络连接当成一个流,数据在两个Socket间通过IO传输。
一般主动发起通信的应用程序属客户端,等待通信请求的
为服务端
基于Socket的TCP编程
Java语言的基于套接字编程分为服务端编程和客户端编程,其通信模型如图所示:
Socket类的常用方法
ServerSocket类的常用方法
基于Socket的TCP编程
客户端Socket的工作过程包含以下四个基本的步骤:
创建 Socket
根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应,则建立客户端到服务器的通信线路。若连接失败,会出现异常。
打开连接到 Socket 的输入/出流
使用 getInputStream()方法获得输入流,使用 getOutputStream()方法获得输出流,进行数据传输
按照一定的协议对 Socket 进行读/写操作
通过输入流读取服务器放入线路的信息(但不能读取自己放入线路的信息),通过输出流将信息写入线程。
关闭 Socket
断开客户端到服务器的连接,释放线路
客户端创建Socket对象
客户端程序可以使用Socket类创建对象,创建的同时会自动向服务器方发起连接。Socket的构造方法是:
Socket(String host,int port)throws UnknownHostException,IOException:向服务器(域名是host。端口号为port)发起TCP连接,若成功,则创建Socket对象,否则抛出异常。
Socket(InetAddress address,int port)throws IOException:根据InetAddress对象所表示的IP地址以及端口号port发起连接。
客户端建立socketAtClient对象的过程就是向服务器发出套接字连接请求
Socket s = new Socket(“192.168.40.165”,9999);
OutputStream out = s.getOutputStream();
out.write(“hello”.getBytes());
s.close();
基于Socket的TCP编程
服务器程序的工作过程包含以下四个基本的步骤:
调用 ServerSocket(int port)
创建一个服务器端套接字,并绑定到指定端口上。用于监听客户端的请求。
调用 accept()
监听连接请求,如果客户端请求连接,则接受连接,返回通信套接字对象。
调用 该Socket类对象的 getOutputStream() 和 getInputStream ()
获取输出流和输入流,开始网络数据的发送和接收。
关闭ServerSocket和Socket对象
客户端访问结束,关闭通信套接字。
服务器建立 ServerSocket 对象
ServerSocket 对象负责等待客户端请求建立套接字连接,类似邮局某个窗口中的业务员。也就是说,服务器必须事先建立一个等待客户请求建立套接字连接的ServerSocket对象。
所谓“接收”客户的套接字请求,就是accept()方法会返回一个 Socket 对象
ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept ();
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int num = in.read(buf);
String str = new String(buf,0,num);
System.out.println(s.getInetAddress().toString()+”:”+str);
s.close();
ss.close();
客户端—服务端
客户端:
自定义
浏览器
服务端:
自定义
Tomcat服务器
类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序。
UDP数据报通过数据报套接字 DatagramSocket 发送和接收,系统不保证UDP数据报一定能够安全送到目的地,也不能确定什么时候可以抵达。
DatagramPacket 对象封装了UDP数据报,在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
UDP协议中每个数据报都给出了完整的地址信息,因此无须建立发送方和接收方的连接
流 程:
DatagramSocket与DatagramPacket
建立发送端,接收端
建立数据包
调用Socket的发送、接收方法
关闭Socket
发送端与接收端是两个独立的运行程序
发送端
DatagramSocket ds = new DatagramSocket();
byte[] by = “hello,atguigu.com”.getBytes();
DatagramPacket dp = new DatagramPacket(by,0,by.length,
InetAddress.getByName(“127.0.0.1”),10000);
ds.send(dp);
ds.close();
接收端
在接收端,要指定监听的端口。
DatagramSocket ds = new DatagramSocket(10000);
byte[] by = new byte[1024];
DatagramPacket dp = new DatagramPacket(by,by.length);
ds.receive(dp);
String str = new String(dp.getData(),0,dp.getLength());
System.out.println(str+"--"+dp.getAddress());
ds.close();
URL编程
URL(Uniform Resource Locator):统一资源定位符,它表示 Internet 上某一资源的地址。通过 URL 我们可以访问 Internet 上的各种网络资源,比如最常见的 www,ftp 站点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源。
URL的基本结构由5部分组成:
<传输协议>://<主机名>:<端口号>/<文件名>
例如: http://192.168.1.100:8080/helloworld/index.jsp
http://127.0.0.1:8080/examples/hello.txt
为了表示URL,java.net 中实现了类 URL。我们可以通过下面的构造器来初始化一个 URL 对象:
public URL (String spec):
通过一个表示URL地址的字符串可以构造一个URL对象。例如:URL url = new URL ("http://www. atguigu.com/");
public URL(URL context, String spec):
通过基 URL 和相对 URL 构造一个 URL 对象。例如:URL downloadUrl = new URL(url, “download.html")
public URL(String protocol, String host, String file);
例如:new URL("http", "www.atguigu.com", “download. html");
public URL(String protocol, String host, int port, String file);
例如: URL gamelan = new URL("http", "www.atguigu.com", 80, “download.html");
类URL的构造方法都声明抛出非运行时异常,必须要对这一异常进行处理,通常是用 try-catch 语句进行捕获。
一个URL对象生成后,其属性是不能被改变的,但可以通过它给定的方法来获取这些属性:
public String getProtocol( ) 获取该URL的协议名
public String getHost( ) 获取该URL的主机名
public String getPort( ) 获取该URL的端口号
public String getPath( ) 获取该URL的文件路径
public String getFile( ) 获取该URL的文件名
public String getQuery( ) 获取该URL的查询名
例如
URL url = new URL("http://localhost:8080/examples/myTest.txt");
System.out.println("getProtocol() :"+url.getProtocol());
System.out.println("getHost() :"+url.getHost());
System.out.println("getPort() :"+url.getPort());
System.out.println("getPath() :"+url.getPath());
System.out.println("getFile() :"+url.getFile());
System.out.println("getQuery() :"+url.getQuery());
针对HTTP协议的URLConnection类
URL的方法 openStream():能从网络上读取数据
若希望输出数据,例如向服务器端的 CGI (公共网关接口-Common Gateway Interface-的简称,是用户浏览器和服务器端的应用程序进行连接的接口)程序发送一些数据,则必须先与URL建立连接,然后才能对其进行读写,此时需要使用 URLConnection 。
URLConnection:表示到URL所引用的远程对象的连接。当与一个URL建立连接时,首先要在一个 URL 对象上通过方法 openConnection() 生成对应的 URLConnection 对象。如果连接过程失败,将产生IOException.
URL netchinaren = new URL ("http://www.atguigu.com/index.shtml");
URLConnectonn u = netchinaren.openConnection( );
URLConnection类
通过URLConnection对象获取的输入流和输出流,即可以与现有的CGI程序进行交互。
public Object getContent( ) throws IOException
public int getContentLength( )
public String getContentType( )
public long getDate( )
public long getLastModified( )
public InputStream getInputStream( )throws IOException
public OutputSteram getOutputStream( )throws IOException
小 结
位于网络中的计算机具有唯一的IP地址,这样不同的主机可以互相区分。
客户端-服务器是一种最常见的网络应用程序模型。服务器是一个为其客户端提供某种特定服务的硬件或软件。客户机是一个用户应用程序,用于访问某台服务器提供的服务。端口号是对一个服务的访问场所,它用于区分同一物理计算机上的多个服务。套接字用于连接客户端和服务器,客户端和服务器之间的每个通信会话使用一个不同的套接字。TCP协议用于实现面向连接的会话。
Java 中有关网络方面的功能都定义在 java.net 程序包中。Java 用 InetAddress 对象表示 IP 地址,该对象里有两个字段:主机名(String) 和 IP 地址(int)。
类 Socket 和 ServerSocket 实现了基于TCP协议的客户端-服务器程序。Socket是客户端和服务器之间的一个连接,连接创建的细节被隐藏了。这个连接提供了一个安全的数据传输通道,这是因为 TCP 协议可以解决数据在传送过程中的丢失、损坏、重复、乱序以及网络拥挤等问题,它保证数据可靠的传送。
类 URL 和 URLConnection 提供了最高级网络应用。URL 的网络资源的位置来同一表示 Internet 上各种网络资源。通过URL对象可以创建当前应用程序和 URL 表示的网络资源之间的连接,这样当前程序就可以读取网络资源数据,或者把自己的数据传送到网络上去。
代码笔记
/**
- 此类用于演示InetAddress类的特点和使用
- getLocalHost()
- getByName(主机名或ip地址)
- getHostName()
- getHostAddress()
*/
public class TestInetAddress {
public static void main(String[] args) throws UnknownHostException {
//1.获取InetAddress类的对象
InetAddress ip1 = InetAddress.getLocalHost();//本机
System.out.println(ip1);
InetAddress ip2 = InetAddress.getByName("localhost");//根据主机名或ip地址获取InetAddress对象
System.out.println(ip2);
//2.获取InetAddress对象中的主机名或ip地址
System.out.println("主机名:"+ip1.getHostName());
System.out.println("ip地址:"+ip1.getHostAddress());
}
}
/**
- 此类用于演示基于TCP的网络通信
- @author liyuting
- 场景1:客户端向服务端发送一句话:hello,服务端接受并打印
*/
public class TestTCP1 {
//演示服务端
@Test
public void testServer() throws IOException {
//1.创建服务端套接字对象,同时指定端口号
ServerSocket ss = new ServerSocket(8888);
//2.接受客户端的连接请求
Socket socket = ss.accept();
//3.------------------读写数据------------------
//读取网络中传来的数据
//①获取读取数据的流对象
InputStream inputStream = socket.getInputStream();
//②通过流对象读取数据
byte[] b = new byte[1024];
int len;
while((len=inputStream.read(b))!=-1){
System.out.print(new String(b,0,len));
}
//4.关闭资源(连接资源和套接字资源)
inputStream.close();
socket.close();
ss.close();
}
//演示客户端
@Test
public void testClient() throws Exception{
//1.创建客户端套接字对象,同时指定服务端的ip和端口号,发送连接请求
Socket socket = new Socket(InetAddress.getLocalHost(),8888);
//2.-----------------读写数据------------------
//向服务端发送数据
//①获取写入数据的流对象
OutputStream outputStream = socket.getOutputStream();
//②通过outputStream写入数据
outputStream.write("hello,I am Client!".getBytes());
//3.关闭资源(流和套接字)
outputStream.close();
socket.close();
}
}
/**
- 此类用于演示基于TCP的网络通信
- @author liyuting
- 场景2:客户端向服务端发送一句话:hello,服务端接受并打印,然后回应一句话给客户端,客户端接受并打印
*/
public class TestTCP2 {
//演示服务端
@Test
public void testServer() throws IOException {
//1.创建服务端套接字对象,同时指定端口号
ServerSocket ss = new ServerSocket(8888);
//2.接受客户端的连接请求
Socket socket = ss.accept();
//3.------------------读写数据------------------
//读取网络中传来的数据
//①获取读取数据的流对象
InputStream inputStream = socket.getInputStream();
//②通过流对象读取数据
byte[] b = new byte[1024];
int len;
while((len=inputStream.read(b))!=-1){
System.out.print(new String(b,0,len));
}
//向客户端写入数据
//①获取写入数据的流对象
OutputStream outputStream = socket.getOutputStream();
//②通过流对象写入数据
outputStream.write("Hi,I am Server!".getBytes());
//③设置写入结束的标记
socket.shutdownOutput();
//4.关闭资源(连接资源和套接字资源)
outputStream.close();
inputStream.close();
socket.close();
ss.close();
}
//演示客户端
@Test
public void testClient() throws Exception{
//1.创建客户端套接字对象,同时指定服务端的ip和端口号,发送连接请求
Socket socket = new Socket(InetAddress.getLocalHost(),8888);
//2.-----------------读写数据------------------
//向服务端发送数据
//①获取写入数据的流对象
OutputStream outputStream = socket.getOutputStream();
//②通过outputStream写入数据
outputStream.write("hello,I am Client!".getBytes());
//③设置写入结束的标记(代表写入完毕)
socket.shutdownOutput();
//读取网络中发来的数据
//①获取读取数据的流对象
InputStream inputStream = socket.getInputStream();
//②循环读取
byte[] b = new byte[1024];
int len;
while((len=inputStream.read(b))!=-1){
System.out.println(new String(b,0,len));
}
//3.关闭资源(流和套接字)
inputStream.close();
outputStream.close();
socket.close();
}
}
/**
- 此类用于演示基于TCP的网络通信
- @author liyuting
- 场景3:客户端向服务端发送一句话:hello,服务端接受并打印,然后回应一句话给客户端,客户端接受并打印
- 进阶:使用包装流对节点流进行一层包装
- 细节注意:
- 因为网络中不像文件一样,到了末尾有个标记,值为-1
- 网络中写入结束,必须自己指定一个标记
- 方式一:单纯使用字节流,写入结束之后,添加socket.shutdownOutput();
- 方式二:如果读写的是纯文本,则可以使用缓冲流或打印流进行包装
-
1、缓冲流
-
writer.write();
-
writer.newLine();
-
writer.flush();
-
2、打印流
-
printer.println();
*/
public class TestTCP3 {
//演示服务端
@Test
public void testServer() throws IOException {
//1.创建服务端套接字对象,同时指定端口号
ServerSocket ss = new ServerSocket(8888);
//2.接受客户端的连接请求
Socket socket = ss.accept();
//3.------------------读写数据------------------
//读取网络中传来的数据
//①获取读取数据的流对象
InputStream inputStream = socket.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
//②读取数据
String line = reader.readLine();
System.out.println(line);
//向客户端写入数据
//②获取写入数据的流对象
OutputStream outputStream = socket.getOutputStream();//SocketOutputStream的流对象
//方式一:使用打印流
PrintStream writer = new PrintStream(outputStream);
writer.println("Hello,我是服务端!");
//方式二:使用缓冲流
// BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
// writer.write("Hello,我是服务端!");
// writer.newLine();
// writer.flush();
// //③设置写入结束的标记
// socket.shutdownOutput();
//4.关闭资源(连接资源和套接字资源)
writer.close();//SocketOutputStream.close();//h+关闭
reader.close();
socket.close();
ss.close();
}
//演示客户端
@Test
public void testClient() throws Exception{
//1.创建客户端套接字对象,同时指定服务端的ip和端口号,发送连接请求
Socket socket = new Socket(InetAddress.getLocalHost(),8888);
//2.-----------------读写数据------------------
//向服务端发送数据
//①获取写入数据的流对象
OutputStream outputStream = socket.getOutputStream();
//方式一:使用打印流
PrintStream writer = new PrintStream(outputStream);
writer.println("Hello,我是客户端!");
//方式二:使用缓冲流
// BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
// //②写入数据
// writer.write("Hello,我是客户端!");
// writer.newLine();
// writer.flush();
// //③设置写入结束的标记
// socket.shutdownOutput();
//读取网络中发来的数据
//①获取读取数据的流对象
InputStream inputStream = socket.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
//②循环读取
System.out.println(reader.readLine());
//3.关闭资源(流和套接字)
reader.close();
writer.close();
socket.close();
}
}
/**
-
此类用于演示基于TCP协议的网络通信
-
@author liyuting
-
场景4:客户端向服务端发送一张图片,服务端接受保存到本地,然后向客户端回应:照片不错呦!
*/public class TestTCP4 { //服务端 /* * 1.读取网络中的图片(读) * 2.将读取到的图片写入到本地(写) * 3.向客户端发送数据(写) */ @Test public void testServer() throws IOException { //1.创建服务端套接字对象 ServerSocket ss = new ServerSocket(9999); //2.接受连接请求 Socket socket = ss.accept(); //3.----------------------读写----------------------- //3-1.读取网络中的图片(读) &将读取到的图片写入到本地(写) //①创建读取和写入流对象 BufferedInputStream bis = new BufferedInputStream(socket.getInputStream()); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src\\copy.jpg")); //②读取数据&写入到本地 byte[] b=new byte[1024]; int len; while((len=bis.read(b))!=-1){ bos.write(b, 0, len); } //3-2 向客户端发送数据(写) //①创建写入的流对象 PrintStream printer= new PrintStream(socket.getOutputStream()); //②写入 printer.println("照片不错呦,再来一张~"); //4.关闭 printer.close(); bos.close(); bis.close(); socket.close(); ss.close(); } //客户端 /* * 1.从本地读取图片(读) * 2.向服务端发送图片(写 * 3.接受服务端发来的文本数据(读) */ @Test public void testClient() throws IOException { //1.创建客户端套接字对象 Socket socket =new Socket(InetAddress.getLocalHost(),9999); //2.读写数据 //2-1 .将本地图片读取,然后再写入到网络中(复制图片) //①获取流对象 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\beauty\\rb.jpg")); OutputStream bos = socket.getOutputStream(); //②边读边写 byte[] b=new byte[1024]; int len; while((len=bis.read(b))!=-1){ bos.write(b, 0, len); } socket.shutdownOutput(); //2-2.读取服务端发来的文本 BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream())); System.out.println(reader.readLine()); //3.关闭 reader.close(); bos.close(); bis.close(); socket.close(); } }
/**
- 此类用于演示基于TCP协议的网络通信
- @author liyuting
- 场景4:客户端向服务端发送一张图片,服务端接受保存到本地,然后向客户端回应:照片不错呦!
*/
public class TestTCP5 {
//服务端
/*
* 1.读取网络中的图片(读)
* 2.将读取到的图片写入到本地(写)
* 3.向客户端发送数据(写)
*/
@Test
public void testServer() throws IOException {
//1.创建服务端套接字对象
ServerSocket ss = new ServerSocket(9999);
//2.接受连接请求
Socket socket = ss.accept();
//3.----------------------读写-----------------------
//3-1.读取网络中的图片(读) &将读取到的图片写入到本地(写)
InputStream inputStream = socket.getInputStream();
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src\\beauty.jpg"));
bos.write(NetWork.day24.utils.StreamUtils.streamToByteArray(inputStream));
//3-2 向客户端发送数据(写)
//①创建写入的流对象
PrintStream printer= new PrintStream(socket.getOutputStream());
//②写入
printer.println("照片不错呦,再来一张~");
//4.关闭
printer.close();
bos.close();
inputStream.close();
socket.close();
ss.close();
}
//客户端
/*
* 1.从本地读取图片(读)
* 2.向服务端发送图片(写
* 3.接受服务端发来的文本数据(读)
*/
@Test
public void testClient() throws IOException {
//1.创建客户端套接字对象
Socket socket =new Socket(InetAddress.getLocalHost(),9999);
//2.读写数据
//2-1 .将本地图片读取,然后再写入到网络中(复制图片)
//①获取流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\beauty\\rb.jpg"));
OutputStream bos = socket.getOutputStream();
//②边读边写
byte[] b=new byte[1024];
int len;
while((len=bis.read(b))!=-1){
bos.write(b, 0, len);
}
socket.shutdownOutput();
//2-2.读取服务端发来的文本
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(reader.readLine());
//3.关闭
reader.close();
bos.close();
bis.close();
socket.close();
}
}
/**
- 此类用于演示基于UDP的网络通信
- @author liyuting
*/
public class TestUDP {
// 发送端
@Test
public void testSend() throws IOException {
//1.创建DatagramSocket套接字对象
DatagramSocket socket = new DatagramSocket(7777);
//-------------------------发送数据-------------------------------------
//①.创建DatagramPacket对象,用于包装要发送的数据
byte[] buf="嗨,我是土豆".getBytes();
DatagramPacket packet = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),6666);
//②.发送
socket.send(packet);
//-------------------------接收数据-------------------------------------
//①.创建DatagramPacket对象,用于接受要发来的数据
byte[] buf2 = new byte[1024];
DatagramPacket packet2 = new DatagramPacket(buf2 , buf2.length);
//②.接受数据并处理
socket.receive(packet2);
String data = new String(packet2.getData(),0,packet2.getLength());
System.out.println(data);
//4.关闭
socket.close();
}
// 接受端
@Test
public void testReceive() throws IOException {
//1.创建DatagramSocket套接字对象
DatagramSocket socket = new DatagramSocket(6666);
//-------------------------接收数据-------------------------------------
//①.创建DatagramPacket对象,用于接受要发来的数据
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf , buf.length);
//②.接受数据并处理
socket.receive(packet);
String data = new String(packet.getData(),0,packet.getLength());
System.out.println(data);
//-------------------------发送数据-------------------------------------
//①.创建DatagramPacket对象,用于包装要发送的数据
byte[] buf2="嗨,我是地瓜".getBytes();
DatagramPacket packet2 = new DatagramPacket(buf2,buf2.length,InetAddress.getLocalHost(),7777);
//②.发送
socket.send(packet2);
//4.关闭
socket.close();
}
}
/**
-
此类用于演示基于URL的网络通信
-
请先安装好Tomcat并启动,创建好文件夹
*/public class TestURL { //测试URL的特点和使用 @Test public void test1() throws MalformedURLException { //1.创建URL对象 URL url = new URL("http://192.168.26.60:8080/cang.jpg?name=john"); //2.调用方法,获取url的各部分 System.out.println(url.getProtocol()); System.out.println(url.getHost()); System.out.println(url.getPort()); System.out.println(url.getPath()); System.out.println(url.getFile()); } //测试基于URL的网络通信——下载url指定的资源 @Test public void test2() throws IOException { //1.创建url对象 URL url = new URL("http://192.168.26.60:8080/cang.jpg"); //2.打开连接 URLConnection connection = url.openConnection(); //3.读数据(下载) InputStream inputStream = connection.getInputStream(); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src\\cang.jpg")); //边读边写 bos.write(NetWork.day24.utils.StreamUtils.streamToByteArray(inputStream)); //4.关闭 bos.close(); inputStream.close(); } }