hashCode and equals contract in java

public boolean equals(Object obj),public int hashCode() are methods of Object class.


Equals Demo Without Hashcode:
-----------------------------
import java.util.HashMap;

public class Emp{
private String name;

public Emp(String _name) {
name = _name;
}

public boolean equals(Object obj) {
if(obj==null) return false;
if (!(obj instanceof Emp))
return false;
if (obj == this)
return true;
return this.name.equals(((Emp) obj).name);
}
}

public class EqualsDemoWithoutHashcode {

public static void main(String[] args) {
Emp emp1 = new Emp("XYZ");
Emp emp2 = new Emp("ABC");

//HashMap stores Emp type and its salary
HashMap<Emp, Integer> m = new HashMap<Emp, Integer>();
m.put(emp1, 1000);
m.put(emp2, 20000);
System.out.println(m.get(new Emp("XYZ")));
}
}

In this case emp1 and emp2 hashcodes are different and equals also returned false as data different of the objects. And emp1 and emp2 are placed into hashmap. Here Object class hashcode function will be used to generate hash code. So while retrieving object from hashmap again it uses Object class hashcode function and it will not give any surety for user defined class objects to create same hash code for the object while retrieving. So if hash code is not same then it gives inconsistent data.


Similarly Suppose implemented hash code function and equals method not implemented. It will stores duplicate keys because it uses Object class equals method and it will not compare data of the object but it compares references. So references are not same so it stores duplicate keys.


HashMap stores internally data in table format and it uses hashcode function and equals method. To store objects in hashmap first it generates hash code and based on the hash code it stores in the bucket. Suppose same hash code is generated for two key objects then it uses equals method whether both key objects are same or different. If two key objects are different then it maintains multiple objects in the same bucket with same hash code.

Proxy design pattern

Proxy design pattern

It is structural design pattern; It is place holder for original object and limits the access to it. This provides interface original object functionality to clients.This represents functionality of another class which is sensitive remote target object.
Client deals with Proxy class which delegates to the original object (target object).

Proxy class which holds the original object and provides interface and  delegates to the target.

Proxy Demo:

BankAccount.java
------------------------
class BankAccount {
int accountNo;
String name
                float amount;
String accountType;
String bankName;
String address;
int customerID;
           
              public BankAccount() {
accountNo = 1111111111111;
name = "abc"
                amount = 10000;
accountType = "Savings";
bankName = "XYZ Bank";
address = "D No-111 efgh street";
customerID = 12345;
}

public boolean withdraw(float _amount) {
boolean isWithdrawSuccess = false;
if (amount > 0 && amount >= _amount) {
amount -= _amount;
isWithdrawSuccess = true;
}
return isWithdrawSuccess;
}

public void deposit(float _amount) {
amount += _amount;
}
public int getAccountNo() {
return accountNo;
}

public void setAccountNo(int _accountNo) {
accountNo = _accountNo;
}

public String getName() {
return name;
}

public void setName(String _name) {
name =_name;
}

