iOS 数据存储的几种方式

在iOS开发过程中常用的本地化存储有五种方式:

1.plist (XML属性列表归档 NSArray\NSDictionary)

2.preference (偏好设置\NSUserDefaults) (本质还是通过plist来存储数据,但是使用更加简单,无需关注文件、文件夹路径和名称)

3.NSCoding (NSKeyedArchiver\NSKeyedUnarchiver)  (能把任何对象都直接保存成文件的方式)
4.SQLite3  (当非常大量的数据时候才会使用)
5.Core Data (是对SQLite3的封装,更加面向对象,效率没有SQLite3高)

沙盒(sandbox):每个iOS应用都有自己的应用沙盒(应用沙盒就是应用的文件夹),与其他文件系统隔离。应用必须待在自己的沙盒里,其他应用不能访问该沙盒
应用沙盒的文件系统目录,如下图所示(假设应用的名称叫Layer)

沙盒结构分析:
应用程序包:(上图中的Layer)包含了所有的资源文件和可执行文件
Documents:保存应用运行时生成的需要持久化的数据,iTunes同步设备时会备份该目录。例如,游戏应用可将游戏存档保存在该目录。保存相对重要的数据。

tmp:保存应用运行时所需的临时数据,使用完毕后再将相应的文件从该目录删除。应用没有运行时,系统也可能会清除该目录下的文件。iTunes同步设备时不会备份该目录。保存不重要的并且大的数据。

Library/Caches:保存应用运行时生成的需要持久化的数据,iTunes同步设备时不会备份该目录。一般存储体积大、不需要备份的非重要数据

Library/Preference:保存应用的所有偏好设置,iOS的Settings(设置)应用会在该目录中查找应用的设置信息。iTunes同步设备时会备份该目录。该目录由系统管理, 无需我们来管理。通常用来存储一些基本的软件配置信息, 比如记住密码、自动登录等。

总结: 我们平时操作数据主要使用Documents目录。

沙盒的目录的获取方式:
沙盒根目录的获取:
NSString *home = NSHomeDirectory();
1.利用沙盒根目录拼接”Documents“字符串:
//这种方式不建议使用,因为如果新版本的操作系统可能会修改目录的名称
NSString *home = NSHomeDirectory();
NSString *documents = [home stringByAppendingPathComponent:@“Documents”];

2.利用NSSearchPathForDirectoriesInDomains函数
// NSUserDomainMask 代表从用户文件夹下找
// YES 代表展开路径中的波浪字符“~”
NSArray *array =  NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
// 在iOS中,只有一个目录跟传入的参数匹配,所以这个集合里面只有一个元素
NSString *documents = [array objectAtIndex:0];

常见沙盒目录获取方式:
tmp:NSString *tmp = NSTemporaryDirectory();
Library/Caches:(跟Documents类似的2种方法)
利用沙盒根目录拼接”Caches”字符串
利用NSSearchPathForDirectoriesInDomains函数(将函数的第2个参数改为:NSCachesDirectory即可)
Library/Preference:通过NSUserDefaults类存取该目录下的设置信息

1、XML属性列表(plist):(不能存储基本数据类型只能存储OC对象)

属性列表是一种 xml格式的文件,拓展名为plist,如果对象是(必须是OC对象,不能存储基本数据类型)NSString、NSDictionary/NSArray、NSData 、NSNumber等类型,就可以使用writeToFile:atomically:方法直接将对象写到属性列表文件中,然后用dictionaryWithContentsOfFile读取数据。

示例代码如下:

//保存
– (IBAction)save {

//1.获取沙盒根路径
NSString *home = NSHomeDirectory();
//2.document路径
NSString *docPath = [home stringByAppendingPathComponent:@”Documents”];
//3.新建数据  数据一般只能存储oc对象  字典也可以
NSArray *data = @[@”jack”,@”mack”,@15];
//4.写数据
NSString *filePath = [docPath stringByAppendingPathComponent:@”data.plist”];
[data writeToFile:filePath atomically:YES];
}
//读取
– (IBAction)read {

//1.获取沙盒根路径
NSString *home = NSHomeDirectory();
//2.document路径
NSString *docPath = [home stringByAppendingPathComponent:@”Documents”];
//3.文件路径
NSString *filePath = [docPath stringByAppendingPathComponent:@”data.plist”];
//4.读取数据
NSArray *data = [NSArray arrayWithContentsOfFile:filePath];
NSLog(@”%@”,data);
}

//将一个NSDictionary对象归档到一个plist属性列表中
// 将数据封装成字典
NSMutableDictionary *dict = [NSMutableDictionary dictionary];
[dict setObject:@”母鸡” forKey:@”name”];
[dict setObject:@”15013141314″ forKey:@”phone”];
[dict setObject:@”27″ forKey:@”age”];
// 将字典持久化到Documents/stu.plist文件中
[dict writeToFile:path atomically:YES];

//读取属性列表,恢复NSDictionary对象
// 读取Documents/stu.plist的内容,实例化NSDictionary
NSDictionary *dict = [NSDictionary dictionaryWithContentsOfFile:path];
NSLog(@”name:%@”, [dict objectForKey:@”name”]);
NSLog(@”phone:%@”, [dict objectForKey:@”phone”]);
NSLog(@”age:%@”, [dict objectForKey:@”age”]);
2、prefrrence (偏好设置)

很多iOS应用都支持偏好设置,比如保存用户名、密码、字体大小等设置,iOS提供了一套标准的解决方案来为应用加入偏好设置功能
每个应用都有个NSUserDefaults实例,通过它来存取偏好设置,比如,保存用户名、字体大小、是否自动登录等。

//存储数据
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
[defaults setObject:@”itcast” forKey:@”username”];
[defaults setFloat:18.0f forKey:@”text_size”];
[defaults setBool:YES forKey:@“auto_login”];
//读取上次保存的设置
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
NSString *username = [defaults stringForKey:@”username”];
float textSize = [defaults floatForKey:@”text_size”];
BOOL autoLogin = [defaults boolForKey:@”auto_login”];
[defaults synchornize];(立刻同步)
注意:UserDefaults设置数据时,不是立即写入,而是根据时间戳定时地把缓存中的数据写入本地磁盘。所以调用了set方法之后数据有可能还没有写入磁盘应用程序就终止了。出现以上问题,可以通过调用synchornize方法强制写入
示例代码如下:

//偏好设置数据存储:(一般用来存储软件的配置,存储在Library/Preferences中,不需要关注文件夹的路径)

//存储
– (IBAction)save {

//1.利用NSUserDefaults,就能直接访问软件的偏好设置(Library/Preferences
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
//2.存储数据
[defaults setObject:@”jack” forKey:@”name”];
[defaults setInteger:10 forKey:@”age”];
[defaults setBool:YES forKey:@”Login”];
//3.立刻同步
[defaults synchronize];
}

//读取
– (IBAction)read {
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
NSString *name = [defaults objectForKey:@”name”];
BOOL login = [defaults objectForKey:@”Login”];
NSLog(@”%@– %d”,name,login);
}

3、NSCoding (NSKeyedArchiver\NSKeyedUnarchiver)
如果对象是NSString、NSDictionary、NSArray、NSData、NSNumber等类型,可以直接用NSKeyedArchiver进行归档和恢复。
不是所有的对象(非OC对象)都可以直接用这种方法进行归档,只有遵守了NSCoding协议的对象才可以
NSCoding协议有2个方法:
encodeWithCoder:每次归档对象时,都会调用这个方法。一般在这个方法里面指定如何归档对象中的每个实例变量,可以使用encodeObject:forKey:方法归档实例变量
initWithCoder:每次从文件中恢复(解码)对象时,都会调用这个方法。一般在这个方法里面指定如何解码文件中的数据为对象的实例变量,可以使用decodeObject:forKey方法解码实例变量

示例代码如下:

NSKeyedArchiver数据存储,不仅可以用来存储OC对象,也可以用来存储非OC对象,以一个Person对象为例:(想归档某个对象,这个对象一定要遵守NSCoding这个协议)
#import <Foundation/Foundation.h>
@interface TWPerson : NSObject <NSCoding>
@property (nonatomic,copy) NSString *name;
@property (nonatomic,assign) int age;
@property (nonatomic,assign) double height;
@end

@implementation TWPerson
//将对象归档的时候调用(将对象写入文件之前调用)
//在这个方法里说清楚:1.哪些属性需要存储  2.怎样存储这些属性
-(void)encodeWithCoder:(NSCoder *)enCoder
{
//将_name属性进行编码(会将_name的值存进文件)
[enCoder encodeObject:_name forKey:@”name”];
[enCoder encodeInt:_age forKey:@”age”];
[enCoder encodeDouble:_height forKey:@”height”];

}
//当从文件中解析对象时使用
//在这个方法说清楚: 1.那个属性需要解析(读取)  2.怎样解析(读取)这些属性
– (id)initWithCoder:(NSCoder *)Decoder
{

if (self = [super init]) {
_name = [Decoder decodeObjectForKey:@”name”];
_age = [Decoder decodeIntForKey:@”age”];
_height = [Decoder decodeDoubleForKey:@”height”];
}
return self;
}
@end

