DEV Community: Asher Toqeer

Modern Java as Data-Oriented Language

Asher Toqeer — Sun, 21 Jan 2024 07:51:48 +0000

Modern Java as Data-Oriented Language

Java, at its core, is an Object Oriented Language. But, Object Oriented Programming alone can't solve all of the problems efficiently. So, with time Java added support for helpful concepts from other programming paradigms. Like, Java 8 introduced first-class support for Functional Programming and now, Java is introducing first-class support for Data-Oriented Programming or DOP.

In this article, we will see what is Data Oriented Programming, why it is useful and how to benefit as a Java developer.

Data-Oriented Programming

Data-Oriented Programming or DOP (not to be confused with Data-Oriented Design) is a programming paradigm that revolves around data as a first-class citizen. The programs are written in a way that functions merely perform transformations over data as they accept one form of data, perform computation and return another form of data. The data is immutable, so it can never be changed during a computation and the result is represented as another form of immutable data.

It is fundamentally different from Object Oriented Programming style where we try to model the real world in the form of "Objects" that have mutable "state" in them that can be modified from an instance method.

For example:

/**
 *  OOP way
 */
cart.addItem(item); // Cart state is mutated as new item is added

/**
 * DOP way
 */
var newCart = addItem(cart, item); // A new cart is created from old cart with new item

Benefits of Data-Oriented Programming

The idea of immutable data and transformer functions is very helpful for certain tasks, especially in the micro-services architecture. Let's say you have a service that consumes system-level messages, categorizes them based on action types, transforms them to run analytics queries or train some ML model and perist them to different data stores based on category and intended use. For this type of task, you are merely operating on data so the Data-Oriented Programming style makes more sense than the traditional OOP style.

Java and Data-Oriented Programming

Yehonathan Sharvit explained DOP very well in this excellent write-up: Principles of Data-Oriented Programming. He provided four principles of DOP:

Separate code (behavior) from data.
Represent data with generic data structures (like maps, lists, sets etc. classes are not allowed).
Treat data as immutable.
Separate data schema from data representation.

Can follow these principles in Java?

We can follow principles 1 and 3 by having immutable data types with no instance methods and writing functions separately, however, we can not follow principle 2. Technically, we can avoid classes and represent data in generic data structures like maps or lists, but, it would mean that we will lose all of type safety. For example, here is how we can represent a user as a map of key-value pairs:

/**
 * A user object represented as a map of values, we have lost type safty
 * 
 * */
Map<String, Object> user = new HashMap<>();
user.put("name", "John Doe");
user.put("email", "john@example.com");
user.put("age", 24);
user.put("dateOfBirth", "2000-01-01");

// we need to type cast to get values
String name = (String) user.get("name");
int age = (int) user.get("age");

In Java we don't compromise on type safety, hence we prefer classes over a generic data structure. Since we are following structure anyway, there is no need for principle 4 as well.

So, In Java, we primarily follow two principles of DOP:

Separate code (behavior) from data.
Treat data as immutable.

Now you might say this is not (according to 4 principles) pure DOP, and you are right, it is not pure. The focus of Java is not being pure. It is on being as effective as possible as a general-purpose programming language.

Data-Oriented Programming as of Java 21

Let's say we are working on some e-commerce system and we have different order-related events like the order created, shipped, delivered, canceled etc. We need to execute some business logic based on event type. Let's implement it in DOP style.

Record type and Sealed classes

The data (events) needs to be immutable so we will use Java Record type. It will provide immutability out of the box. We are also going to need an Event base class for which we want to restrict inheritance to order events only. We will use sealed keyword for that. Our events would look like this:


public sealed interface Event {

  String orderId();

  record OrderCreated(String orderId) implements Event { }
  record OrderShipped(String orderId, ShippingDetails shippingDetails) implements Event { }
  record OrderDelivered(String orderId) implements Event { }
  record OrderCancelled(String orderId) implements Event { }
}

Pattern Matching in instanceof

We can use enhanced pattern-matching capabilities in instanceof operator to write conditionals. For example:

Pattern variable


if (event instanceof OrderCreated orderCreated) {
  var orderId = orderCreated.orderId();
  out.printf("Order created with orderId %s", orderId);
}

This will first check if (event instanceof OrderCreated) is true. If yes, then it will automatically perform (OrderCreated) event and store value in orderCreated that you can directly use.

