Practical Java : Spring Boot 3 REST API with Elasticsearch 8

This course covers various technologies that will be used throughout. It introduces Java as a programming language, highlighting its longevity and frequent updates. The Spring framework is discussed, emphasizing its ability to increase productivity and reduce boilerplate code. Eclipse is recommended as an integrated development environment (IDE) for Java development, while Gradle is suggested as a build automation tool and dependency management system. The use of Google Chrome as a web browser, specifically for accessing APIs and viewing JSON data, is mentioned. Postman is introduced as a development environment for APIs, offering features for execution, testing, and documentation. Elasticsearch is suggested as a data storage solution, optimized for search and analytics. Version control using Git is emphasized as a crucial tool for collaboration among developers, with GitHub mentioned as a cloud-based repository for source code. Docker, a popular container technology, is also mentioned as an optional tool for easy installation and running of various technologies.

This lecture provides comprehensive guidance on downloading and installing the essential tools required for Java development with Spring. It covers the installation process for various tools such as Java, Eclipse IDE, Spring Tools Suite, Postman, Git, Elasticsearch, and Kibana. Detailed instructions are provided for each installation step, including setting up environment variables and verifying the installations.

REST API is a crucial tool for connecting applications and facilitating information sharing. It acts as a user interface for applications, allowing them to interact with each other. APIs provide functionality to other applications without exposing internal code. They are language and platform-independent, making them versatile. REST API, based on the REST architectural style, is a widely used standard for web APIs. It follows principles such as a uniform interface, client-server architecture, and statelessness. REST APIs use HTTP protocol and JSON for communication. They offer a secure and efficient way to exchange data and access functionalities.

JSON, or JavaScript Object Notation, is a widely used data format in modern applications based on REST. It represents data in name-value pairs and sometimes includes arrays. JSON is language-independent and uses readable text format. It allows for easy parsing and creation in most programming languages. JSON enables REST API independence, allowing API providers and consumers to communicate regardless of their programming language. Objects in JSON can be nested, and multiple values can be stored in arrays. If an attribute has no value, it can be set as null. JSON provides a flexible and versatile way to exchange data between systems.

The Spring framework offers numerous benefits for application development. Developers often encounter repetitive patterns in their code, such as connecting to databases, but with Spring, these patterns can be simplified and accelerated through its collection of reusable code. This comprehensive framework covers various aspects of enterprise programming and is highly compatible and proven. The best part is that Spring is open-source and free to use, allowing developers to increase productivity without the need to purchase licenses. Additionally, Spring has a large and supportive developer community, along with well-written documentation, making it easy to learn and seek assistance. One key concept in Spring is "Inversion of Control" (IoC), where object dependencies are managed by the framework, reducing code complexity.

Spring Boot is a powerful tool that simplifies the configuration process in Spring. Spring Boot automates repetitive tasks by providing default configurations that can be overridden if necessary. Developers only need to set up values for pre-defined configurations in files like "application.properties" or "application.yml". Spring Framework offers a wide range of libraries for Java programming, and Spring Initializr is an online project generator that allows developers to select the desired Spring technologies and generate initial scripts. Gradle is used as the dependency management tool in this course. By using Spring Boot and Spring Web, developers can create traditional-style REST APIs easily.

In this lecture, we will build a simple "Hello World" application using Spring Boot. The application will be a Spring REST API hosted on localhost port 8080. It will have only one API that, when requested, will return the string "Welcome to Spring Boot". For now, we will return plain text and not use JSON as the data format. To access the API, we can use a web browser or Postman. We will learn about the Spring annotations "@RestController" and "@RequestMapping", which play a significant role in defining REST APIs.

In this lecture, we will explore Postman, a comprehensive API development tool. Postman offers features for sending requests, examining responses, and more. It allows us to work with different HTTP methods, handle request bodies and headers, and provides advanced functionalities. By using Postman, we can easily test and interact with our APIs. It simplifies the process of API development and testing.

