Question

I want to leverage on the new features of Objectify4 however my application is build and is working with version 3. My application largely builds upon the ObjectifyGenericDao pattern and that the Objectify4 design pattern is quite different from this:

ObjectifyGenericDao.java

public class ObjectifyGenericDao<T> extends DAOBase
{

    static final int BAD_MODIFIERS = Modifier.FINAL | Modifier.STATIC | Modifier.TRANSIENT;

    static
    {
        // Register all your entity classes here
    }

    protected Class<T> clazz;

    /**
     * We've got to get the associated domain class somehow
     *
     * @param clazz
     */
    protected ObjectifyGenericDao(Class<T> clazz)
    {
        this.clazz = clazz;
    }

    public ObjectifyGenericDao(ObjectifyOpts opts) {
        super(opts);
        //this.clazz = clazz;
    }

    public Key<T> put(T entity)
    {
        return ofy().put(entity);
    }

    // TODO This code was modified
    // and need to be tested
    public List<Key<T>> putAll(Iterable<T> entities)
    {
        Map<Key<T>, T> map = ofy().put(entities);
        return new ArrayList<Key<T>>(map.keySet());
        //return ofy().put(entities);
    }

    public void delete(T entity)
    {
        ofy().delete(entity);
    }

    public void deleteKey(Key<T> entityKey)
    {
        ofy().delete(entityKey);
    }

    public void deleteAll(Iterable<T> entities)
    {
        ofy().delete(entities);
    }

    public void deleteKeys(Iterable<Key<T>> keys)
    {
        ofy().delete(keys);
    }

    public T get(Long id) throws EntityNotFoundException
    {
        return ofy().get(this.clazz, id);
    }

    public T get(String id) throws EntityNotFoundException
    {
        return ofy().get(this.clazz, id);
    }

    public T get(Key<T> key) throws EntityNotFoundException
    {
        return ofy().get(key);
    }

    /**
     * Convenience method to get all objects matching a single property
     *
     * @param propName
     * @param propValue
     * @return T matching Object
     */
    public T getByProperty(String propName, Object propValue)
    {
        Query<T> q = ofy().query(clazz);
        q.filter(propName, propValue);
        return q.get();
    }

    public List<T> listByProperty(String propName, Object propValue)
    {
        Query<T> q = ofy().query(clazz);
        q.filter(propName, propValue);
        return asList(q.fetch());
    }

    public List<Key<T>> listKeysByProperty(String propName, Object propValue)
    {
        Query<T> q = ofy().query(clazz);
        q.filter(propName, propValue);
        return asKeyList(q.fetchKeys());
    }

    public T getByExample(T exampleObj)
    {
        Query<T> queryByExample = buildQueryByExample(exampleObj);
        Iterable<T> iterableResults = queryByExample.fetch();
        Iterator<T> i = iterableResults.iterator();
        T obj = i.next();
        if (i.hasNext())
            throw new RuntimeException("Too many results");
        return obj;
    }

    public List<T> listByExample(T exampleObj)
    {
        Query<T> queryByExample = buildQueryByExample(exampleObj);
        return asList(queryByExample.fetch());
    }

    private List<T> asList(Iterable<T> iterable)
    {
        ArrayList<T> list = new ArrayList<T>();
        for (T t : iterable)
        {
            list.add(t);
        }
        return list;
    }

    private List<Key<T>> asKeyList(Iterable<Key<T>> iterableKeys)
    {
        ArrayList<Key<T>> keys = new ArrayList<Key<T>>();
        for (Key<T> key : iterableKeys)
        {
            keys.add(key);
        }
        return keys;
    }

    private Query<T> buildQueryByExample(T exampleObj)
    {
        Query<T> q = ofy().query(clazz);

        // Add all non-null properties to query filter
        for (Field field : clazz.getDeclaredFields())
        {
            // Ignore transient, embedded, array, and collection properties
            if (field.isAnnotationPresent(Transient.class)
                || (field.isAnnotationPresent(Embedded.class))
                || (field.getType().isArray())
                || (Collection.class.isAssignableFrom(field.getType()))
                || ((field.getModifiers() & BAD_MODIFIERS) != 0))
                continue;

            field.setAccessible(true);

            Object value;
            try
            {
                value = field.get(exampleObj);
            }
            catch (IllegalArgumentException e)
            {
                throw new RuntimeException(e);
            }
            catch (IllegalAccessException e)
            {
                throw new RuntimeException(e);
            }
            if (value != null)
            {
                q.filter(field.getName(), value);
            }
        }

        return q;
    }

    // Added, but may not be really useful
    public Query<T> query(String filter, String value) {
        Query<T> q = ofy().query(clazz).filter(filter, value);
        return q;

}

The bottleneck with Objectify4 is that it does not have DAOBase so it not very easy to migrate existing codes.

How can I have this pattern while using Objectify4 features?

Answer 1

As mentioned on the Objectify Google Group, just drop the extends DAOBase.