JavaExp: Java and Open Source Technology

Different ways to initialize arrays in java

2020-05-26T17:24:00.002-07:00

Array Initialization in Java

Different ways to initialize array's in java

Java Arrays can be populated in a number of ways following summarizes different options.

One item at a time using a loop

Following example we are declaring rolNumms array of size 10 and adding one item at a time using a for a loop.

  //Using For loops
   int rollNums[] = new int[10];
   for (int i=0; i

At the Time of Declaration

We can set the content of the array while declaring the array it self. Both the syntax will result in initializing the array with 10 items. Note that when we provide the initializer while declaring the size of the array cannot be specified.

int rollNums2[] = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9 ,10};
int rollNums3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9 ,10};

Arrays.setAll() and Generator function

We can set the content of the array using the Arrays.setAll() method as well.

int rollNums4 [] = new int [10];
Arrays.setAll(rollNums4, p -> p );

Copying another array

We can also copy an existing array to populate a new array, using java.util.Arrays.copyOf method

int rollNums5[] = Arrays.copyOf(rollNums4, rollNums4.length);

Determine OS version from Command line in MacOS

2019-10-11T18:27:00.003-07:00

Sometimes we would like to know about the installed MacOS from Terminal. Or say we are writing scripts to extract the OS related information like it's version and release name etc.

For Mac we have couple of options

System Profiler

Execute the following command from Terminal


system_profiler

As you can see from the screenshot system_profiler will print a lot of information about the Software and Hardware of the Mac.

This is it.....

sw_vers

Execute the following command from Terminal


sw_vers

As you can see from the screenshot sw_vers will print information about the current installed OS Name and Version.

How to change computer name and user name in terminal command prompt in MacOS

2019-10-11T18:15:00.001-07:00

Sometimes we want to hide the system name or username that is displayed on the Terminal.

May be to take some screenshot and then paste it in the blog and we want to hide the System name/user Name etc.

For Bash based terminals it can be done by setting PS1 variable.

Example on the terminal


$ export PS1="> "
>


$ PS1="Mac:~sidd:"
Mac:~sidd:


$ export PS1="This is Demo Terminal: $ "
This is Demo Terminal: $

Change your prompt in your profile file to make it permanent across all Terminals and new sessions.

How to Install Apache 2 on Ubuntu Linux

2019-10-10T23:08:00.001-07:00

Following are the steps to install Apache 2 on Ubuntu Linux and then start it.

Update the System Repository


sudo apt update

Install Apache2 Software with apt command


sudo apt install apache2

How to convert HttpResponse to String in Java

2019-09-05T00:04:00.000-07:00

Following code snippet explains how to convert HttpResponse object to String in Java

Steps

Call httpclient.execute()
Get the InputStream from the response
Convert the InputStream to ByteArrayOutputStream
Convert the ByteArrayOutputStream to String
Close the request and InputStream


private String executeAndGetResponse(HttpRequestBase request)
      throws IOException, ClientProtocolException, Exception, UnsupportedEncodingException {
    HttpResponse response = httpClient.execute(request);
    InputStream inputStream = response.getEntity().getContent();
    ByteArrayOutputStream result = new ByteArrayOutputStream();
    byte[] buffer = new byte[1024];
    int length;
    while ((length = inputStream.read(buffer)) != -1) {
      result.write(buffer, 0, length);
    }
    String strRes = result.toString(StandardCharsets.UTF_8.name());
   
    request.releaseConnection();
    inputStream.close();
    return strRes;
  }

Jackson Object Mapper to conver String to JsonNode

2019-09-03T00:56:00.000-07:00

Following are some of the code snippet for Jackson Object Mapper
Convert String to JsonNode Object

String data;
JsonNode jsonNode = getObjectMapper().readTree(data);

Convert an Object to JSON String

String jsonString = getObjectMapper().writeValueAsString(object);

Convert InputStream to JsonNode Object

InputStream inputStream;
JsonNode jsonNode = getObjectMapper().readTree(inputStream);

How to check what version of JQuery is loaded in browser

2019-08-22T00:25:00.002-07:00

Sometimes we might want to know what version of jQuery a particular site is using. It is not always possible to know the version of jQuery we are using through the jQuery File name or reading the content of the files, specially when the jQuery is minimized.

Following snippet can tell us the version of jQuery loaded by a site.


if (typeof jQuery != 'undefined') {  
    // jQuery is loaded => print the version
    alert(jQuery.fn.jquery);
}

Simply go to the console of the browser, once the webpage is loaded, and then type. the above command on the console. It should display the version as an Alert.

How to generate sitemap for Blogs hosted on Blogger

2019-08-20T22:02:00.002-07:00

Blogger comes with some goodies, like the atom feed URL, which can be used to generate sitemap for bloggers.

Sign in to Google Search Console.
Select the Blog from the left hand side.
Click on Sitemaps link.
At the top of the page with title "Add a new sitemap"
Add the below code in the text field.

atom.xml?redirect=false&start-index=1&max-results=500

Example :


https://webdevpedia.blogspot.com/atom.xml?redirect=false&start-index=1&max-results=500

Press “Submit Sitemap” button.

Handle 409 conflict document in couchdb

2019-08-13T23:32:00.002-07:00

Problem Use case:

CouchDB Error 409 conflict document.

