DEV Community: Isurumax26

Guide To Choose A Database For Your Next Design

Isurumax26 — Sun, 26 May 2024 18:51:20 +0000

Why we need to choose a database?

A database is an organized collections of data that can be managed and accessed easily. Each provider has applied these modifications to data stores differently, depending on the type of database and how the database engine is configured. As a result, we are unable to store certain data structures in one type of database but in another.

As an illustration, a relational database cannot hold a graph data structure. These kinds of data structures are intended to be stored in different kinds of databases. Therefore, it is crucial to select the appropriate database for your needs at the design phase rather than selecting the incorrect database type and changing it later on in the development process.

Types Of Databases

We can choose between traditional relational databases and non-relational databases. More than these two words you may have heard SQL and NO SQL databases. Non-relational databases are referred to as NO SQL and relational databases as SQL.

Let's talk about the various factors we took into account before deciding on a database for our designs.

Relational Databases

Relational databases have been around here for more than 40 years and it is the default choice of software professionals for structured data storages. You might have heard about ACID principles. In order to maintain consistency in databases, before and after the transactions, certain properties are followed. These are called ACID properties. One of the greatest powers of the relational database is its abstractions of ACID transactions and related programming semantics.

Some of the important features of relational database are

ACID compliance
The general principle is if one change fails, the whole transaction will fail, and the database will remain in the state it was in before the transaction was attempted.
Reduced redundancy - Normalization
The information related to a specific entity is stored in one table and relent data is stored in another table linked to that by a foreign key. As an example, product related information are stored in a one table and customer who brought the product stored in another table and linked to the production table by a foreign key. This process is called normalization and has the additional benefit of removing anomalies.
Concurrency
Database concurrency is a unique characteristic enabling two or more users to retrieve information from the database at the same time without affecting data integrity. Common issues during concurrent database transactions include dirty reads and lost data updates (dirty reads - This issue arises when a particular transaction accesses a data object written or updated by another uncommitted transaction in the database.). Concurrency in a relational database is handled through transactional access to the data.
If your database is running this transaction as one whole atomic unit, and the system fails due to a power outage, the transaction can be undone, reverting your database to its original state.
Back Up and Disaster Recovery
Relational databases guarantee the state of data is consistent at any time. The export and import operations make backup and restoration easier. Most cloud-based relational databases perform continuous mirroring to avoid loss of data and make the restoration process easier and quicker.

So If our use case required above features then we should consider going with a relational database.

So are there any drawbacks of relational databases?
Yeah of course, let’s discuss some drawbacks of relational databases

Lack of scalability
While using the relational database over multiple servers, its structure changes and becomes difficult to handle, especially when the quantity of the data is large. Due to this, the data is not scalable on different physical storage servers. Ultimately, its performance is affected.
Complexity in Structure
Relational databases can only store data in tabular form which makes it difficult to represent complex relationships between objects. This is an issue because many applications require more than one table to store all the necessary data required by their application logic.

Non-Relational Databases

These databases are used in applications that require a large volume of semi-structured and unstructured data, low latency, and flexible data models. This can be achieved by relaxing some of the data consistency restrictions of other databases.
Following are some of the characteristics of the NOSQL database

Simple Design
Unlike SQL databases, NoSQL databases are not complicated. They store data in an unstructured or a semi-structured form that requires no relational or tabular arrangement. For example storing all the customer related information in a one document instead of multiple tables which require join operations. So less code , debug and maintain.
Horizontal Scaling
As stated above scaling is one of the drawbacks in the relational databases. But scaling is one of the prominent features in non-relational databases. Because we can represent all of the customer related information in a one document instead of multiple tables over several nodes like in relational databases, we scale NoSQL databases pretty easily.
Availability
Most of the non-relational databases support replication to support availability.
Independent Of Schema
Non-relational databases don’t need a schema at the time of database configuration or data writes. As an example, mongo db which store the data in document (JSON, XML) allow different fields in different documents. So Number of fields in different documents can be different

