网络编程实现
网络编程实现
InetAddress
/*
* 没有可调用的构造方法，使用静态方法返回对象
* */
import java.net.InetAddress;
import java.net.UnknownHostException;
public class Address {
public static void main(String[] args) throws UnknownHostException {
// 创建InetAddress对象
// static InetAddress getByName(String host) 确定主机名称的IP地址。
InetAddress addresses = InetAddress.getByName("127.0.0.1");
/*
* 常用方法
* String getHostAddress() 返回文本显示中的IP地址字符串。
* String getHostName() 获取此IP地址的主机名。
* */
System.out.println(addresses.getHostAddress());
System.out.println(addresses.getHostName());
}
}
UDP收发数据
利用UDP发送数据
/*
* UDP协议发送数据
*
* 发送数据的步骤：
* 创建发送端的Socket对象(DatagramSocket)
* 创建数据，并把数据打包
* 调用DatagramSocket对象的方法发送数据
* 关闭发送端
* */
import java.io.IOException;
import java.net.*;
public class Send {
public static void main(String[] args) throws IOException {
// 创建发送端的Socket对象(DatagramSocket)
// DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口。
DatagramSocket ds = new DatagramSocket();
// 创建数据
byte[] bytes = "hello,java,net,UDP".getBytes();
// 并把数据打包
// public final class DatagramPacket extends Object 该类表示数据报包。
// DatagramPacket(byte[] buf, int length, InetAddress address, int port) 构造用于发送长度的分组的数据报包 length指定主机上到指定的端口号。
DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("127.0.0.1"), 8080);
// 调用DatagramSocket对象的方法发送数据
ds.send(dp);
// 关闭发送端
ds.close();
}
}
利用UDP接收数据
/*
* UDP接收
*
* 接收数据的步骤：
* 创建接收端的Socket对象(DatagramSocket)
* 创建一个数据包，用于接收数据
* 调用DatagramSocket对象的方法接收数据
* 解析数据包，并把数据在控制台显示
* 关闭接收端
* */
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Receive {
public static void main(String[] args) throws IOException {
// 创建接收端的Socket对象(DatagramSocket)
// 这次使用有参构造
// DatagramSocket(int port) 构造数据报套接字并将其绑定到本地主机上的指定端口。
DatagramSocket ds = new DatagramSocket(8080);
// 定义长度为1024的数据
byte[] bytes = new byte[1024];
// 创建一个数据包，用于接收数据
// DatagramPacket(byte[] buf, int length) 构造一个 DatagramPacket用于接收长度的数据包 length 。
DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
// 调用DatagramSocket对象的方法接收数据
ds.receive(dp);
// 解析数据包，并把数据在控制台显示
byte[] data = dp.getData();
String s = new String(data,0, dp.getLength());
System.out.println(s);
// 关闭接收端
ds.close();
}
}
实训练习
需求：
按照下面的要求实现程序
UDP发送数据:数据来自于键盘录入，直到输入的数据是886，发送数据结束
UDP接收数据:因为接收端不知道发送端什么时候停止发送，故采用死循环接收
发送端：
/*
* 发送端
*
* 数据来自于键盘录入，直到输入的数据是886，发送数据结束
* */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class Send {
public static void main(String[] args) throws IOException {
// 利用打印流获取键盘输入
// 也可使用Scanner类
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;
while ((line = br.readLine()) != null) {
// 判断输入的数据是886，发送数据结束
if (line.equals("886")) {
System.exit(0);
}
// 实例化一个发送数据报数据包的套接字对象
DatagramSocket ds = new DatagramSocket();
// 将输入字符串转换为字节数组
byte[] bytes = line.getBytes();
// 实例化数据包
DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("127.0.0.1"), 8080);
// 发送数据包
ds.send(dp);
// 关闭资源
ds.close();
}
}
}
接收端
/*
* 接收端
*
* 因为接收端不知道发送端什么时候停止发送，故采用死循环接收
* */
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Receive {
public static void main(String[] args) throws IOException {
// 死循环接收
while (true){
// 实例化一个接收数据报数据包的套接字对象
DatagramSocket ds = new DatagramSocket(8080);
// 定义一个空数据
byte[] bytes = new byte[1024];
// 实例化一个数据包
DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
// 接收数据
ds.receive(dp);
// 解析数据包
byte[] data = dp.getData();
// 打印
String s = new String(data,0,dp.getLength());
System.out.println(s);
// 关闭接收端
ds.close();
}
}
}
TCP收发数据
利用TCP发送数据
/*
* TCP客户端
*
* 发送数据的步骤：
* 创建客户端的Socket对象(Socket)
* 获取输出流,写数据
* 释放资源
* */
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class Send {
public static void main(String[] args) throws IOException {
// 创建客户端的Socket对象(Socket)
// Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号。
Socket socket = new Socket("127.0.0.1", 8080);
// 获取输出流,写数据
// getOutputStream() 返回此套接字的输出流。
OutputStream os = socket.getOutputStream();
os.write("hello,java,tcp".getBytes());
// 释放资源
os.close();
socket.close();
}
}
利用TCP接收数据
/*
* TCP服务器
*
* 接收数据的步骤:
* 创建服务器端的Socket对象(ServerSocket)
* 获取输入流，读数据，并把数据显示在控制台
* 释放资源
* */
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Receive {
public static void main(String[] args) throws IOException {
// 创建服务器端的Socket对象(ServerSocket)
ServerSocket ss = new ServerSocket(8080);
// 监听客户端连接
Socket accept = ss.accept();
// 获取输入流，读数据，
InputStream is = accept.getInputStream();
byte[] bytes = new byte[1024];
int length;
while ((length = is.read(bytes)) != -1){
// 并把数据显示在控制台
System.out.println(new String(bytes,0,length));
}
// 释放资源
is.close();
accept.close();
ss.close();
}
}
TCP接收服务器反馈
客户端代码：
/*
* TCP客户端
* */
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class Send {
public static void main(String[] args) throws IOException {
// 创建客户端的Socket对象(Socket)
// Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号。
Socket socket = new Socket("127.0.0.1", 8080);
// 获取输出流,写数据
// getOutputStream() 返回此套接字的输出流。
OutputStream os = socket.getOutputStream();
os.write("hello,java,tcp".getBytes());
// 获取反馈
InputStream is = socket.getInputStream();
// 读数据
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println("客户端收到：" + new String(bytes,0,len));
// 释放资源
socket.close();
}
}
服务器代码：
/*
* TCP服务器
* */
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Receive {
public static void main(String[] args) throws IOException {
// 创建服务器端的Socket对象(ServerSocket)
ServerSocket ss = new ServerSocket(8080);
// 监听客户端连接
Socket accept = ss.accept();
// 获取输入流，读数据，
InputStream is = accept.getInputStream();
byte[] bytes = new byte[1024];
int length = is.read(bytes);
// 并把数据显示在控制台
System.out.println("服务器收到：" + new String(bytes, 0, length));
// 获取输出流写数据
OutputStream os = accept.getOutputStream();
os.write("收到了".getBytes());
// 释放资源
accept.close();
}
}
TCP键盘输入传递实训
客户端代码
/*
* 客户端
*
* 键盘输入
* 和UDP案例需求一样
* */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
public class Client {
public static void main(String[] args) throws IOException {
// 实例化一个Socket
Socket client = new Socket("127.0.0.1", 8080);
// 解析出OutputStream
OutputStream output = client.getOutputStream();
System.out.println("请输入：");
// 用键盘接收
BufferedReader keyboard = new BufferedReader(new InputStreamReader(System.in));
String line;
while (!(line = keyboard.readLine()).equals("886")) {
// 写入
output.write(line.getBytes());
}
// 关闭资源
keyboard.close();
client.close();
}
}
服务器代码
/*
* 服务器
* */
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) throws IOException {
// 实例化一个ServerSocket
ServerSocket server = new ServerSocket(8080);
// 实现通讯
Socket accept = server.accept();
// 解析出InputStream
InputStream input = accept.getInputStream();
// 读取
byte[] bytes = new byte[1024];
int len;
while ((len = input.read(bytes)) != -1) {
String data = new String(bytes, 0, len);
System.out.println("收到客户端发来：" + data);
}
// 关闭资源
server.close();
}
}
TCP键盘输入传递，服务器写入文件实训
客户端不变
服务器代码：
/*
* 服务器
* */
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) throws IOException {
// 实例化一个ServerSocket
ServerSocket server = new ServerSocket(8080);
// 实现通讯
Socket accept = server.accept();
// 解析出InputStream
InputStream input = accept.getInputStream();
// 定义一个字节缓存输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\MYcode_K\\java_K\\javaNet\\src\\com\\net\\tcp\\toFile\\java.txt"));
// 读取
byte[] bytes = new byte[1024];
int len;
while ((len = input.read(bytes)) != -1) {
// 写入文件
bos.write(bytes,0,len);
bos.write("\r\n".getBytes());
}
// 关闭资源
bos.close();
server.close();
}
}
客户端输入来自文件，服务器写入文本
服务器代码如上
客户端代码：
/*
* 客户端
* */
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
public class Client {
public static void main(String[] args) throws IOException {
// 实例化一个Socket
Socket client = new Socket("127.0.0.1", 8080);
// 解析出输出流
OutputStream os = client.getOutputStream();
// 定义一个数据文件的输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\MYcode_K\\java_K\\javaNet\\src\\com\\net\\tcp\\fromFile\\fromData.txt"));
// 读取数据
byte[] bytes = new byte[1024];
int len;
while ((len = bis.read(bytes)) != -1){
// 放入输出流给服务器
os.write(bytes,0,len);
}
// 释放资源
bis.close();
client.close();
}
}