Exception Details [Truncated]:
CouchDB is throwing error 409 conflict while calling REST API to update data.
CouchDB will throw 409 conflict document exception if the payload is not proper. Following are some of the cases.
"_id" : This attribute is present, but the "_rev" attribute is not present or is wrong.
CouchDB uses both the "_id" and "_rev" attribute while updating a Document. Every time we update a document the "_rev" attribute value gets updated.

Solution:
If we want to update data, then make sure both "_id" and "_rev" attributes are carrying proper values respectively.

Referance Links related to CouchDB:
https://webdevpedia.blogspot.com/2019/07/installing-couchdb-on-gcp-compute-engine.html

CouchDB Error 412:Precondition Failed

2019-08-13T23:26:00.001-07:00

Problem Use case:
CouchDB Error 412:Precondition Failed

Exception Details [Truncated]:
CouchDB is throwing error while calling REST API to update data.

Solution:
CouchDB will throw 412:Precondition Failed exception if the payload does not contain the unique identifier "_id" attribute or its value is missing. Check the payload for PUT or POST to make sure the "_id" attribute is not missing.

Referance Links related to CouchDB:
https://webdevpedia.blogspot.com/2019/07/installing-couchdb-on-gcp-compute-engine.html

Starting Spring Boot Application in Debug mode

2019-04-30T23:42:00.000-07:00

Start the Spring boot application with the following jvm argument.


mvn spring-boot:run -Drun.jvmArguments="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005"

Maven attach source code for external Jar

2019-04-20T20:34:00.001-07:00

For Java project that uses Maven for dependency and building we can attach the third party library source. By default the source is not available, using the following commands we can down load the associated source and java doc from maven repository by reading the project pom file.

Maven will not be able to download sources and docs if those were not published for a particular library.


mvn dependency:sources
mvn dependency:resolve -Dclassifier=javadoc

//to download source for only one library

mvn dependency:sources -DincludeArtifactIds=spring-boot

Now after executing the above two commands, maven will download the respective sources and java docs. Now we can attach the source in the IDE. For eclipse specially it is better to use the Maven Eclipse plugin


mvn eclipse:eclipse -DdownloadSources=true
mvn eclipse:eclipse -DdownloadSources=true -DdownloadJavadocs=false

Executing the above commands will also download the sources and it also updates the .classpath file. Now refreshing the Project in side eclipse should be able to map the corresponding sources for the external jars.

Failed to instantiate [java.util.List]: Specified class is an interface in HTTP controller handler?

2019-04-13T00:15:00.004-07:00

Problem Use case:
Following SpringBoot Rest Controller is not able to map the request payload


