Java Boots

AWS Notes of training

2019-08-17T18:33:00.000-07:00

Listing some notes from my learning. I hope it is useful for everybody.

AWS is a secure cloud service platform offering computation power, database storage, content delivery and other useful functionalities that help the business to scale.
We have different domains in AWS:

Compute (EC2, Light Sails, Lamda)
Storage (Disk, SSD) : S3 low cost storage
Database (SQL/NoSQL): RDS
Network and Content delivery: Route53 (DNS system)
Management Tools: Manage AWS services (Cloud Watch)
Security and Identity Compliance: "Iam" accounts (authenticate user access to AWS )
Messaging: Email Service, PubSub,
Migration (Transfer GB of data to AWS. Snowball (sending physical data to AWS) )

AWS Compute Services:

EC2: Raw server configured to anything
Lamda: To host background tasks and not hosting. Listen to triggers and execute the code.
Elastic Beanstalk: Advanced of EC2. Here we don't need to set up the env manually. You select what you need and AWS installs every s/w require for you like java, tomcat, load balance, and Nginx. One needs to upload the code and its autoscale depends on autoscale settings.
Elastic Load Balancer: Distribute the workload on deployed resources.
Autoscaling: Scale up the infra automatically. say if CPU usage above 70%, launch a new server.

AWS Storage Domain

S3: Object-Oriented File System. All files are treated as objects and stored in a bucket(folder). Root has to be a bucket and upload files (object)
CloudFront: Content delivery Network
Elastic Block Storage: Hard Drive to EC2. EC2 is backed by EBS volumes. One EBS instance can be connected to one EC2 instance, just like 1 HDD connect to one computer.
Glacier: A Data archiving server (magnet tapes). Data which is not frequently used. Retrieval time is more but cheap.
Snowball: Transferring data to AWS and back from the AWS server using the SNOWBALL device. Use case transfer petabyte of data as physically transferring data.
Storage Gateway: Provides on-premise servers access to virtually unlimited cloud storage. Move tape backups to cloud, provide backup dB files and pure files, AWS data sync.

AWS Database Service

RDS: Relation DB mgmt service (Oracle, Mysql, MariaDB, SQL Server, Amazon aurora). Updates DB engines, install security patches automatically
Aurora: DB developed by Amazon
DynamoDB: Mgmt service for Non-relational DB (NO SQL). It's a NoSQL DB which managed automatically. If more data comes, DB automatically scales.
Elastic Cache: Amazon ElastiCache offers fully managed Redis and Memcached. Seamlessly deploy, run, and scale popular open source compatible in-memory data stores
Redshift: Data Warehouse service(Analytics). Data fed from RDS, DynamoDB and do analysis.

AWS Networking Service

VPC: Virtual Private Cloud. If AWS instance is configured for 1 VPC, so all instances/resources are visible to each other and can interact. Provide security and communication made easy.
Direct Connect: It's a leased line which you can directly connect to AWS. Instead of the internet, we can direct connect service.
Route 53: is a DNS. Redirect traffic from URL to IP address

AWS Management Services

CloudWatch: Monitoring tool to monitor AWS resources. Creates an alarm.
CloudFormation: used to templatize the AWS infra.
CloudTrail: is a logging service backed by S3
CLI: CLI tool for AWS
OpsWorks: A configuration mgmt tool. Layers and stack.
TrustedAdvisor: is a personal advisor in the AWS. Advises on certain best practices, Iam policies.

AWS Security Service

IAM: Identification and Authentication Mgmt tool.
KMS: Key Mgmt Service: Public key with AWS and user log in with the private key.

AWS Application Services

SES: Simple Email Service. Manage auto-reply.
SQS: Simple queue service. The server reads the queue and executes them.
SNS: Simple notification service to send notification to related AWS service.

AWS Pricing

Pay as you Go: Pay what you use
Pay less by using more: Bills you for the hour
Save when you reserve: Reserving your instance for specific time frame.

How generics can be used in Class Factories

2013-05-02T06:22:00.000-07:00

Lets see how generics can be used to create generic interface for class factories.