//存储数据
– (IBAction)save {
TWPerson *p = [[TWPerson alloc]init];
p.name = @”jack”;
p.age = 10;
p.height = 1.82;
NSString *path = @”/Users/wtw/Desktop/person.data”;
//归档
[NSKeyedArchiver archiveRootObject:p toFile:path];
}
//读取数据
– (IBAction)read {
NSString *path = @”/Users/wtw/Desktop/person.data”;
//读档(反归档)
TWPerson *p = [NSKeyedUnarchiver  unarchiveObjectWithFile:path];
NSLog(@”%@ — %f — %d”,p.name,p.height,p.age);
}
4、SQLite3
SQLite3 是一款开源的轻型的嵌入式关系型数据库,可移植性好、易使用、内存开销小,SQLite3 是无类型的,可以保存任何类型的数据到任意的字段中。
数据库存储数据的步骤:

》新建一个数据库(DataBase)

》新建一张表(table)

》添加多个字段(column,列,属性)

》添加多行记录(row,每行存放多个字段对应的值)

SQL语句的分类:

数据定义语句:(DDL :Data Definition Language)

包括create 和 drop 等操作。

在数据库中创建新表或者删除表(creat table 或 drop table)
数据库操作语句: (DML : Data manipulation Language)

包括 insert 、update 、delete 等操作。

上面的3种操作分别用于添加、修改、删除表中的数据

数据查询语句 :(DQL : Data Query Language)

可以用于查询获得表中的数据

关键字select 是 DQL 用的*多的操作

其他DQL 常用的关键字有 where 、order by、group by 和 having 等。
创建表:

//创建表:
/*
创建数据表
CREATE TABLE ‘表名’ (
‘字段1’ 类型(INTEGER, REAL, TEXT, BLOB)
NOT NULL 不允许为空
PRIMARY KEY 主键
AUTOINCREMENT 自增长,
‘字段名2′ 类型,

)
*/
提示:可以从navicat先创建好表,复制粘贴,需要自己增加 IF NOT EXISTS

CREATE TABLE IF NOT EXISTS “T_Person” (
“id” INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
“name” TEXT,
“age” INTEGER,
“heigth” REAL
)
删除表:
//删除表
//DROP TABLE t_student;
DROP TABLE IF EXISTS t_student;
插入数据:

//插入命令:
INSERT INTO 表名
(字段名1,字段名2…..)
VALUES
(值1,值2。。。。)
//注意:值和字段一定要一致
//提示:SQLite的字段属性,只是给程序员看的,存什么都行

INSERT INTO t_student
(age, score, name)
VALUES
(’28’, 100, ‘zhangsan’);
更新数据:

//更新数据:
UPDATE 表名
SET
字段1 = ‘值1’ , //提示: 如果是字符串,需要使用单引号引起来
字段2 = 值2 ,…
/*更新记录的name*/
UPDATE t_student SET name = ‘zhangsan’;
//注意:如果更新时没有指定更新哪一条记录,那么会更新所有的数据

删除数据:

//删除指令:
//注意:删除数据的时候,一定要设置条件
//如果条件不满足,什么也不会发生

DELETE FROM 表名
WHERE 主键 = 值;

//例如:
DELETE FROM t_student;
DELETE FROM t_student WHERE age < 50;

查询数据:

//查询指令:
/* 分页 */
SELECT * FROM t_student
ORDER BY id ASC LIMIT 30, 10;
/* 排序 */
SELECT * FROM t_student
WHERE score > 50
ORDER BY age DESC;
SELECT * FROM t_student
WHERE score < 50
ORDER BY age ASC , score DESC;
/* 计量 */
SELECT COUNT(*)
FROM t_student
WHERE age > 50;
/* 别名 */
SELECT name as myName, age as myAge, score as myScore
FROM t_student;
SELECT name myName, age myAge, score myScore
FROM t_student;
SELECT s.name myName, s.age myAge, s.score myScore
FROM t_student s
WHERE s.age > 50;
/* 查询 */
SELECT name, age, score FROM t_student;
SELECT * FROM t_student;
数据库的基本使用:

@property (nonatomic, assign) sqlite3 *db;
/*
1.创建数据库
2.创建表(指定字段)
3.操作数据库
*/
/*
*个参数:是告诉系统数据库文件在什么地方.
>如果文件不存在就会自动创建, 然后再打开
>如果数据库存在就会自动打开
第二个参数:返回打开的数据库对象
*/
// 1.拼接数据库地址
NSString *path = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)lastObject];
NSString *sqlFile = [path stringByAppendingPathComponent:@”student.sqlite”];
// sqlite3 *db = NULL;
// 2.打开数据库
int result = sqlite3_open(sqlFile.UTF8String, &_db);// [self db]
// 3.判断是否打开成功
if (result == SQLITE_OK) {
NSLog(@”打开成功”);
// 3.1创建表
/*
*个参数: 需要执行SQL语句的数据库对象
第二个参数: 需要执行的SQL语句
第三个参数: 回调函数
第四个参数: 第三个参数的参数
第五个参数: 接收错误信息
*/
NSString *sql = @”CREATE TABLE IF NOT EXISTS t_student(id INTEGER PRIMARY KEY AUTOINCREMENT , name TEXT, age INTEGER, score REAL);”;
result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, NULL);
if (result == SQLITE_OK) {
NSLog(@”创建表成功”);
}else
{
NSLog(@”创建表失败”);
}
}else
{
NSLog(@”打开失败”);
}
– (IBAction)insertClick:(id)sender {

NSString *sql = @”INSERT INTO t_student(age, score, name) VALUES (’28’, 100, ‘jonathan’);”;
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, NULL);
if (result == SQLITE_OK) {
NSLog(@”插入成功”);
}
}

– (IBAction)updateClick:(id)sender {
NSString *sql = @”UPDATE t_student SET name = ‘XXX’;”;
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, NULL);
if (result == SQLITE_OK) {
NSLog(@”修改成功”);
}
}

– (IBAction)deleteClick:(id)sender {
NSString *sql = @”DELETE FROM t_student WHERE id = 1; “;
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, NULL);
if (result == SQLITE_OK) {
NSLog(@”删除成功”);
}6
}

– (IBAction)selectClick:(id)sender {
/*
sqlite3操作中, 所有DML语句都是使用sqlite3_exec函数执行SQL语句即可,
但是如果是需要查询数据库, 不能使用sqlite3_exec, 因为它并没有返回查询到得结果发给我们
*/
/*
NSString *sql = @”SELECT * FROM t_student;”;
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, NULL);
if (result == SQLITE_OK) {
NSLog(@”查询成功”);
}
*/
// 1.准备查询
/*
*个参数:需要执行SQL语句的数据库
第二个参数:需要执行的SQL语句
第三个参数: 告诉系统SQL语句的长度, 如果传入一个小于0的数, 系统会自动计算
第四个参数:结果集, 里面存放所有查询到的数据(不严谨)
*/
NSString *sql = @”SELECT * FROM t_student;”;
sqlite3_stmt *stemt = NULL;
sqlite3_prepare_v2(_db, sql.UTF8String, -1, &stemt, NULL);
// 2.判断有没有查询结果
// int result = sqlite3_step(stemt);
// if (result == SQLITE_ROW) {
while (sqlite3_step(stemt) == SQLITE_ROW) {
// NSLog(@”查询到了数据”);
// 3.取出查询到得结果
const unsigned char *name = sqlite3_column_text(stemt, 1);
int age = sqlite3_column_int(stemt, 2);
double score = sqlite3_column_double(stemt, 3);
NSLog(@”%s %d %f”, name, age, score);
}
}

数据库的基本的封装:
@interface SQLManager : NSObject

+ (instancetype)shareManage;
//插入新数据
– (BOOL)insertStudent:(HMStudent *)student;
//删除数据
– (BOOL)deleteWithStudent:(HMStudent *)student;
//更新数据
– (BOOL)updateWithStudent:(HMStudent *)student;
//查询数据
– (NSArray *)query;
@end
#import “SQLManager.h”
#import <sqlite3.h>

@implementation SQLManager

static SQLManager *_instance;
+ (instancetype)shareManage
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
_instance = [[SQLManager alloc] init];
});
return _instance;
}

sqlite3 *_db;
+ (void)initialize
{
// 1.拼接数据库地址
NSString *path = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)lastObject];
NSString *sqlFile = [path stringByAppendingPathComponent:@”student.sqlite”];
// 2.打开数据库
int result = sqlite3_open(sqlFile.UTF8String, &_db);// [self db]
// 3.判断是否打开成功
if (result == SQLITE_OK) {
NSLog(@”打开成功”);
// 3.1创建表
NSString *sql = @”CREATE TABLE IF NOT EXISTS t_student(id INTEGER PRIMARY KEY AUTOINCREMENT , name TEXT, age INTEGER, score REAL);”;
result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, NULL);
}
}

