一、网络通信协议
1、InetAddress类
InetAddress
类没有提供公共的构造器,而是提供了如下几个静态方法来获取
InetAddress
实例
>public static InetAddress getLocalHost()
>public static InetAddress getByName(String host)
InetAddress
提供了如下几个常用的方法
>public String getHostAddress()
:
返回
IP
地址字符串(以文本表现形式)。
>public String getHostName():
获取此
IP
地址的主机名
>public boolean isReachable(int timeout):
测试是否可以达到该地址
2、Socket
端口分类:
公认端口:
0~1023
。被预先定义的服务通信占用(如:
HTTP
占用端口80,
FTP
占用端口
21
,
Telnet
占用端口
23
)
注册端口:
1024~49151
。分配给用户进程或应用程序。(如:
Tomcat
占用端口8080
,
MySQL
占用端口
3306
,
Oracle
占用端口
1521
等)。
动态
/
私有端口:
49152~65535
。
>网络上具有唯一标识的
IP
地址和端口号组合在一起才能构成唯一能识别的标识符套接字。
Socket
分类:
>
流套接字(
stream socket
):使用
TCP
提供可依赖的字节流服务
>数据报套接字(
datagram socket
):使用
UDP
提供“尽力而为”的数据报服务
Socket
类的常用构造器:
>public Socket(InetAddress address,int port)
创建一个流套接字并将其连接到指定
IP
地址的指定端口号。
>
public Socket(String host,int port)
创建一个流套接字并将其连接到指定主机上的指定端口号。
Socket
类的常用方法:
public InputStream getInputStream()
返回此套接字的输入流。可以用于接收网络消息
public OutputStream getOutputStream()
返回此套接字的输出流。可以用于发送网络消息
public InetAddress getInetAddress()
此套接字连接到的远程
IP
地址;如果套接字是未连接的,则返回
null
。
public InetAddress getLocalAddress()
获取套接字绑定的本地地址。 即本端的
IP
地址
public int getPort()
此套接字连接到的远程端口号;如果尚未连接套接字,则返回
0
。
public int getLocalPort()
返回此套接字绑定到的本地端口。 如果尚未绑定套接字,则返回
-1
。即本端的端口号。
public void close()
关闭此套接字。套接字被关闭后,便不可在以后的网络连接中使用(即无法重新连接或重新绑定)。需要创建新的套接字对象。 关闭此套接字也将会关闭该套接字的 InputStream
和OutputStream。
public void shutdownInput()
如果在套接字上调用
shutdownInput()
后从套接字输入流读取内容,则流将返回 EOF
(文件结束符)。 即不能在从此套接字的输入流中接收任何数据。
public void shutdownOutput()
禁用此套接字的输出流。对于
TCP
套接字,任何以前写入的数据都将被发送,并且后跟 TCP
的正常连接终止序列。 如果在套接字上调用
shutdownOutput()
后写入套接字输出流,则该流将抛出 IOException
。 即不能通过此套接字的输出流发送任何数据。
二、tcp网络编程
![](https://i-blog.csdnimg.cn/blog_migrate/52e2b4d145bab4d1dce78291ffa5ce29.png)
基于
Socket
的
TCP
编程
客户端
Socket
的工作过程包含以下四个基本的步骤
:
1)
创建
Socket
:
根据指定服务端的
IP
地址或端口号构造
Socket
类对象。若服务器端响应,则建立客户端到服务器的通信线路。若连接失败,会出现异常。
2)
打开连接到
Socket
的输入
/
出流:
使用
getInputStream()
方法获得输入流,使用getOutputStream()方法获得输出流,进行数据传输
3)
按照一定的协议对
Socket
进行读
/
写操作:
通过输入流读取服务器放入线路的信息 (但不能读取自己放入线路的信息),通过输出流将信息写入线程。
4)
关闭
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
编程
服务器程序的工作过程包含以下四个基本的步骤:
1)
调用
ServerSocket(int port)
:
创建一个服务器端套接字,并绑定到指定端口上。用于监听客户端的请求。
2)
调用
accept()
:
监听连接请求,如果客户端请求连接,则接受连接,返回通信套接字对象。
3)
调用 该
Socket
类对象的
getOutputStream()
和
getInputStream ()
:
获取输出流和输入流,开始网络数据的发送和接收。
4)
关闭
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();
public class TCPTest2 {
@Test
public void client() {
Socket socket = null;
OutputStream os = null;
FileInputStream fis = null;
InputStream is = null;
ByteArrayOutputStream baos = null;
try {
socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
os = socket.getOutputStream();
fis = new FileInputStream(new File("WX20210930-145733@2x.png"));
byte[] buffer = new byte[1024];
int len;
while((len=fis.read(buffer)) != -1) {
os.write(buffer, 0, len);
}
socket.shutdownOutput();
is = socket.getInputStream();
baos = new ByteArrayOutputStream();
byte[] buffer1 = new byte[20];
int len1;
while((len1=is.read(buffer1)) != -1) {
baos.write(buffer1, 0, len1);
}
System.out.println(baos);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(os != null) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(baos != null) {
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void server(){
ServerSocket ss = null;
Socket socket = null;
InputStream is = null;
FileOutputStream fos = null;
OutputStream os = null;
try {
ss = new ServerSocket(9090);
socket = ss.accept();
is = socket.getInputStream();
fos = new FileOutputStream(new File("1.png"));
byte[] buffer = new byte[1024];
int len;
while((len=is.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
os = socket.getOutputStream();
os.write("我是服务器,已收到数据".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null) {
try {
fos.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(ss != null) {
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(os != null) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
//应该使用try-catch-finally
@Test
public void client() throws IOException {
//1.
InetAddress inet = InetAddress.getByName("127.0.0.1");
//2.
Socket socket = new Socket(inet, 8899);
//3.
OutputStream os = socket.getOutputStream();
os.write("您好,我是客户端,请在服务器端输出我".getBytes());
//注意点
socket.shutdownOutput();
InputStream is = socket.getInputStream();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] bytes = new byte[20];
int len;
while((len = is.read(bytes)) != -1) {
baos.write(bytes, 0, len);
}
System.out.println(baos.toString());
baos.close();
is.close();
os.close();
socket.close();
}
//应该使用try-catch-finally
@Test
public void server() throws IOException {
//1.
ServerSocket serverSocket = new ServerSocket(8899);
//2.
Socket socket = serverSocket.accept();
//3.
InputStream is = socket.getInputStream();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] bytes = new byte[20];
int len;
while((len = is.read(bytes)) != -1) {
baos.write(bytes, 0, len);
}
System.out.println(baos.toString());
OutputStream os = socket.getOutputStream();
os.write("我是服务器,收到你的信息".getBytes());
baos.close();
os.close();
is.close();
socket.close();
serverSocket.close();
}
三、UDP网络通信
>
类
DatagramSocket
和
DatagramPacket
实现了基于
UDP
协议网络程序。
>UDP
数据报通过数据报套接字
DatagramSocket
发送和接收,
系统不保证UDP数据报一定能够安全送到目的地,也不能确定什么时候可以抵达。
>
DatagramPacket
对象封装了
UDP
数据报,在数据报中包含了发送端的
IP地址和端口号以及接收端的IP
地址和端口号。
>
UDP
协议中
每个数据报都给出了完整的地址信息,因此无须建立发送方和接收方的连接。如同发快递包裹一样。
1、DatagramSocket 类的常用方法
>
public DatagramSocket(int port)
创建数据报套接字并将其绑定到本地主机上的指定端口。套接字将被绑定到通配符地址,IP
地址由内核来选择。
>
public DatagramSocket(int port,InetAddress laddr)
创建数据报套接字,将其绑定到指定的本地地址。本地端口必须在 0
到
65535
之间(包括两者)。如果
IP
地址为
0.0.0.0
,套接字将被绑定到通配符地址,IP
地址由内核选择。
>public void close()
关闭此数据报套接字。
>public void send(DatagramPacket p)
从此套接字发送数据报包。
DatagramPacket
包含的信息指示:将要发送的数据、其长度、远程主机的 IP
地址和远程主机的端口号。
>public void receive(DatagramPacket p)
从此套接字接收数据报包。当此方法返回时,
DatagramPacket的缓冲区填充了接收的数据。数据报包也包含发送方的 IP
地址和发送方机器上的端口号。 此方法在接收到数据报前一直阻塞。数据报包对象的 length
字段包含所接收信息的长度。如果信息比包的长度长,该信息将被截短。
>public InetAddress getLocalAddress()
获取套接字绑定的本地地址。
>public int getLocalPort()
返回此套接字绑定的本地主机上的端口号。
>public InetAddress getInetAddress()
返回此套接字连接的地址。如果套接字未连接,则返回
null
。
>public int getPort()
返回此套接字的端口。如果套接字未连接,则返回
-1
。
2、DatagramPacket类的常用方法
>
public DatagramPacket(byte[] buf,int length)
构造
DatagramPacket
,用来接收长度为 length
的数据包。
length
参数必须小于等于
buf.length
。
>
public DatagramPacket(byte[] buf,int length,InetAddress address,int port)
构造数据报包,用来将长度为 length
的包发送到指定主机上的指定端口号。
length参数必须小于等于 buf.length
。
>
public InetAddress getAddress()
返回某台机器的
IP
地址,此数据报将要发往该机器或者是从该机器接收到的。
>
public int getPort()
返回某台远程主机的端口号,此数据报将要发往该主机或者是从该主机接收到的。
>
public byte[]
getData()
返回数据缓冲区。接收到的或将要发送的数据从缓冲区中的偏移量 offset
处开始,持续
length
长度。
>
public int
getLength()
返回将要发送或接收到的数据的长度。
3、UDP网络通信流程:
1). DatagramSocket
与
DatagramPacket
2).
建立发送端,接收端
3).
建立数据包
4).
调用
Socket
的发送、接收方法
5).
关闭
Socket
发送端与接收端是两个独立的运行程序
@Test
public void sender() throws IOException {
DatagramSocket socket = new DatagramSocket();
String str = "我是UDP的发送端";
byte[] data = str.getBytes();
InetAddress inet = InetAddress.getLocalHost();
DatagramPacket packet = new DatagramPacket(data, 0, data.length, inet, 9900);
socket.send(packet);
socket.close();
}
@Test
public void receiver() throws IOException {
DatagramSocket socket = new DatagramSocket(9900);
byte[] buffer = new byte[1024];//要设置足够长度
DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
socket.receive(packet);
String str = new String(packet.getData(), 0, packet.getLength());
System.out.println(str);
socket.close();
}
四、URL编程
1、URL类
>
URL(Uniform Resource Locator)
:统一资源定位符,它表示
Internet
上
某一
资源
的地址。
>
它是一种具体的
URI
,即
URL
可以用来标识一个资源,而且还指明了如何
locate这个资源。
>
通过
URL
我们可以访问
Internet
上的各种网络资源,比如最常见的
www
,
ftp站点。浏览器通过解析给定的 URL
可以在网络上查找相应的文件或其他资源。
>
URL
的基本结构由
5
部分组成:
<
传输协议
>://<
主机名
>:<
端口号
>/<
文件名
>#
片段名
?
参数列表
2、URL类构造器
>
为了表示
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
语句进行捕获。
3、URL类的常用方法
一个
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
的查询名
4、针对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
对象获取的输入流和输出流,即可以与现有的
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
public static void main(String[] args) {
HttpURLConnection urlConnection = null;
InputStream is = null;
FileOutputStream fos = null;
try {
URL url = new URL("http://localhost:8080/examples/beauty.jpg");
urlConnection = (HttpURLConnection) url.openConnection();
urlConnection.connect();
is = urlConnection.getInputStream();
fos = new FileOutputStream("day10\\beauty3.jpg");
byte[] buffer = new byte[1024];
int len;
while((len = is.read(buffer)) != -1){
fos.write(buffer,0,len);
}
System.out.println("下载完成");
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭资源
if(is != null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(urlConnection != null){
urlConnection.disconnect();
}
}