Summary of what I learned about Spring Boot

Introduction

I will keep a memorandum of what I learned when I first touched Spring Boot from November to December last year.

• It is just a memorandum

Target audience

For those who want to touch Spring Boot from now on. I think that it will be known to those who have used it.

What I made

A simple external public API that just returns information based on the received input value.

Various things used

• Java(1.8)
• Spring Boot(2.1.0)
• Spring Data JPA
• Maven(3.5.3)
• Lombok(1.18.2)

Configuration of the application implemented this time

Overview of various classes

Descriptions and samples of various classes

Main class

Add @SpringBootApplication.

• Equivalent to the state with the following three annotations.

Various classes are read and set by @ComponentScan and @EnableAutoConfiguration, and the application is executed.

• By default, classes in the same hierarchy as the class with @ComponentScan and packages in the hierarchy below it will be scanned, so classes above the class with @ComponentScan will be scanned. Not loaded.

SampleApplication.java

@SpringBootApplication
public class SampleApplication {

    public static void main (final String[] args) {
        SpringApplication.run (SampleApplication .class, args);
    }

    @Override
    protected SpringApplicationBuilder configure (final SpringApplicationBuilder builder) {
        return builder.sources (SampleApplication .class);
    }
}

RestController class

• Add @RestController annotation. Target of @ComponentScan.
• A class that implements the interface part of the API. Examine the input value and call various components, and return a response to the client.
• Define HTTP method and URL mapping for each method, and map request and called method.
• Define which Form class to use for handling received requests and returned responses for each method.

SampleController.java

/**
 *Sample controller.
 */
@RestController
@Validated
public class SampleController {

    @Autowired
    private SampleService service; //Associate the Service class to be used.

    @PostMapping (path = "/sample", //Specify the path to map to the method.
        consumes = MediaType.APPLICATION_JSON_UTF8_VALUE, //Specify the Media Type of the request to be received.
        produces = MediaType.APPLICATION_JSON_UTF8_VALUE) //Specify the Media Type of the response to be returned.
    @CrossOrigin
    public ResponseEntity<SampleForm> sampleMethod (
        @RequestHeader (value = "sample_key") //Define the key value of the value received from the header.
        @NotEmpty (message = "sample_key is empty.") //If you want to scrutinize without using Form, define the scrutiny content here.
        @Valid String sampleKey, //Define a variable to store the value received from the header.
        @RequestBody
        @Valid SampleForm form //Define the Form class that stores the value received from the body and the variable that stores it.
    ) {
        return new ResponseEntity<> (service.sampleMethod (form.getSampleUserId), HttpStatus.OK);
    }
}

Form class

• A class that holds information about the content of requests from clients and the response returned.
• Details of scrutiny are described here.
• In addition to the scrutiny definition by annotation, you can also define your own scrutiny method.

SampleForm.java

@Data
@ToString
public class SampleForm implements Serializable {

    private static final long serialVersionUID = 1L;

    @JsonProperty ("sample_user_id") //Define the key value on JSON.
    @NotEmpty (message = "sampleUserId is empty") //Define the content of the scrutiny.
    private String sampleUserId;
    
}

RestControllerAdvice class

• Add @RestControllerAdvice. Target of @ComponentScan.
• Common processing can be implemented in RestController class. (Pre-processing, error handling, etc.)
• By preparing a method with @ExceptionHandler, error handling will be done automatically when the specified exception is thrown.

SampleExceptionHandler.java

@RestControllerAdvice
public class SampleExceptionHandler {

    @ExceptionHandler (Exception.class) //Define the exception to catch.
    @ResponseStatus (HttpStatus.INTERNAL_SERVER_ERROR) //Define the HTTP status code of the response returned when the above exception occurs.
    protected ErrorForm handleInternalServerError (Exception e) {
        logger.error (e);
        return new ErrorForm ("Internal Server Error");
    }

    @RequiredArgsConstructor
    private class ErrorForm implements Serializable {
        private static final long serialVersionUID = 1L;
        private final String message;
    }
}

Service class

• Add @Service. Target of @ComponentScan.
• A class that implements business logic. Perform various calculations and DB access based on the input value received from the RestController class.
• Since Spring Data JPA was used this time, DB access is performed by calling the repository class.

SampleService.java

@Service
@Transactional //Automatically roll back when an exception occurs.
public class SampleService {

    @Autowired
    private SampleUserRepository sampleUserRepository; //Associate the Repository class to be used.

    public SampleForm returnSampleForm (String sampleUserId) {
        return convertToSampleForm(sampleUserRepository.findBySampleUserId(sampleUserId));
    }
}

Repository class

• Add @Repository. Target of @ComponentScan.
• It is a class that performs DB access, and if you use Spring Data JPA, you can execute simple CRUD by implementing only interface.
• Inherit JpaRepository and define the table to access.
• By assigning a method name according to the naming convention, it will automatically read which CRUD and what search conditions it is.
  Example) If findByUserId (String userId) is set, it will be a method to search by userId.
• If you try to implement a query or search with a table join, it's not so simple, but I didn't use it this time, so I'll omit it.

SampleUserRepository.java

@Repository
public interface SampleUserRepository extends JpaRepository<SampleUser, String> { //Define the access destination table and primary key type.
    SampleUser findBySampleUserId (String sampleUserId); //Define method names and arguments according to the naming convention.
}

Entity class

• Add @Entity.
• Holds the data acquired from the DB and the data to be input to the DB.
• This time, I tied it to the table one-on-one.

SampleUser.java

@Entity
@Table (name = "sample_user") //Define the table name to be linked.
@Data
public class SampleUser implements Serializable {

    private static final long serialVersionUID = 1L;

    /**Sample user ID*/
    @Id //Give to the item of the primary key.
    @GeneratedValue (strategy = GenerationType.IDENTITY) //If you want automatic numbering, define the numbering method.
    private String sampleUserId;

    /**Sample username*/
    private String sampleUserName;
}

Reference site

• https://docs.spring.io/spring-boot/docs/current/reference/html/index.html