Spring boot actual database operation example code

In the previous article, I explained the basic principle and use of spring boot through a simple HelloWorld program. This article mainly explains how to access the database through spring boot. This article will demonstrate three ways to access the database: the first is jdbctemplate, the second is JPA, and the third is mybatis. As mentioned earlier, this series will be based on a blog system, so this article will explain the storage and access of articles (but not the details of articles). Because the final implementation is completed through mybatis, only a simple demonstration will be made for jdbctemplate and JPA, and the mybatis part will fully realize the addition, deletion, modification and query of articles.

1、 Preparatory work

Before demonstrating these methods, you need to prepare something. The first is the database. The system is implemented by mysql. We need to create a TB first_ Table for article:

Subsequent demonstrations will add, delete, modify and query this table. You should see that there are no article details in this table. The reason is that the article details are relatively long. If placed in this table, it is easy to affect the efficiency of querying the article list, so the article details will be stored in another table alone. In addition, we need to configure the database connection pool. Here, we use Druid connection pool, and the configuration file uses yaml configuration, that is, application YML (you can also use the application.properties configuration file. There is no big difference. If you are not familiar with ymal, you can check it if you are interested. It is relatively simple). The configuration of connection pool is as follows:

Finally, we also need to establish POJO classes corresponding to the database. The code is as follows:

Well, that's all the preparations. Now let's start the database operation.

2、 Integration with jdbctemplate

First, we access the database through the jdbctemplate. Here we only demonstrate data insertion. As we mentioned in the previous article, spring boot provides many starters to support different functions. To support the jdbctemplate, we only need to introduce the following Starters:

Now we can insert data through jdbctemplate:

We test the above code through JUnit:

To support the above test program, you also need to introduce a starter:

As can be seen from the above code, in fact, except for the introduction of JDBC start, there is basically no configuration, which is automatically completed by spring boot. The above code needs to pay attention to the location of the application class. This class must be located in the package of the parent of Dao class. For example, Dao is located in com pandy. blog. Dao, now let's put the application Java this class from com pandy. Blog this package moves to com pandy. blog. In the app package, the following errors will appear:

In other words, the implementation of articledao cannot be found. What is the reason? In the previous blog post, we saw that the annotation @ springbootapplication inherits @ componentscan. By default, it will only scan the package and sub package where the application class is located. Therefore, for the above error, in addition to keeping the application class in the parent package of Dao, you can also specify the scanned package to solve it:

3、 Integration with JPA

Now let's begin to explain how to operate the database through JPA. Similar to the jdbctemplate, first, we need to introduce the corresponding starter:

Then we need to add an entity annotation to the POJO class, specify the table name (if not specified, the default table name is article), and then specify the ID and its generation strategy. These are JPA knowledge and have nothing to do with spring boot. If you are not familiar with it, you can see the knowledge points of JPA:

Finally, we need to inherit the jparepository class. Here we implement two query methods. The first is a query that conforms to the JPA naming specification. JPA will automatically help us generate query statements. The other way is to implement jpql (a kind of SQL query supported by JPA).

Well, we can test the above code again:

Note that there is still a problem similar to that of jdbctemplate. You need to make the startup class application not in the parent package of repository and entity classes, otherwise the following error will occur:

Of course, you can also specify the scanned JPA package through the annotation @ enablejparepositories, but it still doesn't work. The following errors will occur:

This error indicates that entity cannot be recognized, so the package of entity needs to be specified through annotation @ entityscan. The final configuration is as follows:

4、 Integration with mybatis

Finally, let's look at how to access the database through mybatis. Similarly, we still need to introduce starter:

Since the starter is not officially provided by spring boot, the version number is inconsistent with spring boot and needs to be specified manually.

Mybatis can generally specify the SQL to operate the database through XML or annotation. I prefer XML. Therefore, this article only demonstrates how to access the database through XML. First, we need to configure the mapper directory. We are in application Configure in YML:

The configuration here mainly includes three parts. One is the configuration of mybatis itself, such as the alias of basic types. The second is to specify the location of the mapper file, and the third is the alias of the POJO class. This configuration can also be implemented through Java configuration. Due to the space problem, I won't elaborate here. Interested friends can implement it by themselves.

After configuration, we first write the interface corresponding to mapper:

For the time being, the interface only defines four methods: add, update, query by ID and paging query. This is an interface, and similar to JPA, there is no need to implement classes. Next, we write an XML file:

Finally, we need to manually specify the packages scanned by mapper:

Well, the integration with mybatis has been completed. Let's test again:

5、 Summary

This article demonstrates the integration of spring boot with jdbctemplate, JPA and mybatis. On the whole, the configuration is relatively simple. Students who have done relevant configuration before should feel that spring boot has indeed provided us with great help in this regard. In subsequent articles, we will only use mybatis to operate the database. Another point to be explained here is that the paging query of mybatis is handwritten here. This paging can be completed through plug-ins in formal development, but it has nothing to do with spring boot, Therefore, this paper temporarily uses this manual way to process paging.

The above is the whole content of this article. I hope it will be helpful to your study, and I hope you can support programming tips.