Play Store Application link – Spring Framework in 9 steps – Apps on Google Play

The Spring Web module makes building web applications easier by handling common web development tasks such as handling HTTP requests, session management, and security.

Key Features of the Web Module:

1. HTTP request handling: Easily handle HTTP requests, parameters, headers, and cookies.
2. Web sockets: Enable real-time communication between server and client.
3. Web security: Simplified support for authentication and authorization.
4. Web services: Support for building REST and SOAP services.

Example: Handling HTTP Requests

Let’s look at a basic example to understand how Spring Web simplifies HTTP request handling.

@Controller // Marks this class as a Spring MVC Controller, responsible for handling HTTP requests.
public class MyController {
    @GetMapping("/") // Maps HTTP GET requests to the root ("/") URL.
    public String root() {
        return "home"; // Returns the logical view name "home", which will be resolved to a view file (e.g., home.jsp or home.html).
    }
    @GetMapping("/hello") // Maps HTTP GET requests to the "/hello" URL.
    @ResponseBody // Tells Spring to return the result as a response body (plain text).
    public String hello() {
        return "Hello, world!"; // Returns the string "Hello, world!" as the HTTP response body.
    }
    @GetMapping("/greet") // Maps HTTP GET requests to the "/greet" URL.
    @ResponseBody // Tells Spring to return the result as a response body (plain text).
    public String greet(@RequestParam(name = "name", defaultValue = "Guest") String name) {
        return "Hello, " + name + "!"; // Greets the user by name, or defaults to "Guest" if no name is provided.
    }
    @GetMapping("/user") // Maps HTTP GET requests to the "/user" URL.
    @ResponseBody // Tells Spring to return the result as a response body (JSON representation of the User object).
    public User getUser() {
        return new User("John", "Doe"); // Returns a User object, which will be automatically converted to JSON (if Jackson is present).
    }
}

• @Controller: Marks the class as a Spring MVC controller that handles HTTP requests.
• @GetMapping("/path"): Maps the GET HTTP request for the specified path.
• @ResponseBody: Ensures the return value of the method is sent directly as the HTTP response body, rather than being interpreted as a view name (e.g., JSP or HTML).
• @RequestParam: Binds request parameters (like name in the /greet URL) to method arguments. In this case, if name is not provided, it defaults to "Guest".
• User object: When returning a Java object like User, Spring automatically converts it to JSON format if you have a library like Jackson in the classpath.
• Result for Each Request:
• GET /: Returns a view named “home” (mapped to a view file such as home.jsp or home.html).
• GET /hello: Responds with "Hello, world!".
• GET /greet?name=John: Responds with "Hello, John!". If no name is provided, it defaults to "Guest".
• GET /user: Responds with a JSON representation of the User object, something like:
  { "firstName": "John", "lastName": "Doe" }

Handling Request Parameters

You can also accept request parameters, like so:

@GetMapping("/greet")
@ResponseBody
public String greet(@RequestParam String name) {
  return "Hello, " + name + "!";
}

• @RequestParam: Binds query parameters like ?name=John to method arguments.

Example: Returning JSON Responses

Spring makes it easy to return JSON data for RESTful services:

@GetMapping("/user")
@ResponseBody
public User getUser() {
  User user = new User("John", "Doe"); // Create user object
  return user; // Spring automatically converts it to JSON
}

Github project link (XML based) – https://github.com/kuldeep101990/SpringWebXml

Github project link (Annotation based) – https://github.com/kuldeep101990/SpringWebAnnotation

Practical Web Application Features

1. Session Management:
   Spring can automatically manage HTTP sessions, making it easy to store and retrieve user-specific data across multiple requests.
2. Web Security:
   You can secure your web application using Spring Security, which integrates seamlessly with the Web module to handle authentication (login) and authorization (access control).
3. Building REST APIs:
   Spring’s Web module makes it straightforward to create REST APIs with just a few annotations, allowing for easy interaction between clients and servers.

Conclusion

The Spring Web module simplifies web application development by handling common tasks like request mapping, session management, and response generation. With minimal configuration, you can focus on your application’s core logic without getting bogged down by low-level web development details.