@Controller
@RequestMapping("/api")
  public class BlogController {  
    @RequestMapping(value = "/blogstories", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
       public ResponseEntity<List<BlogStoryObject>> addUpdateblog(List<BlogStoryObject> blogItems) {
          List<BlogStoryObject> result = new ArrayList<BlogStoryObject>();
    //TODO:: Call Service to update/save objects
    return new ResponseEntity<List<RootBlogStoryObject>>(result, HttpStatus.OK);
 }
}

Exception Details [Truncated]:

And the error thrown at runtime is Failed to instantiate [java.util.List]: Specified class is an interface.

Solution

Solution to the problem is to @RequestBody annotation to the method definition, so the following will work.


public ResponseEntity<List<RootBlogStoryObject>> addUpdateblog(
  @RequestBody List<RootBlogStoryObject> blogItems) {
  /////implementation goes here

}

Spring Boot Error : Unable to start EmbeddedWebApplicationContext due to missing EmbeddedServletContainerFactory

2019-04-12T18:32:00.000-07:00

Problem Use case:
While starting a Spring Boot Application using

mvn spring-boot:run

The Application fails to start
Unable to start EmbeddedWebApplicationContext due to missing EmbeddedServletContainerFactory bean.

Exception Details [Truncated]:
[ERROR] Failed to execute goal org.springframework.boot:spring-boot-maven-plugin:1.5.9.RELEASE:run (default-cli) on project Javaexp-springboot-rest: An exception occurred while running. null: InvocationTargetException: Unable to start embedded container; nested exception is org.springframework.context.ApplicationContextException: Unable to start EmbeddedWebApplicationContext due to missing EmbeddedServletContainerFactory bean. -> [Help 1]
[ERROR]
[ERROR] To see the full stack trace of the errors, re-run Maven with the -e switch.
[ERROR] Re-run Maven using the -X switch to enable full debug logging.
[ERROR]
[ERROR] For more information about the errors and possible solutions, please read the following articles:
[ERROR] [Help 1] http://cwiki.apache.org/confluence/display/MAVEN/MojoExecutionException

Solution
Update pom.xml and use the spring-boot-starter-web


<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <version>1.5.9.RELEASE</version>
</dependency>

Now do a new build and the application should be able to start.

Spring Boot CommandLineRunner

2019-04-05T11:01:00.002-07:00

CommandLineRunner is an interface which allows us to write code that would be executed when the SpringBoot Application is initialized and before the startup is finished.

Technology used

Java 8
Spring boot 1.5.9
Logback 1.1.1.1
Maven 3.5.0

Implementation

This project uses Maven to build the project. It shows a very simple example of a Spring boot Application and two Classes implementing CommandLineRunner.

High level steps as described bellow with sample code

Define the pom.xml file

Write Spring boot app class

Write Spring boot CommandLineRunner class
Change the order with Order annotation

For simplicity the pom file is not provided here, but it can be found on the git repo here https://github.com/siddharthagit/spring-boot-references/blob/master/spingboot-resttemplate/pom.xml

SpringBoot Application Class

ResttemplateApplication.java

@SpringBootApplication
public class ResttemplateApplication {

  private static final Logger log = LoggerFactory.getLogger(ResttemplateApplication.class);

  public static void main(String args[]) {
    log.info("about to call SpringApplication.run()");
    SpringApplication.run(ResttemplateApplication.class, args);
    log.info("completeed executing SpringApplication.run()");
  }

}

Next we will provide two Classes which implements CommandLineRunner interface.

LoadAllEndpoint loads all the available endpoints by calling github's REST API

LoadAllEndpoint.java


@Component
@Order(1)
public class LoadAllEndpoint implements CommandLineRunner {

  private static final Logger log = LoggerFactory.getLogger(ResttemplateApplication.class);

  @Override
  public void run(String... args) throws Exception {
    log.info("about to call LoadGithubRepo.run()");
    RestTemplate restTemplate = new RestTemplateBuilder().build();
    ResponseEntity apis =
        restTemplate.getForEntity("https://api.github.com", JsonNode.class);
    
    //log.info(apis.toString());
  }
}

LoadGithubRepo returns all the available in github for an account by calling github's REST API

LoadGithubRepo.java


@Component
@Order(2)
public class LoadGithubRepo implements CommandLineRunner {

  private static final Logger log = LoggerFactory.getLogger(ResttemplateApplication.class);

  @Override
  public void run(String... args) throws Exception {
    log.info("about to call LoadGithubRepo.run()");
    RestTemplate restTemplate = new RestTemplateBuilder().build();
    ResponseEntity repos = restTemplate
        .getForEntity("https://api.github.com/users/siddharthagit/repos", JsonNode.class);
    //log.info(repos.toString());
  }
}

Run the application


mvn spring-boot:run

Console Output (some part)


AnnotationMBeanExporter:431 - Registering beans for JMX exposure on startup
ResttemplateApplication:21 - about to call LoadAllEndpoint.run()
ResttemplateApplication:21 - about to call LoadGithubRepo.run()
ResttemplateApplication:57 - Started ResttemplateApplication in 2.07 seconds
ResttemplateApplication:17 - completed executing ResttemplateApplication.run()

Summary

CommandLineRunner is useful when we need to execute code before the Applicaton startup completes

We can have multiple implementations of CommandLineRunner

We can arrange the order of execution between different implementations using Order annotation

Download and Run

git clone https://github.com/siddharthagit/spring-boot-references.git
cd spingboot-resttemplate
mvn spring-boot:run

Spring boot with Thymeleaf example

2019-03-05T20:47:00.001-08:00

This blog shows how to use Thymeleaf as a template engine with Spring boot.

Technologies Used

Java 8
Spring framework 1.5.9
Spring boot 1.5.9
Thymeleaf 2.1.6
Tomcat embed 8.5.23
Logback 1.1.1.1
Junit 4.12
Bootstrap 4
Maven 3.5.0

Implementation

This project uses Maven to build the project. It shows a very simple example of a login page with corresponding Spring boot controller.
The goal of this project is to have a login page rendered using Thymeleaf template.
The template it self uses the bootstrap css for styling.

High level steps as described bellow with sample code

Define the pom.xml file

Write Spring boot app class

Write Spring boot controller class

Write Thymeleaf Template for the controller class

Write the CSS referred by Template file

pom.xml



<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <artifactId>Javaexp.blogspot.com-thymeleaf</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>Javaexp.blogspot.com Thymeleaf</name>
  <description>Javaexp Thymeleaf Example</description>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
    <relativePath />
  </parent>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
  </properties>

  <dependencies>
  
    <!-- Springboot -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <version>1.5.9.RELEASE</version>
    </dependency>

    <!-- test -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>

    <!-- for Thymeleaf -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>

    <!-- hot swapping, disable cache for template, enable live reload -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <optional>true</optional>
      <scope>runtime</scope>
    </dependency>

  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <addResources>true</addResources>
        </configuration>
        <executions>
          <execution>
            <goals>
              <goal>repackage</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <configuration>
          <webResources>
            <resource>
              <directory>dist/</directory>
            </resource>
          </webResources>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

StartWebApplication.java


package com.blogspot.blogger;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class StartWebApplication {

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

}

WebLoginController.java


package com.blogspot.blogger;

import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class WebLoginController {

  @GetMapping("/login")
  public String login(Model model) {
    return "login";
  }

}

For the Thymeleaf template file put it under src/main/resources/templates/login.html


<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"></meta>
<link rel="stylesheet" type="text/css" th:href="@{~/css/bootstrap.min.css}" />
<link rel="stylesheet" type="text/css" th:href="@{~/css/style.default.css}" />
<title>Javaexp.blogspot.com Thymeleaf Example</title>
</head>
<body>
  <div class="container">
    <div class="modal-dialog">
      <div class="loginmodal-container">
        <h1>Login to Your Account</h1>
        <form>
          <input type="text" name="user" placeholder="Username"></input> <input
            type="password" name="pass" placeholder="Password"></input> <input
            type="submit" name="login" class="login loginmodal-submit"
            value="Login"></input>
        </form>
        <div class="login-help">
          <a href="#">Register</a> - <a href="#">Forgot Password</a>
        </div>
      </div>
    </div>
  </div>
</body>
</html>

application.properties


#SPRING BOOT MVC
spring.mvc.view.prefix=/static/
spring.mvc.view.suffix=.html

Run the Spring boot Application

$ mvn spring-boot:run

INFO restartedMain o.a.c.h.Http11NioProtocol:179 - Starting 
ProtocolHandler ["http-nio-8080"]
INFO restartedMain o.a.t.u.n.NioSelectorPool:179 - Using a shared selector for servlet write/read
INFO restartedMain o.s.b.c.e.t.TomcatEmbeddedServletContainer:201 - Tomcat started on port(s): 8080 (http)
INFO restartedMain c.b.b.StartWebApplication:57 - Started StartWebApplication in 2.337 seconds (JVM running for 2.735)

Demo

Goto : http://localhost:8080/login

Download and Run

git clone https://github.com/siddharthagit/spring-boot-references.git
cd spingboot-web-thymeleaf
mvn spring-boot:run

Installing Couchdb on GCP Compute Engine

2019-03-01T00:40:00.000-08:00

This article covers the steps that needed to install Apache Couchdb on Google Cloud Platform.

There are various way of how to achieve this, that is having a Compute Engine (VM) installed with Couchdb.

One option is to use the the Marketplace in GCP which offers quick option to deploy on Cloud Platform.
Login to GCP and click on the Marketplace Icon and then search for CouchDB. Although we would still need to perform some additional steps like Creating Firewall Rule etc so that we can access the instance after getting VM with CouchDB installed from Marketplace.

Rather than using the Marketplace, we would do everything manually on the VM Instance.
Following are the steps in details that i had to take to lunch an instance of CouchDB, do configuration update and create Firewall Rules to allow access to the instance.

High level steps as covered bellow are

Create an Instance of Google Cloud Engine Instance
Install Apache CouchDB in the VM
Configure the Database Instance
Configure Firewall Access

Create Google Cloud compute Engine instance.

SSH to the VM Instance.

Before installing the Apache CouchDB we will install some useful software that we would need like nano editor.

sudo apt-get install nano

Install CouchDB


sudo apt update

sudo apt-get install apache2 couchdb

Check Status of CouchDB

Following commands are useful to check the status of CouchDB instance, start it and stop it etc.


sudo systemctl stop couchdb.service


sudo systemctl start couchdb.service


sudo systemctl enable couchdb.service


sudo systemctl status couchdb.service

Change the bind address of CouchDB

Normally the CouchDB listens to port 127.0.0.1 which is localhost.
When we deploy the CouchDB on VM on GCP we would like it to be accessed from outside the VM also, for that we need to modify the bind address. We do that by updating CouchDB configuration file

nano /etc/couchdb/default.ini

port = 5984
bind_address = 0.0.0.0

Add Firewall rule for the VM instance

We will now add a new Firewall rule to allow access to the VM on which we have CouchDB installed.
For that go to Navigation Menu -> VPC Networks -> Firewall Rule and click on

Create Firewall rule

Add the necessary details like follows,

Now we we should be able to access the instance over internet

Access the Instance

Open a browser and go to external-ip:port/_util/, we should be able to see a page like as bellow

Testing private method in Java

2019-02-17T14:12:00.000-08:00

Private method in java is not accessible outside the Class which defines it.
Since they cannot be accessed we cannot call them from any Test Class directly to test them.

Following are some of the options to test the private method

1) Change the visibility of the private method to package or protected.
2) Create a public method in the Class and call the private method from the public method

