Storing state in Java | 易学教程

问题

Broad discussion question. Are there any libraries already which allow me to store the state of execution of my application in Java?

E.g I have an application which processes files, now the application may be forced to shutdown suddenly at some point.I want to store the information on what all files have been processed and what all have not been, and what stage the processing was on for the ongoing processes.

Are there already any libraries which abstract this functionality or I would have to implement it from scratch?

回答1:

It seems like what you are looking for is serialization which can be performed with the Java Serialization API.

You can write even less code if you decide to use known libraries such as Apache Commons Lang, and its SerializationUtils class which itself is built on top the Java Serialization API.

Using the latest, serializing/deserializing your application state into a file is done in a few lines.

The only thing you have to do is create a class holding your application state, let's call it... ApplicationState :-) It can look like that:

class ApplicationState {

 enum ProcessState {
  READ_DONE,
  PROCESSING_STARTED,
  PROCESSING_ENDED,
  ANOTHER_STATE;
 }

 private List<String> filesDone, filesToDo;
 private String currentlyProcessingFile;
 private ProcessState currentProcessState;
}

With such a structure, and using SerializationUtils, serializing is done the following way:

try {
      ApplicationState state = new ApplicationState();
      ...
      // File to serialize object to
      String fileName = "applicationState.ser";

      // New file output stream for the file
      FileOutputStream fos = new FileOutputStream(fileName);

      // Serialize String
      SerializationUtils.serialize(state, fos);
      fos.close();

      // Open FileInputStream to the file
      FileInputStream fis = new FileInputStream(fileName);

      // Deserialize and cast into String
      String ser = (String) SerializationUtils.deserialize(fis);
      System.out.println(ser);
      fis.close();
    } catch (Exception e) {
      e.printStackTrace();
    }

回答2:

It sounds like the Java Preferences API might be a good option for you. This can store user/system settings with minimal effort on your part and you can update/retrieve at any time. http://docs.oracle.com/javase/1.4.2/docs/guide/lang/preferences.html

回答3:

It's pretty simple to make from scratch. You could follow this:

Have a DB (or just a file) that stores the information of processing progress. Something like:
```
 Id|fileName|status|metadata
```
As soon as you start processing a file make a entry to this table. Ans mark status as PROCESSING, the you can store intermediate states, and finally when you're done you can set status to DONE.

This way, on restart, you would know what are the files processed; what are the files that were in-citu when the process shutdown/crashed. And (obviously) where to start.

In large enterprise environment where applications are loosely coupled (and there is no guarantee if the application will be available or might crash), we use Message Queue to do something like the same to ensure reliable architecture.

回答4:

There are almost too many ways to mention. I would choice the option you believe is simplest.

You can use;

a file to record what is done (and what is to be done)
a persistent queue on JMS (which support multiple processes, even on different machine)
a embedded or remote database.

An approach I rave about is using memory mapped files. A nice feature is that information is not lost if the application dies or is killed (provided the OS doesn't crash) which means you don't have to flush it, nor worry about losing data if you don't.

This works because the data is partly managed by the OS which means it uses little heap (even for TB of data) and the OS deals with loading and flushing to disk making it much faster (and making sizes much larger than your main memory practical).

BTW: This approach works even with a kill -9 as the OS flushes the data to disk. To test this I use Unsafe.getByte(0) which crashes the application with a SEG fault immediately after making a change (as in the next machine code instruction) and it still writes the change to disk.

This won't work if you pull the power, but you have to be really quick. You can use memory mapped files to force the data to disk before continuing, but I don't know how you can test this really works. ;)

I have a library which could make memory mapped files easier to use

https://github.com/peter-lawrey/Java-Chronicle

Its a not long read and you can use it as an example.

回答5:

Apache Commons Configuration API: http://commons.apache.org/proper/commons-configuration/userguide/howto_filebased.html#File-based_Configurations

来源：https://stackoverflow.com/questions/9427155/storing-state-in-java

标签

java

persistence