从"0.86.0"升级Realm.到"2.1.0&" [英] Upgrading Realm from "0.86.0" to "2.1.0"
本文介绍了从"0.86.0"升级Realm.到"2.1.0&"的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我在我的简单应用程序中使用了Realm，
I've use Realm in My Simple Application,
我的Realm先前版本是 0.86.0 ，我打算将其升级到最新版本 2.1.0
My Previous Version of Realm was 0.86.0 , to I'm planning to Upgrade it to latest version which is 2.1.0
我正在创建RealmProxy来处理像这样的领域的所有操作
I was Creating RealmProxy To Dealing with all operations of realm Like This
package devs.lo.fff.utils;
import android.content.Context;
import java.io.Closeable;
import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import io.realm.Realm;
import io.realm.RealmConfiguration;
import io.realm.RealmObject;
import io.realm.RealmQuery;
import io.realm.RealmResults;
import io.realm.exceptions.RealmException;
public class RealmProxy implements Closeable {
private Realm realm;
private WeakReference<Context> contextWeakReference;
private static ThreadLocal<Set<RealmProxy>> realmsCache = new ThreadLocal<Set<RealmProxy>>() {
@Override
protected Set<RealmProxy> initialValue() {
return new HashSet<>();
}
};
private static final Object mLock = new Object();
public RealmProxy(Context context) {
contextWeakReference = new WeakReference<>(context);
}
public <T extends RealmObject> RealmQuery<T> where(Class<T> clazz) {
checkRealm();
if (!isValid()) {
return null;
}
return realm.where(clazz);
}
public <T extends RealmObject> RealmResults<T> allObjects(Class<T> clazz) {
checkRealm();
if (!isValid()) {
return null;
}
return realm.where(clazz).findAll();
}
public <T extends RealmObject> T createObject(Class<T> clazz) {
if (!isValid()) {
return null;
}
return realm.createObject(clazz);
}
public <T extends RealmObject> T copyToRealm(T object) {
if (!isValid()) {
return null;
}
return realm.copyToRealm(object);
}
public <T extends RealmObject> T copyToRealmOrUpdate(T object) {
if (!isValid()) {
return null;
}
return realm.copyToRealmOrUpdate(object);
}
public <E extends RealmObject> List<E> copyToRealm(Iterable<E> objects) {
if (!isValid()) {
return null;
}
return realm.copyToRealm(objects);
}
public <E extends RealmObject> List<E> copyToRealmOrUpdate(Iterable<E> objects) {
if (!isValid()) {
return null;
}
return realm.copyToRealmOrUpdate(objects);
}
public <E extends RealmObject> void save(final E object) {
executeTransaction(new Transaction() {
@Override
public void execute(RealmProxy realm) {
copyToRealmOrUpdate(object);
}
});
}
public <E extends RealmObject> void save(final Iterable<E> objects) {
executeTransaction(new Transaction() {
@Override
public void execute(RealmProxy realm) {
copyToRealmOrUpdate(objects);
}
});
}
//region experimental
public <T extends RealmObject> RealmProxy set(T object, String fieldName, Object value) {
Method method = findMethod(object, fieldName, value.getClass());
invokeMethod(method, object, value);
return this;
}
public <T extends RealmObject> RealmProxy set(T object, String fieldName, boolean value) {
Method method = findMethod(object, fieldName, boolean.class);
invokeMethod(method, object, value);
return this;
}
public <T extends RealmObject> RealmProxy set(T object, String fieldName, long value) {
Method method = findMethod(object, fieldName, long.class);
invokeMethod(method, object, value);
return this;
}
public <T extends RealmObject> RealmProxy set(T object, String fieldName, float value) {
Method method = findMethod(object, fieldName, float.class);
invokeMethod(method, object, value);
return this;
}
public <T extends RealmObject> RealmProxy set(List<T> objects, String fieldName, Object value) {
if (objects.isEmpty()) {
return this;
}
Method method = findMethod(objects, fieldName, value.getClass());
invokeMethod(method, objects, value);
return this;
}
public <T extends RealmObject> RealmProxy set(List<T> objects, String fieldName, boolean value) {
if (objects.isEmpty()) {
return this;
}
Method method = findMethod(objects, fieldName, boolean.class);
invokeMethod(method, objects, value);
return this;
}
public <T extends RealmObject> RealmProxy set(List<T> objects, String fieldName, long value) {
Method method = findMethod(objects, fieldName, long.class);
invokeMethod(method, objects, value);
return this;
}
public <T extends RealmObject> RealmProxy set(List<T> objects, String fieldName, float value) {
Method method = findMethod(objects, fieldName, float.class);
invokeMethod(method, objects, value);
return this;
}
private <T extends RealmObject> void invokeMethod(Method method, T object, Object value) {
synchronized (mLock) {
internalBeginTransaction(false);
try {
method.invoke(object, value);
internalCommitTransaction();
} catch (IllegalAccessException e) {
e.printStackTrace();
internalCancelTransaction();
} catch (InvocationTargetException e) {
e.printStackTrace();
internalCancelTransaction();
}
}
}
private <T extends RealmObject> void invokeMethod(Method method, List<T> objects, Object value) {
synchronized (mLock) {
internalBeginTransaction(false);
try {
for (int i = 0; i < objects.size(); i++) {
method.invoke(objects.get(i), value);
}
internalCommitTransaction();
} catch (IllegalAccessException e) {
e.printStackTrace();
internalCancelTransaction();
} catch (InvocationTargetException e) {
e.printStackTrace();
internalCancelTransaction();
}
}
}
private synchronized Method findMethod(Object obj,
String property, Class paramType) {
Class<?> theClass = obj.getClass();
String setter = String.format("set%C%s",
property.charAt(0), property.substring(1));
//Class paramType = value.getClass();
try {
return theClass.getMethod(setter, paramType);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
}
private synchronized Method findMethod(List objects,
String property, Class paramType) {
return findMethod(objects.get(0), property, paramType);
}
//endregion
public <T extends RealmObject> void removeFromRealm(T object) {
checkRealm();
synchronized (mLock) {
internalBeginTransaction(false);
try {
if (object.isValid()) {
object.deleteFromRealm();
internalCommitTransaction();
}
} catch (RuntimeException e) {
internalCancelTransaction();
throw new RealmException("Error during transaction.", e);
} catch (Error e) {
internalCancelTransaction();
throw e;
}
}
}
public void beginTransaction() {
beginTransaction(false);
}
public void beginTransaction(boolean commitCurrent) {
synchronized (mLock) {
internalBeginTransaction(commitCurrent);
}
}
private void internalBeginTransaction(boolean commitCurrent) {
checkRealm();
if (realm.isInTransaction() && commitCurrent) {
realm.commitTransaction();
realm.beginTransaction();
} else if (!realm.isInTransaction()) {
realm.beginTransaction();
}
}
public void commitTransaction() {
synchronized (mLock) {
internalCommitTransaction();
}
}
private void internalCommitTransaction() {
//checkRealm();
if (isValid() && realm.isInTransaction()) {
realm.commitTransaction();
}
}
public void cancelTransaction() {
synchronized (mLock) {
//checkRealm();
internalCancelTransaction();
}
}
private void internalCancelTransaction() {
//checkRealm();
if (isValid() && realm.isInTransaction()) {
realm.cancelTransaction();
}
}
public void clear(Class<? extends RealmObject> classSpec, boolean autoTransaction) {
if (autoTransaction) {
beginTransaction();
realm.delete(classSpec);
commitTransaction();
} else {
realm.delete(classSpec);
}
}
@Override
public void close() {
internalClose();
realmsCache.get().remove(this);
}
private void internalClose() {
if (realm != null) {
realm.close();
realm = null;
}
}
private void checkRealm() {
if (!isValid()) {
Context context = contextWeakReference.get();
if (context == null) {
throw new IllegalStateException("Context is null, Activity or Fragment is already killed");
}
RealmConfiguration config = new RealmConfiguration.Builder(context)
.name(Realm.DEFAULT_REALM_NAME)
.deleteRealmIfMigrationNeeded()
.build();
realm = Realm.getInstance(config);
realmsCache.get().add(this);
}
}
public boolean isValid() {
return !(realm == null || realm.isClosed());
}
public <T extends RealmObject> void executeTransaction(T object, AdvancedTransaction<T> transaction) {
checkRealm();
synchronized (mLock) {
internalBeginTransaction(false);
try {
if (object.isValid()) {
transaction.execute(object);
internalCommitTransaction();
}
} catch (RuntimeException e) {
internalCancelTransaction();
throw new RealmException("Error during transaction.", e);
} catch (Error e) {
internalCancelTransaction();
throw e;
}
}
}
public void executeTransaction(Transaction transaction) {
executeTransaction(transaction, false, false, null);
}
public void executeTransaction(Transaction transaction, boolean commitCurrent) {
executeTransaction(transaction, commitCurrent, false, null);
}
public void executeTransaction(Transaction transaction, boolean commitCurrent, boolean doInBackground) {
executeTransaction(transaction, commitCurrent, doInBackground, null);
}
public synchronized void executeTransaction(final Transaction transaction, boolean commitCurrent, boolean doInBackground, Realm.Transaction.Callback callbacks) {
if (transaction == null || !isValid()) {
return;
}
checkRealm();
if (doInBackground) {
realm.executeTransaction(new Realm.Transaction() {
@Override
public void execute(final Realm realm) {
transaction.execute(RealmProxy.this);
}
}, callbacks);
} else {
synchronized (mLock) {
internalBeginTransaction(commitCurrent);
try {
transaction.execute(this);
internalCommitTransaction();
} catch (RuntimeException e) {
internalCancelTransaction();
throw new RealmException("Error during transaction.", e);
} catch (Error e) {
internalCancelTransaction();
throw e;
}
}
}
}
public interface Transaction {
void execute(RealmProxy realm);
}
public interface AdvancedTransaction<T extends RealmObject> {
void execute(T object);
}
public void clearDataBase() {
Context context = contextWeakReference.get();
if (context == null) {
return;
}
RealmConfiguration config;
if (realm == null) {
config = new RealmConfiguration.Builder(context)
.name(Realm.DEFAULT_REALM_NAME)
.deleteRealmIfMigrationNeeded()
.build();
} else {
config = realm.getConfiguration();
}
/** all realm instances must be closed before deleting the file */
for (RealmProxy realmProxy : realmsCache.get()) {
realmProxy.internalClose();
}
/** clear threadLocal, its no longer needed*/
realmsCache.remove();
Realm.deleteRealm(config);
/*File appDir = context.getExternalFilesDir("Documents");
File[] files;
if (appDir != null) {
files = appDir.listFiles();
if (files != null && files.length != 0) {
for (File file : files) {
file.delete();
}
}
appDir.delete();
}*/
}
public static void clearDataBase(final Context context) {
RealmProxy realm = new RealmProxy(context);
realm.clearDataBase();
realm.close();
}
}
但是升级到2.1.0后，此文件出现了一些错误，我正在尝试解决它，但是似乎存在一些错误，我不知道如何解决它
but after upgrading to 2.1.0 this file got some errors i'm trying to solve it, but it seems there are some errors, i don't know how to solve it
请咨询
谢谢.
推荐答案
https://github.com/realm/realm-java/blob/master/CHANGELOG.md
2.0.0
2.0.0
重大更改
现在需要在调用任何其他Realm API之前先调用Realm.init(Context).
It is now required to call Realm.init(Context) before calling any other Realm API.
Removed RealmConfiguration.Builder(Context)，RealmConfiguration.Builder(Context, File)和RealmConfiguration.Builder(File)构造函数.
0.89.0
重大更改
RealmChangeListener也提供更改的对象/领域/集合(#1594).
RealmChangeListener provides the changed object/Realm/collection as well (#1594).
0.88.0
已弃用
Realm.executeTransaction(Transaction, Callback)，并替换为
-
Realm.executeTransactionAsync(Transaction)，
Realm.executeTransactionAsync(Transaction, OnSuccess)，
Realm.executeTransactionAsync(Transaction, OnError)
Realm.executeTransactionAsync(Transaction, OnSuccess, OnError).
这篇关于从"0.86.0"升级Realm.到"2.1.0&"的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