In this lecture, we will discuss some tips for improving source code readability in Eclipse. It is recommended to keep your code well-formatted with proper indentation and line breaks. Eclipse can automatically format your code by pressing CTRL-SHIFT-F. Additionally, Eclipse provides features for importing libraries and removing unused imports. You can use CTRL-SPACE for autocompleting imports and CTRL-SHIFT-O to organize imports. Unused imports can clutter your code, and Eclipse will highlight them as warnings. Enabling automatic formatting and organizing imports on save can help maintain clean source code. Another option is to use the EditorConfig plugin for consistent formatting rules across different editors.

In this lecture, we will learn about Gradle, a powerful build and dependency management tool. Gradle automates the build process, including compiling source code, packaging, and running tests. It simplifies the management of external libraries and their dependencies, automatically downloading and linking them to your project. With Gradle, you can easily add libraries like Apache Commons Lang3 by defining dependencies in the build.gradle file. Gradle also supports versioning, allowing you to manage and update library versions easily. To use Gradle, you need to configure the build.gradle file in your Java project. Once configured, Gradle will handle the build and dependency management tasks for you.

The numbering convention used in software versions is called semantic versioning (semver). It consists of three parts: major, minor, and patch numbers. The major number indicates significant changes that are not backward compatible. The minor number represents new features or enhancements that are backward-compatible. The patch number signifies bug fixes or changes that do not affect backward compatibility. By following semver, users can understand the severity of changes in each release. While semantic versioning is not mandatory, it is a widely accepted convention among software users. Each part of the version number increments according to specific rules, and incrementing a higher number resets the lower numbers back to zero.

Spring DevTools is a solution provided by Spring that automatically restarts the server whenever changes are saved in the Java classpath. It eliminates the need for manual server restarts, which can be time-consuming and reduce productivity. By default, Spring DevTools monitors specific folders in the classpath for changes. To include Spring DevTools in your project, you need to add the dependency in the build.gradle file. It significantly improves the development experience by providing faster server restarts and streamlining the development workflow.

In order to distribute your application effectively, it needs to be packaged into an executable JAR file. This JAR file acts as a standalone application that can be run on any machine with Java Virtual Machine compatibility. By generating the executable JAR, you can distribute your application easily without the need for the source code or development environment. The JAR file contains all the necessary components to run the application, making it convenient for deployment.

Introducing an alternative approach for distributing your Java application - deploying it as a WAR (Web Archive) file. While executable JARs package a web server into a single file, WAR files are specifically designed for deployment on Java servers. Popular servers like Apache Tomcat, Jetty, or JBoss are commonly used for this purpose. To generate a WAR file, you can leverage the Spring Initializr tool and adjust the build configuration accordingly. Once generated, the WAR file can be easily uploaded and deployed on your preferred Java server. Simplify your application deployment process by exploring this convenient option.

Discover the power of containerization for your Java application deployment. Containers provide a modern and lightweight approach, with Docker being a popular container technology. By leveraging containers, you can ensure consistent application performance across different environments. With the ability to package the application, runtime environment, and proper initialization instructions, containers offer seamless deployment and execution. Take advantage of this efficient deployment option, allowing your application to run smoothly on any machine. Explore the benefits of containerization and streamline your deployment process today.

Experience flexibility in running your Java application by customizing the server port. With Spring Boot's built-in configurations, you have the power to define your preferred port. Simply modify the application.properties or application.yml file, located under src/main/resources, and set the desired port value. Whether it's changing from the default port 8080 to port 8001 or any other port of your choice, Spring Boot makes it effortless. Take full control of your application's deployment and access it with ease. Explore the extensive list of configurable keys provided by Spring Boot and tailor your application to your specific needs.

Version control is like having a backup for your source code, just like Andy, Alice, and Bob did with their Monopoly game. It allows you to restore previous versions of your code, ensuring that you can always go back to a stable state. Without version control, maintaining multiple backups becomes challenging and time-consuming. However, with tools like Git and platforms like GitHub, you can easily manage your code's history and collaborate with others. GitHub, GitLab, and Bitbucket are popular cloud-based Git repositories that offer security and seamless collaboration for developers and companies worldwide. Join the community and discover the power of version control in safeguarding your code and streamlining your development process.