Record Pattern

Record patterns allow you to deconstruct a record directly in conditional:

if (event instanceof OrderShipped(var orderId, var shippingDetails)) {
  var state = shippingDetails.state();
  var city = shippingDetails.city();
  var address = shippingDetails.address();
  out.printf("OrderShipped to %s %s %s", state, city, address);
}

Here we are getting orderId and shippingDetails directly instead of going through some orderShipped variable.

These record patterns can also be nested, allowing you to get values from a deeper hierarchy of records:

if (event instanceof OrderShipped(var orderId, ShippingDetails(var state, var city, var address))) {
  out.printf("OrderShipped to %s %s %s", state, city, address);
}

The above pattern will only be matched if ShippingDetails is not null and then deconstruct the record and provide access to its members.

Pattern matching in `switch` statement

We can also use this power of pattern matching in switch statements, allowing a concise way of implementing business logic:

switch (event) {
  case OrderCreated orderCreated ->  out.printf("Order created with id: %s", orderCreated.orderId());
  case OrderShipped(var orderId, ShippingDetails(var state, var city, var address)) ->  out.printf("OrderShipped to %s %s %s", state, city, address);
  case OrderDelivered(var orderId) -> out.printf("Order delivered %s", orderId);
  case OrderCancelled(var orderId) -> out.printf("Order cancelled %s", orderId);
}

The future

Java will add more functionality related to DOP in the future. For example JEP 443: Unnamed Patterns and Variables is already in preview. Once finalized, it will allow developers to write even more concise deconstruction patterns where unused variables can be marked by unscored _:

if (event instanceof OrderShipped(_, ShippingDetails(var state, _, _)) && state == "NY") {
  // gets executed only if state code is NY
}

There are also more exciting features in progress. Check out Project Amber for more details.

Originally published at https://thebackendguy.com on January 17, 2024.

Spring Framework Brief Overview

Asher Toqeer — Fri, 02 Apr 2021 06:09:51 +0000

History

Spring is a framework for Java Enterprise Application Development. It started in 2003, at that time Java offers J2EE for enterprise applications but it was complex and hard to use. Spring Framework was developed as a response to that complexity. Spring grew in popularity and became a defacto standard for Java enterprise application development.

What do we mean by Spring?

Initially, the Spring framework was a single project which provides enterprise application development features alongside Dependency Injection, but over time it grew into a full ecosystem of related projects for different aspects of an application. For example, we have Spring Web MVC for web-related tasks, Spring Data for data management, Spring Security for application security, and so on. Here is the full list of Spring projects from official site. Now when we say "Spring" we are referring to the whole eco-system of Spring-based related projects.

How to use Spring?

Since there are different projects offered by Spring, configure them properly could be a challenge, even for experienced developers. To overcome this, Spring provides a project called Spring Boot for bootstrapping a Spring application. Spring Boot takes away all of the complexity of setting up a spring application and you can configure any Spring related project with minimum or no configuration. Spring prefers convention over configuration, so most of the features just work right out of the box with no additional configuration required.

Conclusion

Spring Framework started as a Java Enterprise application development framework which grew in popularity and today it has become an eco-system of related projects. Spring Boot is a spring project for bootstrapping a spring application and hides the complexity of configuring different Spring projects together. Spring prefers convention over configuration and most features just work with minimum or no configuration.

Java Spring Download File From Controller

Asher Toqeer — Mon, 29 Mar 2021 14:07:37 +0000

There are situations when we need to return a downloadable file from a controller method, for example, we might need to return a dynamic pdf generated from db records, or some csv containing records or some processed image etc.

To return a file from the spring controller, you just need to return bytes with appropriate headers. This article will explain how to download a file from a spring controller method.

Let's say have a GET /demo-file-download end point and we want to return a demo-file.txt with dynamically created content. Our controller method will look like:

    @GetMapping(value = "/demo-file-download")
    public ResponseEntity<byte[]> demo() { // (1) Return byte array response
        String demoContent = "This is dynamically generated content in demo file"; // (2) Dynamic content
        ...
    }

(1) We are returning a byte array response in response to GET /demo-file-download .
(2) This is dummy dynamic content, this could be records from db or some calculated data.