public class GenericFactory <E>
{
Class<E> thisClass=null;

public GenericFactory (Class iclass)
{
this.thisClass = iclass;
}

public E createInstance() throws IllegalAccessException,InstantiationException{
return(E)this.thisClass.newInstance();
}
}

The <E> is a type token that signals that this class has a type set when instantiated.

public class Myclass {

void print()
{
System.out.println("Hellooo");
}
}

public class Main {

public static void main(String[] args) throws IllegalAccessException, InstantiationException {

GenericFactory<Myclass> factory = new GenericFactory<Myclass>(Myclass.class);
Myclass myclass= factory.createInstance();
myclass.print();
}
}

Output:- Hellooo

We can see that, it is not necessary to cast the object returned from the factory.createInstance().

When to use getClass() and instanceOf in Java

2013-05-02T06:00:00.002-07:00

getClass() only gives equality if two objects belong to same class whereas instanceOf works for subtype also.

If two objects of different classes are checked for equal, then we use instanceOf . But once you use instanceOf at some level in the class hierarchy everything below it must use instanceOf or you will violatate the symmetry clause of equals contract.

e.g. any list can be equal to any list as long they have same elements iun the same order. So any List implementation equals() method must do instanceOf and not getclass() and then compare.

On the other hand, it only make sense for na instance of class X to be equal to another instance of class X ( and not any subclass ) , then use getClass().

Java Interview Points

2013-04-30T10:31:00.003-07:00

Java Interview Points

Uses of finalizer :-

It acts as a safety net. It may be better to free the resources than never e.g. FileInputStream, Connection etc.
Object with native peers, the garbage collector doesn't know about it when it reclaimed the java peer. If native peer hold some critical resources, we can use this method to free the resources.

Clone will not work if the array fields are final because clone would be prohibited from assigning a new value to the field.
A method in an interface can’t be native, synchronized, strictfp but in the implementation class it can be since these keywords describe implementation properties rather than interface properties. Same is true for final.
Only data associated with specific instances of a class is serialized, because static data is associated with a class as opposite to an instance, so it’s not serialized automatically. To serialize static data, one must provide class specific serialization.
Array implementation in Java: - Java treats an array as an object. When we declare an array as

long[] temp = new long[10] ;
the jvm creates a long[] class with temp as its object. When we print the name as

SOP(temp.getClass().getName()), it prints

Definition of this class is:

public abstract final class [J extends java.lang.Object implements Cloneable,Serilizable {
}

6 . Abstract class constructors are frequently used to enforce class constraints as invariants such as:
minimum fileds requiredto set up the class.

7. The foreach loop can be applied to any Object that implements Iterable<E> which in turn refers to

Iterator<E>. Methods Iterstor, hasNext, next which are used by during the transalation of the loop.

8. The < ? extends Animal> means that you can take any subtype of animal, the subtype can be either a

sublass of a class (Abstract or concrete) or a type that implemetsthe interface after the word extends.

Also, it can be assigned a collection that is subtype of Animal or anything that extends
Animal and I promise that I will not add into the collection.

9. List<? > means that it can support any type but does not support Add.

10. You cannot put anything into a type declared with extends wildcard except for values as NULL,

which belongs to every ref type.

11. Extends wildcard does not ensure immutability since we can still add null to it. Also you can remove,

remove all, retain swap, shuffle etc.

12. Get and Put Principle tells us that if a structure contains a wildcard, we should get the values of it(if it

extends wildcard) or put values into it (if it is super wildcard). For a strucutr to be usefull, we must do

both.

e.g List <Number> nums = new ArrayList<Number>();

List<? Super Number> sink = number // put

List<? Extends Number> source = nums; //get

Why we have Runtime Exceptioons in Java

2013-04-12T11:29:00.001-07:00

Oracle defines Exception as

"An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions."

We have three categories of exception as:-

Checked Exceptions , which are subject to catch . All exceptions are checked exceptions, except for those indicated by Error, RuntimeException, and their subclasses

Runtime Exceptions are internal to the application and system does not expect to recover from. NullPointerException is type of RunTime Exception

Error are exceptions which are external to applications like OutOfMemory Exception, StackOverFlow Exception.

The class diagram of Exception is as follows:-

This discussion is regarding why we have Runtime type of exceptions in Java.

When exception was first designed, there was worry about conditions that occur because of

problems with the machine on which the program being run
bugs in VM
security violations.

These sort of things can occur any time. But it would only clutter up the language to require every method declare that it can throw an exception for these reasons.
Generally, it would not be the method that throw such an exception, it would be the underlying VM. It would just make the code longer and less robust To clear this , a special sort of exception, called RunTime Exception was build into the Java. Since RunTimeException can be thrown any time and need not to be declared as part of method signature.

Use: Sometime in the midst of writing the implementation programmer discovers that there is an exception condition that hadn't thought in the original design. One way , is to declare the exception as Exception as subclass of Runtime Exception. That way, one need not to change the calling code.
But , it will result more work and headache in future, when you try to find out why system is failing, Since it not mandate to catch.....

How class.forName loads the Database Driver in JDBC

2012-08-24T13:50:00.001-07:00

When Class.forName() is called with an argument like this:

Class.forName("org.gjt.mm.mysql.Driver");

the classloader attempts to load and link the Driver class in the “org.gjt.mm.mysql” package and if successful, the static initializer is run. The MySQL Driver static initializer looks like this:

static {
try {

    java.sql.DriverManager.registerDriver(new
Driver());

} catch (SQLException E) {

    throw new RuntimeException("Can't register
driver!");

}
}

So it calls a static method in the java.sql.DriverManager class which apparently registers a copy of itself when it loads.

To understand the why you have to look at the next line in the initial code example:

Connection con = DriverManager.getConnection(url,
"myLogin", "myPassword");

The DriverManager class returns a database connection given a JDBC URL string, a username and a password. In order to create that connection, the DriverManager class has to know which database driver you want to use. It does that by iterating over the array (internally a Vector) of drivers that have registered with it (ie: the registerDriver(Driver driver) method illustrated above) and calls the acceptsURL(url)) method on each driver in the array, effectively asking the driver to tell it whether or not it can handle the JDBC URL.

First the DriverManager tries to use each driver in the order it was registered. (The drivers listed in jdbc.drivers are always registered first.) It will skip any drivers that are untrusted code unless they have been loaded from the same source as the code that is trying to open the connection.

It tests the drivers by calling the method Driver.connect on each one in turn, passing them the URL that the user originally passed to the method DriverManager.getConnection. The first driver that recognizes the URL makes the connection.

All DriverManager methods are declared static, which means that they operate on the class as a whole rather than on particular instances. In fact, the constructor for DriverManager is declared private to prevent users from instantiating it. Logically, there is one instance of the DriverManager class.

Problems on Bit Manipulations

2012-06-22T01:47:00.001-07:00

Check if two numbers have opposite sign

We can use the operation

if (x ^ y) < 0 where x and y are non zero numbers

{ True --- if numbers of opposite sign

{ False --- if numbers of same sign

int x=-10,y=2;
System.out.println(((x ^ y) < 0));

Output :-
False

Check if number is power of 2

We can use
x & (x - 1)) == 0    True   --- if numbers is a power of 2
                                 False --- if numbers is not a power of 2

int x=16;

System.out.println((x & (x - 1))==0);
Output :-
True

More bitwise tricks

x&(x-1) :---------------- Returns number x with the lowest bit set off
x ^ ( x & (x-1 ) :---------------- Returns the lowest bit of a number x
x & 1<<n :---------------- Returns 1<<n if the n-th bit is set in x
x | 1<<n :---------------- Returns the number x with the n-th bit set
x ^ 1<<n :---------------- Toggles the state of the n-th bit in the number x

Displaying all subsets of a subset.

Consider a number 10110

Required Output :-
00000
00010
00100
00110
10000
10010
10100
10110

Algorithm

start
N; //an integer
X = N
while true
print X
if( X == 0 )
break;
X = (X-1) & N;
end while
end

Immutability in java

2012-06-03T12:13:00.000-07:00

In Java, Object can be of two types :-

Mutable
Immutable

Mutable objects are the ones whose state can be changes during its lifetime. This is in contrast with Immutable objects, whose state cannot be changed once created. We have many classes in Java which provide immutable objects like String, Integer etc. In this post, I will discuss the immutability in detail, with its features and where can we use this.

In basic terms, Immutable objects are the ones, whose state cannot be changed.e.g

Integer i = new Integer(10) ;

The Integer class provides us no method which can change the state/value of i. So we say Integer is an immutable class & object i is an immutable object.

We have many benefits for it:-

They are good candidates to cache :- Since immutable objects do not change their state, we can share or cache them and retrieve them in future, without copying and cloning the object.
Solid keys :- Immutable objects makes the best keys for Hash classes. HashCode() method depends on the state variables. In case of immutable, state is consistent, the key would always return the same value. For mutable, if state changes after storing in Hash class, the hash algorithm gets confused and will return the wrong or null value.
Provides Thread Safety :- In muti-threaded applications, Many issues arises due to read-write conflicts. Say, one thread going to read a object state while other simultaneously changes the state OR two threads want to write a value at the same time. To prevent this, either we use synchronize the access or can use locks, to prevent object from an inconsistent state. Its not advisable to synchronize everything as it may affect the concurrency. Here we can use Immutable objects that can be shared between threads. Since their state cannot be changed, they can used without any synchronization and simplify the writing, documentation and helps in reducing potential concurrent errors.

Everything not come as free and So as immutability. Follows are its drawbacks :-

Creating a lot immutable objects will have impact on the memory and may result in frequent GC. One way to avoid this is use Flyweight pattern for sharing objects whenever required.
Since the class is final and so as the methods, which prevent to scale the class.

How to create a perfect Immutable class:-

Class declared as final
All of its fields are final and private
this reference is not allowed to escape during construction.
If fields contains mutable objects like arrays,collections then they

should marked private
should never return or expose to callers
should not provide methods to change state

One Imp Note: If a class is final. then all its methods are implicitly final as well and the method is guaranteed not to be over-ridden as well.

When to use Immutable Classes :-

Ideal for defining abstract data types like Integer, BigDecimal, DaysOfWeek, Colors.
When your object needs security from outside interference. One way hacker use to control your class is by subclassing your class and access your private data and methods. Sting class is final for this reason.
Depends on the application like how often the objects would change (defines the synchonization level). If they change, would it meant something for the application. Application is single threaded or multi-threaded.

In case of doubts or corrections, please post a comment. In my future post, I will discuss how to use arrays in immutable class.

Generate Heap Dump in Unix

2012-05-04T07:51:00.000-07:00

Heap dump provides the insight into the JVM - shows live objects on the heap (reachable and unreachable) along with their types and values. In addition it also provides no of objects and their size as %age of total heap size.We have many ways to get the heap dump in Windows. Some are as follows:-

jconsole
jVisual VM
Eclipse MAT ....and it goes on

Out of above , i like jVisualVM the most due to its monitoring capability, interactive display, and easy to use. But the problem comes with the unix. Even though we can monitor the application remotely but we cannot see the live objects, their size and number i.e we cannot get the heap dump remotely.

To get the heap dump on Unix machine, we can use jmap. To use jmap, we need the process id of java application. At times, we have lot many java process running in unix and its difficult to identify. Java provides jps tool which list the JVM with the process Id which it got the access . The steps are as follows:-

Type jps on unix. This will list down all java process running on Unix
Use jmap as jmap -dump:file=<filename> <processid> e.g. jmap -dump:file=heap1.hprof 6771
File created would be read only. If you want to copy, you have the chnage the acess rights. to use we can use chmod as :- chmod 777 heap. hprof

We can copy the dump to windows machine and run jvisualVM. Goto File --> Load

Browse the file in windows as shown and click ok.

Now the dump is loaded in jvisual VM. Next screem shows the summary, classes and instances. summary shows the objects,classes and instances loaded into JVM, classes shows all the classes loaded with no of instances and size as shown.

Summary View:-

Class View:-

In my Next post, I will be discussing how to analyse heap dump in Eclipse MAT

Resource:-

Why Time gets truncated with ResutSet getDate() function.

2012-02-06T09:05:00.000-08:00

Recently I stuck in an issue on populating date from stored procedure. I am reading a date from a resultset using rs.getDate(), storing in a java.util.Date instance variable and displaying on the screen.

Java.util.Date mydate = rs.getDate(1);

Output is only date while time is truncated. But why …!
That confused me a lot. So I google it. Spending lot of time in reading blogs, oracle docs and trying different things on oracle server like checking NLS_DATE_FORMAT, I am not able to get the time.
Next I come across a Timestamp thing in Resultset class.

Rs.getTimestamp (int colIndex)

When I use it, I immediately get the time. Now, the important question, why the resultset function getDate() does not return the Time. Now my search is preety narrow. What I found is :-

In java, we have java.util.Date for java.sq.Date . So functionalities available in sql.Date are also available in util.Date. But there is one difference, sql.Date stores only Date and not Time of date. To get the time, we have to use java.sql.Timestamp class. We can store into util.Date object since Timestamp, in both java.util and java.sql , extends Date class of respective packages.

To verify, I ran the following simple program which verifies my explanation.

public class DateProb {        

       public static void main(String[] args) {

              long time = System.currentTimeMillis();
              java.sql.Date sqlDate = new java.sql.Date(time);
              System.out.println(sqlDate);
              java.sql.Timestamp timestamp = new java.sql.Timestamp(time);
              System.out.println(timestamp);
              java.util.Date utilDate = new java.util.Date(time);
              System.out.println(utilDate);     
       }       
}

Output:-

2012-02-06
2012-02-06 22:33:36.946
Mon Feb 06 22:33:36 IST 2012

Please share your thoughts on this.

Where to declare Constants in Java

2011-11-15T06:08:00.001-08:00

Its been an topic of debate where should constants be declared. Let look at approaches :-

Declared in an Interface.
Declared in a Class.
Enums

Going through google, i found number of explanation for both of these. Each have their pros and cons. I'll try to summarise and share my thoughts on it.

Lets start with interface. In Java, Interfaces are used as abstract type, that contain method signatures, constants and nested types as according to Oracle. We can use interfaces to defined a contract or for communication as explained in my previous article. If we define constants here, we can have the following consequences:-

We cannot stop a class to not implement an interface.So a Global constant interface can be used for subtype which is not advisable.
We cannot give define constants depend on certain state condition.
All the constants would stay in memory all the time.

Although, we can define constants in interfaces, we have the above constraints. Lets look how we overcome all of this in Class.

We can declare a UtilConstant class. Make it final and make the constructor private. With this, we can overcome the problem (1) of interfaces.
Also if constants to be declared need some computation or a function call, we can do in class as defined below:-

public class constantClassExample {
static final int BATCH_SIZE=getBatchsize();

   private static int getBatchsize() {
   // User defined computation
   return 0;
  }
}

So we have seen that we can define constants at runtime i.e (2).
So to overcome (3) problem in interfaces, we can make use of static imports. It allows you to import one or two members as per requirement. Be aware, if you import all the constants using '*' , it can polluter your class space.
Afcourse, if the constants are relevent to current class, it will help keeping the code encapsulated.

Last comes the Enums. If the constants can be clubbed to one single type or we need to enumerate , we can use Enums.

For futher readings -

More About Java Arrays

2011-10-07T06:43:00.000-07:00

With the addition of Collections in Java, the use of primitives and primitive arrays decreases day by day. But at the API level or framework design level, primitives are highly used even today as they are fast and does’t include method chaining.

Arrays class in Java, provides the basic to advanced functionality to arrays. Java 6 adds a couple of more functions to this class. They are

copyOf ( T[ ] original, int newLength )

copyOfRange( int[ ] original, int from, int to )

CopyOf copies the array and allows to explicitly defined the size of new array, padding with zeroes (in case of int, float, double, short), null (in case of char) and false (in case of boolean). Its similar to System.arraycopy() but doesnt allows to specify the size of output array. Simple but useful functionality.

Lets understand with the example:-

public class Test {
 public static void main(String[] args) {
  
  int[] orig={1,2,3,4,5,6,6,7,77,8,8};
  int[] copyOf = Arrays.copyOf(orig, 20);
  System.out.println("CopyOf---> "+copyOf.length + "   " +Arrays.toString(copyOf));
  
  int[] copyOfRange= Arrays.copyOfRange(orig, 0, 7);
  System.out.println("CopyOfRange---> "+ copyOfRange.length + "   " +Arrays.toString(copyOfRange));   
 }
}
 Output:-
CopyOf---> 20   [1, 2, 3, 4, 5, 6, 6, 7, 77, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0]
CopyOfRange---> 7   [1, 2, 3, 4, 5, 6, 6]

Keep looking the space for more tips and tricks.

Pay Packets of BIG IT Giants

2011-10-01T21:11:00.000-07:00

What Apple is paying for a Software developer..? How much is facebook, Twitter, linkedin paying to Analysts?

Mentioned above are few Big Tech IT Companies where everybody likes to work. Well few of us got an opportunity. But at least everybody likes to know what they are paying....!

Few days back, I come across a website http://techcompanypay.com/ ,which shows the average salary of IT companies as per their designation. The company claims that it had collected the information publicily available on the internet, so no comment on the authenticity. But at least one can have the idea... Do check it out.

Learning JDK 7 Features Part 3: Try With Resource

2011-09-28T06:27:00.000-07:00

Today we follow some standard coding conventions so that code should easy to read and maintainable or i can say " Code should look beautiful ". But there are some cases where we find our code is cluttered or duplicated. Its more often with Exception Handlers, Streams and JDBC calls i.e. opening and closing streams/connections and multiple catch handlers. Java 7 comes to rescue us from this duplication and is succeeded in it.

Before Java 7, to cloase a resource, we write a final block and close every resource in it. but some times the finally block become large and cluttered. Take a look at the code below:-

finally {
            try {
                if (resultSet != null)
                    resultSet.close();
            }
            catch(Exception e) {}
            finally {
                try {
                    if (statement != null)
                        statement.close();
                }
                catch(Exception e) {}
                finally {
                    connection.close();
                }
            }
        }

So here we see that we close the every stream and write catch block for every close which makes the code cluttered. Also there is good chance that one forget to close the resource and it stays in memory forever.

With Java 7, there is no need to close the resource manually . Java do it for you. But there is catch. One must aware of catching mechanism, which I'll discuss later. Lets look at updated code:-

public static void printEmployees(Connection con) 
 {
  String query = "select ID, NAME, Location, Employee";

  try (Statement stmt = con.createStatement();
    ResultSet resultset = stmt.executeQuery(query);)
  {
   while (resultset.next()) {
    String id = resultset.getString("ID");
    String name = resultset.getString("NAME");
    String loc = resultset.getString("Location");
    System.out.println(id + ", " + name + ", " + loc);
   }

  } catch (SQLException e) {
   e.printStackTrace();
  }
 }
}

We declare the objects/resources in try, as shown in code. Now, there is no need to write finally block to close the resources. Now the question arises, what type of object should consider as resource. Java comes up with a new interface to solve the problem; is "AutoCloseable". Those classes which implements the interface is considered as a resource, can used inside try. Below is an example to declare a class as resource and used try as resource :-

public class  TestNewTryCatch{

 public static void main(String[] args) {

  try(MyResource res = new MyResource())
  {
   res.execute();
  }  
  catch (Exception e  ) {}
 }
}

class MyResource implements AutoCloseable
{
 @Override
 public void close() throws Exception {
  System.out.println("In close");
 }
 public void execute() throws Exception
 {
  System.out.println("In Execute");
 }
}

Exception handling handles differently. If an exception is thrown in try block and one or more exceptions are thrown from try with resource than exceptions that corresponds to try with resource are surpressed. We can retrieved the surpressed exceptions using throwable.getSuppressed() . Lets see with an example:-

public class TestNewTryCatch{

 public static void main(String[] args) {
  try(MyResource res = new MyResource() )
  {
   res.execute();
  }  
  catch (Exception e  ) {
   System.out.println("In exception-->" + e.getMessage());
   Throwable ht[] =e.getSuppressed();
   for(Throwable t:ht)
   {
    System.out.println(t.getClass());
    System.out.println(t.getMessage());
   }
  }
 }
}
class MyResource implements AutoCloseable
{
 @Override
 public void close() throws Exception {
  System.out.println("In close");
  throw new MyException("Test2");
 }

 public void execute() throws Exception
 {
  throw new RuntimeException("EXECUTE Test");
 }

}

class MyException extends Exception
{
 public MyException(String string) {
  super(string);
 } 
}
Output:-
In close
In exception-->EXECUTE Test
class MyException
Test2

Hope this article puts some light into the new try feature. Throw a comment in case i miss something or have some query.

Why java supports Multiple Interface Inheritance

2011-09-27T03:39:00.000-07:00

Java does not support multiple class inheritance i.e. we cannot extend multiple classes at one time in a class. But we can implememt multiple interfaces in a class. Lets start with the benefits of inheritance.

Interfaces are user for two reasons :-

1) Contract

2) Communication

