刘新修

Dioxus由DioxusLabs开发的全栈应用框架旨在简化跨平台应用的开发

Tue, 10 Dec 2024 09:14:59 +0000

Dioxus是一个现代的、轻量级的、用于构建跨平台UI的库，灵感来源于React。它以其高性能、简洁的API和丰富的生态系统，为开发者提供了一种高效开发原生应用的新方式。

项目简介

Dioxus的核心目标是为移动应用、Web应用、桌面应用以及服务器端渲染提供一致性的开发体验。使用Rust编程语言编写，它提供了与React类似的语法和概念，但利用了Rust的强大功能，如类型安全和编译时检查，从而在性能上取得显著优势。

技术分析

Dioxus的架构基于组件模型，允许开发者以声明式的方式创建可复用的UI元素。与React类似，它使用虚拟DOM来减少对实际DOM的操作，不过Dioxus进一步优化，通过Rust的静态分析能力避免了不必要的更新，实现了更快的渲染速度。

此外，Dioxus还支持SSR（Server-Side Rendering）和SSG（Static Site Generation），并可以无缝地与WebAssembly集成，这使得它能够被广泛应用于Web开发和后端渲染场景。

应用场景

移动应用开发：Dioxus提供了一套完整的工具链，让你可以用Rust直接开发iOS和Android应用。

Web应用：你可以创建高效的单页应用，并受益于Rust的安全性和性能。

桌面应用：借助Electron或其它桌面应用框架，Dioxus可以轻松构建桌面应用。

服务器渲染：对于SEO友好的网站或者需要快速首屏加载的应用，Dioxus的SSR功能非常实用。

特点

高性能：Rust的零成本抽象和编译时优化，使Dioxus的性能远超传统的JavaScript解决方案。

类型安全：利用Rust的类型系统，Dioxus确保代码在运行前无类型错误，提高了软件的稳定性。

简洁API：Dioxus的API设计借鉴了React，对熟悉React的开发者来说，学习曲线较平缓。

跨平台兼容：一套代码，多平台运行，大大提高了开发效率。

强大的社区支持：Dioxus拥有活跃的开发者社区，不断推出新的库和工具，丰富生态体系。

快速使用指南

安装 CLI 工具：首先，安装 Dioxus 提供的 CLI 工具。可以通过以下命令进行安装：

cargo install dioxus-cli

创建新项目：使用 CLI 工具创建一个新的 Dioxus 项目：

dioxus new my_project

运行开发服务器：进入项目目录并启动开发服务器：

cd my_project dioxus serve

编写代码：在 src 目录下编写你的应用代码。Dioxus 使用类似 JSX 的语法，使得编写 UI 代码变得简单直观。

打包和部署：当应用开发完成后，可以使用以下命令进行打包和部署：

dioxus bundle --release

通过以上步骤，你可以快速上手 Dioxus 并开始构建跨平台应用。Dioxus 的高性能、易用性和强大的功能使其成为现代应用开发的理想选择。

结论

如果你正在寻找一种能够提升应用性能，同时保持开发效率的技术栈，Dioxus值得你尝试。其结合了React的易用性和Rust的高性能，为开发者带来前所未有的开发体验。无论是新项目还是现有项目的重构，Dioxus都能作为一个强大且灵活的选择。

Go实现多线程分片下载文件

Mon, 21 Oct 2024 08:39:22 +0000

我们在下载大文件时，通常会使用多线程下载的方式来加快下载速度。例如常用的多线程下载工具（Gopeed、Aria2、XDM等等），都是通过多线程下载技术充分利用了网络带宽，以提高下载速度。

那么多线程下载是怎么实现的呢？多个线程发送网络请求，是怎么做到同时下载一个文件呢？事实上，借助HTTP协议中的一些机制就可以实现了！

今天我们就通过使用Go语言为例，从了解HTTP请求相关的一些机制开始，实现一个多线程下载的示例。

1，多线程下载原理

事实上，多线程下载的原理很简单，主要的步骤如下：

获取待下载文件大小
每个线程下载文件的一部分
全部下载完成后，拼接为完整文件

实现这些步骤，就涉及到HTTP协议的下列相关机制。

(1) `HEAD`请求 - 只获取请求头

我们通常发送HTTP请求大多数是GET或者POST类型，发送请求后我们会立即获取响应体，浏览器则会根据响应体的类型来处理内容，例如返回的是text/html就会作为网页显示，返回image/png就会解码为图片等等，响应体的类型由响应头Content-Type标识。当我们下载文件时，事实上也是发送HTTP请求，只不过服务器返回的响应体就是文件本身了！其类型则是application/octet-stream，浏览器也知道这是个文件需要下载。

当然，文件作为响应体通常比起网页、图片要大得多，在多线程下载时，我们就要先获取文件的大小，而不是立即获取文件本身，这时我们就可以向服务器发起HEAD请求而不是GET请求。

服务器收到HEAD请求后，就只会返回对应的响应头，而不会返回响应体，这样我们就可以在下载文件之前，读取响应头中的Content-Length来先获取待下载文件大小。

(2) `Range`请求头 - 只获取部分响应体

知道了文件大小，我们就需要让每个线程只下载一部分文件，借助HTTP的Range请求头，就可以实现只让服务端返回响应体内容的一部分，而不是返回完整的响应体。

这里我们先来借助书籍《图解HTTP》中对Range请求头的讲解，来学习一下：

XML/HTML代码

Range: bytes=5001-10000

那么服务端就只会返回响应体的第5001到第10000字节的内容部分，包含第5001和第10000字节，0表示响应体的第一个字节。

这样，在多个线程同时下载文件时，我们在每个线程的请求中使用Range请求头，就可以实现一个线程只下载文件的一部分了！

(3) 为什么多线程下载可以提升速度？

事实上，在我们客户端（下载文件的）和服务端双向网络通信情况都很好的情况下，使用单线程和多线程下载的速度是几乎没有差异的，也就是说能够跑满我们客户端的全部带宽，那么这种情况下我们使用单线程下载反而更能够节省硬件和网络资源。

但是在我们客户端和服务端之间网络波动较大的情况下，例如我们国内从Github下载文件的时候，就会发现多线程下载速度比单线程快得多，反之使用单线程完全无法充分利用我们的网络带宽。

这种现象事实上是因为TCP连接的慢启动机制导致的，众所周知HTTP是基于TCP的协议，每次我们建立HTTP连接时，包括下载文件，都是在传输层基于TCP协议进行传输。TCP慢启动机制是TCP 协议中一种拥塞控制的机制，目的是在开始数据传输时逐步探测网络的容量，避免瞬间发送大量数据而导致网络拥塞。慢启动不是字面意义上的“慢”，而是相对于立即使用最大带宽而言，它会逐渐增加传输速率。

慢启动机制的过程简要概括如下：

