Java annotations baeldung spring boot example

Vita 155 Published: 10/04/2024

Java annotations baeldung spring boot example

Here's an example of using Java annotations with Baeldung and Spring Boot:

In this example, we'll create a simple RESTful API that uses Java annotations to define the endpoints and their corresponding actions.

First, let's create a new Spring Boot project using Baeldung's Spring Initializr. We'll choose the "Web" and "Java" options and give our project a name (e.g., "annotations-example").

Once we have our project set up, let's add some dependencies to our pom.xml file:



org.springframework.boot


spring-boot-starter-web


junit


junit


test

Now, let's create a simple controller that uses Java annotations to define two endpoints:

@RestController

@RequestMapping("/api")


public class AnnotationController {


@GetMapping("/hello")


public String hello() {


return "Hello from Annotations!";


}


@PostMapping("/greet/{name}")


public String greet(@PathVariable String name) {


return "Hello, " + name + "!";


}


}

In this example, we're using the @RestController annotation to mark our controller as a RESTful API. We're also using the @RequestMapping annotation to specify that all endpoints in this controller should be prefixed with /api.

The first endpoint is a simple GET request that returns a string message. We've used the @GetMapping annotation to specify that this endpoint should respond to GET requests.

The second endpoint is a POST request that takes a name parameter and returns a greeting message. We've used the @PostMapping annotation to specify that this endpoint should respond to POST requests, and we're using the @PathVariable annotation to extract the value of the {name} path variable from the URL.

Now, let's test our endpoints by sending some HTTP requests to our application:

curl http://localhost:8080/api/hello

Hello from Annotations!


curl -X POST -H "Content-Type: text/plain" -d "John" http://localhost:8080/api/greet/John


Hello, John!

In this example, we're using cURL to send some HTTP requests to our application. We're first sending a GET request to the /hello endpoint and then sending a POST request with the {name} parameter set to "John".

That's it! This is just a simple example of how you can use Java annotations with Baeldung and Spring Boot to define RESTful API endpoints.

What are annotations in java spring boot with example

In Java Spring Boot, annotations are a key feature that allows developers to simplify the code and make it more readable by adding specific metadata to methods or classes. Annotations can be used to specify various properties, behaviors, or configurations for a particular part of the code.

Here's an example of how annotations are used in Spring Boot:

Let's consider we have a simple web application with a RESTful API that handles HTTP requests and returns JSON responses. We want to secure this API using Basic Authentication.

We can use the @EnableWebSecurity annotation on our main configuration class (WebSecurityConfig) to enable Web Security:

@Configuration

@EnableWebSecurity


public class WebSecurityConfig extends WebSecurityConfigurerAdapter {


// Configuration methods...


}

In this example, the @EnableWebSecurity annotation tells Spring that we want to use the Web Security feature. The WebSecurityConfigurerAdapter is a base class that provides some default configurations for us.

We can also use annotations like @Autowired or @Value to inject dependencies or set properties:

@Service

public class UserService {


@Autowired


private UserRepository userRepository;


public List getUsers() {


return userRepository.findAll();


}


}

In this example, the @Service annotation marks our UserService class as a Spring Bean that provides a business service. The @Autowired annotation injects an instance of UserRepository into our service.

Another example is using annotations like @GetMapping or @PostMapping to specify HTTP request methods:

@RestController

public class UserController {


@GetMapping("/users")


public List getUsers() {


// Return all users...


}


@PostMapping("/users")


public User createUser(@RequestBody User user) {


// Create a new user...


}


}

In this example, the @RestController annotation marks our UserController class as a Spring MVC controller that handles HTTP requests. The @GetMapping and @PostMapping annotations specify the HTTP request methods for our API endpoints.

Annotations can also be used to provide additional metadata or configuration options for specific classes or methods. For instance, we could use the @Profile annotation to specify different configurations based on a profile:

@Configuration

public class DatabaseConfig {


@Profile("dev")


public DataSource devDataSource() {


// Configure the development environment...


}


@Profile("prod")


public DataSource prodDataSource() {


// Configure the production environment...


}


}

In this example, we have two different data source configurations for our application. The @Profile annotation specifies which profile to use when running the application.

These are just a few examples of how annotations can be used in Spring Boot. Annotations provide a powerful and flexible way to configure and customize our applications, making them more maintainable, scalable, and easy to develop.

Related Articles