realm的学习

最新推荐文章于 2021-12-06 21:08:57 发布
最新推荐文章于 2021-12-06 21:08:57 发布
阅读量1.3k 收藏
点赞数

realm是一个跨平台移动数据库引擎，支持iOS、OS X（Objective-C和Swift）以及Android。

为了彻底解决性能问题，核心数据引擎C++打造的MVCC 数据库（MVCC 指的是多版本并发控制），并不是建立在SQLite之上的ORM。如果对数据引擎实现想深入了解可以查看：Realm 核心数据库引擎探秘。因此得到的收益就是比普通的ORM要快很多，甚至比单独无封装的SQLite还要快。这具体快多少的数据有人做过实验，可网上搜索。

相比SQLite，Realm更快并且具有很多现代数据库的特性，比如支持JSON，流式api，数据变更通知，以及加密支持，这些都为开发者带来了方便。

我认为靠谱的使用或者在现有项目上替换方式是抽象层+特性开关，这样降低耦合性，方便日后替换成任何数据库。

多数情况下把数据存在磁盘上的数据库文件中。发起一个从持久化机制（比如 ORM 或者 Core Data）中获取数据的请求，数据格式会是和本地平台密切相关的。持久化机制会把请求转换成一系列的 SQL 语句，创建一个数据库连接（如果没有创建的话），发送到磁盘上，执行查询，读取命中查询的每一行的数据，然后存到内存里（这里有内存消耗）。之后你需要把数据序列化成可在内存里面存储的格式，（比特对齐），CPU 才能处理它们。数据需要转换成语言层面的类型，然后它会以对象的形式返回，这样平台才能用（POJO， NSManagedObject 等等）来处理它。

Realm 跳过了拷贝过程，因为数据库文件是 memory-mapped。Realm 在访问文件偏移的时候就好像文件已经在内存中一样，实际上不是，而是虚拟内存。这是个 Realm 核心文件格式的重要设计决定。它允许文件能在没有做任何反序列化的情况下可以在内存中读取。

Realm 跳过了所有这些开销很大的步骤，而这些步骤在传统的持久化机制中必须执行。Realm 只需要简单地计算偏移来找到文件中的数据，然后从原始访问点返回数据结构(POJO/NSManagedObject/等等)的值 。有效而且更快。

realm的文档地址（https://realm.io/docs/java/latest/），有demo，有简介。

托管realm对象和非托管realm对象。Realm.copyFromRealm()Realm.copyToRealm()

继承RealmObject对象或者实现RealmModel接口

public class Product extends RealmObject {
    @PrimaryKey
    private long productId;        // 商品ID

    private String title;          // 商品标题

    private double price;          // 商品价格

    private String image;          // 商品图片

    private long vshopId;

    private boolean collect;       // 是否收藏

    public long getProductId() {
        return productId;
    }

    public void setProductId(long productId) {
        this.productId = productId;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getImage() {
        return image;
    }

    public void setImage(String image) {
        this.image = image;
    }

    public long getVshopId() {
        return vshopId;
    }

    public void setVshopId(long vshopId) {
        this.vshopId = vshopId;
    }

    public boolean isCollect() {
        return collect;
    }

    public void setCollect(boolean collect) {
        this.collect = collect;
    }

    @Override
    public String toString() {
        return "Product{" +
                "productId=" + productId +
                ", title=" + title +
                ", price=" + price +
                ", image=" + image +
                ", vshopId=" + vshopId +
                ", collect=" + collect +
                '}';
    }
}
public class ProductRealmProxy extends Product implements RealmObjectProxy, ProductRealmProxyInterface {
    private final ProductRealmProxy.ProductColumnInfo columnInfo;
    private final ProxyState proxyState;
    private static final List<String> FIELD_NAMES;

    ProductRealmProxy(ColumnInfo columnInfo) {
        this.columnInfo = (ProductRealmProxy.ProductColumnInfo)columnInfo;
        this.proxyState = new ProxyState(Product.class, this);
    }

    public long realmGet$productId() {
        this.proxyState.getRealm$realm().checkIfValid();
        return this.proxyState.getRow$realm().getLong(this.columnInfo.productIdIndex);
    }

    public void realmSet$productId(long value) {
        this.proxyState.getRealm$realm().checkIfValid();
        this.proxyState.getRow$realm().setLong(this.columnInfo.productIdIndex, value);
    }