一开始建立连接：当一个新的TCP连接建立后，发送方并不知道当前网络的拥塞情况。因此，发送方不会马上发送大量数据，而是会使用慢启动机制来逐步增加数据传输的速率，在TCP中使用阻塞窗口cwnd来限制发送的数据量，也就是说一开始cwnd是非常小的
拥塞窗口增长：在建立连接后，每当接收到一个确认ACK包时，cwnd会指数级增长，直到达到网络的带宽限制或者某个拥塞控制的阈值（称为慢启动阈值ssthresh），这个过程会一直持续，直到发送方探测到网络出现了拥塞（比如丢包或者确认延迟变长），或者cwnd达到了某个预定义的慢启动阈值ssthresh
慢启动的终止：慢启动机制会在以下情况终止：
- 达到慢启动阈值ssthresh：当拥塞窗口cwnd增长到慢启动阈值ssthresh时，慢启动机制停止，此时TCP会进入另一种拥塞控制机制，称为拥塞避免，这时cwnd增长变为线性而非指数级
- 发生拥塞（如丢包或超时）：如果发送方检测到数据包丢失（例如没有收到确认），它会认为网络已经出现拥塞，此时ssthresh会被调整为当前cwnd的一半，然后cwnd会重置为1 MSS，重新进入慢启动阶段

可见TCP连接使用cwnd限制两者发送的数据量的大小，并逐步“试探”两者传输数据速率的上限并增加传输的数据量。

在我们下载文件时，事实上是服务端在向我们发送文件，如果网络波动较大、不稳定，TCP连接机会一直将cwnd限制在一个较小的值，在单位时间内，服务端也无法向我们发送更大的数据量。

此时，如果我们使用多线程下载，和服务端建立多个TCP连接，这样即使每个TCP连接的cwnd较小，所有TCP连接加起来传输的数据量仍然可以占满我们的带宽。

2，Go代码实现

知道了HTTP的上述几个机制，相信大家就知道如何实现一个简单的多线程下载了！我们可以总结主要步骤如下：

发送HEAD类型请求，通过Content-Length请求头获取待下载文件大小
根据给定的线程数量，结合待下载文件大小，确定每个线程下载的范围部分，也就是每个线程的Range请求头字节范围
启动所有线程，使得每个线程下载它们对应的部分文件，并等待全部线程下载完成
合并每个线程下载的部分为最终文件
清理每个线程下载的文件部分

这里分别设计下列类（结构体），用于存放多线程下载时的传入参数和状态量：

上述ShardTask类表示一个线程的下载任务，其中会完成一个分片（文件的一部分）的下载请求操作，它有如下作为参数的属性：

Url 下载的文件地址
Order 分片序号
ShardFilePath 这个分片文件的保存路径
RangeStart和RangeEnd 下载的文件起始范围和结束范围，用于设定Range请求头

此外，还有作为下载状态的属性：

DownloadSize 下载任务进行时，这个线程已下载的文件部分大小
TaskDone 这个线程的下载任务是否完成

该类的成员方法如下：

DoShardGet 执行分片下载任务，在其中会根据RangeStart和RangeEnd设定对应的HTTP请求头，发送请求并下载对应的文件部分

然后就是ParallelGetTask类，表示一整个多线程下载任务，其中包含了一个多线程下载任务的参数和状态量，并且实现了多线程下载的每个步骤，它有如下作为参数的属性：

Url 文件的下载链接
FilePath 文件下载完成后的保存位置
Concurrent 下载并发数，即同时下载的分片数量
TempFolder 临时分片文件的保存文件夹

此外还有作为状态的属性：

TotalSize 待下载文件的总大小
ShardTaskList 存储所有分片任务对象指针的列表

该类中的方法主要是分片下载的一些步骤如下：

getLength 发送HEAD请求获取Content-Length以获取文件大小，获取后将其设定到TotalSize属性
allocateTask 根据给定的线程数和获取到的文件大小，计算每个线程下载的文件内容范围，并创建对应的ShardTask结构体放入ShardTaskList中
downloadShard 为每一个ShardTask对象创建一个线程（Goroutine）并在新的线程中调用ShardTask对象的下载分片方法，以启动所有线程的下载任务，并通过sync.WaitGroup来等待全部线程完成
mergeFile 下载完成后，合并每个分片为最终文件
cleanShard 合并完成后，清理下载的每个分片文件
printTotalProcess 这是一个附加的辅助方法，用于实时输出下载进度
Run 启动整个多线程下载任务，该函数是暴露的公开函数，其中对上述每个步骤函数进行了组织，按顺序调用执行

下面，我们来看一下它们的代码实现。

(1) `ShardTask` - 一个线程的下载任务

C#代码

package model
import (
"bufio"
"fmt"
"github.com/fatih/color"
"io"
"net/http"
"os"
"sync"
)
// 全局HTTP客户端
var httpClient = http.Client{
Transport: &http.Transport{
// 关闭keep-alive确保一个线程就使用一个TCP连接
DisableKeepAlives: true,
},
}
// ShardTask 单个分片下载任务的任务参数和状态量
type ShardTask struct {
// 下载链接
Url string
// 分片序号，从1开始
Order int
// 这个分片文件的路径
ShardFilePath string
// 分片的起始范围（字节，包含）
RangeStart int64
// 分片的结束范围（字节，包含）
RangeEnd int64
// 已下载的部分（字节）
DownloadSize int64
// 该任务是否完成
TaskDone bool
}
// NewShardTask 构造函数
func NewShardTask(url string, order int, shardFilePath string, rangeStart int64, rangeEnd int64) *ShardTask {
return &ShardTask{
// 设定任务参数
Url: url,
Order: order,
ShardFilePath: shardFilePath,
RangeStart: rangeStart,
RangeEnd: rangeEnd,
// 初始化状态量
DownloadSize: 0,
TaskDone: false,
}
}
// DoShardGet 开始下载这个分片（该方法在goroutine中执行）
func (task *ShardTask) DoShardGet(waitGroup *sync.WaitGroup) {
// 创建文件
file, e := os.OpenFile(task.ShardFilePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0755)
if e != nil {
color.Red("任务%d创建文件失败！", task.Order)
color.HiRed("%s", e)
return
}
// 准备请求
request, e := http.NewRequest("GET", task.Url, nil)
if e != nil {
color.Red("任务%d创建请求出错！", task.Order)
color.HiRed("%s", e)
return
}
// 设定请求头
request.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", task.RangeStart, task.RangeEnd))
// 发送请求
response, e := httpClient.Do(request)
if e != nil {
color.Red("任务%d发送下载请求出错！", task.Order)
color.HiRed("%s", e)
return
}
// 读取请求体
body := response.Body
// 读取缓冲区
buffer := make([]byte, 8092)
// 准备写入文件
writer := bufio.NewWriter(file)
for {
// 读取一次内容至缓冲区
readSize, readError := body.Read(buffer)
if readError != nil {
// 如果读取完毕则退出循环
if readError == io.EOF {
break
} else {
color.Red("任务%d读取响应错误！", task.Order)
color.HiRed("%s", readError)
return
}
}
// 把缓冲区内容追加至文件
_, writeError := writer.Write(buffer[0:readSize])
if writeError != nil {
color.Red("任务%d写入文件时出现错误！", task.Order)
color.HiRed("%s", writeError)
return
}
_ = writer.Flush()
// 记录下载进度
task.DownloadSize += int64(readSize)
}
// 关闭全部资源
_ = body.Close()
_ = file.Close()
// 标记任务完成
task.TaskDone = true
// 使线程组中计数器-1
waitGroup.Done()
}