Create a Git repository effortlessly. Sign in to your GitHub account, click "New repository," and give it a name, such as "practical-java." Choose between public or private repositories to suit your needs. Be cautious not to include sensitive information in public repositories. Say goodbye to complicated setup processes and streamline your workflow with Practical Java's gitignore functionality. Keep your repository clean by ignoring unnecessary files, such as compiled or temporary files.

Simplify Code Management with Git! Easily track changes, collaborate seamlessly, and manage versions of your project. Clone remote repositories, make local modifications, and create save points or commits. Push your changes to the remote repository to keep everyone synchronized. Git's intuitive interface and integration with popular IDEs make code comparison and restoration a breeze. Start streamlining your workflow and enhancing collaboration today with Git!

Logging is a vital process in programming that helps record and track important events, such as errors and debugging information. It enables developers to analyze program behavior and identify issues efficiently. In development environments, programmers have full control over logging, allowing them to easily troubleshoot and gather necessary information. However, in test or production environments, constant monitoring is impractical. Logging helps by documenting events for future reference, facilitating effective troubleshooting and problem replication. With frameworks like Logback in Spring Boot, developers gain better control and flexibility in logging, defining what events to log and where to store the logs.

Learn the seamless conversion between JSON and Java in this lecture. Convert your POJOs to JSON effortlessly and vice versa. Spring Boot's inclusion of the Jackson library enables automatic conversion with minimal effort. Build a simple Car API with brand, color, and type attributes. Create endpoints for Java to JSON and JSON to Java conversions. Follow best practices by versioning your API for smooth transitions. Enjoy the convenience of Spring's dependency injection using annotations like @Autowired and @Service.

Learn how to create a Car class with brand, color, and type attributes effortlessly. Generate getters, setters, and toString method with a simple right-click. Clean up your source code for better readability. Build the CarService interface with predefined lists of attributes. Implement the RandomCarService to generate random combinations. Create a REST API with the CarApi class and utilize the @Autowired annotation for dependency injection. Retrieve a random car by hitting the API endpoint. Experience the seamless conversion of Java objects to JSON automatically. Commit and push your work to GitHub using GitHub Desktop.

Discover how to convert JSON to Java effortlessly with our Car API. Modify the API to include a POST endpoint for echoing JSON values. Experience the convenience of logging JSON input at our Java program and returning a descriptive string about the car. No need to handle JSON this time; we'll simply return a simple string. Learn to accept JSON as a request body by annotating the parameter with @RequestBody. Create the echo() method in CarApi.java to handle this new API endpoint. Configure the @PostMapping annotation with the "/echo" path and specify the "consumes" parameter as JSON. Start the server and test the API on Postman by sending a POST request with a JSON request body. Stay tuned for the next lecture to discover what happens in case of errors.

Experience seamless JSON to Java conversion with our powerful API. No need to worry about constructors, as Java automatically handles the creation of a public, no-argument constructor for you. In case you have defined other constructors, simply add the no argument constructor manually. To fix any issues, just navigate to Car.java and include the necessary constructor. Give it a try using Postman, and witness the smooth functioning of our API. Feel free to experiment by adding or removing parameters in the JSON body, and see how our API handles it gracefully. Stay tuned to explore more advanced JSON processing tricks in Java.

In this comprehensive course, we explore common JSON use cases in REST API development. Learn how to configure Java with Jackson to handle JSON data effectively. Discover practical techniques for handling numeric, boolean, and Date data types. We also cover working with arrays and collections, returning multiple cars as JSON, and handling nested class relationships. Unlock the full potential of JSON in your Spring Boot projects with this course.

Discover how to effortlessly convert Java objects to JSON and vice versa in this comprehensive course. Learn the essential concepts of working with Java and JSON, including the importance of providing getters and setters for smooth conversion. Explore practical usage and discover how to handle numeric, boolean, and Date data types effectively. Gain valuable insights into generating random values and working with new attributes in your JSON objects. With Spring's seamless integration, you can easily convert Java objects to JSON and JSON to Java. Simplify your development process and unlock the power of JSON with this course.