    public String realmGet$title() {
        this.proxyState.getRealm$realm().checkIfValid();
        return this.proxyState.getRow$realm().getString(this.columnInfo.titleIndex);
    }

    public void realmSet$title(String value) {
        this.proxyState.getRealm$realm().checkIfValid();
        if(value == null) {
            this.proxyState.getRow$realm().setNull(this.columnInfo.titleIndex);
        } else {
            this.proxyState.getRow$realm().setString(this.columnInfo.titleIndex, value);
        }
    }

    public double realmGet$price() {
        this.proxyState.getRealm$realm().checkIfValid();
        return this.proxyState.getRow$realm().getDouble(this.columnInfo.priceIndex);
    }

    public void realmSet$price(double value) {
        this.proxyState.getRealm$realm().checkIfValid();
        this.proxyState.getRow$realm().setDouble(this.columnInfo.priceIndex, value);
    }

    public String realmGet$image() {
        this.proxyState.getRealm$realm().checkIfValid();
        return this.proxyState.getRow$realm().getString(this.columnInfo.imageIndex);
    }

    public void realmSet$image(String value) {
        this.proxyState.getRealm$realm().checkIfValid();
        if(value == null) {
            this.proxyState.getRow$realm().setNull(this.columnInfo.imageIndex);
        } else {
            this.proxyState.getRow$realm().setString(this.columnInfo.imageIndex, value);
        }
    }

    public long realmGet$vshopId() {
        this.proxyState.getRealm$realm().checkIfValid();
        return this.proxyState.getRow$realm().getLong(this.columnInfo.vshopIdIndex);
    }

    public void realmSet$vshopId(long value) {
        this.proxyState.getRealm$realm().checkIfValid();
        this.proxyState.getRow$realm().setLong(this.columnInfo.vshopIdIndex, value);
    }

    public boolean realmGet$collect() {
        this.proxyState.getRealm$realm().checkIfValid();
        return this.proxyState.getRow$realm().getBoolean(this.columnInfo.collectIndex);
    }

    public void realmSet$collect(boolean value) {
        this.proxyState.getRealm$realm().checkIfValid();
        this.proxyState.getRow$realm().setBoolean(this.columnInfo.collectIndex, value);
    }

    public static Table initTable(ImplicitTransaction transaction) {
        if(!transaction.hasTable("class_Product")) {
            Table table = transaction.getTable("class_Product");
            table.addColumn(RealmFieldType.INTEGER, "productId", false);
            table.addColumn(RealmFieldType.STRING, "title", true);
            table.addColumn(RealmFieldType.DOUBLE, "price", false);
            table.addColumn(RealmFieldType.STRING, "image", true);
            table.addColumn(RealmFieldType.INTEGER, "vshopId", false);
            table.addColumn(RealmFieldType.BOOLEAN, "collect", false);
            table.addSearchIndex(table.getColumnIndex("productId"));
            table.setPrimaryKey("productId");
            return table;
        } else {
            return transaction.getTable("class_Product");
        }
    }