构造函数NewShardTask负责完成ShardTask的参数传入和状态量初始化，而DoShardGet方法实现了下载一个文件分片的完整步骤，从创建文件准备写入，到设定请求头，发出请求，最后读取响应体保存到文件。

此外，可见这里的http.Client对象中，我们将其DisableKeepAlives设为了true即关闭keep-alive，这是因为默认情况下Go语言的HTTP客户端会复用TCP连接，即使你多个线程发起请求，也会使用一个TCP连接进行。

而多线程下载需要每个线程持有一个单独的TCP连接来达到突破cwnd的限制，因此这里关闭keep-alive实现每个线程发起请求时，使用单独的TCP连接。

(2) `ParallelGetTask` - 一整个多线程下载任务

C#代码

package model
import (
"bufio"
"fmt"
"gitee.com/swsk33/shard-download-demo/util"
"github.com/fatih/color"
"io"
"net/http"
"os"
"path/filepath"
"strconv"
"sync"
"time"
)
// ParallelGetTask 多线程下载任务类，存放一个多线程下载任务的参数和状态量
type ParallelGetTask struct {
// 文件的下载链接
Url string
// 文件的最终保存位置
FilePath string
// 下载并发数
Concurrent int
// 下载的分片临时文件保存文件夹
TempFolder string
// 下载文件的总大小
TotalSize int64
// 全部的下载分片任务参数列表
ShardTaskList []*ShardTask
}
// NewParallelGetTask 构造函数
func NewParallelGetTask(url string, filePath string, concurrent int, tempFolder string) *ParallelGetTask {
return &ParallelGetTask{
// 参数赋值
Url: url,
FilePath: filePath,
Concurrent: concurrent,
TempFolder: tempFolder,
// 初始化状态量
TotalSize: 0,
ShardTaskList: make([]*ShardTask, 0),
}
}
// 发送HEAD请求获取待下载文件的大小
func (task *ParallelGetTask) getLength() error {
// 发送请求
response, e := http.Head(task.Url)
if e != nil {
color.Red("发送HEAD请求出错！")
return e
}
// 读取并设定长度
task.TotalSize = response.ContentLength
return nil
}
// 根据待下载文件的大小和设定的并发数，创建每个分片任务对象
func (task *ParallelGetTask) allocateTask() {
// 如果并发数大于总大小，则进行调整
if int64(task.Concurrent) > task.TotalSize {
task.Concurrent = int(task.TotalSize)
}
// 开始计算每个分片的下载范围
eachSize := task.TotalSize / int64(task.Concurrent)
// 创建任务对象
for i := 0; i < task.Concurrent; i++ {
task.ShardTaskList = append(task.ShardTaskList, NewShardTask(task.Url, i+1, filepath.Join(task.TempFolder, strconv.Itoa(i+1)), int64(i)*eachSize, int64(i+1)*eachSize-1))
}
// 处理末尾部分
if task.TotalSize%int64(task.Concurrent) != 0 {
task.ShardTaskList[task.Concurrent-1].RangeEnd = task.TotalSize - 1
}
}
// 根据任务列表进行多线程分片下载操作
func (task *ParallelGetTask) downloadShard() {
// 创建线程组
waitGroup := &sync.WaitGroup{}
// 开始执行全部分片下载线程
for _, task := range task.ShardTaskList {
go task.DoShardGet(waitGroup)
waitGroup.Add(1)
}
// 等待全部下载完成
waitGroup.Wait()
}
// 下载完成后，合并分片文件
func (task *ParallelGetTask) mergeFile() error {
// 创建目的文件
targetFile, e := os.OpenFile(task.FilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0755)
if e != nil {
color.Red("创建目标文件出错！")
return e
}
// 创建写入器
writer := bufio.NewWriter(targetFile)
// 准备读取每个分片文件
for _, shard := range task.ShardTaskList {
shardFile, e := os.OpenFile(shard.ShardFilePath, os.O_RDONLY, 0755)
if e != nil {
color.Red("读取分片文件出错！")
return e
}
reader := bufio.NewReader(shardFile)
readBuffer := make([]byte, 1024*1024)
for {
// 读取每个分片文件，一次读取1KB
readSize, readError := reader.Read(readBuffer)
// 处理结束或错误
if readError != nil {
if readError == io.EOF {
break
} else {
color.Red("读取分片文件出错！")
return readError
}
}
// 写入到最终合并的文件
_, writeError := writer.Write(readBuffer[0:readSize])
if writeError != nil {
color.Red("写入合并文件出错！")
return writeError
}
_ = writer.Flush()
}
// 关闭分片文件资源
_ = shardFile.Close()
}
// 关闭目的文件资源
_ = targetFile.Close()
return nil
}
// 删除分片临时文件
func (task *ParallelGetTask) cleanShard() error {
for _, shard := range task.ShardTaskList {
e := os.Remove(shard.ShardFilePath)
if e != nil {
color.Red("删除分片临时文件%s出错！", shard.ShardFilePath)
return e
}
}
return nil
}
// 在一个新线程中，实时输出每个分片的下载进度和总进度
func (task *ParallelGetTask) printTotalProcess() {
go func() {
// 上一次统计时的已下载大小，用于计算速度
var lastDownloadSize int64 = 0
for {
// 如果全部任务完成则结束输出，并统计并发数
allDone := true
// 当前并发数
currentTaskCount := 0
for _, shardTask := range task.ShardTaskList {
if !shardTask.TaskDone {
allDone = false
currentTaskCount += 1
}
}
if allDone {
break
}
// 统计所有分片已下载大小之和
var totalDownloadSize int64 = 0
for _, shardTask := range task.ShardTaskList {
totalDownloadSize += shardTask.DownloadSize
}
// 计算速度
currentDownload := totalDownloadSize - lastDownloadSize
lastDownloadSize = totalDownloadSize
speedString := util.ComputeSpeed(currentDownload, 300)
// 输出到控制台
fmt.Printf("\r当前并发数：%3d 速度：%s 总进度：%3.2f%%", currentTaskCount, speedString, float32(totalDownloadSize)/float32(task.TotalSize)*100)
// 等待300ms
time.Sleep(300 * time.Millisecond)
}
}()
}
// Run 开始执行整个分片多线程下载任务
func (task *ParallelGetTask) Run() error {
// 获取文件大小
e := task.getLength()
if e != nil {
color.Red("%s", e)
return e
}
color.HiYellow("已获取到下载文件大小：%d字节", task.TotalSize)
// 分配任务
task.allocateTask()
color.HiYellow("已完成分片任务分配，共计%d个任务", len(task.ShardTaskList))
// 开启进度输出
task.printTotalProcess()
// 开始下载分片
task.downloadShard()
color.HiYellow("\n所有分片已下载完成！")
// 开始合并文件
e = task.mergeFile()
if e != nil {
color.Red("%s", e)
return e
}
color.HiYellow("合并分片完成！")
// 清理临时分片文件
e = task.cleanShard()
if e != nil {
color.Red("%s", e)
return e
}
color.HiYellow("清理分片临时文件完成！")
color.Green("分片下载任务完成！")
return nil
}