Contract ,is an aggrement between the interface and the implementing class, that the class will provide the implementation of the methods of the interface's. On has to adhere to the contract. Collections in java has many interfaces like Set, List, Map. These interfaces provide the basic set of methods for the class depending on its interface type.We have their implementation classes like HashSet for Set, ArrayList for List and HashMap for Map.

Communication , is used to communicate certain functionality of a class to the outside world. This is very usefull when you want to expose a class but we dont want that one should know all the methods , variables and other class information. Instead we expose the interface which has some defined methods and one can call those methods only. This technique are highly used in frameworks and remote applications. Lets understand with a example.

LinkedList class in java implements two interfaces. List and Queue. Each interface has its own set of methods but the use case is differant for each. List is used to store elements as list while queue is based on FIFO or LIFO but the use the same class LinkedList. So, when we wan to use LinkedList as List, we expose as List interface and when we require a LIFO/ FIFO type functionality, we expose the Queue Interface.

Now come to the question i.e. multiple inheritance part. As discussed in Communication part, we can expose a class with a interface. If Java doesnt support multiple inheritance, we have to write different classes for each interface, where each class has the same code, but method names would be different which increase the duplication of code.

Wonderfull, isnt it......!

Fix double check locking in Java 5

2011-09-25T01:13:00.000-07:00

