Spring - Integration of Spring 4, Struts 2, and Hibernate

In modern Java web application development, integrating different frameworks is a common requirement to leverage the strengths of each framework. Spring, Struts, and Hibernate are three popular frameworks that can work together seamlessly to build robust and scalable applications. In this article, we will explore how to integrate Spring 4, Struts 2, and Hibernate in a Java application.

Prerequisites: Before we begin, ensure that you have the following components set up:

• Java Development Kit (JDK) installed
• Apache Maven or Gradle installed
• Integrated Development Environment (IDE) such as Eclipse or IntelliJ IDEA

Project Setup

Create a new Maven or Gradle project in your preferred IDE. This project will serve as the foundation for our integration. Add the necessary dependencies for Spring, Struts, and Hibernate to your project's build configuration file (pom.xml for Maven or build.gradle for Gradle). Here's an example of the required dependencies:

<!-- Spring dependencies -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>4.3.29.RELEASE</version>
</dependency>

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

<!-- Struts 2 dependencies -->
<dependency>
  <groupId>org.apache.struts</groupId>
  <artifactId>struts2-core</artifactId>
  <version>2.5.26</version>
</dependency>

<!-- Hibernate dependencies -->
<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>5.4.32.Final</version>
</dependency>

<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-validator</artifactId>
  <version>6.1.7.Final</version>
</dependency>

Adjust the versions according to your project requirements and let Maven or Gradle resolve the dependencies.

Configuring Spring

Create a Spring configuration file (e.g., `spring-config.xml`) in the `src/main/resources` directory. This file will contain the necessary Spring bean definitions. Configure Spring MVC by adding the following line to your Spring configuration file:

<mvc:annotation-driven />

This configuration enables the processing of annotations in your Spring MVC controllers.

Enable component scanning by adding the following line:

<context:component-scan base-package="com.example.controllers" />

Adjust the `base-package` value to the package containing your Spring MVC controllers.

Configure Hibernate by defining the session factory bean in the Spring configuration file:

<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
  <property name="hibernateProperties">
    <props>
      <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
      <prop key="hibernate.show_sql">true</prop>
    </props>
  </property>
</bean>

Adjust the Hibernate dialect and other properties as per your database requirements.

Configure the Hibernate transaction manager by adding the following lines:

<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
  <property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager" />

These configurations enable Spring's transaction management using Hibernate.

Integrating Struts with Spring and Hibernate

Create a Struts configuration file (e.g., `struts.xml`) in the `src/main/resources` directory. This file will define the Struts actions and result mappings. Configure the Struts action classes to use Spring beans by adding the following lines to the Struts configuration file:

<constant name="struts.objectFactory" value="spring" />
<constant name="struts.objectFactory.spring.autoWire" value="name" />
<constant name="struts.objectFactory.spring.useClassCache" value="true" />

These configurations ensure that Struts actions are managed by Spring's IoC container.

In your Struts action classes, use Spring's @Autowired annotation to inject dependencies:

import org.springframework.beans.factory.annotation.Autowired;

public class MyAction {
  @Autowired
  private MyService myService;

  // Rest of the action class
}

This allows you to access Spring-managed beans within your Struts actions.

Building the Application

With the necessary configurations in place, you can now build and run your integrated Spring, Struts, and Hibernate applications. Use the following steps:

1. Implement the necessary Spring MVC controllers, Struts actions, and Hibernate entities according to your application requirements.
2. Use Spring annotations like `@Controller` and `@RequestMapping` to define Spring MVC controllers and their mappings.
3. Implement Struts actions by extending the appropriate Struts base classes and defining action methods.
4. Configure Hibernate mappings, repositories, and services to handle data persistence.
5. Build and package your application using Maven or Gradle.
6. Deploy the resulting artifact to a suitable Java application server such as Apache Tomcat or Jetty.
7. Access your application using the appropriate URL, taking into account the mappings defined in your Spring MVC controllers and Struts actions.

Congratulations! You have successfully integrated Spring 4, Struts 2, and Hibernate into your Java application. You can now leverage the power of these frameworks together to build robust and scalable web applications.

That's it! This article provides a step-by-step guide to integrating Spring 4, Struts 2, and Hibernate in a Java application. By following the instructions and configuring the necessary components, you can build powerful web applications that leverage the strengths of each framework.