Following are some of drawback of Non-relational databases.

No Support for ACID implicitly
They don’t support ACID (atomicity, consistency, isolation, durability) transactions across multiple documents. But currently there are some newer versions of No-SQL databases which supports ACID properties to some extent. (MongoDB added support for multi-document ACID transactions in the 4.0 release, and extended them in 4.2 to span sharded clusters.)
Relatively Large Storage
In terms of storage utilization, No SQL databases needs more storage because they focus more on query optimization than considering the storage. So there are lot of duplicates data in No-SQL databases
NoSQL databases are divided into various categories based on the nature of the operations and features, including document store, columnar database, key-value store, and graph database.
So we discussed about different pros and cons of relational and non-relational databases. So how do we choose the right database for our requirement.

Choose the right database

Various factors affect the choice of database to be used in an application. A comparison between the relational and non-relational databases is shown in the following table to help us choose:

By taking above table as a guidance we will go through some scenarios

Which database should we use when we have unstructured data and there’s a need for high performance?
So type of data is unstructured and needs high performance. So, it should be No SQL database. NoSQL database like MongoDB would be a perfect choice for this

Which database should we use when we have a financial application, like stock trading application, and we need our data to be consistent all times?
In a stock trading application data will be structured and we need high consistency too. So these are the features of relational database.

What kind of database should we use if we make a retail store application that requires storing the data in tabular format?
if we have tabular data that means we have structured data. Hence, a relational database is the right choice

Which kind of database should we use for making an application like Reddit/Facebook?
The data generated by the these social media applications are mostly unstructured which requires a non-relational databases.

For a web multiplayer game?
In this scenario we need to store data in the database as same as the object in the game so we can deserialize later. Hence, best choice is document oriented NoSQL database.

Creating A Maven Plugin

Isurumax26 — Sat, 12 Aug 2023 19:15:03 +0000

Introduction

Here, we'll make a Maven plugin to run a method of a different project from the plugin. Instead of POJO, this custom plugin is known as MOJO (Mavan Old Java Object).
I'll walk you through the steps involved in making this plugin in this blog.

Creating a Plugin

In this tutorial, we'll build the make-sound plugin, which accepts an object from a consumer project, initializes it there, executes the makeSound method in the consumer, and publishes the results to the console.

We create the plugin
Install it in the maven repo(.m2)
Consumer projects will consume it

To do this, first create a plugin-util module in your project. A few dependencies should be added to the project, and your pom file should appear as follows:

<dependencies>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-plugin-api</artifactId>
            <version>3.6.3</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.maven.plugin-tools</groupId>
            <artifactId>maven-plugin-annotations</artifactId>
            <version>3.6.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-core</artifactId>
            <version>3.9.2</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-plugin-plugin</artifactId>
                <version>3.7.0</version>
            </plugin>
        </plugins>
    </build>

Make sure dependencies are compatible with your java version.

 <groupId>org.example</groupId>
 <artifactId>plugin-util</artifactId>
 <version>1.0-SNAPSHOT</version>
 <packaging>maven-plugin</packaging>

maven-plugin-api – necessary classes and interfaces to create our mojo
maven-plugin-annotation – handy to use annotations in our class
maven-project – lets us access the information about the project

packaging tag also very important because if not by default maven will package this as jar module

Then we need to create our Mojo class

@Mojo(name = "make-sound", defaultPhase = LifecyclePhase.COMPILE)

Our custom class should extends the AbstractMojo class.

@Mojo – This provides us with our mojo's execution name and phase information. I've listed the mojo for the compilation process here. There are other steps, such as testing and deployment, among others.

Then we need to override the execute() method of the super class AbstractMojo

During the execution plugin will execute this method.

