Java Dao类代码示例

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
public synchronized Dao getDao(Class clazz) throws SQLException
{
    Dao dao = null;
    String className = clazz.getSimpleName();

    if (daos.containsKey(className))
    {
        dao = daos.get(className);
    }
    if (dao == null)
    {
        dao = super.getDao(clazz);
        daos.put(className, dao);
    }
    return dao;
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
/**
 * Saves the user data to the database.
 *
 * @param data The user data to save.
 */
private static void save(UserData data) {
    data.setAvatarUrl(data.getAvatarUrl());
    data.setUsername(data.getUsername());

    ZLevels.async.submit(() -> {
        try {
            ConnectionSource source = Database.openConnection();
            if (source == null) return;

            Dao<UserData, String> db = DaoManager.createDao(source, UserData.class);
            db.createOrUpdate(data);
            Database.closeConnection();
        } catch (Exception e) {
            ZLogger.warn("Could not save UserData for " + data.getUserId() + "!");
            e.printStackTrace();
        }
    });
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
/**
 * Deletes this user data from the database and cache.
 */
public void delete() {
    UserData current = this;

    if (cache.containsKey(current.getUserId())) cache.remove(current.getUserId());

    ZLevels.async.submit(() -> {
        try {
            ConnectionSource source = Database.openConnection();
            if (source == null) return;

            Dao<UserData, String> db = DaoManager.createDao(source, UserData.class);

            db.delete(current);

            Database.closeConnection();
        } catch (Exception e) {
            ZLogger.warn("Colud not delete UserData for " + getUserId() + "!");
            e.printStackTrace();
        }
    });
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
/**
 * Gets the user data by userId from the cache and database.
 *
 * @param userId The user id.
 * @return The user data.
 */
public static UserData fromId(String userId) {
    if (cache.containsKey(userId)) {
        return cache.get(userId);
    }
    try {
        ConnectionSource source = Database.openConnection();
        if (source == null) return null;

        Dao<UserData, String> db = DaoManager.createDao(source, UserData.class);

        UserData data = db.queryForEq("userId", userId).get(0);

        Database.closeConnection();

        return data;
    } catch (Exception e) {
        if (e instanceof IndexOutOfBoundsException) {
            return null;
        }

        ZLogger.warn("Could not get UserData for " + userId + "!");
        e.printStackTrace();
        return null;
    }
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
@Nullable
public static BgReading lastBg() {
    List<BgReading> bgList = null;

    try {
        Dao<BgReading, Long> daoBgReadings = MainApp.getDbHelper().getDaoBgReadings();
        QueryBuilder<BgReading, Long> queryBuilder = daoBgReadings.queryBuilder();
        queryBuilder.orderBy("date", false);
        queryBuilder.limit(1L);
        queryBuilder.where().gt("value", 38);
        PreparedQuery<BgReading> preparedQuery = queryBuilder.prepare();
        bgList = daoBgReadings.query(preparedQuery);

    } catch (SQLException e) {
        log.debug(e.getMessage(), e);
    }
    if (bgList != null && bgList.size() > 0)
        return bgList.get(0);
    else
        return null;
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
protected boolean checkSuspectedApps(String packageName) {
    boolean matched = true;
    if (!_settings.isAdvancedMode()) {
        try {
            Dao<SuspectedApp, Integer> suspectedAppDao = DatabaseHelper.getHelper(_context.getApplicationContext()).getSuspectedAppDao();
            List<SuspectedApp> res = suspectedAppDao.queryForEq("packageName", packageName);
            if (res.size() == 0) {
                Log.i(TAG, String.format("Skipping %s since not in suspected app list and is probably a FP", packageName));
                matched = false;
            } else {
                Log.d(TAG, String.format("Process %s found in suspected apps", packageName));
                matched = true;
            }
        } catch (SQLException e) {
            Log.e(TAG, String.format("SQL exception: %s", e.getMessage()));
            matched = false;
        }
    }
    return matched;
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
/**
 * This method obtains a DAO given its Class
 * <p/>
 * Source: https://goo.gl/6LIYy2
 *
 * @param clazz
 *         The DAO class
 * @param <D>
 *         DAO super class
 * @param <T>
 *         Requested DAO class
 *
 * @return The DAO instance
 *
 * @throws SQLException
 */
public <D extends Dao<T, ?>, T> D getDao(Class<T> clazz) throws SQLException {
  // lookup the dao, possibly invoking the cached database config
  Dao<T, ?> dao = DaoManager.lookupDao(connectionSource, clazz);
  if (dao == null) {
    // try to use our new reflection magic
    DatabaseTableConfig<T> tableConfig = DatabaseTableConfigUtil
            .fromClass(connectionSource, clazz);
    if (tableConfig == null) {
      /**
       * Note: We have to do this to get to see if they are using the deprecated
       * annotations like
       * {@link DatabaseFieldSimple}.
       */
      dao = (Dao<T, ?>) DaoManager.createDao(connectionSource, clazz);
    } else {
      dao = (Dao<T, ?>) DaoManager.createDao(connectionSource, tableConfig);
    }
  }

  @SuppressWarnings("unchecked")
  D castDao = (D) dao;
  return castDao;
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
public List<TempTarget> getTemptargetsDataFromTime(long mills, boolean ascending) {
    try {
        Dao<TempTarget, Long> daoTempTargets = getDaoTempTargets();
        List<TempTarget> tempTargets;
        QueryBuilder<TempTarget, Long> queryBuilder = daoTempTargets.queryBuilder();
        queryBuilder.orderBy("date", ascending);
        Where where = queryBuilder.where();
        where.ge("date", mills);
        PreparedQuery<TempTarget> preparedQuery = queryBuilder.prepare();
        tempTargets = daoTempTargets.query(preparedQuery);
        return tempTargets;
    } catch (SQLException e) {
        log.error("Unhandled exception", e);
    }
    return new ArrayList<TempTarget>();
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
@Override
    public void onCreate() {
        super.onCreate();
//        This is here because onStart is not called when BIND_AUTO_CREATE is used
        mContext = this;
        localBroadcastManager = LocalBroadcastManager.getInstance(this);
        final OrmHandler ormHandler = OpenHelperManager.getHelper(this, OrmHandler.class);
        Dao<Track, String> dbTrack;
        try {
            dbTrack = ormHandler.getDao(Track.class);
            mTrackList = dbTrack.queryForAll();
            mBucketList = dbTrack.queryForEq("bucket", true);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
@Nullable
public Treatment findTreatmentById(String _id) {
    try {
        Dao<Treatment, Long> daoTreatments = getDaoTreatments();
        QueryBuilder<Treatment, Long> queryBuilder = daoTreatments.queryBuilder();
        Where where = queryBuilder.where();
        where.eq("_id", _id);
        queryBuilder.limit(10L);
        PreparedQuery<Treatment> preparedQuery = queryBuilder.prepare();
        List<Treatment> trList = daoTreatments.query(preparedQuery);
        if (trList.size() != 1) {
            //log.debug("Treatment findTreatmentById query size: " + trList.size());
            return null;
        } else {
            //log.debug("Treatment findTreatmentById found: " + trList.get(0).log());
            return trList.get(0);
        }
    } catch (SQLException e) {
        log.error("Unhandled exception", e);
    }
    return null;
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
/**
 * 获取dao
 *
 * @param cls 表结构bean
 * @return
 */
public synchronized Dao getDao(Class cls) {
    Dao dao;
    String clsName = cls.getSimpleName();
    if (daoMap.containsKey(clsName)) {
        dao = daoMap.get(clsName);
    } else {
        try {
            dao = super.getDao(cls);
        } catch (SQLException e) {
            LogUtils.e("database operate fail", e);
            return null;
        }
        daoMap.put(clsName, dao);
    }
    return dao;
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
@Override
protected Void doInBackground(Void... voids) {
    ArrayList<Track> mTrackList = Utils.musicLoader(mContext);
    OrmHandler ormHandler = OpenHelperManager.getHelper(mContext, OrmHandler.class);
    try {
        Dao<Track, String> dbTrack = ormHandler.getDao(Track.class);
        List<Track> _temp = dbTrack.queryForAll();
        _temp.removeAll(mTrackList);
        for (Track t :
                mTrackList) {
            dbTrack.createIfNotExists(t);
        }
        dbTrack.delete(_temp);
    } catch (SQLException e) {
        e.printStackTrace();
    }
    OpenHelperManager.releaseHelper();
    return null;
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
public static void bucketOps(String path, Boolean bucket, Context mContext) {
    final OrmHandler ormHandler = OpenHelperManager.getHelper(mContext, OrmHandler.class);
    try {
        Dao<Track, String> dbTrack = ormHandler.getDao(Track.class);
        QueryBuilder<Track, String> queryBuilder = dbTrack.queryBuilder();
        SelectArg selectArg = new SelectArg();
        queryBuilder.where().eq("path", selectArg);
        PreparedQuery<Track> preparedQuery = queryBuilder.prepare();
        selectArg.setValue(path);
        List<Track> lister = dbTrack.query(preparedQuery);
        Track temp_track = lister.get(0);
        temp_track.setBucket(bucket);
        dbTrack.update(temp_track);
        BUCKET_OPS = true;
    } catch (SQLException | IndexOutOfBoundsException e) {
        e.printStackTrace();
    }
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
/**
 * Creates appropriate adapter for the specified action.
 * @param removeActionDao   content removal action DAO
 * @param action            removal action
 * @return  {@linkplain RemoveContentActionSyncAdapter} instance.
 */
public static RemoveContentActionSyncAdapter createAdapter(
	Dao<UserActionCache.ContentRemovedAction, Integer> removeActionDao,
	UserActionCache.ContentRemovedAction action) {

	INetworkOperation operation;

	switch (action.getContentType()) {
		case COMMENT:
			operation = (service) -> service.removeComment(new RemoveCommentRequest(action.getContentHandle()));
			break;

		case REPLY:
			operation = (service) -> service.removeReply(new RemoveReplyRequest(action.getContentHandle()));
			break;

		case TOPIC:
		default:
			operation = (service) -> service.removeTopic(new RemoveTopicRequest(action.getContentHandle()));
	}

	return new RemoveContentActionSyncAdapter(removeActionDao, action, operation);
}
 

import com.j256.ormlite.dao.Dao; //导入依赖的package包/类
public <D extends Dao<T, ?>, T> D getCachedDao(Class<T> clazz) {
    Dao dao = daoCacheMap.get(clazz);
    if (dao == null) {
        try {
            dao = this.getDao(clazz);
        } catch (Exception e) {
            e.printStackTrace();
        }
        daoCacheMap.put(clazz, dao);
    }
    return (D) dao;
}