Unlock the power of collections in JSON with our comprehensive course. Discover how to seamlessly add additional attributes to your JSON objects, such as a list of strings representing features like GPS, alarm, and more. Learn to handle collections of various data types, including numbers, booleans, and dates, effortlessly. Explore the flexibility of returning collections of objects as JSON, perfect for scenarios where you need to retrieve multiple cars from a database or generate unpredictable counts of rows. With Spring's automatic conversion capabilities, you can simplify your development process and ensure valid JSON output. Join our course now and take your JSON skills to the next level!

Learn how to create specialized classes like Engine and Tire, adding attributes such as fuel type, horsepower, manufacturer, size, and price. With our step-by-step guidance, you'll master the art of generating valid JSON effortlessly. Explore the flexibility of Spring Boot and its Jackson library, as we dive into the world of annotation customization. Take your JSON skills to the next level and unlock a world of possibilities in JSON processing. Join our course now and become a JSON expert!

Join us as we explore various use cases that will enhance your JSON handling skills. In this course, you will learn how to format date and time using custom patterns, change field naming styles to suit your preferences, show or hide specific fields based on criteria, and unwrap nested objects for simplified JSON structure. We provide step-by-step guidance on leveraging annotations like @JsonFormat, @JsonNaming, @JsonProperty, @JsonInclude, @JsonIgnore, and @JsonUnwrapped to achieve your desired JSON output. Don't miss this opportunity to level up your JSON expertise. Enroll in our course today!

Elasticsearch 8 comes with built-in security features, ensuring that your data remains protected through encrypted communication. In our course, we will guide you through the SSL configuration process, including obtaining the Certificate Authority (CA) fingerprint for secure communication. You'll learn how to enable and disable security, set up usernames and passwords for authentication, and even reset your password if needed. We'll also show you how to interact with Elasticsearch using popular tools like Postman, making API integration a breeze. Join our course today and harness the power of Elasticsearch 8 with confidence.

We cover various aspects of creating and managing APIs, including using HTTP verbs like GET and POST. You'll learn how to handle different types of endpoints, including those with variables in the URL and query parameters. We'll guide you through the process of creating, updating, and deleting data, using both PUT and DELETE requests. Additionally, we'll show you how to work with Elasticsearch, a powerful search engine, and integrate it seamlessly with your application using Spring Data Elasticsearch. With Spring Data, you can simplify data manipulation and leverage the support for various data sources. Join our course today and discover the magic of Spring Data for yourself!

In this lecture, we'll guide you through the process of generating thousands random cars and feeding them into Elasticsearch as dummy data. Our step-by-step approach ensures a smooth workflow, similar to working with a relational database. The data source is automatically cleared upon server startup, allowing you to begin with a fresh set of thousands data every time. By leveraging the capabilities of Spring RestTemplate, you'll effortlessly consume Elasticsearch's REST API. Additionally, our course covers important topics like basic authorization, SSL certificate handling, and custom HTTP client configuration. Join us today and gain the skills to create and manage data sources in Elasticsearch like a pro!

Learn basic operations using Postman, including retrieving document counts, creating new entries, and updating records. Harness the power of Elasticsearch's JSON-based data storage and unlock its exceptional search capabilities. Seamlessly integrate Elasticsearch into your Java applications with Spring Data Elasticsearch.

Learn various methods to pass request data, including JSON in the request body, path parameters, and query parameters. Our course guides you through the process of handling different data types effectively. Explore the power of Spring Data Elasticsearch and effortlessly manipulate data in Elasticsearch. Gain control over your API by adding business logic and validation. Start your journey to becoming a proficient API developer today!

Learn the power of Spring Data for efficient querying. Our comprehensive course covers theory and implementation, providing a solid foundation. Simplify database interactions with consistent rules for relational and non-relational databases. Harness automatic query creation based on method names. Customize queries using @Query annotations for specific syntax. Boost your querying skills with Spring Data's flexibility and simplicity.