– (BOOL)insertStudent:(HMStudent *)student
{
NSString *sql = [NSString stringWithFormat: @”INSERT INTO t_student(age, score, name) VALUES (%d, %f, ‘%@’);”, student.age, student.score, student.name];
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, NULL);
if (result == SQLITE_OK) {
return YES;
}
return NO;
}
– (BOOL)deleteWithStudent:(HMStudent *)student
{
NSString *sql = [NSString stringWithFormat:@”DELETE FROM t_student WHERE id = %d;”, student.ID];
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, NULL);
if (result == SQLITE_OK) {
return YES;
}
return NO;
}
– (BOOL)updateWithStudent:(HMStudent *)student
{

NSString *sql = [NSString stringWithFormat:@”UPDATE t_student SET name = ‘%@’;”, student.name];
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, NULL);
if (result == SQLITE_OK) {
return YES;
}
return NO;
}
– (NSArray *)query
{
NSString *sql = @”SELECT * FROM t_student;”;
sqlite3_stmt *stemt = NULL;
sqlite3_prepare_v2(_db, sql.UTF8String, -1, &stemt, NULL);
// 2.判断有没有查询结果
NSMutableArray *arrM = [NSMutableArray array];
while (sqlite3_step(stemt) == SQLITE_ROW) {
// 3.取出查询到得结果
const unsigned char *name = sqlite3_column_text(stemt, 1);
int age = sqlite3_column_int(stemt, 2);
double score = sqlite3_column_double(stemt, 3);
HMStudent *stu = [[HMStudent alloc] init];
stu.name = [NSString stringWithUTF8String:name];
stu.age = age;
stu.score = score;
[arrM addObject:stu];
}
return arrM;
}
@end
FMDB的基本使用:

以OC的方式封装了SQLite的C语言API.

优点是:

使用起来更加面向对象,省去麻烦冗余的C语言的代码,对比苹果的Core Data 框架,更加的轻量级和灵活,提供了多线程安全的数据库操作方法,有效防止数据混乱。

FMDB有三个三个主要的类:

FMDataBase :一个FMDataBase 对象就代表一个单独的DataBase数据库,用来执行SQL语句。

FMResultSet: 使用FMResultSet执行查询后的结果集。

FMDataBaseQueue: 用于多线程执行多个查询或者更新,他是线程安全的。
@property (nonatomic, strong) FMDatabase *db;
@implementation ViewController
– (void)viewDidLoad {
[super viewDidLoad];
/*
1.创建数据库
2.创建表
3.操作
*/
// 1.拼接数据库地址
NSString *path = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)lastObject];
NSString *sqlFile = [path stringByAppendingPathComponent:@”student.sqlite”];
//该方法接收一个路径, 它会根据地址创建一个数据库, 如果不存在就会自动创建
FMDatabase *db = [FMDatabase databaseWithPath:sqlFile];
self.db = db;
if([db open]){
// 2.创建表
NSString *sql = @”CREATE TABLE IF NOT EXISTS t_student(id INTEGER PRIMARY KEY AUTOINCREMENT , name TEXT, age INTEGER, score REAL);”;

// 注意: 在FMDB中除了查询以外的操作都称之为更新
if([db executeUpdate:sql]){
NSLog(@”创建表成功”);
}
}
}
– (IBAction)insertClick:(id)sender
{ NSString *sql = @”INSERT INTO t_student(age, score, name) VALUES (’28’, 100, ‘jonathan’);”;
if([self.db executeUpdate:sql])
{
NSLog(@”插入成功”);
}
}
– (IBAction)selectClick:(id)sender
{
NSString *sql = @”SELECT * FROM t_student;”;
// 查询数据, 会将所有查询到得数据, 放到results中
FMResultSet *results = [self.db executeQuery:sql];
// 从results中获取数据
while ([results next]) {
NSString *name = [results stringForColumn:@”name”];
int age = [results intForColumn:@”age”];
double score = [results doubleForColumn:@”score”];
NSLog(@”%@ %d %f”, name, age, score);
}
}
FMDataBaseQueue:

@property (nonatomic, strong) FMDatabaseQueue *dbQueue;
@implementation ViewController

– (void)viewDidLoad {
[super viewDidLoad];

// 1.拼接数据库地址
NSString *path = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)lastObject];
NSString *sqlFile = [path stringByAppendingPathComponent:@”student.sqlite”];
// 创建一个数据库队列
FMDatabaseQueue *dbQueue = [FMDatabaseQueue databaseQueueWithPath:sqlFile];
self.dbQueue = dbQueue;
//只要调用dbQueue的inDatabase方法, 系统就会传递一个已经打开并且线程安全的数据库给我们
[dbQueue inDatabase:^(FMDatabase *db) {
// 2.创建表
NSString *sql = @”CREATE TABLE IF NOT EXISTS t_student(id INTEGER PRIMARY KEY AUTOINCREMENT , name TEXT, age INTEGER, score REAL);”;

// 注意: 在FMDB中除了查询以外的操作都称之为更新
if([db executeUpdate:sql]){
NSLog(@”创建表成功”);
}
}];
}
– (IBAction)insertClick:(id)sender
{
[self.dbQueue inDatabase:^(FMDatabase *db) {
NSString *sql = @”INSERT INTO t_student(age, score, name) VALUES (’28’, 100, ‘jonathan’);”;
if([db executeUpdate:sql])
{
NSLog(@”插入成功”);
}
}];
}
– (IBAction)selectClick:(id)sender
{
[self.dbQueue inDatabase:^(FMDatabase *db) {
NSString *sql = @”SELECT * FROM t_student;”;
// 查询数据, 会将所有查询到得数据, 放到results中
FMResultSet *results = [db executeQuery:sql];
// 从results中获取数据
while ([results next]) {
NSString *name = [results stringForColumn:@”name”];
int age = [results intForColumn:@”age”];
double score = [results doubleForColumn:@”score”];
NSLog(@”%@ %d %f”, name, age, score);
}
}];
}
@end

事务:可以将多条SQL数据绑定在一起,要么一起执行成功要么一起执行失败。
CoreData:
Core Data框架提供了对象-关系映射(ORM)的功能,即能够将OC对象转化成数据,保存在SQLite3数据库文件中,也能够将保存在数据库中的数据还原成OC对象。在此数据操作期间,不需要编写任何SQL语句。

 

云计算发展进程中的六大关键技术

云计算是以数据为中心的一种数据密集型的超级计算。在数据存储、数据管理、编程模式、并发控制、系统管理等方面具有自身独特的技术。

海量分布式存储技术

为保证高可用、高可靠和经济性,云计算采用分布式存储的方式来存储数据和冗余存储的方式来保证存储数据的可靠性,从而提供廉价可靠的系统。为了满足大量用户的需求,数据存储技术必须具有高吞吐率和高传输率的特点。

云计算的数据存储系统主要有Google GFS(Google File System)和Hadoop开发团队的开源系统HDFS(Hadop Distributed File System)。大部分IT厂商,包括Yahoo、Intel的“云”计划采用的都是HDFS的数据存储技术。

并行编程模式

为了高效地利用云计算的资源,使用户能更轻松地享受云计算带来的服务,云计算的变成哦是必须保证后台复杂的并行执行和任务调度向用户和编程人员透明。云计算采用MapReduce编程模式,将任务自动分成多个子任务,通过Map和Reduce两部实现任务在大规模计算节点中的调度与分配。

数据管理技术

云计算系统对大数据集进行处理、分析,向用户提供高效的服务。因此,数据管理技术必须能够高效地管理大数据集。其次,如何在规模巨大的数据中找到特定的数据,也是云计算数据管理技术所必须解决的问题。云系统的数据管理往往采用列存储的数据管理模式,保证海量数据存储和分析性能。云计算的数据管理技术*著名的是Googe的BigTable数据管理技术,同事Hadop开发团队开发了累死BigTable的开源数据管理模块HBase。

分布式资源管理技术

在多节点并发执行环境,分布式资源管理系统是保证系统状态正确性的关键技术。系统状态需要在多节点之间同步,关键节点出现故障时需要迁移服务,分布式资源管理技术通过锁机制协调多任务对于资源的使用,从而保证数据操作的一致性。Google的Ghubby是*锥你给的分布式资源管理系统。

云计算平台管理技术

云计算资源规模庞大,一个系统的服务器数量可能会高达十万台并跨越几个坐落于不同物理地点的数据中心,同时还运行成百上千种应用。如何有效地管理这些服务器,保证这些服务器组成的系统能提供7*24小时不间断服务是一个巨大的挑战。云计算系统管理技术是云计算的“神经网络”,通过这些技术能够是大量的服务器协同工作,方便地进行业务部署和开通,快速发现和恢复系统故障,通过自动化、智能化的手段实现大会磨系统的可运营、可管理。Google通过其卓越的云计算管理系统维持着全球上百万台PC服务器协同、高效地运行,起云计算系统管理技术也被作为企业核心机密,至今没有公布任何技术资料。

