java.lang.Object
- org.jooby.cassandra.Cassandra

All Implemented Interfaces:: Jooby.Module

public class Cassandra
extends Object
implements Jooby.Module

cassandra

The Apache Cassandra database is the right choice when you need scalability and high availability without compromising performance. Linear scalability and proven fault-tolerance on commodity hardware or cloud infrastructure make it the perfect platform for mission-critical data. Cassandra's support for replicating across multiple datacenters is best-in-class, providing lower latency for your users and the peace of mind of knowing that you can survive regional outages.

This module offers cassandra database features via Datastax Java Driver.

exports

Cluster
Session
MappingManager
Datastore
Optionally a Cassandra Session.Store

usage

Via connection string:


 {
   use(new Cassandra("cassandra://localhost/db"));
 }

Via connection property:


 {
   use(new Cassandra("db"));
 }

After you install the module Session, MappingManager and Datastore are ready to use.


 {
   use(new Cassandra("cassandra://localhost/db"));

   get("/doWithSession", req -> {
     Session session = require(Session.class);
     // work with session
   });

   get("/doWithMappingManager", req -> {
     MappingManager manager = require(MappingManager.class);
     Mapper<Beer> mapper = manager.mapper(Beer.class);
     // work with mapper;
   });

   get("/doWithDatastore", req -> {
     Datastore ds = require(Datastore.class);
     // work with datastore;
   });
 }

basic crud

This module exports MappingManager so you are free to use a Mapper. Jooby also offers the Datastore service which basically wrap a Mapper and provides query/read operations.

The main advantage of Datastore over Mapper is that you require just once instance regardless of your number of entities, but also it provides some useful query* methods.

Here is a basic API on top of Datastore:


 {

   use("/api/beer")
     .post(req -> {
       Datastore ds = req.require(Datastore.class);
       Beer beer = req.body().to(Beer.class);
       ds.save(beer);
       return beer;
     })
     .get("/:id", req -> {
       Datastore ds = req.require(Datastore.class);
       Beer beer = ds.get(Beer.class, req.param("id").value());
       return beer;
     })
     .get(req -> {
       Datastore ds = req.require(Datastore.class);
       return ds.query(Beer.class, "select * from beer").all();
     })
     .delete("/:id", req -> {
       Datastore ds = req.require(Datastore.class);
       ds.delete(Beer.class, req.param("id").value());
       return Results.noContent();
     });
 }

Keep in mind your entities must be mapped as usual or as required by Mapper. A great example is available here

accessors

Accessors provide a way to map custom queries not supported by the default entity mappers. Accessors are created at application startup time via accesor(Class) method:


 {
   use(new Cassandra("cassandra://localhost/db")
    .accessor(UserAccessor.class)
   );

   get("/users", req -> {
     return require(UserAccessor.class).getAll();
   });
 }

The accessor can be required or injected in a MVC route.

dse-driver

Add the dse-driver dependency to your classpath and then:

 {
    use(new Cassandra(DseCluster::build));
 }

That's all! Now you can require/inject a DseSession.

async

Async? Of course!!! just use the Datastax async API:


 {
   use(new Cassandra("cassandra://localhost/db"));

   use("/api/beer")
     .post(req -> {
       Datastore ds = req.require(Datastore.class);
       Beer beer = req.body().to(Beer.class);
       ds.saveAsync(beer);
       return beer;
     })
     .get("/:id", req -> {
       Datastore ds = req.require(Datastore.class);
       ListeneableFuture<Beer> beer = ds.getAsync(Beer.class, req.param("id").value());
       return beer;
     })
     .get(req -> {
       Datastore ds = req.require(Datastore.class);
       return ds.queryAsync(Beer.class, "select * from beer").all();
     })
     .delete("/:id", req -> {
       Datastore ds = req.require(Datastore.class);
       ds.deleteAsync(Beer.class, req.param("id").value());
       return Results.noContent();
     });
 }

multiple contact points