Discover the simplicity of querying with Spring Data. Easily create queries based on method names and specific parameters. Find cars released after a certain date by utilizing the firstReleaseDate field. Experience the convenience of testing the Spring repository with a GET method in CarApi.java. Effortlessly retrieve a list of cars newer than a specified date by executing the "/cars/date" endpoint. Unleash the power of Spring Data as it generates queries for you, making querying Elasticsearch a breeze. Customize your queries with the @Query annotation for more advanced filtering options. Gain control over your data retrieval process and enhance your Elasticsearch querying skills with Spring Data.

Discover the power of pagination and sorting with Spring Data. Effortlessly retrieve specific portions of data and save bandwidth by fetching only what you need. With Spring Data's built-in pagination feature, you can easily specify the page index and the number of elements to be returned. Take control of your data display by implementing sorting based on your preferred criteria. Experience the simplicity and convenience of pagination and sorting with Spring Data, empowering you to optimize your data retrieval process. Start leveraging these powerful features today to enhance the efficiency of your application.

HTTP headers play a crucial role in passing additional information between clients and servers. They consist of key-value pairs within HTTP messages, allowing for enhanced communication. Headers are case-insensitive and separated by a colon, with values following without line breaks. One advantage is the ability to save bandwidth by selectively retrieving and delivering specific data instead of all at once. Standard headers, such as "User-Agent" and "Last-Modified," provide valuable information about browsers, operating systems, and object modification dates. By understanding how to retrieve headers using annotations or Java HTTP requests, you can leverage this valuable data. Whether you're a provider or consumer, standardizing the usage of HTTP headers ensures seamless communication.

Discover better control over HTTP responses in this lecture. We delve into handling variables and addressing specific scenarios, such as the absence of a desired color in random car searches. Instead of a generic HTTP status 200, we now return status codes like 400 Bad Request to indicate client input issues. To enhance the user experience, we also provide error messages instead of empty collections. This is made possible through the use of Spring's ResponseEntity class, which allows for precise configuration of the HTTP response, including status codes, headers, and body. By leveraging ResponseEntity, we can tailor responses to meet client needs and ensure effective communication between client and server.

Exception handling is a critical part of software engineering, and Spring provides a robust mechanism for REST API error management. With dedicated exception handler methods, such as "handleInvalidColorException()," we can effectively handle specific exceptions and provide appropriate responses. By throwing exceptions like java.lang.IllegalArgumentException with informative messages, we communicate the nature of the error to clients. The response is wrapped in the ErrorResponse class, ensuring a well-structured and meaningful error response. Experience this powerful exception handling in action by trying it out on Postman, and witness the seamless execution of our error handler. Stay tuned as we explore handling multiple exception types in the next phase.

Discover the power of handling multiple types of exceptions within a single controller. In addition to the existing numeric color handler, let's tackle the challenge of handling numeric brand. Introducing our custom exception type, IllegalApiParamException, and the corresponding handler, handleNumericBrandException(). With a simple extension of RuntimeException, we've created a robust custom exception class. By checking if the brand is numeric in the findCarsByParam method, we can now throw IllegalApiParamException with a specific message. To handle this unique exception, we've created the handleIllegalApiParamException method, which gracefully returns a ResponseEntity.

Experience seamless exception handling within Spring controllers. Each controller handles exceptions within its own class, ensuring efficient error management. However, different controllers require separate exception handler methods to address specific exceptions. Let's explore this concept with the CarPromotionApi, a powerful API for retrieving car promotions. By leveraging the carPromotionService, we guarantee valid promotion types and trigger an IllegalApiParamException when necessary. Test the endpoints on Postman to witness the streamlined exception handling and receive accurate error responses.

Ensure the reliability of your code with comprehensive unit testing. Manual testing can be time-consuming, especially when dealing with multiple endpoints. Changes made in one part of the system may unknowingly affect other areas. With unit testing, you can systematically test each endpoint, comparing expected results with actual values. Java provides a robust unit testing framework, and Spring Initializr includes the necessary dependencies for testing with Spring Boot. By implementing unit testing, you can confidently identify and resolve any issues, ensuring the stability and quality of your application.

