public class SyncFactory extends Object
SyncProvider
instances to be used by disconnected RowSet
objects. The SyncProvider
instances in turn provide the javax.sql.RowSetReader
object the RowSet
object needs to populate itself with data and the javax.sql.RowSetWriter
object it needs to propagate changes to its data back to the underlying data source. Because the methods in the SyncFactory
class are all static, there is only one SyncFactory
object per Java VM at any one time. This ensures that there is a single source from which a RowSet
implementation can obtain its SyncProvider
implementation.
SyncFactory
class provides an internal registry of available synchronization provider implementations (SyncProvider
objects). This registry may be queried to determine which synchronization providers are available. The following line of code gets an enumeration of the providers currently registered. java.util.Enumeration e = SyncFactory.getRegisteredProviders();All standard
RowSet
implementations must provide at least two providers: CachedRowSet
implementation or an implementation derived from it WebRowSet
objects SyncProvider
implementations RIOptimisticProvider
and RIXmlProvider
, which satisfy this requirement. The SyncFactory
class provides accessor methods to assist applications in determining which synchronization providers are currently registered with the SyncFactory
.
Other methods let RowSet
persistence providers be registered or de-registered with the factory mechanism. This allows additional synchronization provider implementations to be made available to RowSet
objects at run time.
Applications can apply a degree of filtering to determine the level of synchronization that a SyncProvider
implementation offers. The following criteria determine whether a provider is made available to a RowSet
object:
RowSet
object, and the SyncFactory
does not contain a reference to this provider, a SyncFactoryException
is thrown stating that the synchronization provider could not be found. RowSet
implementation is instantiated with a specified provider and the specified provider has been properly registered, the requested provider is supplied. Otherwise a SyncFactoryException
is thrown. RowSet
object does not specify a SyncProvider
implementation and no additional SyncProvider
implementations are available, the reference implementation providers are supplied. SyncProvider
Implementations Both vendors and developers can register SyncProvider
implementations using one of the following mechanisms.
-Drowset.provider.classname=com.fred.providers.HighAvailabilityProvider
#Default JDBC RowSet sync providers listing # # Optimistic synchronization provider rowset.provider.classname.0=com.sun.rowset.providers.RIOptimisticProvider rowset.provider.vendor.0=Oracle Corporation rowset.provider.version.0=1.0 # XML Provider using standard XML schema rowset.provider.classname.1=com.sun.rowset.providers.RIXMLProvider rowset.provider.vendor.1=Oracle Corporation rowset.provider.version.1=1.0The
SyncFactory
checks this file and registers the SyncProvider
implementations that it contains. A developer or vendor can add other implementations to this file. For example, here is a possible addition: rowset.provider.classname.2=com.fred.providers.HighAvailabilityProvider rowset.provider.vendor.2=Fred, Inc. rowset.provider.version.2=1.0
SyncFactory
will attempt to load SyncProvider
implementations from that JNDI context. For example, the following code fragment registers a provider implementation on a JNDI context. This is something a deployer would normally do. In this example, MyProvider
is being registered on a CosNaming namespace, which is the namespace used by J2EE resources. import javax.naming.*; Hashtable svrEnv = new Hashtable(); srvEnv.put(Context.INITIAL_CONTEXT_FACTORY, "CosNaming"); Context ctx = new InitialContext(svrEnv); com.fred.providers.MyProvider = new MyProvider(); ctx.rebind("providers/MyProvider", syncProvider);
SyncFactory
instance. This allows the SyncFactory
to browse within the JNDI context looking for SyncProvider
implementations. Hashtable appEnv = new Hashtable(); appEnv.put(Context.INITIAL_CONTEXT_FACTORY, "CosNaming"); appEnv.put(Context.PROVIDER_URL, "iiop://hostname/providers"); Context ctx = new InitialContext(appEnv); SyncFactory.registerJNDIContext(ctx);If a
RowSet
object attempts to obtain a MyProvider
object, the SyncFactory
will try to locate it. First it searches for it in the system properties, then it looks in the resource files, and finally it checks the JNDI context that has been set. The SyncFactory
instance verifies that the requested provider is a valid extension of the SyncProvider
abstract class and then gives it to the RowSet
object. In the following code fragment, a new CachedRowSet
object is created and initialized with env, which contains the binding to MyProvider
. Hashtable env = new Hashtable(); env.put(SyncFactory.ROWSET_SYNC_PROVIDER, "com.fred.providers.MyProvider"); CachedRowSet crs = new com.sun.rowset.CachedRowSetImpl(env);Further details on these mechanisms are available in the
javax.sql.rowset.spi
package specification.Modifier and Type | Field | Description |
---|---|---|
static final String |
ROWSET_SYNC_PROVIDER |
The standard property-id for a synchronization provider implementation name. |
static final String |
ROWSET_SYNC_PROVIDER_VERSION |
The standard property-id for a synchronization provider implementation version tag. |
static final String |
ROWSET_SYNC_VENDOR |
The standard property-id for a synchronization provider implementation vendor name. |
Modifier and Type | Method | Description |
---|---|---|
static SyncProvider |
getInstance |
Returns the SyncProvider instance identified by providerID. |
static Logger |
getLogger() |
Returns the logging object for applications to retrieve synchronization events posted by SyncProvider implementations. |
static Enumeration |
getRegisteredProviders() |
Returns an Enumeration of currently registered synchronization providers. |
static SyncFactory |
getSyncFactory() |
Returns the SyncFactory singleton. |
static void |
registerProvider |
Adds the given synchronization provider to the factory register. |
static void |
setJNDIContext |
Sets the initial JNDI context from which SyncProvider implementations can be retrieved from a JNDI namespace |
static void |
setLogger |
Sets the logging object to be used by the SyncProvider implementation provided by the SyncFactory . |
static void |
setLogger |
Sets the logging object that is used by SyncProvider implementations provided by the SyncFactory SPI. |
static void |
unregisterProvider |
Removes the designated currently registered synchronization provider from the Factory SPI register. |
public static final String ROWSET_SYNC_PROVIDER
public static final String ROWSET_SYNC_VENDOR
public static final String ROWSET_SYNC_PROVIDER_VERSION
public static void registerProvider(String providerID) throws SyncFactoryException
SyncProvider
specification for the required naming conventions for SyncProvider
implementations. Synchronization providers bound to a JNDI context can be registered by binding a SyncProvider instance to a JNDI namespace.
SyncProvider p = new MySyncProvider();
InitialContext ic = new InitialContext();
ic.bind ("jdbc/rowset/MySyncProvider", p);
Furthermore, an initial JNDI context should be set with the SyncFactory
using the setJNDIContext
method. The SyncFactory
leverages this context to search for available SyncProvider
objects bound to the JNDI context and its child nodes.providerID
- A String
object with the unique ID of the synchronization provider being registeredSyncFactoryException
- if an attempt is made to supply an empty or null provider namepublic static SyncFactory getSyncFactory()
SyncFactory
singleton.SyncFactory
instancepublic static void unregisterProvider(String providerID) throws SyncFactoryException
providerID
- The unique-id of the synchronization providerSyncFactoryException
- If an attempt is made to unregister a SyncProvider implementation that was not registered.public static SyncProvider getInstance(String providerID) throws SyncFactoryException
SyncProvider
instance identified by providerID.providerID
- the unique identifier of the providerSyncProvider
implementationSyncFactoryException
- If the SyncProvider cannot be found, the providerID is null
, or some error was encountered when trying to invoke this provider.public static Enumeration<SyncProvider> getRegisteredProviders() throws SyncFactoryException
RowSet
implementation may use any provider in the enumeration as its SyncProvider
object. At a minimum, the reference synchronization provider allowing RowSet content data to be stored using a JDBC driver should be possible.
SyncFactoryException
- If an error occurs obtaining the registered providerspublic static void setLogger(Logger logger)
SyncProvider
implementation provided by the SyncFactory
. All SyncProvider
implementations can log their events to this object and the application can retrieve a handle to this object using the getLogger
method. This method checks to see that there is an SQLPermission
object which grants the permission setSyncFactory
before allowing the method to succeed. If a SecurityManager
exists and its checkPermission
method denies calling setLogger
, this method throws a java.lang.SecurityException
.
logger
- A Logger object instanceSecurityException
- if a security manager exists and its checkPermission
method denies calling setLogger
NullPointerException
- if the logger is nullpublic static void setLogger(Logger logger, Level level)
SyncProvider
implementations provided by the SyncFactory
SPI. All SyncProvider
implementations can log their events to this object and the application can retrieve a handle to this object using the getLogger
method. This method checks to see that there is an SQLPermission
object which grants the permission setSyncFactory
before allowing the method to succeed. If a SecurityManager
exists and its checkPermission
method denies calling setLogger
, this method throws a java.lang.SecurityException
.
logger
- a Logger object instancelevel
- a Level object instance indicating the degree of logging requiredSecurityException
- if a security manager exists and its checkPermission
method denies calling setLogger
NullPointerException
- if the logger is nullpublic static Logger getLogger() throws SyncFactoryException
Logger
that has been specified for use by SyncProvider
implementationsSyncFactoryException
- if no logging object has been set.public static void setJNDIContext(Context ctx) throws SyncFactoryException
This method checks to see that there is an SQLPermission
object which grants the permission setSyncFactory
before allowing the method to succeed. If a SecurityManager
exists and its checkPermission
method denies calling setJNDIContext
, this method throws a java.lang.SecurityException
.
ctx
- a valid JNDI contextSyncFactoryException
- if the supplied JNDI context is nullSecurityException
- if a security manager exists and its checkPermission
method denies calling setJNDIContext
© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.sql.rowset/javax/sql/rowset/spi/SyncFactory.html