We need to set appropriate headers so that browser can handle response properly:

    @GetMapping(value = "/demo-file-download")
    public ResponseEntity<byte[]> demo() { // (1) Return byte array response
        String demoContent = "This is dynamically generated content in demo file"; // (2) Dynamic content
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.set(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_OCTET_STREAM_VALUE); // (3) Content-Type: application/octet-stream
        httpHeaders.set(HttpHeaders.CONTENT_DISPOSITION, ContentDisposition.attachment().filename("demo-file.txt").build().toString()); // (4) Content-Disposition: attachment; filename="demo-file.txt"
        ...
    }

(3) We are setting header Content-Type: application/octet-stream. This will set MIME type application/octet-stream to indicate response contains binary.
(4) We are also setting header Content-Disposition: attachment; filename="demo-file.txt". This will indicate browser that response is an attachment and it should be saved as demo-file.txt

Finally, we can send content as bytes in response, the complete controller implementation would look like:

import org.springframework.http.ContentDisposition;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class DemoController {

    @GetMapping(value = "/demo-file-download")
    public ResponseEntity<byte[]> demo() { // (1) Return byte array response
        String demoContent = "This is dynamically generated content in demo file"; // (2) Dynamic content
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.set(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_OCTET_STREAM_VALUE); // (3) Content-Type: application/octet-stream
        httpHeaders.set(HttpHeaders.CONTENT_DISPOSITION, ContentDisposition.attachment().filename("demo-file.txt").build().toString()); // (4) Content-Disposition: attachment; filename="demo-file.txt"
        return ResponseEntity.ok().headers(httpHeaders).body(demoContent.getBytes()); // (5) Return Response
    }
}

(5) demoContent.getBytes() will return byte[] . The method will return bytes with http headers for browser to download file.

Run the application, hit http://localhost:8080/demo-file-download in the browser, demo-file.txt will be downloaded automatically with dummy content in it.

Originally published at: All About Spring Framework

Java Spring Framework Dependency Injection Without Spring Boot

Asher Toqeer — Thu, 17 Dec 2020 14:17:21 +0000

Today, Spring Framework is used as an umbrella term for Spring projects and Spring ecosystem, However, Spring Framework is basically a Dependency Injection Framework and we can use its Dependency Injection capabilities in any Java project, without using Spring Boot or any other Spring project.

Example Java Project

Let's say we have a Java project with an EmployeeService that has a dependency on DepartmentService and an Application class to run the application:

package com.thebackendguy.com.service;

public class DepartmentService {

    public String getDepartmentName(String employeeId) {
        System.out.println(this + ": getDepartmentName");
        return "Accounts";
    }
}

package com.thebackendguy.com.service;

public class EmployeeService {

    private final DepartmentService departmentService;

    public EmployeeService(DepartmentService departmentService) {
        this.departmentService = departmentService;
    }

    public String checkDepartment() {
        System.out.println(this + ": checkDepartment");
        return departmentService.getDepartmentName("EMP-0098");
    }
}

package com.thebackendguy.com;

import com.thebackendguy.com.service.DepartmentService;
import com.thebackendguy.com.service.EmployeeService;

public class Application {

    public static void main(String[] args) {
        DepartmentService departmentService = new DepartmentService();
        EmployeeService employeeService = new EmployeeService(departmentService);
        System.out.println(employeeService.checkDepartment());
    }
}

Here we are manually creating and injecting dependencies, we want Spring framework to do this, let's add Spring Framework to the project

Add Spring Framework Dependency

We only need spring-context dependency to be added in the project. It is will provide all dependency injection capabilities Spring Framework has to offer. At the time of writing this article, the latest stable version is 5.2.12.RELEASE.

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.12.RELEASE</version>
</dependency>

Creating and Managing Dependencies (Beans)

Spring managed dependencies are called Beans. Since EmployeeService depends on DepartmentService we want Spring to manage that dependency. We need to have a configuration class where we can define dependencies and let Spring know about them.

Spring Beans Configuration class:

Create a new ApplicationConfig class that will hold dependency (Bean) configurations:

package com.thebackendguy.com.config;

import com.thebackendguy.com.service.DepartmentService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration // 1
public class ApplicationConfig {

    @Bean // 2
    public DepartmentService departmentService() {
        return new DepartmentService();
    }
}