绿色节能技术

云计算技术降低了服务器的采购成本,从而使电源消耗所带来的运营成本成为云计算计算中心的主要开支之一,为了进一步降低成本,云计算的先去在绿色节能技术上进行了大量探索。

传统数据中心空调冷却的费用约占整体电费的30%—70%,Google为了节省能源,在比利时的数据中心降温系统无需冷却剂,而是采取额室外空气进行自然冷却。根据比利时的气候条件,每年只有7天左右无法使用自由冷却方式。在比较炎热的夏天,Google可以通过云计算管理系统将该数据中心的计算任务转移到其他数据中心中。

iOS基础教程:深入浅出 Cocoa 之 Core Data

Core data 是 Cocoa 中处理数据,绑定数据的关键特性,其重要性不言而喻,但也比较复杂。Core Data 相关的类比较多,初学者往往不太容易弄懂。计划用三个教程来讲解这一部分:

框架详解:讲解 Core data 框架,运作过程,设计的类;
Core data应用程序示例:通过生成一个使用 Core data 的应用程序来讲解如何 在 XCode 4 中使用 Core data。
手动创建Core data示例:不利用框架自动生成代码,完全自己编写所有的 Core data 相关代码的命令行应用程序来深入讲解 Core data的使用。

本文为*部份:框架详解

一,概观
下面先给出一张类关系图,让我们对它有个总体的认识。

%title插图%num

在上图中,我们可以看到有五个相关模块:
1, Managed Object Model
Managed Object Model 是描述应用程序的数据模型,这个模型包含实体(Entity),特性(Property),读取请求(Fetch Request)等。(下文都使用英文术语。)

2,Managed Object Context
Managed Object Context 参与对数据对象进行各种操作的全过程,并监测数据对象的变化,以提供对 undo/redo 的支持及更新绑定到数据的 UI。

3,Persistent Store Coordinator
Persistent Store Coordinator 相当于数据文件管理器,处理底层的对数据文件的读取与写入。一般我们无需与它打交道。

4,Managed Object
Managed Object 数据对象,与 Managed Object Context 相关联。

5,Controller
图中绿色的 Array Controller, Object Controller, Tree Controller 这些控制器,一般都是通过 control+drag 将 Managed Object Context 绑定到它们,这样我们就可以在 nib 中可视化地操作数据。

这写模块是怎样运作的呢?
%title插图%num

1,应用程序先创建或读取模型文件(后缀为xcdatamodeld)生成 NSManagedObjectModel 对象。Document应用程序是一般是通过 NSDocument 或其子类 NSPersistentDocument)从模型文件(后缀为 xcdatamodeld)读取。
2,然后生成 NSManagedObjectContext 和 NSPersistentStoreCoordinator 对象,前者对用户透明地调用后者对数据文件进行读写。
3,NSPersistentStoreCoordinator 负责从数据文件(xml, sqlite,二进制文件等)中读取数据生成 Managed Object,或保存 Managed Object 写入数据文件。
4,NSManagedObjectContext 参与对数据进行各种操作的整个过程,它持有 Managed Object。我们通过它来监测 Managed Object。监测数据对象有两个作用:支持 undo/redo 以及数据绑定。这个类是*常被用到的。
5,Array Controller, Object Controller, Tree Controller 这些控制器一般与 NSManagedObjectContext 关联,因此我们可以通过它们在 nib 中可视化地操作数据对象。

二, Model class

模型有点像数据库的表结构,里面包含 Entry, 实体又包含三种 Property:Attribute(属性),RelationShip(关系), Fetched Property(读取属性)。Model class 的名字多以 “Description” 结尾。我们可以看出:模型就是描述数据类型以及其关系的。

主要的 Model class 有:

Model Classes
Managed Object Model NSManagedObjectModel 数据模型
Entity NSEntityDescription 抽象数据类型,相当于数据库中的表
Property NSPropertyDescription Entity 特性,相当于数据库表中的一列
> Attribute NSAttributeDescription 基本数值型属性(如Int16, BOOL, Date等类型的属性)
> Relationship NSRelationshipDescription 属性之间的关系
> Fetched Property NSFetchedPropertyDescription 查询属性(相当于数据库中的查询语句)

1)Entity – NSEntityDescription
Entity 相当于数据库中的一个表,它描述一种抽象数据类型,其对应的类为 NSManagedObject 或其子类。

NSEntityDescription 常用方法:
+insertNewObjectForEntityForName:inManagedObjectContext: 工厂方法,根据给定的 Entity 描述,生成相应的 NSManagedObject 对象,并插入 ManagedObjectContext 中。
-managedObjectClassName返回映射到 Entity 的 NSManagedObject 类名
-attributesByName以名字为 key, 返回 Entity 中对应的 Attributes
-relationshipsByName以名字为 key, 返回 Entity 中对应的 Relationships

2)Property – NSPropertyDescription
Property 为 Entity 的特性,它相当于数据库表中的一列,或者 XML 文件中的 value-key 对中的 key。它可以描述实体数据(Attribute),Entity之间的关系(RelationShip),或查询属性(Fetched Property)。

> Attribute – NSAttributeDescription
Attribute 存储基本数据,如 NSString, NSNumber or NSDate 等。它可以有默认值,也可以使用正则表达式或其他条件对其值进行限定。一个属性可以是 optional 的。

> Relationship – NSRelationshipDescription
Relationship 描述 Entity,Property 之间的关系,可以是一对一,也可以是一对多的关系。

> Fetched Property – NSFetchedPropertyDescription
Fetched Property 根据查询谓词返回指定 Entity 的符合条件的数据对象。

上面说的比较抽象,举个例子来说,

我们有一个 CocoaDataDemo.xcdatamodeld 模型文件,应用程序根据它生成一个 NSManagedObjectModel 对象,这个模型有三个 Entity,每个 Entity 又可包含 Attribute Relationship, Feteched Property 三种类型的 Property。在本例中, Author Entity 包含两个Attribute : name 和 email,它们对于的运行时类均为 NSManagedObject;还包含一个与 Post 的 Relationship;没有设置 Feteched Property。

我们通常使用 KVC 机制来访问 Property。下面来看代码:

  1. NSManagedObjectContext * context = [[NSApp delegate] managedObjectContext];
  2. NSManagedObject * author = nil;
  3. author = [NSEntityDescription insertNewObjectForEntityForName: @“Author” inManagedObjectContext: context];
  4. [author setValue: @“nemo@pixar.com” forKey: @“email”];
  5. NSLog (@“The Author’s email is: %@”, [author valueForKey:@“email”]);

在上面代码中,我们先取得 NSManagedObjectContext, 然后调用 NSEntityDescription 的方法,以 Author 为实体模型,生成对应的 NSManagedObject 对象,插入 NSManagedObjectContext 中,然后给这个对象设置特性 email 的值。

三,运行时类与对象
> Managed Object – NSManagedObject
Managed Object 表示数据文件中的一条记录,每一个 Managed Object 在内存中对应 Entity 的一个数据表示。Managed Object 的成员为 Entity 的 Property 所描述。
比如在上面的代码,author 这个 NSManagedObject,对应名为 Author 的 Entity。

每一个 Managed Object 都有一个全局 ID(类型为:NSManagedObjectID)。Managed Object 会附加到一个 Managed Object Context,我们可以通过这个全局 ID 在 Managed Object Context 查询对应的 Managed Object。

NSManagedObject 常用方法
-entity 获取其 Entity
-objectID 获取其 Managed Object ID
-valueForKey: 获取指定 Property 的值
-setValue: forKey: 设定指定 Property 的值

> Managed Object Context – NSManagedObjectContext
Managed Object Context 的作用相当重要,对数据对象进行的操作都与它有关。当创建一个数据对象并插入 Managed Object Context 中,Managed Object Context 就开始跟踪这个数据对象的一切变动,并在合适的时候提供对 undo/redo 的支持,或调用 Persistent Store Coordinato 将变化保存到数据文件中去。

通常我们将 controller 类(如:NSArrayController,NSTreeController)或其子类与 Managed Object Context 绑定,这样就方便我们动态地生成,获取数据对象等。

NSManagedObjectContext 常用方法
-save: 将数据对象保存到数据文件
-objectWithID: 查询指定 Managed Object ID 的数据对象
-deleteObject: 将一个数据对象标记为删除,但是要等到 Context 提交更改时才真正删除数据对象
-undo 回滚*后一步操作,这是都 undo/redo 的支持
-lock 加锁,常用于多线程以及创建事务。同类接口还有:-unlock and -tryLock
-rollback 还原数据文件内容
-reset 清除缓存的 Managed Objects。只应当在添加或删除 Persistent Stores 时使用
-undoManager 返回当前 Context 所使用的 NSUndoManager
-assignObject: toPersistantStore: 由于 Context 可以管理从不同数据文件而来的数据对象,
这个接口的作用就是指定数据对象的存储数据文件(通过指定 PersistantStore 实现)
-executeFetchRequest: error: 执行 Fetch Request 并返回所有匹配的数据对象

