Spring Boot MySQL Integration: 6 Easy Steps

The popular Spring Framework offers advanced infrastructure support to develop Java applications. However, due to its rich feature set, developers often face complexity while configuring Spring applications. To safeguard developers from this tedious and error-prone process, the Spring team launched Spring Boot as a useful extension of the Spring framework. Spring Boot eliminates the excessive configuration work by automating the decision-making tasks involved in Spring applications. Moreover, it facilitates a faster and optimal Application Development ecosystem.

Spring Boot by default depends upon the system memory to support its Application Development. However, with the increasing data requirements, businesses are inclining towards the idea of using MySQL as the data management facility for Spring Boot applications. MySQL, being a cloud-based DBMS (Database Management System) can easily scale according to the developer’s needs and thus allow for faster data processing.

This article will introduce you to Spring Boot and MySQL along with their key features. It will also discuss the importance of setting up the Spring Boot MySQL Integration. Furthermore, the article will provide a detailed step-by-step process using which you can connect your Spring Boot and MySQL applications easily. Read along to learn more about Spring Boot MySQL Integration and build your connection today! 

What is Spring Boot?

Spring Boot is a micro-framework that is available in an open-source format. This framework is popular for providing an automated configurable Spring application to Java Developers that simplifies their task of building complex applications. Java developers fancy this tool as it allows them to commence their work without any delay on the Spring application. The Spring Boot user community is massive and any new user can find plenty of resources and tutorials to get you started. This easy accessibility plays a key role in the ever-rising popularity of this framework. has had a massive effect on the framework’s popularity. 

Key Features of Spring Boot

Spring Boot acts as a great choice for Application Development due to the following features:

• Auto-Configuration: Spring Boot provides you with an auto-configuration feature that makes more than 200+ decisions related to Application Development and automatically configures numerous functionalities by simply examining the dependencies. It also helps you in detecting the occurrence of a Class in the Classpath and then configures it automatically for you. The auto-configuration feature saves you a lot of work and reduces the time overhead for your development process.
• Actuator: The Spring Boot Actuator feature enables you to monitor what’s going on inside a working Spring Boot application. This feature is important as it prevents you from the risk of neglecting your application due to the auto-configuration feature. The Actuator offers great insight that can help you better understand your in-process Spring Boot applications.
• Plug-ins: Spring Boot offers a variety of plugins that you can apply to smoothly operate with embedded and in-memory databases. Moreover, it facilitates the seamless creation and testing of Java applications via its default setup for unit and integration testing.

You can learn more about Spring Boot, here.

What is MySQL

MySQL, deployed in 1995, is an effective management system for databases. This  DBMS makes use of SQL (Structured Query Language) to perform data manipulation and various data-related operations. MySQL fundamentally works on an open-source model that is accessible to anyone who wishes to make use of its services. However, there are certain superior versions of MySQL, designed to take care of specific business requirements. You need to pay a monthly fee to leverage the facilities of such MySQL versions. Due to its multitude of capabilities and benefits, organizations these days depend upon the MySQL platform for a scalable and dependable data solution. 

The simplicity that MySQL offers gives it a clear advantage over the likes of Oracle databases and Microsoft SQL Server. Moreover, you can implement any programming language of your choice, for free, when working with this DBMS platform. Another benefit of using MySQL lies in its ability to combine with Linux, Unix, Windows, and other operating systems. Furthermore, MySQL lets you select its mode of implementation, so you can either use it online or after installing it in your local system.

Key Features of MySQL

The following features make MySQL a popular DBMS in the market: 

• High performance: The MySQL engine provides a unique combination of high processing rates with an easy-to-use interface. Moreover, it can host several customers simultaneously and provide them with faster MySQL access from any location. 
• Compatibility: MySQL along with its secure and low-latency data transactions, also offers you the environment to install multiple web devolvement tools. 
• Scalability: The MySQL platform helps you to scale up or down your data load at any time. This platform also adapts seamlessly to most well-known operating structures like Linux, OS X, Windows, etc.

