Table of Contents

• What you’ll build
• What you’ll need
• Set up the project
• Create a Customer object
• Store and retrieve data
• Summary

This guide walks you through the process of accessing relational data with Spring.

What you’ll build

You’ll build an application using Spring’s JdbcTemplate to access data stored in a relational database.

What you’ll need

https://raw.github.com/spring-guides/getting-started-macros/master/prereq_editor_jdk_buildtools.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/how_to_complete_this_guide.adoc

Set up the project

https://raw.github.com/spring-guides/getting-started-macros/master/build_system_intro.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/create_directory_structure_hello.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/create_both_builds.adoc

build.gradle

link:initial/build.gradle[role=include]

https://raw.github.com/spring-guides/getting-started-macros/master/bootstrap_starter_pom_disclaimer.adoc

Create a Customer object

The simple data access logic you will work with below below manages first and last names of customers. To represent this data at the application level, create a Customer class.

src/main/java/hello/Customer.java

link:complete/src/main/java/hello/Customer.java[role=include]

Store and retrieve data

Spring provides a template class called JdbcTemplate that makes it easy to work with SQL relational databases and JDBC. Most JDBC code is mired in resource acquisition, connection management, exception handling, and general error checking that is wholly unrelated to what the code is meant to achieve. The JdbcTemplate takes care of all of that for you. All you have to do is focus on the task at hand.

src/main/java/hello/Application.java

link:complete/src/main/java/hello/Application.java[role=include]

In this example you set up a JDBC [DataSource] using Spring’s handy SimpleDriverDataSource. Then, you use the DataSource to construct a JdbcTemplate instance.

Note	SimpleDriverDataSource is a convenience class and not intended for production.

After you configure JdbcTemplate, it’s easy to start making calls to the database.

First, you install some DDL using JdbcTemplate’s `execute method.

Then, you install some records in your newly created table using JdbcTemplate’s `update method. The first argument to the method call is the query string, the last argument (the array of Object s) holds the variables to be substituted into the query where the “?” characters are.

Note	Use ? for arguments to avoid SQL injection attacks by instructing JDBC to bind variables.

Finally you use the query method to search your table for records matching the criteria. You again use the “?” arguments to create parameters for the query, passing in the actual values when you make the call. The last argument in the query method is an instance of RowMapper<T>, which you provide. Spring’s done 90% of the work, but it can’t know what you want it to do with the result set data. So, you provide a RowMapper<T> instance that Spring will call for each record, aggregate the results, and return as a collection.

https://raw.github.com/spring-guides/getting-started-macros/master/build_an_executable_jar_mainhead.adoc https://raw.github.com/spring-guides/getting-started-macros/master/build_an_executable_jar_with_both.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/run_the_application_with_both.adoc

You should see the following output:

Creating tables
Inserting customer record for John Woo
Inserting customer record for Jeff Dean
Inserting customer record for Josh Bloch
Inserting customer record for Josh Long
Querying for customer records where first_name = 'Josh':
Customer[id=3, firstName='Josh', lastName='Bloch']
Customer[id=4, firstName='Josh', lastName='Long']

Summary

Congratulations! You’ve just used Spring to develop a simple JDBC client.