Forem: Ghazanfar Mumtaz

DAO Design Pattern

Ghazanfar Mumtaz — Sat, 16 Dec 2023 15:01:21 +0000

Data Access Object design pattern or DAO pattern is a fundamental structural pattern commonly used in Java Applications.

DAO Design Pattern is used to separate low-level data accessing API or operations from high-level business logics.

Why did we need DAO Design Pattern?

Before the DAO pattern, applications often directly embedded data access logic within their business logic. This led to tight coupling and several downsides:

Difficult Maintenance: Changes in the database structure or access methods required modifications throughout the application, making maintenance cumbersome.
Limited Reusability: The Data access code was specific to a particular database and couldn't be easily reused in other parts of the application.
Reduced Testability: Testing business logic became more complex due to intertwined data access operations.

The Data Access Object Design Pattern addresses these issues by introducing a dedicated layer for data access.

Following are the components in DAO Pattern.

DAO Interface: Defines a standard set of operations that can be performed on a specific data model. This interface remains independent of the underlying database implementation.
DAO Implementation: - This class implements above interface. This class is responsible to get data from a data source which can be database / xml or any other storage mechanism.
It Provides concrete implementations of the DAO interface using
the chosen data access framework (e.g., JDBC)
Model Object: Represents the data model with appropriate properties and methods.
Business Logic: Utilizes the DAO interface to access and manipulate data without any knowledge of the underlying database technology.

Implementation Example:

1. Define the DAO Interface:

interface PersonDao{
    public Person getName(int id) throws SQLException;

    public Person getDetails(int Personid) throws SQLException;
}

2. Implement the DAO:

class PersonDaoImplementation implements PersonDao{
    public Person getName(int id) throws SQLException {
        Person p = new Person();
        p.PersonId = id;

        //fetch data from the database
        String name = DataRequestHandler.getNamefromDataBase(int PersonId) //just an example 

        p.name = name;
        return p;
    }

    @Override
    public Person getDetails(int Personid) throws SQLException {
        return null;
    }
}

3. Model Object:

class Person{
    private int PersonId;
    private String name;

    public int getPersonId() {
        return PersonId;
    }

    public void setPersonId(int personId) {
        PersonId = personId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

 }

4. Utilize the DAO in Business Logic:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcDaoDemo {

    public static void main(String[] args) throws Exception {
        PersonDao dao = new PersonDaoImplementation();
        Person p1 = dao.getName(9);
        System.out.println(p1.getName());
    }
}

Benefits:

Separation of Concerns: Isolates data access logic, making the business logic cleaner and easier to maintain.
Database Independence: Enables switching databases without affecting the business logic.
Encapsulation: Protects the application from changes in the underlying database implementation.
Reusability: Promotes code reuse for data access operations.

Conclusion:

The DAO design pattern plays a crucial role in building clean and maintainable Java applications. Separating data access concerns and promoting abstraction, leads to improved code quality, flexibility, and testability. By understanding and implementing the DAO pattern effectively, developers can build robust and efficient applications that are easier to maintain and adapt to future changes.

HOISTING in javascript

Ghazanfar Mumtaz — Fri, 08 Dec 2023 14:35:58 +0000

What is Hoisting?

Hoisting is the behavior in JavaScript where variable and function declarations are lifted to the top of their respective scopes during the compilation phase. This means that, regardless of where the declarations appear in the code, they are effectively moved to the top of their containing scope, making them available for use even before their actual placement in the code.

Take a look at the code below and think what will its output.

console.log(notEqual(1, '1')); // => false
// Function declaration
function notEqual(item1, item2) {
   return item1 === item2;
}

We are able to use notEqual function even before it is declared.This is the magic of hoisting in javascript

The code works nicely because notEqual() is created by a function declaration and hoisted to the top of the scope.

Ok, so lets again look at an example and guess its output.

console.log(name); var name = "John";
It might surprise you that this code outputs undefined and doesn't fail or throw an error neither it prints the value 'John' assigned to name variable.

Let's understand this behavior of js

Hoisting influences the variable life cycle, which consists of 3 steps:

Declaration - create a new variable. Initialization - initialize the variable with a value. Usage - access and use the variable value.

Declaration –> Initialisation/Assignment –> Usage

// Declare var name; // Initialize name = 'John; // Use console.log(name); // => John

Hoisting moves the variables and functions declaration to the top of the function scope (or global scope if outside any function).

So in this code console.log(name); var name = "John"
only declaration var name is moved to the top of scope.

var name default value is undefined..

Actually Hoisting was created for functions only and its applicability to var is just the by product.

JS creator Brendan Eich once said on X (the social media platform formerly known as Twitter)

@aravind030792 var hoisting was thus unintended consequence of function hoisting, no block scope, JS as a 1995 rush job. ES6 'let' may help.
— BrendanEich (@BrendanEich) October 15, 2014

Variable hoisting with let and const

Variables declared with let and const are hoisted but not initialized with a default value. Accessing a let or const variable before it is declared will result in a ReferenceError:

function learnHoisting(value) {
  if (value) {
    //temporal dead zone for name

   // Throws ReferenceError: name is not defined
    console.log(name);
    let name = 'foo';
    // end of temporary dead zone for name
    console.log(name); // => 'foo'
    return true;
  }
  return false;
}
learnHoisting(1)

The interpreter still hoists name: the error message tells us that variable is initialized somewhere.

Note - From the declaration statement up to the beginning of the block the let and const variable are in a temporal dead zone (TDZ) and cannot be accessed.