DEV Community: Boufnichel

In computer science, we don't just fix problems. We make the magic that powers today's world.

Boufnichel — Sat, 06 Jan 2024 20:32:24 +0000

In computer science, we don't just fix problems. We make the magic that powers today's world.

Dockerizing a Spring Boot Application

Boufnichel — Sun, 07 May 2023 20:09:31 +0000

Why Dockerize a Spring Boot Application?
When developing a Spring Boot application, we want it to run smoothly and efficiently in production. However, deploying an application to a production environment can be a challenging and time-consuming process. It requires us to set up a proper runtime environment, install all required dependencies, and ensure that everything is configured correctly.

This is where Docker comes in handy. Docker is a powerful containerization platform that enables developers to package their applications along with all the necessary dependencies, libraries, and configurations into a single container. Dockerizing a Spring Boot application can simplify deployment and make it more efficient, consistent, and predictable across different environments.
In this article, we will guide you through the process of dockerizing a Spring Boot application step by step. We assume that you have some basic knowledge of Spring Boot and Docker. Let's get started!
Step 1: Create a new Spring Boot application using the Spring Initializr. To do so, navigate to https://start.spring.io in your browser.
Step 2: Select the required project details, such as the project type, language, and dependencies. Click on the GENERATE button to download the project.
Step 3: Extract the downloaded ZIP file and import the project into your IDE.
Step 4: In the IDE, open the base Java file of the project and add a new simple controller to the base class of the application :
@RequestMapping("/") public String home() { return "Dockerizing Spring Boot Application"; }

Step 5: Add the RestController annotation and import the required packages. In the end, you must have something like:

package com.docker.spring;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {

    @RequestMapping("/")
    public String home() {
        return "Dockerizing Spring Boot Application";
    }

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

}

Step 6: Start the application by running the following command in your terminal:
./mvnw spring-boot:run

Step 7: Navigate to http://localhost:8080 in your browser to test the application.

Step 8: Create a new file called Dockerfile in the root directory of your Spring Boot project, and paste the following contents:

# Fetching latest version of Java
FROM openjdk:18

# Setting up work directory
WORKDIR /app

# Copy the jar file into our app
COPY ./target/spring-0.0.1-SNAPSHOT.jar /app

# Exposing port 8080
EXPOSE 8080

# Starting the application
CMD ["java", "-jar", "spring-0.0.1-SNAPSHOT.jar"]

Step 9: Build a new Docker image by running the following command in your terminal. Replace [name:tag] with a name and tag for the image:
docker build -t [name:tag] .

Step 10: Once the build process is complete, you can start a new Docker container by running the following command:
docker run -p 8080:8080 [name:tag]
The -p flag maps the exposed container port to a port on the host machine. In this case, we are mapping port 8080 of the container to port 8080 of the host machine.

Step 11: Navigate to http://localhost:8080 in your browser to test the application running inside the Docker container.

And congratulations! You have now Dockerized your Spring Boot application and deployed it inside a container. This makes it easy to deploy and run the application on different machines without worrying about dependencies and environment-specific configurations.

Building GraphQL APIs with Spring Boot

Boufnichel — Sat, 11 Mar 2023 10:37:07 +0000

GraphQL is an API standard that has been gaining popularity in recent years due to its flexibility and efficiency. It allows clients to specify exactly what data they need and in what format, which can reduce the amount of data sent over the wire and improve performance. In this article, we'll explore how to build GraphQL APIs with Spring Boot.

Getting Started with GraphQL

To get started with GraphQL, you need to define a schema that describes the types of data that your API can return. A schema consists of a set of types, each of which has one or more fields. Fields can be of different types, including scalars (like strings and integers), objects (defined by other types), and lists (of other types). Here's an example schema for a simple blog API:

type Query {
  posts: [Post]
}

type Post {
  id: ID!
  title: String!
  body: String!
  author: User!
}

type User {
  id: ID!
  name: String!
}

This schema defines three types: Query, Post, and User. The Query type has one field, posts, which returns a list of Post objects. The Post type has four fields: id, title, body, and author. The author field is an object of type User. The User type has two fields: id and name.

Building a GraphQL API with Spring Boot

Now that we have a schema, let's build a GraphQL API with Spring Boot. We'll use the graphql-java library to parse and execute GraphQL queries.

First, add the following dependencies to your build.gradle or pom.xml file:

dependencies {
  implementation 'com.graphql-java:graphql-spring-boot-starter:15.0.0'
  implementation 'com.graphql-java:graphql-java-tools:15.0.2'
}

Next, create a GraphQL controller that handles GraphQL queries. Here's an example controller:

@RestController
@RequestMapping("/graphql")
public class GraphQLController {

  private final GraphQL graphQL;

  public GraphQLController(GraphQL graphQL) {
    this.graphQL = graphQL;
  }

  @PostMapping
  public ResponseEntity<Object> query(@RequestBody String query) {
    ExecutionResult result = graphQL.execute(query);
    return ResponseEntity.ok(result.getData());
  }
}

