or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

exception-handling.mdhibernate-integration.mdindex.mdjpa-integration.mdpersistence-context.mdtransaction-management.md
tile.json

tessl/maven-org-springframework--spring-orm

Spring Object/Relational Mapping integration module providing comprehensive support for JPA, Hibernate, and other ORM frameworks within the Spring ecosystem

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.springframework/spring-orm@6.2.x

To install, run

npx @tessl/cli install tessl/maven-org-springframework--spring-orm@6.2.0

index.mddocs/

Spring ORM

Spring ORM is a comprehensive Object/Relational Mapping integration module that provides seamless integration of JPA (Java Persistence API), Hibernate, and other ORM frameworks within the Spring ecosystem. It offers declarative transaction management, dependency injection for persistence contexts, exception translation, and web tier integration patterns that simplify data access layer development in enterprise applications.

Package Information

  • Package Name: org.springframework:spring-orm
  • Package Type: Maven
  • Language: Java
  • Version: 6.2.8
  • Installation:

Maven:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>6.2.8</version>
</dependency>

Gradle:

implementation 'org.springframework:spring-orm:6.2.8'

Core Imports

JPA Integration:

import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor;

Hibernate Integration:

import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.orm.hibernate5.HibernateTemplate;

Exception Handling:

import org.springframework.orm.ObjectOptimisticLockingFailureException;
import org.springframework.orm.ObjectRetrievalFailureException;

Annotations:

import jakarta.persistence.PersistenceContext;
import jakarta.persistence.PersistenceUnit;

Basic Usage

JPA Configuration with Spring Boot

@Configuration
@EnableJpaRepositories(basePackages = "com.example.repository")
@EnableTransactionManagement
public class JpaConfig {

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
            DataSource dataSource) {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource);
        em.setPackagesToScan("com.example.entity");
        em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
        
        Properties jpaProperties = new Properties();
        jpaProperties.setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
        jpaProperties.setProperty("hibernate.hbm2ddl.auto", "validate");
        em.setJpaProperties(jpaProperties);
        
        return em;
    }

    @Bean
    public PlatformTransactionManager transactionManager(
            EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private String email;
    
    // getters and setters
}

@Repository
public class UserRepository {
    
    @PersistenceContext
    private EntityManager entityManager;
    
    @Transactional
    public void save(User user) {
        entityManager.persist(user);
    }
    
    public User findById(Long id) {
        return entityManager.find(User.class, id);
    }
}

Hibernate Configuration

@Configuration
@EnableTransactionManagement
public class HibernateConfig {

    @Bean
    public LocalSessionFactoryBean sessionFactory(DataSource dataSource) {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setPackagesToScan("com.example.entity");
        
        Properties hibernateProperties = new Properties();
        hibernateProperties.setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
        hibernateProperties.setProperty("hibernate.show_sql", "true");
        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", "validate");
        sessionFactory.setHibernateProperties(hibernateProperties);
        
        return sessionFactory;
    }

    @Bean
    public PlatformTransactionManager transactionManager(SessionFactory sessionFactory) {
        return new HibernateTransactionManager(sessionFactory);
    }

    @Bean
    public HibernateTemplate hibernateTemplate(SessionFactory sessionFactory) {
        return new HibernateTemplate(sessionFactory);
    }
}

@Repository
public class HibernateUserRepository {
    
    @Autowired
    private HibernateTemplate hibernateTemplate;
    
    public void save(User user) {
        hibernateTemplate.save(user);
    }
    
    public User findById(Long id) {
        return hibernateTemplate.get(User.class, id);
    }
    
    @SuppressWarnings("unchecked")
    public List<User> findAll() {
        return hibernateTemplate.loadAll(User.class);
    }
}

Architecture

Spring ORM follows a layered architecture that integrates ORM frameworks with Spring's core features:

Transaction Management Layer

  • PlatformTransactionManager: Abstraction for transaction management across different ORM providers
  • JpaTransactionManager: JPA-specific transaction management with EntityManager lifecycle
  • HibernateTransactionManager: Hibernate-specific transaction management with Session lifecycle
  • Declarative Transactions: @Transactional annotation support with AOP

Persistence Context Management

  • EntityManagerFactory: JPA EntityManagerFactory configuration and lifecycle management
  • SessionFactory: Hibernate SessionFactory configuration and lifecycle management
  • Shared EntityManager: Thread-safe EntityManager proxies for dependency injection
  • Open EntityManager/Session in View: Web request-scoped persistence context patterns

Exception Translation

  • PersistenceExceptionTranslator: Converts ORM-specific exceptions to Spring's DataAccessException hierarchy
  • Vendor-specific Translators: HibernateExceptionTranslator, JPA exception handling
  • Consistent Error Handling: Uniform exception types across different ORM providers

Dependency Injection Integration

  • @PersistenceContext: EntityManager injection with proper lifecycle management
  • @PersistenceUnit: EntityManagerFactory injection for programmatic access
  • PersistenceAnnotationBeanPostProcessor: Annotation processing for persistence resource injection

Capabilities

JPA Integration

Comprehensive JPA support including EntityManagerFactory configuration, transaction management, shared EntityManager creation, and vendor-specific adaptations for Hibernate and EclipseLink.

// Core JPA Configuration
public class LocalContainerEntityManagerFactoryBean 
        extends AbstractEntityManagerFactoryBean 
        implements ResourceLoaderAware, LoadTimeWeaverAware {
    public void setDataSource(DataSource dataSource);
    public void setPackagesToScan(String... packagesToScan);
    public void setJpaVendorAdapter(JpaVendorAdapter jpaVendorAdapter);
    public void setPersistenceUnitManager(PersistenceUnitManager persistenceUnitManager);
    public EntityManagerFactory createNativeEntityManagerFactory() throws PersistenceException;
}

// Transaction Management
public class JpaTransactionManager extends AbstractPlatformTransactionManager 
        implements ResourceTransactionManager, BeanFactoryAware, InitializingBean {
    public JpaTransactionManager(EntityManagerFactory emf);
    public void setEntityManagerFactory(EntityManagerFactory emf);
    public void setDataSource(DataSource dataSource);
    public void setJpaDialect(JpaDialect jpaDialect);
}

// Shared EntityManager Creation
public abstract class SharedEntityManagerCreator {
    public static EntityManager createSharedEntityManager(EntityManagerFactory emf);
    public static EntityManager createSharedEntityManager(EntityManagerFactory emf, Map<?, ?> properties);
}

JPA Integration

Hibernate Integration

Native Hibernate 5.x support with SessionFactory configuration, transaction management, template-based data access operations, and Spring integration features.

// SessionFactory Configuration
public class LocalSessionFactoryBean extends HibernateExceptionTranslator 
        implements FactoryBean<SessionFactory>, ResourceLoaderAware, InitializingBean, DisposableBean {
    public void setDataSource(DataSource dataSource);
    public void setPackagesToScan(String... packagesToScan);
    public void setHibernateProperties(Properties hibernateProperties);
    public void setConfigLocation(Resource configLocation);
}

// Transaction Management
public class HibernateTransactionManager extends AbstractPlatformTransactionManager 
        implements ResourceTransactionManager, BeanFactoryAware, InitializingBean {
    public HibernateTransactionManager(SessionFactory sessionFactory);
    public void setSessionFactory(SessionFactory sessionFactory);
    public void setDataSource(DataSource dataSource);
}

// Template Operations
public class HibernateTemplate implements HibernateOperations, InitializingBean {
    public HibernateTemplate(SessionFactory sessionFactory);
    public <T> T execute(HibernateCallback<T> action);
    public <T> T get(Class<T> entityClass, Serializable id);
    public Serializable save(Object entity);
    public void update(Object entity);
    public void delete(Object entity);
}

Hibernate Integration

Transaction Management

