struct redisObject {
    unsigned type:4;           // 对象类型，4位
    unsigned encoding:4;       // 编码方式，4位（底层实现）
    unsigned lru:LRU_BITS;     // LRU时间或LFU数据，24位（相对于 server.lruclock） 
    unsigned iskvobj : 1;      // 是否为kvobj，1位
    unsigned expirable : 1;    // 是否可过期，1位
    unsigned refcount : OBJ_REFCOUNT_BITS; // 引用计数，30位
    void *ptr;                 // 指向实际数据的指针
};

typedef struct redisObject kvobj;

kvobj *kvobjCreate(int type, const sds key, void *ptr, int hasExpire) {
    // 计算嵌入键的大小
    size_t key_sds_len = sdslen(key);
    char key_sds_type = sdsReqType(key_sds_len);
    size_t key_sds_size = sdsReqSize(key_sds_len, key_sds_type);

    // 计算基础对象大小
    size_t min_size = sizeof(robj);
    if (hasExpire) min_size += sizeof(long long);
    min_size += 1 + key_sds_size; // 1字节用于SDS头部大小

    // 分配对象内存
    robj *o = zmalloc_usable(min_size, &bufsize);
    o->type = type;
    o->encoding = OBJ_ENCODING_RAW;
    o->ptr = ptr;
    o->refcount = 1;
    o->lru = 0;
    o->iskvobj = 1;
    o->expirable = hasExpire;

    // 在结构体后面嵌入数据
    char *data = (void *)(o + 1);
    
    // 设置过期时间字段
    if (o->expirable) {
        *(long long *)data = -1;
        data += sizeof(long long);
    }

    // 存储嵌入的键
    *data++ = sdsHdrSize(key_sds_type);
    sdsnewplacement(data, key_sds_size, key_sds_type, key, key_sds_len);

    return o;
}

  +-----------+------------+------------------+------------------------+
  | robj (16) | expiry (8) | key-hdr-size (1) | sdshdr5 "mykey" \0 (7) | 
  +-----------+------------+------------------+------------------------+

robj *createObject(int type, void *ptr) {
    robj *o = zmalloc(sizeof(*o));
    o->type = type;
    o->encoding = OBJ_ENCODING_RAW;
    o->ptr = ptr;
    o->refcount = 1;
    o->lru = 0;
    o->iskvobj = 0;
    o->expirable = 0;
    return o;
}

void incrRefCount(robj *o) {
    if (o->refcount < OBJ_FIRST_SPECIAL_REFCOUNT) {
        o->refcount++;
    } else {
        if (o->refcount == OBJ_SHARED_REFCOUNT) {
            // 共享对象，无需操作
        } else if (o->refcount == OBJ_STATIC_REFCOUNT) {
            serverPanic("You tried to retain an object allocated in the stack");
        }
    }
}

void decrRefCount(robj *o) {
    if (o->refcount == OBJ_SHARED_REFCOUNT)
        return; // 共享对象，永不释放

    if (unlikely(o->refcount <= 0)) {
        serverPanic("illegal decrRefCount for object");
    }

    if (--(o->refcount) == 0) {
        // 根据对象类型释放内存
        switch(o->type) {
        case OBJ_STRING: freeStringObject(o); break;
        case OBJ_LIST: freeListObject(o); break;
        case OBJ_SET: freeSetObject(o); break;
        case OBJ_ZSET: freeZsetObject(o); break;
        case OBJ_HASH: freeHashObject(o); break;
        case OBJ_MODULE: freeModuleObject(o); break;
        case OBJ_STREAM: freeStreamObject(o); break;
        default: serverPanic("Unknown object type"); break;
        }
        zfree(o);
    }
}

// 字符串对象的编码选择
robj *createStringObject(const char *ptr, size_t len) {
    if (len <= OBJ_ENCODING_EMBSTR_SIZE_LIMIT)
        return createEmbeddedStringObject(ptr,len);  // 嵌入式编码
    else
        return createRawStringObject(ptr,len);       // 原始编码
}