This controller maps HTTP POST requests to the /graphql endpoint and executes the GraphQL query passed in the request body. The result of the query is returned in the response.

To create a GraphQL schema from our schema definition, we'll use the graphql-java-tools library. Add the following code to your main Spring Boot application class:

@SpringBootApplication
public class MyApp {

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

  @Bean
  public GraphQLSchema schema() {
    TypeRegistry typeRegistry = new TypeRegistry();
    SchemaParser schemaParser = new SchemaParser();
    typeRegistry.merge(schemaParser.parse(
      "type Query { posts: [Post] }" +
      "type Post { id: ID!, title: String!, body: String!, author: User! }" +
      "type User { id: ID!, name: String! }"
    ));

    RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()
      .type("Query", builder -> builder.dataFetcher("posts", new PostsFetcher()))
      .type("Post", builder -> builder.dataFetcher("author", new AuthorFetcher()))
      .build();

    SchemaGenerator schemaGenerator = new SchemaGenerator();
    return schemaGenerator.makeExecutableSchema(typeRegistry, runtimeWiring)

Spring boot : A security without WebSecurityConfigurerAdapter

Boufnichel — Fri, 27 Jan 2023 20:18:28 +0000

Web security is an essential aspect of any web application, and it is crucial to keep it up-to-date with the latest best practices. One of the ways to secure a web application built with Spring is by using the WebSecurityConfigurerAdapter class. This class has been a powerful tool for developers, as it allows for fine-grained control over the application's security settings. However, starting with Spring Security 5.0, the WebSecurityConfigurerAdapter class has been deprecated in favor of a new approach using the SecurityFilterChain bean.

The old way of configuring security using WebSecurityConfigurerAdapter is a quite verbose and can be confusing for some developers. Let's take a look at an example of how it would look like:

In this example, we are defining two methods configure(AuthenticationManagerBuilder auth) and configure(HttpSecurity http). The first one is used to configure the authentication manager, and the second one is used to configure the authorization rules.

We can see that the configure(AuthenticationManagerBuilder auth) method is used to set up the UserDetailsService and PasswordEncoder to be used by the authentication manager.

The configure(HttpSecurity http) method is used to define the authorization rules. We can see that we are using antMatchers to match the requested URLs, and then we are using the hasRole method to define the role that is required to access those URLs.

As you can see, the old approach is quite verbose, and it can be difficult to understand for some developers. However, starting with Spring Security 5.0, a new approach has been introduced to configure security. The new approach uses the SecurityFilterChain bean, and it is more concise and easier to understand. Let's take a look at an example:

In this example, we are using the SecurityFilterChain bean to configure security. The SecurityFilterChain bean is a functional bean that allows for more flexibility in terms of configuring security settings.
So you only need to implement a single method, for whatever your embeded datasource, and make your config as we want.

Is Spring Boot worth considering over Spring? ?

Boufnichel — Thu, 12 Jan 2023 12:15:01 +0000

A feature of Spring Framework that allows managing application's objects dependencies, it's the dependency injection.

But unlike Spring Framework, Spring Boot has no need of XML configuration (spring beans configuration..).

For example, Why do you need to restart you server manually for every code changes and the starter-projects can make it with just one dependency ?

Spring Boot is a powerful framework that allows developers to quickly create and run Spring-based applications with minimal configuration. It provides a number of features and conventions that make it easier to get started with a new project and to quickly build, test, and deploy your application.

One of the key features of Spring Boot is its starter_projects. Spring Boot provides a number of "starter POMs" that allow developers to quickly add common dependencies to their project(JPA, Devtools, Hibernate...). This can save a lot of time and effort when setting up a new project, as you don't need to manually add and configure all the dependencies. The starter POMs also ensure that you are using the correct versions of the dependencies, which can help to prevent compatibility issues.

Another great feature of Spring Boot is its autoconfiguration. It can automatically configure a lot of the settings and dependencies for your application, based on the libraries you have included in your project. This means that you don't need to spend lots of time configuring your application and can instead focus on writing the code that makes your application unique. The autoconfiguration feature can also help to prevent common configuration mistakes and make it easier to deploy your application to different environments.

Another feature that makes Spring Boot better than Spring Framework is its #embedded_servers. You can run your application on an embedded server, such as Tomcat or Jetty, without the need to set up and configure a separate server(you don't need to add any Library or .JAR files). This can save a lot of time and effort and also makes it easy to deploy your application to different environments.

Finally, Spring Boot includes an #actuator that provides information about the health and performance of your application. This can be very useful for monitoring and troubleshooting your application and also allows you to perform operations such as shutting down the application. This can also help you to quickly identify and fix any problems with your application, which can help to ensure that your application is always running correctly.
All of these features combined make Spring Boot a more opinionated and easy-to-use framework as compared to Spring Framework. It requires minimal configuration and provides many features out of the box, which makes it easy to create and run Spring-based applications. If you are looking to start a new project or to quickly develop and deploy a Spring-based application, then Spring Boot is definitely worth considering.