Java 网络编程

最新推荐文章于 2025-08-11 14:43:21 发布

原创最新推荐文章于 2025-08-11 14:43:21 发布 · 202 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#网络编程 #java #语言

Java高级特性专栏收录该内容

12 篇文章

订阅专栏

基于TCP协议下的网络编程：

获取本地主机地址

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * 测试InetAddress类
 * @author 30869
 *
 */
public class Test_InetAddress {

	public static void main(String[] args) {
		try {
			InetAddress address=InetAddress.getLocalHost();//获取表示本地主机的InetAddress对象
			System.out.println("本地主机地址是："+address);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
		
	}

}

传输字符串

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 测试Socket客户端
 * @author 30869
 *
 */
public class TestSocket {

	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket socket=new Socket("localhost", 8800);//创建客户端Socket连接，指定服务器的位置为本机和8800端口
		InputStream is=socket.getInputStream();//打开输入/输出流
		OutputStream os=socket.getOutputStream();
		String info="用户名：李林，密码：123456";//发送客户端登录信息，即向输出流写入信息
		os.write(info.getBytes());
		socket.shutdownOutput();
		String reply=null;//接受服务器响应，即从输入流读取信息
		BufferedReader br=new BufferedReader(new InputStreamReader(is));
		while(!((reply=br.readLine())==null)){
			System.out.println("我是客户端，服务器响应信息："+reply);
		}
		is.close();//关闭资源
		os.close();
		socket.close();
		br.close();
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 测试ServerSocket服务器端
 * @author 30869
 *
 */
public class TestServerSocket {

	public static void main(String[] args) throws IOException {
		ServerSocket serverSocket=new ServerSocket(8800);//建立一个服务器Socket(ServerSocket),指定端口8800并开始监听
		Socket socket=serverSocket.accept();//等待客户端触发通信
		InputStream is=socket.getInputStream();//打开输入输出流
		OutputStream os=socket.getOutputStream();
		String info=null;//获取客户端信息，即从输入流读取信息
		//InputStreamReader()转换流，字节转字符
		BufferedReader br=new BufferedReader(new InputStreamReader(is));
		while(!((info=br.readLine())==null)){
			System.out.println("我是服务器，客户登录信息为："+info);
		}
		String reply="欢迎你，登录成功！";//给客户端一个响应，即从输出流写入信息
		os.write(reply.getBytes());
		serverSocket.close();//关闭资源
		socket.close();
		is.close();
		os.close();
		br.close();
	}

}

传输对象

import java.io.Serializable;

/**
 * 序列化用户类
 * @author 30869
 *
 */
public class User implements Serializable{

	private String uName;//用户名
	private String pwd;//密码
	
	public User() {
		super();
	}

	public User(String uName, String pwd) {
		super();
		this.uName = uName;
		this.pwd = pwd;
	}

	public String getuName() {
		return uName;
	}

	public void setuName(String uName) {
		this.uName = uName;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
	
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

/**
 * 客户端
 * @author 30869
 *
 */
public class Client {

	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket socket=new Socket("localhost", 8800);//建立客户端Socket连接，指定服务器位置和端口
		OutputStream os=socket.getOutputStream();//打开输入/输出流
		InputStream is=socket.getInputStream();
		ObjectOutputStream oos=new ObjectOutputStream(os);//对象序列化
		List<User> users=new ArrayList<User>();//添加对象数据
		users.add(new User("李林", "123456"));
		users.add(new User("杨英", "654321"));
		users.add(new User("周星驰", "158312"));
		users.add(new User("叶问", "851236"));
		users.add(new User("李连杰", "741852"));
		oos.writeObject(users);//写入数据
		//禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。
		//如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException
		socket.shutdownOutput();
		BufferedReader br=new BufferedReader(new InputStreamReader(is));//读取服务器响应信息
		String reply=null;
		while(!((reply=br.readLine())==null)){
			System.out.println("我是客户端：服务器响应信息为："+reply);
		}
		br.close();//关闭资源
		oos.close();
		os.close();
		is.close();
		socket.close();
	}

}

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

import com.lilin.testSocket_ServerSocket_Object.User;

/**
 * 服务器端
 * 
 * @author 30869
 *
 */
public class Server {

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		ServerSocket serverSocket = new ServerSocket(8800);// 指定端口8800并开始监听
		Socket socket = serverSocket.accept();// 等待客户端触发通信
		InputStream is = socket.getInputStream();// 打开输入/输出流
		OutputStream os = socket.getOutputStream();
		ObjectInputStream ois = new ObjectInputStream(is);// 对象反序列化
		List<User> users = new ArrayList<User>();
		users = (List<User>) ois.readObject();// 读取客户端信息
		if (!(users == null)) {//先判断客户端是否发出请求
			System.out.println("我是服务器：客户端登录信息如下：");
			for (User user : users) {
				System.out.println("用户名：" + user.getuName() + "\t密码：" + user.getPwd());
			}
		}
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));// 给客户端响应
		bw.write("登录人数：" + users.size() + "人");
		bw.close();// 关闭资源
		ois.close();
		os.close();
		is.close();
		socket.close();
		serverSocket.close();
	}

}