> Persistent Store Coordinator – NSPersistentStoreCoordinator
使用 Core Data document 类型的应用程序,通常会从磁盘上的数据文中中读取或存储数据,这写底层的读写就由 Persistent Store Coordinator 来处理。一般我们无需与它直接打交道来读写文件,Managed Object Context 在背后已经为我们调用 Persistent Store Coordinator 做了这部分工作。

NSPersistentStoreCoordinator 常用方法
-addPersistentStoreForURL:configuration:URL:options:error: 装载数据存储,对应的卸载数据存储的接口为 -removePersistentStore:error:
-migratePersistentStore:toURL:options:withType:error: 迁移数据存储,效果与 “save as”相似,但是操作成功后,
迁移前的数据存储不可再使用
-managedObjectIDForURIRepresentation: 返回给定 URL所指示的数据存储的 object id,如果找不到匹配的数据存储则返回 nil
-persistentStoreForURL: 返回指定路径的 Persistent Store
-URLForPersistentStore: 返回指定 Persistent Store 的存储路径

> Persistent Document – NSPersistentDocument
NSPersistentDocument 是 NSDocument 的子类。 multi-document Core Data 应用程序使用它来简化对 Core Data 的操作。通常使用 NSPersistentDocument 的默认实现就足够了,它从 Info.plist 中读取 Document types 信息来决定数据的存储格式(xml,sqlite, binary)。

NSPersistentDocument 常用方法
-managedObjectContext 返回文档的 Managed Object Context,在多文档应用程序中,每个文档都有自己的 Context。
-managedObjectModel 返回文档的 Managed Object Model

四,Fetch Requests
Fetch Requests 相当于一个查询语句,你必须指定要查询的 Entity。我们通过 Fetch Requests 向 Managed Object Context 查询符合条件的数据对象,以 NSArray 形式返回查询结果,如果我们没有设置任何查询条件,则返回该 Entity 的所有数据对象。我们可以使用谓词来设置查询条件,通常会将常用的 Fetch Requests 保存到 dictionary 以重复利用。

示例:

  1. NSManagedObjectContext * context = [[NSApp delegate] managedObjectContext];
  2. NSManagedObjectModel * model = [[NSApp delegate] managedObjectModel];
  3. NSDictionary * entities = [model entitiesByName];
  4. NSEntityDescription * entity = [entities valueForKey:@“Post”];
  5. NSPredicate * predicate;
  6. predicate = [NSPredicate predicateWithFormat:@“creationDate > %@”, date];
  7. NSSortDescriptor * sort = [[NSortDescriptor alloc] initWithKey:@“title”];
  8. NSArray * sortDescriptors = [NSArray arrayWithObject: sort];
  9. NSFetchRequest * fetch = [[NSFetchRequest alloc] init];
  10. [fetch setEntity: entity];
  11. [fetch setPredicate: predicate];
  12. [fetch setSortDescriptors: sortDescriptors];
  13. NSArray * results = [context executeFetchRequest:fetch error:nil];
  14. [sort release];
  15. [fetch release];

在上面代码中,我们查询在指定日期之后创建的 post,并将查询结果按照 title 排序返回。

NSFetchRequest 常用方法
-setEntity: 设置你要查询的数据对象的类型(Entity)
-setPredicate: 设置查询条件
-setFetchLimit: 设置*大查询对象数目
-setSortDescriptors: 设置查询结果的排序方法
-setAffectedStores: 设置可以在哪些数据存储中查询

参考资料:
Core Data ReferenceAPI listing for the Core Data classes
http://developer.apple.com/documentation/Cocoa/Reference/CoreData_ObjC/index.html

NSPredicate ReferenceAPI listing for NSPredicate

http://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSPredicate.html

 

前面详细讲解了 Core Data 的框架以及设计的类,下面我们来讲解一个完全手动编写代码使用这些类的示例,这个例子来自苹果官方示例。在这个例子里面,我们打算做这样一件事情:记录程序运行记录(时间与 process id),并保存到xml文件中。我们使用 Core Data 来做这个事情。

 

一,建立一个新的 Mac command-line tool application 工程,命名为 CoreDataTutorial。为支持垃圾主动回收机制,点击项目名称,在右边的 Build Setting 中查找 garbage 关键字,将找到的 Objective-C Garbage Collection 设置为 Required [-fobj-gc-only]。并将 main.m 中 的 main() 方法修改为如下:

  1. int main (int argc, const char * argv[])
  2. {
  3. NSLog(@” === Core Data Tutorial ===”);
  4. // Enable GC
  5. //
  6. objc_startCollectorThread();
  7. return 0;
  8. }

二,创建并设置模型类

在 main() 之前添加如下方法:

  1. NSManagedObjectModel *managedObjectModel()
  2. {
  3. static NSManagedObjectModel *moModel = nil;
  4. if (moModel != nil) {
  5. return moModel;
  6. }
  7. moModel = [[NSManagedObjectModel alloc] init];
  8. // Create the entity
  9. //
  10. NSEntityDescription *runEntity = [[NSEntityDescription alloc] init];
  11. [runEntity setName:@“Run”];
  12. [runEntity setManagedObjectClassName:@“Run”];
  13. [moModel setEntities:[NSArray arrayWithObject:runEntity]];
  14. // Add the Attributes
  15. //
  16. NSAttributeDescription *dateAttribute = [[NSAttributeDescription alloc] init];
  17. [dateAttribute setName:@“date”];
  18. [dateAttribute setAttributeType:NSDateAttributeType];
  19. [dateAttribute setOptional:NO];
  20. NSAttributeDescription *idAttribute = [[NSAttributeDescription alloc] init];
  21. [idAttribute setName:@“processID”];
  22. [idAttribute setAttributeType:NSInteger32AttributeType];
  23. [idAttribute setOptional:NO];
  24. [idAttribute setDefaultValue:[NSNumber numberWithInteger:-1]];
  25. // Create the validation predicate for the process ID.
  26. // The following code is equivalent to validationPredicate = [NSPredicate predicateWithFormat:@”SELF > 0″]
  27. //
  28. NSExpression *lhs = [NSExpression expressionForEvaluatedObject];
  29. NSExpression *rhs = [NSExpression expressionForConstantValue:[NSNumber numberWithInteger:0]];
  30. NSPredicate *validationPredicate = [NSComparisonPredicate
  31. predicateWithLeftExpression:lhs
  32. rightExpression:rhs
  33. modifier:NSDirectPredicateModifier
  34. type:NSGreaterThanPredicateOperatorType
  35. options:0];
  36. NSString *validationWarning = @“Process ID < 1”;
  37. [idAttribute setValidationPredicates:[NSArray arrayWithObject:validationPredicate]
  38. withValidationWarnings:[NSArray arrayWithObject:validationWarning]];
  39. // set the properties for the entity.
  40. //
  41. NSArray *properties = [NSArray arrayWithObjects: dateAttribute, idAttribute, nil];
  42. [runEntity setProperties:properties];
  43. // Add a Localization Dictionary
  44. //
  45. NSMutableDictionary *localizationDictionary = [NSMutableDictionary dictionary];
  46. [localizationDictionary setObject:@“Date” forKey:@“Property/date/Entity/Run”];
  47. [localizationDictionary setObject:@“Process ID” forKey:@“Property/processID/Entity/Run”];
  48. [localizationDictionary setObject:@“Process ID must not be less than 1” forKey:@“ErrorString/Process ID < 1”];
  49. [moModel setLocalizationDictionary:localizationDictionary];
  50. return moModel;
  51. }

 

在上面的代码中:

1)我们创建了一个全局模型 moModel;
2)并在其中创建一个名为 Run 的 Entity,这个 Entity 对应的 ManagedObject 类名为 Run(很快我们将创建这样一个类);
3)给 Run Entity 添加了两个必须的 Property:date 和 processID,分别表示运行时间以及进程 ID;并设置默认的进程 ID 为 -1;
4)给 processID 特性设置检验条件:必须大于 0;
5)给模型设置本地化描述词典;

本地化描述提供对 Entity,Property,Error信息等的便于理解的描述,其可用的键值对如下表:

Key

Value

“Entity/NonLocalizedEntityName”

“LocalizedEntityName”

“Property/NonLocalizedPropertyName/Entity/EntityName”

“LocalizedPropertyName”

“Property/NonLocalizedPropertyName”

“LocalizedPropertyName”

“ErrorString/NonLocalizedErrorString”

“LocalizedErrorString”

三,创建并设置运行时类和对象