@Override
    public void execute() throws MojoExecutionException, MojoFailureException {

        try {
            Class<?> requiredClass = getClassLoader().loadClass(className);

            Animal animal = null;

            for (Constructor<?> constructor : requiredClass.getDeclaredConstructors()) {
                if (constructor.getParameterCount() == 0) {
                    animal = (Animal) constructor.newInstance();
                }
                else if (constructor.getParameterCount() == 1) {
                    animal = (Animal) constructor.newInstance();
                }
                else {
                    throw new IllegalAccessException();
                }

            }
            animal.makeSound();
        } catch (ClassNotFoundException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
            throw new RuntimeException(e);
        }


    }

The plugin will only have access to its class loader during execution, which is crucial to keep in mind. It is unable to reach the consumer's class loader. At compile time, a ClassNotFoundException will be thrown if a consumer class is referenced in the plugin.

Therefore, during execution, you must add the class loader of the consumer to the class loader of the plugin. Using project objects, Maven offers a method for accomplishing this. We must include a MavenProject as a parameter in order to access the project data.
The approach I developed to include the consumer's class loader in the plugin's class loader is shown below.

 public ClassLoader getClassLoader() {
        try {
            Set<URL> urls = new HashSet<>();
            List<String> elements = project.getTestClasspathElements();
            //getRuntimeClasspathElements()
            //getCompileClasspathElements()
            //getSystemClasspathElements()
            for (String element : elements) {
                urls.add(new File(element).toURI().toURL());
            }

            ClassLoader contextClassLoader = URLClassLoader.newInstance(
                    urls.toArray(new URL[0]),
                    Thread.currentThread().getContextClassLoader());

            Thread.currentThread().setContextClassLoader(contextClassLoader);
            return Thread.currentThread().getContextClassLoader();


        } catch (DependencyResolutionRequiredException | MalformedURLException e) {
            return this.getClass().getClassLoader();
        }
    }

You can now access the consumer classes. The consumer object in the plugin class must then be initialized, based on your requirements. The code snippet I used to create the consumer object in the plugin is provided below.

We normally overload constructors in java classes. In those circumstances, we must notify the plugin of the constructor to which we must refer.