  public float getAmount() {
return amount;
}

public void setAmount(float _amount) {
amount = _amount;
}

public String getAccountType() {
return accountType;
}

public void setAccountType(String _accountType){
accountType= _accountType;
}

public String getBankName() {
return bankName;
}

public void setBankName(String _bankName) {
bankName = _bankName;
}

public String getAddress() {
return address;
}

public void setAddress(String _address) {
address = _address;
}

public int getCustomerID() {
return customerID;
}

public void setCustomerID(int _customerID) {
customerID =_customerID;
}

}

 interface OrderOperations {
  AccountDetails getAccountDetails();
  void  bookOrder(float orderAmount, String customerType);
  void unbookOrder(float orderAmount, String customerType);
}
AccountDetails.java
---------------------------
class AccountDetails {
String name;
float amount;
public String getName() {
return name;
}
public void setName(String _name) {
name =_name;
}
public float getAmount() {
return amount;
}
public void setAmount(float _amount) {
amount = _amount;
}

}
ProxyOrderOperationsImpl.java
-------------------------------------------
class ProxyOrderOperationsImpl implements OrderOperations {
BankAccount customerAccount;
ProxyOrderOperationsImpl() {
customerAccount = new BankAccount();
}

public AccountDetails getAccountDetails() {
AccountDetails  accountdetails = new AccountDetails();
System.out.println("***Account Details***");
System.out.println("Name:::" + customerAccount.getName());
accountdetails.setName(customerAccount.getName());
System.out.println("Amount:::" + customerAccount.getAmount());
accountdetails.setAmount(customerAccount.getAmount());
   return accountdetails;
}

public void  bookOrder(float orderAmount, String customerType) {
if (orderAmount > 5000) {
if("Regular".equalIgnoreCase(customerType)) {
orderAmount-=500;
} else {
orderAmount-=100;
}
}
boolean isBookOrder = customerAccount.withdraw(orderAmount);
if (isBookOrder) {
System.out.println("Order Booking is successful...");
} else {
System.out.println("Order Booking is un-successful...");
}

}
public void unbookOrder(float orderAmount, String customerType) {
        if (orderAmount > 5000) {
if("Regular".equalIgnoreCase(customerType)) {
orderAmount-=500;
} else {
orderAmount-=100;
}
        }
boolean isUnbookOrder = customerAccount.deposit(orderAmount);
if (isUnbookOrder ) {
System.out.println("Order Unbooking is successful...");
} else {
System.out.println("Order Unbooking is un-successful...");
}
}

}
PrxoyPatternDemo.java
--------------------------------
public PrxoyPatternDemo {
public static void main (String args[]) {
ProxyOrderOperationsImpl orderOperations = new ProxyOrderOperationsImpl();
orderOperations.getAccountDetails();
orderOperations.bookOrder(3000, "Regular");
orderOperations.unbookOrder(3000,"Regular");
}
}

Production issue analysis

Production issue analysis

Step 1: Try to reproduce issue in development environment, integration environment, and pre-production environment.

Step 2: If Production issue is not reproducible in above step, then we will get logs for production and we will analyse the logs to understand the issue; we will look is there any error message related to issue.

Step 3: We will see for "is there any differences in configuration between production and lower environment" and deployment version difference.

Step 4: if above three steps fails then we will  get production installed ear file or war file and we will deploy in lower environment and try to reproduce the issue.

Step 5: If above four steps fails then we will request for data-dump from production and we will load that into lower environments and try to reproduce the issue in lower environment.

Service locator design pattern

Service locator design pattern: 
It is used when we want to locate various services objects like JNDI. It caches the service objects. It looks first for service objects its cache. It access service object from its cache if it exists in cache otherwise  it lookup service object, it adds to its cache and returns service object.

Service - This is the actual service which process the request.

Service Locator - This is central point to get service object and it caches the services.

Cache - This holds references of services to reuse them.

Client - This calls the ServiceLocator and rceives the service object.

Servicelocator Demo:

BankService.java
-----------------------
public interface BankService {
 public String getServiceName();
 public boolean createAccount(CustmorInfo custInfo);
 public boolean deleteAccount(CustmorInfo custInfo);
}

AbcBankService.java
----------------------------
public class AbcBankService implements BankService {
public boolean createAccount(CustmorInfo custInfo){
boolean accountCreationStatus = false;
if (custInfo.getName()!= null) {
System.out.println("Account is created successfully in AbcBank");
accountCreationStatus = true;
}
retur accountCreationStatus;
}
public boolean deleteAccount(CustmorInfo custInfo) {
boolean accountDeletionStatus = false;
if (custInfo.getName()!= null) {
System.out.println("Account is delted successfully from AbcBank");
accountDeletionStatus = true;
}
retur accountDeletionStatus;
}
    @Override
public String getServiceName() {
    return "AbcBankService";
}
}

