网络编程的实质
就是两个(或多个)设备(例如计算机)之间的数据传输。
一、网络:将不同区域的计算机连接到一起 局域网 城域网 互联网
**二、地址:**IP地址 确定网络上 一个绝对地址 |位置 —>房子的地址
三、端口号: 区分计算机软件的 –>房子的房门 2个字节 0-65535 共65536个
1、在同一个协议下 端口号不能重复 不同协议下可以重复
2、1024以下的不要使用 80–>http 21 –>ftp
四、资源定位: URL 统一资源定位符 URI :统一资源
五、数据的传输
1、协议: Tcp 和UDP协议
1)、TCP(transfer control protocol): 电话 类似于三次握手 面向连接 安全可靠 效率低下
2)、UDP(UserDatagramProtocol ): 短信 非面向连接 效率高
2、传输:
1)、先封装
2)、后拆封
网络编程相关类
1、InetAddress InetSocketAddress
2、URL
3、TCP: ServerSocket Socket
4、UDP: DatagramSocket DatagramPacket
InetAddress
封装计算机的IP地址和DNS。无端口。
方法:
getHostAddress():返回IP地址
getHostName():返回域名/本机为计算机名
InetAddress.getLocalHost():返回本机IP,如果IP不存在则返回自身
InetAddress.getByName(“IP地址/域名”):根据IP地址/域名得到InetAddress对象。
public static void main(String[] args) throws UnknownHostException{
//使用getLocalHost方法创建InetAddress对象
InetAddress addr = InetAddress.getLocalHost();
System.out.println(addr.getHostAddress()); //返回:192.168.1.100
System.out.println(addr.getHostName()); //输出计算机名
//根据域名得到InetAddress对象
addr = InetAddress.getByName("www.163.com");
System.out.println(addr.getHostAddress()); //返回 163服务器的ip:61.135.253.15
System.out.println(addr.getHostName()); //输出:www.163.com
//根据ip得到InetAddress对象
addr = InetAddress.getByName("61.135.253.15");
System.out.println(addr.getHostAddress()); //返回 163服务器的ip:61.135.253.15
System.out.println(addr.getHostName()); //输出ip而不是域名。如果这个IP地 址不存在或DNS服务器不允许进行IP地址和域名的映射,getHostName方法就直接返回这个IP地址。
}
InetSocketAddress
在InetAddress基础上+封装端口。
(1)创建对象
InetSocketAddress(String hostName,int port);
InetSocketAddress(InetAddress addr,int port);
(2)方法
getAddress():返回一个InetAddress对象
getHostName():返回地址
getPort():返回端口
public static void main(String[] args) throws UnknownHostException {
InetSocketAddress address = new InetSocketAddress("127.0.0.1",8888);
address = new InetSocketAddress(InetAddress.getByName("127.0.0.1"),8888);
System.out.println(address.getHostName());
System.out.println(address.getPort());
InetAddress addr =address.getAddress();
System.out.println(addr.getHostAddress());
System.out.println(addr.getHostName());
}
URL
URL:统一资源定位符
URI:统一资源标识符
四部分组成:协议 存放协议的主机域名 端口 资源文件名
1.创建
URL(String spec):绝对路径创建
URL(URL url,String a):相对路径创建
2.方法
getProtocol():获取协议
getHost():获取域名
getPort():获取端口
getFile():获取资源
getPath():获取相对路径
getRef():获取锚点(也称为引用)
getQuery():获取参数 在URL路径的?后面
getFile():获取URL文件名部分
getAuthority():获取此URL的授权部分
getDefaultPort():获取协议的默认端口号
import java.net.*;
import java.io.*;
public class TestURL
{
public static void main(String [] args)
{
URL url;
try {
url = new URL("http://www.baidu.com:80/index.html?uname=vvvvvv#123");
System.out.println("协议:"+url.getProtocol());
System.out.println("授权部分:"+url.getAuthority());
System.out.println("域名:"+url.getHost());
System.out.println("默认端口:"+url.getDefaultPort());
System.out.println("端口:"+url.getPort());
System.out.println("资源:"+url.getFile());
System.out.println("相对路径:"+url.getPath());
System.out.println("锚点:"+url.getRef()); //锚点
System.out.println("参数:"+url.getQuery());
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//结果
协议:http
授权部分:www.baidu.com:80
域名:www.baidu.com
默认端口:80
端口:80
主机:www.baidu.com
资源:/index.html?uname=vvvvvv
相对路径:/index.html
锚点:123
参数:uname=vvvvvv
3.流
InputStream openStream():获取资源网络流
//网络爬虫原理
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;
public class TestURLDemo {
public static void main(String[] args) throws IOException {
URL url = new URL("http://www.baidu.com"); // 主页 默认资源
// 获取资源 网络流
/*
InputStream is = url.openStream();
byte[] flush = new byte[1024];
int len = 0;
while (-1 != (len = is.read(flush))) {
System.out.println(new String(flush, 0, len));
}
is.close();
*/
BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("baidu2.html"), "utf-8"));
String msg = null;
while ((msg = br.readLine()) != null) {
// System.out.println(msg);
bw.append(msg);
bw.newLine();
}
bw.flush();
bw.close();
br.close();
}
}
UDP
1.类 DatagramSocket DatagramPacket
①客户端
(1)创建客户端 DatagramSocket类+指定端口
(2)准备数据 字节数组
(3)打包 DatagramPacket + 服务器地址及端口
(4)发送
(5)释放资源
②服务器端
(1)创建服务器端 DatagramSocket类+指定端口
(2)准备接收容器 字符数组封装DatagramPacket类
(3)包 接受数据
(4)分析
(5)释放资源
PS:服务器需要先创建,否则会引发客户端找不到服务器的问题
//服务器端
public class MyServer {
public static void main(String[] args) throws IOException {
//1、创建服务端 +端口
DatagramSocket server = new DatagramSocket(8888);
//2、准备接受容器
byte[] container = new byte[1024];
//3、封装成 包 DatagramPacket(byte[] buf, int length)
DatagramPacket packet =new DatagramPacket(container, container.length) ;
//4、接受数据
server.receive(packet);
//5、分析数据
byte[] data =packet.getData();
int len =packet.getLength();
System.out.println(new String(data,0,len));
//6、释放
server.close();
}
//客户端
public class MyClient {
public static void main(String[] args) throws IOException {
//1、创建客户端 +端口
DatagramSocket client = new DatagramSocket(6666);
//2、准备数据
String msg ="udp编程";
byte[] data =msg.getBytes();
//3、打包(发送的地点 及端口) DatagramPacket(byte[] buf, int length, InetAddress address, int port)
DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",8888));
//4、发送
client.send(packet);
//5、释放
client.close();
}
//传递除了字符数组以外的东西,需要结合IO流
public class Server {
public static void main(String[] args) throws IOException {
//1、创建服务端 +端口
DatagramSocket server = new DatagramSocket(8888);
//2、准备接受容器
byte[] container = new byte[1024];
//3、封装成 包 DatagramPacket(byte[] buf, int length)
DatagramPacket packet =new DatagramPacket(container, container.length) ;
//4、接受数据
server.receive(packet);
//5、分析数据
double data =convert(packet.getData());
System.out.println(data);
//6、释放
server.close();
}
/**
* 字节数组 +Data 输入流
* @param data
* @return
* @throws IOException
*/
public static double convert(byte[] data) throws IOException{
DataInputStream dis =new DataInputStream(new ByteArrayInputStream(data));
double num =dis.readDouble();
dis.close();
return num;
}
}
public class Client {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//1、创建客户端 +端口
DatagramSocket client = new DatagramSocket(6666);
//2、准备数据
double num =89.12;
byte[] data =convert(num);
//3、打包(发送的地点 及端口) DatagramPacket(byte[] buf, int length, InetAddress address, int port)
DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",8888));
//4、发送
client.send(packet);
//5、释放
client.close();
}
/**
* 字节数组 数据源 +Data 输出流
* @param num
* @return
* @throws IOException
*/
public static byte[] convert(double num) throws IOException{
byte[] data =null;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
DataOutputStream dos =new DataOutputStream(bos);
dos.writeDouble(num);
dos.flush();
//获取数据
data = bos.toByteArray();
dos.close();
return data;
}
}
TCP
面向连接。
1.Socket编程
①服务器端 ServerSocket
(1)创建服务器端 指定端口 ServerSocket(int port)
(2)接受客户端连接 阻塞式Socketaccept()
(3)发送数据 + 接收数据
②客户端
(1)创建客户端 Socket(String host,int port);必须指定服务器+端口,此时就在进行连接
(2)接收数据 + 发送数据
BufferedReader br = new BufferedReader(
new InputStreamReader(
client.getInputStream()));
public class Server {
public static void main(String[] args) throws IOException {
//1、创建服务器 指定端口 ServerSocket(int port)
ServerSocket server = new ServerSocket(8888);
//2、接收客户端连接 阻塞式
Socket socket =server.accept();
System.out.println("一个客户端建立连接");
//3、发送数据
String msg ="欢迎使用";
//输出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(msg);
dos.flush();
}
}
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
//1、创建客户端 必须指定服务器+端口 此时就在连接
Socket client = new Socket("localhost",8888);
//2、接收数据
DataInputStream dis = new DataInputStream(client.getInputStream());
String echo = dis.readUTF();
System.out.println(echo);
}
}
简易聊天室 存在bug
实现群聊私聊功能。
//client
package com.vvvvvv.chatdemo03;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* 创建客户端:发送数据+接受数据
* 写出数据:输出流
* 读取数据:输入流
* @author Administrator
*
*/
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
Socket client = new Socket("localhost",8888);
System.out.println("请输入姓名:");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String name = br.readLine();
if(name.equals(""))
return;
//启动线程
new Thread(new Send(client,name)).start();
new Thread(new Receive(client)).start();
}
}
//server
package com.vvvvvv.chatdemo03;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import com.vvvvvv.chatdemo02.CloseUtil;
/**
* 创建服务器
*
* @author Administrator
*
*/
public class Server {
private List<MyChannel> all = new ArrayList<MyChannel>();
public static void main(String[] args) throws IOException {
new Server().start();//一个线程代表一个客户端
}
//启动线程
public void start() throws IOException {
ServerSocket server = new ServerSocket(8888);
while (true) {
Socket client = server.accept();
MyChannel channel = new MyChannel(client);
all.add(channel);
new Thread(channel).start();
}
}
class MyChannel implements Runnable {
private DataInputStream dis;
private DataOutputStream dos;
private boolean isRunning = true;
private String name;
public MyChannel() {
}
public MyChannel(Socket client) {
try {
dis = new DataInputStream(client.getInputStream());
dos = new DataOutputStream(client.getOutputStream());
this.name = dis.readUTF();
this.send("欢迎加入聊天室");
sendOthers(this.name + "进入了聊天室", true);
} catch (IOException e) {
// e.printStackTrace();
isRunning = false;
CloseUtil.closeAll(dis, dos);
}
}
//发送数据给其他人
//并且做判断是系统信息还是非系统信息 是私聊还是群聊
//私聊格式:@name:context
public void sendOthers(String msg, boolean flag) {
if (msg.startsWith("@") && msg.indexOf(":") > -1) {
String name = msg.substring(1, msg.indexOf(":"));
String context = msg.substring(msg.indexOf(":") + 1);
for(MyChannel temp:all) {
if(temp.name.equals(name)) {
temp.send(this.name+"悄悄地对你说:"+context);
}
}
} else {
for (MyChannel temp : all) {
if (temp == this) {
continue;
}
if(flag)
temp.send("系统消息:"+ msg);
else
temp.send(this.name + "对所有人说:" +msg);
}
}
}
//将msg发送出去 谁调用就发送给谁
public void send(String msg) {
if (null != msg && !msg.equals("")) {
try {
dos.writeUTF(msg);
dos.flush();
} catch (IOException e) {
// e.printStackTrace();
isRunning = false;
CloseUtil.closeAll(dos);
all.remove(this);
}
}
}
//接收数据
public String receive() {
String msg = "";
try {
msg = dis.readUTF();
} catch (IOException e) {
isRunning = false;
CloseUtil.closeAll(dis);
all.remove(this);
}
return msg;
}
@Override
public void run() {
//线程体
while (isRunning) {
sendOthers(this.receive(),false);
}
}
}
}
//客户端发送数据线程
package com.vvvvvv.chatdemo03;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
/**
* 发送数据线程
* @author Administrator
*
*/
public class Send implements Runnable {
//控制台输入流
private BufferedReader console;
//输出流
private DataOutputStream dos;
//线程标识
private boolean isRunning = true;
//当前线程
private String name;
public Send() {
console = new BufferedReader(new InputStreamReader(System.in));
}
public Send(Socket client,String name) {
this();
try {
dos = new DataOutputStream(client.getOutputStream());
this.name = name;
send(this.name);
} catch (IOException e) {
isRunning = false;
CloseUtil.closeAll(dos,console);
}
}
private String getMsgFromConsole() {
try {
return console.readLine();
} catch (IOException e) {
}
return "";
}
/**
* 从控制台接收数据
* 发送数据
*/
public void send (String msg) {
if(null != msg && !msg.equals("")) {
try {
dos.writeUTF(msg);
dos.flush();
} catch (IOException e) {
isRunning = false;
CloseUtil.closeAll(dos,console);
}
}
}
public void run() {
while(isRunning)
send(getMsgFromConsole());
}
}
//客户端接收数据线程
package com.vvvvvv.chatdemo03;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
/**
* 接收数据线程
* @author Administrator
*
*/
public class Receive implements Runnable {
private DataInputStream dis;
private boolean isRunning = true;
public Receive() {
}
public Receive(Socket client) {
try {
dis = new DataInputStream(client.getInputStream());
} catch (IOException e) {
isRunning = false;
CloseUtil.closeAll(dis);
}
}
public String receive() {
String msg = "";
try {
msg = dis.readUTF();
} catch (IOException e) {
isRunning = false;
CloseUtil.closeAll(dis);
}
return msg;
}
public void run() {
while(isRunning)
System.out.println(receive());
}
}
//关闭流工具类
package com.vvvvvv.chatdemo03;
import java.io.Closeable;
import java.io.IOException;
/**
* 关闭流的方法
* @author Administrator
*
*/
public class CloseUtil {
public static void closeAll(Closeable... io) {
for(Closeable temp: io) {
if(null != temp) {
try {
temp.close();
} catch (IOException e) {
}
}
}
}
}