Persistence Strategy for Standalone Desktop Java Application

Question

(Only managed to find one other question on this - Object persistence strategy for desktop application)

I have a basic Java Swing application - which needs to access / persist a few thousand POJOs. I may need to run basic queries on these.

Originally I looked at JPA-Hibernate + HSQLDB, but this slows app start-up time and I figured it was overkill for my query requirements.

I simplified my data model and started looking at Document DBs - mongodb is great but it isnt really suited for non-server environments; starting up and shutting down the mongod process from Java (using ProcessBuilder) is fiddly and I really want an embedded solution.

I really want a fast, lightweight persistence tool with basic query functions that can be embedded in a Java app.

Are these the only options?

http://prevayler.org/
Java Embedded Database (HSQL) without ORM
Java Serialization to filesystem
JSON persisted to flat files?
XStream (and XBird? - http://code.google.com/p/xbird/)
OODB
JCR Implementation ?

Can anyone offer any other advice / suggestions? At what point would serializing a large List of POJO's start to really hurt performance?

Thanks

edit: Just found this post - https://stackoverflow.com/questions/2825491/are-there-any-embeddable-document-database-engines-for-java-something-similar-t recommending Orient - http://code.google.com/p/orient/

Side note: I would generally recommend H2 over HSQLDB for this kind of problems. — Viruzzo, Mar 01 '12 at 13:16
i used H2 in a project a couple of years ago. gotta love it's simplicity and ease of setup. — jere, Mar 02 '12 at 12:45
I have started using OrientDB's document database and its a good fit so far. — Andrew B, Mar 02 '12 at 14:32

score 1 · Accepted Answer · answered Mar 01 '12 at 13:51

1

I recently used db4o (http://www.db4o.com/) as a data store for a standalone desktop application. Its an object data base which can be run in embedded mode w/o a server running in the background.

answered Mar 01 '12 at 13:51

Stefan

4,645
1
19
35

Thanks - I had a look at this but ideally want something more lightweight – Andrew B Mar 01 '12 at 22:23

score 1 · Answer 2 · answered Mar 02 '12 at 12:29

1

If you want lightweight, you definitely don't want JCR. The API is cumbersome, and the performance is generally poorer than the other options. JCR has some powerful features which outweigh these drawbacks if you need them, but it sounds like you don't.

answered Mar 02 '12 at 12:29

Tom Anderson

46,189
17
92
133

score 1 · Answer 3 · answered Mar 02 '12 at 12:42

First and foremost, i would suggest that you encapsulate your persistence operations in some sort of repository object, so if you change the implementation in future, you will have less work to do. If you can think in terms of documents, or some other way of grouping related objects ("customer file", "saved game", "development project"), then build an interface that looks like:

public interface DocumentRepository {
    public Document create();
    public Document load(String id);
    public void update(Document doc);
    public Set<Document> findByCustomerNameFreeTextSearch(String query);
}

That should be implementable on top of a variety of backends.

Secondly, i would initially implement this with plain old serialization. Something like:

public class SerializingDocumentRepository implements DocumentRepository {
    private final File persistenceDir;

    public Document create() {
        return new Document();
    }

    public Document load(String id) {
        ObjectInputStream in = new ObjectInputStream(persistenceDir, new File(id));
        try {
            return (Document)in.readObject();
        }
        finally {
            in.close();
        }
    }

    public void update(Document doc) {
        ObjectOutputStream out = new ObjectOutputStream(persistenceDir, new File(id)).writeObject(doc);
        try {
            out.writeObject(doc);
        }
        finally {
            in.close();
        }
    }

    public Set<Document> findByCustomerNameFreeTextSearch(String query) {
        Set<Document> hits = new HashSet<Document>();
        for (String filename: persistenceDir.list()) {
            Document doc = load(filename);
            if (doc.getCustomer().getName().contains(query)) hits.add(doc);
        }
        return hits;
    }
}

Only with exception handling.

That implementation should be very, very simple to write. It might not be terribly fast (for searching, at least), but it will be fast enough to let you write the rest of the application. Once you've written the rest of the application, you'll be able to generate enough data to be able to make a better choice about persistence.

Thanks for tip - I was originally using spring-data JPA and the generic DAO implementations they have were a big draw. — Andrew B, Mar 02 '12 at 14:30

Persistence Strategy for Standalone Desktop Java Application

3 Answers3