网络编程
端口
IP地址
IP地址用来标识网络中的一个通信实体的地址。通信实体可以是计算机、路由器等。例如：互联网的每个服务器都要有自己的IP地址，而局域网的每台计算机要进行通信也要配置IP地址。路由器是连接两个或者多个网络的网络设备。
目前的主流IP地址使用的是IPv4协议，但是随着网络规模的不断扩大，采用IPv4协议的可用地址不足时的危险，故推出了IPv6协议
IPv4协议采用32位地址，并以8位为一个单位，分成4部分，以点分十进制表示，如：192.168.0.1
IPv6协议为128位地址，写成8个16位的无符号整数，每个整数用四个十六进制位表示，每个数之间用冒号（：）分开，如：3ffe：3201:1401:1280：c8ff：fe4d：db39:1984。
端口
可以利用cmd来查看（桌面键+r->cmd）
package com.text.net;
import java.net.InetSocketAddress;
/**
* 端口的概念
* 用于区分软件
* 同一个协议端口不能冲突
*
* @author 墨雷
*
*/
public class TextNet02 {
public static void main(String[] args) {
InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
InetSocketAddress socketAddress2 = new InetSocketAddress("localhost",9000);
System.out.println(socketAddress.getHostName());
System.out.println(socketAddress2.getPort());
}
}
URL的基本用法
在因特网上，每一信息资源都有统一且唯一的地址，该地址就叫做URL（Uniform Resource Locator），它是因特网上的统一资源定位符。URL由4部分组成：协议，存放资源的主机域名，资源文件名，端口号。如果未指定端口号，则使用协议默认的端口。
package com.text.net;
import java.net.MalformedURLException;
import java.net.URL;
/**
* URL
* 1）协议
* 2)域名、计算机
* 3）端口
* 4）请求
* @author 墨雷
*
*/
public class TextNet03_URL {
public static void main(String[] args) throws MalformedURLException {
URL url =new URL("https://fanyi.baidu.com/translate?aldtype=16047&query=host&keyfrom=baidu&smartresult=dict&lang=auto2zh&decrypt_suc=1#en/zh/");
System.out.println("协议:"+url.getProtocol());
System.out.println("域名:"+url.getHost());
System.out.println("端口:"+url.getPort());
System.out.println("请求资源1："+url.getFile());
System.out.println("请求资源2："+url.getPath());
//参数
System.out.println("参数:"+url.getQuery());
//锚点
System.out.println("锚点:"+url.getRef());
}
}
package com.text.net;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class TextNet04_Spider {
public static void main(String[] args) throws IOException {
//获取URL
URL u = new URL("http://www.dianping.com/");
//下载资源
HttpURLConnection con = (HttpURLConnection)u.openConnection();//模拟网络申请
con.setRequestMethod("GET");//GET or POST
con.setRequestProperty("User-Agent","Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.25 Safari/537.36 Core/1.70.3650.400 QQBrowser/10.4.3341.400");//此处为模拟使用者，此处我用的是百度的
//InputStream is =u.openStream();
BufferedReader br = new BufferedReader(new java.io.InputStreamReader(con.getInputStream(),"UTF-8"));
//分析
String s;
while(null !=(s = br.readLine())) {
System.out.println(s);
}
}
}
传输协议
TCP协议
一种面向连接的，可靠的，基于字节流的运输层通信协议
特点：
面向连接
点到点的通信
高可靠性
占用资源多，效率低
public class Text01 {
public static void main(String[] args) throws Exception {
System.out.println("---server---");
// * 1、指定端口 使用ServerSocket创建服务器
ServerSocket server = new ServerSocket(8888);
// * 2、阻塞式的等待链接accept
Socket clisen = server.accept();
System.out.println("客户端接入");
// * 3、操作：输入输出流操作
DataInputStream dis = new DataInputStream(clisen.getInputStream());
System.out.println(dis.readUTF());
// * 4、释放资源
dis.close();
clisen.close();
server.close();
}
}
public class Text02 {
public static void main(String[] args) throws Exception {
System.out.println("---client---");
// * 1、 使用Socket创建客户端
Socket client = new Socket("localhost",8888);
// * 2、操作：输入输出流操作
DataOutputStream data = new DataOutputStream(client.getOutputStream());
data.writeUTF("蛇皮玩意儿？");
// * 3、释放资源
data.close();
client.close();
}
}
网上多人聊天室（基础版）
package com.text.chatRoom;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* 多人聊天室（学习用）
* @author 墨雷
*
*/
public class Threadchat {
private static CopyOnWriteArrayList<ChatServer> all = new CopyOnWriteArrayList<ChatServer>();
public static void main(String[] args) {
ServerSocket server = null;
try {
server = new ServerSocket(8888);
while(true) {
Socket socket= server.accept();//阻塞式的等待
ChatServer c = new ChatServer(socket);
all.add(c);
new Thread(c).start();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
static class ChatServer implements Runnable{
private Socket client;
private DataInputStream dis;
private DataOutputStream dos;
private boolean isRunning;
public ChatServer(Socket client){
this.client = client;
isRunning = true;
try {
dis = new DataInputStream(client.getInputStream());
dos = new DataOutputStream(client.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
//关闭相应的流
private void closeAll() {
System.out.println("close");
try {
client.close();
dis.close();
dos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//接收流
private String recive() {
String content = null;
try {
content = dis.readUTF();
System.out.println("执行");
} catch (IOException e) {
closeAll();
}
return content;
}
//发送流
public void send(String msg) {
try {
dos.writeUTF(msg);
dos.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
public void run() {
String centent = "";
while(isRunning) {
centent = recive();
System.out.println(centent);
if(!centent.equals("")) {
for(ChatServer other:all) {
if(other == this) {
continue;
}else {
other.send(centent);
}
}
if(centent.equals("bye")) {
isRunning = false;
all.remove(this);
}
}
}
closeAll();
}
}
}
UDP协议
一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务
特点：
非面向连接，传输不可靠，可能丢失
发送不管对方是否准备好，接受方收到也不确认
可以广播发送
非常简单的协议
单项传输：
package com.text.net;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;
/**
* 发送端
* 1、使用DatagramSocket 指定端口，创建发送端
* 2、准备数据，并转成字节数组
* 3、封装成DatagramPacket包裹，指定目的地
* 4、发送包裹send（）
* 5、释放资源
* @author 墨雷
*
*/
public class TextNet05_UDP2 {
public static void main(String[] args) throws Exception {
// * 1、使用DatagramSocket 指定端口，创建发送端
System.out.println("发送端");
DatagramSocket dg = new DatagramSocket(8888);
// * 2、准备数据，并转成字节数组
String data = "nice first things !";
byte [] list = data.getBytes();
// * 3、封装成DatagramPacket包裹，指定目的地
DatagramPacket dp = new DatagramPacket(list, 0, list.length, new InetSocketAddress("localhost",9999));
// * 4、发送包裹send（）
dg.send(dp);
// * 5、释放资源
dg.close();
}
}
package com.text.net;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
* 接收端
* 1、使用DatagramSocket 指定端口，创建接受端
* 2、准备容器 封装成DatagramPacket 包裹
* 3、阻塞是接受包裹receive（）
* 4、分析数据
* 5、释放资源
* @author 墨雷
*
*/
public class TextNet05_UDP {
public static void main(String[] args) throws Exception {
System.out.println("接收端");
// * 1、使用DatagramSocket 指定端口，创建接受端(端口号)
DatagramSocket dg = new DatagramSocket(9999);
// * 2、准备容器 封装成DatagramPacket 包裹
byte[] byt = new byte[1024*60];
DatagramPacket dp = new DatagramPacket(byt, 0,byt.length);
// * 3、阻塞式接受包裹receive（）
dg.receive(dp);
// * 4、分析数据
byte[] data = dp.getData();
System.out.println(new String(data,0,dp.getLength()));
// * 5、释放资源
dg.close();
}
}
在此基础上的双方聊天的模式
老师端
public class Teacher {
public static void main(String[] args) {
//接收
new Thread(new TextNet05_UDP_1(8888)).start();
//发送
new Thread(new TextNet05_UDP2_1(4444, "localhost",9999,"老师")).start();
}
}
学生端
public class Student {
public static void main(String[] args) {
//接收
new Thread(new TextNet05_UDP_1(9999)).start();
//发送
new Thread(new TextNet05_UDP2_1(7777, "localhost",8888,"学生")).start();
}
}
接收端（线程）
public class TextNet05_UDP_1 implements Runnable{
private DatagramSocket dg;
public TextNet05_UDP_1(int port) {
try {
dg = new DatagramSocket(port);
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void run() {
byte[] getd;
while(true) {
byte[] byt = new byte[1024*60];
DatagramPacket dp = new DatagramPacket(byt, 0,byt.length);
try {
dg.receive(dp);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
getd = dp.getData();
System.out.println(new String(getd,0,getd.length));
if(new String(getd,0,getd.length).equals("bye")) {
break;
}
}
dg.close();
}
}
发送端
public class TextNet05_UDP2_1 implements Runnable{
private DatagramSocket dg ;
private String oIP;
private int oPort;
private BufferedReader br;
private String user;
public TextNet05_UDP2_1(int port,String oIP,int oPort,String user) {
this.oIP = oIP;
this.oPort = oPort;
this.user =user;
try {
this.dg = new DatagramSocket(port);
this.br = new BufferedReader(new InputStreamReader(System.in));
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void run() {
// TODO Auto-generated method stub
String s = null;
byte[] list;
while(true) {
try {
s =user+":"+this.br.readLine();
list = s.getBytes();
DatagramPacket dp = new DatagramPacket(list, 0, list.length, new InetSocketAddress(oIP,oPort));
dg.send(dp);
if(s.equals("bye")) {
break;
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
dg.close();
}
}
976
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