Platform-agnostic transaction management with support for declarative transactions, programmatic transaction control, and integration with various transaction managers.

// Base Transaction Manager
public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager {
    public final TransactionStatus getTransaction(TransactionDefinition definition);
    public final void commit(TransactionStatus status);
    public final void rollback(TransactionStatus status);
}

// Resource Transaction Manager
public interface ResourceTransactionManager extends PlatformTransactionManager {
    Object getResourceFactory();
}

// Transaction Synchronization
public interface TransactionSynchronization {
    void beforeCommit(boolean readOnly);
    void beforeCompletion();
    void afterCommit();
    void afterCompletion(int status);
}

Transaction Management

Persistence Context Management

Advanced persistence context management including annotation-driven dependency injection, container-managed persistence contexts, and application-managed EntityManager creation.

// Persistence Annotation Processing
public class PersistenceAnnotationBeanPostProcessor implements InstantiationAwareBeanPostProcessor, 
        DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
    public void setDefaultPersistenceUnitName(String unitName);
    public void setPersistenceUnits(Map<String, PersistenceUnitInfo> persistenceUnits);
    public void setPersistenceContexts(Map<String, EntityManagerFactory> persistenceContexts);
}

// Extended EntityManager Creation  
public abstract class ExtendedEntityManagerCreator {
    public static EntityManager createApplicationManagedEntityManager(EntityManager rawEntityManager, EntityManagerFactoryInfo emfInfo);
    public static EntityManager createContainerManagedEntityManager(EntityManagerFactory emf, Map<?, ?> properties, boolean synchronizedWithTransaction);
}

// Persistence Unit Management
public interface PersistenceUnitManager {
    PersistenceUnitInfo obtainDefaultPersistenceUnitInfo();
    PersistenceUnitInfo obtainPersistenceUnitInfo(String persistenceUnitName);
}

Persistence Context

Exception Handling

Comprehensive exception translation from ORM-specific exceptions to Spring's consistent DataAccessException hierarchy, with support for optimistic locking and object retrieval failures.

// Base ORM Exceptions
public class ObjectOptimisticLockingFailureException extends OptimisticLockingFailureException {
    public ObjectOptimisticLockingFailureException(Class<?> persistentClass, Object identifier);
    public ObjectOptimisticLockingFailureException(Class<?> persistentClass, Object identifier, Throwable cause);
    public Class<?> getPersistentClass();
    public Object getIdentifier();
}

public class ObjectRetrievalFailureException extends DataRetrievalFailureException {
    public ObjectRetrievalFailureException(Class<?> persistentClass, Object identifier);
    public ObjectRetrievalFailureException(Class<?> persistentClass, Object identifier, String msg, Throwable cause);
    public Class<?> getPersistentClass();
    public Object getIdentifier();
}

// Exception Translation
public interface PersistenceExceptionTranslator {
    DataAccessException translateExceptionIfPossible(RuntimeException ex);
}

Exception Handling

Database Support

Spring ORM provides extensive database platform support through the Database enumeration:

public enum Database {
    DEFAULT,     // Default/generic database
    DB2,         // IBM DB2 database
    DERBY,       // Apache Derby database
    H2,          // H2 database
    HANA,        // SAP HANA database
    HSQL,        // HSQLDB database
    INFORMIX,    // IBM Informix database
    MYSQL,       // MySQL database
    ORACLE,      // Oracle database
    POSTGRESQL,  // PostgreSQL database
    SQL_SERVER,  // Microsoft SQL Server database
    SYBASE       // Sybase database
}

Web Integration

Spring ORM provides specialized support for web applications through filters and interceptors that manage persistence contexts across web requests:

  • OpenEntityManagerInViewFilter: Binds JPA EntityManager to request thread
  • OpenSessionInViewFilter: Binds Hibernate Session to request thread
  • AsyncWebRequestInterceptor: Supports asynchronous web request processing
  • Request-scoped Persistence: Manages lazy loading in web tier