robj *createEmbeddedStringObject(const char *val_ptr, size_t val_len) {
    size_t val_sds_size = sdsReqSize(val_len, SDS_TYPE_8);
    robj *o = zmalloc_usable(sizeof(robj) + val_sds_size, &bufsize);
    o->type = OBJ_STRING;
    o->encoding = OBJ_ENCODING_EMBSTR;  // 嵌入式编码
    o->refcount = 1;
    o->lru = 0;
    o->expirable = 0;
    o->iskvobj = 0;
    
    // 在对象后面直接存储字符串数据
    char *data = (char *)(o + 1);
    o->ptr = sdsnewplacement(data, remaining_size, SDS_TYPE_8, val_ptr, val_len);
    return o;
}

// 创建一个字符串对象
robj *str_obj = createStringObject("hello", 5);

// 创建一个列表对象
robj *list_obj = createQuicklistObject();

// 检查对象类型
if (str_obj->type == OBJ_STRING) {
    // 处理字符串对象
}

// 增加引用计数
incrRefCount(str_obj);

// 减少引用计数
decrRefCount(str_obj);

robj *tryObjectEncodingEx(robj *o, int try_trim) {
    long value;
    sds s = o->ptr;
    size_t len;

    // 只对字符串对象进行编码优化
    serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
    
    // 只处理RAW或EMBSTR编码的对象
    if (!sdsEncodedObject(o)) return o;
    
    // 共享对象不能重新编码
    if (o->refcount > 1) return o;

    // 尝试转换为整数编码
    len = sdslen(s);
    if (len <= 20 && string2l(s,len,&value)) {
        if (o->encoding == OBJ_ENCODING_RAW) {
            sdsfree(o->ptr);
            o->encoding = OBJ_ENCODING_INT;
            o->ptr = (void*) value;
            return o;
        } else if (o->encoding == OBJ_ENCODING_EMBSTR) {
            decrRefCount(o);
            return createStringObjectFromLongLongForValue(value);
        }
    }

    // 尝试转换为嵌入式编码
    if (len <= OBJ_ENCODING_EMBSTR_SIZE_LIMIT) {
        robj *emb;
        if (o->encoding == OBJ_ENCODING_EMBSTR) return o;
        emb = createEmbeddedStringObject(s,sdslen(s));
        decrRefCount(o);
        return emb;
    }

    // 最后尝试优化SDS字符串
    if (try_trim)
        trimStringObjectIfNeeded(o, 0);

    return o;
}

int compareStringObjectsWithFlags(const robj *a, const robj *b, int flags) {
    serverAssertWithInfo(NULL,a,a->type == OBJ_STRING && b->type == OBJ_STRING);
    char bufa[128], bufb[128], *astr, *bstr;
    size_t alen, blen, minlen;

    if (a == b) return 0;
    
    // 处理不同编码的字符串
    if (sdsEncodedObject(a)) {
        astr = a->ptr;
        alen = sdslen(astr);
    } else {
        alen = ll2string(bufa,sizeof(bufa),(long) a->ptr);
        astr = bufa;
    }
    
    if (sdsEncodedObject(b)) {
        bstr = b->ptr;
        blen = sdslen(bstr);
    } else {
        blen = ll2string(bufb,sizeof(bufb),(long) b->ptr);
        bstr = bufb;
    }
    
    // 根据标志选择比较方式
    if (flags & REDIS_COMPARE_COLL) {
        return strcoll(astr,bstr);  // 使用locale比较
    } else {
        int cmp;
        minlen = (alen < blen) ? alen : blen;
        cmp = memcmp(astr,bstr,minlen);  // 二进制比较
        if (cmp == 0) return alen-blen;
        return cmp;
    }
}

