提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  后端

当前栏目

Java 网络编程

JAVA网络编程
2023-09-14 08:56:53 时间

 目录

使用URL类下载网络资源

使用URL类下载资源时返回403的解决方法

IP相关的InetAddress

端口相关的InetSocketAddress

简单使用UDP

　　1、最简套路

　　2、发送基本数据类型的数据

　　3、发送引用数据类型的数据

TCP编程

 

 

使用URL下载网络资源

　　使用URL类下载网络资源的时候，功能就类似于Linux里面的wget命令。

package lixin.gan;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.MalformedURLException;
import java.net.URL;

public class Use_URL {
	public static void getURLinfo() throws MalformedURLException {
		
		PrintStream out = System.out;
		
		URL url = new URL("http://localhost:80/di/user.html?name=abc&age=99#a");
		
		out.println(url.getProtocol());	// http
		out.println(url.getHost());		// localhost
		out.println(url.getFile());		// /di/user.html?name=abc&age=99
		out.println(url.getPort());		// 80
		out.println(url.getQuery());	// name=abc&age=99
		out.println(url.getRef());      // a
		
	}
	
	public static void downloadURL() {
		URL url = null;
		try {
			url = new URL("http://localhost:80/di/user.html?name=abc&age=99#a");
		} catch (MalformedURLException e) {
			e.printStackTrace();
		}
		
		try {
			// 打开连接
			InputStream inputStream = url.openStream();
			
			BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
			
			String content = "";
			while ((content = bufferedReader.readLine()) != null) {
				System.out.println(content);
			}
			bufferedReader.close();
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		downloadURL();
	}
	
}

　　

 

使用URL类下载资源时返回403的解决方法

　　有时候，模拟浏览器发起http请求的时候，获得403的响应码，这是因为请求的服务器有一些措施，防止通过这种方式请求。

　　此时，可以通过设置http的头部信息和请求方法。

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class TestUrl {
	public static void main(String[] args) throws Exception  {
		URL url = new URL("http://www.dianping.com");
		
		HttpURLConnection conn = (HttpURLConnection)url.openConnection();
		
		// setRequestMethod(GET|POST) 注意使用大写
		conn.setRequestMethod("GET");
		
		// setRequestProperty(String key, String value) 设定http头部信息
		conn.setRequestProperty("user-agent", ".......");
		
		InputStream is = conn.getInputStream();
		
		// 等价于
		//InputStream is = url.openStream();
		
		BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
		
		String msg = null;
		while ((msg = br.readLine()) != null) {
			System.out.println(msg);
		}
		br.close();
	}
}

　　

 

InetAddress类

　　InetAddress主要是与ip、域名相关。

package lixin.gan;

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

//InetAddress可以通过多种方法来返回InetAddress对象
public class Use_InetAddress {
	public static void main(String[] args) {
		
		InetAddress inetAddress = null;
		
		try {
			// 获得本机的InetAddress对象
			InetAddress localhost = InetAddress.getLocalHost();
			System.out.println(localhost.getHostName());  // 获得主机名         DESKTOP-IKPJ8II
			System.out.println(localhost.getHostAddress()); // 获得本机ip 192.168.228.1

		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
		
		try {
			// 通过域名获取InetAddress对象
			inetAddress = InetAddress.getByName("www.ganlixin.cn");
			System.out.println(inetAddress.getHostAddress());  // 140.143.12.251
			System.out.println(inetAddress.getHostName());		// www.ganlixin.cn
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
		
		try {
			// 通过ip获取InetAddress对象
			inetAddress = InetAddress.getByName("140.143.12.251");
			System.out.println(inetAddress.getHostAddress());
			System.out.println(inetAddress.getHostName());
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
		
	}
}

　　

 

InetSocketAddress类

　　InetSocketAddress类不仅与ip相关，还和端口相关，正如计算机网络课程中所说的：  ip + port => socket。

package lixin.gan;

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

public class Use_InetSocketAddress {
	public static void main(String[] args) {
		InetSocketAddress inetSocketAddress = null;
		
		//inetSocketAddress = new InetSocketAddress(InetAddress.getByName("www.baidu.com"), 8080);
		
		inetSocketAddress = new InetSocketAddress("127.0.0.1", 80);
		
		InetAddress address = inetSocketAddress.getAddress();
		String hostName = inetSocketAddress.getHostName();
		int port = inetSocketAddress.getPort();
		
	}
}

　　

 

UDP编程--最简套路

　　这里以客户端-服务器端的形式来展示使用udp进行交互的过程，实际上，任何一方都可以发送数据，也都可以接收数据。

　　Client

package lix.gan.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.net.SocketException;

/**
 **发送端的几个步骤
 * 1、使用DatagramSocket 指定ip+port， 创建发送端（注意不是接收端）
 * 2、将要发送的数据转换为字节数组，封装为DatagramPacket, 用来保存要发送的数据
 * 3、发送数据 send(DatagramPacket p)
 * 4、释放资源
 */
public class Client {
	public static void main(String[] args) throws SocketException {
		
		System.out.println("发送端启动");
		
		/**
		 * 创建发送端， 下面的例子是localhost:9999 发送给 localhost:8888
		 */
		SocketAddress clientSocketAddress = new InetSocketAddress("localhost", 9999);
		DatagramSocket client = new DatagramSocket(clientSocketAddress);
		
		/**
		 * 指定接收端的ip+port
		 */
		SocketAddress serverSocketAddress = new InetSocketAddress("localhost", 8888);
		
		/**
		 * 组装为数据包
		 */
		byte[] data = "这是数据 data".getBytes();
		DatagramPacket datagramPacket = new DatagramPacket(data, data.length, serverSocketAddress);
		
		/**
		 * 发送数据
		 */
		try {
			client.send(datagramPacket);
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		client.close();
	}
}

　　

　　Server

package lix.gan.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.net.SocketException;

/**
 **接收端的几个步骤
 * 1、使用DatagramSocket 指定ip+port， 创建接收端
 * 2、准备容器，封装为DatagramPacket, 用来保存接收到的数据
 * 3、阻塞式接收数据 receive(DatagramPacket p)
 * 4、拆数据包 
 * 5、释放资源
 */
public class Server {

	public static void main(String[] args) throws IOException {
		
		System.out.println("接收端启动");
		
		SocketAddress serverSocketAddress = new InetSocketAddress("localhost", 8888);
		DatagramSocket server = new DatagramSocket(serverSocketAddress);
		
		SocketAddress clientSocketAddress = new InetSocketAddress("localhost", 9999);
		
		byte[] container = new byte[1024 * 5];
		DatagramPacket datagramPacket = new DatagramPacket(container, 0, container.length);
		
		// 阻塞式接收数据
		server.receive(datagramPacket);
		
		byte[] data = datagramPacket.getData();
		int length = datagramPacket.getLength();
		
		System.out.println(new String(data, 0, length));
		
		server.close();
		
	}

}

　　

 

UDP编程--发送和接收基本数据类型的数据

　　其实使用的是DataOutputStream和DataInputStream这两个包装流

　　Client

package lix.gan.udp;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;

public class Client_Send_Basic_Data_Type {
	public static void main(String[] args) throws IOException {

		System.out.println("发送端启动");
		
		/**
		 * 创建发送端， 下面的例子是localhost:9999 发送给 localhost:8888
		 */
		SocketAddress clientSocketAddress = new InetSocketAddress("localhost", 9999);
		DatagramSocket client = new DatagramSocket(clientSocketAddress);
		
		/**
		 * 指定接收端的ip+port
		 */
		SocketAddress serverSocketAddress = new InetSocketAddress("localhost", 8888);
		
		/**
		 * 组装为数据包
		 * 对于基本数据类型，要使用Data流来传输
		 */
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
		DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(byteArrayOutputStream));
		
		dataOutputStream.writeUTF("hello data");
		dataOutputStream.writeBoolean(true);
		dataOutputStream.writeInt(99);
		dataOutputStream.flush();
		
		byte[] data = byteArrayOutputStream.toByteArray();
		DatagramPacket datagramPacket = new DatagramPacket(data, data.length, serverSocketAddress);
		
		/**
		 * 发送数据
		 */
		try {
			client.send(datagramPacket);
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		client.close();
	}
}

　　

　　Server

package lix.gan.udp;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;

public class Server_Receive_Basic_Data_Type {

	public static void main(String[] args) throws IOException {
		
		System.out.println("接收端启动");
		
		SocketAddress serverSocketAddress = new InetSocketAddress("localhost", 8888);
		DatagramSocket server = new DatagramSocket(serverSocketAddress);
		
		SocketAddress clientSocketAddress = new InetSocketAddress("localhost", 9999);
		
		byte[] container = new byte[1024 * 5];
		DatagramPacket datagramPacket = new DatagramPacket(container, 0, container.length);
		
		server.receive(datagramPacket);
		
		/**
		 * 读取数据时，对于基本类型，需要使用Data流
		 */
		byte[] data = datagramPacket.getData();
		int length = datagramPacket.getLength();
		
		DataInputStream dataInputStream = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(data)));
		String str = dataInputStream.readUTF();
		boolean flag = dataInputStream.readBoolean();
		int number = dataInputStream.readInt();
		System.out.println(str);
		System.out.println(flag);
		System.out.println(number);
		
		server.close();
		
	}

}

　　

 

UDP编程--发送对象数据

　　其实是用的ObjectInputStream和ObjectOutputStream

　　Client

package lix.gan.udp;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;

public class Client_Send_Object {
	public static void main(String[] args) throws IOException {

		System.out.println("发送端启动");
		
		/**
		 * 创建发送端， 下面的例子是localhost:9999 发送给 localhost:8888
		 */
		SocketAddress clientSocketAddress = new InetSocketAddress("localhost", 9999);
		DatagramSocket client = new DatagramSocket(clientSocketAddress);
		
		/**
		 * 指定接收端的ip+port
		 */
		SocketAddress serverSocketAddress = new InetSocketAddress("localhost", 8888);
		
		/**
		 * 组装为数据包
		 * 对于对象（引用类型），要使用Object流来传输
		 */
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
		ObjectOutputStream objectOutputStream = new ObjectOutputStream(new BufferedOutputStream(byteArrayOutputStream));
		
		/**
		 * 
		 */
		objectOutputStream.writeObject(new Person(1, "abc", 9999));
		objectOutputStream.writeObject(new Person(2, "xyz", 8888));
		objectOutputStream.flush();
		
		byte[] data = byteArrayOutputStream.toByteArray();
		DatagramPacket datagramPacket = new DatagramPacket(data, data.length, serverSocketAddress);
		
		/**
		 * 发送数据
		 */
		try {
			client.send(datagramPacket);
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		client.close();
	}
}

　　

　　Server

package lix.gan.udp;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;

public class Server_Receive_Basic_Data_Type {

	public static void main(String[] args) throws IOException {
		
		System.out.println("接收端启动");
		
		SocketAddress serverSocketAddress = new InetSocketAddress("localhost", 8888);
		DatagramSocket server = new DatagramSocket(serverSocketAddress);
		
		SocketAddress clientSocketAddress = new InetSocketAddress("localhost", 9999);
		
		byte[] container = new byte[1024 * 5];
		DatagramPacket datagramPacket = new DatagramPacket(container, 0, container.length);
		
		server.receive(datagramPacket);
		
		/**
		 * 读取数据时，对于基本类型，需要使用Data流
		 */
		byte[] data = datagramPacket.getData();
		int length = datagramPacket.getLength();
		
		DataInputStream dataInputStream = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(data)));
		String str = dataInputStream.readUTF();
		boolean flag = dataInputStream.readBoolean();
		int number = dataInputStream.readInt();
		System.out.println(str);
		System.out.println(flag);
		System.out.println(number);
		
		server.close();
		
	}

}

　　

 

TCP编程

　　client

package lixin.gan.tcp;

import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

import com.sun.xml.internal.ws.spi.db.DatabindingException;

/*
 * 创建客户端的流程
 * 1、使用Socket创建和服务器的连接， 指定服务器端的ip和port
 * 2、操作输入输出流
 * 3、关闭连接
 * 
 */
public class Client {
	public static void main(String[] args) throws UnknownHostException, IOException {
		//Creates a stream socket and connects it to the specified portnumber on the named host. 
		Socket connection = new Socket("localhost", 8888);
		
		// 获得连接的流
		//connection.getOutputStream();
		
		DataOutputStream dataOutputStream = new DataOutputStream(connection.getOutputStream());
		dataOutputStream.writeUTF("hello world");
		dataOutputStream.writeBoolean(false);
		dataOutputStream.flush();
		dataOutputStream.close();
		
		connection.close();
		
	}
}

　　

　　Server

package lixin.gan.tcp;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/*
 * 创建服务器流程
 * 1、使用ServerSocket创建服务器，指定本机监听的port
 * 2、调用accept()方法，阻塞式的等待客户端的请求
 * 3、获得连接后，进行操作输入输出流
 * 4、释放连接
 */
public class Server {
	public static void main(String[] args) throws IOException {
		ServerSocket server = new ServerSocket(8888);
		
		System.out.println("Listen localhost:8888");
		
		/*Listens for a connection to be made to this socket and acceptsit. 
		 *The method blocks until a connection is made. */
		Socket connection = server.accept();
		
		System.out.println("a connection has been established");
		
		DataInputStream dataInputStream = new DataInputStream(connection.getInputStream());
		String str = dataInputStream.readUTF();
		boolean flag = dataInputStream.readBoolean();
		System.out.println(str + "---" + flag);
		
		dataInputStream.close();
		server.close();
	}
}

　　

相关文章