{"id":84685,"date":"2018-12-20T08:35:38","date_gmt":"2018-12-20T06:35:38","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=84685"},"modified":"2018-12-28T09:29:33","modified_gmt":"2018-12-28T07:29:33","slug":"build-basic-spring-boot-using-postgresql","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2018\/12\/build-basic-spring-boot-using-postgresql.html","title":{"rendered":"Build a Basic App with Spring Boot and JPA using PostgreSQL"},"content":{"rendered":"

\u201cI love writing authentication and authorization code.\u201d ~ No Java Developer Ever.<\/b> Tired of building the same login screens over and over? Try the Okta API for hosted authentication, authorization, and multi-factor auth.<\/a><\/span><\/p>\n

Every non-trivial application needs a way to save and update data: a resource server that is accessible via HTTP. Generally, this data must be secured. Java is a great language with decades of history in professional, enterprise development, and is a great choice for any application\u2019s server stack. Within the Java ecosystem, Spring makes building secure resource servers for your data simple. When coupled with Okta, you get professionally maintained OAuth and JWT technologies easily integrated into Spring Boot using Spring Security.<\/p>\n

In this post, you\u2019re going to build a resource server using Spring Boot and Spring Data JPA. On top of that, you\u2019re going to implement a group-based authentication and authorization layer using OAuth 2.0. If this sounds complicated – don\u2019t worry! It\u2019s not.<\/p>\n

Before we dig in, let\u2019s cover some background:<\/p>\n

Aresource server<\/strong> is a programmatic access point for your server\u2019s functions and data (basically the same as an API server and\/or possibly REST server).<\/p>\n

JPA<\/strong> is the Java Persistence API, a specification for managing relational databases using Java. It describes an abstraction layer between Java classes and a relational database.<\/p>\n

Spring Data JPA<\/strong><\/a> is a wrapper around JPA providers such as Hibernate. As you\u2019ll see, it makes persisting your Java classes as simple as adding some annotations and creating a simple repository interface. No need to actually write persistence or retrieval methods! Another great benefit is that you can change the underlying database implementation transparently without having to change any code. For example, in this tutorial, you\u2019ll be using Postgres, but later if you decided you\u2019d rather use MySQL, all you\u2019d have to do is change out some dependencies.<\/p>\n

Install PostgreSQL for JPA Persistence<\/h2>\n

You\u2019ll need to have PostgreSQL installed for this tutorial. If you don\u2019t already have it installed, go to their downloads page<\/a> and install it.<\/p>\n

The next thing you\u2019ll need to do is create a Postgres user and database for the project. For this, you can use the Postgres CLI.
\nYou should be able to run the following command: psql -V<\/code> and get a response like:<\/p>\n

psql (PostgreSQL) 11.12<\/pre>\n
Create a PostgreSQL Database for Your JPA Entities<\/h2>\n
Before you can use your database, you need to do a few things. You need to:<\/p>\n
    \n
  1. Create a user for the app<\/li>\n
  2. Set a password for that user<\/li>\n
  3. Create a database for the app<\/li>\n
  4. Grant privileges on the database for the user<\/li>\n<\/ol>\n
    This tutorial uses jpatutorial<\/em> for the username and springbootjpa<\/em> for the database name. Feel free to change these if you like, but you\u2019ll have to remember to use your custom values throughout the tutorial.<\/p>\n
    Type psql<\/code> from the terminal to enter the Postgres shell. Then enter the following command.<\/p>\n
    Create a user<\/h3>\n
    create user jpatutorial;<\/pre>\n
    The shell should respond with: CREATE ROLE<\/code><\/p>\n
    Don\u2019t forget the semicolon!<\/strong> I would never, ever do this. I am definitely not speaking from experience. But if you don\u2019t type in the semicolon psql<\/code> doesn\u2019t process the command and you can lose 20-30 minutes in frustrated confusion wondering what is happening until you do<\/em> enter a semicolon, at which point it tries to process all of your commands.<\/p>\n
    Give the user a password<\/h3>\n
    alter user jpatutorial with encrypted password '<your really secure password>';<\/pre>\n
    The shell should respond with: ALTER ROLE<\/code>.<\/p>\n
    Create the database<\/h3>\n
    create database springbootjpa;<\/pre>\n
    The shell should respond with: CREATE DATABASE<\/code>.<\/p>\n
    Grant privileges<\/h3>\n
    grant all privileges on database springbootjpa to jpatutorial;<\/pre>\n
    The shell should respond with GRANT<\/code>.<\/p>\n
    Finally, type \\q<\/code> to quit the shell, if you want.<\/p>\n
    If you want to read more about psql<\/code> you can take a look at Postgres\u2019 docs<\/a>.<\/p>\n
    Build a Spring Boot Resource Server<\/h2>\n
    Clone the starter project from the GitHub repository and check out the start<\/strong> branch:<\/p>\n
    git clone -b start https:\/\/github.com\/oktadeveloper\/okta-spring-boot-jpa-example.git<\/pre>\n
    The starter project is a clean slate Spring Boot project with just a little bit of Postgres-specific configuration already in place. If you look in the build.gradle<\/code> file you\u2019ll see a PostgreSQL JPA connector dependency. You\u2019ll also notice the file src\/main\/resources\/hibernate.properties<\/code> whose sole purpose is to get rid of an annoying warning\/error that doesn\u2019t really matter to us. The src\/main\/resources\/application.yml<\/code> file also has some properties pre-filled for you.<\/p>\n
    Go ahead and open the application.yml<\/code> file and fill in the password you created for your database user. You should also update the username, database name, and port (if they are different).<\/p>\n
    spring:  \n  jpa:  \n    hibernate:  \n      ddl-auto: create  \n    database-platform: org.hibernate.dialect.PostgreSQLDialect  \n  datasource:  \n    url: \"jdbc:postgresql:\/\/localhost:5432\/springbootjpa\"  \n    username: jpatutorial  \n    password: < your password >\n<\/pre>\n
    The ddl-auto<\/code> property specifies hibernate\u2019s behavior upon loading. The options are:<\/p>\n