Multiple contact points are separated by a comma:


 {
   use(new Casssandra("cassandra://host1,host2/db");
 }

advanced configuration

Advanced configuration is available via cluster builder callback:


 {
   use(new Casssandra("cassandra://localhost/db")
     .doWithClusterBuilder(builder -> {
       builder.withClusterName("mycluster");
     }));
 }

Or via cluster callback:


 {
   use(new Casssandra("cassandra://localhost/db")
     .doWithCluster(cluster -> {
       Configuration configuration = cluster.getConfiguration();
       // set option
     }));
 }

Since:: 1.0.0.CR7
Author:: edgar

Constructor Summary

Constructors
Constructor and Description
`Cassandra()` Creates a new `Cassandra` module.
`Cassandra(String db)` Creates a new `Cassandra` module.
`Cassandra(String db, Supplier<com.datastax.driver.core.Cluster.Builder> builder)` Creates a new `Cassandra` module.
`Cassandra(Supplier<com.datastax.driver.core.Cluster.Builder> builder)` Creates a new `Cassandra` module.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Cassandra`	`accesor(Class<?> accessor)` Register an `Accessor` which is accessible via require calls or dependency injection.
`void`	`configure(Env env, com.typesafe.config.Config conf, com.google.inject.Binder binder)` Configure and produces bindings for the underlying application.
`Cassandra`	`doWithCluster(BiConsumer<com.datastax.driver.core.Cluster,com.typesafe.config.Config> configurer)` Configure a cluster after creation.
`Cassandra`	`doWithCluster(Consumer<com.datastax.driver.core.Cluster> configurer)` Configure a cluster after creation.
`Cassandra`	`doWithClusterBuilder(BiConsumer<com.datastax.driver.core.Cluster.Builder,com.typesafe.config.Config> configurer)` Configure a cluster before creating it.
`Cassandra`	`doWithClusterBuilder(Consumer<com.datastax.driver.core.Cluster.Builder> configurer)` Configure a cluster before creating it.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.jooby.Jooby.Module
config

- Constructor Detail
  - Cassandra
```
public Cassandra(String db,
                 Supplier<com.datastax.driver.core.Cluster.Builder> builder)
```
    Creates a new Cassandra module. Conenct via connection string:
```
 {
   use(new Cassandra("cassandra://localhost/db", DseCluster::builder));
 }
 
```
    Or via property:
```
 {
   use(new Cassandra("db", DseCluster::builder));
 }
 
```
    Parameters:
    
    db - Connection string or a property with a connection String.
    
    builder - Cluster builder.
  - Cassandra
```
public Cassandra(String db)
```
    Creates a new Cassandra module. Conenct via connection string:
```
 {
   use(new Cassandra("cassandra://localhost/db"));
 }
 
```
    Or via property:
```
 {
   use(new Cassandra("db"));
 }
 
```
    Parameters:
    
    db - Connection string or a property with a connection String.
  - Cassandra
```
public Cassandra(Supplier<com.datastax.driver.core.Cluster.Builder> builder)
```
    Creates a new Cassandra module. A property db property must be present and have a valid connection string.
  - Cassandra
```
public Cassandra()
```
    Creates a new Cassandra module. A property db property must be present and have a valid connection string.
- Method Detail
  - accesor
```
public Cassandra accesor(Class<?> accessor)
```
    Register an Accessor which is accessible via require calls or dependency injection.
    
    Parameters:
    
    accessor - An accessor.
    
    Returns:
    
    This module.
  - doWithClusterBuilder
```
public Cassandra doWithClusterBuilder(BiConsumer<com.datastax.driver.core.Cluster.Builder,com.typesafe.config.Config> configurer)
```
    Configure a cluster before creating it.
    
    Parameters:
    
    configurer - Configurer callback.
    
    Returns:
    
    This module.
  - doWithClusterBuilder
```
public Cassandra doWithClusterBuilder(Consumer<com.datastax.driver.core.Cluster.Builder> configurer)
```
    Configure a cluster before creating it.
    
    Parameters:
    
    configurer - Configurer callback.
    
    Returns:
    
    This module.
  - doWithCluster
```
public Cassandra doWithCluster(BiConsumer<com.datastax.driver.core.Cluster,com.typesafe.config.Config> configurer)
```
    Configure a cluster after creation.
    
    Parameters:
    
    configurer - Configurer callback.
    
    Returns:
    
    This module.
  - doWithCluster
```
public Cassandra doWithCluster(Consumer<com.datastax.driver.core.Cluster> configurer)
```
    Configure a cluster after creation.
    
    Parameters:
    
    configurer - Configurer callback.
    
    Returns:
    
    This module.
  - configure
```
public void configure(Env env,
                      com.typesafe.config.Config conf,
                      com.google.inject.Binder binder)
```
    Description copied from interface: Jooby.Module
    
    Configure and produces bindings for the underlying application. A module can optimize or customize a service by checking current the application env and/or the current application properties available from Config.
    
    Specified by:
    
    configure in interface Jooby.Module
    
    Parameters:
    
    env - The current application's env. Not null.
    
    conf - The current config object. Not null.
    
    binder - A guice binder. Not null.

Class Cassandra

cassandra

exports

usage

basic crud

accessors

dse-driver

async

multiple contact points

advanced configuration

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.jooby.Jooby.Module

Constructor Detail

Cassandra

Cassandra

Cassandra

Cassandra

Method Detail

accesor

doWithClusterBuilder

doWithClusterBuilder

doWithCluster

doWithCluster

configure