Create JUnit test cases in the same package as the class to be tested. Each test method is annotated with @Test and has a generated fail() method body. Run the tests to see the results and identify any failures. Focus on implementing the method body for each test case. Annotate the test class with @SpringBootTest and @AutoconfigureMockMvc to configure the Spring environment and enable mocking for API calls. Simulate requests and compare the expected results using MockMvc. Verify that the status is 200 OK and the content matches the expected value. Run the unit tests and celebrate success.

Test the "/api/time" method to ensure it generates the correct value within a 30-second range of the current time. Build a mock HTTP GET request and compare the response content to your own logic using the assert() method. Run the test and celebrate the green results. Witness the effectiveness of unit testing as JUnit identifies the failed test case when you modify the logic in the API. Save time by conducting multiple tests and validating changes instantly without opening Postman. Restore the logic in DefaultRestApi and explore further with testing headers using the "api/header-one" endpoint. Perform the request, expect the response body to contain the header values, and watch all tests pass.

Experience the power of unit testing with CarApiTest.Loop the test code to conduct multiple tests within seconds, saving valuable time. Unleash the full potential of unit testing by testing the creation of a new car using a mock POST request with JSON request body simulation. Validate the success of the test by checking the 2xx status code. Witness the efficiency of unit testing in testing API performance with a maximum execution time of 1 second. Explore the capability of adding request parameters to mock requests and test finding cars by path, checking the number of elements returned. Ensure the list is not null and has a size equal to or less than the specified size. Celebrate the green results and deliver better quality software with confidence.

JUnit provides code coverage to assess test effectiveness. Set targets for code coverage to drive test creation. Execute unit tests for classes to achieve code coverage. High code coverage boosts confidence in software delivery.

Modify Elasticsearch configuration file to set the HTTPS parameter to false. Access Elasticsearch via HTTP on http://localhost:9200. Adjust Spring Boot settings accordingly for seamless operation. Disable security on Kibana by modifying the Kibana configuration file and restarting the server. Access Kibana at http://localhost:5601.

Monitor API performance to make informed improvements. Use tools like Elasticsearch and Kibana for data storage and visualization. Integrate Spring Actuator for automatic data collection. Add Micrometer Elastic dependency to push data to Elasticsearch. Configure data push frequency in application.yml. Start the application and observe data being pushed to Elasticsearch. Generate a large number of requests using Postman to collect metrics. Create graphics and visualizations in Kibana for analysis and monitoring.

Use Kibana to visualize and analyze API performance data.Identify the relevant index pattern for metrics data. Create a new data view for the metrics index pattern. In Kibana's Discover menu, filter and explore the metrics data. Utilize Kibana's readable format and filtering capabilities for easier data analysis. Build charts and dashboards based on the metrics data in Kibana's Visualize menu. Create visualizations such as line charts to track HTTP request counts and status. Customize the display and colors of the visualizations. Monitor the data in real-time with auto-refresh options.

To create a dashboard in Kibana, modify existing visualizations for specific API endpoints and save them with new names. Then, create a new dashboard and add the modified visualizations by dragging and dropping them into the layout. Finally, save the completed dashboard and enjoy the easy data visualization provided by Elasticsearch and Kibana.

To create API documentation using OpenAPI specification, add the springdoc-openapi dependency to your project. Create a new configuration class, OpenApiConfig, with minimal configuration and annotate it as @Configuration. Define a method that returns OpenApi and annotate it as @Bean. Expand each API to see detailed information about parameters, requests, and responses. You can also try out the API by clicking the "try it out" button.

Springdoc provides annotations to build API documentation. Use `@Tag` at the class level to set the API's documentation and name. Use `@Operation` for methods and specify the API's description. Annotate parameters with `@Parameter`, and use `@ApiResponses` to define possible HTTP status responses. To hide the "Try it out" button, configure the `application.yml` file. With Springdoc, creating and sharing API documentation becomes easy, allowing you to showcase the value of your API to others.