Hi Chuck,
to isolate your problem use default
settings for connection properties:
eager-release="false"
batch-mode="false"
useAutoCommit="1"
ignoreAutoCommitExceptions="false"
Maybe the sequence manager cause the problem.
Change the sequence manager
(e.g. SequenceManagerInMemoryImpl when running
in non-clustered environment) if possible.
regards,
Armin
----- Original Message -----
From: "Chuck Grohowski" <[EMAIL PROTECTED]>
To: "OJB Users List" <[EMAIL PROTECTED]>
Sent: Wednesday, June 04, 2003 5:30 PM
Subject: Re: OJB will not persist a simple object :-(
> Thanks so much Armin. Now After writing one object to the db, I get
no
> errros but no more objects written to the database. DEBUG tells me it
is
> now updating an object rather than doing a new insert even though a
new
> object is attempted to be written.
> My repository.xml has changed to this:
> <jdbc-connection-descriptor jcd-alias="mysql"
default-connection="true"
> platform="MySQL" jdbc-level="3.0" driver="org.gjt.mm.mysql.Driver"
> protocol="jdbc"
> subprotocol="mysql" dbalias="//127.0.0.1/wolfbot" username="wolfbot"
> password="wb0t"
> eager-release="false" batch-mode="true" useAutoCommit="2"
> ignoreAutoCommitExceptions="true">
> <connection-pool maxActive="10" maxIdle="2" maxWait="3"
> whenExhaustedAction="2" />
> <sequence-manager
>
className="org.apache.ojb.broker.util.sequence.SequenceManagerMySQLImpl"
/>
> </jdbc-connection-descriptor>
>
> Thanks again,
> Chuck
> ----- Original Message -----
> From: "Armin Waibel" <[EMAIL PROTECTED]>
> To: "OJB Users List" <[EMAIL PROTECTED]>
> Sent: Wednesday, June 04, 2003 5:00 AM
> Subject: Re: OJB will not persist a simple object :-(
>
>
> > Hi Chuck,
> >
> > ----- Original Message -----
> > From: "Chuck Grohowski" <[EMAIL PROTECTED]>
> > To: "OJB Users List" <[EMAIL PROTECTED]>
> > Sent: Wednesday, June 04, 2003 7:09 AM
> > Subject: OJB will not persist a simple object :-(
> >
> >
> > > Hello
> > > I successfully have OJB 0.9.9 working in a web app and am trying
to
> > get OJB
> > > 1.0rc3 working correctly in a standalone app I am developing.
When
> > trying
> > > to persist a simple object all that is returned in the log is this
:
> > >
> > > [org.apache.ojb.broker.accesslayer.ConnectionFactoryPooledImpl]
INFO:
> > > Destroy object was called, try to close connection:
> > > [EMAIL PROTECTED]
> >
> > This is called by the commons-pool api when a corrupted
> > connection was found (asking the pool for a connection)
> > or commons-pool shrink the connection-pool and destory(close)
> > idle connections.
> >
> > > eager-release="true"
> > It's recommended to set 'eager-release' false (introduced only for
> > use OJB within jboss).
> >
> > > logAbandoned="true"
> > detection of abandoned connections only
> > supported by ConnectionFactoryDBCPImpl
> > implementation (before use, please get latest
> > version from CVS - was refactored).
> > All other ConnectionFactory implementations
> > ignore these properties.
> >
> > regards,
> > Armin
> >
> > >
> > > Any help would be appreciated. No exceptions are being thrown so
I
> > really
> > > don't know where to start looking. :(
> > > My database is mysql Ver 12.20 Distrib 4.0.13, for pc-linux
(i686)
> > >
> > > TIA,
> > > Chuck Grohowski
> > >
> > > repository.xml:
> > >
> > > <?xml version="1.0" encoding="UTF-8"?>
> > > <!-- This is a sample metadata repository for the ObJectBridge
System.
> > > Use this file as a template for building your own mappings-->
> > >
> > > <!-- defining entities for include-files -->
> > > <!DOCTYPE descriptor-repository SYSTEM "repository.dtd" [
> > > <!ENTITY user SYSTEM "repository_user.xml">
> > > <!ENTITY internal SYSTEM "repository_internal.xml">
> > > ]>
> > >
> > >
> > > <descriptor-repository version="1.0"
> > isolation-level="read-uncommitted">
> > > <!-- The Default JDBC Connection. If a class-descriptor does not
> > > specify its own JDBC Connection,
> > > the Connection specified here will be used. -->
> > >
> > > <jdbc-connection-descriptor jcd-alias="mysql"
> > default-connection="true"
> > > platform="MySQL" jdbc-level="3.0"
driver="org.gjt.mm.mysql.Driver"
> > > protocol="jdbc"
> > > subprotocol="mysql" dbalias="//127.0.0.1/wolfbot"
username="wolfbot"
> > > password="xxxx"
> > > eager-release="true"
> > > batch-mode="true"
> > > useAutoCommit="2"
> > > ignoreAutoCommitExceptions="true">
> > > <connection-pool maxActive="10" maxIdle="2" maxWait="3"
> > > minEvictableIdleTimeMillis="4"
> > > numTestsPerEvictionRun="5" testOnBorrow="true"
testOnReturn="true"
> > > testWhileIdle="true"
> > > timeBetweenEvictionRunsMillis="6" whenExhaustedAction="2"
> > > validationQuery="select * from test limit 0,1"
> > > logAbandoned="true" removeAbandoned="true"
> > removeAbandonedTimeout="8" />
> > >
> > > <sequence-manager
> > >
> >
className="org.apache.ojb.broker.util.sequence.SequenceManagerMySQLImpl"
> > />
> > > </jdbc-connection-descriptor>
> > >
> > > <!-- include user defined mappings here -->
> > > &user;
> > >
> > > <!-- include ojb internal mappings here -->
> > > &internal;
> > >
> > > </descriptor-repository>
> > >
> > > repository_user.xml:
> > >
> > > <class-descriptor class="Kills" table="kills">
> > > <field-descriptor name="id" column="id"
jdbc-type="INTEGER"
> > > nullable="false" primarykey="true" autoincrement="true"/>
> > > <field-descriptor name="prawner" column="prawner"
> > jdbc-type="INTEGER"
> > > nullable="false"/>
> > > <field-descriptor name="prawned" column="prawned"
> > jdbc-type="INTEGER"
> > > nullable="false"/>
> > > <field-descriptor name="deathBy" column="death_by"
> > jdbc-type="INTEGER"
> > > nullable="false"/>
> > > <field-descriptor name="timeOfDeath" column="time_of_death"
> > > jdbc-type="TIME" nullable="false"/>
> > > </class-descriptor>
> > >
> > > offending code:
> > > public static void recordKill( Kills k ) {
> > >
> > > PersistenceBroker broker = null;
> > > try {
> > >
> > > broker =
> > PersistenceBrokerFactory.defaultPersistenceBroker();
> > > broker.beginTransaction();
> > > broker.store( k );
> > > broker.commitTransaction();
> > > }
> > > catch( PBFactoryException pbe ) {
> > >
> > > broker.abortTransaction();
> > > pbe.printStackTrace();
> > > }
> > > catch( Exception e ) {
> > > broker.abortTransaction();
> > > e.printStackTrace();
> > > }
> > > finally {
> > > if( broker != null ) {
> > >
> > > broker.close();
> > > }
> > > }
> > > }
> > >
> > > OJB.properties:
> > > # OJB.properties -- configuration of the OJB runtime environment
> > > # Version: 1.0
> > > # (c) 2001, 2002, 2003 Apache Software Foundation
> > > # Author: Thomas Mahler and many others
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # repository file settings
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The repositoryFile entry tells OJB to use this file as as its
> > standard
> > > mapping
> > > # repository. The file is looked up from the classpath.
> > > #
> > > repositoryFile=repository.xml
> > > #
> > > # If the useSerializedRepository entry is set to true, OJB tries
to
> > load a
> > > # serialized version of the repository for performance reasons.
> > > # if set to false, OJB always loads the xml file.
> > > # Setting this flag to true will accelerate the startup sequence
of
> > OJB.
> > > # If set to true changes to the repository.xml file will only be
> > detected
> > > # after maually deleting the repository.xml.serialized file.
> > > useSerializedRepository=false
> > > #
> > > # If Repository serialization is used the entry
> > serializedRepositoryPath
> > > defines the
> > > # directory where the Repository is written to and read from.
> > > # this entry is used only when the useSerializedRepository flag is
set
> > to
> > > true
> > > #
> > > serializedRepositoryPath=.
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # PersistenceBrokerFactory / PersistenceBroker
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The PersistenceBrokerFactoryClass entry decides which concrete
> > > # PersistenceBrokerFactory implemention is to be used.
> > >
> >
PersistenceBrokerFactoryClass=org.apache.ojb.broker.core.PersistenceBrok
> > erFa
> > > ctoryDefaultImpl
> > > #
> > > # The PersistenceBrokerClass entry decides which concrete
> > PersistenceBroker
> > > # implementation is to be served by the PersistenceBrokerFactory.
> > > # This is the singlevm implementation:
> > >
> >
PersistenceBrokerClass=org.apache.ojb.broker.core.PersistenceBrokerImpl
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # PersistenceBrokerFactory pool
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # PersistenceBroker pool configuration
> > > # This pool uses the jakarta-commons-pool api.
> > > # There you can find things described in detail.
> > > #
> > > # maximum number of brokers that can be borrowed from the
> > > # pool at one time. When non-positive, there is no limit.
> > > maxActive=100
> > > #
> > > # controls the maximum number of brokers that can sit idle in the
> > > # pool (per key) at any time. When non-positive, there is no limit
> > > maxIdle=-1
> > > #
> > > # max time block to get broker instance from pool, after that
> > exception is
> > > thrown.
> > > # When non-positive, block till last judgement
> > > maxWait=2000
> > > #
> > > # indicates how long the eviction thread should sleep before
"runs" of
> > > examining
> > > # idle objects. When non-positive, no eviction thread will be
> > launched.
> > > timeBetweenEvictionRunsMillis=-1
> > > #
> > > # specifies the minimum amount of time that an broker may sit idle
> > > # in the pool before it is eligable for eviction due to idle time.
> > > # When non-positive, no object will be dropped from the pool due
> > > # to idle time alone (depends on timeBetweenEvictionRunsMillis >
0)
> > > minEvictableIdleTimeMillis=1000000
> > > #
> > > # specifies the behaviour of the pool when broker capacity is
> > > # exhausted (see maxActive above)
> > > # 0 - fail
> > > # 1 - block
> > > # 2 - grow
> > > whenExhaustedAction=0
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # ConnectionFactory / Default ConnectionPool
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The ConnectionFactoryClass entry determines which kind of
> > > ConnectionFactory
> > > # is to be used within org.apache.ojb as connection factory.
> > > # A ConnectionFactory is responsible for creating
> > > # JDBC Connections. Current version ships four implementations:
> > > #
> > > # 1. ConnectionFactoryNotPooledImpl
> > > # No pooling, no playing around.
> > > # Every connection request returns a new connection,
> > > # every connection release close the connection.
> > > # 2. ConnectionFactoryPooledImpl
> > > # This implementation supports connection pooling.
> > > # 3. ConnectionFactoryDBCPImpl
> > > # Using the jakarta-DBCP api for connection management, support
> > > # connection- and prepared statement-pooling, abandoned
connection
> > > handling.
> > > # 4. ConnectionFactoryManagedImpl
> > > # Connection factory for use within managed environments - e.g.
> > JBoss.
> > > # Every obtained DataSource was wrapped within OJB (and ignore
> > > # e.g. con.commit() calls within OJB).
> > > # Use this implementation e.g if you use Datasources from an
> > application
> > > server.
> > > #
> > > # Use the OJB performance tests to decide, which implementation is
> > best for
> > > you.
> > > # The proper way of obtaining a connection is configured in
> > > # JDBCConnectionDescriptor entries in the repository.xml file.
> > > # If want a more fine grained control of each connection pool used
by
> > OJB,
> > > # take a look at the repository.dtd, there was a possibility to
> > override
> > > # this default connection factory entry in each
> > JDBCConnectionDescriptor.
> > > #
> > >
> >
ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFacto
> > ryPo
> > > oledImpl
> > >
> >
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFact
> > oryN
> > > otPooledImpl
> > >
> >
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFact
> > oryM
> > > anagedImpl
> > >
> >
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFact
> > oryD
> > > BCPImpl
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # ConnectionManager
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The ConnectionManagerClass entry defines the ConnectionManager
> > > implemementation to be used
> > >
> >
ConnectionManagerClass=org.apache.ojb.broker.accesslayer.ConnectionManag
> > erIm
> > > pl
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # SqlGenerator
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The SqlGeneratorClass entry defines the SqlGenerator
> > implemementation to
> > > be used
> > >
> >
SqlGeneratorClass=org.apache.ojb.broker.accesslayer.sql.SqlGeneratorDefa
> > ultI
> > > mpl
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # CollectionProxy class
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The optional CollectionProxy entry defines the class to be used
for
> > > CollectionProxies
> > > # if this entry is null
org.apache.ojb.broker.accesslayer.ListProxy is
> > used
> > > for Lists
> > > # and org.apache.ojb.broker.accesslayer.CollectionProxy for
> > Collections
> > > #
> > > #CollectionProxyClass=
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # StatementManager
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The StatementManagerClass entry defines the StatementManager
> > > implemementation to be used
> > >
> >
StatementManagerClass=org.apache.ojb.broker.accesslayer.StatementManager
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # JdbcAccess
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The JdbcAccessClass entry defines the JdbcAccess
implemementation to
> > be
> > > used
> > > JdbcAccessClass=org.apache.ojb.broker.accesslayer.JdbcAccessImpl
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # Object cache
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The ObjectCacheClass entry tells OJB which concrete instance
Cache
> > > # implementation is to be used.
> > >
ObjectCacheClass=org.apache.ojb.broker.cache.ObjectCacheDefaultImpl
> > > #ObjectCacheClass=org.apache.ojb.broker.cache.ObjectCacheEmptyImpl
> > >
#ObjectCacheClass=org.apache.ojb.broker.cache.ObjectCachePerBrokerImpl
> > >
#ObjectCacheClass=org.apache.ojb.broker.cache.MetaObjectCacheJCSImpl
> > >
> >
#ObjectCacheClass=org.apache.ojb.broker.cache.MetaObjectCachePerClassImp
> > l
> > > #
> > > #
> > > # Use CacheFilters to do filter operations before caching methods
were
> > > # called. Build your own filter class by implementing
> > > org.apache.ojb.cache.CacheFilter.
> > > # It is possible to use a arbitrary number of CacheFilters, but
this
> > slows
> > > # down the performance of the cache, thus handle with care.
> > > #
> > > # - org.apache.ojb.broker.cache.CacheFilterClassImpl
> > > # allows filtering of classes
> > > # - org.apache.ojb.broker.cache.CacheFilterPackageImpl
> > > # allows filtering of packages
> > > # More info see Javadoc of the according classes.
> > > # Set a comma separated list of CacheFilter.
> > >
> >
#ObjectCacheFilter=org.apache.ojb.broker.cache.CacheFilterClassImpl,org.
> > apac
> > > he.ojb.broker.cache.CacheFilterPackageImpl
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # Locking
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The LockManagerClass entry tells OJB which concrete LockManager
> > > # implementation is to be used.
> > >
LockManagerClass=org.apache.ojb.odmg.locking.LockManagerDefaultImpl
> > > #
> > > # The LockMapClass entry tells OJB which concrete LockMap
> > > # implementation is to be used.
> > > # If OJB is running on multiple concurrent clients it is
recommended
> > > # to use the PersistentLockMapImpl. It guarantees to provide
> > > # Lockamanagement across multiple JVMs.
> > > # If OJB is running in a single JVM (e.g. in a desktop app, or in
a
> > servlet
> > > # engine) it is save to use the InMemoryLockMapImpl. Using it will
> > result
> > > # in a large performance gain.
> > > # LockMapClass=org.apache.ojb.odmg.locking.PersistentLockMapImpl
> > > LockMapClass=org.apache.ojb.odmg.locking.InMemoryLockMapImpl
> > > #
> > > # The LockTimeout entry defines the maximum time in milliseconds
> > > # that a lock may be hold. Defaults to 60000 = 1 minute
> > > LockTimeout=60000
> > > #
> > > # The ImplicitLocking entry defines if implicit lock acquisition
is
> > > # to be used. If set to true OJB implicitely locks objects to ODMG
> > > # transactions after performing OQL queries.
> > > # If implicit locking is used locking objects is recursive, that
is
> > > # associated objects are also locked.
> > > # If ImplicitLocking is set to false, no locks are obtained in OQL
> > > # queries and there is also no recursive locking.
> > > ImplicitLocking=true
> > > #ImplicitLocking=false
> > > #
> > > # The LockAssociations entry defines the behaviour for the OJB
> > > # implicit locking feature. If set to WRITE (default) acquiring a
> > write-
> > > # lock on a given object x implies write locks on all objects
> > associated
> > > # to x. If set to READ implicit read-locks are acquired.
> > > # Acquiring a read-lock on x thus allways results in implicit
> > read-locks
> > > # on all associated objects.
> > > #LockAssociations=READ
> > > LockAssociations=WRITE
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # Logging
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The LoggerClass entry tells OJB which concrete Logger
> > > # implementation is to be used.
> > > #
> > > # Commons-logging
> > > #LoggerClass=org.apache.ojb.broker.util.logging.CommonsLoggerImpl
> > > # log4j based logging
> > > #LoggerClass=org.apache.ojb.broker.util.logging.Log4jLoggerImpl
> > > # OJB's own simple looging support
> > > LoggerClass=org.apache.ojb.broker.util.logging.PoorMansLoggerImpl
> > > LoggerConfigFile=log4j.properties
> > > #
> > > # The LogLevel entries tells OJB which LogLevels are active
> > > # for the different loggers used within OJB
> > > # Loglevels: DEBUG < INFO < WARN < ERROR < FATAL
> > > # That is loglevel WARN won't log DEBUG and INFO messages,
> > > # but will log WARN, ERROR, and FATAL messages
> > > #
> > > # The Default Logger
> > > DEFAULT.LogLevel=DEBUG
> > >
org.apache.ojb.broker.accesslayer.ConnectionFactoryPooledImpl=DEBUG
> > > # Logger for PersistenceBrokerImpl class
> > > org.apache.ojb.broker.core.PersistenceBrokerImpl.LogLevel=DEBUG
> > > # Logger for PersistenceBrokerFactory class
> > > org.apache.ojb.broker.PersistenceBrokerFactory.LogLevel=DEBUG
> > > # Logger for RepositoryXmlHandler, useful for debugging parsing of
> > > repository.xml!
> > > org.apache.ojb.broker.metadata.RepositoryXmlHandler.LogLevel=DEBUG
> > > # Logger for JdbcAccess, useful for debugging JDBC related
problems
> > > org.apache.ojb.broker.accesslayer.JdbcAccess.LogLevel=DEBUG
> > > # Logger for RsIterator, useful for debugging problems with Object
> > > materialization
> > > org.apache.ojb.broker.accesslayer.RsIterator.LogLevel=DEBUG
> > > # Logger for StatementsForClass, useful for debugging JDBC
Connection
> > > related problems
> > >
org.apache.ojb.broker.accesslayer.StatementsForClass.LogLevel=DEBUG
> > > # Logger for SqlGenerator, useful for debugging generation of SQL
> > >
> >
org.apache.ojb.broker.accesslayer.sql.SqlGeneratorDefaultImpl.LogLevel=D
> > EBUG
> > > # Logger for RepositoryPersistor
> > > org.apache.ojb.broker.metadata.RepositoryPersistor.LogLevel=DEBUG
> > > # Logger for PersistenceBrokerFactoryDefaultImpl
> > >
> >
org.apache.ojb.broker.core.PersistenceBrokerFactoryDefaultImpl.LogLevel=
> > WARN
> > > # Logger for the ODMG Implementation
> > > ODMG.LogLevel=DEBUG
> > > # Logger for the JDO RI Implementation
> > > JDO.LogLevel=DEBUG
> > > # Logger for the performance tests
> > > performance.LogLevel=DEBUG
> > > # Logger for the soda api
> > > soda.LogLevel=DEBUG
> > > # Logger for the factory service
> > > ConfigurableFactory.LogLevel=DEBUG
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # OQL / SQL settings
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The OqlCollectionClass entry defines the collection type
returned
> > > # from OQL queries. By default this value is set to DListImpl.
> > > # This will be good for most situations as DList allows maximum
> > flexibility
> > > # in a ODMG environment.
> > > # Using DLists for large resultsets may be bad for application
> > performance.
> > > # For these scenarios you can use ArrayLists or Vectors.
> > > # Important note: the collections class to be used MUST implement
the
> > > # interface org.apache.ojb.broker.ManageableCollection.
> > > #
> > > OqlCollectionClass=org.apache.ojb.odmg.collections.DListImpl
> > > #
> > >
> >
OqlCollectionClass=org.apache.ojb.broker.util.collections.ManageableArra
> > yLis
> > > t
> > > # OqlCollectionClass=org.apache.ojb.broker.util.ManageableVector
> > > #
> > > # The SqlInLimit entry limits the number of values in IN-sql
> > statement,
> > > # -1 for no limits. This hint is used in Criteria.
> > > SqlInLimit=200
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # Meta data / mapping settings
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # The PersistentFieldClass property defines the implementation
class
> > > # for PersistentField attributes used in the OJB MetaData layer.
> > > # By default a attribute based Version using Reflection is
selected.
> > > # using this Class persistent attributes don't need getters and
> > setters
> > > # and don't have to be declared public or protected.
> > > #
> > >
> >
PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.Persiste
> > ntFi
> > > eldDefaultImpl
> > > #
> > > # There is also a high-speed version of this access strategy
> > avalaible.
> > > # The PersistentFieldMaxPerformanceImpl does not cooperate with
> > > # an AccessController, but accesses the fields directly.
> > >
> >
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.Persist
> > entF
> > > ieldMaxPerformanceImpl
> > > #
> > > # The PersistentFieldPropertyImpl uses JavaBeans comformant calls
only
> > > # to access persistent attributes. No Reflection is needed.
> > > # But for each attribute xxx there must be public getXxx() and
> > setXxx()
> > > methods.
> > > #
> > >
> >
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.Persist
> > entF
> > > ieldPropertyImpl
> > > #
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # Component Intercepting for Profiling and Tracing
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # By enabling an InterceptorClass all OJB components will use
> > > # this Interceptor. Interceptors allow advanced tracing and
Profiling
> > > # of all component method calls.
> > > # This is currently an experimental feature useful only for OJB
kernel
> > > developers.
> > > #
> > >
> >
#InterceptorClass=org.apache.ojb.broker.util.interceptor.TracingIntercep
> > tor
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # Transaction Management and assocation
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # Use the LocalTxManager if you want the transaction to be
associated
> > by a
> > > thread
> > > OJBTxManagerClass=org.apache.ojb.odmg.LocalTxManager
> > > # Use the JTATxManager if you want the transaction to be
associated
> > via the
> > > Transaction
> > > # manager that is in your application server.
> > > #OJBTxManagerClass=org.apache.ojb.odmg.JTATxManager
> > > #
> > > # The TransactionManager is acquired in different ways dependent
on
> > the
> > > application server.
> > > # The JTATransactionManagerClass property allows you to specify
the
> > class
> > > that implements
> > > # the proper behaviour for finding the transaction manager. Only
use
> > when
> > > OJBTxManagerClass
> > > # is set to a factory that uses the application server transaction
> > manager
> > > # (org.apache.ojb.odmg.JTATxManager)
> > > #
> > > # JBoss Transaction Manager Factory
> > >
> >
JTATransactionManagerClass=org.apache.ojb.odmg.transaction.JBossTransact
> > ionM
> > > anagerFactory
> > > # Weblogic Transaction Manager Factory
> > >
> >
#JTATransactionManagerClass=org.apache.ojb.odmg.transaction.WeblogicTran
> > sact
> > > ionManagerFactory
> > > # WebSphere transaction manager factory
> > >
> >
#JTATransactionManagerClass=org.apache.ojb.odmg.transaction.WebSphereTra
> > nsac
> > > tionManagerFactory
> > > # Orion transaction manager factory
> > >
> >
#JTATransactionManagerClass=org.apache.ojb.odmg.transaction.OrionTransac
> > tion
> > > ManagerFactory
> > > #
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > > # End of OJB.properties file
> > >
> >
#-----------------------------------------------------------------------
> > ----
> > > -------------
> > >
> > >
> > >
> >
> ---------------------------------------------------------------------
> > > To unsubscribe, e-mail: [EMAIL PROTECTED]
> > > For additional commands, e-mail: [EMAIL PROTECTED]
> > >
> > >
> >
> >
> >
>
> ---------------------------------------------------------------------
> > To unsubscribe, e-mail: [EMAIL PROTECTED]
> > For additional commands, e-mail: [EMAIL PROTECTED]
> >
> >
> >
>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [EMAIL PROTECTED]
> For additional commands, e-mail: [EMAIL PROTECTED]
>
>
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