Above two solutions requires us to change the original Class. Some times we cannot change the original Class but still would like to have a Test Class for the same method.

The other option is to use Reflection api to invoke the private method.

For example lets try to test a private method multiple on Class CreditcardMask.java


Class targetClass =
(Class) Class.forName(CreditcardMask.class.getName());

// get the method multiply
Method testMethod = targetClass.getDeclaredMethod("multiply", Integer.class, Integer.class);

Assert.assertNotNull("testMethod is Null", testMethod);

// set visibility to true for the private method
testMethod.setAccessible(true);

// get the constructor
Constructor constructor = targetClass.getDeclaredConstructor();
Object instance = constructor.newInstance(); // create a new instance

Integer param1 = 10;
Integer param2 = 10;

// invoke the method
Object testMethodResult = testMethod.invoke(instance, param1, param2);

Assert.assertEquals(100, testMethodResult);

Full source code can be found on
Github https://github.com/siddharthagit/javaexpcodes/blob/master/core-java/test/TestPrivateMethod.java

Proxy Design Pattern In java

2019-02-01T10:20:00.001-08:00

Type : Structural Design Pattern

Summary

Proxy Design pattern lets a Proxy Object rather then the real object to interact with Client. By doing so the proxy can control access to the real object or delay the creation of real object unless it is is really needed.

Description

