CoherencePushReplicationDB.zipIn
the example bellow I'm describing a way of developing a
custom push
replication publisher that publishes data to a database via JDBC.
This example can be easily changed to publish data to other receivers
(JMS,...) by performing changes to
step 2 and small changes to
step
3, steps that are presented bellow. I've used Eclipse as the
development tool.
To
develop a
custom push replication publishers we will need to go
through 6 steps:
Step
1:
Create a
custom publisher scheme class
Step
2: Create
a
custom publisher class that should define what the publisher is
doing.
Step
3:
Create a class data is performing the actions (publish to JMS, DB,
etc ) for the
custom publisher.
Step
4:
Register the new publisher against a ContentHandler.
Step
5: Add
the new
custom publisher in the cache configuration file.
Step
6:
Add the
custom publisher scheme class to the POF configuration
file.
All
these steps are detailed bellow.
The
coherence project is attached and conclusions are presented at the
end.
Step
1: In the Coherence Eclipse project create a
class called CustomPublisherScheme that should implement
com.oracle.coherence.patterns.pushreplication.publishers.AbstractPublisherScheme.
In this class define the elements of the custom-publisher-scheme
element.
For
instance for a CustomPublisherScheme that looks like that:
<sync:publisher>
<sync:publisher-name>Active2-JDBC-Publisher</sync:publisher-name>
<sync:publisher-scheme>
<sync:custom-publisher-scheme>
<sync:jdbc-string>jdbc:oracle:thin:@machine-name:1521:XE</sync:jdbc-string>
<sync:username>hr</sync:username>
<sync:password>hr</sync:password>
</sync:custom-publisher-scheme>
</sync:publisher-scheme>
</sync:publisher>
the
code is:
package
com.oracle.coherence;
import
java.io.DataInput;
import
java.io.DataOutput;
import
java.io.IOException;
import
com.oracle.coherence.patterns.pushreplication.Publisher;
import
com.oracle.coherence.configuration.Configurable;
import
com.oracle.coherence.configuration.Mandatory;
import
com.oracle.coherence.configuration.Property;
import
com.oracle.coherence.configuration.parameters.ParameterScope;
import
com.oracle.coherence.environment.Environment;
import
com.tangosol.io.pof.PofReader;
import
com.tangosol.io.pof.PofWriter;
import
com.tangosol.util.ExternalizableHelper;
@Configurable
public
class
CustomPublisherScheme
extends
com.oracle.coherence.patterns.pushreplication.publishers.AbstractPublisherScheme
{
/**
*
*/
private
static
final
long
serialVersionUID
= 1L;
private
String jdbcString;
private
String username;
private
String password;
public
String getJdbcString()
{
return
this.jdbcString;
}
@Property("jdbc-string")
@Mandatory
public
void
setJdbcString(String jdbcString)
{
this.jdbcString
= jdbcString;
}
public
String getUsername()
{
return
username;
}
@Property("username")
@Mandatory
public
void
setUsername(String username)
{
this.username
= username;
}
public
String getPassword()
{
return
password;
}
@Property("password")
@Mandatory
public
void
setPassword(String password)
{
this.password
= password;
}
public
Publisher realize(Environment environment, ClassLoader classLoader,
ParameterScope
parameterScope)
{
return
new
CustomPublisher(getJdbcString(), getUsername(),
getPassword());
}
public
void
readExternal(DataInput in) throws
IOException
{
super.readExternal(in);
this.jdbcString
= ExternalizableHelper.readSafeUTF(in);
this.username
= ExternalizableHelper.readSafeUTF(in);
this.password
= ExternalizableHelper.readSafeUTF(in);
}
public
void
writeExternal(DataOutput out) throws
IOException
{
super.writeExternal(out);
ExternalizableHelper.writeSafeUTF(out,
this.jdbcString);
ExternalizableHelper.writeSafeUTF(out,
this.username);
ExternalizableHelper.writeSafeUTF(out,
this.password);
}
public
void
readExternal(PofReader reader) throws
IOException
{
super.readExternal(reader);
this.jdbcString
= reader.readString(100);
this.username
= reader.readString(101);
this.password
= reader.readString(102);
}
public
void
writeExternal(PofWriter writer) throws
IOException
{
super.writeExternal(writer);
writer.writeString(100,
this.jdbcString);
writer.writeString(101,
this.username);
writer.writeString(102,
this.password);
}
}
Step
2:
Define
what the CustomPublisher should basically do by creating a new java
class called CustomPublisher
that implements
com.oracle.coherence.patterns.pushreplication.Publisher
package
com.oracle.coherence;
import
com.oracle.coherence.patterns.pushreplication.EntryOperation;
import
com.oracle.coherence.patterns.pushreplication.Publisher;
import
com.oracle.coherence.patterns.pushreplication.exceptions.PublisherNotReadyException;
import
java.io.BufferedWriter;
import
java.util.Iterator;
public
class
CustomPublisher implements
Publisher
{
private
String jdbcString;
private
String username;
private
String password;
private
transient
BufferedWriter bufferedWriter;
public
CustomPublisher()
{
}
public
CustomPublisher(String jdbcString, String username, String password)
{
this.jdbcString
= jdbcString;
this.username
= username;
this.password
= password;
this.bufferedWriter
= null;
}
public
String getJdbcString()
{
return
this.jdbcString;
}
public
String getUsername()
{
return
username;
}
public
String getPassword()
{
return
password;
}
public
void
publishBatch(String cacheName, String publisherName,
Iterator<EntryOperation>
entryOperations)
{
DatabasePersistence
databasePersistence = new
DatabasePersistence(
jdbcString,
username,
password);
while
(entryOperations.hasNext())
{
EntryOperation
entryOperation = (EntryOperation) entryOperations
.next();
databasePersistence.databasePersist(entryOperation);
}
}
public
void
start(String cacheName, String publisherName)
throws
PublisherNotReadyException
{
System.err
.printf("Started:
Custom JDBC Publisher for Cache %s with Publisher %s\n",
new
Object[] { cacheName, publisherName });
}
public
void
stop(String cacheName, String publisherName)
{
System.err
.printf("Stopped:
Custom JDBC Publisher for Cache %s with Publisher %s\n",
new
Object[] { cacheName, publisherName });
}
}
In
the publishBatch
method from above we inform the publisher that he is supposed
to persist data to a database:
DatabasePersistence
databasePersistence = new
DatabasePersistence(
jdbcString,
username,
password);
while
(entryOperations.hasNext())
{
EntryOperation
entryOperation = (EntryOperation) entryOperations
.next();
databasePersistence.databasePersist(entryOperation);
}
Step
3:
The
class that deals with the persistence is a very basic one that uses
JDBC to perform inserts/updates against a database.
package
com.oracle.coherence;
import
com.oracle.coherence.patterns.pushreplication.EntryOperation;
import
java.sql.*;
import
java.text.SimpleDateFormat;
import
com.oracle.coherence.Order;
public
class
DatabasePersistence
{
public
static
String INSERT_OPERATION
= "INSERT";
public
static
String UPDATE_OPERATION
= "UPDATE";
public
Connection dbConnection;
public
DatabasePersistence(String jdbcString, String username,
String
password)
{
this.dbConnection
= createConnection(jdbcString, username, password);
}
public
Connection createConnection(String jdbcString, String username,
String
password)
{
Connection
connection = null;
System.err.println("Connecting
to: " + jdbcString + "
Username: "
+
username + " Password: "
+ password);
try
{
//
Load the JDBC driver
String
driverName = "oracle.jdbc.driver.OracleDriver";
Class.forName(driverName);
//
Create a connection to the database
connection
= DriverManager.getConnection(jdbcString, username,
password);
System.err.println("Connected
to:" + jdbcString + "
Username: "
+
username + " Password: "
+ password);
}
catch
(ClassNotFoundException e)
{
e.printStackTrace();
}
//
driver
catch
(SQLException e)
{
e.printStackTrace();
}
return
connection;
}
public
void
databasePersist(EntryOperation entryOperation)
{
if
(entryOperation.getOperation().toString()
.equalsIgnoreCase(INSERT_OPERATION))
{
insert(((Order)
entryOperation.getPublishableEntry().getValue()));
}
else
if
(entryOperation.getOperation().toString()
.equalsIgnoreCase(UPDATE_OPERATION))
{
update(((Order)
entryOperation.getPublishableEntry().getValue()));
}
}
public
void
update(Order order)
{
String
update = "UPDATE Orders set
QUANTITY= '"
+
order.getQuantity()
+
"', AMOUNT='"
+
order.getAmount()
+
"', ORD_DATE= '"
+
(new
SimpleDateFormat("dd-MMM-yyyy")).format(order
.getOrdDate())
+ "' WHERE SYMBOL='"
+ order.getSymbol()
+
"'";
System.err.println("UPDATE
= " + update);
try
{
Statement
stmt = getDbConnection().createStatement();
stmt.execute(update);
stmt.close();
}
catch
(SQLException ex)
{
System.err.println("SQLException:
" + ex.getMessage());
}
}
public
void
insert(Order order)
{
String
insert = "insert into Orders
values('"
+
order.getSymbol()
+
"',"
+
order.getQuantity()
+
","
+
order.getAmount()
+
",'"
+
(new
SimpleDateFormat("dd-MMM-yyyy")).format(order
.getOrdDate())
+ "')";
System.err.println("INSERT
= " + insert);
try
{
Statement
stmt = getDbConnection().createStatement();
stmt.execute(insert);
stmt.close();
}
catch
(SQLException ex)
{
System.err.println("SQLException:
" + ex.getMessage());
}
}
public
Connection getDbConnection()
{
return
dbConnection;
}
public
void
setDbConnection(Connection dbConnection)
{
this.dbConnection
= dbConnection;
}
}
Step
4:
Now we need to register our publisher against a ContentHandler.
In order to achieve that we need to create in our eclipse project a
new class called CustomPushReplicationNamespaceContentHandler
that should extend the
com.oracle.coherence.patterns.pushreplication.configuration.PushReplicationNamespaceContentHandler.
In the constructor of the new class we define a new handler for our
custom
publisher.
package
com.oracle.coherence;
import
com.oracle.coherence.configuration.Configurator;
import
com.oracle.coherence.environment.extensible.ConfigurationContext;
import
com.oracle.coherence.environment.extensible.ConfigurationException;
import
com.oracle.coherence.environment.extensible.ElementContentHandler;
import
com.oracle.coherence.patterns.pushreplication.PublisherScheme;
import
com.oracle.coherence.environment.extensible.QualifiedName;
import
com.oracle.coherence.patterns.pushreplication.configuration.PushReplicationNamespaceContentHandler;
import
com.tangosol.run.xml.XmlElement;
public
class
CustomPushReplicationNamespaceContentHandler extends
PushReplicationNamespaceContentHandler
{
public
CustomPushReplicationNamespaceContentHandler()
{
super();
registerContentHandler("custom-publisher-scheme",
new
ElementContentHandler()
{
public
Object onElement(ConfigurationContext context, QualifiedName
qualifiedName, XmlElement xmlElement)
throws
ConfigurationException
{
PublisherScheme
publisherScheme = new
CustomPublisherScheme();
Configurator.configure(publisherScheme, context,
qualifiedName, xmlElement);
return
publisherScheme;
}
});
}
}
Step
5:
Now we should define our CustomPublisher
in the cache configuration file according to the following
documentation.
<cache-config
xmlns:sync="class:com.oracle.coherence.CustomPushReplicationNamespaceContentHandler"
xmlns:cr="class:com.oracle.coherence.environment.extensible.namespaces.InstanceNamespaceContentHandler">
<caching-schemes>
<sync:provider
pof-enabled="false">
<sync:coherence-provider
/>
</sync:provider>
<caching-scheme-mapping>
<cache-mapping>
<cache-name>publishing-cache</cache-name>
<scheme-name>distributed-scheme-with-publishing-cachestore</scheme-name>
<autostart>true</autostart>
<sync:publisher>
<sync:publisher-name>Active2
Publisher</sync:publisher-name>
<sync:publisher-scheme>
<sync:remote-cluster-publisher-scheme>
<sync:remote-invocation-service-name>remote-site1</sync:remote-invocation-service-name>
<sync:remote-publisher-scheme>
<sync:local-cache-publisher-scheme>
<sync:target-cache-name>publishing-cache</sync:target-cache-name>
</sync:local-cache-publisher-scheme>
</sync:remote-publisher-scheme>
<sync:autostart>true</sync:autostart>
</sync:remote-cluster-publisher-scheme>
</sync:publisher-scheme>
</sync:publisher>
<sync:publisher>
<sync:publisher-name>Active2-Output-Publisher</sync:publisher-name>
<sync:publisher-scheme>
<sync:stderr-publisher-scheme>
<sync:autostart>true</sync:autostart>
<sync:publish-original-value>true</sync:publish-original-value>
</sync:stderr-publisher-scheme>
</sync:publisher-scheme>
</sync:publisher>
<sync:publisher>
<sync:publisher-name>Active2-JDBC-Publisher</sync:publisher-name>
<sync:publisher-scheme>
<sync:custom-publisher-scheme>
<sync:jdbc-string>jdbc:oracle:thin:@machine_name:1521:XE</sync:jdbc-string>
<sync:username>hr</sync:username>
<sync:password>hr</sync:password>
</sync:custom-publisher-scheme>
</sync:publisher-scheme>
</sync:publisher>
</cache-mapping>
</caching-scheme-mapping>
<!--
The following scheme is required for each remote-site when using a
RemoteInvocationPublisher
-->
<remote-invocation-scheme>
<service-name>remote-site1</service-name>
<initiator-config>
<tcp-initiator>
<remote-addresses>
<socket-address>
<address>localhost</address>
<port>20001</port>
</socket-address>
</remote-addresses>
<connect-timeout>2s</connect-timeout>
</tcp-initiator>
<outgoing-message-handler>
<request-timeout>5s</request-timeout>
</outgoing-message-handler>
</initiator-config>
</remote-invocation-scheme>
<!--
END: com.oracle.coherence.patterns.pushreplication -->
<proxy-scheme>
<service-name>ExtendTcpProxyService</service-name>
<acceptor-config>
<tcp-acceptor>
<local-address>
<address>localhost</address>
<port>20002</port>
</local-address>
</tcp-acceptor>
</acceptor-config>
<autostart>true</autostart>
</proxy-scheme>
</caching-schemes>
</cache-config>
As
you can see in the red-marked text from above I've:
- set new Namespace Content Handler
- define the new
custom publisher that should work together with
other publishers like: stderr and remote publishers in our case.
Step
6:
Add
the com.oracle.coherence.CustomPublisherScheme
to your custom-pof-config file:
<pof-config>
<user-type-list>
<!--
Built in types -->
<include>coherence-pof-config.xml</include>
<include>coherence-common-pof-config.xml</include>
<include>coherence-messagingpattern-pof-config.xml</include>
<include>coherence-pushreplicationpattern-pof-config.xml</include>
<!--
Application types -->
<user-type>
<type-id>1901</type-id>
<class-name>com.oracle.coherence.Order</class-name>
<serializer>
<class-name>com.oracle.coherence.OrderSerializer</class-name>
</serializer>
</user-type>
<user-type>
<type-id>1902</type-id>
<class-name>com.oracle.coherence.CustomPublisherScheme</class-name>
</user-type>
</user-type-list>
</pof-config>
CONCLUSIONSThis
approach allows for publishers to publish data to almost any other
receiver (database, JMS, MQ, ...). The only thing that needs to be
changed is the
DatabasePersistence.java
class that should be adapted to the chosen receiver. Only minor
changes are needed for the rest of the code (to publishBatch
method
from CustomPublisher
class).
