My Experience with Developing API using Java Spring Boot| Coding.
Java spring is a famous framework used to build web applications on top of Java EE. Java EE stands for Enterprise edition, which is community-driven enterprise software. Java EE has contributions from industry experts, commercial, community, and open-source contributions. It can be used with any Java application. After years of coding using different scripting languages like JavaScript and Python, I felt the urge to learn the concept of Java once again.
In this tutorial, we will exploring the concept of Java Spring framework by developing a basic rest full service in which we will expose few endpoints related to Camera Management System.
Prerequisite
- Java
- Basic understanding of Programming(Any language).
- Spring Tool Suite / Eclipse, or any editor of your choice.
- Basic understanding of Rest APIs.
- Postman( Anything Similar)
This will be moreover a journey in which anyone interested in learning Java can explore it along with me. I don't want to make it as a tutorial series but wanted to design it as a roadmap in which one can make plenty of mistakes, but learn something new every week.
We will be making the project for the CRUD operations for our camera management system. Just to make things more clearer, the agenda is to develop different Rest API that will be used to perform multiple actions on the Camera list. In this particular tutorial we won’t be connecting our application with the database, but will be using in-memory storage.
1. Setting up the basic bootstrap spring project
By visiting the website which is well known for creating basic Java spring bootstrap project. Open the following link https://start.spring.io/, we will be setting our basic project.
- Group: com.camera-service
- Artifact: camera
- Name: camera
- Packaging: jar
- Java: 8 (I have installed this version in my system.)
Once you have provided all the information, it the time to download the code into your machine by clicking on Generate button. Once the code in downloaded, unzip and open it your Spring Tool Suite. Simple click on
File > Import > Maven > Existing Maven Projects > then browse to the location where you have unzipped the code.
After selecting your Existing Maven Projects directory, and do select the POM file and then click finish. Great you have successfully cleared path first.
We have a basic skeleton ready, for starting with our Java Camera Rest API Microservice.
2. Designing a controller.
Let’s start with building a basic Controller with four different Rest method, right click on the project and create new Java Class. You should add correct package name and name of your controller.
Once done, add following line to your code. By this we are making controller for 3 apis end point to Create and Read the in memory data.
Notes
@RestController annotation is an alternative of Controller annotation which is introduced in Spring 4.0, this help in a specialization of the Component class.
package com.cameraservice.camera.controller;import java.util.List;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;import com.cameraservice.camera.entity.Camera;
import com.cameraservice.camera.services.CameraService;@RestController
public class MyController {@Autowired
private CameraService cameraService;
@GetMapping("/")
public String index() {
return "Hello world.";
}
@GetMapping("/camera")
public List<Camera> cameraList() {
return this.cameraService.getCameras();
}
@GetMapping("/camera/{cameraId}")
public Camera getCourse(@PathVariable String cameraId) {
return this.cameraService.getCamera(Long.parseLong(cameraId));
}
@PostMapping("/camera")
public List<Camera> addCourse(@RequestBody Camera camera) {
return this.cameraService.addCamera(camera);
}
}
3. Developing Service Class.
Once the controller is ready, let us create an interface for CameraService.java and service for CameraServiceImpl class, inside com.cameraservice.camera.services package.
CameraService.java
package com.cameraservice.camera.services;
import java.util.List;
import com.cameraservice.camera.entity.Camera;
public interface CameraService {
public List<Camera> getCameras();
public Camera getCamera(long cameraId);
public List<Camera> addCamera(Camera camera);
}CameraServiceImpl.java
package com.cameraservice.camera.services;import java.util.ArrayList;
import java.util.List;import org.springframework.stereotype.Service;import com.cameraservice.camera.entity.Camera;@Service
public class CameraServiceImpl implements CameraService{List<Camera> list;
public CameraServiceImpl () {
list = new ArrayList<>();
list.add(new Camera(1, "Front Desk Camera", "CP Plus"));
list.add(new Camera(2, "Back Desk Camera","Hikvision"));
}@Override
public List<Camera> getCameras() {
// TODO Auto-generated method stub
return list;
}@Override
public Camera getCamera(long cameraId) {
// TODO Auto-generated method stub
Camera c = new Camera(1,"No Camera Exist","NA");
for(Camera camera : list) {
System.out.println(camera.getId());
if(camera.getId() == cameraId) {
c = camera;
break;
}
}
return c;
}
@Override
public List<Camera> addCamera(Camera camera) {
// TODO Auto-generated method stub
this.list.add(camera);
return this.list;
}
}
4. Developing Entity Class
Finally we create our entity class for our camera and name it as Camera.java inside com.cameraservice.camera.entity.
package com.cameraservice.camera.entity;public class Camera {
private long id;
private String name;
private String manufacturer;public Camera(long id, String name, String manufacturer) {
super();
this.id = id;
this.name = name;
this.manufacturer = manufacturer;
}public long getId() {
return id;
}public void setId(long id) {
this.id = id;
}public String getName() {
return name;
}public void setName(String name) {
this.name = name;
}public String getManufacturer() {
return manufacturer;
}public void setManufacterer(String manufacturer) {
this.manufacturer = manufacturer;
}}
So we are done with developing our Camera Rest application. The next step is to start our camera application by right clicking on our application and then Run it as Spring Boot App.
We can open our postman client, a broadly used client for mimicking our front end server, it will help us in making rest api call.
Let’s start with very first api which is used to check if the application is working correctly and ofcourse return the world famous ' Hello World’.
1. Api to check if the application is working correctly.
API route: http://localhost:8080
Method: GET.
2. Api to get the list of camera list.
API route: http://localhost:8080/camera
Method: GET
3. API to get the camera filter based upon on the camera unique id.
API route: http://localhost:8080/camera/1
Method: GET
4. API help in adding new camera into the list.
API Route localhost:8080/camera
Method: POST.
These is all for the the Restful service that we built using Java spring boot framework, as promised we will be exposing 4 rest API i.e.
- To get the list of camera.
- To add a new camera.
- To get a specific camera based upon camera id.
- The initial testing api, return “Hello world”.
Read, update and delete will be a task, just to implement business logic for these functionality and you will be good to understand about the concepts.
In the subsequent tutorial we will be exploring about how can we connect our application with the database. Since we are using an in-memory storage in the current tutorial, so risk is to lose the data once we rebuild our application.
But with the help of database we can store the data for as long as we want.
Github Code Link: https://github.com/apoorvtomar2222/camera-management-system/
Branch: Master