In Proxy Design pattern the Client is served with a Proxy Object rather than the real object. Benefit of doing so is that, we have greater control in when to create the real object. It would help us in providing in lazy loading the real object, providing extra security checking etc.

Example

For example lets consider a service called UserDetails Service which the Client calls to get UserDetails Object. Now say UserDetails is a complex object, and we need to real the database to populate it. Also we would like to have a security authorization check by which we will not show the details at all or show only few attributes from UserDetails Object.

Returning a Proxy rather than original object help us in achieving our goals. In our example UserDetailsProxy either returns a proxy object or real object based on the parameter(caller id). Say if "admin" user is calling than it returns the actual object otherwise it returns the proxy object.

Class Diagram

Sample Code

public interface UserDetails {

  public UserDetails getUserDetails(String callerId, String uid);

  public Double getTotalBalance(String uid);
}

// actual Object which contains UserDetails
public class UserDetailsImpl implements UserDetails {

  private String userId;
  private String bankAccountNo;
  private String socialSecurityNo;
  private String zipCode;
  private Double totalBalance;

  @Override
  public UserDetails getUserDetails(String callerId, String uid) {
    return UserDetailsService.retrieveUserById(uid);
  }

  public UserDetailsImpl() {

  }

  @Override
  public String toString() {
    return "userId=" + this.userId + " bankAccountNo=" + this.bankAccountNo + " socialsecurity="
        + socialSecurityNo;
  }

  @Override
  public Double getTotalBalance(String uid) {
    return totalBalance;
  }

}


// proxy Object for UserDetails
public class UserDetailsProxy implements UserDetails {

  UserDetailsImpl realUserDetails = null;

  @Override
  public UserDetails getUserDetails(String callerId, String uId) {
    if (callerId.equalsIgnoreCase("admin")) {
      return UserDetailsService.retrieveUserById(uId);
    } else {
      return new UserDetailsProxy();
    }
  }


  @Override
  public String toString() {
    return "userId=NA bankAccountNo=NA socialsecurity=NA";
  }


  @Override
  public Double getTotalBalance(String uid) {
    if (realUserDetails == null) {
      realUserDetails = UserDetailsService.retrieveUserById(uid);
    }

    return realUserDetails.getTotalBalance();
  }

}


//UserDetails Service which returns the Object
public class UserDetailsService {

  public static UserDetailsImpl retrieveUserById(String uId) {
    UserDetailsImpl userDetail = new UserDetailsImpl();
    userDetail.setUserId(uId);
    userDetail.setBankAccountNo("swissbank_11228899");
    userDetail.setSocialSecurityNo("888 11 777");
    userDetail.setZipCode("95011");
    userDetail.setTotalBalance(99.9);
    return userDetail;
  }
}

Github Code

Advantages

Proxies can help increase performance by delaying creation of the real object.

It can improve security by wrapping the real object by proxy object and returning real object when allowed.

Disadvantages

Proxy pattern introduces new Proxy objects.

Proxy objects might need to refactored if the Original object also changes.

References

https://en.wikipedia.org/wiki/Proxy_pattern

Flyweight Pattern in Java

2019-02-01T10:20:00.000-08:00

Type : Structural Design Pattern

Summary

Flyweight design pattern deals with sharing some of the internal details between different object instances, so that we can save memory by basically using less duplication of the attributes across its instances.

Details

In Flyweight design pattern the Object attributes are categorized into its extrinsic and intrinsic attributes. Extrinsic attributes are the attributes that can be considered as sharable across other instances. Intrinsic attributes are the attributes that are unique for each object, like the primary key, unique fields etc.
In Flyweight design we can improve the memory footprint by reusing the extrinsic properties in multiple instances of the object.

Flyweight can use Cache to store the different Extrinsic states. Factory method can be used to create the instances of the Extrinsic object and stored in cache.

Example

For instance say we are designing a Vehicle in OOP. Now each instance of the Vehicle will have some unique characteristics like its serial number, registration number.

Also we can notice that each vehicle instances will share something very similar like the Body Type, Engine etc. across multiple instances.

We will consider the Engine to be extrinsic property which can be shared across different instances of Vehicle

We will consider the serial number as intrinsic property.

Vehicle is the interface representing vehicle

Vehicle contains an instance fo Engine

Engine is an interface

We have two type of Engine implemented by ElectricEngine and GasolineEngine

EngineFactory is a cache holding different types of Engine.

CarImpl implements Vehicle. It has a reference to Engine object.

Class Diagram

Sample Code


public interface Engine {
  
  public String getEngineName();

  public String getType();

  public int getHorsePower();

  public String getMaxSpeed();
}



public interface Vehicle {

  public String getModelName();

  public String getYear();

  Engine getEngine();

}

public class ElectricEngine implements Engine {

  private String engineName;
  private String engineType;

  public ElectricEngine(String name) {
    this.engineName = name;
    this.engineType = "Electric";
  }

  @Override
  public String getEngineName() {
    return engineName;
  }

  @Override
  public int getHorsePower() {
    return 200;
  }

  @Override
  public String getMaxSpeed() {
    return "110 MPH";
  }
  
  public String getEngineType() {
    return engineType;
  }

  @Override
  public String getType() {
    return this.engineType;
  }

}

public class GasolineEngine implements Engine {

  private String engineName;
  private String engineType;

