Java基础--网络编程01
网络编程
网络参考模型
IP地址InetAddress
- 网络中设备的标识；
- 不易记忆，可用主机名；
- 本地回环地址：127.0.0.1；主机名：localhost；
- 端口号：
- 用于标识进程的逻辑地址，不同进程的标识；
- 有效端口：0~65535，其中0~1024系统使用或保留端口；
- 传输协议：
通讯规则，常见协议：TCP,UDP;
InetAddress
- 已知子类：Inet4Address,Inet6Address;此类表示互联网协议（IP）地址；
- 该类没有构造函数，不可通过new创建对象，只能使用方法返回一个InetAddress对象；
- 常用方法：
- getByAddress(String host,byte[] addr)根据提供的主机名IP地址创建InetAddress；host-指定主机，addr-网络字节顺序的原始IP地址；
- getByName(String host);根据给定主机名返回IP地址；host-指定主机（可以是IP，可以是网址）；
- getHostAddress()；返回IP地址字符串；
- getHostName()；获取此IP地址的主机名；
- getLocalHost()；返回本地主机；
- toString()；将此IP地址转换为String；
- hashCode()；返回此IP地址的哈希值；
- getAllByName(String host);根据给定主机名，返回其IP地址所组成的数组；
import java.net.*;
class IPDemo{
public static void main(String[] args) throws Exception{
//InetAddress i = InetAddress.getLocalHost();
// System.out.println(i.toString());
// System.out.println("address:"+i.getHostAddress());
// System.out.println("name:"+i.getHostName());
InetAddress ia = InetAddress.getByName("thinkpad-sl400");
System.out.println("address:"+ia.getHostAddress());
System.out.println("name:"+ia.getHostName());
}
}
TCP和UDP
UDP
- 将数据及源和目的封装在数据包中，不需要建立连接；
- 每个数据包的大小限定在64k内；
- 因为无连接，是不可靠协议；
- 不需要建立连接，速度快；
TCP
- 建立连接，形成传输数据的通道；
- 在连接中进行大数据传输；
- 通过三次握手完成连接，是可靠协议；
- 必须建立连接，效率会稍低；
Socket
- Socket就是为网络服务提供的一种机制；
- 通信的两端都有Socket；
- 网络通信其实就是Socket间的通信；
- 数据在两个Socket间通过IO传输；
UDP传输
- 每个传输协议都有自己不同的建立端点的方式；
- UDP的Socket服务特有传输方式对应的对象：
- 建立UDP Socket服务：
DatagramSocket与DatagramPacket
- 建立发送端，接收端。
- 建立数据包。
- 调用Socket的发送接收方法。
- 关闭Socket。
发送端与接收端是两个独立的运行程序。
DatagramSocket
- 此类表示用来发送和接收数据报包的套接字；
构造方法：
- DatagramSocket()；构造函数数据报套接字将其绑定到本机上的任何可用端口；
- DatagramSocket(int port);将其绑定到本地主机上的指定端口；
- DatagramSocket(int port,InetAddress laddr);指定的本地地址；port-要使用的本地端口，laddr-要绑定的本地地址；
- DatagramSocket(SocketAddress bindaddr)~指定的本地套接字地址；
常用方法：
- close();关闭资源；
- receive（DatagramPacket p）从套接字接收数据包；
- send(DatagramPacket p)从套接字发送数据包；
DatagramPacket
- 此类表示数据报包，数据用来实现无连接包投递服务；
构造方法：
- DatagramPacket(byte[] b,int length,InetAddress address, int port)；构造函数报包，用来将长度为length的包发送到指定主机上的指定端口号；（用于发送）
- DatagramPacket(byte[] buf,int offset,int length,InetAddress address ,int port );用来将长度为length偏移量的为offset的包发送到指定主机上的指定端口号；（用于发送）
- DatagramPacket(byte[] buf,int length);用来接收长度为length的数据包；（接收）
- DatagramPacket(byte[] buf,int offset,int length);用于接收
常用方法：
- getAddress()；返回某台机器的IP，要发往该机器或从该机器接收到的；
- getData()；返回数据缓冲区，（接收到的数据）
- getLength()；返回要发送或接收到的数据长度；
- getPort()；返回某台远程主机的端口号，此数据将要发往该主机或从该主机接收到的；
import java.net.*;
/*
需求：通过udp传输方式，将一段文字数据发送出去。，
定义一个udp发送端。
思路：
1，建立updsocket服务。
2，提供数据，并将数据封装到数据包中。
3，通过socket服务的发送功能，将数据包发出去。
4，关闭资源。
*/
class UdpSend{
public static void main(String[] args) throws Exception{
//1，创建udp服务。通过DatagramSocket对象。
DatagramSocket ds = new DatagramSocket(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的接收端。
思路：
1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。
方便于明确哪些数据过来该应用程序可以处理。
2，定义一个数据包，因为要存储接收到的字节数据。
因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
3，通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
4，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
5，关闭资源。
*/
class UdpRece{
public static void main(String[] args) throws Exception{
//1,创建udp socket，建立端点。
DatagramSocket ds = new DatagramSocket(10000);
while(true){
//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();
}
}
UDP数据的发送与接收
定义一个发送端：
- 创建UDP服务，通过DatagramSocket对象；
- 确定数据，并封装成数据包；
DatagramPacket(byte[] buf,int length,InetAddress address,int port);将数据源转换成byte[]传入UDP； - 通过Socket服务，将已有的数据包发送出去，通过send方法；
- 关闭资源；
定义一个UDP接收端；
- 创建UDP Socket服务，建立端点，通常会监听一个端口；
- 定义数据包，用于存储数据，数据包对象中有更多功能可以提取字节数据中的不同数据信息；
- 通过Socket服务的receive方法将接收到的数据存入定义好的数据包中；
- 通过数据包对象的特有功能，将这些不同的数据取出；
- 关闭资源；
import java.io.*;
import java.net.*;
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();
}
}
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();
}
}
TCP传输
- Socket和ServerSocket
- 建立客户端和服务器端；
- 建立连接后，通过Socket中的IO流进行数据的传输；
- 关闭Socket；
- 同样，客户端与服务器端是两个独立的应用程序；
Socket
- 此类实现客户端套接字，套接字是两台机器间通信的端点；
常用构造函数：
- Socket()；空参数时用connect方法连接；
- Socket(InetAddress address，int port)；
- Socket(String host，int port)；
- Socket(InetAddress address ,int port ,InetAddress localAddr,int localPort);
常用方法：
- getInetAddress();返回此套接字连接的地址；
- getInputStream();返回此套接字的输入法；
- getLocalAddress()；获取套接字绑定的本地地址；
- getLocalPort()；
- getOutputStream()；返回此套接字的输出流；
- getPort()；返回此套接字连接到的远程端口；
- shutdownInput()；
- shutdownOutput()；关闭客户端的输出流，相当于给流中加入一个结束标记(一般用于上传文件接收后，给服务端的readLine发送一个结束标记，以示文件传送玩读取结束);
- connect(SocketAddress endpoint)将套接字连接到服务器用于空参数的套接字连接；（注：SocketAddress 的子类InetSocketAddress封装了IP地址和端口）
ServerSocket
- 此类实现服务器套接字，服务器套接字等待请求通过网络传入；
构造方法：
- serverSocket();
- serverSocket(int port)；创建绑定到特定端口的服务器套接字；
- ServerSocket(int port，int backlog)；
- serverSocket(int port，int backlog，InetAddress binAddr)；backlog：队列的最大长度，即：能连接到服务器的客户端最大的同时在线个数；
常用方法：
- close()；关闭资源；
- accept();侦听并接受此套接字的连接；
- getInetAddress();返回此服务器套接字的本地地址；
import java.io.*;
import java.net.*;
/*
演示tcp的传输的客户端和服务端的互访。
需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。
*/
/*
客户端：
1，建立socket服务。指定要连接主机和端口。
2，获取socket流中的输出流。将数据写到该流中。通过网络发送给服务端。
3，获取socket流中的输入流，将服务端反馈的数据获取到，并打印。
4，关闭客户端资源。
*/
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();
}
}
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();
}
}
/*
需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。
而且客户度可以不断的进行文本转换。当客户端输入over时，转换结束。
分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入。
目的：网络设备，网络输出流。
而且操作的是文本数据。可以选择字符流。
步骤
1，建立服务。
2，获取键盘录入。
3，将数据发给服务端。
4，后去服务端返回的大写数据。
5，结束，关资源。
都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。
*/
import java.io.*;
import java.net.*;
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();
}
}
/*
服务端：
源：socket读取流。
目的：socket输出流。
都是文本，装饰。
*/
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();
}
}/*
编写一个聊天程序。
有收数据的部分，和发数据的部分。
这两部分需要同时执行。
那就需要用到多线程技术。
一个线程控制收，一个线程控制发。
因为收和发动作是不一致的，所以要定义两个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){
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();
}
}