We can fix the double check locking using volatile keyword. In Java 5, the JRE system will not allow a write of volatile to be reordered i.e read and write of volatile cannot be reordered w.r.t any previous read and write. So the volatile always gives the latest value.

class Foo{
               private volatile Helper helper=null;
               public Helper getHelper(){
                  if(helper=null){
                      synchronized(this){
                          if(helper=null)
                              helper=new Helper();
                   }
               }
               return helper;
          }
}

Learning JDK 7 Features Part 2: Updated Generic Instance Creation

2011-09-23T08:47:00.000-07:00

Prior to Java 7, we create the generic instance as follows:-

List<String> list = new ArrayList<String>( );

This syntex tunrs urgly in complex situations in which the length of type parameters increases. As mentioned in Effective Java (2nd Edition) chapter 2 , Joshua suggest us a way which can reduce the verbosity of generic instance creation; as follows

public class TypeInference {
              public static void main(String[ ] args)
                   {
                      List list = TypeInference.newInstance(); list.add("str");
                    }
               public static ArrayList newInstance( )
                  {
                       return new ArrayList( );
                  }
}

Even the previous method has an limitation that u have to insert a static method for each implementaion class.

Oracle with Java 7 comes out a way which take of this redundancy with some limitations. As suggested in oracle documenation , we can create objects with empty type parameter(<>) as long as compiler can understand the defined type at compile time. This pair of backets defined informally diamond by Oracle.