  public GasolineEngine(String name) {
    this.engineName = name;
    this.engineType = "Gasoline";
  }

  @Override
  public String getEngineName() {
    return this.engineName;
  }

  @Override
  public int getHorsePower() {
    return 200;
  }

  @Override
  public String getMaxSpeed() {
    return "170 MPH";
  }

  public String getEngineType() {
    return engineType;
  }
  
  @Override
  public String getType() {
    return this.engineType;
  }

}



public class EngineFactory {
  private static Map engineCache = new HashMap();

  public static Engine getEngine(String engineName) {
    if (engineCache.containsKey(engineName)) {
      return engineCache.get(engineName);
    } else {
      if (engineName.startsWith("Electric"))
        return getElectricEngine(engineName);
      else
        return getGasEngine(engineName);
    }
  }

  public static Engine getGasEngine(String engineName) {
    GasolineEngine gasEngine = new GasolineEngine(engineName);
    engineCache.put(engineName, gasEngine);
    return gasEngine;
  }

  public static Engine getElectricEngine(String engineName) {
    ElectricEngine gasEngine = new ElectricEngine(engineName);
    engineCache.put(engineName, gasEngine);
    return gasEngine;
  }

  public static int getTotalEnginesMade() {
    return engineCache.size();
  }

}

public class CarImpl implements Vehicle {

  private String model;
  private String year;
  private String serialNumber;
  private Engine engine;

  public CarImpl(String model, String year, String slNumber, String type) {
    this.model = model;
    this.year = year;
    this.serialNumber = slNumber;
    this.engine = EngineFactory.getEngine(type);
  }

  @Override
  public String getModelName() {
    return this.model;
  }

  @Override
  public String getYear() {
    return this.year;
  }

  @Override
  public Engine getEngine() {
    return this.engine;
  }

  public String getSerialNumber() {
    return this.serialNumber;
  }

  @Override
  public String toString() {
    return "model= " + this.model + " year=" + this.year + " slNo=" + this.serialNumber
        + " engineType=" + this.engine.getType();
  }
}

Advantages

Memory consumption can be reduced by sharing Extrinsic states across objects.

Disadvantages

Flyweight weight increases the complexity of Object structure.

Adapter Design Pattern in Java

2019-02-01T10:19:00.002-08:00

Type : Structural Design Pattern

Summary

Adapter design pattern is a Structural design pattern. It is used to provides compatible interface for and Class so that can be used by Client. Adapter pattern is used to provide compatibility for Classes which already exists and cannot be modified.

Details

Need for adapter design pattern is very obvious. It is also very common in real world as well as in Software Engineering. For instance if we have any electrical appliances which runs on 110 Volt and then we travel to a country where the electricity supply is 220 V. We cannot change or modify the electric connection to provide us 110 V. Rather we can use a adapter to convert the 220 V from outlet to 110V.

Adapter pattern is similar to Bridge pattern because both provide mechanism to connect incompatible Classes.

Advantages

Incompatible Object or Class can be used using an Adapter for it.

Disadvantages

Increases number of Classes

Adapter Class needs to be modified if the Target Classes changes.

Example

For instance if we consider a TV set which has input connector as USB. We can connect any device which has USB port.

Now say a new device launched "Blue Ray DVD" which has HDMI as output. We cannot connect this two devices as they are not compatible .

We make them work together by providing an adapter HDMIToUSBAdapter which converts HDMI to USB and vice versa

Class Diagram

Sample Code


// TV which connects though USB port
public class TV {

  private USBConnectorPlayer connect;

  public void connectTVAndPlay(USBConnectorPlayer conn) {
    this.connect(conn);
    this.connect.renderContent();
  }

  public void connect(USBConnectorPlayer connect) {
    this.connect = connect;
  }
}


// USB connector player
public class USBConnectorPlayer {
   private String content;
   public USBConnectorPlayer(String content) {
     this.content = content;
  }
   public void renderContent() {
       System.out.println(this.content);
   }
}

// a player that supports HDMI connection
public class HDMIConnectorPlayer {

  private StringBuffer content;

  public HDMIConnectorPlayer(StringBuffer content) {
    this.content = content;
  }

  public void renderContent() {
    System.out.println(this.content);
  }

  public StringBuffer getContent() {
    return content;
  }
}

package blog.javaexp.structural.adapter;

// Adapter Class to convert HDMI to USB
public class HDMIToUSBAdapter {

  public USBConnectorPlayer convertToUSB(HDMIConnectorPlayer hdmi) {
    String str = hdmi.getContent().toString();
    USBConnectorPlayer ret = new USBConnectorPlayer(str);
    return ret;
  }

}

Github Code

References

Abstract Factory Design Pattern in Java

2019-02-01T10:18:00.001-08:00

Type: Creational Design Pattern

Summary

Provide an indirect way to create object that abstracts the creation of families of related objects without directly specifying their concrete Classes. The Factory owns the responsibility create objects. Client is not aware of how to create the object.

Details

It is similar to Factory method design pattern. Only difference is that rather than returning instance of Subclasses, Abstract factory method can create object of Subclasses having different inheritance hierarchy. Generally Abstract Factory will return different Factories, which in turn can be used to Objects

Abstract Factory is used when we want to create objects by Clients and control which instance should be returned. It is used in DAO (Data Access Object).