To get more details regarding MySQL, visit here.

Importance of Spring Boot MySQL Integration

Deploying your Spring Boot based applications via MySQL instead of using in-built memory, will provide you with the following benefits:

• MySQL offers unparalleled scalability to make it easy to manage deeply integrated Spring Boot applications that operate on terabytes of data. Moreover, on-demand flexibility is the main feature of MySQL. This open-source solution allows full customization of your data and caters to the unique database server requirements of your Spring Boot-based applications for e-commerce businesses.
• Spring Boot can build stand-alone web applications with integrated servers. Now using MySQL Database instead of internal memory storage can minimize the query execution time. This way the application developed vis Spring Boot MySQL Integration, will be more suitable better for real-time work, and the users will get a better experience.
• Applications built on Spring Boot and running on MySQL are not only cost-effective for development, but also act as a viable solution for enterprise-level tasks. Spring Boot can leverage MySQL to enhance its ability to package a complete service (such as user authentication) into a self-contained, fully deployable form that also provides an API. This way it can greatly simplify the installation and deployment processes of an application. The Spring Boot MySQL Integration is also gaining popularity in the world of microservices.

Steps to Integrate MySQL with Spring Boot

Now, since you have understood the benefits of connecting Spring Boot to MySQL, it’s time that you learn how to actually go through with it. The following steps will help you in setting up the Spring Boot MySQL Integration:

• Step 1: Creating a MySQL Database
• Step 2: Append MySQL Dependencies
• Step 3: Set Spring Boot MySQL Connection Configuration 
• Step 4: Build a Repository Class for Spring Boot
• Step 5: Convert the Blog Class to Entity
• Step 6: Add the Controller to Spring Boot MySQL Integration

Step 1: Creating a MySQL Database

After installing the MySQL application, you need to create a database table to initiate your Spring Boot MySQL Integration. On the MySQL terminal, execute the following code:

CREATE DATABASE restapi;
USE restapi;
CREATE TABLE blog (
  id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
  title VARCHAR(500) NOT NULL,
  content VARCHAR(5000) NOT NULL
);

This command will create a database named “restapi” that contains the blog table.

Step 2: Append MySQL Dependencies

To connect your MySQL Database created in Step 1 to the Spring Boot application, you need to place the required dependencies (e.g. MySQL library) into the Spring Boot’s pom.xml file. These dependencies are a type of Java library that will facilitate your Spring Boot MySQL connection. In this scenario, the “mysql-connector-java” library is useful. Navigate to the dependency tag in your Spring Boot application and navigate to the pom.xml file where you must paste the following code: 

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

Upon execution, your pom.xml file will look similar to the following:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>me.salisuwy</groupId>
    <artifactId>SpringRest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>

    <dependencies>
        <!-- Spring boot dependency -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- JPA Data (We are going to use Repositories, Entities, Hibernate, etc...) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!-- Use MySQL Connector-J -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Step 3: Set Spring Boot MySQL Connection Configuration

Now, your Spring Boot MySQL Integration requires you to provide the database connection properties to Spring Boot. The MySQL Database URL, port, username, password, etc. falls under the required properties. Open the resource folder in Spring Boot and add the following code in it to provide the database-related information:

spring.datasource.url=jdbc:mysql://localhost:3306/restapi
spring.datasource.username=root
spring.datasource.password=

You must edit the above code and place the username, url, and password of your MySQL Database.

Step 4: Build a Repository Class for Spring Boot

Once the Spring Boot MySQL Integration is in place, you have to create a class in Spring Boot that can communicate with the MySQL Database. Such a “repository class” requires an interface that can extend the JpaRepository. The use of JpaRepository is essential as it adds certain functionalities like fetching all records, saving, updating, deleting, etc. The following code will create your required class:

package me.salisuwy;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface BlogRespository extends JpaRepository<Blog, Integer> {

    // custom query to search to blog post by title or content
    List<Blog> findByTitleContainingOrContentContaining(String text, String textAgain);    
}

Step 5: Convert the Blog Class to Entity

