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

一. 缓存原理

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

缓存的目录结构如下图：

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

二. 图片名称处理

为了确保缓存下来的图片的唯一性，所以此处采用图片的url+md5=唯一标识符，来存储图片，如上图图片的名称。

创建一个sting+md5.swift字符串分类文件（同时此处需要创建一个bridge.h桥接文件，引入这个头文件

#import <commoncrypto/commondigest.h>，md5加密方法需要使用的文件）

1.bridge.h桥接文件如下：

#ifndef bridge_h 
#define bridge_h 
 
#import <commoncrypto/commondigest.h> 
 
#endif /* bridge_h */ 

2. sting+md5.swift文件如下

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. 图片缓存

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.图片读取

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的，然后获取文件数据

/* 写文件 
  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.读写内存文件

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 
    } 
  } 
} 

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。