/* * Copyright 2002-2006 the original author or authors. * * Licensed 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. */ package org.springframework.orm.jdo; import javax.jdo.JDOException; import javax.jdo.PersistenceManager; import javax.jdo.PersistenceManagerFactory; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.dao.DataAccessException; /** * Base class for JdoTemplate and JdoInterceptor, defining common * properties such as PersistenceManagerFactory and flushing behavior. * *
Note: With JDO, modifications to persistent objects are just possible * within a transaction (in contrast to Hibernate). Therefore, eager flushing * will just get applied when in a transaction. Furthermore, there is no * explicit notion of flushing never, as this would not imply a performance * gain due to JDO's field interception mechanism (which doesn't involve * the overhead of snapshot comparisons). * *
Eager flushing is just available for specific JDO providers. * You need to a corresponding JdoDialect to make eager flushing work. * *
Not intended to be used directly. See JdoTemplate and JdoInterceptor. * * @author Juergen Hoeller * @since 02.11.2003 * @see JdoTemplate * @see JdoInterceptor * @see #setFlushEager */ public abstract class JdoAccessor implements InitializingBean { /** Logger available to subclasses */ protected final Log logger = LogFactory.getLog(getClass()); private PersistenceManagerFactory persistenceManagerFactory; private JdoDialect jdoDialect; private boolean flushEager = false; /** * Set the JDO PersistenceManagerFactory that should be used to create * PersistenceManagers. */ public void setPersistenceManagerFactory(PersistenceManagerFactory pmf) { this.persistenceManagerFactory = pmf; } /** * Return the JDO PersistenceManagerFactory that should be used to create * PersistenceManagers. */ public PersistenceManagerFactory getPersistenceManagerFactory() { return persistenceManagerFactory; } /** * Set the JDO dialect to use for this accessor. *
The dialect object can be used to retrieve the underlying JDBC * connection and to eagerly flush changes to the database. *
Default is a DefaultJdoDialect based on the PersistenceManagerFactory's * underlying DataSource, if any. */ public void setJdoDialect(JdoDialect jdoDialect) { this.jdoDialect = jdoDialect; } /** * Return the JDO dialect to use for this accessor. *
Creates a default one for the specified PersistenceManagerFactory if none set. */ public JdoDialect getJdoDialect() { if (this.jdoDialect == null) { this.jdoDialect = new DefaultJdoDialect(); } return this.jdoDialect; } /** * Set if this accessor should flush changes to the database eagerly. *
Eager flushing leads to immediate synchronization with the database, * even if in a transaction. This causes inconsistencies to show up and throw * a respective exception immediately, and JDBC access code that participates * in the same transaction will see the changes as the database is already * aware of them then. But the drawbacks are: *
org.springframework.dao
hierarchy.
* Default implementation delegates to the JdoDialect. * May be overridden in subclasses. * @param ex JDOException that occured * @return the corresponding DataAccessException instance * @see JdoDialect#translateException */ public DataAccessException convertJdoAccessException(JDOException ex) { return getJdoDialect().translateException(ex); } }