Lets understand with an example prior to Java 7:-

Map <String,HashMap<String,List<String>>> map = new HashMap<String,HashMap<String,List<String>>>( );

In Java 7 , we can substitute the parametrized constructor with empty brackets as shown:-

Map<String,HashMap<String,List<String>>> map = new HashMap( );

Everything doesnt come free. So as Java. We cannot use subtitute the empty bracktes (<>) everywhere instead of type paramters. Lets look a at the example

List list = new ArrayList( );
list.add("A");
// The following statement would not compile since addAll expects Collection
list.addAll(new ArrayList( ));

Error Msg :-The method addAll(Collection<? extends String>) in the type List<String> is not applicable for the arguments (ArrayList<Object>) . FYI : syntax for addAll

boolean addAll(Collection c);

But the following line will compile:-

list.addAll(new ArrayList( ));

Learning JDK 7 Features Part 1 : Strings in switch Statements

2011-09-23T03:23:00.000-07:00

Switch statement is enhanced in JDK 7 with the support of String Object. Prior to it JDK 7 release, switch only supports byte, short, char, and int litearls. With this release onwards, we use string objects in switch expressions. Its is same as comparing String.equals method for each case. Please note the comparison is CASE- SENSITIVE. Let see how it works :-

private static String getTypeOfSeasonFromSwitch(String monthArg) {
  
  String typeOfSeason = null;
      switch (monthArg) {
       case "December":    
       case "January":
       case "Febuary":
           typeOfSeason = "Winter";
              break;
          case "March":
          case "April":
          case "May":
           typeOfSeason = "Spring";
              break;
          case "June":
          case "July":
          case "August":
           typeOfSeason = "Summer";
              break;         
          case "September":
          case "October":
          case "November":
           typeOfSeason = "Autumn";
              break;          
          default:
              throw new IllegalArgumentException("Invalid month: " + typeOfSeason);
      }
      return typeOfSeason;
 }

