Java 网络编程
目录
使用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();
}
}
如需转载，请注明文章出处，谢谢！！！
浙公网安备 33010602011771号