try {
            Class<?> requiredClass = getClassLoader().loadClass(className);

            Animal animal = null;

            for (Constructor<?> constructor : requiredClass.getDeclaredConstructors()) {
                if (constructor.getParameterCount() == 0) {
                    animal = (Animal) constructor.newInstance();
                }
                else if (constructor.getParameterCount() == 1) {
                    animal = (Animal) constructor.newInstance();
                }
                else {
                    throw new IllegalAccessException();
                }

            }

We now need to install the plugin module in the Maven repository after developing it. As a result, other modules will be able to use it as well.

So how we do it?

Just run the maven goals form clean -------> install then jar of the plugin will be installed to the maven repo

Adding the Plugin to the consumer module

This procedure is simple and straightforward. The name of your plugin goal, which you specify in the @Mojo annotation, is all that has to be done to add the plugin to the maven repo goal. A plugin may have multiple goals. We must define the plugin-specific parameters inside the configuration tag. I've included the class path for the class that I need to initialize here using the plugin's class Loader.

Keep in mind that we added the consumer's classLoader to the plugin's classLoader.

 <build>
        <plugins>
            <plugin>
                <groupId>org.example</groupId>
                <artifactId>plugin-util</artifactId>
                <version>1.0-SNAPSHOT</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>make-sound</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <className>org.example.Cat</className>
                </configuration>
            </plugin>
        </plugins>
    </build>

Now you have created the plugin module and added it to the consumer class. You just need to build the consumer.
Run the consumer module from clean -------> test phase. Now check console output if you output anything you can see those in the console

The plugin has output "meow" as you can see. This came from the Cat class's makeSound method.

  public void makeSound() {
        System.out.println("meow");
    }

Congratulations you have built a nice maven plugin !

The Hidden Hero of Java: A Deep Dive into the Java Virtual Machine

Isurumax26 — Sat, 25 Mar 2023 06:32:32 +0000

The JVM executes Java bytecode, a compact and platform-independent representation of Java code. When you compile a Java program, it is converted into bytecode, which can then be executed by any JVM that supports the Java language specification. The JVM translates bytecode into machine code that can be executed by the host machine using a combination of interpretation and JIT compilation.

The class loader, bytecode verifier, runtime data area, execution engine, and garbage collector are all key components of the JVM's architecture. Each of these components has a distinct role to play in the execution of Java programs.

Class loader: Class loader is in charge of loading Java class files into memory. It loads the classes as the program references them and ensures that the classes are loaded only once.

Bytecode Verifier: The bytecode verifier ensures that the bytecode can be executed safely and that it adheres to the Java language specification. It checks the bytecode for errors and ensures that no security constraints are violated.

Runtime Data Area: The runtime data area is the memory space used by the JVM to store data at runtime. It is divided into several components, including the method area, heap, stack, and program counter

Execution Engine: The execution engine is in charge of interpreting bytecode and running it on the host machine. It optimizes the performance of the Java program by combining interpretation and JIT compilation.

Garbage Collector: The garbage collector is responsible for automatically managing the memory used by the Java program. It identifies objects that are no longer in use and frees up the memory used by those objects.

Benefits of the JVM
The use of the JVM provides several key benefits to Java developers and users. Some of the most notable benefits include:

Platform Independence: Java programs can run on any platform that supports the JVM thanks to the JVM. This means that developers can write code once and deploy it on multiple platforms without changing it.
Performance Optimization: The ability of the JVM to perform JIT compilation allows it to optimize the performance of Java programs. As a result, execution times are reduced and overall performance is improved.
Memory Management: The JVM's garbage collector automates memory management, freeing developers from having to manually manage memory allocation and deallocation.
Security: The JVM enforces security policies and prevents malicious code from executing, making Java a popular choice for developing applications that require a high level of security.

Conclusion
The JVM is an essential component of the Java platform that offers numerous advantages to developers and users. Its ability to execute bytecode, perform JIT compilation, automatically manage memory, and enforce security policies makes it an effective tool for developing high-performance and secure Java applications. Developers can use the JVM's capabilities to create robust and reliable Java programs by understanding how it works and its key features and benefits

Immutability in java

Isurumax26 — Sun, 13 Mar 2022 08:15:37 +0000

An immutable object is an object whose internal state remains constant after it has been entirely created.

In other words immutable object means whose content cannot be changed. So mutable object means whose content can be changed.

This means that the public API of an immutable object guarantees us that it will behave in the same way during its whole lifetime.

Sometimes we want to create an object whose content cannot be changed after it has been created. Such an object is called immutable object and class which made that object is called immutable class.
Ex - String objects are immutable object and String class is an
immutable class.

Immutable class

All data fields must be private.
There can't be any setter methods.
No getter fields can return a data field that is mutable. If there is are getter methods all of them should return an immutable object Class should satisfy all of these conditions to be an immutable class.

The best way to understand this is through examples. Let's see some examples.
Exmples 1

class A1 {

    private int x;

    public A1(int x) {
        this.x = x;
    }

    public int getX() {
        return this.x;
    }
 }

Is this immutable or not? Check with the rules
all the data fields are private
no any setter methods
getter method doesn't return a immutable object
So this class is a immutable class.

Example 2

class A2 {

    private int x;

    public A2(int x) {
        this.x = x;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }
}

Check with the rules
all the data fields are private
one setter method is there
So this class is not immutable.

I think now you have an good idea about immutable classes. let's see one more example

Example 3

class A1 {
    private int x;
    private A2 a2;

    public A1(int x, A2 a2) {
        this.x = x;
        this.a2 = a2;
    }

    public int getX() {
        return x;
    }

}

In the previous example I showed you that class A2 is not an immutable class. But keep it aside and go through the rules.

all the data fields are private
no setter methods are there
does getter method return any non immutable object? No

So this is an immutable class.

Example 4

class A1 {
    private int x;
    private A2 a2;

    public A1(int x, A2 a2) {
        this.x = x;
        this.a2 = a2;
    }

    public int getX() {
        return x;
    }

    public A2 getA2() {
        return this.a2;
    }
}

all the data fields are private
no setter methods are there
does getter method return any non immutable object? Yes it does.

So this is not an immutable class.

you might ask why this is not immutable. So no other way to explain that let's try to create an object of this class A1

 public static void main(String[] args) {
        A1 a1 = new A1(2, new A2(3));
        A2 a2 = a1.getA2(); // returning a immutable object
        a2.setX(5); // changing the value
    }

See x field of a2 is 3 previously. But from the line 3 we modified it to the 5. change is not a word with immutable object. Actually immutable means no change. It is the definition of immutable objects.

I think now you have a good idea about immutable object. There is keyword related with immutability in java that is final keyword. Simply final keyword won't let us change the value of a final variable. It will be a compile error. But we should remember that final only forbids us from changing the reference the variable holds, it doesn't protect us from changing the internal state of the object it refers to by using its public API.

I think this article will be too long if i talk about that in this article.

So if you have any questions please let me know in the comment section. I'm more than happy to help.

Stream API Java

Isurumax26 — Mon, 17 Jan 2022 09:44:30 +0000

As we all know java introduces set of new features in its version 8.
Stream API is one of that.
First we will see how to create an stream :

Stream Creation

Collections to stream Let's see how we can convert a list into a stream.In this way we can create collection, set to a stream

List<String> cities = Arrays.asList("London", "Tokyo", "Manila"); Stream<String> cityStream = cities.stream();

In the following code snippet you can see how we can convert an array into a stream.
String[] foods = {"Pizza", "Egg", "Chicken"}; Stream<String> foodsStream = Arrays.stream(foods);
We can also create an stream out of a part of an array

Stream<String> foodsStream = Arrays.stream(foods, 1, 3);

Map to a Stream In this snippet I'm going to show you how we can convert a java collection type map in to a stream. In this code first i convert the map to a entryset and then to a stream

Map<String, Integer> hm = new HashMap<>(); Stream<Map.Entry<String, Integer>> entryStream = hm.entrySet().stream();

One of a best practise when using stream instance is that if you want to return null object. Just return a empty stream (This is a good for other collections as well. Such as list, set, map)
Stream.empty()

we often use empty() method upon creation to avoid returning null for streams with no element.

public Stream<String> streamOf(List<String> list) { return list == null || list.isEmpty() ? Stream.empty() : list.stream(); }

Using builder method We can create a stream using this method too. Remember when you are using this method you have to specify the type too. If not it will return an instances of Stream.

Stream<String> streamBuilder = Stream.<String>builder().add("a").add("b").add("c").build();

but according to my knowledge we don't often use this type of creation.

Streams of primitives we can create streams out of int, long and double. Main advantage of this is we can avoid unnecessary usage of auto unboxing. It will increase the performances of your code.

IntStream intStream = IntStream.range(1, 3); LongStream longStream = LongStream.rangeClosed(1, 3);

In the first method it doesn't include the value of second parameter(one value less than the second parameter)

But in the second method it include that value as well.

Remember that stream is literally a stream. If you get to a point you can't move back likewise after you created a stream you can't again reuse that stream.

Optional<String> anyElement = stream.findAny(); Optional<String> firstElement = stream.findFirst();
It will throw an IlleagalStateException which is a Runtime exception.

Conclusion
Stream API is one of the powerful feature in java 8. You have to remember that all the methods which i have used are running in a single thread. But stream API allows you create parallels streams in multiple threads as well. We will check all those in future series.This is just a beginning of a series let's dig deep in to the streams in the following articles. will meet u soon -:D

Let me know your suggestion and improvement for this series.

Mainframe Testing

Isurumax26 — Mon, 16 Aug 2021 05:44:19 +0000

Mainframe

mainframes are high-performance computers (ASP 400 –IBM) with large amounts of memory and processors that process billions of simple calculations and transactions in real time. The mainframe is critical to commercial databases, transaction servers, and applications that require high resiliency, security, and agility.

Mainframe testing
Mainframe testing is connected with two main concepts.

Outbound transfer
Inbound transfer

Outbound transfer
As the name suggests outbound transfer means transferring files from mainframe to the outside(Applications). In a real world application we don’t transfer a single file during a transaction mostly it is bulk of files (batch processing).

Inbound transfer
This is the opposite of outbound transfer. Files are transferring from outside (Applications) to mainframe.

Testing Methodologies
Mainframe testing is like any other testing procedure starting from Requirement gathering, test design, test execution and result reporting. Mainframe application testing is a time taking process. A clear test schedule should be followed for test design, data setup and execution.

In mainframe testing we are using manual testing technique. Because we have to determine files are transferred successfully or not. We can’t necessarily do this with automation tools. But there are tools we can do this, it depends on our requirements.
According to the requirements we have to choose whether we are testing for a single file or batch of files. In most of the cases it is batch of files. But in some cases you have to perform a test case for a single test file.

In Mainframe testing, the Software or an application are retrieved by end-users in a way, which is diverse from Web applications.
And the application tester should know these significant differences, which are shown below:

Web Applications
The web applications are acquired via two-tier architecture [Client/Server] or three-tier architecture [Presentation/apps/DB storage layers]
The web applications retrieve across Browser or UI.
In this, the testing can be performed straight on the application screen.

Mainframe Applications
In the mainframe application, the end-user must log into the system directly.
Terminal Emulator must retrieve the web applications.
In this, the tester should have precise knowledge of mainframe operations.

Test Cases
• Outbound transfer
Steps

x.dat is sending from mainframe to application
x.dat file trigger the daemon program
x.dat file send via the gateway
Verify the delivery notifications.

• Inbound transfer
Steps

Trigger x.ack file from application to gateway
Verify the file is present in input directory.
Verify the file moved to the Archive directory

Common issues occurring in mainframe testing

I/O error
Reading at the end of the file, file length error, attempt to write into read-only file.
Error occurred during OPEN
Gateway is down
Operation Exception
Unable to open file, missing DD card

How to use POM in software testing

Isurumax26 — Tue, 04 May 2021 05:25:13 +0000

What is POM?

POM is a design pattern which is commonly used in Selenium for Automating the Test Cases. This design pattern can be used with any kind of framework like keyword-driven, Data-driven, hybrid framework, etc. I think you have an idea about the above frameworks Anyway I'll talk about them later.

Project hierarchy?

Under this model, for each web page in the application, there should be a corresponding Page Class. This Page class will identify the WebElements of that web page and also contains Page methods which perform operations on those WebElements. Name of these methods should be given as per the task they are performing, i.e., if loader needs to search something using the search box the method name will be setSearchBox(String item).

Consider following script for search some thing

As you can see all we are doing in this script is finding the web elements and setting the methods to fill those values. Above code is under the package pages

what we are doing here is filling the search box with values we provided(Test cases). Internal logic of these methods are implemented with the separate classes in the page package.

The chief problem with script maintenance is that if 10 different scripts are using the same page element, with any change in that element, you need to change all 10 scripts. This is time consuming and error prone.

A better approach to script maintenance is to create a separate class file which would find web elements, fill them or verify them. This class can be reused in all the scripts using that element. In future, if there is a change in the web element, we need to make the change in just 1 class file and not 10 different scripts. That is the page object model(POM)

Summary

Developing a maintainable automation code is one of the keys to a successful test-automation project. When developing Selenium WebDriver tests(Or any other framework), We can use the page object model pattern, This pattern helps enhances the tests by making them highly maintainable, reducing the code duplication, building a layer of abstraction, and hiding the inner implementation from tests.