一. 缓存原理
图片缓存原理原理是，如内存没图片，去磁盘找，若磁盘也没有，则根据url去下载，然后缓存到内存和磁盘中，简单易用
缓存的目录结构如下图：
|
1
2
|
//存储图片的文件夹
var ljfilepath:string =nshomedirectory() +"/documents/"+"ljimagecache/"
|
二. 图片名称处理
为了确保缓存下来的图片的唯一性，所以此处采用图片的url+md5=唯一标识符，来存储图片，如上图图片的名称。
创建一个sting+md5.swift字符串分类文件（同时此处需要创建一个bridge.h桥接文件，引入这个头文件
#import <commoncrypto/commondigest.h>，md5加密方法需要使用的文件）
1.bridge.h桥接文件如下：
|
1
2
3
4
5
6
|
#ifndef bridge_h
#define bridge_h
#import <commoncrypto/commondigest.h>
#endif /* bridge_h */
|
2. sting+md5.swift文件如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
import foundation
extension string {
var md5 : string{
let str = self.cstring(using: string.encoding.utf8)
let strlen = cc_long(self.lengthofbytes(using: string.encoding.utf8))
let digestlen = int(cc_md5_digest_length)
let result = unsafemutablepointer<cunsignedchar>.allocate(capacity: digestlen)
cc_md5(str!, strlen, result)
let hash = nsmutablestring()
for i in 0 ..< digestlen {
hash.appendformat("%02x", result[i])
}
result.deinitialize()
return string(format: hash as string)
}
}
|
三.图片缓存和读取
1. 图片缓存
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
func urlsession(_ session: urlsession, task: urlsessiontask, didcompletewitherror error: error?)
{
if ljcallbackclosure != nil ,let data = self.responsedata{
weak var weakself : ljopreationmanager? = self
dispatchqueue.main.async
{
print("urlsessiondatadelegate----数据下载完毕")
ljcachedatamanage.shared.setmemorycache((task.currentrequest?.url?.absolutestring)!,data as data)
//图片缓存，根据唯一的url来作为存储数据的名称
let a = ljfilemanager.shared.writefile((task.currentrequest?.url?.absolutestring)!,data as nsdata)
print("-----写入文件成功\(a)")
//将接收的数据结果回调到前台，用于进度展示
weakself?.ljcallbackclosure!(data as data ,nil)
}
}
}
|
2.图片读取
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public func retrieveimage(_ ljurl: string, _ ljcallback: @escaping opreationclosure){
if ljurl != "" {
if ljfilemanager.shared.readfilefromcache(ljurl) != nil {
//将接收的数据结果回调到前台，用于进度展示
print("获取的是disk缓存数据哦完毕")
ljcallback(ljfilemanager.shared.readfilefromcache(ljurl) as! data,nil)
}
//首先取缓存数据，没取到的话，直接下载
else if ljcachedatamanage.shared.getmemorycache(ljurl) != nil {
//将接收的数据结果回调到前台，用于进度展示
print("获取的是memory缓存数据哦完毕")
ljcallback(ljcachedatamanage.shared.getmemorycache(ljurl) ,nil)
}
else
{
_ = self.requestwebbyurl(ljurl, ljcallback)
}
}
}
|
3. 读写磁盘文件
（1）存储的时候给url进行md5加密得到filename.md5文件名称，然后存储，如上面的截图
（2）读取文件时，给url进行md5加密得到path.md5的，然后获取文件数据
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
/* 写文件
filename: 文件名称
data: 数据data
*/
func writefile(_ filename:string , _ data:nsdata) -> bool{
//let filepath:string = nshomedirectory() + "/documents/" + filename.md5
//return data.write(tofile: filepath, atomically: true)
guard self.isexistfiledir(ljfilepath) else{
return false
}
guard let filepath : string = ljfilepath + filename.md5 else{
return false
}
return data.write(tofile: filepath, atomically: true)
}
//读取文件 -（根据路径）
func readfilefromcache(_ path:string) -> nsdata?{
if self.isexistfiledir(ljfilepath)
{
let ljpatch = ljfilepath + path.md5
var result:nsdata?
do{
result = try nsdata(contentsoffile: ljpatch, options: data.readingoptions.uncached)
}catch{
return nil
}
return result
}
return nil
}
|
4.读写内存文件
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
import foundation
class ljcachedatamanage: nsobject{
//单例
public static let shared = ljcachedatamanage()
// public var diskcache =
//缓存的数据
public var memorycache = dictionary<string, data>()
//返回缓存的数据
func getmemorycache(_ urlstr : string) -> data? {
print("返回缓存的数据------\(memorycache[urlstr] ?? nil)")
return (memorycache[urlstr] ?? nil)
}
//设置缓存值
func setmemorycache(_ urlstr : string, _ data : data){
if urlstr != "", data != nil {
memorycache[urlstr] = data
}
}
}
|
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：http://blog.csdn.net/robinson_911/article/details/77622696