上述printTotalProcess函数中，util.ComputeSpeed函数用于计算下载速度并自动转换为可读单位，代码如下：

C#代码

package util
import (
"fmt"
"math"
)
// 关于单位的实用工具函数
// ComputeSpeed 计算网络速度
// size 一段时间内下载的数据大小，单位字节
// timeElapsed 经过的时间长度，单位毫秒
// 返回计算得到的网速，会自动换算单位
func ComputeSpeed(size int64, timeElapsed int) string {
bytePerSecond := size / int64(timeElapsed) * 1000
if 0 <= bytePerSecond && bytePerSecond <= 1024 {
return fmt.Sprintf("%4d Byte/s", bytePerSecond)
}
if bytePerSecond > 1024 && bytePerSecond <= int64(math.Pow(1024, 2)) {
return fmt.Sprintf("%6.2f KB/s", float64(bytePerSecond)/1024)
}
if bytePerSecond > 1024*1024 && bytePerSecond <= int64(math.Pow(1024, 3)) {
return fmt.Sprintf("%6.2f MB/s", float64(bytePerSecond)/math.Pow(1024, 2))
}
return fmt.Sprintf("%6.2f GB/s", float64(bytePerSecond)/math.Pow(1024, 3))
}

可见通过构造函数NewParallelGetTask完成参数传递和状态量设定后，其它每个私有函数都对应我们多线程下载中的一个步骤，最后由公开函数Run统筹组织起所有的步骤，完成整个多线程下载任务。

3，实现效果

现在我们在main函数中创建一个ParallelGetTask对象，设定好参数后调用其Run方法即可开始多线程下载文件的任务：

C#代码

package main
import (
"gitee.com/swsk33/shard-download-demo/model"
)
func main() {
// 创建任务
task := model.NewParallelGetTask(
"https://github.com/jgraph/drawio-desktop/releases/download/v24.7.17/draw.io-24.7.17-windows-installer.exe",
"C:\\Users\\swsk33\\Downloads\\draw.io.exe",
64,
"C:\\Users\\swsk33\\Downloads\\temp",
)
// 执行任务
_ = task.Run()
}

MD5 加密之 java 与 js 实现

Tue, 09 Jan 2024 08:45:10 +0000

MD5 加密算法实际是一种信息摘要算法，其加密不可逆向解密；

其一般用作数据签名，来确保信息传输的完整性与安全性；

完整性：传输数据完整未丢失
安全性：数据未被恶意篡改

一、java 实现 MD5 加密

Java代码

