swift3.0网络图片缓存原理简析

时间:2021-08-13 14:27:22

一. 缓存原理

图片缓存原理原理是,如内存没图片,去磁盘找,若磁盘也没有,则根据url去下载,然后缓存到内存和磁盘中,简单易用

缓存的目录结构如下图:

?
1
2
//存储图片的文件夹
var ljfilepath:string =nshomedirectory() +"/documents/"+"ljimagecache/"

swift3.0网络图片缓存原理简析

二. 图片名称处理

为了确保缓存下来的图片的唯一性,所以此处采用图片的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