It can be used to design Platform dependent software solution, by providing platform specific implementations.

Example

We will extend the example of Sales Man and Different types of Car (SUV, Sedan) to have different type of Car's in terms of its engine (Electric, Gasoline). Now rather than giving an option to create instance of concrete Class like SUV and Sedan, we have an Abstract Factory Class which can return Factory for either ElectricCar or GasolineCar.

Class Diagram

Sample Code



// interface for Engine Factory
public interface EngineProvider {

  public Car getSedan();

  public Car getSuv();
}

// electric Car Factory
public class ElectricCarFactory implements EngineProvider {

  @Override
  public Car getSedan() {
    return new ElectricSedan();
  }

  @Override
  public Car getSuv() {
    return new ElectricSUV();
  }
}


//gasoline Car Factory
public class GasolineCarFactory implements EngineProvider{
 
  @Override
  public Car getSedan() {
    return new GasolineSedan();
  }

  @Override
  public Car getSuv() {
    return new GasolineSUV();
  }

}


// Car Factory Class which interacts with Clients
public class CarFactory {

  private static EngineProvider factory;

  public static EngineProvider getProvider(String providerName) {
    switch (providerName) {
      case "ELECTRIC":
        factory = new ElectricCarFactory();
        break;
      case "GASOLINE":
        factory = new GasolineCarFactory();
        break;

    }
    return factory;
  }
}

Github Code

Advantages

Provide a standard interface by which family of objects can be created
Internally in the Abstract factory we can use other design patterns like Flyweight or Proxy or Prototype pattern as per the need.

Disadvantages

Sometime supporting for new Object type might lead to changing the interface and refactoring the existing implementation.

References

https://en.wikipedia.org/wiki/Abstract_factory_pattern

Factory Design Pattern in Java

2019-02-01T10:18:00.000-08:00

Type: Creational Design Pattern

Summary

Factory or Factory method Design pattern is a creational design pattern. It helps in loose coupling between client and the actual object that the Client needs. Rather than Client calling the constructor using new operator it calls the Factory and the factory returns the respective object.

Details

Factory method design pattern encapsulate the complexities around creating an object and also uses Inheritance by letting factory method to decide which Subclass instance is needed to be returned.

Factory method pattern solves the issue of creating object without exposing internal details by
Provide an interface (Could be an Interface or Abstract Class) and a factory method
let the Client create the appropriate object by calling the factory method.

Example

Let's say we have a company ABC Cars Corp, which manufactures different type's of Cars (Sedan, SUV etc). Now we want to provide a way to the Sales man to be able to get a Car (object instance) based on Customer preference, and can demo those cars to Customers.
One option is to provide constructor for those Cars. So that Client can call the constructors and create cars.

That exposes a lot of technical details to the Sales Man. Better would be have a factory/or room which has all available cars. Then the Sales Man can could quickly turn around with available Car to the Customer. That way the learning curve for the Sales Man is very minimum.

Now say down the lane, ABC Cars Corp also starting manufacturing Sports Car. Now the problem is, all the Sales Team needs to know what parameters needed to be sent to create a sample Sports cars.

Factory method does that by utilizing inheritance and based on the requirement it creates a specific instance of one of the SubClass.

GasolineCarFactory is the Factory that implements a factory method.
Car is extended by two Subclasses SUVCar and CompactSedan Car

Class Diagram

Sample Code



// subclass of Car
public class CompactSedanCar extends Car {

  @Override
  public String getModel() {
    return "Compact4person";
  }

  @Override
  public String getPrice() {
    return "20k";
  }

  @Override
  public String getType() {
    return "COMPACT";
  }
}

// subclass of Car
public class SUVCar extends Car {

  @Override
  public String getModel() {
    return "SUV2019";
  }

  @Override
  public String getPrice() {
    return "40k";
  }

  @Override
  public String getType() {
    return "SUV";
  }
}

// factory method Class which the Client interact with
public class GasolineCarFactory {

  public Car getCarType(int i) {
    switch (i) {
      case 1:
        return new CompactSedanCar();
      case 2:
        return new SUVCar();
      default:
        return new CompactSedanCar();
    }

  }

}

Github Code

Advantages

Centralized interface to create object.
Easy of refactoring and code reuse.
Easy discovery for developers.
Better testable codes.
Internally the factory method can utilize Prototype design pattern or Flyweight design pattern as per the situation.

Disadvantages

Factory method design pattern adds a layer of attraction between Client and real Object.

when a new SubClass is introduced the factory method needs to update to take that into consideration.

When to Use

When we want to provide a centralized or common interface to create multiple objects (subclasses)

When we want to hide the complexities of creating instances of those object.
When we want to control how an object instance should be created.
If we have complex business logic while creating objects, this design pattern is very useful

References

https://en.wikipedia.org/wiki/Factory_method_pattern

Singleton Design Pattern

2019-02-01T10:17:00.002-08:00

Creational Design Pattern

Summary

Singleton Design pattern is used to provide a mechanism so that a Class can have only one instance. So when Client try's to use an instance of Singleton Class it gets the same instance.

Singleton.

Details

Singleton Design pattern make sure that Class which implement this pattern can have only one instance. In case of Java, only one instance in a single JVM.

For instance if we want only one instance of Cache Class which would store temporary values in memory.