@Configuration is a Spring annotation to mark a class as Bean configuration class, it will help Spring framework to find Beans.
@Bean is a Spring annotation to let Spring know about dependency. This annotation is used on a method that Spring will call to obtain that dependency. Here a new DepartmentService instance is returned for Spring to manage. That instance is now called a Bean.

Application Context:

Spring Framework use ApplicationContext to manage the beans. ApplicationContext represents a container, also called Spring Inversion of Control (IoC) container, that contains all of Spring managed instances or beans.

We need to create an Application Context for our application to access beans. Let's update our main Application class.

package com.thebackendguy.com;

import com.thebackendguy.com.config.ApplicationConfig;
import com.thebackendguy.com.service.DepartmentService;
import com.thebackendguy.com.service.EmployeeService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class); // 1
        DepartmentService departmentService = context.getBean(DepartmentService.class); // 2
        System.out.println(departmentService); // 3

        EmployeeService employeeService = new EmployeeService(departmentService);
        System.out.println(employeeService.checkDepartment());
    }
}

Create a new ApplicationContext using our ApplicationConfig class (this class contains our DepartmentService bean). We need to specify configuration class(s) while creating context so that Spring can find our beans. We can use XML based configuration too instead of Annotation based configurations, but for simplicity we will stick with Annotation based configurations.
We are getting DepartmentService bean from application context (or IoC container), instead of creating it here.
We are simply printing departmentService object.

We are passing departmentService to EmployeeService same as before.

Auto Injecting Dependencies (Autowiring Beans)

So far we have created DepartmentService Bean and an ApplicationContext to manage that bean. We can access that Bean using context and pass it to another service, but it would be much cleaner if the Bean "gets injected" automatically, rather than we get it from the application context and inject manually.

This auto injection of dependencies (or Beans) is called Autowiring and Spring provides it out of the box, given that both of the instances (the dependent and the dependency) are Spring Beans. In other words, DepartmentService gets injected in EmployeeService automatically if both of them are Beans. It won't work otherwise. So, let's make EmployeeService a bean too.

Update ApplicationConfig class to add EmployeeService bean:

package com.thebackendguy.com.config;

import com.thebackendguy.com.service.DepartmentService;
import com.thebackendguy.com.service.EmployeeService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ApplicationConfig {

    @Bean
    public DepartmentService departmentService() {
        return new DepartmentService();
    }

    @Bean
    public EmployeeService employeeService() {
        return new EmployeeService(departmentService()); // 1
    }
}

EmployeeService needs an instance of DepartmentService at the time of creation, so we are calling departmentService() to fulfill that dependency, but this will not create a new DepartmentService instance rather it will automatically Inject the previously existing DepartmentService bean. Both of the methods are actually Spring Bean configuration and default Bean scope is singleton (single shared instance per context) and Spring is smart enough to realize and inject existing beans where ever required. (For brevity of this article I am not going into detail of bean scope)

Let's update our Application class to get EmployeeService instance rather than creating it.

public class Application {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class);

        EmployeeService employeeService = context.getBean(EmployeeService.class); // 1
        System.out.println(employeeService.checkDepartment()); 
    }
}

Now we don't need to manually create an instance of EmployeeService and inject DepartmentService dependency. It is now getting handled by the Spring framework.

These are the minimal steps required to use Spring Framework without Spring boot. Spring Framework Dependency Injection has a lot to offer in addition to these basic Dependency Injection capabilities.

Find code on GitHub: https://github.com/thebackendguy-code-examples/java-spring-demo-without-spring-boot

Spring Fix Null @Autowired Field

Asher Toqeer — Sun, 31 May 2020 14:23:59 +0000

Null @Autowired field is a common problem in Spring and the main reason for this is, the instance, in which @Autowired is used, is not a Spring-managed instance.

Spring is a dependency injection framework and dependency injection in Spring only works with Spring-managed instances, called Beans. Hence, the @Autowired field will only get populated when Spring manages both instances, the field itself and the object in which it is getting injected too.

Example:

Let us create a simple application that should return 'HelloWorld'. Let's start with the service layer.

@Service
public class DemoService {

    @Autowired
    private DemoMessageUtil messageUtil;

    public String getMessage() {
        return messageUtil.beautify("HelloWorld");
    }
}

