| 1 | #<!-- |
|---|
| 2 | #/* Copyright 2002-2004 The Apache Software Foundation |
|---|
| 3 | # * |
|---|
| 4 | # * Licensed under the Apache License, Version 2.0 (the "License"); |
|---|
| 5 | # * you may not use this file except in compliance with the License. |
|---|
| 6 | # * You may obtain a copy of the License at |
|---|
| 7 | # * |
|---|
| 8 | # * http://www.apache.org/licenses/LICENSE-2.0 |
|---|
| 9 | # * |
|---|
| 10 | # * Unless required by applicable law or agreed to in writing, software |
|---|
| 11 | # * distributed under the License is distributed on an "AS IS" BASIS, |
|---|
| 12 | # * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|---|
| 13 | # * See the License for the specific language governing permissions and |
|---|
| 14 | # * limitations under the License. |
|---|
| 15 | # */ |
|---|
| 16 | #--> |
|---|
| 17 | # OJB.properties -- configuration of the OJB runtime environment |
|---|
| 18 | # Version: 1.0 |
|---|
| 19 | # (c) 2001, 2002, 2003 Apache Software Foundation |
|---|
| 20 | # Author: Thomas Mahler and many others |
|---|
| 21 | # @version $Id: OJB.properties 365059 2005-10-12 00:06:49Z arminw $ |
|---|
| 22 | # |
|---|
| 23 | #---------------------------------------------------------------------------------------- |
|---|
| 24 | # repository file settings |
|---|
| 25 | #---------------------------------------------------------------------------------------- |
|---|
| 26 | # The repositoryFile entry tells OJB to use this file as as its standard mapping |
|---|
| 27 | # repository. The file is looked up from the classpath. |
|---|
| 28 | # |
|---|
| 29 | repositoryFile=repository.xml |
|---|
| 30 | # |
|---|
| 31 | # If the useSerializedRepository entry is set to true, OJB tries to load a |
|---|
| 32 | # serialized version of the repository for performance reasons. |
|---|
| 33 | # if set to false, OJB always loads the xml file. |
|---|
| 34 | # Setting this flag to true will accelerate the startup sequence of OJB. |
|---|
| 35 | # If set to true changes to the repository.xml file will only be detected |
|---|
| 36 | # after maually deleting the repository.xml.serialized file. |
|---|
| 37 | useSerializedRepository=false |
|---|
| 38 | # |
|---|
| 39 | # If Repository serialization is used the entry serializedRepositoryPath defines the |
|---|
| 40 | # directory where the Repository is written to and read from. |
|---|
| 41 | # this entry is used only when the useSerializedRepository flag is set to true |
|---|
| 42 | # |
|---|
| 43 | serializedRepositoryPath=. |
|---|
| 44 | # |
|---|
| 45 | #---------------------------------------------------------------------------------------- |
|---|
| 46 | # PersistenceBrokerFactory / PersistenceBroker |
|---|
| 47 | #---------------------------------------------------------------------------------------- |
|---|
| 48 | # The PersistenceBrokerFactoryClass entry decides which concrete |
|---|
| 49 | # PersistenceBrokerFactory implemention is to be used. |
|---|
| 50 | PersistenceBrokerFactoryClass=org.apache.ojb.broker.core.PersistenceBrokerFactoryDefaultImpl |
|---|
| 51 | # If in managed environment *only* the PB-api was used it's recommended to use this factory |
|---|
| 52 | # to enable the PersistenceBroker instances to participate in the JTA transaction. This makes |
|---|
| 53 | # e.g. PBStateListener work properly in managed environments. |
|---|
| 54 | #PersistenceBrokerFactoryClass=org.apache.ojb.broker.core.PersistenceBrokerFactorySyncImpl |
|---|
| 55 | # |
|---|
| 56 | # |
|---|
| 57 | # The PersistenceBrokerClass entry decides which concrete PersistenceBroker |
|---|
| 58 | # implementation is to be served by the PersistenceBrokerFactory. |
|---|
| 59 | # This is the singlevm implementation: |
|---|
| 60 | PersistenceBrokerClass=org.apache.ojb.broker.core.PersistenceBrokerImpl |
|---|
| 61 | # |
|---|
| 62 | # This is an implementation that uses Prevayler (prevayler.sf.net) as the persistent storage. |
|---|
| 63 | # Using this implementation OJB works as a simple OODBMS |
|---|
| 64 | #PersistenceBrokerClass=org.apache.ojb.broker.prevayler.PBPrevaylerImpl |
|---|
| 65 | # |
|---|
| 66 | # |
|---|
| 67 | # This setting can be helpful during development if the PersistenceBroker transaction |
|---|
| 68 | # demarcation was used (this is true in most cases). If set 'true' on PB#store(...) |
|---|
| 69 | # and PB#delete(...) methods calls OJB check for active PB-tx and if no active tx is |
|---|
| 70 | # found a error is logged. This can help to avoid store/delete calls without a running |
|---|
| 71 | # PB-tx while development. Default setting is 'false'. (Note: When using OJB in a managed |
|---|
| 72 | # environment *without* OJB-caching, it's valid to use store/delete calls without a running PB-tx) |
|---|
| 73 | TxCheck=false |
|---|
| 74 | # |
|---|
| 75 | #---------------------------------------------------------------------------------------- |
|---|
| 76 | # PersistenceBroker pool |
|---|
| 77 | #---------------------------------------------------------------------------------------- |
|---|
| 78 | # PersistenceBroker pool configuration |
|---|
| 79 | # This pool uses the jakarta-commons-pool api. |
|---|
| 80 | # There you can find things described in detail. |
|---|
| 81 | # |
|---|
| 82 | # maximum number of brokers that can be borrowed from the |
|---|
| 83 | # pool at one time. When non-positive, there is no limit. |
|---|
| 84 | maxActive=100 |
|---|
| 85 | # |
|---|
| 86 | # controls the maximum number of brokers that can sit idle in the |
|---|
| 87 | # pool (per key) at any time. When non-positive, there is no limit |
|---|
| 88 | maxIdle=-1 |
|---|
| 89 | # |
|---|
| 90 | # max time block to get broker instance from pool, after that exception is thrown. |
|---|
| 91 | # When non-positive, block till last judgement |
|---|
| 92 | maxWait=2000 |
|---|
| 93 | # |
|---|
| 94 | # indicates how long the eviction thread should sleep before "runs" of examining |
|---|
| 95 | # idle objects. When non-positive, no eviction thread will be launched. |
|---|
| 96 | timeBetweenEvictionRunsMillis=-1 |
|---|
| 97 | # |
|---|
| 98 | # specifies the minimum amount of time that an broker may sit idle |
|---|
| 99 | # in the pool before it is eligable for eviction due to idle time. |
|---|
| 100 | # When non-positive, no object will be dropped from the pool due |
|---|
| 101 | # to idle time alone (depends on timeBetweenEvictionRunsMillis > 0) |
|---|
| 102 | minEvictableIdleTimeMillis=1000000 |
|---|
| 103 | # |
|---|
| 104 | # specifies the behaviour of the pool when broker capacity is |
|---|
| 105 | # exhausted (see maxActive above) |
|---|
| 106 | # 0 - fail |
|---|
| 107 | # 1 - block |
|---|
| 108 | # 2 - grow |
|---|
| 109 | whenExhaustedAction=0 |
|---|
| 110 | # |
|---|
| 111 | # |
|---|
| 112 | #---------------------------------------------------------------------------------------- |
|---|
| 113 | # ConnectionFactory / Default ConnectionPool |
|---|
| 114 | #---------------------------------------------------------------------------------------- |
|---|
| 115 | # The ConnectionFactoryClass entry determines which kind of ConnectionFactory |
|---|
| 116 | # is to be used within org.apache.ojb as connection factory. |
|---|
| 117 | # A ConnectionFactory is responsible for creating |
|---|
| 118 | # JDBC Connections. Current version ships four implementations: |
|---|
| 119 | # 2. ConnectionFactoryPooledImpl |
|---|
| 120 | # This implementation supports connection pooling. |
|---|
| 121 | # 3. ConnectionFactoryDBCPImpl |
|---|
| 122 | # Using the jakarta-DBCP api for connection management, support |
|---|
| 123 | # connection- and prepared statement-pooling, abandoned connection handling. |
|---|
| 124 | # 4. ConnectionFactoryManagedImpl |
|---|
| 125 | # Connection factory for use within managed environments - e.g. JBoss. |
|---|
| 126 | # Every obtained DataSource was wrapped within OJB (and ignore |
|---|
| 127 | # e.g. con.commit() calls within OJB). |
|---|
| 128 | # |
|---|
| 129 | # 1. ConnectionFactoryNotPooledImpl |
|---|
| 130 | # No pooling, no playing around. |
|---|
| 131 | # Every connection request returns a new connection, |
|---|
| 132 | # every connection release close the connection. |
|---|
| 133 | # 2. ConnectionFactoryPooledImpl |
|---|
| 134 | # This implementation supports connection pooling. |
|---|
| 135 | # 3. ConnectionFactoryDBCPImpl |
|---|
| 136 | # Using the jakarta-DBCP api for connection management, support |
|---|
| 137 | # connection- and prepared statement-pooling, abandoned connection handling. |
|---|
| 138 | # 4. ConnectionFactoryManagedImpl |
|---|
| 139 | # Connection factory for use within managed environments - e.g. JBoss. |
|---|
| 140 | # Every obtained DataSource was wrapped within OJB (and ignore |
|---|
| 141 | # e.g. con.commit() calls within OJB). |
|---|
| 142 | # Use this implementation e.g if you use Datasources from an application server. |
|---|
| 143 | # |
|---|
| 144 | # Use the OJB performance tests to decide, which implementation is best for you. |
|---|
| 145 | # The proper way of obtaining a connection is configured in |
|---|
| 146 | # JDBCConnectionDescriptor entries in the repository.xml file. |
|---|
| 147 | # If want a more fine grained control of each connection pool used by OJB, |
|---|
| 148 | # take a look at the repository.dtd, there was a possibility to override |
|---|
| 149 | # this default connection factory entry in each JDBCConnectionDescriptor. |
|---|
| 150 | # |
|---|
| 151 | ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryPooledImpl |
|---|
| 152 | #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryNotPooledImpl |
|---|
| 153 | #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryDBCPImpl |
|---|
| 154 | # Only needed when using OJB 1.0.3 or earlier in managed environments. Since version |
|---|
| 155 | # 1.0.4 OJB detects datasources from managed environments automatically. |
|---|
| 156 | #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryManagedImpl |
|---|
| 157 | # |
|---|
| 158 | # |
|---|
| 159 | #---------------------------------------------------------------------------------------- |
|---|
| 160 | # ConnectionManager |
|---|
| 161 | #---------------------------------------------------------------------------------------- |
|---|
| 162 | # The ConnectionManagerClass entry defines the ConnectionManager implemementation to be used |
|---|
| 163 | ConnectionManagerClass=org.apache.ojb.broker.accesslayer.ConnectionManagerImpl |
|---|
| 164 | # |
|---|
| 165 | # |
|---|
| 166 | #---------------------------------------------------------------------------------------- |
|---|
| 167 | # SqlGenerator |
|---|
| 168 | #---------------------------------------------------------------------------------------- |
|---|
| 169 | # The SqlGeneratorClass entry defines the SqlGenerator implemementation to be used |
|---|
| 170 | SqlGeneratorClass=org.apache.ojb.broker.accesslayer.sql.SqlGeneratorDefaultImpl |
|---|
| 171 | # |
|---|
| 172 | # |
|---|
| 173 | #---------------------------------------------------------------------------------------- |
|---|
| 174 | # ProxyFactory and IndirectionHandler |
|---|
| 175 | #---------------------------------------------------------------------------------------- |
|---|
| 176 | # The ProxyFactoryClass entry defines which ProxyFactory implementation is to be used. |
|---|
| 177 | # By default, a 1.0 compatiable, JDK-based version is used. However, a the CGLIB based entry |
|---|
| 178 | # is available. |
|---|
| 179 | # |
|---|
| 180 | # - ProxyFactoryCGLIBImpl: Refernece proxies are generated using bytecode manipulation |
|---|
| 181 | # from the CGLIB library. Any class can become a dynamic proxy, and not just ones |
|---|
| 182 | # that implement an interface. |
|---|
| 183 | # - ProxyFactoryJDKImpl: OJB 1.0 compatiable Proxy implementation. Proxies in this method |
|---|
| 184 | # can only be generated from classes that implement an interface, and the generated |
|---|
| 185 | # Proxy will implement all methods of that interface. |
|---|
| 186 | # |
|---|
| 187 | # NOTE: The appropriate cooresponding IndirectionHandler must be choosen as well |
|---|
| 188 | # |
|---|
| 189 | #ProxyFactoryClass=org.apache.ojb.broker.core.proxy.ProxyFactoryCGLIBImpl |
|---|
| 190 | ProxyFactoryClass=org.apache.ojb.broker.core.proxy.ProxyFactoryJDKImpl |
|---|
| 191 | # |
|---|
| 192 | # The IndirectionHandlerClass entry defines the class to be used by OJB's proxies to |
|---|
| 193 | # handle method invocations |
|---|
| 194 | # |
|---|
| 195 | #IndirectionHandlerClass=org.apache.ojb.broker.core.proxy.IndirectionHandlerCGLIBImpl |
|---|
| 196 | IndirectionHandlerClass=org.apache.ojb.broker.core.proxy.IndirectionHandlerJDKImpl |
|---|
| 197 | # |
|---|
| 198 | #---------------------------------------------------------------------------------------- |
|---|
| 199 | # ListProxy |
|---|
| 200 | #---------------------------------------------------------------------------------------- |
|---|
| 201 | # The ListProxyClass entry defines the proxy class to be used for collections that |
|---|
| 202 | # implement the java.util.List interface. |
|---|
| 203 | # |
|---|
| 204 | ListProxyClass=org.apache.ojb.broker.core.proxy.ListProxyDefaultImpl |
|---|
| 205 | # |
|---|
| 206 | #---------------------------------------------------------------------------------------- |
|---|
| 207 | # SetProxy |
|---|
| 208 | #---------------------------------------------------------------------------------------- |
|---|
| 209 | # The SetProxyClass entry defines the proxy class to be used for collections that |
|---|
| 210 | # implement the java.util.Set interface. |
|---|
| 211 | # |
|---|
| 212 | SetProxyClass=org.apache.ojb.broker.core.proxy.SetProxyDefaultImpl |
|---|
| 213 | # |
|---|
| 214 | #---------------------------------------------------------------------------------------- |
|---|
| 215 | # CollectionProxy |
|---|
| 216 | #---------------------------------------------------------------------------------------- |
|---|
| 217 | # The CollectionProxyClass entry defines the proxy class to be used for collections that |
|---|
| 218 | # do not implement java.util.List or java.util.Set. |
|---|
| 219 | # |
|---|
| 220 | CollectionProxyClass=org.apache.ojb.broker.core.proxy.CollectionProxyDefaultImpl |
|---|
| 221 | # |
|---|
| 222 | #---------------------------------------------------------------------------------------- |
|---|
| 223 | # StatementManager |
|---|
| 224 | #---------------------------------------------------------------------------------------- |
|---|
| 225 | # The StatementManagerClass entry defines the StatementManager implemementation to be used |
|---|
| 226 | StatementManagerClass=org.apache.ojb.broker.accesslayer.StatementManager |
|---|
| 227 | # |
|---|
| 228 | # |
|---|
| 229 | #---------------------------------------------------------------------------------------- |
|---|
| 230 | # StatementsForClass |
|---|
| 231 | #---------------------------------------------------------------------------------------- |
|---|
| 232 | # The StatementsForClassClass entry defines the StatementsForClass implemementation to be used |
|---|
| 233 | # to implement cached statements. |
|---|
| 234 | StatementsForClassClass=org.apache.ojb.broker.accesslayer.StatementsForClassImpl |
|---|
| 235 | # |
|---|
| 236 | # |
|---|
| 237 | #---------------------------------------------------------------------------------------- |
|---|
| 238 | # JdbcAccess |
|---|
| 239 | #---------------------------------------------------------------------------------------- |
|---|
| 240 | # The JdbcAccessClass entry defines the JdbcAccess implemementation to be used |
|---|
| 241 | JdbcAccessClass=org.apache.ojb.broker.accesslayer.JdbcAccessImpl |
|---|
| 242 | # |
|---|
| 243 | # |
|---|
| 244 | #---------------------------------------------------------------------------------------- |
|---|
| 245 | # RowReader |
|---|
| 246 | #---------------------------------------------------------------------------------------- |
|---|
| 247 | # Set the standard RowReader implementation. It is also possible to specify the |
|---|
| 248 | # RowReader on class-descriptor level. |
|---|
| 249 | RowReaderDefaultClass=org.apache.ojb.broker.accesslayer.RowReaderDefaultImpl |
|---|
| 250 | # |
|---|
| 251 | # |
|---|
| 252 | #---------------------------------------------------------------------------------------- |
|---|
| 253 | # Object cache |
|---|
| 254 | #---------------------------------------------------------------------------------------- |
|---|
| 255 | # NOTE: ObjectCacheClass declaration in OJB.properties file was removed (since OJB 1.0.2). |
|---|
| 256 | # The concrete ObjectCache implementation has to specified in the repository file using |
|---|
| 257 | # the 'object-cache' element. See documentation for more detailed info. |
|---|
| 258 | # |
|---|
| 259 | # This property is only relevant if the per class-descriptor object-cache |
|---|
| 260 | # declaration was used in conjunction with metadata runtime changes. |
|---|
| 261 | # If set 'flase' the class name of the object is used |
|---|
| 262 | # to find a per class ObjectCache implementation. |
|---|
| 263 | # If set 'true' the ObjectCacheDescriptor instance is used as key to |
|---|
| 264 | # find a per class ObjectCache, this enables to use different ObjectCache |
|---|
| 265 | # instances for the same class. |
|---|
| 266 | descriptorBasedCaches=false |
|---|
| 267 | # |
|---|
| 268 | # NOTE: CacheFilters declaration was removed (since OJB 1.0.2). To exclude |
|---|
| 269 | # object of whole packages from being cache use a specific property in |
|---|
| 270 | # cache declaration - see caching guide in reference docs. |
|---|
| 271 | #---------------------------------------------------------------------------------------- |
|---|
| 272 | # Locking |
|---|
| 273 | #---------------------------------------------------------------------------------------- |
|---|
| 274 | # The 'LockManagerClass' specify the internal used LockManager implementation. |
|---|
| 275 | # If OJB is running in distributed environment it is recommended to use the remote |
|---|
| 276 | # lock manager. It guarantees to provide Lockmanagement across multiple JVM's. |
|---|
| 277 | # |
|---|
| 278 | # The deprecated odmg locking implementation. Needs enabled 'LockMapClass' too. |
|---|
| 279 | #@deprecated LockManagerClass=org.apache.ojb.odmg.locking.LockManagerDefaultImpl |
|---|
| 280 | # A servlet based lock implementation for distributed environments, needs enabled |
|---|
| 281 | # property 'LockServletUrl' too. |
|---|
| 282 | #LockManagerClass=org.apache.ojb.broker.locking.LockManagerRemoteImpl |
|---|
| 283 | # Lock manager implementation using apache's commons-transaction locking api |
|---|
| 284 | #LockManagerClass=org.apache.ojb.broker.locking.LockManagerCommonsImpl |
|---|
| 285 | LockManagerClass=org.apache.ojb.broker.locking.LockManagerInMemoryImpl |
|---|
| 286 | # |
|---|
| 287 | # The LockServletUrl entry points to the Lockserver servlet. |
|---|
| 288 | # This Servlet is addressed by all distributed JVMs if the RemoteLockMapImpl |
|---|
| 289 | # is used. |
|---|
| 290 | #LockServletUrl=http://127.0.0.1:8080/ojb-lockserver |
|---|
| 291 | # |
|---|
| 292 | # The LockTimeout entry defines the maximum time in milliseconds |
|---|
| 293 | # that a lock may be hold. Defaults to 60000 = 1 minute |
|---|
| 294 | LockTimeout=60000 |
|---|
| 295 | # |
|---|
| 296 | # |
|---|
| 297 | # ------ deprecated ------ |
|---|
| 298 | # The LockMapClass entry tells OJB which concrete LockMap |
|---|
| 299 | # implementation is to be used. |
|---|
| 300 | # If OJB is running on multiple concurrent clients it is recommended |
|---|
| 301 | # to use the LockMapRemoteImpl. It guarantees to provide |
|---|
| 302 | # Lockmanagement across multiple JVMs. |
|---|
| 303 | # This Implemenation relies on a Servlet based Lockserver. To use it you have to |
|---|
| 304 | # deploy the ojb-lockserver.war into a Servlet engine. |
|---|
| 305 | # and you have to set the Property LockServletUrl to point to this servlet. |
|---|
| 306 | # (see LockServletUrl section below). |
|---|
| 307 | # If OJB is running in a single JVM (e.g. in a desktop app, or in a servlet |
|---|
| 308 | # engine) it is save to use the LockMapInMemoryImpl. Using it will result |
|---|
| 309 | # in a large performance gain. |
|---|
| 310 | # These settings are deprecated, only needed in conjunction with the old odmg 'LockManagerClass' |
|---|
| 311 | # @deprecated LockMapClass=org.apache.ojb.odmg.locking.RemoteLockMapImpl |
|---|
| 312 | # @deprecated LockMapClass=org.apache.ojb.odmg.locking.InMemoryLockMapImpl |
|---|
| 313 | # |
|---|
| 314 | # |
|---|
| 315 | #---------------------------------------------------------------------------------------- |
|---|
| 316 | # OQL / SQL settings |
|---|
| 317 | #---------------------------------------------------------------------------------------- |
|---|
| 318 | # The OqlCollectionClass entry defines the collection type returned |
|---|
| 319 | # from OQL queries. By default this value is set to a List. |
|---|
| 320 | # This will be good for most situations. If you need the additional features of |
|---|
| 321 | # DList (DList itself is persistable, support of predicate) comment in the DList |
|---|
| 322 | # implementation. See also section 'ODMG settings' (DListClass entry). |
|---|
| 323 | # Using DLists for large resultsets may be bad for application performance. |
|---|
| 324 | # For these scenarios you can use ArrayLists or Vectors. |
|---|
| 325 | # Important note: the collections class to be used MUST implement the |
|---|
| 326 | # interface 'org.apache.ojb.broker.ManageableCollection'. |
|---|
| 327 | # |
|---|
| 328 | OqlCollectionClass=org.apache.ojb.broker.util.collections.ManageableArrayList |
|---|
| 329 | # OqlCollectionClass=org.apache.ojb.odmg.collections.DListImpl |
|---|
| 330 | # OqlCollectionClass=org.apache.ojb.broker.util.collections.ManageableVector |
|---|
| 331 | # |
|---|
| 332 | # The SqlInLimit entry limits the number of values in IN-sql statement, |
|---|
| 333 | # -1 for no limits. This hint is used in Criteria. |
|---|
| 334 | SqlInLimit=200 |
|---|
| 335 | # |
|---|
| 336 | # |
|---|
| 337 | #---------------------------------------------------------------------------------------- |
|---|
| 338 | # ODMG-api settings |
|---|
| 339 | #---------------------------------------------------------------------------------------- |
|---|
| 340 | # Specify the used base class for ODMG API |
|---|
| 341 | # - ImplementationDefaultImpl is the default class |
|---|
| 342 | # - ImplementationJTAImpl is for use in managed environments like J2EE conform |
|---|
| 343 | # Application Server |
|---|
| 344 | # |
|---|
| 345 | ImplementationClass=org.apache.ojb.odmg.ImplementationImpl |
|---|
| 346 | #ImplementationClass=org.apache.ojb.odmg.ImplementationJTAImpl |
|---|
| 347 | # |
|---|
| 348 | # Specify the used tx handling. |
|---|
| 349 | # - LocalTxManager use if you want the transaction to be associated by a thread |
|---|
| 350 | # - JTATxManager use if you want the transaction to be associated via the Transaction |
|---|
| 351 | # manager that is in your application server. |
|---|
| 352 | # |
|---|
| 353 | OJBTxManagerClass=org.apache.ojb.odmg.LocalTxManager |
|---|
| 354 | #OJBTxManagerClass=org.apache.ojb.odmg.JTATxManager |
|---|
| 355 | # |
|---|
| 356 | # |
|---|
| 357 | # The ImplicitLocking entry defines if implicit lock acquisition is |
|---|
| 358 | # to be used. If set to 'true' OJB implicitly locks objects to ODMG |
|---|
| 359 | # transactions after performing OQL queries. |
|---|
| 360 | # Also if implicit locking is used locking objects is recursive, that is |
|---|
| 361 | # associated objects are also locked. |
|---|
| 362 | # If ImplicitLocking is set to 'false', no locks are obtained in OQL |
|---|
| 363 | # queries, lookup objects and there is also no recursive locking. |
|---|
| 364 | # This setting can be changed at runtime using OJB's ODMG extensions. |
|---|
| 365 | # ImplicitLocking=true |
|---|
| 366 | |
|---|
| 367 | # Set to false since otherwise performance in UI intensive operations suffers |
|---|
| 368 | ImplicitLocking=false |
|---|
| 369 | # |
|---|
| 370 | # The LockAssociations entry defines the behaviour for the OJB |
|---|
| 371 | # implicit locking feature. If set to WRITE (default) acquiring a write- |
|---|
| 372 | # lock on a given object x implies write locks on all objects associated |
|---|
| 373 | # to x. If set to READ implicit read-locks are acquired. |
|---|
| 374 | # Acquiring a read-lock on x allways results in implicit read-locks |
|---|
| 375 | # on all associated objects (if 'implicit locking' is enabled). |
|---|
| 376 | # This setting can be changed at runtime using OJB's ODMG extensions. |
|---|
| 377 | #LockAssociations=READ |
|---|
| 378 | LockAssociations=WRITE |
|---|
| 379 | # |
|---|
| 380 | # Enable/Disable OJB's persistent object ordering algorithm on commit |
|---|
| 381 | # of a transaction. If enabled OJB try to calculate a valid order for |
|---|
| 382 | # all new/modified objects (and referenced objects). |
|---|
| 383 | # If the used databases support 'deferred checks' it's recommended to use this |
|---|
| 384 | # feature and to disable OJB's object ordering. |
|---|
| 385 | # This setting can be changed at runtime using OJB's ODMG extensions. |
|---|
| 386 | Ordering=true |
|---|
| 387 | # |
|---|
| 388 | # |
|---|
| 389 | # Used ODMG collection implementation classes |
|---|
| 390 | # (e.g. when do a Implementation#newDlist() call) |
|---|
| 391 | # |
|---|
| 392 | # org.odmg.DList implementation class |
|---|
| 393 | DListClass=org.apache.ojb.odmg.collections.DListImpl |
|---|
| 394 | # |
|---|
| 395 | # org.odmg.DArray implementation class |
|---|
| 396 | DArrayClass=org.apache.ojb.odmg.collections.DListImpl |
|---|
| 397 | # |
|---|
| 398 | # org.odmg.DMap implementation class |
|---|
| 399 | DMapClass=org.apache.ojb.odmg.collections.DMapImpl |
|---|
| 400 | # |
|---|
| 401 | # org.odmg.DBag implementation class |
|---|
| 402 | DBagClass=org.apache.ojb.odmg.collections.DBagImpl |
|---|
| 403 | # |
|---|
| 404 | # org.odmg.DSet implementation class |
|---|
| 405 | DSetClass=org.apache.ojb.odmg.collections.DSetImpl |
|---|
| 406 | # |
|---|
| 407 | # |
|---|
| 408 | # @deprecated property for backward compatibility. |
|---|
| 409 | # If set 'true' the behavior of method |
|---|
| 410 | # ImplementationImpl#setImplicitLocking(...) will be the same as |
|---|
| 411 | # in OJB <=1.0.3 (set the implicit locking behavior of the current used transaction) |
|---|
| 412 | # and disable the new possibility of global 'implicit locking' |
|---|
| 413 | # setting at runtime with ImplementationExt#setImplicitLocking. |
|---|
| 414 | # This is only for backward compatibility and will |
|---|
| 415 | # be removed at a later date. |
|---|
| 416 | ImplicitLockingBackward=false |
|---|
| 417 | #---------------------------------------------------------------------------------------- |
|---|
| 418 | # Meta data / mapping settings |
|---|
| 419 | #---------------------------------------------------------------------------------------- |
|---|
| 420 | # The PersistentFieldClass property defines the implementation class |
|---|
| 421 | # for PersistentField attributes used in the OJB MetaData layer. |
|---|
| 422 | # By default the best performing attribute/refection based implementation |
|---|
| 423 | # is selected (PersistentFieldDirectAccessImpl). |
|---|
| 424 | # |
|---|
| 425 | # - PersistentFieldDirectAccessImpl |
|---|
| 426 | # is a high-speed version of the access strategies. |
|---|
| 427 | # It does not cooperate with an AccessController, |
|---|
| 428 | # but accesses the fields directly. Persistent |
|---|
| 429 | # attributes don't need getters and setters |
|---|
| 430 | # and don't have to be declared public or protected |
|---|
| 431 | # - PersistentFieldPrivilegedImpl |
|---|
| 432 | # Same as above, but does cooperate with AccessController and do not |
|---|
| 433 | # suppress the java language access check (but is slow compared with direct access). |
|---|
| 434 | # - PersistentFieldIntrospectorImpl |
|---|
| 435 | # uses JavaBeans compliant calls only to access persistent attributes. |
|---|
| 436 | # No Reflection is needed. But for each attribute xxx there must be |
|---|
| 437 | # public getXxx() and setXxx() methods. |
|---|
| 438 | # - PersistentFieldDynaBeanAccessImpl |
|---|
| 439 | # implementation used to access a property from a |
|---|
| 440 | # org.apache.commons.beanutils.DynaBean. |
|---|
| 441 | # - PersistentFieldAutoProxyImpl |
|---|
| 442 | # for each field determines upon first access how to access this particular field |
|---|
| 443 | # (directly, as a bean, as a dyna bean) and then uses that strategy |
|---|
| 444 | # |
|---|
| 445 | PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldDirectImpl |
|---|
| 446 | #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldPrivilegedImpl |
|---|
| 447 | #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldIntrospectorImpl |
|---|
| 448 | #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldDynaBeanImpl |
|---|
| 449 | #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldAutoProxyImpl |
|---|
| 450 | #(DynaBean implementation does not support nested fields) |
|---|
| 451 | # |
|---|
| 452 | #---------------------------------------------------------------------------------------- |
|---|
| 453 | # Component Intercepting for Profiling and Tracing |
|---|
| 454 | #---------------------------------------------------------------------------------------- |
|---|
| 455 | # By enabling an InterceptorClass all OJB components will use |
|---|
| 456 | # this Interceptor. Interceptors allow advanced tracing and Profiling |
|---|
| 457 | # of all component method calls. |
|---|
| 458 | # This is currently an experimental feature useful only for OJB kernel developers. |
|---|
| 459 | # |
|---|
| 460 | #InterceptorClass=org.apache.ojb.broker.util.interceptor.TracingInterceptor |
|---|
| 461 | # |
|---|
| 462 | #---------------------------------------------------------------------------------------- |
|---|
| 463 | # Transaction Management and assocation |
|---|
| 464 | #---------------------------------------------------------------------------------------- |
|---|
| 465 | # (optional, only used when OJB runs within managed environments) |
|---|
| 466 | # To praticipate in JTA transaction OJB needs access to the underlying transaction manager. |
|---|
| 467 | # The TransactionManager is acquired in different ways dependent on the application server. |
|---|
| 468 | # The JTATransactionManagerClass property allows you to specify the class that implements |
|---|
| 469 | # the proper behaviour for finding the transaction manager. Only use when OJBTxManagerClass |
|---|
| 470 | # is set to a factory that uses the application server transaction manager |
|---|
| 471 | # (org.apache.ojb.odmg.JTATxManager) |
|---|
| 472 | # |
|---|
| 473 | # JBoss Transaction Manager Factory |
|---|
| 474 | JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.JBossTransactionManagerFactory |
|---|
| 475 | # Weblogic Transaction Manager Factory |
|---|
| 476 | #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.WeblogicTransactionManagerFactory |
|---|
| 477 | # WebSphere transaction manager factory |
|---|
| 478 | #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.WebSphereTransactionManagerFactory |
|---|
| 479 | # Orion transaction manager factory |
|---|
| 480 | #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.OrionTransactionManagerFactory |
|---|
| 481 | # SunOne transaction manager factory |
|---|
| 482 | #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.SunOneTransactionManagerFactory |
|---|
| 483 | # JOnAs transaction manager factory |
|---|
| 484 | #JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.JOnASTransactionManagerFactory |
|---|
| 485 | # |
|---|
| 486 | # |
|---|
| 487 | #---------------------------------------------------------------------------------------- |
|---|
| 488 | # Logging settings are now in their own file, OJB-logging.properties |
|---|
| 489 | #---------------------------------------------------------------------------------------- |
|---|
| 490 | #---------------------------------------------------------------------------------------- |
|---|
| 491 | # End of OJB.properties file |
|---|
| 492 | #---------------------------------------------------------------------------------------- |
|---|
