Connecting Spring Boot and PostgreSQL database – Part 2

Following on from part 1, we will now make a Spring Boot rest service.

Create a project directory and we will work inside of their.

Inside your project directory, create this directory structure:

$ mkdir -p src/main/java/users

$ mkdir -p src/main/resources

We will be using maven to manage our dependencies, so create in the top level a pom.xml with the following content:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="" xmlns:xsi=""




        <!-- JPA Data (We are going to use Repositories, Entities, Hibernate, etc...) -->







Then, we will create an inside our resources directory:


This allows us to update the database rather than create a new one every time with update instead of create.

Now, create the following classes inside the users directory:

package users;

import javax.persistence.*;

@Table(name = "users")
public class Users implements Serializable {

    private static final long serialVersionUID = -3009157732242241606L;
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    @Column(name = "username")
    private String username;

    protected Users() {

    public String getUsername() {
        return username;

    public Users(String username) {
        this.username = username;

    public String toString() {
        return String.format("Customer[id=%d, username='%s']", id, username);

package users;


 *  This will be AUTO IMPLEMENTED by Spring into a Bean called userRepository
 *  CRUD refers Create, Read, Update, Delete
public interface UserRepository extends CrudRepository<Users, Long> {


package users;

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

public class UserController {

    private UserRepository userRepository;

    public @ResponseBody String addNewUser (@RequestParam String username) {
        Users testuser = new Users(username);;
        return "done";

    public @ResponseBody Iterable getAllUsers() {
        return userRepository.findAll();

package users;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

public class Application {

    public static void main(String[] args) {, args);

Let’s test the application works.

$ mvn clean install spring-boot:run

Then, in a browser, run navigate to http://localhost:8080/users/add?username=johndoe then navigate to http://localhost:8080/users/all and this should display all the usernames stored in the database in json format.


Connecting Spring Boot and PostgreSQL database – Part 1

In todays tutorial, we will be setting up a postgreSQL database with a Java Spring Boot rest service.

Before we begin with the Java service, we will need to install PostgreSQL. You can find their latest downloads on their website. When you have downloaded and installed this on your machine, we will then set up the database and table.

First, check your PostgreSQL installation and that it is properly added onto your path. You can test this by opening up a command:

$ psql --version

This should return the version of PostgreSQL installed.

Depending on how you have installed PostgreSQL, you will have a default username and password of postgres.

Log into Postgres to check this, type:

$ psql postgres

postgres=# \du

this will list the current users that are installed. For more information about this, check out this link.

Presuming that is all installed, I will use the username and password Postgres for this tutorial and this will be a default user on the Postgres app for mac.

Log into Postgres with:

$ psql postgres

then, run the following SQL script:

postgres=# CREATE TABLE users (
id char(5),
username varchar(40)

This will create a table for users with columns id and username.

In part 2, we will create the Java app that will insert and remove data from the database.

Creating an AWS Java Lambda

Amazon don’t make learning lambdas that straightforward, so I will give a quick tutorial on how to create a Java Lambda and make a HTTP GET on the lambda to get a response of Hello World.

Before starting, I would highly recommend downloading Eclipse. Then download the Amazon Plugin this then installs the necessary components for you to build a Java Lambda project.


  • Register on Amazon Web Services
  • Open Eclipse
  • Go File -> New -> Other
  • There should be a folder after the AWS plugins have been installed into Eclipse
  • AWS -> AWS Java Lambda Project
  • Click next
  • Fill in a project name
  • Change input type to Custom (this produces a Hello World template)
  • Click finish

Staying with Eclipse, right click on the Java file you are currently working on. Go down to AWS Lambda and go Upload Function to AWS Lambda.

Select the correct timezone and give it an appropriate name.

Click next, select an appropriate S3 bucket to store your Lambda in, if you do not have one, create one on the AWS console.

Select finish.

Editing the lambda

Once the lambda is up there, now you can start editing it.

You will need to send back a HTTP response, otherwise you will not be able to make a get on the lambda.

  • change the handleRequest method return type to Map<String, String>
  • have a key in the map called body, and the value called Hello World
  • save it and upload to amazon as done before on setup

Exposing the Lambda to the outside world

Go to the AWS console. Then, go to Lambda. Then select functions.

Your function should be listed there at this point. Select it.

Go to Triggers and add API gateway. This will allow your Lambda to access the outside world. Configure the triggers accordingly.

On the AWS console, go to API gateway and select LambdaMicroservice.

On actions, select deploy API and set it to PROD.

On the side menu, click stages, then click prod dropdown icon.

There should be your function with GET, POST etc..

Select GET, then copy the URL into your browser window, and it should return hello world to the window.



JNI – the Java Native Interface

The Java Native Interface is a framework used to allow Java programs to integrate with other applications written in other programming languages like C and C++.

This feature is quite old now with regards to the JVM and was added in 1.1 to 1.2 of the JVM.

I have started using this feature with a Raspberry Pi as you can access the GPIO pins directly with C without other libraries and this can be integrated with a Java program to control the GPIO pins.

This feature is very useful, as the Pi4J library doesn’t work on all versions of Debian for the Raspberry Pi at the time of blogging this post, since they renamed some features, which broke Pi4J.

I will give an example of how to do this –

Create a file called

import com.sun.jna.Library;
import com.sun.jna.Native;

public class HelloWorld {
public interface CTest extends Library {
public void helloFromC();

public interface GPIO extends Library {
public int main();
public static void main(String[] args) {
CTest ctest = (CTest) Native.loadLibrary("ctest", CTest.class);

GPIO gpio = (GPIO) Native.loadLibrary("gpio", GPIO.class);

Create a file called gpio.c

// How to access GPIO registers from C-code on the Raspberry-Pi
// Example program
// 15-January-2012
// Dom and Gert
// Revised: 15-Feb-2013

// Access from ARM Running Linux

#define BCM2708_PERI_BASE 0x20000000
#define GPIO_BASE (BCM2708_PERI_BASE + 0x200000) /* GPIO controller */


#define PAGE_SIZE (4*1024)
#define BLOCK_SIZE (4*1024)

int mem_fd;
void *gpio_map;

// I/O access
volatile unsigned *gpio;

// GPIO setup macros. Always use INP_GPIO(x) before using OUT_GPIO(x) or SET_GPIO_ALT(x,y)
#define INP_GPIO(g) *(gpio+((g)/10)) &= ~(7<<(((g)%10)*3))
#define OUT_GPIO(g) *(gpio+((g)/10)) |= (1<<(((g)%10)*3))
#define SET_GPIO_ALT(g,a) *(gpio+(((g)/10))) |= (((a)<=3?(a)+4:(a)==4?3:2)<<(((g)%10)*3))

#define GPIO_SET *(gpio+7) // sets bits which are 1 ignores bits which are 0
#define GPIO_CLR *(gpio+10) // clears bits which are 1 ignores bits which are 0

#define GET_GPIO(g) (*(gpio+13)&(1<<g)) // 0 if LOW, (1<<g) if HIGH

#define GPIO_PULL *(gpio+37) // Pull up/pull down
#define GPIO_PULLCLK0 *(gpio+38) // Pull up/pull down clock

void setup_io();

void printButton(int g)
if (GET_GPIO(g)) // !=0 bit is 1 <- port is HIGH=3.3V
printf("Button pressed!\n");
else // port is LOW=0V
printf("Button released!\n");

int main(int argc, char **argv)
int g,rep;

// Set up gpi pointer for direct register access

// Switch GPIO 7..11 to output mode

* You are about to change the GPIO settings of your computer. *
* Mess this up and it will stop working! *
* It might be a good idea to 'sync' before running this program *
* so at least you still have your code changes written to the SD-card! *

// Set GPIO pins 7-11 to output
for (g=7; g<=11; g++)
INP_GPIO(g); // must use INP_GPIO before we can use OUT_GPIO

for (rep=0; rep<10; rep++)
for (g=7; g<=11; g++)
GPIO_SET = 1<<g;
for (g=7; g<=11; g++)
GPIO_CLR = 1<<g;

return 0;

} // main

// Set up a memory regions to access GPIO
void setup_io()
/* open /dev/mem */
if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
printf("can't open /dev/mem \n");

/* mmap GPIO */
gpio_map = mmap(
NULL, //Any adddress in our space will do
BLOCK_SIZE, //Map length
PROT_READ|PROT_WRITE,// Enable reading & writting to mapped memory
MAP_SHARED, //Shared with other processes
mem_fd, //File to map
GPIO_BASE //Offset to GPIO peripheral

close(mem_fd); //No need to keep mem_fd open after mmap

if (gpio_map == MAP_FAILED) {
printf("mmap error %d\n", (int)gpio_map);//errno also set!

// Always use volatile pointer!
gpio = (volatile unsigned *)gpio_map;

} // setup_io

Run the Following commands:


Create the jni headers file

javah -jni HelloWorld

Do not modify the file above

gcc -shared -I/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/include -I/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/include/linux HelloWorld.c -o

Then to run the application, use

java -Djava.library.path=. HelloWorld

If you would like more information, I initially used this website

Unit testing introduction

What are unit tests?

Unit tests are the smallest part of the application that can be tested and are tested in parts.

Why should I care?

Unit tests are important to show if parts of an application are working in the way they are expected to work. For example, if you had a method called int return4() and you expected 4 to be returned, a unit test is written to validate the method returns 4. If it doesn’t, the test fails and is shown up to the tester if written well.

Where can I start unit testing?

For Spring Boot applications, I would recommend the following tutorial. This integrates a unit test with Spring Boot. I would advise you experiment with the tests and see what you can make.

Design Patters, Java and the Factory Pattern

Have you ever looked at a piece of code, project or application and thought “what on earth is going on here”? I have many times and so have many other developers, so ages ago, Design Patterns were introduced to keep coding clean, and organised.

You probably organise your code already closely to a few design patterns without even realising. Today, I’ll introduce the Factory Pattern as a method of structuring your code.

The Factory Pattern allows objects of similar logic to be created to a common interface.

Tutorialspoint has a great example involving shapes.

Summarising the example, you can have a shape factory that creates triangles, squares, circles.

This may seem rather abstract, but for example, you may want to make different types of database connection for customers and want to get their details, which they would have a Customer interface, but a Customer Factory for all the individual details so that they are not exposed to the client.

Getting Started With Spring Boot?

What is Spring Boot?

Spring Boot is a Java framework. Spring Boot shouldn’t be confused with Spring Framework and more information can be found here.

How do I get started?

The Spring Boot webpage is a great place to start. You can install via Maven (or Gradle).

Great, why should I do this?

Spring Boot is great for setting up web services and other applications quickly and without too much complication, but allows the developer to configure parts to make diverse applications without spending too much time setting up the project.

Give it a try and see what you think 🙂


How to Make MySQL and Spring-Boot CRUD application for Raspberry Pi

In this post, I will share how to make a very basic Spring Boot application and database with MySQL with Raspberry Pi.


  • I will assume you know Git and Source Control and you know how to set up a Raspberry Pi.

Lets Start:

Installing MySQL Raspberry Pi

Using some information from this guide, you will need to install MySQL and drivers. Php is not needed for this.

  • Open up your terminal on your Raspberry Pi
  • sudo apt-get install mysql-server --fix-missing
  • Agree  to all of the install terms
  • Create a password for your MySQL database when required
  • sudo apt-get install mysql-client php5-mysql
  • Agree to all of the install terms

MySQL should be installed correctly on your Raspberry Pi.

Installing Maven

You will need Apache Maven to run the application on your Raspberry Pi.

I will summarise this tutorial as this is what I used:

Before starting developing the Application, I advise you use an IDE on a main computer and Git with source control to transfer it over.

  • Create an account on GitHub to store the project that will be created in the next part
  • Once created, clone the repository onto the Raspberry Pi and your laptop or desktop development environment

From Spring Boot’s website we’ll follow this guide.

You should build this application on your GitHub repository that you created earlier and pull it via command line on your Raspberry Pi as this will keep the development fast.

How to Install Java for Development

After the previous post to What is Java I will now provide a quick start up to installing Java, so you can start to develop your own applications.

Is Java Development Kit and Java Runtime Environment installed?

To check this, on linux and mac OS open terminal (for Windows, open cmd) and type:

javac -version
This will show the JDK version.

java -version
Will show the JRE version.

Please note – it is important that the JDK and JRE versions match – for example 1.8.X for both, where X can be any number, if it is 1.7.X and 1.8.X for the JDK or JRE (or vice versa), the code will not compile as Java needs to be the same version for compilation as running.

Typically, on a mac, it would be installed. If not, Oracle’s official installation JDK and JRE will provide the information to install it.

For Linux, here is the official installation JDK and JRE.

For Windows, here are the System Requirements, then install the JDK and JRE.

If things start to go wrong, here are some quick points to check:

  • Is the JDK and JRE installed already?
  • Are the versions the same or different?
  • For Windows – Is the JDK and JRE on your PATH variables?
  • For Mac and Linux – Is $PATH got the correct path to your JDK and JRE?

For further information – please go to Oracle’s Official Website  for installation tips and requirements.

What is Java?

Quoting from Wikipedia – Java is a general-purpose computer programming language that is concurrent, class-based, object-oriented.

So, what does that mean?

  • Java can execute several computations in overlapping time periods – for example, multithreading is used to execute several tasks at the same time.
  • Java has classes – therefore you can use inheritance and encapsulation.
  • Java has objects – you can define attributes of the object and use them in the code.

Other Features Developing Java

  • Java uses a compiler – when developing Java, you need to use a Java Development Kit (JDK) to compile the code into byte code that is run on a Java Virtual Machine (JVM)
  • Write once, run everywhereWikipedia, you can run Java bytecode on any JVM on any machine, what this means is you do not need different flavours of code to run on different systems like Linux and Microsoft – providing they have a JVM, you can run the code on all of them.