XyzBankService.java
----------------------------
public class XyzBankService implements BankService {
public boolean createAccount(CustmorInfo custInfo){
boolean accountCreationStatus = false;
if (custInfo.getName()!= null) {
System.out.println("Account is created successfully in XyzBank");
accountCreationStatus = true;
}
retur accountCreationStatus;
}
public boolean deleteAccount(CustmorInfo custInfo) {
boolean accountDeletionStatus = false;
if (custInfo.getName()!= null) {
System.out.println("Account is delted successfully from XyzBank");
accountDeletionStatus = true;
}
retur accountDeletionStatus;
}
    @Override
public String getServiceName() {
    return "AbcBankService";
}
}
CustmorInfo.java
------------------------
class CustmorInfo {
String name;
String address;
String accountType;

public setName(String _name) {
name = _name;
}
public String getName {
rturn name;
}
public void setAddress(String _address) {
address = _address;
}
public String getAddress() {
return address;
}
public void setAccountType(String _accountType) {
accountType = _accountType;
}
public String getAccountType() {
return accountType;
}
}

Cache.java
--------------
import java.util.ArrayList;
import java.util.List;
public class Cache {

  private List<BankService> services;
    public Cache(){    
services = new ArrayList<BankService>();
}
    public Service getService(String serviceName){
        for (BankService service : services) {
if(service.getServiceName().equalsIgnoreCase(serviceName)){
           System.out.println("Returning cached  " + serviceName + " object");
           return service;      
}    
}    
return null;
}
 
public void addService(BankService newService){    
boolean exists = false;          
for (BankService service : services) {      
if(service.getServiceName().equalsIgnoreCase(newService.getName())){          
exists = true;      
}    
}    
if(!exists){      
services.add(newService);    
}
}
}
ServiceLocator.java
--------------------------
public class ServiceLocator {
private static Cache cache;
    static {
     cache = new Cache();  
}
    public static Service getService(String serviceName){
      Service service = cache.getService(serviceName);
      if(service != null){      
return service;    
}
      //Make lookup calls to get service objects from JNDI  
Service service1 = BankServiceFactory.buildService(serviceName);
try {    
cache.addService(service1);
} catch (InvalidBankServiceException exception) {
System.out.println("Requested service is invalid" + exception);
}  
return service1;
}
}
BankServiceFactory.java
--------------------------------
class BankServiceFactory {
public static BankService buildService(serviceName) throws InvalidBankServiceException{
if ("AbcBankService".equalsIngnoreCase(serviceName)) {
return new AbcBankService();
} else if ("XyzBankService".equalsIngnoreCase(serviceName)) {
return new XyzBankService();
} else {
throw new InvalidBankServiceException("Requested bank service is invalid:::"+serviceName);
}

}
}

InvalidBankServiceException.java
---------------------------------------------
class InvalidBankServiceException{
InvalidBankServiceException(String s) {
     super(s);
}
}
ServiceLocatorDesignPatternDemo.java
----------------------------------------------------
public class ServiceLocatorDesignPatternDemo {
public static void main(String[] args) {    
Service service = ServiceLocator.getService("AbcBankService");
if (service != null) {    
service.createAccount();
}    
service = ServiceLocator.getService("XyzBankService");    
if (service != null) {    
service.createAccount();    
}
service = ServiceLocator.getService("AbcBankService");    
if (service != null) {    
service.deleteAccount();    
}
service = ServiceLocator.getService("XyzBankService");    
{
service.deleteAccount();  
}
}
}

Singleton design pattern Demo

                                  Singleton design pattern Demo
Singleton pattern ensures that only one instance of the class exists in the java virtual machine.It provides a way to access instance of the class through factory method.

synchronized block - In multi thread environment; it gives access to single thread and it ensures that only one instance exists to class
final in class declaration - It will not allow to create subclass; privents inheritance
Colonable - need to override which should not allow to colone the object
Serializable - need to override readReslove method which should not create another object while desralizing object

final public class SingletonClass implements Cloneable, Serializable{
   
    private static SingletonClass myObj;
   
    //Private constructor
   
    private MySingletonClass(){
       
    }
   