由于要用到存储功能,所以我们必须定义持久化数据的存储路径。我们在 main() 之前添加如下方法设置存储路径:

  1. NSURL *applicationLogDirectory()
  2. {
  3. NSString *LOG_DIRECTORY = @“CoreDataTutorial”;
  4. static NSURL *ald = nil;
  5. if (ald == nil)
  6. {
  7. NSFileManager *fileManager = [[NSFileManager alloc] init];
  8. NSError *error = nil;
  9. NSURL *libraryURL = [fileManager URLForDirectory:NSLibraryDirectory inDomain:NSUserDomainMask
  10. appropriateForURL:nil create:YES error:&error];
  11. if (libraryURL == nil) {
  12. NSLog(@“Could not access Library directory\n%@”, [error localizedDescription]);
  13. }
  14. else
  15. {
  16. ald = [libraryURL URLByAppendingPathComponent:@“Logs”];
  17. ald = [ald URLByAppendingPathComponent:LOG_DIRECTORY];
  18. NSLog(@” >> log path %@”, [ald path]);
  19. NSDictionary *properties = [ald resourceValuesForKeys:[NSArray arrayWithObject:NSURLIsDirectoryKey] error:&error];
  20. if (properties == nil)
  21. {
  22. if (![fileManager createDirectoryAtPath:[ald path] withIntermediateDirectories:YES attributes:nil error:&error])
  23. {
  24. NSLog(@“Could not create directory %@\n%@”,
  25. [ald path], [error localizedDescription]);
  26. ald = nil;
  27. }
  28. }
  29. }
  30. }
  31. return ald;
  32. }

在上面的代码中,我们将持久化数据文件保存到路径: /Users/kesalin/Library/Logs/CoreDataTutorial 下。

下面,我们来创建运行时对象:ManagedObjectContext 和 PersistentStoreCoordinator。

  1. NSManagedObjectContext *managedObjectContext()
  2. {
  3. static NSManagedObjectContext *moContext = nil;
  4. if (moContext != nil) {
  5. return moContext;
  6. }
  7. moContext = [[NSManagedObjectContext alloc] init];
  8. // Create a persistent store coordinator, then set the coordinator for the context.
  9. //
  10. NSManagedObjectModel *moModel = managedObjectModel();
  11. NSPersistentStoreCoordinator *coordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:moModel];
  12. [moContext setPersistentStoreCoordinator: coordinator];
  13. // Create a new persistent store of the appropriate type.
  14. //
  15. NSString *STORE_TYPE = NSXMLStoreType;
  16. NSString *STORE_FILENAME = @“CoreDataTutorial.xml”;
  17. NSError *error = nil;
  18. NSURL *url = [applicationLogDirectory() URLByAppendingPathComponent:STORE_FILENAME];
  19. NSPersistentStore *newStore = [coordinator addPersistentStoreWithType:STORE_TYPE
  20. configuration:nil
  21. URL:url
  22. options:nil
  23. error:&error];
  24. if (newStore == nil) {
  25. NSLog(@“Store Configuration Failure\n%@”, ([error localizedDescription] != nil) ? [error localizedDescription] : @“Unknown Error”);
  26. }
  27. return moContext;
  28. }

在上面的代码中:
1)我们创建了一个全局 ManagedObjectContext 对象 moContext;
2)并在设置其 persistent store coordinator,存储类型为 xml,保存文件名为:CoreDataTutorial.xml,并将其放到前面定义的存储路径下。

好,至此万事具备,只欠 ManagedObject 了!下面我们就来定义这个数据对象类。向工程添加 Core Data->NSManagedObject subclass 的类,名为 Run (模型中 Entity 定义的类名) 。

Run.h

  1. #import <CoreData/NSManagedObject.h>
  2. @interface Run : NSManagedObject
  3. {
  4. NSInteger processID;
  5. }
  6. @property (retain) NSDate *date;
  7. @property (retain) NSDate *primitiveDate;
  8. @property NSInteger processID;
  9. @end

Run.m

  1. //
  2. // Run.m
  3. // CoreDataTutorial
  4. //
  5. // Created by kesalin on 8/29/11.
  6. // Copyright 2011 kesalin@gmail.com. All rights reserved.
  7. //
  8. #import “Run.h”
  9. @implementation Run
  10. @dynamic date;
  11. @dynamic primitiveDate;
  12. – (void) awakeFromInsert
  13. {
  14. [super awakeFromInsert];
  15. self.primitiveDate = [NSDate date];
  16. }
  17. #pragma mark –
  18. #pragma mark Getter and setter
  19. – (NSInteger)processID
  20. {
  21. [self willAccessValueForKey:@“processID”];
  22. NSInteger pid = processID;
  23. [self didAccessValueForKey:@“processID”];
  24. return pid;
  25. }
  26. – (void)setProcessID:(NSInteger)newProcessID
  27. {
  28. [self willChangeValueForKey:@“processID”];
  29. processID = newProcessID;
  30. [self didChangeValueForKey:@“processID”];
  31. }
  32. // Implement a setNilValueForKey: method. If the key is “processID” then set processID to 0.
  33. //
  34. – (void)setNilValueForKey:(NSString *)key {
  35. if ([key isEqualToString:@“processID”]) {
  36. self.processID = 0;
  37. }
  38. else {
  39. [super setNilValueForKey:key];
  40. }
  41. }
  42. @end

注意:
1)这个类中的 date 和 primitiveDate 的访问属性为 @dynamic,这表明在运行期会动态生成对应的 setter 和 getter;
2)在这里我们演示了如何正确地手动实现 processID 的 setter 和 getter:为了让 ManagedObjecContext 能够检测 processID的变化,以及自动支持 undo/redo,我们需要在访问和更改数据对象时告之系统,will/didAccessValueForKey 以及 will/didChangeValueForKey 就是起这个作用的。
3)当我们设置 nil 给数据对象 processID 时,我们可以在 setNilValueForKey 捕获这个情况,并将 processID 置 0;
4)当数据对象被插入到 ManagedObjectContext 时,我们在 awakeFromInsert 将时间设置为当前时间。

三,创建或读取数据对象,设置其值,保存
好,至此真正的万事具备,我们可以创建或从持久化文件中读取数据对象,设置其值,并将其保存到持久化文件中。本例中持久化文件为 xml 文件。修改 main() 中代码如下:

  1. int main (int argc, const char * argv[])
  2. {
  3. NSLog(@” === Core Data Tutorial ===”);
  4. // Enable GC
  5. //
  6. objc_startCollectorThread();
  7. NSError *error = nil;
  8. NSManagedObjectModel *moModel = managedObjectModel();
  9. NSLog(@“The managed object model is defined as follows:\n%@”, moModel);
  10. if (applicationLogDirectory() == nil) {
  11. exit(1);
  12. }
  13. NSManagedObjectContext *moContext = managedObjectContext();
  14. // Create an Instance of the Run Entity
  15. //
  16. NSEntityDescription *runEntity = [[moModel entitiesByName] objectForKey:@“Run”];
  17. Run *run = [[Run alloc] initWithEntity:runEntity insertIntoManagedObjectContext:moContext];
  18. NSProcessInfo *processInfo = [NSProcessInfo processInfo];
  19. run.processID = [processInfo processIdentifier];
  20. if (![moContext save: &error]) {
  21. NSLog(@“Error while saving\n%@”, ([error localizedDescription] != nil) ? [error localizedDescription] : @“Unknown Error”);
  22. exit(1);
  23. }
  24. // Fetching Run Objects
  25. //
  26. NSFetchRequest *request = [[NSFetchRequest alloc] init];
  27. [request setEntity:runEntity];
  28. NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@“date” ascending:YES];
  29. [request setSortDescriptors:[NSArray arrayWithObject:sortDescriptor]];
  30. error = nil;
  31. NSArray *array = [moContext executeFetchRequest:request error:&error];
  32. if ((error != nil) || (array == nil))
  33. {
  34. NSLog(@“Error while fetching\n%@”, ([error localizedDescription] != nil) ? [error localizedDescription] : @“Unknown Error”);
  35. exit(1);
  36. }
  37. // Display the Results
  38. //
  39. NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
  40. [formatter setDateStyle:NSDateFormatterMediumStyle];
  41. [formatter setTimeStyle:NSDateFormatterMediumStyle];
  42. NSLog(@“%@ run history:”, [processInfo processName]);
  43. for (run in array)
  44. {
  45. NSLog(@“On %@ as process ID %ld”, [formatter stringForObjectValue:run.date], run.processID);
  46. }
  47. return 0;
  48. }

