Spring MVC Integration with MySQL
Last Updated :
23 Jul, 2025
Spring MVC is one of the most popular Java frameworks for building scalable web applications. When combined with MySQL, it provides a robust solution for developing data-driven applications. This article will guide you through integrating Spring MVC with MySQL, covering database setup, project configuration, DAO layer implementation, and CRUD operations. Whether you are a beginner or an experienced developer, this step-by-step article will help you build a Spring MVC MySQL application efficiently.
Steps Involved in the Creation of Database and Table
Step 1: Create the Database
First, we will create a database test.
Note: test is the name of the database here.
CREATE DATABASE test;
Step 2: Make the Database test an Active
use test;
Step 3: Create the Table
Create a table named studentsdetails with the following structure
CREATE TABLE studentsdetails (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(25),
caste VARCHAR(25),
neetmarks INT,
gender VARCHAR(10)
);
Step 4: Insert Records into the Table
INSERT INTO studentsdetails(name, caste, neetmarks, gender) VALUES ('Geek1', 'OBC', 600, 'Female');
INSERT INTO studentsdetails(name, caste, neetmarks, gender) VALUES ('Geek2', 'General', 700, 'Female');
INSERT INTO studentsdetails(name, caste, neetmarks, gender) VALUES ('Geek3', 'General', 600, 'Male');
INSERT INTO studentsdetails(name, caste, neetmarks, gender) VALUES ('Geek4', 'OBC', 670, 'Male');
INSERT INTO studentsdetails(name, caste, neetmarks, gender) VALUES ('Geek5', 'SC', 600, 'Female');
INSERT INTO studentsdetails(name, caste, neetmarks, gender) VALUES ('Geek6', 'SC', 500, 'Male');
Step 5: Select Data from the Table
Retrieve all records from the studentsdetails table
SELECT * FROM studentsdetails;
The below image demonstrates a database table showing student data, including their names, caste, NEET marks and gender
Spring MVC Application Setup
Now let us do all the necessary steps in the Spring MVC application.
Project Structure:
The project structure for the Spring MVC application is as follows:
Step 1: pom.xml Configuration
The pom.xml file includes the necessary dependencies for Spring MVC, MySQL, and other libraries.
XML
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.students</groupId>
<artifactId>SpringMVCMedicalSeatAvailabilityBasedOnNEETMarks</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<!-- Spring MVC Dependency -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.18</version>
</dependency>
<!-- MySQL Connector Dependency -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>
<!-- Spring JDBC Dependency -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.18</version>
</dependency>
<!-- JUnit Dependency -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>SpringMVCMedicalSeatAvailabilityBasedOnNEETMarks</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.3.2</version>
</plugin>
</plugins>
</build>
</project>
Step 2: spring-servlet.xml
The spring-servlet.xml file is used to configure the Spring MVC application context and database connection.
XML
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans/"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context/"
xmlns:mvc="http://www.springframework.org/schema/mvc/"
xsi:schemaLocation="
http://www.springframework.org/schema/beans/
http://www.springframework.org/schema/beans//spring-beans.xsd
http://www.springframework.org/schema/context/
http://www.springframework.org/schema/context//spring-context.xsd
http://www.springframework.org/schema/mvc/
http://www.springframework.org/schema/mvc//spring-mvc.xsd">
<context:component-scan base-package="com.students.controllers" />
<!-- Database Configuration -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC" />
<property name="username" value="root" />
<property name="password" value="yourpassword" /> <!-- Add your MySQL password here -->
</bean>
<!-- JdbcTemplate Configuration -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
<!-- DAO Configuration -->
<bean id="studentDao" class="com.students.dao.StudentDao">
<property name="template" ref="jdbcTemplate" />
</bean>
</beans>
Let us now roll on over to 'bean class.' The fields in this bean class should be equivalent to the MySQL table structure. Then only it will be easier and more effective to communicate.
Step 3: Student.java (Bean Class)
The Student class maps to the studentsdetails table.
Java
// Java Program to Illustrate Student Class
// Class
public class Student {
// Class data members
// Map to studentsdetails.id
private int id;
// Map to studentsdetails.name
private String name;
// Map to studentsdetails.caste
private String caste;
// Map to studentsdetails.neetMarks
private int neetMarks;
// Map to studentsdetails.gender
private String gender;
// Getter and setter methods
// Getter
public int getNeetMarks() { return neetMarks; }
// Setter
public void setNeetMarks(int neetMarks)
{
this.neetMarks = neetMarks;
}
// Getter
public String getGender() { return gender; }
// Setter
public void setGender(String gender)
{
this.gender = gender;
}
// Getter
public int getId() { return id; }
// Setter
public void setId(int id) { this.id = id; }
// Getter
public String getName() { return name; }
// Setter
public void setName(String name) { this.name = name; }
// Getter
public String getCaste() { return caste; }
// Setter
public void setCaste(String caste)
{
this.caste = caste;
}
}
Now to do the database operations, we need the DAO java file
Step 4: StudentDao.java (DAO Class)
The StudentDao class handles database operations.
Java
// Java Program to Illustrate StudentDao Class
// Importing required classes
import com.students.beans.Student;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
// Class
public class StudentDao {
private JdbcTemplate template;
public void setTemplate(JdbcTemplate template) {
this.template = template;
}
// Method to search student by name
public Student getStudentByName(String studentName) {
String sql = "SELECT * FROM studentsdetails WHERE name=?";
try {
return template.queryForObject(
sql, new Object[] { studentName },
new BeanPropertyRowMapper<>(Student.class));
} catch (Exception e) {
// Return null if no student is found
return null;
}
}
// Method to search student by caste
public Student getStudentByCaste(String caste) {
String sql = "SELECT * FROM studentsdetails WHERE caste=?";
try {
return template.queryForObject(
sql, new Object[] { caste },
new BeanPropertyRowMapper<>(Student.class));
} catch (Exception e) {
// Return null if no student is found
return null;
}
}
// Method to search student by ID
public Student getStudentById(int id) {
String sql = "SELECT * FROM studentsdetails WHERE id=?";
try {
return template.queryForObject(
sql, new Object[] { id },
new BeanPropertyRowMapper<>(Student.class));
} catch (Exception e) {
// Return null if no student is found
return null;
}
}
// Method to search student by NEET marks
public Student getStudentByNeetMarks(int neetMarks) {
String sql = "SELECT * FROM studentsdetails WHERE neetMarks=?";
try {
return template.queryForObject(
sql, new Object[] { neetMarks },
new BeanPropertyRowMapper<>(Student.class));
} catch (Exception e) {
// Return null if no student is found
return null;
}
}
// Additional business logic can be added here
}
Let us see the controller class now
Step 5: StudentController.java
The StudentController class handles HTTP requests.
Java
// Java Program to Illustrate StudentController Class
// Importing required classes
import com.students.beans.Student;
import com.students.dao.StudentDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
// Class
@Controller
public class StudentController {
// Autowired to inject StudentDao
private final StudentDao dao;
@Autowired
public StudentController(StudentDao dao) {
this.dao = dao;
}
// Method to display the search form
@RequestMapping("/studentsearchform")
public String showSearchForm(Model model) {
model.addAttribute("command", new Student());
return "studentsearchform";
}
// Method to check medical seat eligibility based on NEET marks
@RequestMapping(value = "/checkByNeetMarks", method = RequestMethod.POST)
public ModelAndView checkByNeetMarks(@ModelAttribute("student") Student student) {
ModelAndView mav = new ModelAndView("welcome");
// Fetch student details from the database
Student studentData = dao.getStudentByName(student.getName());
if (studentData != null) {
// Determine eligibility based on caste and NEET marks
boolean isEligible = false;
String caste = studentData.getCaste();
int neetMarks = studentData.getNeetMarks();
if (caste.equalsIgnoreCase("General") && neetMarks >= 600) {
isEligible = true;
} else if (caste.equalsIgnoreCase("OBC") && neetMarks >= 500) {
isEligible = true;
} else if (caste.equalsIgnoreCase("SC") && neetMarks >= 400) {
isEligible = true;
}
// Add data to the ModelAndView object
mav.addObject("firstname", studentData.getName());
mav.addObject("caste", caste);
mav.addObject("neetmarks", neetMarks);
mav.addObject("availability", isEligible ? "Eligible to get Medical Seat" : "Not eligible to get Medical Seat");
} else {
// If student is not found in the database
mav.addObject("firstname", student.getName());
mav.addObject("availability", "Student not found in the database");
}
return mav;
}
}
Step 6: Deployment and Testing
Deploy the application as a WAR file under the Tomcat webapps folder.
At the start of Tomcat, the above application can be invoked by using. Start Tomcat and access the application using
http://localhost:8080/SpringMVCMedicalSeatAvailabilityBasedOnNEETMarks/
Use the form to check medical seat eligibility based on NEET marks.
After clicking the link, we will get output as below:
Check for the url change. All should be aligned with controller
Usecase:
According to the logic written, we are getting results, here:
- Geek1 is the name given for the search. It will be checked against the "studentsdetails" table
- Circled one indicates the name of the request mapping.
It is a sample application and the necessary steps are given in this which interacts with the MySQL database. Using Spring MVC and MySQL, we can easily carry out the business logic easily.
Similar Reads
Advanced Java Tutorial | Mastery in Java Programming Advanced Java typically refers to the specialized topics and advanced features of the Java programming language beyond the basics covered in Core Java. Includes concepts like Servlets, JSP (JavaServer Pages), JDBC (Java Database Connectivity), Java EE (Enterprise Edition), web services, frameworks l
13 min read
Java Enterprise Edition
Introduction to Java ServletsJava Servlet is a Java program that runs on a Java-enabled web server or application server. It handles client requests, processes them and generates responses dynamically. Servlets are the backbone of many server-side Java applications due to their efficiency and scalability.Key Features:Servlets w
7 min read
Life Cycle of a ServletThe entire life cycle of a Servlet is managed by the Servlet container, which uses the jakarta.servlet.Servlet interface to understand the Servlet object and manage it. So, before creating a Servlet object, let's first understand the life cycle of the Servlet object, which is actually understanding
6 min read
Introduction to JSPJavaServer Pages (JSP) is a server-side technology that creates dynamic web applications. It allows developers to embed Java code directly into HTML pages and it makes web development more efficient.JSP is an advanced version of Servlets. It provides enhanced capabilities for building scalable and p
4 min read
JSP ArchitectureJSP (Java Server Pages) uses a three-tier architecture with a client, web server, and database. When the client sends a request, the web server's JSP engine processes the JSP file by converting it into a servlet, compiling, and executing it. The generated HTML is sent back to the client. The followi
2 min read
JSF | Java Server FacesJSF technology includes a set of APIs, which represent different UI components and helps in managing their states. These APIs further help in handling events on the UI components and validate user inputs through the UI components. JSF framework provides the flexibility of creating simple as well as
4 min read
Enterprise Java Beans (EJB)Note java.beans: This package has been deprecated in Java 9 and later versions, in favor of using annotations and other modern ways of creating beans. Enterprise Java Beans (EJB) is one of the several Java APIs for standard manufacture of enterprise software. EJB is a server-side software element th
4 min read
Multithreading
Concurrency
java.util.concurrent PackageJava Concurrency package covers concurrency, multithreading, and parallelism on the Java platform. Concurrency is the ability to run several or multi programs or applications in parallel. The backbone of Java concurrency is threads (a lightweight process, which has its own files and stacks and can a
9 min read
Java.util.concurrent.Executor interface with ExamplesThe concurrent API in Java provides a feature known as an executor that initiates and controls the execution of threads. As such, an executor offers an alternative to managing threads using the thread class. At the core of an executor is the Executor interface. It refers to the objects that execute
1 min read
Java.util.concurrent.ExecutorService Interface with ExamplesThe ExecutorService interface extends Executor by adding methods that help manage and control the execution of threads. It is defined in java.util.concurrent package. It defines methods that execute the threads that return results, a set of threads that determine the shutdown status. The ExecutorSer
3 min read
Java Runnable Interfacejava.lang.Runnable is an interface that is to be implemented by a class whose instances are intended to be executed by a thread. There are two ways to start a new Thread - Subclass Thread and implement Runnable. There is no need to subclass a Thread when a task can be done by overriding only the run
3 min read
Callable and Future in JavaIn Java, multithreading allows tasks to run concurrently, improving performance and responsiveness. Traditionally, developers used the Runnable interface to define tasks, but it has two major limitations: it cannot return a result and cannot throw checked exceptions.To overcome these, Java introduce
2 min read
Difference Between Callable and Runnable in Javajava.lang.Runnable is an interface that is to be implemented by a class whose instances are intended to be executed by a thread. There are two ways to start a new Thread â Subclass Thread and implement Runnable. There is no need of sub-classing Thread when a task can be done by overriding only run()
3 min read
JDBC (Java Database Connectivity)
JDBC (Java Database Connectivity)JDBC is an API that helps applications to communicate with databases, it allows Java programs to connect to a database, run queries, retrieve, and manipulate data. Because of JDBC, Java applications can easily work with different relational databases like MySQL, Oracle, PostgreSQL, and more.JDBC Arc
5 min read
JDBC DriversDBC drivers are software components that enable Java applications to communicate with different types of databases. Each database (like MySQL, Oracle, or PostgreSQL) requires a specific JDBC driver that translates Java JDBC calls into the database-specific protocol.The JDBC classes are contained in
4 min read
Establishing JDBC Connection in JavaBefore performing any database operations, you first need to establish a connection using JDBC. This connection acts like a communication channel through which SQL queries are sent and results are received. Setting up this connection involves loading the database driver, specifying the database URL,
6 min read
Types of Statements in JDBCIn Java, the Statement interface in JDBC (Java Database Connectivity) is used to create and execute SQL queries in Java applications. JDBC provides three types of statements to interact with the database:StatementPrepared StatementCallable Statement1. StatementA Statement object is used for general-
5 min read
Java Frameworks
Introduction to Spring FrameworkThe Spring Framework is a lightweight Java framework widely used for building scalable, maintainable enterprise applications. It offers a comprehensive programming and configuration model for Java-based development.Benefits of Using Spring FrameworkSimplified Development: Spring reduces boilerplate
7 min read
Spring - Understanding Inversion of Control with ExampleSpring IoC (Inversion of Control) Container is the core of the Spring Framework. It creates and manages objects (beans), injects dependencies and manages their life cycles. It uses Dependency Injection (DI), based on configurations from XML files, Java-based configuration, annotations or POJOs. Sinc
6 min read
Introduction to Spring BootSpring is one of the most popular frameworks for building enterprise applications, but traditional Spring projects require heavy XML configuration, making them complex for beginners.Spring Boot solves this problem by providing a ready-to-use, production-grade framework on top of Spring. It eliminate
4 min read
Spring - MVC FrameworkThe Spring MVC Framework follows the Model-View-Controller architectural design pattern, which works around the Front Controller, i.e., the Dispatcher Servlet. The Dispatcher Servlet handles and dispatches all incoming HTTP requests to the appropriate controller. It uses @Controller and @RequestMapp
4 min read
How to Create a REST API using Java Spring Boot?Representational State Transfer (REST) is a software architectural style that defines a set of constraints for creating web services. RESTful web services allow systems to access and manipulate web resources through a uniform and predefined set of stateless operations. Unlike SOAP, which exposes its
4 min read
What is Spring Data JPA?Spring Data JPA is a powerful framework that simplifies database access in Spring Boot applications by providing an abstraction layer over the Java Persistence API (JPA). It enables seamless integration with relational databases using Object-Relational Mapping (ORM), eliminating the need for boilerp
6 min read
Spring - JDBC TemplateIn this article, we will discuss the Spring JDBC Template and how to configure the JDBC Template to execute queries. Spring JDBC Template provides a fluent API that improves code simplicity and readability, and the JDBC Template is used to connect to the database and execute SQL Queries. What is JDB
7 min read
Spring Hibernate Configuration and Create a Table in DatabaseSpring Boot and Hibernate are a powerful combination for building scalable and efficient database-driven applications. Spring Boot simplifies application development by reducing boilerplate code, while Hibernate, a popular ORM (Object-Relational Mapping) framework, enables easy database interactions
4 min read
Aspect Oriented Programming (AOP) in Spring FrameworkSpring AOP (Aspect-Oriented Programming) is a programming technique in the Spring Framework that helps separate cross-cutting concerns (like logging, security, transactions) from the main business logic. Instead of adding this logic inside every class, AOP allows you to write it once and apply it wh
3 min read
Introduction to Spring Security and its FeaturesSpring Security is a powerful authentication and authorization framework used to secure Java-based web applications. It easily integrates with Spring Boot and provides advanced security mechanisms such as OAuth2, JWT-based authentication, role-based access control, and protection against common vuln
3 min read
What is Spring Cloud?There are many reasons to use Spring Framework for example if you want faster development, less configuration, auto-configuration, embedded server, production-ready application, and many more. But apart from that most importantly we have ready-made support for microservices and this ready-made suppo
2 min read
Introduction and Working of Struts Web FrameworkStruts is an open-source web application framework developed by Apache Software Foundation, it is used to create a web application based on servlet and JSP. It depends on the MVC (Model View Controller) framework. Struts are thoroughly useful in building J2EE (Java 2 Platform, Enterprise Edition) ap
3 min read
JUnit
Introduction to JUnit 5JUnit is a Testing Framework. The Junit 5 is the latest version of the testing framework, and it has a lot of features when compared with Junit 4. JUnit 5, also known as JUnit Jupiter. It introduces several new features and improvements over its predecessor, JUnit 4, making it more powerful and flex
8 min read
JUnit 5 vs JUnit 4JUnit 4 and JUnit 5 both are Java-based testing frameworks, The JUnit 5 is the advanced testing framework when compared with JUnit 4. The JUnit provides a lot of features like Annotation-based coding, parallel test execution, and other features. Difference between JUnit 5 and JUnit 4TopicJUnit 5JUni
4 min read
How to Write Test Cases in Java Application using Mockito and Junit?Mockito is an open-source testing framework used for unit testing of Java applications. It plays a vital role in developing testable applications. Mockito is used to mock interfaces so that a dummy functionality can be added to a mock interface that can be used in Unit Testing. Unit Testing is a typ
4 min read
Unit Testing in Spring Boot Project using Mockito and JunitSpring Boot is a Java-based framework built on top of Spring that simplifies application development with minimal configuration. Itâs ideal for creating production-ready applications quickly, thanks to features like embedded servers, auto-configuration and reduced boilerplate code.Mockito is an open
4 min read
JUnit 5 - Test Suites with ExampleJUnit 5 encourages a modular approach to test creation with its test suites. These suites function as containers, bundling multiple test classes for easier management and collective execution within a single run. In this article, we will learn about JUnit 5 - Test Suites. Test SuiteIn JUnit 5, a tes
2 min read
JUnit 5 â JaCoCo Code CoverageIn simple terms, code coverage means measuring the percentage of lines of code that are executed during automated tests. For example, if you have a method containing 100 lines of code and you are writing a test case for it, code coverage tells you briefly how many of those lines were actively exerci
5 min read