Our service layer depends on DemoMessageUtil utility class, let's create it too:

@Component
public class DemoMessageUtil {

    public String beautify(String text) {
        return "--[" + text + "]--";
    }
}

Perfect, now we need a controller to expose a REST API for GET /message endpoint

@RestController
public class DemoController {

    private DemoService demoService;

    public DemoController() {
        this.demoService = new DemoService(); // Create an instance of DemoService
    }

    @GetMapping("/message")
    public String getMessage() {
        return demoService.getMessage();
    }
}

Run this application and call GET http://localhost:8080/message. You will get an Internal Server Error and you will find following statements in logs:

java.lang.NullPointerException: null
    at com.example.demo.service.DemoService.getMessage(DemoService.java:14) ~[classes/:na]
    at com.example.demo.controller.DemoController.getMessage(DemoController.java:18) ~[classes/:na]
    ...

We got a NullPointerException in DemoService at line:

return messageUtil.beautify("HelloWorld");

. The messageUtil was NULL there.

But, why did this happen? We have used proper annotations like @Component, @Service, Controller.

Problem is in the constructor of DemoController:

...
public DemoController() {
        this.demoService = new DemoService(); // Create an instance of DemoService
    }
...

Here we are creating a new instance of DemoService(), which is NOT a spring-managed instance because we created it, not the Spring context, so the Spring can't manage this instance. That's why @Autowired has no effect in that instance and we got a Null @Autowired field.

To solve this issue, Just remove DemoService creation. Since it is annotated by @Service, Spring will automatically create its instance and we can @Autowired the service in the controller. The updated controller would look like:

@RestController
public class DemoController {

    @Autowired
    private DemoService demoService;

    @GetMapping("/message")
    public String getMessage() {
        return demoService.getMessage();
    }
}

Run the application, and the NullPointerException will be gone.

Conclusion:

Spring dependency injection only works with Spring-managed objects or Beans. If the object in which a Bean is getting injected is not a spring managed object, you will get null @Autowired fields. To fix this, make sure only the framework create and manage the related dependencies.

Java Modules Introduction

Asher Toqeer — Tue, 12 May 2020 05:26:17 +0000

Classes are the basic unit of a program in Java. Packages are used to manage classes and modules are used to manage packages.

Modules were introduced in Java 9. Before that, an application consists of packages that hold classes. It is a problem in large codebases. A public class means that anyone from anywhere could access that class, which can lead to unwanted dependencies. Modules are uniquely named, reusable groups of related packages as well as resources.

A Module controls which packages should be private for internal use only and which should be public for other modules to use. In modular Java, a public class no longer means that anyone can access that class from anywhere, instead, it is public within a module only, unless module exports its package for other modules to use.

From Java 9, the language itself has broken down into modules. Run java --list-modules on JDK 9 or above. It will print out a list of Java modules.

$ java --list-modules
java.base@11.0.5
java.compiler@11.0.5
java.datatransfer@11.0.5
java.desktop@11.0.5
java.instrument@11.0.5
.
.
.

You can check any module's meta-data with the command: java --describe-module [module name]. For example:

$ java --describe-module java.logging
java.logging@11.0.5
exports java.util.logging
requires java.base mandated
provides jdk.internal.logger.DefaultLoggerFinder with sun.util.logging.internal.LoggingProviderImpl
contains sun.net.www.protocol.http.logging
contains sun.util.logging.internal
contains sun.util.logging.resources

exports java.util.logging the classes in this package are accessible to other modules.

requires java.base mandated this module depends on another module named: mandated.