在上面的代码中:
1)我们先获得全局的 NSManagedObjectModel 和 NSManagedObjectContext 对象:moModel 和 moContext;
2)并创建一个Run Entity,设置其 Property processID 为当前进程的 ID;
3)将该数据对象保存到持久化文件中:[moContext  save : &error]。我们无需与 PersistentStoreCoordinator 打交道,只需要给 ManagedObjectContext 发送 save 消息即可,NSManagedObjectContext 会透明地在后面处理对持久化数据文件的读写;
4)然后我们创建一个 FetchRequest 来查询持久化数据文件中保存的数据记录,并将结果按照日期升序排列。查询操作也是由 ManagedObjectContext 来处理的:[moContext executeFetchRequest :request  error :&error];
5)将查询结果打印输出;

大功告成!编译运行,我们可以得到如下显示:

  1. 2011-09-03 21:42:47.556 CoreDataTutorial[992:903] CoreDataTutorial run history:
  2. 2011-09-03 21:42:47.557 CoreDataTutorial[992:903] On 2011-9-3 下午09:41:56 as process ID 940
  3. 2011-09-03 21:42:47.557 CoreDataTutorial[992:903] On 2011-9-3 下午09:42:16 as process ID 955
  4. 2011-09-03 21:42:47.558 CoreDataTutorial[992:903] On 2011-9-3 下午09:42:20 as process ID 965
  5. 2011-09-03 21:42:47.558 CoreDataTutorial[992:903] On 2011-9-3 下午09:42:24 as process ID 978
  6. 2011-09-03 21:42:47.559 CoreDataTutorial[992:903] On 2011-9-3 下午09:42:47 as process ID 992

 

通过这个例子,我们可以更好理解 Core Data 的运作机制。在 Core Data 中我们*常用的就是 ManagedObjectContext,它几乎参与对数据对象的所有操作,包括对 undo/redo 的支持;而 Entity 对应的运行时类为 ManagedObject,我们可以理解为抽象数据结构 Entity 在内存中由 ManagedObject 来体现,而 Perproty 数据类型在内存中则由 ManagedObject 类的成员属性来体现。一般我们不需要与 PersistentStoreCoordinator 打交道,对数据文件的读写操作都由 ManagedObjectContext 为我们代劳了。

IOS学习之ios开发之数据的持久化存储机制

IOS中数据的持久化保存这块内容,类似于Android中文件的几种常见的存储方式。
对于数据的持久化存储,ios中一般提供了4种不同的机制。
1.属性列表
2.对象归档
3.数据库存储(SQLite3)
4.苹果公司提供的持久性工具Core Data。

其实储存的形式无非就这么几种,而我们还必须要关心的是,这些文件会被放置在那个文件下,然后如何读取。
也就是说:IOS上数据存储,我们要了解的两点,数据存储格式(也就是存储机制),数据存储位置。
1》文件如何存储(如上面4点)
2》文件存储在哪里。
对于数据的操作,其实我们关心的是操作的速率。
就好比在Adnroid中偏好存储,数据库存储,io存储一样。
我大致问了我们公司新来的ios哥们,他说他们培训机构基本对数据操作这块就讲了属性列表和数据库,以及普通的文件存储(比如音视频图这些多媒体数据)。
我就只好先看看书了。

一:应用文件目录
首先我们来看了解下ios数据存储位置,因为只有知道位置路径我们才能去读取数据,而数据的持久化机制不过是针对操作速率来考虑的,
比如我们大致知道属性列表(既键值对形式)的存储熟虑应该高于数据库高于io文件流存储。
我们在选择用何种机制存储数据,主要也是看数据的形式。

一个ios应用安装后大致会有如下文件夹及其对应路径:

%title插图%num

在mac上看模拟器中应用路径:
/Users/nono/Library/Application Support/iPhone Simulator/5.1/Applications/2D135859-1E80-4754-B36D-34A53C521DE3

你在finder中的home下可能找不到Library这个目录,因为貌似是影藏起来了(我这机器上是,在终端可以看到)。
*后那一窜的类似序列号的东西就是ios自动给应用生成的一组应用唯一识别码*为了应用的home目录名。
其下面就是上图所示了。
书上对这些文件夹介绍:

Document:应用程序将其数据存储在这个文件夹下,基于NSUserDefaults的首选项的设置除外。

简单理解是,基本上我们要操作的一些数据都是存储在这个文件夹下面的

TIPS:这边提下一点,对于ios系统这么分配文件夹,是因为在设备进行同步时,ITunes有选择性的意识来备份文件。

比如我们可以猜到,tmp下的应该就不会备份了。

对于Document文件夹目录路径的获取,API提供了这么一种方法:

[cpp] view plain copy

  1. NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
  2.    NSString *docPath = [paths objectAtIndex:0];
  1. NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
  2. NSString *docPath = [paths objectAtIndex:0];

Library:基于NSUserDefault首选项设置存储在其下Preferences文件夹中,简单来说,这个文件夹一般你很少操作到。

书上对于这部分基本没介绍。估计对于初级部分是跳过了。

Tmp:应用临时存储文件,当不需要时,应用负责删除其下的文件数据。

该文件也提供了目录获取方法:

[cpp] view plain copy

  1. NSString *tmpDoc = NSTemporaryDirectory();
NSString *tmpDoc = NSTemporaryDirectory();

应用程序文件:这个基本没提到书上,但是我们大致可以猜测,这就是整个应用程序的程序文件夹吧。

好了,以上我们大致解决了我们提到的*个点,文件存储目录

二:数据存储机制

1.属性列表

这个其实我们早见过,plist就是,感觉用来存储键值对小数据是*合适,因为速率很高。

这个存储机制很简单,对于前面我们使用过了在plist文件来读取数据填充一些列表,只不过那会plist文件存储位置不同,

用的是Mainbundle什么的来返回文件夹,其实这边我也推测,上面提到有个应用程序文件夹,它下面的文件就是这么来读取的~(反正暂时不管他)

这边不过就是改变了存储位置,数据操作还是一样的

[cpp] view plain copy

  1. NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
  2. NSString *docPath = [paths objectAtIndex:0];
  3. NSString *myFile = [docPath stringByAppendingPathComponent:@“my.list”];
  4. //读取文件 
  5. NSArray *array = [[NSArray alloc] initWithContentsOfFile:myFile];
  6. //操作完若修改了数据则,写入文件 
  7. [array writeToFile:myFile atomically:YES];
  1. NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
  2. NSString *docPath = [paths objectAtIndex:0];
  3. NSString *myFile = [docPath stringByAppendingPathComponent:@“my.list”];
  4. //读取文件
  5. NSArray *array = [[NSArray alloc] initWithContentsOfFile:myFile];
  6. //操作完若修改了数据则,写入文件
  7. [array writeToFile:myFile atomically:YES];

2.对象归档

上面的属性列表存储机制,我们都知道,这个机制支持NSArray,NSDictionary,NSData,NSString,NSNumber,NSDate 等等

这些对象直接写入plist文件中。

那么对于一些复杂对象,我要保存整个这个对象数据呢?

反正我是这么觉得,这个机制很像java中的对象整体序列化。当然,这些数据在读取是就需要遵循一种墨守成规的协议了。

首先我们定义的对象类,必须实现NSCoding和NSCopying协议(额,网上说后面这个不实现也可以,我猜是他对象没有copy操作,因此没出错)书本上反正是实现了这两个协议
然后归档中用到的操作类
NSKeyedArchiver
这边我们定义一个对象,h文件中定义两属性,申明要实现的NSCoding和NSCopying协议
实现文件

[cpp] view plain copy

  1. // 
  2. //  TestObj.m 
  3. //  DataStorageTest 
  4. // 
  5. //  Created by Nono on 12-5-12. 
  6. //  Copyright (c) 2012年 NonoWithLilith. All rights reserved. 
  7. // 
  8. #import “TestObj.h” 
  9. @implementation TestObj
  10. @synthesize stringA = stringA;
  11. @synthesize stringB = stringB;
  12. #pragma mark – 
  13. #pragma NSCoding协议实现实现 
  14. – (void)encodeWithCoder:(NSCoder *)aCoder
  15. {   //encoder 
  16.     [aCoder encodeObject:stringAforKey:@“1”];
  17.     [aCoder encodeObject:stringBforKey:@“2”];
  18. }
  19. – (id)initWithCoder:(NSCoder *)aDecoder
  20. {
  21.     //decoder 
  22.     if (self = [superinit]) {
  23.         stringA = [[aDecoder decodeObjectForKey:@“1”] retain];
  24.         stringB = [[aDecoder decodeObjectForKey:@“2”] retain];
  25.     }
  26.     returnself;
  27. }
  28. #pragma NSCopying协议实现 
  29. – (id)copyWithZone:(NSZone *)zone
  30. {
  31.     TestObj *copy = [[[selfclass] allocWithZone:zone] init];
  32.     copy.stringA = [[self.stringAcopyWithZone:zone] autorelease];
  33.     copy.stringB = [[self.stringBcopyWithZone:zone] autorelease];
  34.     return copy;
  35. }
  36. @end
  1. //
  2. // TestObj.m
  3. // DataStorageTest
  4. //
  5. // Created by Nono on 12-5-12.
  6. // Copyright (c) 2012年 NonoWithLilith. All rights reserved.
  7. //
  8. #import “TestObj.h”
  9. @implementation TestObj
  10. @synthesize stringA = stringA;
  11. @synthesize stringB = stringB;
  12. #pragma mark –
  13. #pragma NSCoding协议实现实现
  14. – (void)encodeWithCoder:(NSCoder *)aCoder
  15. { //encoder
  16. [aCoder encodeObject:stringAforKey:@“1”];
  17. [aCoder encodeObject:stringBforKey:@“2”];
  18. }
  19. – (id)initWithCoder:(NSCoder *)aDecoder
  20. {
  21. //decoder
  22. if (self = [superinit]) {
  23. stringA = [[aDecoder decodeObjectForKey:@“1”] retain];
  24. stringB = [[aDecoder decodeObjectForKey:@“2”] retain];
  25. }
  26. returnself;
  27. }
  28. #pragma NSCopying协议实现
  29. – (id)copyWithZone:(NSZone *)zone
  30. {
  31. TestObj *copy = [[[selfclass] allocWithZone:zone] init];
  32. copy.stringA = [[self.stringAcopyWithZone:zone] autorelease];
  33. copy.stringB = [[self.stringBcopyWithZone:zone] autorelease];
  34. return copy;
  35. }
  36. @end

