| #<!-- |
| #/* Licensed to the Apache Software Foundation (ASF) under one or more |
| #/* contributor license agreements. See the NOTICE file distributed with |
| #/* this work for additional information regarding copyright ownership. |
| #/* The ASF licenses this file to You under the Apache License, Version 2.0 |
| #/* (the "License"); you may not use this file except in compliance with |
| #/* the License. You may obtain a copy of the License at |
| # * |
| # * http://www.apache.org/licenses/LICENSE-2.0 |
| # * |
| # * Unless required by applicable law or agreed to in writing, software |
| # * distributed under the License is distributed on an "AS IS" BASIS, |
| # * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # * See the License for the specific language governing permissions and |
| # * limitations under the License. |
| # */ |
| #--> |
| # OJB.properties -- configuration of the OJB runtime environment |
| # Version: 1.0 |
| # (c) 2001, 2002, 2003 Apache Software Foundation |
| # Author: Thomas Mahler and many others |
| # @version $Id: OJB.properties,v 1.75.2.7 2005/04/03 02:40:57 arminw Exp $ |
| # |
| #---------------------------------------------------------------------------------------- |
| # 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.PersistenceBrokerFactoryDefaultImpl |
| # If in managed environment *only* the PB-api was used it's recommended to use this factory |
| # to enable the PersistenceBroker instances to participate in the JTA transaction. This makes |
| # e.g. PBStateListener work properly in managed environments. |
| #PersistenceBrokerFactoryClass=org.apache.ojb.broker.core.PersistenceBrokerFactorySyncImpl |
| # |
| # |
| # 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 |
| # |
| # This is an implementation that uses Prevayler (prevayler.sf.net) as the persistent storage. |
| # Using this implementation OJB works as a simple OODBMS |
| #PersistenceBrokerClass=org.apache.ojb.broker.prevayler.PBPrevaylerImpl |
| # |
| # |
| # This setting can be helpful during development if the PersistenceBroker transaction |
| # demarcation was used (this is true in most cases). If set 'true' on PB#store(...) |
| # and PB#delete(...) methods calls OJB check for active PB-tx and if no active tx is |
| # found a error is logged. This can help to avoid store/delete calls without a running |
| # PB-tx while development. Default setting is 'false'. (Note: When using OJB in a managed |
| # environment *without* OJB-caching, it's valid to use store/delete calls without a running PB-tx) |
| TxCheck=false |
| # |
| #---------------------------------------------------------------------------------------- |
| # PersistenceBroker 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. ConnectionFactoryAvalonDatasource |
| # Uses a Cocoon configured DataSource specified with the jcd-alias attribute value in |
| # a jdbc-connection-descriptor element in the repository.xml file. |
| # 2. ConnectionFactoryNotPooledImpl |
| # No pooling, no playing around. |
| # Every connection request returns a new connection, |
| # every connection release close the connection. |
| # 3. ConnectionFactoryPooledImpl |
| # This implementation supports connection pooling. |
| # 4. ConnectionFactoryDBCPImpl |
| # Using the jakarta-DBCP api for connection management, support |
| # connection- and prepared statement-pooling, abandoned connection handling. |
| # 5. 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.cocoon.ojb.components.ConnectionFactoryImpl |
| #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryPooledImpl |
| #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryNotPooledImpl |
| #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryDBCPImpl |
| # Only needed when using OJB 1.0.3 or earlier in managed environments. Since version |
| # 1.0.4 OJB detects datasources from managed environments automatically. |
| #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryManagedImpl |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # ConnectionManager |
| #---------------------------------------------------------------------------------------- |
| # The ConnectionManagerClass entry defines the ConnectionManager implemementation to be used |
| ConnectionManagerClass=org.apache.ojb.broker.accesslayer.ConnectionManagerImpl |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # SqlGenerator |
| #---------------------------------------------------------------------------------------- |
| # The SqlGeneratorClass entry defines the SqlGenerator implemementation to be used |
| SqlGeneratorClass=org.apache.ojb.broker.accesslayer.sql.SqlGeneratorDefaultImpl |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # ProxyFactory and IndirectionHandler |
| #---------------------------------------------------------------------------------------- |
| # The ProxyFactoryClass entry defines which ProxyFactory implementation is to be used. |
| # By default, a 1.0 compatiable, JDK-based version is used. However, a the CGLIB based entry |
| # is available. |
| # |
| # - ProxyFactoryCGLIBImpl: Refernece proxies are generated using bytecode manipulation |
| # from the CGLIB library. Any class can become a dynamic proxy, and not just ones |
| # that implement an interface. |
| # - ProxyFactoryJDKImpl: OJB 1.0 compatiable Proxy implementation. Proxies in this method |
| # can only be generated from classes that implement an interface, and the generated |
| # Proxy will implement all methods of that interface. |
| # |
| # NOTE: The appropriate cooresponding IndirectionHandler must be choosen as well |
| # |
| #ProxyFactoryClass=org.apache.ojb.broker.core.proxy.ProxyFactoryCGLIBImpl |
| ProxyFactoryClass=org.apache.ojb.broker.core.proxy.ProxyFactoryJDKImpl |
| # |
| # The IndirectionHandlerClass entry defines the class to be used by OJB's proxies to |
| # handle method invocations |
| # |
| #IndirectionHandlerClass=org.apache.ojb.broker.core.proxy.IndirectionHandlerCGLIBImpl |
| IndirectionHandlerClass=org.apache.ojb.broker.core.proxy.IndirectionHandlerJDKImpl |
| # |
| #---------------------------------------------------------------------------------------- |
| # ListProxy |
| #---------------------------------------------------------------------------------------- |
| # The ListProxyClass entry defines the proxy class to be used for collections that |
| # implement the java.util.List interface. |
| # |
| ListProxyClass=org.apache.ojb.broker.core.proxy.ListProxyDefaultImpl |
| # |
| #---------------------------------------------------------------------------------------- |
| # SetProxy |
| #---------------------------------------------------------------------------------------- |
| # The SetProxyClass entry defines the proxy class to be used for collections that |
| # implement the java.util.Set interface. |
| # |
| SetProxyClass=org.apache.ojb.broker.core.proxy.SetProxyDefaultImpl |
| # |
| #---------------------------------------------------------------------------------------- |
| # CollectionProxy |
| #---------------------------------------------------------------------------------------- |
| # The CollectionProxyClass entry defines the proxy class to be used for collections that |
| # do not implement java.util.List or java.util.Set. |
| # |
| CollectionProxyClass=org.apache.ojb.broker.core.proxy.CollectionProxyDefaultImpl |
| # |
| #---------------------------------------------------------------------------------------- |
| # StatementManager |
| #---------------------------------------------------------------------------------------- |
| # The StatementManagerClass entry defines the StatementManager implemementation to be used |
| StatementManagerClass=org.apache.ojb.broker.accesslayer.StatementManager |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # StatementsForClass |
| #---------------------------------------------------------------------------------------- |
| # The StatementsForClassClass entry defines the StatementsForClass implemementation to be used |
| # to implement cached statements. |
| StatementsForClassClass=org.apache.ojb.broker.accesslayer.StatementsForClassImpl |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # JdbcAccess |
| #---------------------------------------------------------------------------------------- |
| # The JdbcAccessClass entry defines the JdbcAccess implemementation to be used |
| JdbcAccessClass=org.apache.ojb.broker.accesslayer.JdbcAccessImpl |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # RowReader |
| #---------------------------------------------------------------------------------------- |
| # Set the standard RowReader implementation. It is also possible to specify the |
| # RowReader on class-descriptor level. |
| RowReaderDefaultClass=org.apache.ojb.broker.accesslayer.RowReaderDefaultImpl |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # Object cache |
| #---------------------------------------------------------------------------------------- |
| # NOTE: ObjectCacheClass declaration in OJB.properties file was removed (since OJB 1.0.2). |
| # The concrete ObjectCache implementation has to specified in the repository file using |
| # the 'object-cache' element. See documentation for more detailed info. |
| # |
| # This property is only relevant if the per class-descriptor object-cache |
| # declaration was used in conjunction with metadata runtime changes. |
| # If set 'flase' the class name of the object is used |
| # to find a per class ObjectCache implementation. |
| # If set 'true' the ObjectCacheDescriptor instance is used as key to |
| # find a per class ObjectCache, this enables to use different ObjectCache |
| # instances for the same class. |
| descriptorBasedCaches=false |
| # |
| # NOTE: CacheFilters declaration was removed (since OJB 1.0.2). To exclude |
| # object of whole packages from being cache use a specific property in |
| # cache declaration - see caching guide in reference docs. |
| #---------------------------------------------------------------------------------------- |
| # Locking |
| #---------------------------------------------------------------------------------------- |
| # The 'LockManagerClass' specify the internal used LockManager implementation. |
| # If OJB is running in distributed environment it is recommended to use the remote |
| # lock manager. It guarantees to provide Lockmanagement across multiple JVM's. |
| # |
| # The deprecated odmg locking implementation. Needs enabled 'LockMapClass' too. |
| #@deprecated LockManagerClass=org.apache.ojb.odmg.locking.LockManagerDefaultImpl |
| # A servlet based lock implementation for distributed environments, needs enabled |
| # property 'LockServletUrl' too. |
| #LockManagerClass=org.apache.ojb.broker.locking.LockManagerRemoteImpl |
| # Lock manager implementation using apache's commons-transaction locking api |
| #LockManagerClass=org.apache.ojb.broker.locking.LockManagerCommonsImpl |
| LockManagerClass=org.apache.ojb.broker.locking.LockManagerInMemoryImpl |
| # |
| # The LockServletUrl entry points to the Lockserver servlet. |
| # This Servlet is addressed by all distributed JVMs if the RemoteLockMapImpl |
| # is used. |
| #LockServletUrl=http://127.0.0.1:8080/ojb-lockserver |
| # |
| # The LockTimeout entry defines the maximum time in milliseconds |
| # that a lock may be hold. Defaults to 60000 = 1 minute |
| LockTimeout=60000 |
| # |
| # |
| # ------ deprecated ------ |
| # 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 LockMapRemoteImpl. It guarantees to provide |
| # Lockmanagement across multiple JVMs. |
| # This Implemenation relies on a Servlet based Lockserver. To use it you have to |
| # deploy the ojb-lockserver.war into a Servlet engine. |
| # and you have to set the Property LockServletUrl to point to this servlet. |
| # (see LockServletUrl section below). |
| # 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 LockMapInMemoryImpl. Using it will result |
| # in a large performance gain. |
| # These settings are deprecated, only needed in conjunction with the old odmg 'LockManagerClass' |
| # @deprecated LockMapClass=org.apache.ojb.odmg.locking.RemoteLockMapImpl |
| # @deprecated LockMapClass=org.apache.ojb.odmg.locking.InMemoryLockMapImpl |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # OQL / SQL settings |
| #---------------------------------------------------------------------------------------- |
| # The OqlCollectionClass entry defines the collection type returned |
| # from OQL queries. By default this value is set to a List. |
| # This will be good for most situations. If you need the additional features of |
| # DList (DList itself is persistable, support of predicate) comment in the DList |
| # implementation. See also section 'ODMG settings' (DListClass entry). |
| # 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.broker.util.collections.ManageableArrayList |
| OqlCollectionClass=org.apache.ojb.odmg.collections.DListImpl |
| # OqlCollectionClass=org.apache.ojb.broker.util.collections.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 |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # ODMG-api settings |
| #---------------------------------------------------------------------------------------- |
| # Specify the used base class for ODMG API |
| # - ImplementationDefaultImpl is the default class |
| # - ImplementationJTAImpl is for use in managed environments like J2EE conform |
| # Application Server |
| # |
| ImplementationClass=org.apache.ojb.odmg.ImplementationImpl |
| #ImplementationClass=org.apache.ojb.odmg.ImplementationJTAImpl |
| # |
| # Specify the used tx handling. |
| # - LocalTxManager use if you want the transaction to be associated by a thread |
| # - JTATxManager use if you want the transaction to be associated via the Transaction |
| # manager that is in your application server. |
| # |
| OJBTxManagerClass=org.apache.ojb.odmg.LocalTxManager |
| #OJBTxManagerClass=org.apache.ojb.odmg.JTATxManager |
| # |
| # |
| # The ImplicitLocking entry defines if implicit lock acquisition is |
| # to be used. If set to 'true' OJB implicitly locks objects to ODMG |
| # transactions after performing OQL queries. |
| # Also 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, lookup objects and there is also no recursive locking. |
| # This setting can be changed at runtime using OJB's ODMG extensions. |
| 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 allways results in implicit read-locks |
| # on all associated objects (if 'implicit locking' is enabled). |
| # This setting can be changed at runtime using OJB's ODMG extensions. |
| #LockAssociations=READ |
| LockAssociations=WRITE |
| # |
| # Enable/Disable OJB's persistent object ordering algorithm on commit |
| # of a transaction. If enabled OJB try to calculate a valid order for |
| # all new/modified objects (and referenced objects). |
| # If the used databases support 'deferred checks' it's recommended to use this |
| # feature and to disable OJB's object ordering. |
| # This setting can be changed at runtime using OJB's ODMG extensions. |
| Ordering=true |
| # |
| # |
| # Used ODMG collection implementation classes |
| # (e.g. when do a Implementation#newDlist() call) |
| # |
| # org.odmg.DList implementation class |
| DListClass=org.apache.ojb.odmg.collections.DListImpl |
| # |
| # org.odmg.DArray implementation class |
| DArrayClass=org.apache.ojb.odmg.collections.DListImpl |
| # |
| # org.odmg.DMap implementation class |
| DMapClass=org.apache.ojb.odmg.collections.DMapImpl |
| # |
| # org.odmg.DBag implementation class |
| DBagClass=org.apache.ojb.odmg.collections.DBagImpl |
| # |
| # org.odmg.DSet implementation class |
| DSetClass=org.apache.ojb.odmg.collections.DSetImpl |
| # |
| # |
| # @deprecated property for backward compatibility. |
| # If set 'true' the behavior of method |
| # ImplementationImpl#setImplicitLocking(...) will be the same as |
| # in OJB <=1.0.3 (set the implicit locking behavior of the current used transaction) |
| # and disable the new possibility of global 'implicit locking' |
| # setting at runtime with ImplementationExt#setImplicitLocking. |
| # This is only for backward compatibility and will |
| # be removed at a later date. |
| ImplicitLockingBackward=false |
| #---------------------------------------------------------------------------------------- |
| # Meta data / mapping settings |
| #---------------------------------------------------------------------------------------- |
| # The PersistentFieldClass property defines the implementation class |
| # for PersistentField attributes used in the OJB MetaData layer. |
| # By default the best performing attribute/refection based implementation |
| # is selected (PersistentFieldDirectAccessImpl). |
| # |
| # - PersistentFieldDirectAccessImpl |
| # is a high-speed version of the access strategies. |
| # It does not cooperate with an AccessController, |
| # but accesses the fields directly. Persistent |
| # attributes don't need getters and setters |
| # and don't have to be declared public or protected |
| # - PersistentFieldPrivilegedImpl |
| # Same as above, but does cooperate with AccessController and do not |
| # suppress the java language access check (but is slow compared with direct access). |
| # - PersistentFieldIntrospectorImpl |
| # uses JavaBeans compliant calls only to access persistent attributes. |
| # No Reflection is needed. But for each attribute xxx there must be |
| # public getXxx() and setXxx() methods. |
| # - PersistentFieldDynaBeanAccessImpl |
| # implementation used to access a property from a |
| # org.apache.commons.beanutils.DynaBean. |
| # - PersistentFieldAutoProxyImpl |
| # for each field determines upon first access how to access this particular field |
| # (directly, as a bean, as a dyna bean) and then uses that strategy |
| # |
| PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldDirectImpl |
| #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldPrivilegedImpl |
| #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldIntrospectorImpl |
| #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldDynaBeanImpl |
| #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldAutoProxyImpl |
| #(DynaBean implementation does not support nested fields) |
| # |
| #---------------------------------------------------------------------------------------- |
| # 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.TracingInterceptor |
| # |
| #---------------------------------------------------------------------------------------- |
| # Transaction Management and assocation |
| #---------------------------------------------------------------------------------------- |
| # (optional, only used when OJB runs within managed environments) |
| # To praticipate in JTA transaction OJB needs access to the underlying transaction manager. |
| # 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.broker.transaction.tm.JBossTransactionManagerFactory |
| # Weblogic Transaction Manager Factory |
| #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.WeblogicTransactionManagerFactory |
| # WebSphere transaction manager factory |
| #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.WebSphereTransactionManagerFactory |
| # Orion transaction manager factory |
| #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.OrionTransactionManagerFactory |
| # SunOne transaction manager factory |
| #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.SunOneTransactionManagerFactory |
| # JOnAs transaction manager factory |
| #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.JOnASTransactionManagerFactory |
| # |
| # |
| #---------------------------------------------------------------------------------------- |
| # Logging settings are now in their own file, OJB-logging.properties |
| #---------------------------------------------------------------------------------------- |
| #---------------------------------------------------------------------------------------- |
| # End of OJB.properties file |
| #---------------------------------------------------------------------------------------- |
