Spring Boot - REST Example

Here's a simple example of creating a RESTful web service using Spring Boot:

1. Setting Up the Project:

You can use Spring Initializr to bootstrap a new Spring Boot application. Select Web as a dependency, which will include spring-boot-starter-web.

If you're setting it up manually, add the following dependency to your pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2. Create a Model:

For this example, let's create a simple Book model.

public class Book {
    private Long id;
    private String title;
    private String author;

    // Constructors, getters, setters, etc.
}

3. Create a Controller:

We'll create a simple REST controller to handle CRUD operations for Book.

import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;

@RestController
@RequestMapping("/api/books")
public class BookController {

    private final List<Book> books = new ArrayList<>();
    private final AtomicLong counter = new AtomicLong();

    @GetMapping
    public List<Book> getAllBooks() {
        return books;
    }

    @GetMapping("/{id}")
    public Book getBook(@PathVariable Long id) {
        return books.stream().filter(book -> book.getId().equals(id)).findFirst().orElse(null);
    }

    @PostMapping
    public Book addBook(@RequestBody Book book) {
        book.setId(counter.incrementAndGet());
        books.add(book);
        return book;
    }

    @PutMapping("/{id}")
    public Book updateBook(@PathVariable Long id, @RequestBody Book book) {
        Book existingBook = getBook(id);
        if (existingBook != null) {
            existingBook.setTitle(book.getTitle());
            existingBook.setAuthor(book.getAuthor());
        }
        return existingBook;
    }

    @DeleteMapping("/{id}")
    public void deleteBook(@PathVariable Long id) {
        books.removeIf(book -> book.getId().equals(id));
    }
}

4. Running the Application:

Create the main Spring Boot application class to run the application.

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

@SpringBootApplication
public class RestExampleApplication {
    public static void main(String[] args) {
        SpringApplication.run(RestExampleApplication.class, args);
    }
}

Run the RestExampleApplication class, and your Spring Boot application will start.

5. Testing the RESTful Service:

Once the application is up and running, you can use tools like Postman or simply a web browser to test the endpoints:

Get All Books: GET http://localhost:8080/api/books
Get a Book by ID: GET http://localhost:8080/api/books/{id}
Add a Book: POST http://localhost:8080/api/books with JSON payload.
Update a Book: PUT http://localhost:8080/api/books/{id} with JSON payload.
Delete a Book: DELETE http://localhost:8080/api/books/{id}

This is a basic introduction to creating a RESTful web service using Spring Boot. In a real-world scenario, you might also involve a database, use Spring Data JPA for data access, add validation, exception handling, etc.

Creating a simple REST service with Spring Boot:

Description: Spring Boot simplifies the creation of RESTful services. Start by creating a basic controller with a simple endpoint.

Code:

// Example REST controller in Spring Boot
@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Spring Boot!";
    }
}

Configuring REST endpoints in Spring Boot:

Description: Configure REST endpoints using annotations like @RequestMapping or more specific annotations like @GetMapping, @PostMapping, etc.

Code:

// Example using @RequestMapping
@RestController
@RequestMapping("/api")
public class MyController {
    @GetMapping("/resource")
    public String getResource() {
        return "This is a resource.";
    }
}

Request mapping and HTTP methods in Spring Boot REST:
- Description: Use @RequestMapping to map HTTP methods to specific controller methods. Use more specific annotations like @GetMapping for better clarity.
- Code:
```
// Example using @GetMapping
@RestController
public class UserController {
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        // Logic to fetch user by id
    }
}
```

CRUD operations with Spring Boot RESTful services:

Description: Implement CRUD operations by combining various HTTP methods (GET, POST, PUT, DELETE) in your Spring Boot RESTful service.

Code:

// Example CRUD operations in a Spring Boot RESTful service
@RestController
@RequestMapping("/api/users")
public class UserController {
    // GET: Retrieve all users
    // POST: Create a new user
    // GET: Retrieve a user by ID
    // PUT: Update a user by ID
    // DELETE: Delete a user by ID
}

Exception handling in Spring Boot REST APIs:

Description: Handle exceptions gracefully in Spring Boot REST APIs using @ExceptionHandler or @ControllerAdvice.

Code:

// Example exception handling in Spring Boot
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<String> handleResourceNotFound(ResourceNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());
    }
}

Versioning strategies for RESTful APIs in Spring Boot:
- Description: Implement versioning strategies such as URI versioning, request header versioning, or content negotiation to handle API evolution.
- Code:
```
// Example URI versioning
@GetMapping("/api/v1/users")
public List<User> getAllUsersV1() {
    // ...
}

@GetMapping("/api/v2/users")
public List<User> getAllUsersV2() {
    // ...
}
```
Securing Spring Boot REST services with authentication and authorization:
- Description: Secure REST services using Spring Security. Configure authentication and authorization mechanisms to control access.
- Code:
```
// Example security configuration in Spring Boot
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    // Configure authentication and authorization
}
```
Testing and documenting REST APIs in Spring Boot:
- Description: Test REST APIs using tools like JUnit or Spring's @WebMvcTest. Document APIs using tools like Swagger or Springdoc.
- Code:
```
// Example testing with JUnit and Spring's MockMvc
@RunWith(SpringRunner.class)
@WebMvcTest(UserController.class)
public class UserControllerTests {
    // Test methods
}
```