Jesque is an implementation of Resque in Java. It is fully-interoperable with the Ruby and Node.js (Coffee-Resque) implementations.
Jesque is a Maven project and depends on Jedis to connect to Redis, Jackson to map to/from JSON and SLF4J for logging.
The project contains a client implementation as well as a worker implementation that supports listeners.
NOTE: Jesque's delayed jobs implementation is not compatible with resque-scheduler
Jesque requires Java 7+. Download the latest source at:
https://github.com/gresrun/jesque Or, to use it in your Maven project, add it as a dependency:
<dependency>
<groupId>net.greghaines</groupId>
<artifactId>jesque</artifactId>
<version>2.2.0</version>
</dependency>
// Configuration
final Config config = new ConfigBuilder().build();
// Add a job to the queue
final Job job = new Job("TestAction",
new Object[]{ 1, 2.3, true, "test", Arrays.asList("inner", 4.5)});
final Client client = new ClientImpl(config);
client.enqueue("foo", job);
client.end();
// Start a worker to run jobs from the queue
final Worker worker = new WorkerImpl(config,
Arrays.asList("foo"), new MapBasedJobFactory(map(entry("TestAction", TestAction.class))));
final Thread workerThread = new Thread(worker);
workerThread.start();
// Enqueue more jobs, etc.
// Shutdown the worker when finished
worker.end(true);
try { workerThread.join(); } catch (Exception e){ e.printStackTrace(); }
If enqueueing multiple jobs at the same time, there is client.batchEnqueue(String queue, List<Job> jobs)
which does it
in an optimized way.
Delayed jobs can be executed at sometime in the future.
final long delay = 10; // in seconds
final long future = System.currentTimeMillis() + (delay * 1000); // timestamp
client.delayedEnqueue("fooDelay", job, future);
Recurring jobs can start at a specific time and execute at specified intervals.
final long delay = 10; // in seconds
final long future = System.currentTimeMillis() + (delay * 1000); // timestamp
final long frequency = 60; // in seconds
client.recurringEnqueue("fooRecur", job, future, (frequency * 1000));
Delayed and recurring jobs can be cancelled.
client.removeDelayedEnqueue("fooDelay", job);
client.removeRecurringEnqueue("fooRecur", job);
ClientPool
is useful in multi threaded apps,
final Client jesqueClientPool = new ClientPoolImpl(config, PoolUtils.createJedisPool(config));
jesqueClientPool.enqueue("foo", job);
You can execute custom callbacks during specific Worker events.
int myVar = 0;
worker.getWorkerEventEmitter().addListener(new WorkerListener(){
public void onEvent(WorkerEvent event, Worker worker, String queue, Job job,
Object runner, Object result, Throwable t) {
if (runner instanceof TestAction) {
((TestAction) runner).setSomeVariable(myVar);
}
}
}, WorkerEvent.JOB_EXECUTE);
WORKER_START
Finished starting up and is about to start running.WORKER_POLL
Polling the queue.JOB_PROCESS
Processing a Job.JOB_EXECUTE
About to execute a materialized Job.JOB_SUCCESS
Successfully executed a materialized Job.JOB_FAILURE
Caught an Exception during the execution of a materialized Job.WORKER_ERROR
Caught an Exception during normal operation.WORKER_STOP
Finished running and is about to shutdown.
For more usage examples check the tests. The tests require that Redis is running on localhost:6379
.
Use the resque-web application to see the status of your jobs and workers or, if you prefer Java, try Jesque-Web.
As mentioned Jesque depends on Jedis to connect to Redis.
You can configure Jesque to connect to Redis given a URL in a system property (as used in Heroku + RedisToGo) with the following snippet: