Welcome to this article where you will receive training on creating a simple calculator using Spring Boot. This project will provide you with hands-on experience and a deeper understanding of how to leverage Spring Boot's capabilities to develop a functional web application. Whether you're looking to solidify your knowledge or explore new concepts, this guide will help you navigate the process with ease.
Creating a simple calculator serves as an excellent introduction to web development using Spring Boot. This project will allow you to implement essential features such as addition, subtraction, multiplication, and division. By the end of this guide, you'll have a fully functional web-based calculator application, complete with a user-friendly interface and robust backend capabilities.
Before diving into the project, it’s crucial to set up your development environment correctly. Here are the key components you'll need:
Once your environment is ready, you can create the project structure. You can initialize a new Spring Boot project easily using the Spring Initializr. Follow these steps:
com.examplesimple-calculatorsimple-calculatorA simple calculator applicationcom.example.simplecalculatorIn your pom.xml file, ensure that you have the necessary dependencies for Spring Web and Thymeleaf. Below is an example of what your pom.xml file might look like:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>These dependencies will enable you to build RESTful web services and render HTML views using Thymeleaf.
Next, we need to create a model for our calculator. In this simple project, we will create a class called Calculator. This class will handle the arithmetic operations.
Create a new Java class in the src/main/java/com/example/simplecalculator directory:
package com.example.simplecalculator;
public class Calculator {
public double add(double a, double b) {
return a + b;
}
public double subtract(double a, double b) {
return a - b;
}
public double multiply(double a, double b) {
return a * b;
}
public double divide(double a, double b) {
if (b == 0) {
throw new ArithmeticException("Division by zero is not allowed.");
}
return a / b;
}
}The Calculator class contains methods for each of the arithmetic operations. Note the exception handling in the divide method, which prevents division by zero.
To create a user-friendly interface, we will use Thymeleaf for rendering our HTML views. Create an HTML file named calculator.html in the src/main/resources/templates directory:
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>Simple Calculator</title>
</head>
<body>
<h1>Simple Calculator</h1>
<form action="#" th:action="@{/calculate}" method="post">
<input type="text" name="firstNumber" placeholder="First Number" required/>
<input type="text" name="secondNumber" placeholder="Second Number" required/>
<select name="operation">
<option value="add">Add</option>
<option value="subtract">Subtract</option>
<option value="multiply">Multiply</option>
<option value="divide">Divide</option>
</select>
<button type="submit">Calculate</button>
</form>
<div th:if="${result}">
<h2>Result: <span th:text="${result}"></span></h2>
</div>
</body>
</html>This form captures user input for two numbers and the desired arithmetic operation.
Now, we need to implement the controller that will handle the requests from the frontend. Create a new Java class named CalculatorController in the same package:
package com.example.simplecalculator;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class CalculatorController {
private final Calculator calculator = new Calculator();
@PostMapping("/calculate")
public String calculate(@RequestParam double firstNumber,
@RequestParam double secondNumber,
@RequestParam String operation,
Model model) {
double result = 0;
switch (operation) {
case "add":
result = calculator.add(firstNumber, secondNumber);
break;
case "subtract":
result = calculator.subtract(firstNumber, secondNumber);
break;
case "multiply":
result = calculator.multiply(firstNumber, secondNumber);
break;
case "divide":
result = calculator.divide(firstNumber, secondNumber);
break;
}
model.addAttribute("result", result);
return "calculator";
}
}This controller processes the form submission and returns the result to the user interface.
To enhance the application, it’s important to validate user input. You can add simple validation checks in the calculate method. Ensure that the input numbers are indeed numeric and handle exceptions accordingly.
If you want to perform input validation, consider leveraging Spring's @Valid annotation and creating a custom validation handler.
Testing is an essential aspect of software development. To ensure your calculator functions as expected, write unit tests using JUnit. Create a new test class CalculatorTest in the src/test/java/com/example/simplecalculator directory:
package com.example.simplecalculator;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
public class CalculatorTest {
private final Calculator calculator = new Calculator();
@Test
public void testAddition() {
assertEquals(5, calculator.add(2, 3));
}
@Test
public void testSubtraction() {
assertEquals(1, calculator.subtract(3, 2));
}
@Test
public void testMultiplication() {
assertEquals(6, calculator.multiply(2, 3));
}
@Test
public void testDivision() {
assertEquals(2, calculator.divide(6, 3));
}
@Test
public void testDivisionByZero() {
Exception exception = assertThrows(ArithmeticException.class, () -> {
calculator.divide(1, 0);
});
assertEquals("Division by zero is not allowed.", exception.getMessage());
}
}These tests validate the functionality of the Calculator class, ensuring that each arithmetic operation works correctly.
Once your basic calculator is up and running, consider adding more advanced features such as:
Incorporating these enhancements will not only improve your application but also provide more learning opportunities as you explore Spring Boot’s capabilities.
Once you have developed and tested your application, it's time to deploy it. You can deploy your Spring Boot application to platforms like Heroku, AWS, or your own server. To build a JAR file for deployment, run the following command in your project's root directory:
mvn clean packageThis command generates a JAR file in the target directory, which you can then deploy on your chosen platform. For detailed deployment instructions, refer to the Spring Boot documentation.
In this article, you learned how to create a simple calculator using Spring Boot. From setting up your development environment to deploying your application, each step was designed to enhance your understanding of web development with Spring Boot.
Last Update: 28 Dec, 2024