然后是对对象归档的读取和写入

[cpp] view plain copy

  1. //读取归档文件 
  2.    NSData *data = [[NSMutableDataalloc] initWithContentsOfFile:myFile];
  3.    NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiveralloc] initForReadingWithData:data];
  4.    TestObj * test = [unarchiver decodeObjectForKey:@“data”];
  5.    [unarchiver finishDecoding];
  6.    [data release];
  7.    [unarchiver release];
  8.    //写入归档文件 
  9.    NSMutableData *data1 = [[NSMutableDataalloc] init];
  10.    NSKeyedArchiver *archiver = [[NSKeyedArchiveralloc] initForWritingWithMutableData:data1];
  11.    [archiver encodeObject:test forKey:@“data”];
  12.    [archiver finishEncoding];
  13.    [data writeToFile:myFile atomically:YES];
  14.    [data1 release];
  15.    [archiver release];
  16.    [test release];
  1. //读取归档文件
  2. NSData *data = [[NSMutableDataalloc] initWithContentsOfFile:myFile];
  3. NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiveralloc] initForReadingWithData:data];
  4. TestObj * test = [unarchiver decodeObjectForKey:@“data”];
  5. [unarchiver finishDecoding];
  6. [data release];
  7. [unarchiver release];
  8. //写入归档文件
  9. NSMutableData *data1 = [[NSMutableDataalloc] init];
  10. NSKeyedArchiver *archiver = [[NSKeyedArchiveralloc] initForWritingWithMutableData:data1];
  11. [archiver encodeObject:test forKey:@“data”];
  12. [archiver finishEncoding];
  13. [data writeToFile:myFile atomically:YES];
  14. [data1 release];
  15. [archiver release];
  16. [test release];

但是问了下新同事,据说这个用到也是蛮少,至少他目前。
但是,我看了下,觉得这个和Android 中Parcelable
太尼玛像似了

三.数据库存储
和Android一样,ios中也是用了SQLite3这种嵌入式数据库。

这个网上例子是很多了。我这边就大致看下了数据库的打开,

数据库表创建,查询,插入

[cpp] view plain copy

  1.  //数据库操作 
  2.  sqlite3 *database;
  3. // const NSString * dbname = @”mydb” 
  4.  int result;
  5.  //打开一个指定路径的现有的数据库,如果没有则会新建一个db库 
  6.  result =  sqlite3_open([myFile UTF8String], &database);
  7.  if (result != SQLITE_OK) {
  8.      sqlite3_close(database);
  9.  }
  10.  //创建一个db表 
  11.  char *errorMsg;
  12.  NSString *sql_create_table = @“CREATE TABLE IF NOT EXISTS NONOTABLE 省略~~~~~~~~~~~~~”;
  13.  int result1 ;
  14.  //sqlite_exec用了针对sqlite3运行任何不要返回数据的命令,它用于执行更新,插入和删除。简单来说,这个方法执行的都是一些无需返回数据(虽然我们可能获取一个状态值。)。 
  15.  result1 = sqlite3_exec(database, [sql_create_table UTF8String], NULL, NULL, &errorMsg);
  16.  //检索查询操作 
  17.  int result2 ;
  18.  sqlite3_stmt *statment;
  19.  NSString *sql_selected = @“查询语句”;
  20. result2 = sqlite3_prepare_v2(database, [sql_selected UTF8String], -1, &statment, nil);
  21.  if(result2 == SQLITE_OK){
  22.      //单步操作 
  23.      while (sqlite3_step(statment) == SQLITE_ROW) {
  24.          int row = sqlite3_column_int(statment, 0);
  25.          char * rpwData = sqlite3_column_text(statment, 1);
  26.      }
  27.      sqlite3_finalize(statment);
  28.  }
  29.  //绑定变量,既就是插入操作的一种变种,比如我么那上面提到sqlite_exec可以执行插入操作,插入内容直接是写在sql字窜里,但是考虑到字窜涉及到无效的符号以及会一些严重的注入漏洞(比如以前听过的引号符号)。 
  30.  NSString *sql_bind = @“insert into foo value(?,?)”;
  31.  result2 = sqlite3_prepare_v2(database, [sql_selected UTF8String], -1, &statment, nil);
  32.  if(result2 == SQLITE_OK){
  33.      sqlite3_bind_int(statment, 1, 235);
  34.      sqlite3_bind_text(statment, 2, “test”, -1, nil);
  35.            sqlite3_finalize(statment);
  36.  }
  37.  if (sqlite3_step(statment) != SQLITE_DONE)
  38.      NSLog(@“error”);
  39.  sqlite3_finalize(statment);
  40.  sqlite3_close(database);
  1. //数据库操作
  2. sqlite3 *database;
  3. // const NSString * dbname = @”mydb”
  4. int result;
  5. //打开一个指定路径的现有的数据库,如果没有则会新建一个db库
  6. result = sqlite3_open([myFile UTF8String], &database);
  7. if (result != SQLITE_OK) {
  8. sqlite3_close(database);
  9. }
  10. //创建一个db表
  11. char *errorMsg;
  12. NSString *sql_create_table = @“CREATE TABLE IF NOT EXISTS NONOTABLE 省略~~~~~~~~~~~~~”;
  13. int result1 ;
  14. //sqlite_exec用了针对sqlite3运行任何不要返回数据的命令,它用于执行更新,插入和删除。简单来说,这个方法执行的都是一些无需返回数据(虽然我们可能获取一个状态值。)。
  15. result1 = sqlite3_exec(database, [sql_create_table UTF8String], NULL, NULL, &errorMsg);
  16. //检索查询操作
  17. int result2 ;
  18. sqlite3_stmt *statment;
  19. NSString *sql_selected = @“查询语句”;
  20. result2 = sqlite3_prepare_v2(database, [sql_selected UTF8String], -1, &statment, nil);
  21. if(result2 == SQLITE_OK){
  22. //单步操作
  23. while (sqlite3_step(statment) == SQLITE_ROW) {
  24. int row = sqlite3_column_int(statment, 0);
  25. char * rpwData = sqlite3_column_text(statment, 1);
  26. }
  27. sqlite3_finalize(statment);
  28. }
  29. //绑定变量,既就是插入操作的一种变种,比如我么那上面提到sqlite_exec可以执行插入操作,插入内容直接是写在sql字窜里,但是考虑到字窜涉及到无效的符号以及会一些严重的注入漏洞(比如以前听过的引号符号)。
  30. NSString *sql_bind = @“insert into foo value(?,?)”;
  31. result2 = sqlite3_prepare_v2(database, [sql_selected UTF8String], -1, &statment, nil);
  32. if(result2 == SQLITE_OK){
  33. sqlite3_bind_int(statment, 1, 235);
  34. sqlite3_bind_text(statment, 2, “test”, -1, nil);
  35. sqlite3_finalize(statment);
  36. }
  37. if (sqlite3_step(statment) != SQLITE_DONE)
  38. NSLog(@“error”);
  39. sqlite3_finalize(statment);
  40. sqlite3_close(database);

关于更多的,大伙可以自行百度,因为数据库的操作语法太怪异了,书上说是基本是基于c的,本人没学过c。看得有点心烦~

4。Core Data存储机制

大致浏览下基本感觉就是将对象归档搞成了可视化和简单化。

这块内容比较多。网上资料也挺丰富的。

暂时不做介绍了。

总结下:其实对于ios数据存储,*常用和主要要掌握的就是属性列表和数据库,因为两个是出镜率比较高的。

其他可能在数据存明显体现出储优势时,我们会去考虑用另外两种机制。

基础的来说,必须掌握属性列表和sqlite的操作存储。