Singleton pattern is also used in Logger Classes. Logger provide single instance for logging which is used by application code.

Singleton design pattern is implemented by following mechanism

1) Making the constructor private. So that Client cannot create different instances

2) Provide a static method, which the client will interact to get the instance of the class

3) Do not offer any setter method for the object

4) If any getter for individual property returns any object reference, it should return a copy of it

5) Taking care of reflection api, to do this we can throw exception in the constructor if it the instance is not initialized.

Advantages

Provide an option to make sure the instance is single, and if we want to create multiple copies of the object still they will be same.

Useful when we want only one instance of a Class like Service, shared resource etc.

Disadvantages

Depending on the need, DI/IOC can be better suitable.

Possible ways to break

Following points need to be thought about possible ways to break the Singleton Class to get more than one instance.

In java one can use the Reflection API to alter the constructor (private) of the Singleton Class to create different instances. This can be taken care by throwing exception from the private constructor.

In Java one can use the clone. It can be achieved by overriding clone() method and throwing Exception.

Multiple thread can break the Singleton Class. It needs to be taken care as well.

In Java Serialization can cause breaking this contract. It can be handled by returning the instance from readResolve() method.

Example

Let's take example of a House Key. We want only one key for the whole house. We do not want any way to temper the key. We want only one identical key to be available. If any one needs a key, essentially they will get the same single key instance. We can utilize the Singleton pattern to make sure that the key once generated is not modifiable.

Here the Class HouseKey implements Singleton pattern, and that Class make sure only one instance of the key exists.

Class Diagram

Sample Code


public class HouseKey implements Serializable {
  private static final long serialVersionUID = 1L;
  private String keyPattern;
  private Long keyDate;

  private static HouseKey instance;

  // private constructor
  private HouseKey() {

  }

  // public get instance method
  public static HouseKey getInstance() {
    if (instance == null) {
      synchronized (HouseKey.class) {
        instance = new HouseKey();
        instance.keyPattern = "key 12345";
        instance.keyDate = new Date().getTime();
      }
    }
    return instance;
  }


  // safeguard against Clone
  protected Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
  }


  // safeguard against Serialization
  public Object readResolve() {
    return HouseKey.getInstance();
  }

  @Override
  public String toString() {
    return "HouseKey " + this.keyPattern + "  " + this.keyDate;
  }
}

Github Code

References

https://en.wikipedia.org/wiki/Singleton_pattern

Chain of Responsibility Design Pattern in Java

2019-02-01T10:16:00.000-08:00

Type : Behavioral Design Pattern

Summary

Chain of Responsibility deals with how best we can design a sender - receivers without tight coupling the sender and receivers. Where the sender

sends an object to a set of receivers. And one or more than one receiver work on the object that the sender sent.

Details

As the name suggests, rather than the Client deciding how to process an request object( Say by calling specific method from specific Object), the request is sent though a pipe or chain of different Objects which might be able to process the request.

The request enters from one end and pass on the request to the next Handler until the request processor is done.

Following are the participants in this pattern

Handler : An Interface that Concrete Handlers implements

Concrete Handler : Handler implementation that processes the request, or pass to the next handler in the chain.

Client : Client that utilizes the chain of handlers by invoking first handler.

Advantages

Sender and receiver (handler) can go independently

Follows plug in like architecture, where we can add more handler without changing existing behaviour.

Easy to maintenance and more testable code.

Disadvantages

If the handlers are not implemented properly it could result in broken processing the request.

Based on the logic wrong order of the Handler in the chain could cause issue.

Example

Let's take example of a software system which processes customer request. Broadly we have divided the customer request as of 3 types for now Account, Billing and Technical support related. When client sends the request we loop though all the respective handler and process the request. We also have a Default handler which works when the customer that is asking for something we donot support.

Class Diagram

Sample Code



// interface to represent a request
public interface Request {

  public String [] getRequestDetails(); //PasswordReset, UnlockAccount, GetAccountDetails
  
  public void setRequestDetails(String [] news); //PasswordReset, UnlockAccount, GetAccountDetails
}

// customer support request object containging request details
public class CustomerSupportRequest implements Request {

  private String[] requestDetails;

  public CustomerSupportRequest(String[] reqType) {
    this.requestDetails = reqType;
  }

}

// abstract request handler
public abstract class RequestHandler {

  RequestHandler nextHandler;

  public void setNextHandler(RequestHandler handler) {
    this.nextHandler = handler;
  }

  public void handleRequest(Request req) {
    processRequest(req);
    if (this.nextHandler != null) {
      this.nextHandler.handleRequest(req);
    }
  }

  public abstract void processRequest(Request req);
  
}


// account related request handler
public class AccountRequestHandler extends RequestHandler {

  @Override
  public void processRequest(Request req) {
    System.out.println("ACCOUNT DEPARTMENT HANDLED!");
  }

}

//billing related request handler
public class BillingRequestHandler extends RequestHandler {

  @Override
  public void processRequest(Request req) {

    System.out.println("BILLING DEPARTMENT HANDLED!");

  }

}

//technical related request handler
public class TechnicalRequestHandler extends RequestHandler {

  @Override
  public void processRequest(Request req) {
   
    System.out.println("TECH DEPARTMENT HANDLED!");
    
  }

}