size_t objectComputeSize(robj *key, robj *o, size_t sample_size, int dbid) {
    dict *d;
    dictIterator di;
    struct dictEntry *de;
    size_t asize = 0, elesize = 0, elecount = 0, samples = 0;

    if (o->type == OBJ_STRING) {
        if(o->encoding == OBJ_ENCODING_INT) {
            asize = sizeof(*o);  // 整数编码只计算对象头
        } else if(o->encoding == OBJ_ENCODING_RAW) {
            asize = sdsZmallocSize(o->ptr)+sizeof(*o);  // RAW编码加上SDS大小
        } else if(o->encoding == OBJ_ENCODING_EMBSTR) {
            asize = zmalloc_size((void *)o);  // 嵌入式编码计算整个对象
        }
    } else if (o->type == OBJ_LIST) {
        if (o->encoding == OBJ_ENCODING_QUICKLIST) {
            quicklist *ql = o->ptr;
            quicklistNode *node = ql->head;
            asize = sizeof(*o)+sizeof(quicklist);
            
            // 采样计算平均节点大小
            do {
                elesize += sizeof(quicklistNode)+zmalloc_size(node->entry);
                elecount += node->count;
                samples++;
            } while ((node = node->next) && samples < sample_size);
            
            asize += (double)elesize/elecount*ql->count;
        }
    }
    // ... 其他类型的计算
    return asize;
}

int objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
                       long long lru_clock, int lru_multiplier) {
    if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
        // LFU模式：高16位存储时间，低8位存储频率
        if (lfu_freq >= 0) {
            serverAssert(lfu_freq <= 255);
            val->lru = (LFUGetTimeInMinutes()<<8) | lfu_freq;
            return 1;
        }
    } else if (lru_idle >= 0) {
        // LRU模式：存储最后访问时间
        lru_idle = lru_idle*lru_multiplier/LRU_CLOCK_RESOLUTION;
        long lru_abs = lru_clock - lru_idle;
        
        // 处理时钟回绕
        if (lru_abs < 0)
            lru_abs += LRU_CLOCK_MAX;
        val->lru = lru_abs;
        return 1;
    }
    return 0;
}

int checkType(client *c, robj *o, int type) {
    if (o->type != type) {
        addReply(c,shared.wrongtypeerr);
        return 1;
    }
    return 0;
}

int getLongLongFromObject(robj *o, long long *target) {
    long long value;

    if (o == NULL) {
        value = 0;
    } else {
        serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
        if (sdsEncodedObject(o)) {
            if (string2ll(o->ptr, sdslen(o->ptr), &value) == 0) return C_ERR;
        } else if (o->encoding == OBJ_ENCODING_INT) {
            value = (long)o->ptr;
        } else {
            serverPanic("Unknown string encoding");
        }
    }
    *target = value;
    return C_OK;
}

size_t getObjectLength(robj *o) {
    switch(o->type) {
        case OBJ_STRING: return stringObjectLen(o);
        case OBJ_LIST: return listTypeLength(o);
        case OBJ_SET: return setTypeSize(o);
        case OBJ_ZSET: return zsetLength(o);
        case OBJ_HASH: return hashTypeLength(o, 0);
        case OBJ_STREAM: return streamLength(o);
        default: return 0;
    }
}

void objectCommand(client *c) {
    kvobj *kv;

    if (!strcasecmp(c->argv[1]->ptr,"refcount") && c->argc == 3) {
        // 返回引用计数
        addReplyLongLong(c, kv->refcount);
    } else if (!strcasecmp(c->argv[1]->ptr,"encoding") && c->argc == 3) {
        // 返回编码方式
        addReplyBulkCString(c,strEncoding(kv->encoding));
    } else if (!strcasecmp(c->argv[1]->ptr,"idletime") && c->argc == 3) {
        // 返回空闲时间
        addReplyLongLong(c, estimateObjectIdleTime(kv) / 1000);
    } else if (!strcasecmp(c->argv[1]->ptr,"freq") && c->argc == 3) {
        // 返回访问频率（LFU模式）
        addReplyLongLong(c,LFUDecrAndReturn(kv));
    }
}