多个客户端访问服务器

import java.io.Serializable;

/**
 * 序列化用户类
 * @author 30869
 *
 */
public class User implements Serializable{

	private String uName;//用户名
	private String pwd;//密码
	
	public User() {
		super();
	}

	public User(String uName, String pwd) {
		super();
		this.uName = uName;
		this.pwd = pwd;
	}

	public String getuName() {
		return uName;
	}

	public void setuName(String uName) {
		this.uName = uName;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
	
}

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
/**
 * 服务端线程
 * @author 30869
 *
 */
import java.util.Scanner;
public class LoginThread extends Thread {
	Socket socket = null;
	OutputStream os = null;
	InputStream is = null;
	ObjectInputStream ois = null;
	BufferedWriter bw = null;
	Scanner scanner=new Scanner(System.in);
	//每启动一个线程，连接对应的Socket
	public LoginThread(Socket socket) {
		super();
		this.socket = socket;
	}
	//启动线程，即响应客户端请求
	public void run() {
		try {
			os = socket.getOutputStream();
			is = socket.getInputStream();
			ois = new ObjectInputStream(is);
			
			List<User> users = new ArrayList<User>();
			users = (List<User>) ois.readObject();
			StringBuffer sb = new StringBuffer();//用于存储响应信息
			if (!(users == null)) {
				System.out.println("我是服务器：客户端请求信息如下：");
				for (User user : users) {
					System.out.println("用户名：" + user.getuName() + "\t密码" + user.getPwd());
					sb.append(user.getuName() + "已登录\n");
				}
			}
			bw = new BufferedWriter(new OutputStreamWriter(os));
			bw.write(sb.toString());
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bw.close();
				ois.close();
				is.close();
				os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}

		}

	}
}

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 服务器端
 * @author 30869
 *
 */
public class Server {

