wmproxy
是由Rust
编写,已实现http/https
代理,socks5
代理, 反向代理,静态文件服务器,内网穿透,配置热更新等, 后续将实现websocket
代理等,同时会将实现过程分享出来, 感兴趣的可以一起造个轮子法
gite: https://gitee.com/tickbh/wmproxy
github: https://github.com/tickbh/wmproxy
HTTP中压缩的意义在于降低了网络传输的数据量,从而提高客户端浏览器的访问速度。当然,同时也会增加一点服务器的负担。
HTTP/1.1协议中压缩主要包括gzip压缩和deflate压缩两种方法。其中gzip压缩使用的是LZ77和哈夫曼编码,而deflate压缩使用的是LZ77和哈夫曼编码以及霍夫曼编码。
此外在2015年由Google公司开发的Brotli算法是也基本全面普及开来,Brotli算法的核心原理包括两个部分:预定义的字典和无损压缩算法。预定义的字典是Brotli算法中的一项关键技术,它包含了一些常见的字符序列,例如Web标记、HTML、CSS和JavaScript代码等。Brotli算法的无损压缩算法采用了一种基于模式匹配的压缩方法。它通过预测数据中出现的重复模式,对数据进行压缩。
在HTTP的压缩协议中,这三种压缩算法基本上可以全部被支持。
gzip、deflate和brotli这三种压缩算法都有各自的优势和劣势,具体如下:
以下是压缩解压的数率图:
数据来源src
可以看出brotli的压缩比大概在9左右,gzip大概在7左右,deflate也大概在7左右,压缩比brotli最高,适应网络传输慢的情况,压缩速度gzip和deflate相对较快,解压缩deflate较快,brotli和gzip差不多。
通常寻找rust中的第三方库的时候,可以通过https://crates.io/
进行选择,这里公开的第三方库都会在这里显示,包括使用次数,流行热度,最近下载量,最近更新时间等,可以从多维度的知道该库的好与坏再进行相应的选择。
该库支持三种压缩格式的算法,deflate
, zlib
, gzip
,我们选择用它来做deflate
, gzip
的支持。
该库如库名一般,只支持brotli
算法,相对热度较高,算是支持brolti里最好的一个,我们进行选择。
三种方式均可实现流式的压缩,即边写入数据,边读出压缩数据,不用完全的写入所有数据,完整的实现方法在 RecvStream里,将压缩的数据缓存到
self.cache_body_data
中
定义压缩方法值
pub const COMPRESS_METHOD_NONE: i8 = 0;
pub const COMPRESS_METHOD_GZIP: i8 = 1;
pub const COMPRESS_METHOD_DEFLATE: i8 = 2;
pub const COMPRESS_METHOD_BROTLI: i8 = 3;
此处利用的是类
use flate2::write::GzEncoder
,定义为GzEncoder<BinaryMut>
,其中BinaryMut为压缩后的数据,需要具备std::io::Write
方法。
Consts::COMPRESS_METHOD_GZIP => {
// 数据结束,需要主动调用结束以导出全部结果
if data.len() == 0 {
self.compress.open_write_gz();
let gz = self.compress.write_gz.take().unwrap();
let value = gz.finish().unwrap();
if value.remaining() > 0 {
Self::inner_encode_data(&mut self.cache_body_data, &value, self.is_chunked)?;
}
if self.is_chunked {
Helper::encode_chunk_data(&mut self.cache_body_data, data)
} else {
Ok(0)
}
} else {
self.compress.open_write_gz();
let gz = self.compress.write_gz.as_mut().unwrap();
gz.write_all(data).unwrap();
// 每次写入,在尝试读取出数据
if gz.get_mut().remaining() > 0 {
let s =
Self::inner_encode_data(&mut self.cache_body_data, &gz.get_mut().chunk(), self.is_chunked);
gz.get_mut().clear();
s
} else {
Ok(0)
}
}
}
此处利用的是类
use flate2::write::DeflateEncoder
,定义为DeflateEncoder<BinaryMut>
,其中BinaryMut为压缩后的数据,需要具备std::io::Write
方法。
Consts::COMPRESS_METHOD_DEFLATE => {
// 数据结束,需要主动调用结束以导出全部结果
if data.len() == 0 {
self.compress.open_write_de();
let de = self.compress.write_de.take().unwrap();
let value = de.finish().unwrap();
if value.remaining() > 0 {
Self::inner_encode_data(&mut self.cache_body_data, &value, self.is_chunked)?;
}
if self.is_chunked {
Helper::encode_chunk_data(&mut self.cache_body_data, data)
} else {
Ok(0)
}
} else {
self.compress.open_write_de();
let de = self.compress.write_de.as_mut().unwrap();
de.write_all(data).unwrap();
// 每次写入,在尝试读取出数据
if de.get_mut().remaining() > 0 {
let s =
Self::inner_encode_data(&mut self.cache_body_data, &de.get_mut().chunk(), self.is_chunked);
de.get_mut().clear();
s
} else {
Ok(0)
}
}
}
此处利用的是类
use brotli::CompressorWriter;
,定义为CompressorWriter<BinaryMut>
,其中BinaryMut为压缩后的数据,需要具备std::io::Write
方法。
Consts::COMPRESS_METHOD_BROTLI => {
// 数据结束,需要主动调用结束以导出全部结果
if data.len() == 0 {
self.compress.open_write_br();
let mut de = self.compress.write_br.take().unwrap();
de.flush()?;
let value = de.into_inner();
if value.remaining() > 0 {
Self::inner_encode_data(&mut self.cache_body_data, &value, self.is_chunked)?;
}
if self.is_chunked {
Helper::encode_chunk_data(&mut self.cache_body_data, data)
} else {
Ok(0)
}
} else {
self.compress.open_write_br();
let de = self.compress.write_br.as_mut().unwrap();
de.write_all(data).unwrap();
// 每次写入,在尝试读取出数据
if de.get_mut().remaining() > 0 {
let s =
Self::inner_encode_data(&mut self.cache_body_data, &de.get_mut().chunk(), self.is_chunked);
de.get_mut().clear();
s
} else {
Ok(0)
}
}
}
和压缩不同的是,解压的时候必须将完整的数据进行解压,所以需要收到全部的数据的时候才尝试进行解压,可能我的理解有误,欢迎指出,当下的实现方式可能会占用大量的内存,非我所愿。主要源码在 SendStream中实现。
三种方式均类似,以下
// 收到数据进行缓存,只有到结束时才进行解压缩
match self.compress_method {
Consts::COMPRESS_METHOD_GZIP => {
self.cache_body_data.put_slice(data);
if self.is_end {
self.compress.open_reader_gz(self.cache_body_data.clone());
let gz = self.compress.reader_gz.as_mut().unwrap();
let s = Self::read_all_data(&mut self.cache_buf, &mut self.real_read_buf, gz);
self.cache_body_data.clear();
s
} else {
Ok(0)
}
}
Consts::COMPRESS_METHOD_DEFLATE => {
self.cache_body_data.put_slice(data);
if self.is_end {
self.compress.open_reader_de(self.cache_body_data.clone());
let de = self.compress.reader_de.as_mut().unwrap();
let s = Self::read_all_data(&mut self.cache_buf, &mut self.real_read_buf, de);
self.cache_body_data.clear();
s
} else {
Ok(0)
}
}
Consts::COMPRESS_METHOD_BROTLI => {
self.cache_body_data.put_slice(data);
if self.is_end {
self.compress.open_reader_br(self.cache_body_data.clone());
let br = self.compress.reader_br.as_mut().unwrap();
let s = Self::read_all_data(&mut self.cache_buf, &mut self.real_read_buf, br);
self.cache_body_data.clear();
s
} else {
Ok(0)
}
}
_ => {
self.real_read_buf.put_slice(data);
Ok(data.len())
},
}
如果数据包非常的巨大的时候,可能需要将内存内容写入缓存文件来缓解内存的压力。
压缩为了可以更好的存储,也可以更好的传输,是我们日常生活中必不可少的存在,虽然现在比以前带宽更高,存储比之前的更便宜,但是现在的数据更多,传输延时要求更少,所以高压缩的能力依然非常受欢迎。