In this section, we discuss how to start ClusterJ applications and the ClusterJ application environment.
Executing a ClusterJ application.
All of the ClusterJ jar files are normally found in
share/mysql/java/ in the MySQL
installation directory. When executing a ClusterJ application,
you must set the classpath to point to these files. In
addition, you must set
variable to point to the directory containing the Cluster
ndbclient library, normally found in
lib/mysql (also in the MySQL installation
directory). Thus you might execute a ClusterJ program
MyClusterJApp in a manner similar to what
is shown here:
java -classpath /usr/local/mysql/share/mysql/java/clusterj.jar \ -Djava.library.path=/usr/local/mysql/lib MyClusterJApp
The precise locations of the ClusterJ jar files and of
libndbclient depend on how the NDB Cluster
software was installed. See
Installation Layouts, for more information.
ClusterJ encourages you to use different jar files at compile
time and runtime. This is to remove the ability of applications
to access implementation artifacts accidentally. ClusterJ is
intended to be independent of the NDB Cluster software version,
ndbclient layer is
version-specific. This makes it possible to maintain a stable
API, so that applications written against it using a given NDB
Cluster version continue to run following an upgrade of the
cluster to a new version.
Getting the SessionFactory and getting a Session.
is the source of all ClusterJ sessions that use a given NDB
Cluster. Usually, there is only a single
SessionFactory per NDB Cluster, per Java
SessionFactory can be configured by setting
one or more properties. The preferred way to do this is by
putting these in a properties file, like this:
The name of the properties file is arbitrary; however, by
convention, such files are named with a
.properties extension. For ClusterJ
applications, it is customary to name the file
After editing and saving the file, you can load its contents
into an instance of
as shown here:
File propsFile = new File("clusterj.properties"); InputStream inStream = new FileInputStream(propsFile); Properties props = new Properties(); props.load(inStream);
It is also possible to set these properties directly, without the use of a properties file:
Properties props = new Properties(); props.put("com.mysql.clusterj.connectstring", "localhost:1186"); props.put("com.mysql.clusterj.database", "mydb");
Once the properties have been set and loaded (using either of
the techniques just shown), you can obtain a
SessionFactory, and then from that a
instance. For this, you use the
method, as shown here:
SessionFactory factory = ClusterJHelper.getSessionFactory(props); Session session = factory.getSession();
It is usually sufficient to set and load the
properties (and these properties, along with
cannot be changed after starting the
SessionFactory). For a complete list of
SessionFactory properties and usual
values, see com.mysql.clusterj.Constants.
Session instances must not be shared among
threads. Each thread in your application should use its own
we use the default NDB Cluster connection string
NDB Cluster Connection Strings, for more
information). For the value of
mydb in this example, but this value
can be the name of any database containing
NDB tables. For a listing of all
SessionFactory properties that can be set in
this manner, see com.mysql.clusterj.Constants.
Reconnecting to an NDB Cluster. ClusterJ does not attempt to reconnect to an NDB Cluster once the connection is lost (error 4009) due to, for example, a network outage or the cluster going down. This, together with other errors, should be handled by the application with a common error handler. The handler needs to be able to detect and distinguish among three types of errors, and handle them accordingly:
Normal errors: These are errors at the application level (for example, those to deal with duplicate key, foreign key constraint, or timeout). They should be handled in application-specific ways, and, if resolved, the application can continue with the transaction.
Unexpected errors: These are failures to work with the cluster that cannot be accounted for by the conditions of the application, but are nonfatal. The application should close the ClusterJ session and reopen a new one.
Fatal errors: These are fatal errors like, for example, error 4009, Cluster Failure, which indicates a network outage or the cluster going down. The application should close the session and notify the rest of the application to shut down and then restart the
The restarting of the
SessionFactorycan be an automatic application function or a manual intervention. In either case, the code should wait until all sessions have been closed (that is, the public method getConnectionPoolSessionCounts() in the
SessionFactoryinterface returns zeros for all pooled connections). Then the
SessionFactorycan be closed and reopened, and applications can start to get sessions again.
logging. Here are some default settings for the
ClusterJ logging, which are specified in the
logging.properties file and can be
Logging level is set at
INFOfor all classes.
java.util.logging.FileHandleras the handler.
Default level for
java.util.logging.FileHandleris set at
java.util.logging.SimpleFormatteras the formatter for the handler.
Log files are put inside the
targetdirectory under the current working directory, and file names are, generally, in the pattern of
Numis a unique number for resolving file name conflicts (see the Java documentation for
logging.properties file is located by
default in the current working directory, but the location can
be changed by specifying the system property
java.util.logging.config.file when you start