	public static void main(String[] args) throws IOException {
		ServerSocket serverSocket=new ServerSocket(8800);//建立服务器Socket(SeverSocket)，指定端口并开始监听
		Socket socket=null;
		//监听一直进行
		while(true){
			socket=serverSocket.accept();//等待客户端触发通信
			LoginThread loginThread=new LoginThread(socket);
			loginThread.start();
		}
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

/**
 * 客户端
 * @author 30869
 *
 */
public class Client2 {

	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket socket=new Socket("localhost", 8800);//建立客户端Socket连接，指定服务器位置和端口
		OutputStream os=socket.getOutputStream();//打开输入/输出流
		InputStream is=socket.getInputStream();
		ObjectOutputStream oos=new ObjectOutputStream(os);//对象序列化
		List<User> users=new ArrayList<User>();//添加对象数据
		users.add(new User("黎明", "123456"));
		users.add(new User("张学友", "654321"));
		users.add(new User("周星驰", "158312"));
		users.add(new User("刘德华", "851236"));
		users.add(new User("李连杰", "741852"));
		oos.writeObject(users);//写入数据
		//禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。
		//如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException
		socket.shutdownOutput();
		BufferedReader br=new BufferedReader(new InputStreamReader(is));//读取服务器响应信息
		String reply=null;
		System.out.println("我是客户端：服务器响应信息为：");
		while(!((reply=br.readLine())==null)){
			System.out.println(reply);
		}
		br.close();//关闭资源
		oos.close();
		os.close();
		is.close();
		socket.close();
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

/**
 * 客户端
 * @author 30869
 *
 */
public class Client {

	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket socket=new Socket("localhost", 8800);//建立客户端Socket连接，指定服务器位置和端口
		OutputStream os=socket.getOutputStream();//打开输入/输出流
		InputStream is=socket.getInputStream();
		ObjectOutputStream oos=new ObjectOutputStream(os);//对象序列化
		List<User> users=new ArrayList<User>();//添加对象数据
		users.add(new User("李林", "123456"));
		users.add(new User("杨英", "654321"));
		users.add(new User("周星驰", "158312"));
		users.add(new User("叶问", "851236"));
		users.add(new User("张学友", "741852"));
		oos.writeObject(users);//写入数据
		//禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。
		//如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException
		socket.shutdownOutput();
		BufferedReader br=new BufferedReader(new InputStreamReader(is));//读取服务器响应信息
		String reply=null;
		System.out.println("我是客户端：服务器响应信息为：");
		while(!((reply=br.readLine())==null)){
			System.out.println(reply);
		}
		br.close();//关闭资源
		oos.close();
		os.close();
		is.close();
		socket.close();
	}

}

基于UDP协议的网络编程：

/**
 * 发送端
 */
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class Send {

	public static void main(String[] args) {
		InetAddress ia=null;//主机地址引用
		DatagramSocket ds=null;//DatagramSocket引用
		String msgs="你好，哪位？";
		System.out.println("我说："+msgs);//显示与本地对话框
		try {
			ia=InetAddress.getByName("localhost");//获取主机地址
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
		//创建DatagramPacket对象，封装数据
		DatagramPacket dp=new DatagramPacket(msgs.getBytes(), msgs.getBytes().length,ia,8800);
		try {
			ds=new DatagramSocket();//创建DatagramSocket对象
		
		} catch (SocketException e) {
			e.printStackTrace();
		}
		try {
			ds.send(dp);//向服务器发送数据
		} catch (IOException e) {
			e.printStackTrace();
		}
		//接收服务器响应
		byte[] buf=new byte[1024];
		DatagramPacket dprp=new DatagramPacket(buf, 1024);
		try {
			ds.receive(dprp);
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			ds.close();//关闭DatagramSocket对象
		}
		String reply=new String(dprp.getData(),0,dprp.getLength());//取出信息
		System.out.println(dp.getAddress().getHostAddress()+"说："+reply);
			
	}

}

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketAddress;
import java.net.SocketException;
/**
 * 接收端
 * @author 30869
 *
 */
public class Receive {

	public static void main(String[] args) {
		DatagramSocket ds=null;//创建DatagramSocket引用
		byte[] buf=new byte[1024];
		//创建DatagramPacket对象，用来准备接收数据包
		DatagramPacket dp=new DatagramPacket(buf, 1024);
		try {
			ds=new DatagramSocket(8800);//创建DatagramSocket对象，指定端口
		} catch (SocketException e) {
			e.printStackTrace();
		}
		try {
			ds.receive(dp);//接收数据，放入dp
		} catch (IOException e) {
			e.printStackTrace();
		}
		String msgs=new String(dp.getData(), 0, dp.getLength());//取出数据信息
		System.out.println(dp.getAddress().getHostAddress()+"说："+msgs);
		//向客户端发送响应信息
		String reply="我是李林";
		System.out.println("我说:"+reply);//显示与本地对话框
		//SocketAddress类，供套接字用于绑定、连接或用作返回值
		//getSocketAddress()，获取要将此包发送到的或发出此数据报的远程主机的 SocketAddress（通常为 IP 地址 + 端口号）。
		SocketAddress sa=dp.getSocketAddress();
		//创建DatagramPacket对象，封装数据
		DatagramPacket dpto=new DatagramPacket(reply.getBytes(), reply.getBytes().length,sa);
		try {
			ds.send(dpto);//发送
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			ds.close();//关闭DatagramSocket对象
		}
	}

}