    public static ProductRealmProxy.ProductColumnInfo validateTable(ImplicitTransaction transaction) {
        if(!transaction.hasTable("class_Product")) {
            throw new RealmMigrationNeededException(transaction.getPath(), "The Product class is missing from the schema for this Realm.");
        } else {
            Table table = transaction.getTable("class_Product");
            if(table.getColumnCount() != 6L) {
                throw new RealmMigrationNeededException(transaction.getPath(), "Field count does not match - expected 6 but was " + table.getColumnCount());
            } else {
                HashMap columnTypes = new HashMap();

                for(long columnInfo = 0L; columnInfo < 6L; ++columnInfo) {
                    columnTypes.put(table.getColumnName(columnInfo), table.getColumnType(columnInfo));
                }

                ProductRealmProxy.ProductColumnInfo var5 = new ProductRealmProxy.ProductColumnInfo(transaction.getPath(), table);
                if(!columnTypes.containsKey("productId")) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Missing field \'productId\' in existing Realm file. Either remove field or migrate using io.realm.internal.Table.addColumn().");
                } else if(columnTypes.get("productId") != RealmFieldType.INTEGER) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Invalid type \'long\' for field \'productId\' in existing Realm file.");
                } else if(table.isColumnNullable(var5.productIdIndex) && table.findFirstNull(var5.productIdIndex) != -1L) {
                    throw new IllegalStateException("Cannot migrate an object with null value in field \'productId\'. Either maintain the same type for primary key field \'productId\', or remove the object with null value before migration.");
                } else if(table.getPrimaryKey() != table.getColumnIndex("productId")) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Primary key not defined for field \'productId\' in existing Realm file. Add @PrimaryKey.");
                } else if(!table.hasSearchIndex(table.getColumnIndex("productId"))) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Index not defined for field \'productId\' in existing Realm file. Either set @Index or migrate using io.realm.internal.Table.removeSearchIndex().");
                } else if(!columnTypes.containsKey("title")) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Missing field \'title\' in existing Realm file. Either remove field or migrate using io.realm.internal.Table.addColumn().");
                } else if(columnTypes.get("title") != RealmFieldType.STRING) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Invalid type \'String\' for field \'title\' in existing Realm file.");
                } else if(!table.isColumnNullable(var5.titleIndex)) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Field \'title\' is required. Either set @Required to field \'title\' or migrate using RealmObjectSchema.setNullable().");
                } else if(!columnTypes.containsKey("price")) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Missing field \'price\' in existing Realm file. Either remove field or migrate using io.realm.internal.Table.addColumn().");
                } else if(columnTypes.get("price") != RealmFieldType.DOUBLE) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Invalid type \'double\' for field \'price\' in existing Realm file.");
                } else if(table.isColumnNullable(var5.priceIndex)) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Field \'price\' does support null values in the existing Realm file. Use corresponding boxed type for field \'price\' or migrate using RealmObjectSchema.setNullable().");
                } else if(!columnTypes.containsKey("image")) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Missing field \'image\' in existing Realm file. Either remove field or migrate using io.realm.internal.Table.addColumn().");
                } else if(columnTypes.get("image") != RealmFieldType.STRING) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Invalid type \'String\' for field \'image\' in existing Realm file.");
                } else if(!table.isColumnNullable(var5.imageIndex)) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Field \'image\' is required. Either set @Required to field \'image\' or migrate using RealmObjectSchema.setNullable().");
                } else if(!columnTypes.containsKey("vshopId")) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Missing field \'vshopId\' in existing Realm file. Either remove field or migrate using io.realm.internal.Table.addColumn().");
                } else if(columnTypes.get("vshopId") != RealmFieldType.INTEGER) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Invalid type \'long\' for field \'vshopId\' in existing Realm file.");
                } else if(table.isColumnNullable(var5.vshopIdIndex)) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Field \'vshopId\' does support null values in the existing Realm file. Use corresponding boxed type for field \'vshopId\' or migrate using RealmObjectSchema.setNullable().");
                } else if(!columnTypes.containsKey("collect")) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Missing field \'collect\' in existing Realm file. Either remove field or migrate using io.realm.internal.Table.addColumn().");
                } else if(columnTypes.get("collect") != RealmFieldType.BOOLEAN) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Invalid type \'boolean\' for field \'collect\' in existing Realm file.");
                } else if(table.isColumnNullable(var5.collectIndex)) {
                    throw new RealmMigrationNeededException(transaction.getPath(), "Field \'collect\' does support null values in the existing Realm file. Use corresponding boxed type for field \'collect\' or migrate using RealmObjectSchema.setNullable().");
                } else {
                    return var5;
                }
            }
        }
    }

    public static String getTableName() {
        return "class_Product";
    }

    public static List<String> getFieldNames() {
        return FIELD_NAMES;
    }

    public static Product createOrUpdateUsingJsonObject(Realm realm, JSONObject json, boolean update) throws JSONException {
        ProductRealmProxy obj = null;
        if(update) {
            Table table = realm.getTable(Product.class);
            long pkColumnIndex = table.getPrimaryKey();
            long rowIndex = -1L;
            if(!json.isNull("productId")) {
                rowIndex = table.findFirstLong(pkColumnIndex, json.getLong("productId"));
            }

            if(rowIndex != -1L) {
                obj = new ProductRealmProxy(realm.schema.getColumnInfo(Product.class));
                ((RealmObjectProxy)obj).realmGet$proxyState().setRealm$realm(realm);
                ((RealmObjectProxy)obj).realmGet$proxyState().setRow$realm(table.getUncheckedRow(rowIndex));
            }
        }

        if(obj == null) {
            if(json.has("productId")) {
                if(json.isNull("productId")) {
                    obj = (ProductRealmProxy)realm.createObject(Product.class, (Object)null);
                } else {
                    obj = (ProductRealmProxy)realm.createObject(Product.class, Long.valueOf(json.getLong("productId")));
                }
            } else {
                obj = (ProductRealmProxy)realm.createObject(Product.class);
            }
        }

        if(json.has("productId")) {
            if(json.isNull("productId")) {
                throw new IllegalArgumentException("Trying to set non-nullable field productId to null.");
            }

            ((ProductRealmProxyInterface)obj).realmSet$productId(json.getLong("productId"));
        }

        if(json.has("title")) {
            if(json.isNull("title")) {
                ((ProductRealmProxyInterface)obj).realmSet$title((String)null);
            } else {
                ((ProductRealmProxyInterface)obj).realmSet$title(json.getString("title"));
            }
        }

        if(json.has("price")) {
            if(json.isNull("price")) {
                throw new IllegalArgumentException("Trying to set non-nullable field price to null.");
            }

            ((ProductRealmProxyInterface)obj).realmSet$price(json.getDouble("price"));
        }

        if(json.has("image")) {
            if(json.isNull("image")) {
                ((ProductRealmProxyInterface)obj).realmSet$image((String)null);
            } else {
                ((ProductRealmProxyInterface)obj).realmSet$image(json.getString("image"));
            }
        }

        if(json.has("vshopId")) {
            if(json.isNull("vshopId")) {
                throw new IllegalArgumentException("Trying to set non-nullable field vshopId to null.");
            }

            ((ProductRealmProxyInterface)obj).realmSet$vshopId(json.getLong("vshopId"));
        }

        if(json.has("collect")) {
            if(json.isNull("collect")) {
                throw new IllegalArgumentException("Trying to set non-nullable field collect to null.");
            }

            ((ProductRealmProxyInterface)obj).realmSet$collect(json.getBoolean("collect"));
        }

        return obj;
    }

    public static Product createUsingJsonStream(Realm realm, JsonReader reader) throws IOException {
        Product obj = (Product)realm.createObject(Product.class);
        reader.beginObject();

        while(reader.hasNext()) {
            String name = reader.nextName();
            if(name.equals("productId")) {
                if(reader.peek() == JsonToken.NULL) {
                    reader.skipValue();
                    throw new IllegalArgumentException("Trying to set non-nullable field productId to null.");
                }

                ((ProductRealmProxyInterface)obj).realmSet$productId(reader.nextLong());
            } else if(name.equals("title")) {
                if(reader.peek() == JsonToken.NULL) {
                    reader.skipValue();
                    ((ProductRealmProxyInterface)obj).realmSet$title((String)null);
                } else {
                    ((ProductRealmProxyInterface)obj).realmSet$title(reader.nextString());
                }
            } else if(name.equals("price")) {
                if(reader.peek() == JsonToken.NULL) {
                    reader.skipValue();
                    throw new IllegalArgumentException("Trying to set non-nullable field price to null.");
                }

                ((ProductRealmProxyInterface)obj).realmSet$price(reader.nextDouble());
            } else if(name.equals("image")) {
                if(reader.peek() == JsonToken.NULL) {
                    reader.skipValue();
                    ((ProductRealmProxyInterface)obj).realmSet$image((String)null);
                } else {
                    ((ProductRealmProxyInterface)obj).realmSet$image(reader.nextString());
                }
            } else if(name.equals("vshopId")) {
                if(reader.peek() == JsonToken.NULL) {
                    reader.skipValue();
                    throw new IllegalArgumentException("Trying to set non-nullable field vshopId to null.");
                }

                ((ProductRealmProxyInterface)obj).realmSet$vshopId(reader.nextLong());
            } else if(name.equals("collect")) {
                if(reader.peek() == JsonToken.NULL) {
                    reader.skipValue();
                    throw new IllegalArgumentException("Trying to set non-nullable field collect to null.");
                }

                ((ProductRealmProxyInterface)obj).realmSet$collect(reader.nextBoolean());
            } else {
                reader.skipValue();
            }
        }

        reader.endObject();
        return obj;
    }

    public static Product copyOrUpdate(Realm realm, Product object, boolean update, Map<RealmModel, RealmObjectProxy> cache) {
        if(object instanceof RealmObjectProxy && ((RealmObjectProxy)object).realmGet$proxyState().getRealm$realm() != null && ((RealmObjectProxy)object).realmGet$proxyState().getRealm$realm().threadId != realm.threadId) {
            throw new IllegalArgumentException("Objects which belong to Realm instances in other threads cannot be copied into this Realm instance.");
        } else if(object instanceof RealmObjectProxy && ((RealmObjectProxy)object).realmGet$proxyState().getRealm$realm() != null && ((RealmObjectProxy)object).realmGet$proxyState().getRealm$realm().getPath().equals(realm.getPath())) {
            return object;
        } else {
            ProductRealmProxy realmObject = null;
            boolean canUpdate = update;
            if(update) {
                Table table = realm.getTable(Product.class);
                long pkColumnIndex = table.getPrimaryKey();
                long rowIndex = table.findFirstLong(pkColumnIndex, ((ProductRealmProxyInterface)object).realmGet$productId());
                if(rowIndex != -1L) {
                    realmObject = new ProductRealmProxy(realm.schema.getColumnInfo(Product.class));
                    ((RealmObjectProxy)realmObject).realmGet$proxyState().setRealm$realm(realm);
                    ((RealmObjectProxy)realmObject).realmGet$proxyState().setRow$realm(table.getUncheckedRow(rowIndex));
                    cache.put(object, (RealmObjectProxy)realmObject);
                } else {
                    canUpdate = false;
                }
            }

            return canUpdate?update(realm, realmObject, object, cache):copy(realm, object, update, cache);
        }
    }

    public static Product copy(Realm realm, Product newObject, boolean update, Map<RealmModel, RealmObjectProxy> cache) {
        Product realmObject = (Product)realm.createObject(Product.class, Long.valueOf(((ProductRealmProxyInterface)newObject).realmGet$productId()));
        cache.put(newObject, (RealmObjectProxy)realmObject);
        ((ProductRealmProxyInterface)realmObject).realmSet$productId(((ProductRealmProxyInterface)newObject).realmGet$productId());
        ((ProductRealmProxyInterface)realmObject).realmSet$title(((ProductRealmProxyInterface)newObject).realmGet$title());
        ((ProductRealmProxyInterface)realmObject).realmSet$price(((ProductRealmProxyInterface)newObject).realmGet$price());
        ((ProductRealmProxyInterface)realmObject).realmSet$image(((ProductRealmProxyInterface)newObject).realmGet$image());
        ((ProductRealmProxyInterface)realmObject).realmSet$vshopId(((ProductRealmProxyInterface)newObject).realmGet$vshopId());
        ((ProductRealmProxyInterface)realmObject).realmSet$collect(((ProductRealmProxyInterface)newObject).realmGet$collect());
        return realmObject;
    }

    public static Product createDetachedCopy(Product realmObject, int currentDepth, int maxDepth, Map<RealmModel, CacheData<RealmModel>> cache) {
        if(currentDepth <= maxDepth && realmObject != null) {
            CacheData cachedObject = (CacheData)cache.get(realmObject);
            Product unmanagedObject;
            if(cachedObject != null) {
                if(currentDepth >= cachedObject.minDepth) {
                    return (Product)cachedObject.object;
                }

                unmanagedObject = (Product)cachedObject.object;
                cachedObject.minDepth = currentDepth;
            } else {
                unmanagedObject = new Product();
                cache.put(realmObject, new CacheData(currentDepth, unmanagedObject));
            }

            ((ProductRealmProxyInterface)unmanagedObject).realmSet$productId(((ProductRealmProxyInterface)realmObject).realmGet$productId());
            ((ProductRealmProxyInterface)unmanagedObject).realmSet$title(((ProductRealmProxyInterface)realmObject).realmGet$title());
            ((ProductRealmProxyInterface)unmanagedObject).realmSet$price(((ProductRealmProxyInterface)realmObject).realmGet$price());
            ((ProductRealmProxyInterface)unmanagedObject).realmSet$image(((ProductRealmProxyInterface)realmObject).realmGet$image());
            ((ProductRealmProxyInterface)unmanagedObject).realmSet$vshopId(((ProductRealmProxyInterface)realmObject).realmGet$vshopId());
            ((ProductRealmProxyInterface)unmanagedObject).realmSet$collect(((ProductRealmProxyInterface)realmObject).realmGet$collect());
            return unmanagedObject;
        } else {
            return null;
        }
    }

    static Product update(Realm realm, Product realmObject, Product newObject, Map<RealmModel, RealmObjectProxy> cache) {
        ((ProductRealmProxyInterface)realmObject).realmSet$title(((ProductRealmProxyInterface)newObject).realmGet$title());
        ((ProductRealmProxyInterface)realmObject).realmSet$price(((ProductRealmProxyInterface)newObject).realmGet$price());
        ((ProductRealmProxyInterface)realmObject).realmSet$image(((ProductRealmProxyInterface)newObject).realmGet$image());
        ((ProductRealmProxyInterface)realmObject).realmSet$vshopId(((ProductRealmProxyInterface)newObject).realmGet$vshopId());
        ((ProductRealmProxyInterface)realmObject).realmSet$collect(((ProductRealmProxyInterface)newObject).realmGet$collect());
        return realmObject;
    }

    public ProxyState realmGet$proxyState() {
        return this.proxyState;
    }

    public int hashCode() {
        String realmName = this.proxyState.getRealm$realm().getPath();
        String tableName = this.proxyState.getRow$realm().getTable().getName();
        long rowIndex = this.proxyState.getRow$realm().getIndex();
        byte result = 17;
        int result1 = 31 * result + (realmName != null?realmName.hashCode():0);
        result1 = 31 * result1 + (tableName != null?tableName.hashCode():0);
        result1 = 31 * result1 + (int)(rowIndex ^ rowIndex >>> 32);
        return result1;
    }

    public boolean equals(Object o) {
        if(this == o) {
            return true;
        } else if(o != null && this.getClass() == o.getClass()) {
            ProductRealmProxy aProduct = (ProductRealmProxy)o;
            String path = this.proxyState.getRealm$realm().getPath();
            String otherPath = aProduct.proxyState.getRealm$realm().getPath();
            if(path != null) {
                if(!path.equals(otherPath)) {
                    return false;
                }
            } else if(otherPath != null) {
                return false;
            }

            label30: {
                String tableName = this.proxyState.getRow$realm().getTable().getName();
                String otherTableName = aProduct.proxyState.getRow$realm().getTable().getName();
                if(tableName != null) {
                    if(tableName.equals(otherTableName)) {
                        break label30;
                    }
                } else if(otherTableName == null) {
                    break label30;
                }

                return false;
            }

            if(this.proxyState.getRow$realm().getIndex() != aProduct.proxyState.getRow$realm().getIndex()) {
                return false;
            } else {
                return true;
            }
        } else {
            return false;
        }
    }

    static {
        ArrayList fieldNames = new ArrayList();
        fieldNames.add("productId");
        fieldNames.add("title");
        fieldNames.add("price");
        fieldNames.add("image");
        fieldNames.add("vshopId");
        fieldNames.add("collect");
        FIELD_NAMES = Collections.unmodifiableList(fieldNames);
    }

    static final class ProductColumnInfo extends ColumnInfo {
        public final long productIdIndex;
        public final long titleIndex;
        public final long priceIndex;
        public final long imageIndex;
        public final long vshopIdIndex;
        public final long collectIndex;

        ProductColumnInfo(String path, Table table) {
            HashMap indicesMap = new HashMap(6);
            this.productIdIndex = this.getValidColumnIndex(path, table, "Product", "productId");
            indicesMap.put("productId", Long.valueOf(this.productIdIndex));
            this.titleIndex = this.getValidColumnIndex(path, table, "Product", "title");
            indicesMap.put("title", Long.valueOf(this.titleIndex));
            this.priceIndex = this.getValidColumnIndex(path, table, "Product", "price");
            indicesMap.put("price", Long.valueOf(this.priceIndex));
            this.imageIndex = this.getValidColumnIndex(path, table, "Product", "image");
            indicesMap.put("image", Long.valueOf(this.imageIndex));
            this.vshopIdIndex = this.getValidColumnIndex(path, table, "Product", "vshopId");
            indicesMap.put("vshopId", Long.valueOf(this.vshopIdIndex));
            this.collectIndex = this.getValidColumnIndex(path, table, "Product", "collect");
            indicesMap.put("collect", Long.valueOf(this.collectIndex));
            this.setIndicesMap(indicesMap);
        }
    }
}
realmGet$xxx() 和 realmSet$xxx()是和realm数据库打交道的。