public class MD5Util {
/**
* 对字符串md5加密
*
* @param str 传入要加密的字符串
* @return MD5加密后的字符串(小写+字母)
*/
public static String getMD5LowerCase(String str) {
try {
// 生成一个MD5加密计算摘要
MessageDigest md = MessageDigest.getInstance("MD5");
// 计算md5函数
md.update(str.getBytes());
// digest()最后确定返回md5 hash值，返回值为8为字符串。因为md5 hash值是16位的hex值，实际上就是8位的字符
// BigInteger函数则将8位的字符串转换成16位hex值，用字符串来表示；得到字符串形式的hash值
return new BigInteger(1, md.digest()).toString(16);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 对字符串md5加密
*
* @param str 传入要加密的字符串
* @return MD5加密后的字符串(大写+数字)
*/
public static String getMD5UpperCase(String s) {
char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F' };
try {
byte[] btInput = s.getBytes();
// 获得MD5摘要算法的 MessageDigest 对象
MessageDigest mdInst = MessageDigest.getInstance("MD5");
// 使用指定的字节更新摘要
mdInst.update(btInput);
// 获得密文
byte[] md = mdInst.digest();
// 把密文转换成十六进制的字符串形式
int j = md.length;
char str[] = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static void main(String[] args) {
String str = "\"我+Admin1234~！@#￥%……&*（）\"";
System.out.println(str);
//"我+Admin1234~！@#￥%……&*（）"
String s1 = getMD5LowerCase(str);
System.out.println(s1);
//6bb6f83c026357a15cdf12e5d6b2b310
String s2 = getMD5UpperCase(str);
System.out.println(s2);
//6BB6F83C026357A15CDF12E5D6B2B310
}
}

测试

db06c78d1e24cf708a14ce81c9b617ec

DB06C78D1E24CF708A14CE81C9B617EC

二、js 实现 MD5 加密

使用第三方库 crypto-js，示例代码如下：

XML/HTML代码

>
<html lang="zh-CN">
<head>
<meta charset="utf-8">
<title>111title>
<style type="text/css">
body{background:#2C91AE;}
style>
head>
<body>
body>
<script src="http://172.16.102.156/public/crypto/crypto-js.min.js">script>
<script type="text/javascript" src="md5.js">script>
<script type="text/javascript">
/*** 刘新修本地md5加密方法封装(大写) ***/
// function md5(string) {
// function rotateLeft(lValue, iShiftBits) {
// return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
// }
// function addUnsigned(lX, lY) {
// var lX4, lY4, lX8, lY8, lResult;
// lX8 = (lX & 0x80000000);
// lY8 = (lY & 0x80000000);
// lX4 = (lX & 0x40000000);
// lY4 = (lY & 0x40000000);
// lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
// if (lX4 & lY4) {
// return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
// }
// if (lX4 | lY4) {
// if (lResult & 0x40000000) {
// return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
// } else {
// return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
// }
// } else {
// return (lResult ^ lX8 ^ lY8);
// }
// }
// function f(x, y, z) {
// return (x & y) | ((~x) & z);
// }
// function g(x, y, z) {
// return (x & z) | (y & (~z));
// }
// function h(x, y, z) {
// return (x ^ y ^ z);
// }
// function i(x, y, z) {
// return (y ^ (x | (~z)));
// }
// function FF(a, b, c, d, x, s, ac) {
// a = addUnsigned(a, addUnsigned(addUnsigned(f(b, c, d), x), ac));
// return addUnsigned(rotateLeft(a, s), b);
// }
// function GG(a, b, c, d, x, s, ac) {
// a = addUnsigned(a, addUnsigned(addUnsigned(g(b, c, d), x), ac));
// return addUnsigned(rotateLeft(a, s), b);
// }
// function HH(a, b, c, d, x, s, ac) {
// a = addUnsigned(a, addUnsigned(addUnsigned(h(b, c, d), x), ac));
// return addUnsigned(rotateLeft(a, s), b);
// }
// function II(a, b, c, d, x, s, ac) {
// a = addUnsigned(a, addUnsigned(addUnsigned(i(b, c, d), x), ac));
// return addUnsigned(rotateLeft(a, s), b);
// }
// function convertToWordArray(string) {
// var lWordCount;
// var lMessageLength = string.length;
// var lNumberOfWords_temp1 = lMessageLength + 8;
// var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
// var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
// var lWordArray = new Array(lNumberOfWords - 1);
// var lBytePosition = 0;
// var lByteCount = 0;
// while (lByteCount < lMessageLength) {
// lWordCount = (lByteCount - (lByteCount % 4)) / 4;
// lBytePosition = (lByteCount % 4) * 8;
// lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition));
// lByteCount++;
// }
// lWordCount = (lByteCount - (lByteCount % 4)) / 4;
// lBytePosition = (lByteCount % 4) * 8;
// lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
// lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
// lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
// return lWordArray;
// }
// function wordToHex(lValue) {
// var WordToHexValue = "", WordToHexValue_temp = "", lByte, lCount;
// for (lCount = 0; lCount <= 3; lCount++) {
// lByte = (lValue >>> (lCount * 8)) & 255;
// WordToHexValue_temp = "0" + lByte.toString(16);
// WordToHexValueWordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
// }
// return WordToHexValue;
// }
// function utf8Encode(string) {
// stringstring = string.replace(/\r\n/g, "\n");
// var utftext = "";
// for (var n = 0; n < string.length; n++) {
// var c = string.charCodeAt(n);
// if (c < 128) {
// utftext += String.fromCharCode(c);
// }
// else if ((c > 127) && (c < 2048)) {
// utftext += String.fromCharCode((c >> 6) | 192);
// utftext += String.fromCharCode((c & 63) | 128);
// }
// else {
// utftext += String.fromCharCode((c >> 12) | 224);
// utftext += String.fromCharCode(((c >> 6) & 63) | 128);
// utftext += String.fromCharCode((c & 63) | 128);
// }
// }
// return utftext;
// }
// var x = [],
// k, AA, BB, CC, DD, a, b, c, d,
// S11 = 7, S12 = 12, S13 = 17, S14 = 22,
// S21 = 5, S22 = 9 , S23 = 14, S24 = 20,
// S31 = 4, S32 = 11, S33 = 16, S34 = 23,
// S41 = 6, S42 = 10, S43 = 15, S44 = 21;
// string = utf8Encode(string);
// x = convertToWordArray(string);
// // console.log(JSON.stringify(x))
// // console.log(x.length)
// a = 0x67452301;
// b = 0xEFCDAB89;
// c = 0x98BADCFE;
// d = 0x10325476;
// for (k = 0; k < x.length; k += 16) {
// AA = a;
// BB = b;
// CC = c;
// DD = d;
// a = FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
// d = FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
// c = FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
// b = FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
// a = FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
// d = FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
// c = FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
// b = FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
// a = FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
// d = FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
// c = FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
// b = FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
// a = FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
// d = FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
// c = FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
// b = FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
// a = GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
// d = GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
// c = GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
// b = GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
// a = GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
// d = GG(d, a, b, c, x[k + 10], S22, 0x2441453);
// c = GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
// b = GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
// a = GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
// d = GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
// c = GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
// b = GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
// a = GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
// d = GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
// c = GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
// b = GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
// a = HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
// d = HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
// c = HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
// b = HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
// a = HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
// d = HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
// c = HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
// b = HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
// a = HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
// d = HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
// c = HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
// b = HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
// a = HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
// d = HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
// c = HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
// b = HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
// a = II(a, b, c, d, x[k + 0], S41, 0xF4292244);
// d = II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
// c = II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
// b = II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
// a = II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
// d = II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
// c = II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
// b = II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
// a = II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
// d = II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
// c = II(c, d, a, b, x[k + 6], S43, 0xA3014314);
// b = II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
// a = II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
// d = II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
// c = II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
// b = II(b, c, d, a, x[k + 9], S44, 0xEB86D391);
// a = addUnsigned(a, AA);
// b = addUnsigned(b, BB);
// c = addUnsigned(c, CC);
// d = addUnsigned(d, DD);
// }
// var temp = wordToHex(a) + wordToHex(b) + wordToHex(c) + wordToHex(d);
// return temp.toUpperCase();
// };
// console.log('刘新修本地封装/md5加密(--测试--)', md5('测试'))
//"DB06C78D1E24CF708A14CE81C9B617EC"
/*** 第三方类库CryptoJS.MD5()方法 || 和中国文书网测试结果一致(小写) ***/
console.log('刘新修/CryptoJS.MD5()-加密(--测试--)\n', CryptoJS.MD5('测试').toString())
script>
html>

中网文书网/MD5加密(--测试--) db06c78d1e24cf708a14ce81c9b617ec

刘新修/CryptoJS.MD5()-加密(--测试--) db06c78d1e24cf708a14ce81c9b617ec

这个文件只能在登入之后下载。请先注册或登入

php json 处理gbk转码utf-8问题（ json_encode转换数组，值为null）

Tue, 28 Jul 2020 05:40:35 +0000

遇到个很幼稚的问题，用json_encode把数组转换为json时，发现转化的值为null。怎么回事呢？查找手册：发现了下面的话：

该函数只能接受 UTF-8 编码的数据（译注：指字符/字符串类型的数据）

原来数组中有中文，需要转码哦，写个转换字符编码的函数吧：

PHP代码

function encodeConvert($str,$fromCode,$toCode)
{
if (strtoupper($toCode) == strtoupper($fromCode)) return $str;
if (is_string($str)) {
if (function_exists('mb_convert_encoding')) {
return mb_convert_encoding($str, $toCode, $fromCode);
} else {
return iconv($fromCode, $toCode, $str);
}
} elseif (is_array($str)) {
foreach ($str as $k => $v) {
$str[$k] = encodeConvert($v, $fromCode, $toCode);
}
return $str;
}
return $str;
}

对于数组，通过下面方式json_encode调用，一切ok。

PHP代码

$json_api=json_encode(encodeConvert($json_api,'gb2312','utf-8'));
$json_api=json_decode(json_decode($json_api));

今天数组json_encode转json的时候，输出一片空白，难道是数据量太大了？导致输出空白了？
后来检查下php程序似乎没有出错，就是json_encode的时候出现了问题，那到底是什么问题呢？

我们先来说下json_encode这个函数

C#代码

(PHP 5 >= 5.2.0, PECL json >= 1.2.0, PHP 7)
json_encode — 对变量进行 JSON 编码
说明
-----------------------------------------------------------
string json_encode ( mixed $value [, int $options = 0 [, int $depth = 512 ]] )
参数
-----------------------------------------------------------
value
待编码的 value ，除了resource 类型之外，可以为任何数据类型。
所有字符串数据的编码必须是 UTF-8。
options
由以下常量组成的二进制掩码： JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT, JSON_PRESERVE_ZERO_FRACTION, JSON_UNESCAPED_UNICODE, JSON_PARTIAL_OUTPUT_ON_ERROR。
depth
设置最大深度。必须大于0。
返回值
-----------------------------------------------------------
成功则返回 JSON 编码的 string 或者在失败时返回 FALSE 。

注意：上面对参数明确说明（所有字符串数据的编码必须是 UTF-8）

可能正是因为这一点导致我输出错误，但是我怎么知道，会是这个错误呢？因为我发现有一个这个函数json_last_error

我们看下这个函数

C#代码

(PHP 5 >= 5.3.0, PHP 7)
json_last_error — 返回最后发生的错误
说明
-----------------------------------------------------------
int json_last_error ( void )
如果有，返回 JSON 编码解码时最后发生的错误。
参数
-----------------------------------------------------------
此函数没有参数。
返回值
-----------------------------------------------------------
返回一个整型（integer），这个值会是以下的常量之一：

C#代码

例如：
echo json_encode(array('error' => '0', 'message' => '没有错误'));
var_dump(json_last_error());
//这里也可以是json_decode
//错误码对照
0 JSON_ERROR_NONE
1 JSON_ERROR_DEPTH
2 JSON_ERROR_STATE_MISMATCH
3 JSON_ERROR_CTRL_CHAR
4 JSON_ERROR_SYNTAX
5 JSON_ERROR_UTF8
6 JSON_ERROR_RECURSION
7 JSON_ERROR_INF_OR_NAN
8 JSON_ERROR_UNSUPPORTED_TYPE

我返回的是 int 5，对照返回错误码，自然而然就是（异常的 UTF-8 字符，也许是因为不正确的编码）这个错误了，知道错误后，然后检查你要返回的数据，再做下处理就OK了。

实例化php类的时候如何传参

Thu, 18 May 2017 09:55:14 +0000

　当我们实例化一个php类的时候，要怎么传递参数呢？这取决于该类的构造方法。

　　例：

　　person.class.php

　　class person{

　　var $name;

　　var $color;

　　var $sex;

　　var $age;

　　function __construct（$name,$age='',$sex='boy'）{

　　$this->name = $name;

　　$this->age = $age;

　　$this->sex = $sex;

　　$this->color = 'yello';

　　}

　　function eat（）{

　　echo $this->name.'要吃饭';

　　}

　　function xinxi（）{

　　echo $this->name.' is '.$this->sex.' and age is '.$this->age.' fuse is '.$this->color;

　　}

　　son.php

　　include（'person.class.php'）；

　　$son = new person（'cuihua',25,'girl'）；//此处的参数传递要和类的构造方法里面的参数顺序对应

　　//$son->xinxi（）；//cuihua is girl and age is 25 fuse is yello

　　$son->name = '田妞';

　　$son->eat（）；//田妞要吃饭

PHP按符号截取字符串的指定部分

Wed, 26 Oct 2016 06:30:39 +0000

有时我们想截取最后一个斜杠'/'后面的数字；

有时我们又需要截取第一个斜杠'/'前面的内容判断用户输入的url链接带不带http://等等；

字符串的截取php内置函数就有很多种；简单的写几个示例；

1	`$str='123/456/789/abc';`

截取第一个斜杠前面的内容可以这样来：

1	`echo` `substr($str,0,strpos($str,` `'/'))`

或者

$array=explode('/', $str);
echo $array[0];
// 输出 123

截取第一个斜杠后面的内容可以这样来：

echo substr($str,strpos($str,'/')+1);
//输出 456/789/abc

截取最后一个斜杠后面的内容可以这样来：

1	`echo` `trim(strrchr($str,` `'/'),'/');`

或者如果知道斜杠的个数

$array=explode('/', $str);
echo $array[3];
//输出 abc

但是问题来了；如果不知道有多少个斜杠呢？如果想要第二个斜杠和第三个斜杠中间的内容呢？

下面我写的这个函数就可以轻松解决如上所有问题；

/**
 * 按符号截取字符串的指定部分
 * @param string $str 需要截取的字符串
 * @param string $sign 需要截取的符号
 * @param int $number 如是正数以0为起点从左向右截  负数则从右向左截
 * @return string 返回截取的内容
 */
 
function cut_str($str,$sign,$number){
    $array=explode($sign, $str);
    $length=count($array);
    if($number<0){
        $new_array=array_reverse($array);
        $abs_number=abs($number);
        if($abs_number>$length){
            return 'error';
        }else{
            return $new_array[$abs_number-1];
        }
    }else{
        if($number>=$length){
            return 'error';
        }else{
            return $array[$number];
        }
    }
}

示例：

echo cut_str($str,'/',0); //输出 123
echo cut_str($str,'/',2); //输出 789
echo cut_str($str,'/',-1);//输出 abc
echo cut_str($str,'/',-3);//输出 456

Tags - substr , strpos

CORS跨域资源共享PHP版本实现

Mon, 12 Sep 2016 04:15:12 +0000

使用PHP实现CORS 跨域资源共享，可传参origin通过限制，代码如下：

PHP代码

/******** 定义Response返回header头格式及编码 ********/
header('Content-type: application/json; charset=utf-8');
/******** 回调参数设置 ********/
$param="origin";
$origin_URL=$_REQUEST[$param];
/********　json_encode 转成=> encode_json *******/
function encode_json($str){
return urldecode(json_encode(url_encode($str)));
}
function url_encode($str){
if(is_array($str)){
foreach($str as $key=>$value){
$str[urlencode($key)]=url_encode($value);
}
}else{
$str=urlencode($str);
}
return $str;
}
/**************** \/\/反转义范例 ********************/
function stripslashes_deep($value){
$value=is_array($value)?
array_map('stripslashes_deep',$value):
stripslashes($value);
return $value;
}
/******************** Example ******************************/
$array=array("f\\'oo", "b\\'ar", array("fo\\'o", "b\\'ar"));
$array=stripslashes_deep($array);
/******************** Output *******************************/
//echo encode_json(array('china'=>'钓鱼岛是中国的!','Japan'=>array('name'=>'日本狗!')));
/************ 定义Post过来什么数据就返回什么数据 ***********/
$res=array(
'status'=>-1,
'name'=>isset($_POST['name'])?$_POST['name']:'',
'gender'=>isset($_POST['gender'])?$_POST['gender']:''
);
$arr=array(
"status"=>1,
"url"=>"http://www.liuxinxiu.com/",
"dataList"=>array(
"siteId"=>"1",
"title"=>urldecode('我的博客'),
"images"=>"http://192.168.9.100/upload/2015/06/20/moren.gif",
"indexNum"=>10,
"pageNum"=>"300",
"tagNum"=>"20",
"linkType"=>"linkTaobao",
"publishTime"=>"20:00:00"
)
);
$arr['dataList']['images']="http://www.liuxinxiu.com/upload/2015/06/20/moren.gif";
//print_r($arr);
/*************** 定义错误信息 ***************/
$errStr='{"status":-1,"info":"Request Error"}';
$errJson=json_decode($errStr,true); //json_decode转成了array数组
//print_r($errJson) //转成了array数组
/************** 获取客户端的Origin域名 **************/
$origin=isset($_SERVER['HTTP_ORIGIN'])?$_SERVER['HTTP_ORIGIN']:'';
/******** 定义符合规则的域名数组 ********/
$allow_origin=array(
'http://liuxinxiu.com',
'http://code.liuxinxiu.com',
'http://test.liuxinxiu.com'
);
/****************** 判断如果有POST过来数据 *********************/
if(isset($_POST['name'])&&isset($_POST['gender'])){
/********** 只要是POST请求过来无论合法与否都要正常通信 **********/
header('Access-Control-Allow-Methods:POST');
header('Access-Control-Allow-Headers:x-requested-with,content-type');
/******** 匹配客户端域名是否在数组列表中 ******/
if(in_array($origin,$allow_origin)){
header('Access-Control-Allow-Origin:'.$origin);
$res['status']=1;
$res['getUser']=$arr;
echo json_encode($res);
}
else if(!in_array($origin,$allow_origin)){
/******** 如有设置就取设置URL返回头信息 ********/
if(isset($origin_URL)){
header('Access-Control-Allow-Origin:'.$origin_URL);
$res['status']=1;
$res['getUser']=$arr;
echo encode_json($res);
//echo json_encode("中文", JSON_UNESCAPED_UNICODE);
}
/******** 如没有设置URL就返回错误信息 ********/
else{
header('Access-Control-Allow-Origin:'.$origin);
$errJson['status']=-1;
$errJson['info']="You don't have permission to submit!";
echo encode_json($errJson);
}
}
}
/************ 没有所匹配的POST提交数据 ***********/
else{
if($GLOBALS['HTTP_RAW_POST_DATA']){
header('Access-Control-Allow-Origin:'.$origin);
$errJson['status']=-1;
$errJson['info']="Syntax error in parameters or arguments.";
echo encode_json($errJson);
}
else{
header("Content-type: text/html; charset=utf-8");
echo 'It is forbidden for the URL request!';
}
}
?>

PHP数据提交接口地址 (禁止使用GET访问)：http://code.liuxinxiu.com/php/Interface/server.php

配合HTML代码如下：

XML/HTML代码

>
<html>
<head>
<meta charset="utf-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no"/>
<meta name="format-detection"content="telephone=no">
<meta name="apple-mobile-web-app-capable" content="yes" />
<meta name="apple-mobile-web-app-status-bar-style" content="black" />
<style>body,html {background:#fff;font-family: "Lucida Grande",Calibri,Arial;font-size:12pt;color: #333;background: #f8f8f8;text-align:center;}*{margin:0;padding:0;}h1{line-height:1.6em;font-size:24px;text-indent:.5em;padding-top:.6em}i{line-height:2em;font-size:18px;color:#999;}.line{height:10px;border-bottom:1px solid #ccc;font-size:0;overflow:hidden;}style>
<title>跨域测试title>
head>
<body>
<h1 id="show">h1>
<input type="button" value="Click me" onclick="msg()" />
body>
<script src="//code.jquery.com/jquery-1.11.3.min.js">script>
<script type='text/javascript'>
/********** 获取URL参数 **********/
function getQueryString(name){
var reg=new RegExp("(^|&)"+name+"=([^&]*)(&|$)","i");
var r=window.location.search.substr(1).match(reg);
if (r!=null) return unescape(r[2]); return null;
}
/********** 发起Ajax请求 **********/
function msg(){
/******* 动态切换提交数据 *******/
if(_origin){
if(_name&&_gender){
var data={name:_name,gender:_gender,origin:_origin};
}
else{
var data={name:"xiaoming",gender:"male",origin:_origin};
}
}
else if(_error==null){
var data={name:"xiaoming",gender:"male"};
}
else if(_error){
var data={xxx:111};
}
/******* 动态设置提交URL *******/
if(_url){
var urlPath=_url;
}
else{
var urlPath='http://code.liuxinxiu.com/php/Interface/server.php';
}
$.ajax({
type:'post',
url:urlPath,
data:data,
cache:false,
dataType:'json',
success:function(data){
if(data.name){
document.getElementById("show").innerHTML=data.name+' '+data.gender;
}
else if(data.status!=1){
document.getElementById("show").innerHTML=data.info;
}
},
error:function(){
console.log("请求错误//")
}
});
};
/***********************************************************************************************
$.post("http://www.server.com/server.php",{name:"fdipzone",gender:"male"}).done(function(data){
document.getElementById("show").innerHTML=data.name+' '+data.gender;
});
**********************************************************************************************/
script>
html>

HTML访问地址 (测试跨域) ==> http://test1.liuxinxiu.com/php/Interface/html/server.html?n=php

HTML访问地址 (非法参数) ==> http://test1.liuxinxiu.com/php/Interface/html/server.html?error=php

Tags - cors , php

PHP处理HTTP请求的几种方式

Mon, 05 Sep 2016 09:48:38 +0000

GET，一般是明文的，比如XXX.php?a=1&b=2，这里的a，b就必须用GET方式接收，接收代码如下：
$a = $_GET['a'];
$b = $_GET['b'];
//接收a,b两个变量
POST，一般是隐藏的非明文的，一般表单设置成POST的，接收方式如下：
//比如有个表单，表单中有两个文本框，name 分别是 a,b，那么代码如下：
$a = $_POST['a'];
$b = $_POST['b'];
另外：$_REQUEST，可以同时接收GET、POST的变量，用法如：
$_REQUEST['a'];//接收变量a，a可以是GET的也可以是POST的

另外说说PHP获取POST请求的几种方式：

方法1、最常见的方法是：$_POST['fieldname'];
说明：只能接收Content-Type: application/x-www-form-urlencoded提交的数据
解释：也就是表单POST过来的数据
 
方法2、file_get_contents(“php://input”);
说明：
允许读取 POST 的原始数据。
和 $HTTP_RAW_POST_DATA 比起来，它给内存带来的压力较小，并且不需要任何特殊的 php.ini 设置。
php://input 不能用于 enctype=”multipart/form-data”。
解释：
对于未指定 Content-Type 的POST数据，则可以使用file_get_contents(“php://input”);来获取原始数据。
事实上，用PHP接收POST的任何数据都可以使用本方法。而不用考虑Content-Type,包括二进制文件流也可以。
所以用方法二是最保险的方法。
 
方法3、$GLOBALS['HTTP_RAW_POST_DATA'];
说明：
总是产生 $HTTP_RAW_POST_DATA  变量包含有原始的 POST 数据。
此变量仅在碰到未识别 MIME 类型的数据时产生。
$HTTP_RAW_POST_DATA  对于 enctype=”multipart/form-data”  表单数据不可用
如果post过来的数据不是PHP能够识别的，可以用 $GLOBALS['HTTP_RAW_POST_DATA']来接收，
比如 text/xml 或者 soap 等等
解释：
$GLOBALS['HTTP_RAW_POST_DATA']存放的是POST过来的原始数据。
$_POST或$_REQUEST存放的是 PHP以key=>value的形式格式化以后的数据。
但$GLOBALS['HTTP_RAW_POST_DATA']中是否保存POST过来的数据取决于centent-Type的设置，即POST数据时 必须显式示指明Content-Type: application/x-www-form-urlencoded，POST的数据才会存放到 $GLOBALS['HTTP_RAW_POST_DATA']中。

Tags - php

php [urlencode urldecode] 函数

Tue, 29 Mar 2016 05:28:01 +0000

urlencode()编码：对字符串中除了 -_. 之外的所有非字母数字字符都将被替换成百分号（%）后跟两位十六进制数，空格则编码为加号（+）。

urldecode()解码：还原 URL 编码字符串。

示例：

header("Content-Type:text/html; charset=utf-8");

//对参数值进行编码

$parm=urlencode("演示php-mysql");

//拼接url

$url="decode.php?par=".$parm;

urlencode演示

点击连接后地址栏中汉字被编码了：

http://localhost/decode.php?par=%E6%BC%94%E7%A4%BAphp-mysql

------------------------------------------------------------------------

//decode.php

//获取参数值

$parValue=$_GET['par'];

//解码

echo urldecode($parValue);

//运行结果：演示php-mysql

php基于GD库，绘制PNG图像Demo

Thu, 10 Mar 2016 10:21:08 +0000

PHP代码

//创建画布，返回一个资源类型的变量$image，并在内存中开辟一个临时区域
$image = imagecreatetruecolor(400,400); //创建画布大小为400x400
//设置图像中所需的颜色，相当于在画画时准备的染料盒
$white = imagecolorallocate($image, 0xFF, 0xFF, 0xFF); //为图像分配颜色为白色
$gray = imagecolorallocate($image, 0xC0, 0xC0, 0xC0); //为图像分配颜色为灰色
$darkgray = imagecolorallocate($image, 0x90, 0x90, 0x90); //为图像分配颜色为暗灰色
$navy = imagecolorallocate($image, 0x00, 0x00, 0x80); //为图像分配颜色为深蓝色
$darknavy = imagecolorallocate($image, 0x00, 0x00, 0x50); //为图像分配颜色为暗深蓝色
$red = imagecolorallocate($image, 0xFF, 0x00, 0x00); //为图像分配颜色为红色
$darkred = imagecolorallocate($image, 0x90, 0x00, 0x00); //为图像分配颜色为暗红色
imagefill($image, 0, 0, $white); //为画布背景填充背景颜色
//动态制作3D效果
for ($i=220;$i>200;$i--){ //循环10次画出立体效果
imagefilledarc($image, 200, $i, 400, 200, -160, 40, $darknavy, IMG_ARC_PIE);
imagefilledarc($image, 200, $i, 400, 200, 40, 75, $darkgray, IMG_ARC_PIE);
imagefilledarc($image, 200, $i, 400, 200, 75, 200, $darkred, IMG_ARC_PIE);
}
imagefilledarc($image, 200, 200, 400, 200, -160, 40, $navy, IMG_ARC_PIE); //画一椭圆弧且填充
imagefilledarc($image, 200, 200, 400, 200, 40 , 75, $gray, IMG_ARC_PIE); //画一椭圆弧且填充
imagefilledarc($image, 200, 200, 400, 200, 75, 200, $red, IMG_ARC_PIE); //画一椭圆弧且填充
imagestring($image, 20, 100, 230, '34.7%', $white); //水平地画一行字符串,依次是F/X/Y/--数值越大向右、向下
imagestring($image, 20, 200, 150, '55.5%', $white); //水平地画一行字符串,依次是F/X/Y/--数值越大向右、向下
//向浏览器中输出一个GIF格式的图片
header('Content-type:image/png'); //使用头函数告诉浏览器以图像方式处理以下输出
imagepng($image); //向浏览器输出
imagedestroy($image); //销毁图像释放资源
//header("Content-type: text/html; charset=utf-8");
//$str="
'$image'
";
//echo $str;
?>

gd-png.php

PHP代码

//创建画布，返回一个资源类型的变量$image，并在内存中开辟一个临时区域
$image = imagecreatetruecolor(375,375); //创建画布大小为375x375 iPhone6 375X627
//设置图像中所需的颜色，相当于在画画时准备的染料盒
$white = imagecolorallocate($image, 0xFF, 0xFF, 0xFF); //为图像分配颜色为白色
$gray = imagecolorallocate($image, 0xC0, 0xC0, 0xC0); //为图像分配颜色为灰色
$darkgray = imagecolorallocate($image, 0x90, 0x90, 0x90); //为图像分配颜色为暗灰色
$navy = imagecolorallocate($image, 0x00, 0x00, 0x80); //为图像分配颜色为深蓝色
$darknavy = imagecolorallocate($image, 0x00, 0x00, 0x50); //为图像分配颜色为暗深蓝色
$red = imagecolorallocate($image, 0xFF, 0x00, 0x00); //为图像分配颜色为红色
$darkred = imagecolorallocate($image, 0x90, 0x00, 0x00); //为图像分配颜色为暗红色
imagefill($image, 0, 0, $white); //为画布背景填充背景颜色
//动态制作3D效果
for ($i=200;$i>180;$i--){ //循环10次画出立体效果
imagefilledarc($image, 187, $i, 360, 180, -160, 40, $darknavy, IMG_ARC_PIE); //
imagefilledarc($image, 187, $i, 360, 180, 40, 75, $darkgray, IMG_ARC_PIE);
imagefilledarc($image, 187, $i, 360, 180, 75, 200, $darkred, IMG_ARC_PIE);
}
imagefilledarc($image, 187, 180, 360, 180, -160, 40, $navy, IMG_ARC_PIE); //画一椭圆弧且填充,第一个187-180 是错开7像素
imagefilledarc($image, 187, 180, 360, 180, 40 , 75, $gray, IMG_ARC_PIE); //画一椭圆弧且填充
imagefilledarc($image, 187, 180, 360, 180, 75, 200, $red, IMG_ARC_PIE); //画一椭圆弧且填充
imagestring($image, 20, 180, 130, '55.5%', $white); //水平地画一行字符串,依次是F/X/Y/--数值越大向右、向下
imagestring($image, 20, 100, 200, '34.7%', $white); //水平地画一行字符串,依次是F/X/Y/--数值越大向右、向下
//向浏览器中输出一个GIF格式的图片
//header("Content-type:text/html;charset=utf-8"); // 设置页面的编码风格
header('Content-type:image/png'); //使用头函数告诉浏览器以图像方式处理以下输出--通知浏览器输出的是图像
imagepng($image); //向浏览器输出
imagedestroy($image); //销毁图像释放资源
//header("Content-type: text/html; charset=utf-8");
//$str="
'$image'
";
//echo $str;
?>

刘新修

Dioxus由DioxusLabs开发的全栈应用框架 旨在简化跨平台应用的开发

Go实现多线程分片下载文件

1，多线程下载原理

(1) HEAD请求 - 只获取请求头

(2) Range请求头 - 只获取部分响应体

(3) 为什么多线程下载可以提升速度？

2，Go代码实现

(1) ShardTask - 一个线程的下载任务

(2) ParallelGetTask - 一整个多线程下载任务

3，实现效果

MD5 加密之 java 与 js 实现

一、java 实现 MD5 加密

测试

db06c78d1e24cf708a14ce81c9b617ec

DB06C78D1E24CF708A14CE81C9B617EC

二、js 实现 MD5 加密

php json 处理gbk转码utf-8问题（ json_encode转换数组，值为null）

实例化php类的时候如何传参

PHP按符号截取字符串的指定部分

CORS跨域资源共享PHP版本实现

PHP处理HTTP请求的几种方式

php [urlencode urldecode] 函数

php基于GD库，绘制PNG图像Demo

Dioxus由DioxusLabs开发的全栈应用框架旨在简化跨平台应用的开发

(1) `HEAD`请求 - 只获取请求头

(2) `Range`请求头 - 只获取部分响应体

(1) `ShardTask` - 一个线程的下载任务

(2) `ParallelGetTask` - 一整个多线程下载任务