    //A static method to get instance.
    public static MySingletonClass getInstance(){
synchronized {
                if(myObj == null){
     myObj = new SingletonClass();
}
        }
        return myObj;
    }
   
    // clone method overridding
    public Object clone() throws  CloneNotSupportedException{ 

return new CloneNotSupportedException("Clone Not Supported Exception.......");
    }
   
    public Object readResolve() {
      return SingletonClass.getInstance();
   }
   private void writeObject(ObjectOutputStream oos) {
      try {
      ----------------
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void readObject(ObjectInputStream ois) {
       try {
       ----------------
       } catch (Exception e) {
          e.printStackTrace();
       }
   }  

   @Override
   public String toString() {
      return "Singleton toString....";
   }
}

public class MySingletonDemo {
    public static void main(String a[]){
        MySingletonClass st = MySingletonClass.getInstance();
        ------------------------------
   }
}

Publisher And Subscriber Thread example using wait, notify & sleep methods

Publisher And Subscriber Thread example using wait, notify & sleep methods


Message.java

import java.util.Date;
class Message {
 
       String message = null;
 
       Message() {
message = new Date().toString();
}
 
       public void setMessage(String msg) {
message = msg;
}

public String getMessage() {
return message;
}
}

Publisher.java
import java.util.Vector;
class Publisher extends Runnable {

  static final int SIZE = 5;
  private Vector<Message> messages = null;
 
public Publisher() {
 
 messages = new Vector<Message>();

 }

    public void run() {
        try {
            while (true) {
                putMsg();
                sleep(1000);
            }
        } catch (InterruptedException exception) {
System.out.prinln("(Thread Interrupted......");
        }
    }

    private synchronized void putMsg() throws InterruptedException {
        while (messages.size() == SIZE) {
            wait();
        }
 
        //To prepare real time message usually will call services
        messages.addElement(new Message());
        System.out.println("put msg");
        notify();
    }

    public synchronized String getMsg() throws InterruptedException {
        notify();
        while (messages.size() == 0) {
            wait();
        }
        String tempMessage = (String) messages.firstElement();
        messages.removeElement(tempMessage);
        return tempMessage;
    }
}

Subscriber.java
class Subscriber extends Runnable {

    Publisher publisher= null;

    Subscriber(Publisher p) {
        publisher = p;
    }


    public void run() {
        try {
            while (true) {
                String msg = publisher.getMsg();
                System.out.println("Consumed message........." + msg);
                sleep(500);
            }
        } catch (InterruptedException exception) {
            System.out.prinln("(Thread Interrupted......");
        }
    }
}

PublisherAndSubscriberDemo.java
public class PublisherAndSubscriberDemo {

public static void main(String args[]) {
        Thread publisherThread = new Publisher();
        publisherThread.start();
        Thread  subscriberThread = new Subscriber(publisherThread);
subscriberThread.start();
    }

}

Questions

Executor Frame Work in Java 1.6
Strategy Design Pattern in Java
 How many interfaces required to Builder Design pattern in Java
Capabilities of Jan-kins and had-son build tools

1.how to make object unmodifable of final class while creating immutable class
2. fail safe and fail fast and how concurrent hashmap handles if one thread accessing from same bucket and another
thread is removing/adding from same bucket
3. interface1 and interface2 same set of methods; what happens if class is going to implement both the interfces.
4.
Inter i1 = new Ineteger(10);
Inter i2 = new Ineteger(10);

i1 == i2                                            false

i1.equals(i2);                                   true

i1.equals("10");                               false

"10".equals(i1);                               false

Difference between HashSet and TreeSet:

HashSet: complexity to access element is O(1), it uses hashing algorithm to store values,and it will not give any guarantee to maintain sorted order  and it allows null objects.

TreeSet: complexity to access element is O(log n), it is uses tree structure algorithm to store values, it maintains data in sorted order and it will not allow null objects.

HashSet performance is more than TreeSet.

Maven command to execute micro service:

mvn clean install -DSkipTest=true & java -jar MicroService.jar