Now, create a blog class, say “Blog.java” that contains the fields of your MySQL table. Keep in mind that each instance of Blog.java is mapped to a row in your MySQL table. The following code will help you in creating a blog class and converting it into an entity:

package me.salisuwy;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Blog {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;

    private String title;
    private String content;

    public Blog() {  }

    public Blog(String title, String content) {
        this.setTitle(title);
        this.setContent(content);
    }

    public Blog(int id, String title, String content) {
        this.setId(id);
        this.setTitle(title);
        this.setContent(content);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Blog{" +
                "id=" + id +
                ", title='" + title + ''' +
                ", content='" + content + ''' +
                '}';
    }
}

In the above code, the id column of your MySQL Table acts as the primary key. Your Spring Boot MySQL Integration uses an @Id annotation to inform Spring Framework about the required fields.

Step 6: Add the Controller to Spring Boot MySQL Integration

To further enhance your Spring Boot MySQL Integration, you can add the following command to the code in Step 5:

@Autowired
BlogRespository blogRespository;

This will allow you to use blogRepository anywhere in your controller without having to repeatedly instantiate it. The final code will look as follow:

package me.salisuwy;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

@RestController
public class BlogController {

    @Autowired
    BlogRespository blogRespository;

    @GetMapping("/blog")
    public List<Blog> index(){
        return blogRespository.findAll();
    }

    @GetMapping("/blog/{id}")
    public Blog show(@PathVariable String id){
        int blogId = Integer.parseInt(id);
        return blogRespository.findOne(blogId);
    }

    @PostMapping("/blog/search")
    public List<Blog> search(@RequestBody Map<String, String> body){
        String searchTerm = body.get("text");
        return blogRespository.findByTitleContainingOrContentContaining(searchTerm, searchTerm);
    }

    @PostMapping("/blog")
    public Blog create(@RequestBody Map<String, String> body){
        String title = body.get("title");
        String content = body.get("content");
        return blogRespository.save(new Blog(title, content));
    }

    @PutMapping("/blog/{id}")
    public Blog update(@PathVariable String id, @RequestBody Map<String, String> body){
        int blogId = Integer.parseInt(id);
        // getting blog
        Blog blog = blogRespository.findOne(blogId);
        blog.setTitle(body.get("title"));
        blog.setContent(body.get("content"));
        return blogRespository.save(blog);
    }

    @DeleteMapping("blog/{id}")
    public boolean delete(@PathVariable String id){
        int blogId = Integer.parseInt(id);
        blogRespository.delete(blogId);
        return true;
    }

}

JPA provides you with the CRUD operations (i.e. findAll, findOne, save, delete) as default in the above code. However, you can also create your queries for more complex operations.

That’s it! Your Spring Boot MySQL Integration is in place. Now you can try out the above steps by yourself to set up the Spring Boot MySQL connection for your business.

Conclusion

The article introduced you to Spring Boot and MySQL along with their unique features. It then discussed the importance of setting up the Spring Boot MySQL Integration. Furthermore, the article explained the step-by-step process of connecting your Spring Boot application to your MySQL account. Using these steps, you can also set up the Spring Boot MySQL Integration within minutes and start building Java applications today!

Visit our Website to Explore Hevo

You have understood the importance and steps of setting up a Spring Boot MySQL Integration. Now, to run SQL queries or perform Data Analytics on your MySQL data, you first need to export this data to a Data Warehouse. This will require you to custom code complex scripts to develop the ETL processes. Hevo Data can automate your data transfer process, hence allowing you to focus on other aspects of your business like Analytics, Customer Management, etc. This platform allows you to transfer data from 100+ multiple sources like MySQL to Cloud-based Data Warehouses like Amazon Redshift, Snowflake, Google BigQuery, etc. It will provide you with a hassle-free experience and make your work life much easier.

Want to take Hevo for a spin? Sign Up for a 14-day free trial and experience the feature-rich Hevo suite first hand.

Share your understanding of Spring Boot MySQL Integration in the comments below!