12. 网络编程
12.1 TCP/IP 编程
12.1.1 单向通讯
/**
* tcp/ip之单向通讯-客户端
*/
public class Client01 {
public static void main(String[] args) throws IOException {
// 定义客户端套接字
Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
// 根据套接字得到输出流
OutputStream outputStream = socket.getOutputStream();
// 将输出流转换成缓冲字符输出流
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
// 定义一个Scanner输入对象
Scanner scanner = new Scanner(System.in);
// 获取键盘输入的一行数据
String line = scanner.nextLine();
// 将数据输出给服务端
writer.write(line);
// 关闭资源
scanner.close();
writer.close();
socket.close();
}
}
/**
* tcp/ip之单向通讯-服务端
*/
public class Server01 {
public static void main(String[] args) throws IOException {
// 定义服务端套接字
ServerSocket serverSocket = new ServerSocket(6666);
// 通过服务端套接字获得客户端套接字
Socket accept = serverSocket.accept();
// 通过套接字获取输入流
InputStream inputStream = accept.getInputStream();
// 将输入流转换成缓存字符输入流
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
// 获取客户端发来的信息
String line = reader.readLine();
// 打印
System.out.println("客户端说:" + line);
// 关闭资源
reader.close();
accept.close();
serverSocket.close();
}
}
12.1.2 双向通讯
/**
* tcp/ip之双向通讯-客户端
*/
public class Client02 {
public static void main(String[] args) throws IOException {
// 创建客户端套接字
Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
// 根据客户端套接字获取输出流,并转换成缓冲输出流
PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
// 定义一个Scanner获取键盘输入的数据
Scanner scanner = new Scanner(System.in);
// 获取输入的数据
String line = scanner.nextLine();
// 将数据发送给服务端
writer.println(line);
// 根据套接字获取输入流,并转换成缓冲字符输入流
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 获取服务端发送的数据
String line1 = reader.readLine();
// 打印
System.out.println("服务端说:" + line1);
// 关闭资源
reader.close();
scanner.close();
writer.close();
socket.close();
}
}
/**
* tcp/ip之双向通讯-服务端
*/
public class Server02 {
public static void main(String[] args) throws IOException {
// 创建服务端套接字
ServerSocket serverSocket = new ServerSocket(6666);
// 根据服务端套接字获取客户端套接字
Socket accept = serverSocket.accept();
// 根据套接字获取输入流,并转换成缓冲字符输入流
BufferedReader reader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
// 获取客户端发送的数据
String line = reader.readLine();
// 打印
System.out.println("客户端说:" + line);
// 根据套接字获取输出流,并转换成缓冲输出流
PrintWriter writer = new PrintWriter(accept.getOutputStream(), true);
// 定义一个Scanner获取键盘输入的数据
Scanner scanner = new Scanner(System.in);
// 获取输入的数据
String line1 = scanner.nextLine();
// 将数据发送给客户端
writer.println(line1);
// 关闭资源
scanner.close();
writer.close();
reader.close();
accept.close();
serverSocket.close();
}
}
12.2 UDP 编程
12.2.1 发送方
/**
* 发送方
*/
public class Sender01 {
public static void main(String[] args) throws IOException {
// 创建发送方的套接字
DatagramSocket socket = new DatagramSocket();
// 定义Scanner对象
Scanner scanner = new Scanner(System.in);
// 定义发送数据包
System.out.println("请输入发送信息:");
String line = scanner.nextLine();
// 将字符串转换为字节数组
byte[] bytes = line.getBytes();
// 创建要发送的数据包
DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, InetAddress.getLocalHost(), 6666);
// 发送数据包
socket.send(packet);
// 定义一个字节数组
byte[] b = new byte[100];
// 创建接收的空数据包
DatagramPacket packet1 = new DatagramPacket(b, 0, b.length);
// 接收数据包
socket.receive(packet1);
// 将数据包转换成字符串
String str = new String(packet1.getData(),0,packet1.getLength());
// 打印
System.out.println("接受方发来的数据包:" + str);
// 关闭资源
scanner.close();
socket.close();
}
}
12.2.2 接收方
/**
* 接受方
*/
public class Reciver01 {
public static void main(String[] args) throws IOException {
// 创建接收方的套接字
DatagramSocket socket = new DatagramSocket(6666);
// 接收发送方发送的数据包
byte[] bytes = new byte[100];
DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
socket.receive(packet);
// 将数据包转换成字符串
String str = new String(packet.getData(),0,packet.getLength());
// 打印数据包
System.out.println("接收到发送方的数据:" + str);
// 创建一个Scanner对象
Scanner scanner = new Scanner(System.in);
// 得到键盘输入的信息
System.out.println("向发送方发送信息:");
String line = scanner.nextLine();
// 转换为字节数组
byte[] bytes1 = line.getBytes();
// 创建发送的数据包
DatagramPacket packet1 = new DatagramPacket(bytes1, 0, bytes1.length, packet.getAddress(), packet.getPort());
socket.send(packet1);
// 关闭资源
scanner.close();
socket.close();
}
}
12.3 网络编程应用
案例一:通过TCP/IP传递序列化对象
/**
* tcp传递序列化对象
*/
public class Client03 {
public static void main(String[] args) throws IOException {
// 创建客户端套接字
Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
// 根据套接字获取输出流,并转换成序列化
ObjectOutputStream stream = new ObjectOutputStream(socket.getOutputStream());
// 输入学生信息
Scanner scanner = new Scanner(System.in);
System.out.println("请输入学生学号:");
int sid = scanner.nextInt();
System.out.println("请输入学生姓名:");
String name = scanner.next();
System.out.println("请输入学生性别:");
String sex = scanner.next();
System.out.println("请输入学生年龄:");
int age = scanner.nextInt();
System.out.println("请输入学生住址:");
String addr = scanner.next();
// 创建一个学生对象
Student student = new Student(sid, name, sex, age, addr);
// 将学生对象序列化输出
stream.writeObject(student);
// 关闭资源
scanner.close();
stream.close();
socket.close();
}
}
/**
* tcp传递序列化对象
*/
public class Server03 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 定义一个服务端套接字
ServerSocket serverSocket = new ServerSocket(6666);
// 通过服务端套接字获取客户端套接字
Socket accept = serverSocket.accept();
// 通过套接字获取输入流,并转换成反序列化
ObjectInputStream stream = new ObjectInputStream(accept.getInputStream());
// 获取学生对象反序列化
Student student = (Student) stream.readObject();
// 打印
System.out.println(student);
// 关闭资源
stream.close();
accept.close();
serverSocket.close();
}
}
案例二:写一个TCP/IP的聊天程序,实现客户端与服务器端发送信息,服务器端将接收到的信息,输出到F盘的msg.txt文件中。以end结束!
public class Client04 {
/**
* 写一个TCP/IP的聊天程序,实现客户端与服务器端发送信息,服务器端将接收到的信息,输出到F盘的msg.txt文件中。
* 以end结束!
*/
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
// 定义一个客户端的套接字对象
Socket socket = new Socket(InetAddress.getLocalHost(),6666);
// 根据套接字得到缓冲输出流对象
PrintWriter writer = new PrintWriter(socket.getOutputStream(),true);
// 循环输出信息给服务端
while(true){
// 输入一行信息
String line = scanner.nextLine();
// 将此信息输出给服务端
writer.println(line);
// 如果是end就结束
if(line.equalsIgnoreCase("end")){
break;
}
}
// 关闭资源
writer.close();
scanner.close();
socket.close();
}
}
public class Server04 {
/**
* 写一个TCP/IP的聊天程序,实现客户端与服务器端发送信息,服务器端将接收到的信息,输出到F盘的msg.txt文件中。
* 以end结束!
*/
public static void main(String[] args) throws IOException {
// 定义服务端套接字
ServerSocket serverSocket = new ServerSocket(6666);
// 根据服务端套接字得到客户端的套接字对象
Socket accept = serverSocket.accept();
// 构造套接字关联的输入缓冲流
BufferedReader reader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
// 构造一个文件输出流,将得到信息输出到f盘
File file = new File("f:/msg.txt");
FileOutputStream fos = new FileOutputStream(file,true);
PrintWriter writer = new PrintWriter(fos,true);
// 循环读取并写入到f盘文件中
while (true){
// 每次读取一条数据
String line = reader.readLine();
// 先判断是否是end,是就退出
if("end".equalsIgnoreCase(line)){
break;
}
// 将读到的一行数据写入文件中
writer.println(line);
}
// 关闭资源
reader.close();
writer.close();
accept.close();
serverSocket.close();
}
}