在从 Realm 实例中获取任何 Realm 对象的时候（比如调用 Realm.createObject() 或者 RealmQuery.findFirst()），你实际上是获取了这个对象相应的 Realm 代理对象。对其属性的访问实际上都是通过相应生成的方法来访问底层的 Realm 数据库来实现的。

在查询返回Realm 对象的时候，这些对象的属性并没有被拷贝到 Java 堆中，这使得 Realm 的查询非常得快。这些属性只在需要被访问的时候，才经由生成的 getter 方法加载。

realm 通过引用计数控制的，所以要及时关闭。

https://realm.io/docs/上介绍够全，如果遇到问题，就去stackoverflow提问吧。






wangwwish
关注
Realm 你所不知知道的用法
豌豆的专栏
06-18 938
Realm 是一种可以跨平台 的数据库,速度也很快,至于普通的增删改查今天我就不多讲了.讲点大家可能不知道的 1.数据库变动监听 这是什么gui,通俗讲就是对这个数据库表进行监听,当数据发生变化时监听器就会触发,和rxjava 契合,事实上用到了rxjava 可以对增删改查的任意状态进行监听,这个在开发中很有用,数据驱动页面. 我们先来看一组查询时的监听 realm.where(PhonePhotoRealm.class) .sor...
android 数据库模糊查询语句_Realm是否支持Android上的模糊查询
weixin_33700875的博客
12-31 508
我的团队决定使用领域作为数据库,但我有一个问题要问,Realm是否支持模糊查询,如SQLite使用关键字’like’或’％’.有时我们需要使用模糊查询解决方法:public RealmQuery like(String fieldName,String value,Case casing)Condition that the value of field matches with the spec...
详细验证身份证号码规则和姓名（汉字）的java代码
siyecao1991的专栏
11-18 1万+
一、验证汉字的正则表达式 https://code.csdn.net/snippets/523931.js">> 二、验证身份证号码本以为简单写个正则表达式就OK了，  /** 匹配身份证号位数的正则 */    String regxId = "([0-9]{17}([0-9]|X))|([0-9]{15})"; 原来还有更精确的规则匹配如下，网上学习的，备份使用了。 尊重别人劳动成
Realm入门
了凡
04-28 1085
官网，在官网上查看文档教程。为查看数据可安装Realm Browser内容来自raywenderlichRealm入门这里使用的是Realm并不是最新的版本，Cocoapod如下：platform :ios, ‘9.0’ use_frameworks!target 'Todoify' do pod 'RealmSwift', '~> 0.98' end 通过简单的继承 Object 或者一个已经
Realm（Java）数据库使用文档（查询Queries）
GeofferySun的专栏
03-27 1280
文章目录8.1 筛选8.2 逻辑运算符8.3 排序8.4 结果限制8.5 唯一值8.6 链式查询（Chaining queries）8.7 关联查询（Link queries）8.8 自动更新结果8.9 聚合8.10 迭代和快照8.11 删除8.12 异步查询 Realm（Java）数据库使用文档（目录） All fetches (including queries) are lazy in R...
Realm Building Modern Swift Apps with Realm Database
05-15
11. ** 错误处理与调试**：学习 Realm 的错误处理机制，以及如何调试和解决 Realm 相关的问题。 12. **最佳实践**：获取关于 Realm 使用的最佳实践，包括性能优化、内存管理和测试策略。 13. ** Realm 在实际项目...
Android Realm数据库逻辑封装
08-25
`RealmDemo-master` 文件可能包含了一个示例项目，你可以通过查看其代码来进一步学习如何在实际项目中应用 Realm 数据库封装。 总之，对 Realm 进行逻辑封装，能够使 Android 应用程序的数据库操作更加整洁、高效，...
MacOS Realm
03-16
通过查看和学习这个示例，你可以更好地理解如何在实际项目中运用 Realm。 总结来说， Realm 在 MacOS 开发中提供了强大而灵活的数据管理方案，简化了数据存储和检索的过程，同时带来了出色的性能。掌握 Realm 的...
realm-oc-master-object-c reaml数据库学习
最新发布
06-28
学习 Objective-C 需要掌握一些基本概念和技术，以下是一些建议：首先，需要了解 Objective-C 的基本语法和数据类型，包括变量、数据类型、运算符、控制结构、函数等。可以通过阅读 Apple 官方文档或其他相关书籍来...
Realm_Building_Modern_Swift_Apps_with_Realm_Database_v1.0
03-30
通过阅读本书，开发者不仅能够学习到如何将Realm集成到Swift项目中，还能了解到最佳实践和高级技巧。 #### 三、核心知识点详解 ##### 3.1 Realm简介 - **概念**：Realm是一款轻量级的移动数据库，它支持跨平台，...
Realm的model终于可以不继承RealmObject了
大熊的Android开发之旅
05-03 5681
旧的实现方式只能是继承RealmObject这个抽象类，对于一些第三方的类库，如果同样需要继承某些基类，很可能会有冲突：public class User extends RealmObject { ... }因此从0.89.0版本开始，可以直接实现一个RealmModel接口，并在类声明前面加上@RealmClass注解声明即可：@RealmClass public class User
第七章 代理模式 （Proxy）
JackAtJN的博客
04-10 317
代理模式的定义与特点 代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。 代理模式的主要优点有： 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用； 代理对象可以扩展目标对象的功能； 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度； 其主要缺点 ...
shiro中自定义多realm，并指定realm实现验证
qq_37941840的博客
06-13 2839
我们平常的系统建设中大多数都涉及到两种及以上的登陆方式，例如：手机号码登陆、用户名及密码登陆等，而此时我们是不是就得需要两个realm才能实现？
shiro实现不同身份使用不同Realm进行验证
热门推荐
Alan_Xiang的博客
02-01 3万+
假设现在有这样一种需求：存在两张表user和admin，分别记录普通用户和管理员的信息。并且现在要实现普通用户和管理员的分开登录，即需要两个Realm——UserRealm和AdminRealm，分别处理普通用户和管理员的验证功能。 　　但是正常情况下，当定义了两个Realm，无论是普通用户登录，还是管理员登录，都会由这两个Realm共同处理。这是因为，当配置了多个Realm时，我们通常使用的认证
Realm使用的相关问题 Changing Realm data can only be done from inside a transaction.
qwe1314225的博客
08-06 927
保存一个对象的时候报错 java.lang.IllegalStateException: Changing Realm data can only be done from inside a transaction.   代码： public static LocalData getLocalData(String id){ Realm realm = Realm...
Shiro学习笔记（二）：自定义Realm的实现
weixin_47382783的博客
12-06 644
上一篇文章中提到了Realm，它相当于datasource数据源，SecurityManager进行安全验证时需要通过Realm获取用户权限数据，比如：如果用户身份数据在数据库，那么Realm就需要从数据库中获取用户身份信息。因此，在本文中我们将通过跟踪源码的形式来看一下Shiro中的认证和授权是如何完成的。 1、 源码跟踪 以上一篇文章的代码为例，在subject.login()进行断点调试，整体过程如下： （1）进入DelegatingSubject的login()方法。 ...
解决 Realm Only valid managed objects can be copied from Realm.
Alex老夫子的专栏
05-04 2410
最近项目用到了ORM数据库Realm，功能强大，也非常方便，同时也带来了很多奇葩的问题比如这个异常，找了半天也没有解决方案，经过千辛万苦终于找到了，这里做个记录，防止以后再次入坑先看代码 public RealmChatMessage getChatMessageSynchronous(String messageId) { RealmChatMessage realmCha...
Realm数据库使用教程（三）：查询数据
黄孝果的博客
12-20 1万+
Realm数据库使用教程（二）：增加数据查询数据 同步操作：findAll查询 /** * 注意：RealmResults虽然实现了List接口，不过有很多方法是不能用的。 * 比如add、addAll、remove、clear等， * 调用后会直接抛异常。 *
Realm 升级数据库，为表添加新的Field遇到的异常记录
weixin_33775582的博客
09-28 706
在使用Realm数据库管理的时候，需要对一个表添加field。当时是想的是设置默认值就出错了。错误代码如下 if (!schema.hasField("cultureSwitch")) { schema.addField("cultureSwitch", Boolean.class).setNullable("cultureSwitch", true); }...
深入解析Realm数据库应用实例
一个完整的Realm应用例子不仅涵盖了这些知识点，还应包含实际的代码示例和最佳实践，这对于学习和掌握Realm数据库具有极大的帮助。在开发过程中，我们应当通过实际的应用例子来深入理解Realm的使用细节，以便在实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值