Generate Java POJO and Hibernate XML from database tables

2011-09-21T06:53:00.000-07:00

Today we have frameworks to persist java objects to database without writing DAO's and hibernate is one which is widely used. But for nascent developers, creating its mapping to database tables is still difficult.

Recently I come across a way to generate Java POJO and hibernate mapping XML from database tables using a Jboss Hibernate Tools. Its as easy as a click and magic, mapping XML is generated and
corresponding POJO 's are generated. Listed down the steps :-

1. Install the hibernate-tools jar using Eclipse's Install New software, selecting URL from http://www.jboss.org/tools/download.html depending upon the eclipse version.

2. Click on [File -> New -> Other -> Hibernate -> Hibernate Configuration File] and create a cfg file. The following properties should be specified : jdbc url , username, password, DB schema, driver class and dialect.

3. Click on [File -> New -> Other -> Hibernate -> Hibernate Console Configuration ] and create a new console configuration. Add the jar file that contains your DB driver in the classpath section at the bottom.

4. Enter the name of the console configuration. Click Browse button against the Configuration file and select the cfg.xml file created in step 3

5. Click on [File -> New -> Other -> Hibernate -> Hibernate Reverse Engineering File(reveng.xml) and select the location of the file.

6. Select the cfg.xml file created in step 3 as the Console Configuration. Click on include button and specify the schema and table name(s) to reverse engineer. Multiple table names can be specified using sql wild char (eg: TBL_%). Click Finish

7. Switch to the Hibernate perspective and Click on the Hibernate icon in the tool bar and select the [Hibernate Code Generation ..] option.

8. Right click on the [Hibernate Code Generation]tree node and select New.

9. Give the name of the configuration and select the console configuration created in step 5 and reveng.xml created in step6-7. Also select the Output Directory and a relevant package.

10. Go to the Exporters tab and check Generate domain code(.java) and Generate mappings (hbm.xml). Click run.

11. The hibernate mapping xml files and Java classes will be created in the output directory specified in step 9.

My first Post

2011-09-21T06:13:00.000-07:00

Welcome you at the JAVA BOOTS.

Its a place where u find,discuss,share common problems,coding strategies, design principles etc in java and related technologies. I keep sharing my learnings here. Hope it will be helpful to all.