provides ... this module is providing a service implementation (we won't cover services in this article)

contains this is an internal package, accessible within module only.

A bare minimum Java module Example

Our sample application will contain two modules, one for utilities called utils and one main application module that will use the utils module. Let's code it up:

Create a directory JavaModuleExample and cd into it:

$ mkdir JavaModuleExample
$ cd JavaModuleExample/

Create root and subdirectories to contain code. Utils module will be in module.utils directory and App module will be in module.app directory. Both directories will contain their sub-packages. Let's create them:

$ mkdir -p module.utils/com/module/utils
$ mkdir -p module.app/com/module/app

Final Directory Structure would look like:

$ tree
.
├── module.app
│   └── com
│       └── module
│           └── app
└── module.utils
    └── com
        └── module
            └── utils

8 directories, 0 files

In above structure, module.app has package com.module.app and module.utils has package com.module.utils.

Utils Module

Let's complete module.utils. Create a new Java File Utils.java in package com.module.utils with following cat command. It will start waiting for text input.

$ cat > module.utils/com/module/utils/Utils.java

paste following code in console, press Ctrl+D when finished

package com.module.utils;

public class Utils {
    public static int sum (int arg0, int arg1) {
        return arg0 + arg1;
    }
}

[Press Ctrl+D]

To tell Java we are writing a module, we need to provide module-info.java at the root level of the module. Create the following file again with cat command:

$ cat > module.utils/module-info.java

paste following code in console, press Ctrl+D when finished

module module.utils {
    exports com.module.utils;
}

[Press Ctrl+D]

In the above file, we are specifying our module, the name of the module is module.utils, you can name it whatever you want but is a convention to name module the same way as we name packages.

The Other thing is we are exporting a package com.module.utils. We want this package to be available in other modules. If you don't explicitly export it, then by default, it will be only accessible within the module itself.

That's it, we have created a simple module.

App Module

The Next step is to complete module.app. Again, we need module-info.java at the root of our App module and since our app module has a dependency on the utils module, we need to specify that dependency in module-info.java. Create module-info.java with the following command:

$ cat > module.app/module-info.java

paste following code in console, press Ctrl+D when finished

module module.app {
    requires module.utils;
}

[Press Ctrl+D]

In the above file, we need to explicitly tell which modules do we need as a dependency. requires module.utils is specifying we need utils module in our app module.

Now Create Main class to use Utils.

$ cat > module.app/com/module/app/Main.java

paste following code in console, press Ctrl+D when finished

package com.module.app;

import com.module.utils.Utils;

public class Main {

    public static void main(String[] args) {
        System.out.println(Utils.sum(1,2));
    }
}

[Press Ctrl+D]

we are calling sum(...) function from Utils class which exists in the util module.

Finally, our application would look like:

$ tree
.
├── module.app
│   ├── com
│   │   └── module
│   │       └── app
│   │           └── Main.java
│   └── module-info.java
└── module.utils
    ├── com
    │   └── module
    │       └── utils
    │           └── Utils.java
    └── module-info.java

8 directories, 4 files

Compile

Run following command to compile code:

$ javac -d outDir --module-source-path . $(find . -name "*.java")

javac is java compiler that will compile java code to byte code

-d outDir is where our compiled code will go

--module-source-path . we are specifying module source path, which is current directory .

$(find . -name "*.java") we are specifying which files to compile (all files ending with .java)

Run

Run following command to run code:

$ java --module-path outDir -m module.app/com.module.app.Main
3

java --module-path outDir will specify compiled modules directory

-m module.app/com.module.app.Main specifying which class to run, Main class in module.app

3 is printed as a result, which is the result of Utils.sum(1,2), the code we have written in our Main class in the App module.

That was a basic introduction to modules in Java. As a side note, I would like to mention that you should not confuse Java modules with maven modules or IntelliJ IDEA modules. Maven and IntelliJ IDEA have their concepts of modules too. Also, IntelliJ IDEA supports Java modules too see their blog post here.

Originally Published at https://thebackendguy.com/java-modules-introduction/

DEV Community: Asher Toqeer

Modern Java as Data-Oriented Language

Modern Java as Data-Oriented Language

Data-Oriented Programming

Benefits of Data-Oriented Programming

Java and Data-Oriented Programming

Can follow these principles in Java?

Data-Oriented Programming as of Java 21

Record type and Sealed classes

Pattern Matching in instanceof

Pattern variable

Record Pattern

Pattern matching in switch statement

The future

Spring Framework Brief Overview

History

What do we mean by Spring?

How to use Spring?

Conclusion

Java Spring Download File From Controller

Java Spring Framework Dependency Injection Without Spring Boot

Example Java Project

Add Spring Framework Dependency

Creating and Managing Dependencies (Beans)

Spring Beans Configuration class:

Application Context:

Auto Injecting Dependencies (Autowiring Beans)

Spring Fix Null @Autowired Field

Example:

Conclusion:

Java Modules Introduction

A bare minimum Java module Example

Utils Module

App Module

Compile

Run

Pattern matching in `switch` statement