DEV Community: Abdulcelil Cercenazi

An Intro to Software Build Tools

Abdulcelil Cercenazi — Tue, 15 Mar 2022 08:50:05 +0000

What are Build Tools 🏗

Build tools are programs that automate the process of building production-ready software from source code.

This process includes 👇🏽

Downloading third party dependencies.
Compiling code with the right configuration.
Running tests and reporting their results.
Packaging the compiled code into executable form.

Why use them 🧐

To understand why we might want to use such tools, let's look on how to build a production ready JAR file from Java source code without using a build tool.

Let's address each task of the ones stated above.

Downloading third party dependencies 🗂

In the Java world, dependencies are packaged into Jar files which we have to find and download to our local machine.

Instead of going through the hassle of finding the Jars online, build tools such as Maven and Gradle ask you to define which dependencies you want and they will search through an online repository (Maven Repository) and download the Jars,

Compiling code with the right configuration 🔧

A typical Java project might have tens or hundreds of Java classes, each of those have to be compiled with the right configuration.

Now, running the javac command with all the classes' names doesn't seem to be a reasonable thing to do as we will have a very long command which we have to update on every new addition of deletion of classes.

Build tools scripts takes care of this for us, as they ask us to follow a convention for our project directory names and they will ensure that everything is compiled and linked correctly.

Running tests and reporting their results🚦

Running the tests without a build tool requires us to run commands from the command line.
Let's take the JUnit testing framework for example:
Running tests in the class MyClassWithUnitTests

java -cp /path/to/my.jar:/path/to/junit.jar junit.textui.TestRunner com.mypackage.MyClassWithUnitTests

Notice the long command and the need to be careful with the classpath and the location of the Jars. This will get unmaintainable with a big number of tests.

On the other hand, build tools like Maven allow us to run the all tests with a single command mvn test. It also offers the ability to run tests in one or more classes using only the classes' names.

Packaging the compiled code into executable form 💾

The jar command allows us to create a Jar file from our compiled classes.
Let's look at a simple example of creating a Jar file:

jar cfe JarExample.jar com.tutorial.JarExample com/tutorial/*.class

The c option indicates that we're creating a file.
The f option specifies the file name (JarExample.jar).
The e option specifies our entry point, and the jar command will add it to the generated manifest file.

Building tools like Maven does the work for us using a single command mvn package

Build Tools Examples

The Java ecosystem has many building tools that are interesting and worth overviewing. We will cover the most important two however.

Maven 🖊

It was released in 2004 as an improvement to Apache Ant. It is an XML-based build tool. It has many plugins to customize the build process.

A Maven project is primarily defined by Project Object Model (POM) file written in XML. This POM.xml file contain the project’s dependencies, plugins, properties, and configuration data.

Gradle 🐘

Gradle was on Maven’s concepts, it was introduced as Maven’s successor. Rather than using Maven’s XML-based project configuration, it introduced a domain-specific language (DSL) based on the Groovy and Kotlin programming languages.

Conclusion 🤝

Build tools automate the repetitive work (Compile, Link, Test, Bundle) we do to get from code to production ready artifacts.

What is Inversion of Control (IoC) in Spring

Abdulcelil Cercenazi — Tue, 22 Feb 2022 13:49:22 +0000

Meet Mr. Beans 🥸

A Bean is a Java object. That's it.
Java objects are units that hold data and logic which make our application do its work. Objects can depend on other objects (dependencies) to complete a certain task.

In Java, creating dependencies is usually done in the constructor of the class using the new keyword.

Example of Traditional Bean Creation 🧑‍🔧

Say we have a DownloadService that depends on a ConnectionService.
The ConnectionService needs an address and a password to set up its connection.

public class ConnectionService {  

    public ConnectionService(String address, String password)  
    {  
        // use address and password to set up the connection  
  }  
    public void connect()  
    {  
        // connecting things  
  }  
}

Now, if the DownloadService wanted to use the ConnectionService it has to know how to construct it. It has to get the password, the address and call the ConnectionService constructor.

public class DownloadService {  
    ConnectionService connectionService;  

    public DownloadService()  
    {  
        String password = getPassword();  
        String address = getAddress();  
        connectionService = new ConnectionService(address, password);  
    }  
    public void download()  
    {  
        connectionService.connect();  
        // download things  
  }  
    private String getAddress()  
    {  
        return "address";  
    }  

    private String getPassword()  
    {  
        return "pass";  
    }  
}

This is all fine and dandy, but what if we had 10 or more classes that use the ConnnectionService? Then they all have to know how to get the password, the address and call the constructor.

This is certainly not maintainable and hard to follow around.

Inversion of Control (IoC) to the Rescue 🏋️‍♂️

In the software development world, there is a well-known rule called the Single Responsibility Principle. It urges developers to assign a single responsibility to a method or a class.
So in our above example, the DownloadService should not know how to construct the complicated ConnectionService, it should just use it.

What the IoC pattern suggests is that the DownloadService service should invert the responsibility of creating the ConnectionService to some other entity.

This entity could be, for example, a factory class.

public class ConnectionFactory {  

    public ConnectionService createConnectionService()  
    {  
        String password = getPassword();  
        String address = getAddress();  
        return new ConnectionService(address, password);  
    }  

    private String getAddress()  
    {  
        return "address";  
    }  

    private String getPassword()  
    {  
        return "pass";  
    }  
}

Then in the DownloadService, we call the ConnectionFactoy which knows how to construct a ConnectionService object.

public class DownloadService {  
    ConnectionService connectionService;  

    public DownloadService()  
    {  
        connectionService = new ConnectionFactory().createConnectionService();  
    }  
    public void download()  
    {  
        connectionService.connect();  
        // download things  
  }  
}

IoC in Spring ☘️

Spring offers a helping hand using the IoC Spring Container. All we have to do is describe our beans to the container in a configuration class and it will give them to us whenever we want.

Let's test this with our above code:

public class ConnectionService {  

    public ConnectionService(String address, String password)  
    {  
        // use address and password to setup the connection  
  }  
    public void connect()  
    {  
        System.out.println("Connecting...");  
        // connecting things  
  }  
}

Now, let's introduce the configuration class which will provide us with the ConnectionService bean.

@Configuration
public class AppConfiguration {  
  @Bean  
  ConnectionService connectionService()  
    {  
        String address = getAddress();  
        String password = getPassword();  
        return new ConnectionService(address, password);  
    }  

    private String getAddress()  
    {  
        return "address";  
    }  

    private String getPassword()  
    {  
        return "pass";  
    }  
}

Two new things to note here:

The @Configuration annotation indicates that the class has @Bean definition methods. So Spring container can process the class and generate Spring Beans to be used in the application.
The @Bean declares the object returned from the method as a Bean to be managed by Spring IoC container.

Finally, let's check out our DownloadService class which will have the ConnectionService Bean injected in.

@Component  
public class DownloadService {  
    private final ConnectionService connectionService;  

    @Autowired
    public DownloadService(ConnectionService connectionService)  
    {  
        this.connectionService = connectionService;  
    }  
    public void download()  
    {  
        connectionService.connect();  
        // download things  
  }  
}

An important detail to pay attention to here is the @Component and @Autowired annotations.

The @Component will tell Spring to manage the DownloadService as a Bean. Doing this, Spring will create the class and inject any Beans it depends on (ConnectionService in this example) into the class.

The @Autowired will tell Spring to get the objects declared in the constructor parameters from the Spring IoC container, which in our case was declared in the AppConfiguration class.

Now, that was a good move to have the IoC principle implemented in our system. Spring, however, offers an even more convenient way to handle IoC.

We can remove the AppConfiguration class and simply have the logic of instantiating the ConnectionService inside of it and have Spring create the Bean and make it ready for use.

@Component  
public class ConnectionService {  

    public ConnectionService()  
    {  
        // use address and password to setup the connection  
        String address = getAddress();  
        String password = getPassword();  
    }  
    public void connect()  
    {  
        // connecting things  
    }  

    private String getAddress()  
    {  
        return "address";  
    }  

    private String getPassword()  
    {  
        return "pass";  
    }  
}

Note the @Component annotation which tells Spring to treat this class as a Bean and have it in the Spring IoC ready for the DownloadService to use.

Beans' Life Cycle 🌕 🌖 🌗 🌘 🌑

Spring Bean factory manages the lifecycle of beans created through the Spring container and controls the creation and destruction of the beans.

Let's explore the phases of a Spring Bean's life cycle:

Bean definition.
- It's defined by the @Bean annotation over methods in the configuration file (the one annotated with @Configuration file).
- Or using the @Component annotation and its derivatives (@Service, @Controller, etc..) over classes.
Bean Instantiation.
- Spring instantiate bean objects and loads the objects into the ApplicationContext.
Populating Bean properties.
- Spring scans the beans and sets relevant properties as id, scope, and the default values.
Pre-Initialization
- Spring’s BeanPostProcessors do their work.
AfterPropertiesSet
- Spring executes the afterPropertiesSet() methods of the beans which implement InitializingBean.
Custom Initialization
- Spring triggers any initialization methods that we define.
Post-initialization
- Spring’s BeanPostProcessors do their work for one more time.
Ready
- The Bean is ready and injected into all other dependencies.
Pre-Destroy
- Spring triggers @PreDestroy annotated methods in this phase
Destroy
- Spring executes the destroy() methods of DisposableBean implementations
Custom Destruction
- Spring triggers any custom destruction methods that we've defined.

Conclusion ✍️

The principle of Inversion of Control helps us write clean, maintainable code.

This can be achieved by separating the logic of creating complex objects into a class of their own (separation of concerns).

Spring offers a neat solution using Spring's ApplicationContext and Spring's IoC container. The container treats our objects as Beans which have life cycles managed by Spring and custom methods that we can introduce.

Get To Know Annotations in Java

Abdulcelil Cercenazi — Fri, 04 Feb 2022 18:04:22 +0000

What Are Annotations? 🧐

They allow us to mark (annotate) certain Java language elements as having certain properties (annotations).

What Elements?

Package, Class, Method, Field, Parameter.

What Are They Used For? 🤓

There has been a growing trend in the Java world towards annotating elements as having particular attributes that indicate they should be processed in special ways by development tools, deployment tools, or run-time libraries.

Mainly, they are used either on:

Compile time 👇

To examine classes and issue compilation errors or warnings.
To create new source files.

Run time 👇

take actions to do accomplish some task based on the annotations, for example to validate parameters given to a method.

Let's look at two examples using Java annotations 👀

Embed instructions for the Java compiler or source code processing tools (please generate getters for my fields using Lombok annotations).

@Getter @Setter  
public class Shipment {  
    private Integer id;  
    private String serialNumber;  
}

Embed instructions that can be read on run time (using reflection) by your app or third party libraries (Spring for example).

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

Creating Your Own Annotations 🤝

Let's create an annotation called CoolAnnotation which we want to be accessible in compilation time and usable only by types (Classes, Interfaces or Enums).
We also want to add a name value which must be specified by the user.

@Retention(RetentionPolicy.SOURCE)  
@Target(ElementType.TYPE)  
public @interface CoolAnnotation {  
    String name();  
}

Let's use it on a class

@CoolAnnotation(name="myName")  
public class ShipmentService {
    // buisness things 
}

How To Use This Annotation? 🧠

On Runtime 👈

We can read those annotations at runtime and choose to take actions based on their values

Let's introduce the same cool annotation we had before, but this time let's make it visible on runtime

@Retention(RetentionPolicy.RUNTIME)  
@Target(ElementType.TYPE)  
public @interface CoolAnnotation {  
    String name();  
}

And annotate it to the service class

@CoolAnnotation(name="myName")  
public class ShipmentService {  
}

Now let's test it on runtime

import org.junit.jupiter.api.Test;  
import static org.junit.jupiter.api.Assertions.assertEquals;

public class ShipmentAnnotationTest {  
  @Test  
  public void testAnnotation()  
    {  
        String name = ShipmentService  
                .class  
                .getAnnotation(CoolAnnotation.class)  
                .name();  

        assertEquals("myName", name); // lights green 
    }  
}

On Compile time 👈

This is done via compile time annotation processors.

Processors can

Create new resource files.
Create new code source files.
Issue note, warnings and errors which can cause the compilation to fail (picked up by the IDE).
They can't modify existing resources or source code files.

Writing a processor ✍️

It's a topic that requires a post on its own, however you can watch this excellent YouTube video on the topic.

Conclusion 👩‍🎓 🧑‍🎓

Annotations allow us to give Java elements some properties (meta-data) that are used either at compile time or runtime.

This offers major benefits to the Java world like offering static type checking at compile time, automated processing at runtime. This is used heavily in frameworks like Spring and Hibernate.

Don't Miss These Two Important Hibernate Tips

Abdulcelil Cercenazi — Mon, 01 Nov 2021 18:40:56 +0000

Avoid Bi-directional Relationships ☝️

In bi-directional relations we have to remember to set both ends of the relation to reference each other whenever we want to persist one of them.

If we don't one of the two ends will have a null reference to the other and we would mess up our data 😿

Moreover it's very uncommon for us to traverse relationships both ways.

Let's look at an example 👇

Say we have Order and OrderLine entities that have a one-to-many relationship.

Let’s do it the bi-directional way 🚫

@Entity
@Table(name = "ORDERS")
@Data
public class Order{
    @Id
    @GeneratedValue
    Integer id;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    List<OrderLine> orderLines = new ArrayList<>();
}

@Entity
@Data
public class OrderLine
{
    @Id
    @GeneratedValue
    Integer id;

    @ManyToOne
    Order order;
}

So, to make sure we have both ends set up we need to

Order order = new Order();

OrderLine orderLine = new OrderLine();
orderLine.setOrder(order);

order.getOrderLines().add(orderLine);

entityManager.persist(order);

And now let’s do it the unidirectional way ✅

@Entity
@Table(name = "ORDERS")
@Data
public class Order{
    @Id
    @GeneratedValue
    Integer id;

    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name = "ORDER_ID")
    List<OrderLine> orderLines = new ArrayList<>();
}

@Entity
@Data
public class OrderLine
{
    @Id
    @GeneratedValue
    Integer id;
}

Doing the following should persist both entities.

Order order = new Order();

OrderLine orderLine = new OrderLine();

order.getOrderLines().add(orderLine);

entityManager.persist(order);

Limit Relationships Via Numeric IDs ☝🏾

For entities that have different contexts, represent the relationship between them using Ids and not actual classes.

Say we have an OrderLine entity and a Product entity.

@Entity
@Data
public class OrderLine
{
    @Id
    @GeneratedValue
    Integer id;

    @ManyToOne
    Product product;
}

@Entity
@NoArgsConstructor
@AllArgsConstructor
public class Product
{
    @Id
    @GeneratedValue
    Integer id;
}

In this case if we fetch an OrderLine object then the Product will be fetched eagerly as well because the default behavior of ManyToOne is an EAGER fetch 🏃🏽‍♂️

Plus BDD principals says we should keep the Product and OrderLine entities separate from each other because they belong to different contexts.

The best way is to include Product in OrderLine as an ID.

Example time 🏋🏽‍♂️

@Entity
@Data
public class OrderLine
{
    @Id
    @GeneratedValue
    Integer id;

    Integer productId;
}

And the code to set the product ID would be like:

Product product = new Product();  
entityManager.persist(product);  

Order order = new Order();  

OrderLine orderLine = new OrderLine();  
order.getOrderLines().add(orderLine);  
orderLine.setProductId(product.getId());  

entityManager.persist(order);

Credits 🙌🏾

This post was made mainly derived from Victor Rentea's Designing Expressive and Performant Persistence Models for Relational DBs.

Be careful Of This Java Optional Method

Abdulcelil Cercenazi — Wed, 13 Oct 2021 22:21:16 +0000

Let's Remember Java Optional 🤓

According to Oracle it's "A container object which may or may not contain a non-null value."
Optional was introduced in Java 8 and has been used by the SpringBoot team in many projects.

The most common usage of Optionals is in the Spring Data project. Let's look at the JpaRepository interface and an example method.
Say we have a User entity with an Id type of integer and that we have a JpaRepository for it

@Repository  
public interface IUserRepo extends JpaRepository<User, Integer>  
{  
    Optional<User> findByUserName(String userName);  
}

We defined a method that searches for a user via their user name and returns an Optional of a User.

Optional's Convenience Methods 🙌

Optional comes in with many method meant to enable us to write clean and readable code.

map(..).or(...)
map(...).orElse(...)
check out Oracle's docs for the full list.

However, there is one method with a dangerously unexpected behavior

Meet The `orElse` Method 👀

According to Oracle's doc:

public T orElse(T other) 
Return the value if present, otherwise return other.

Now, we can add a method call as the parameter of the orElse, which will be run if the Optional is empty, right?

Yes, that's correct, BUT, what if I tell you that it will run anyways regardless of the presence of the value in Optional or not.

Let's test it ✍️

@Test  
public void orElseTest()  
{  
    String result = Optional.of("hello").orElse(someMethod());  
    assertThat(result).isEqualTo("hello");  
}  
private String someMethod()  
{  
    System.out.println("I am running !!");  
    return "hola";  
}

The test does pass, but we notice that on the console we have the string "I am running" printed out.

Why is that? 🤨

Java runs the method to provide a value to be returned in the Else case.

So Be Careful ⛔️

We want to be careful if the method inside the orElse might have a side effect, because it will be run anyways.

What To Do then?

You can use the OrElseGet method which takes a supplier method to be executed if the Optional exists

Check out this wonderful comment for more details.

👉🏾 Also check out How to escape NullPointerExceptions in Java using Optional

🖐 5 Things Every Developer Must Know about Software Architecture

Abdulcelil Cercenazi — Sun, 26 Sep 2021 23:02:03 +0000

1. Software Architecture Isn’t About Big Design Upfront ☝️

Big designs upfront are usually done in waterfall models of software development.

The waterfall model is predicted to be bad by its own inventor :)

The upfront design should be a basic, good one done with an iterative and incremental process.

When Do We Stop The Architecture Planning? ⛔️

When we have a solid understanding of the following aspects:

The significant architectural drivers
- Cost, Response Time, etc...
Requirements.
Constraints.
The context and scope of the product.
The significant design choices.
Technology used.
Is our application a Monolith or is a set of Microservices?
The risks associated with the product.

2. Every Software Team/Product Needs To Consider Architecture And Needs To Have A Technical Leader ✌️

This is crucial to have consistent patterns in the product.

3. What's The Software Architect Role About 👨‍🔧

Coding.
Keeping an eye on what’s going on with the code base.
Coaching.
Collaboration with others to incrementally draw the architecture of the application.

It’s a continuous role that spans the life of the project.

4. An Architect Doesn’t Need To Use UML 📐

There are several other tools that enable us to create architecture diagrams using GUIs or even using code.

C4-PlantUML (code based)
Diagrams.net (GUI based)
Structurizr (both code and GUI based)

5. A Good Software Architecture Enables Agility ❤️

Credits 🙌

This post has been prepared using the lecture of Simon Brown Five Things Every Developer Should Know about Software Architecture

How To Do System Performance Testing

Abdulcelil Cercenazi — Sat, 18 Sep 2021 20:48:42 +0000

What Is Meant By System Performance 🧐

It's usually described by scalability and usability. However, there are two more important criteria that we should consider systems' performance and the method to test it.

What are Those Criteria 👀

Throughput
- The rate at which a system can process information.
Latency
- The duration between the initiation of an action and its result.

Those two together represent the system's responsiveness, even though they are not necessarily related.

How To Test The Performance 🤨

From the previous two criteria we can see that measuring throughput and latency and comparing them against some values we see fit is basically our testing process.

It's not that simple though. Why 😲

We have so many variables that can affect our system performance test.

The test network traffic (if it's run on the organization's network).
The OS status (is it performing some home cleaning process?)
The run environment status (is the JVM performing garbage collection?)

How To Do It Then? 💁‍♂️

We need to take two things into consideration in order to perform informative performance tests.

1. Control the variables ⚙️

We should have a dedicated testing environment which is a clone of our production environment.
We should control the processes of this environment.
- Network traffic.
- Garbage collection, etc..

2. Test the performance of our performance tests ⚖️

Wait, What? why do you want to test your test?

Well, if the test is slow to start and initiate that would affect the actual code performance measurements and we would have failing tests for code that is actually fast.

How to make sure that our tests are fast enough in order not to make our actual code test fail?

We should test the code using stub methods that do the bare minimum.
- Return hard coded values for example.
Then, if the test passes (meets the throughput and latency requirements) do we insert and test the actual code.

This post was mainly derived from Dave Farley's How To Test Software Performance YouTube video 🙏🏾

Read Spring Properties Like a Pro

Abdulcelil Cercenazi — Sat, 04 Sep 2021 22:57:43 +0000

Configuration Management Is Important ☝️

The necessity of reading configuration in a clean, organized way is growing rapidly especially with the spread of cloud application development and micro-service architecture which requires a lot of integration and connection settings.

What's Wrong With The Typical Way Of Config Reading 🤷

Nothing. However, it can get complicated and messy when we want to inject many of those configs in our code.

Let's look at an example with a single properties file and a test

application.properties ⚙️

demo.test.name=testName  
demo.test.age=16

DemoApplicationTests.java

@SpringBootTest  
class DemoApplicationTests {  
   @Value("${demo.test.name}")  
   private String name;  

  @Value("${demo.test.age}")  
   private Integer age;  

  @Test  
  void loadProperty() {  
      assertEquals("testName", name);  
      assertEquals(16, age);  
  }  
}

Now, imagine we have 5 or 10 of those properties, that would cause our code to be cluttered and hard to follow 🥴

@ConfigurationProperties To The Rescue 🤠

It allows us to inject values from the application.properties file into a custom class.

@Component  
@ConfigurationProperties(prefix = "demo.test")  
@Setter  
@Getter  
public class DemoTestConfigs  
{  
    private String name;  
    private Integer age;  
}

The @Component annotation is to tell Spring to manage this class as a bean and provide it for injection.
The @ConfigurationProperties is what does the magic
- It looks inside the property files in the class path and loads the properties that start with demo.test
The Lombok @Setter is to enable @ConfigurationProperties to populate the values in the DemoTestConfigs class.

We can then simply inject the `DemoTestConfigs` bean into our services. 🤝

Let's check it in a test

@SpringBootTest  
public class ConfigurationPropertiesTest  
{  
  @Autowired  
  private DemoTestConfigs demoTestConfigs;  

  @Test  
  public void loadPropertiesUsingConfigurationProperties(){  
        assertEquals("testName", demoTestConfigs.getName());  
        assertEquals(16, demoTestConfigs.getAge());  
  }  
}

Conclusion 👇

We've seen how @ConfigurationProperties helps us bundle our similar configurations into a single component class which we can inject and use instead of specifying each and every one of them.

Code On GitHub 💻

The Simple Guide To Dockerizing Spring Boot

Abdulcelil Cercenazi — Sat, 21 Aug 2021 16:30:56 +0000

Why Should I Use A Docker Container? 🤨

They are a great replacement for Virtual Machines.
- Why?
  - VMs are big in size (Gigabytes) and slow to run (1-5 mins).
    - Containers on the other hand:
      - Use a shared operating system, this means you can leave behind the useless 99.9 percent VM junk.
    - They are Linux processes that are isolated from each other.

Containers enable us to easily pack, ship, and run any application as a lightweight, portable, self-sufficient container, which can run virtually anywhere.
Containers are easy to deploy in the cloud.

Why Should I Wrap My App In A Docker Container 🤓

Well, to give our app all the benefits we've just described.

How To Do It? 👀

First, create a JAR file from your application.
Given that you are using Maven, run the following command in the pom.xml file directory

mvn clean package

This will create a target directory, in which you can find your JAR file.

Then, create a Docker image using the JAR file we've just created.
Start by creating a file named Dockerfile

FROM openjdk:8  
ADD target/demo-0.0.1-SNAPSHOT.jar demo-0.0.1-SNAPSHOT.jar  
EXPOSE  8085  
ENTRYPOINT java -jar -Dspring.profiles.active=dev demo-0.0.1-SNAPSHOT.jar

This means ☝️

Using the OpenJDK’s Java 8 machine (FROM)
Add this JAR to Docker’s host and name it demo-0.0.1-SNAPSHOT.jar (ADD)
Expose this app at port 8085 (EXPOSE)
And start the application using this command (ENTRYPOINT)

Then build the Docker image

 docker build -t demo .

This means ☝️

Build an image and give it the tag demo.
Look for the Dockerfile in the current directory.

Finally, run the image.

docker run -p 8080:8085 demo

This means ☝️

Run the image called demo, and map the requests coming from the host machine on port 8080 to the Docker port 8085.

How To Send Requests To Our App Inside Docker? 🤩

Simply send the requests local host on the port we've specified http://localhost:8080/ and they will mapped to the port 8085 inside Docker which will lead to our app.

Last Words ✍️

The Docker world is a wonderful and big place, I recommend you diver deeper into it.
Check out those great resources.
Full YouTube Tutorial💎
Dockerizing a Spring Boot Application⚓️

Code On GitHub💻

Intro To Spring's Aspects

Abdulcelil Cercenazi — Sat, 14 Aug 2021 15:48:21 +0000

What Is A Spring Aspect? 😲

Simply put, it's a reusable part of code (Advice) that is injected into a certain part (joinPoint) of the application (defined by Pointcuts) at runtime.

Why Use it? 🤨

Address common concerns across our application.

Like what?

Logging 📝
Transaction management 🗄
Caching 🔗
Security 🔐

It's used all over the place in Spring framework

Aspect Oriented Programming (AOP) is one of the two core concepts that the Spring framework is built on, the second one being Dependency Injection.

Let's Get To Know the agents behind Spring Aspects 🥷🏽

Join point 🔧

A joinpoint is a candidate point in the Program Execution of the application where an aspect can be plugged in.
This point could be a method being called, an exception being thrown, or even a field being modified.
These are the points where your aspect’s code can be inserted into the normal flow of your application to add new behavior.

Advice 📖

The code that addresses system wide concerns (logging, security checks, etc...) representing the action to perform at a joinpoint specified by a pointcut.

Pointcut 📌

A pointcut is an expression that defines at what joinpoints, the associated Advice should be applied.

Aspect 🔍

Aspect is the class that defines the aspect’s behavior and a pointcut defining where the aspect should be executed.

Ready For Some Coding? 🤩

Let's write a simple use-case of logging something to the console on the call of a certain method.

We'll start by adding the maven dependency for AOP

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

Then, let's create a class and annotate it with @Aspect to mark that this class will contain Advice methods and Pointcuts.
We also need to annotate it with @Component so it becomes managed by Spring.

This class will handle the simple task of logging to the console.

@Component
@Aspect
public class LoggingAspect {
    @Pointcut("@annotation(Loggable)")
    public void logAllMethodCallsPointcut(){    
    }
    @Before("logAllMethodCallsPointcut()")
    public void logAllMethodCallsAdvice(){
        System.out.println("From Aspect");
    }
}

We need to create the loggable annotation

@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
public @interface Loggable {  
}

What did we just write? 👀

@Pointcut("@annotation(Loggable)") declares the logAllMethodCallsPointcut method as a pointcut for all method annotated with Loggable.
@Before("logAllMethodCallsPointcut()") declares logAllMethodCallsAdvice advice which will be called before any method annotated with Loggable.

Now let's create a service that will act as our join point 🧠

@Service  
public class HomeService {  
  @Loggable
  // this here is what's called a join point  
  public void homePage(){  
        System.out.println("From Service");  
    }  
}

Now when we call the homePage method, the logAllMethodCallsAdvice advice method will be called before it.

So we will see the following logs 👇

From Aspect
From Service

Remind Me Why Are We doing This? 😢

This example seems useless for the simple case we have, however imagine having a system with hundreds of methods that you want to log something about them.

Would you call the same code before each and everyone? 🤔
What happens if you want to change the implementation of the logging process?
- You need to search for all the usages and change them 😖
Or, you can create a service and call it from all those places, but imagine having more things other than logging.
- You need to create and call separate service for everyone 😤

Aspects are a life saver as you can now see. 😍😍

Conclusion 🙌

Aspects is one of the most important concepts of the Spring framework.
It's quite handy and provides a mean for clean reusable code.
It has a wide range of use-cases (We only discuss logging).

For more details you can check this rich resource 🤝.

Source code on GitHub 💻.

Handle Spring Exceptions Like A Pro

Abdulcelil Cercenazi — Wed, 04 Aug 2021 19:42:00 +0000

Typical Exception Handling In Java ☕️

It's a common thing in Java to try-catch parts of our code that we except to fail for some reason

Missing files, corrupt data, etc...

try{  
    buggyMethod();  
    return "Done!";  
}catch (RuntimeException e){  
    return "An error happened!";  
}

Exception Handling In Spring 🍃

Let's view the workflow of Spring as a web framework:

Listen to requests from the client.
Take some actions based on our business logic.
Return a response to the client containing the result of our work.

Now, we ideally want to catch any exception (error) that might arise at level 2 (action taking).
We can write a try catch block at every controller method that handles the exceptions in a standard way 🙌🏽

@RestController
@RequiredArgsConstructor  
public class TestController  
{
    private final ExceptionHandler exceptionHandler;

    @GetMapping("/test1")  
    public void test1(){  
        try{  
          // test 1 things  
      }catch (Exception e){  
          exceptionHandler.handleException(e);  
      }  
    }  
    @GetMapping("/test2")  
    public void test2(){  
        try{  
          // test 2 things  
      }catch (Exception e){  
         exceptionHandler.handleException(e);  
      }  
    }
}

👎🏽 The problem with this approach however is that it get quite tedious when we have many more controller methods.

Why capture all exceptions? and not just let them occur?🤷🏼

We want our application to be user friendly and handle all edge cases, thus we want it to return responses with standard format.
We might also want to log those exceptions in a backlog to get back to them and investigate them, or do whatever we like with them.

@ControllerAdvice To The Rescue💪🏾

The idea is that we declare a method that will handle any unhandled exceptions in the application.

How to do it? 👀

First, we need to declare a class and annotate it with @ControllerAdvice.
Then, we declare methods, each handling a class of exception.

@ControllerAdvice @Slf4j  
public class GlobalErrorHandler  
{  
    @ResponseStatus(INTERNAL_SERVER_ERROR)  
    @ResponseBody  
    @ExceptionHandler(Exception.class)  
    public String methodArgumentNotValidException(Exception ex) {  
        // you can take actions based on the exception  
        log.error("An unexpected error has happened", ex);  
        return "An internal error has happened, please report the incident";  
  }
    @ResponseStatus(BAD_REQUEST)  
    @ResponseBody  
    @ExceptionHandler(InvalidParameterException.class)  
    public String invalidParameterException(InvalidParameterException ex){  
        return "This is a BAD REQUEST";  
   }  
}

What does the above code do?☝️

Declares two methods that will be run whenever an exception of class Exception, InvalidParameterException (or subclass of them) is thrown and not handled locally in their thread of execution.
They return a string response back the client.

Note that we can specify more than one handler in the class annotated with @ControllerAdvice.

Now, let's code some endpoints for us to validate against. Let's code three endpoints

One that handles the exception thrown.
The other two leave the handling to the global exception handler

@RestController @RequiredArgsConstructor  
public class TestController  
{  
    @GetMapping("/buggyMethod")  
    public String testMeWithExceptionHandler(){  
        try{  
            buggyMethod();  
            return "Done!";  
      }catch (RuntimeException e){  
            return "An error happened!";  
        }  
    }  
    @GetMapping("/potentialBuggyMethod")  
    public String testMeWithoutExceptionHandler(){  
        undercoverBuggyMethod();  
        return "Done!";  
      }  
    @PostMapping("/invalidParamMethod")  
    public String testForInvalidParam(){  
        buggyParameters();  
        return "Done";  
    }  
    private void buggyMethod(){  
        throw new RuntimeException();  
    }  
    private void undercoverBuggyMethod(){  
        throw new RuntimeException("oops");  
    }  
    private void buggyParameters(){  
        throw new InvalidParameterException();  
    } 
}

Let's Verify It With Some Tests 🧠

@WebMvcTest(controllers = TestController.class)  
public class GlobalExceptionHandlerTest  
{  
  @Autowired  
  private MockMvc mockMvc;  

  @Test  
  public void givenAGetRequestToBuggyEndPoint_DetectErrorMessage() throws Exception  
    {  
        MvcResult mvcResult = mockMvc  
                .perform(get("/buggyMethod"))  
                .andExpect(status().isOk())  
                .andReturn();  
        String response = mvcResult.getResponse().getContentAsString();  
        assertEquals(response, "An error happened!");  
  }  
    @Test  
  public void givenAGetRequestToPotentialBuggyMethod_DetectErrorMessage() throws Exception  
    {  
        MvcResult mvcResult = mockMvc  
                .perform(get("/potentialBuggyMethod"))  
                .andExpect(status().is5xxServerError())  
                .andReturn();  
        String response = mvcResult.getResponse().getContentAsString();  
        assertEquals(response, "An internal error has happened, please report the incident");  
  }
  @Test  
public void givenAPostRequestToBuggyMethod_DetectInvalidParameterErrorMessage() throws Exception  
{  
    MvcResult mvcResult = mockMvc  
            .perform(post("/invalidParamMethod"))  
            .andExpect(status().isBadRequest())  
            .andReturn();  
      String response = mvcResult.getResponse().getContentAsString();  
      assertEquals(response, "This is a BAD REQUEST");  
    }  
}

Conclusion 👈

Unexpected and general errors should be handled elegantly to sustain a smooth experience for our application clients. This is best done using Spring's ControllerAdvice.

Check this article for more details Error Handling for REST with Spring👈

Check the code on GitHub🥷

6 Responsibilities Of Controllers (Spring As An Example)

Abdulcelil Cercenazi — Wed, 21 Jul 2021 17:24:28 +0000

What Is A Controller Anyways? 🧐

It acts as the entry point to our backend application from the outside world.
By outside world I mean

Frontend applications that run on browsers.
Other backend applications that run on servers.

How It's Done?👀

The controller defines entry points that clients from the outside world can talk with using REST operations (GET, POST, DELETE, etc..).
A request that has the matching properties defined by a certain entry point will trigger the function of that entry point.
- The function then calls business logic functions that will do some stuff and return a response to the client.

@RestController  
public class GradeController {  
    @GetMapping("/grade/{id}")  
    public void getGradeById(@PathVariable String id){  
        // business stuff  
  }  
}

The example above describes an entry point at baseUrl/grade/someGradeId that is run when a GET request is made with a URL matching the pattern (baseUrl/grade/1 for example).

What Are The Responsibilities Of A Controller?☝️

Let's list them in order from the moment a request is received to the moment of returning a response.

1️⃣ Listening to HTTP requests👂🏼

What URL/HTTP Types/Request Parameters should trigger this function?

In the example above, we are saying that the function getGradeById will be run when a GET request is made to the url baeUrl/grade/{id}.

2️⃣ Deserializing the input from the incoming request ✍️

Turn the request body into Java objects. Turn the request parameters into Integers, Strings, etc...

@RestController  
public class GradeController {  
    @PostMapping("/grade/add")  
    public void getGradeById(@RequestBody Grade grade){  
        // business stuff  
  }  
}

The Grade class

class Grade{  
  Integer id;  
  String letter;  
  // getters and setters and constructors
}

In this example, turn the POST request body into a Grade object.
The POST requests body should something like this:

{
    "id": "1",
    "letter": "A+"
}

3️⃣ Validating the Deserialized objects🧙

We can specify validation rules against the inputs our controllers take. An error will be thrown if the rules weren't met.
For example, the id parameter shouldn't be negative.

We can do the validation manually

@RestController  
public class GradeController {  
    @PostMapping("/grade/add")  
    public void getGradeById(@RequestBody Grade grade) throws Exception{  
        if (grade.getId() < 0)
            throw new Exception();
  }  
}

Or we can use Spring's validation mechanisms

The Grade class with the validation annotation

class Grade{
  @Min(1) 
  Integer id;  
  String letter;
}

The controller with the annotation to activate the validation

@PostMapping("/grade/add")  
public void getGradeById(@RequestBody @Validated Grade grade)  
{  
    // business stuff  
}

Learn more about Spring validation from my other blog post.👈

4️⃣ Calling business logic 💼

The body of the controller function is executed. It should ideally call functions from the service layer which runs business code.

@RestController @RequiredArgsConstructor  
public class GradeController {  
    private final GradeService gradeService;  
  @GetMapping("/grade")  
    public void getGradeById()  
    {  
        gradeService.doThings();  
  }  
}

Note the usage of Lombok to write cleaner code. Check out my bog post about Lombok here.👈🏻

5️⃣ Serializing the output of the controller function 🛠

The returned value from the function is is turned into a HTTP response.

@RestController  
public class GradeController {  
    @GetMapping("/grade/add")  
    public APIResponse getGradeById()  
    {  
       // do things  
       return new APIResponse("success");  
  }  
}  
@AllArgsConstructor  
class APIResponse{  
    String message;  
}

So the response will be a 200 with a JSON value of

{
  "message" : "success"
}

6️⃣ Handle Exceptions ⛔️

If an exception happens and goes unhandled by the business logic code, the controller translates it into a meaningful response.

Important Note ☢️

As we've seen, the controller has a lot to do! It's very important not to include business logic code in the controller.

I've seen this mistake done many times. I've also seen controllers with thousands of lines of business code.

This leads to creating a timed bomb that could explode on a Monday at 9 PM 💣

DEV Community: Abdulcelil Cercenazi

An Intro to Software Build Tools

What are Build Tools 🏗

Why use them 🧐

Downloading third party dependencies 🗂

Compiling code with the right configuration 🔧

Running tests and reporting their results🚦

Packaging the compiled code into executable form 💾

Build Tools Examples

Maven 🖊

Gradle 🐘

Conclusion 🤝

What is Inversion of Control (IoC) in Spring

Meet Mr. Beans 🥸

Example of Traditional Bean Creation 🧑‍🔧

Inversion of Control (IoC) to the Rescue 🏋️‍♂️

IoC in Spring ☘️

Beans' Life Cycle 🌕 🌖 🌗 🌘 🌑

Conclusion ✍️

Get To Know Annotations in Java

What Are Annotations? 🧐

What Are They Used For? 🤓

Let's look at two examples using Java annotations 👀

Creating Your Own Annotations 🤝

How To Use This Annotation? 🧠

On Runtime 👈

On Compile time 👈

Writing a processor ✍️

Conclusion 👩‍🎓 🧑‍🎓

Don't Miss These Two Important Hibernate Tips

Avoid Bi-directional Relationships ☝️

Let's look at an example 👇

Limit Relationships Via Numeric IDs ☝🏾

Example time 🏋🏽‍♂️

Credits 🙌🏾

Be careful Of This Java Optional Method

Let's Remember Java Optional 🤓

Optional's Convenience Methods 🙌

Meet The orElse Method 👀

Why is that? 🤨

So Be Careful ⛔️

What To Do then?

👉🏾 Also check out How to escape NullPointerExceptions in Java using Optional

🖐 5 Things Every Developer Must Know about Software Architecture

1. Software Architecture Isn’t About Big Design Upfront ☝️

When Do We Stop The Architecture Planning? ⛔️

2. Every Software Team/Product Needs To Consider Architecture And Needs To Have A Technical Leader ✌️

3. What's The Software Architect Role About 👨‍🔧

4. An Architect Doesn’t Need To Use UML 📐

5. A Good Software Architecture Enables Agility ❤️

Credits 🙌

How To Do System Performance Testing

What Is Meant By System Performance 🧐

What are Those Criteria 👀

How To Test The Performance 🤨

It's not that simple though. Why 😲

How To Do It Then? 💁‍♂️

1. Control the variables ⚙️

2. Test the performance of our performance tests ⚖️

This post was mainly derived from Dave Farley's How To Test Software Performance YouTube video 🙏🏾

Read Spring Properties Like a Pro

Configuration Management Is Important ☝️

What's Wrong With The Typical Way Of Config Reading 🤷

Now, imagine we have 5 or 10 of those properties, that would cause our code to be cluttered and hard to follow 🥴

@ConfigurationProperties To The Rescue 🤠

We can then simply inject the DemoTestConfigs bean into our services. 🤝

Let's check it in a test

Conclusion 👇

Code On GitHub 💻

The Simple Guide To Dockerizing Spring Boot

Why Should I Use A Docker Container? 🤨

Why Should I Wrap My App In A Docker Container 🤓

How To Do It? 👀

How To Send Requests To Our App Inside Docker? 🤩

Last Words ✍️

Code On GitHub💻

Intro To Spring's Aspects

What Is A Spring Aspect? 😲

Why Use it? 🤨

Like what?

Meet The `orElse` Method 👀

We can then simply inject the `DemoTestConfigs` bean into our services. 🤝