jQuery fundamentals - jQuery basic tutorial 2

2. jQuery Fundamentals

jQuery is a framework built using JavaScript capabilities. So you can use all the functions and other capabilities available in JavaScript.
This chapter would explain most basic concepts but frequently used in jQuery.

String:

A string in JavaScript is an immutable object that contains none, one or many characters.
Following are the valid examples of a JavaScript String:
"This is JavaScript String"
'This is JavaScript String'
'This is "really" a JavaScript String'
"This is 'really' a JavaScript String"

Numbers:

Numbers in JavaScript are double-precision 64-bit format IEEE 754 values. They are immutable, just as strings.
Following are the valid examples of a JavaScript Numbers:
5350 120.27 0.26

Boolean:

A boolean in JavaScript can be either true or false. If a number is zero, it defaults to false. If an empty string defaults to false:
Following are the valid examples of a JavaScript Boolean:
true      // true
false     // false
0         // false
1         // true
""        // false
"hello"   // true

Objects:

JavaScript supports Object concept very well. You can create an object using the object literal as follows:
var emp = {
name: "Zara",
age: 10
};
You can write and read properties of an object using the dot notation as follows:
// Getting object properties
emp.name  // ==> Zara
emp.age   // ==> 10

// Setting object properties
emp.name = "Daisy"  // <== Daisy
emp.age  =  20      // <== 20

Arrays:

You can define arrays using the array literal as follows:
var x = [];
var y = [1, 2, 3, 4, 5];
An array has a length property that is useful for iteration:
var x = [1, 2, 3, 4, 5];
for (var i = 0; i < x.length; i++) {
   // Do something with x[i]
 }

Functions:

A function in JavaScript can be either named or anonymous. A named function can be defined using function keyword as follows:
function named(){
// do some stuff here
}
An anonymous function can be defined in similar way as a normal function but it would not have any name.
A anonymous function can be assigned to a variable or passed to a method as shown below.
var handler = function (){
// do some stuff here
}
JQuery makes a use of anonymous functions very frequently as follows:
$(document).ready(function(){
// do some stuff here
});

Arguments:

JavaScript variable arguments is a kind of array which has length property. Following example explains it very well:
function func(x){
console.log(typeof x, arguments.length);
}
func();                //==> "undefined", 0
func(1);               //==> "number", 1
func("1", "2", "3");   //==> "string", 3
The arguments object also has a callee property, which refers to the function you're inside of. For example:
function func() {
return arguments.callee; 
}
func();                // ==> func

Context:

JavaScript famous keyword this always refers to the current context. Within a function this context can change, depending on how the function is called:
$(document).ready(function() {
// this refers to window.document
});

$("div").click(function() {
  // this refers to a div DOM element
});
You can specify the context for a function call using the function-built-in methods call() and apply() methods.
The difference between them is how they pass arguments. Call passes all arguments through as arguments to the function, while apply accepts an array as the arguments.
function scope() {
console.log(this, arguments.length);
}

scope() // window, 0
scope.call("foobar", [1,2]);  //==> "foobar", 1
scope.apply("foobar", [1,2]); //==> "foobar", 2

Scope:

The scope of a variable is the region of your program in which it is defined. JavaScript variable will have only two scopes.
  • Global Variables: A global variable has global scope which means it is defined everywhere in your JavaScript code.
  • Local Variables: A local variable will be visible only within a function where it is defined. Function parameters are always local to that function.
Within the body of a function, a local variable takes precedence over a global variable with the same name:
var myVar = "global";     // ==> Declare a global variable

function ( ) {
   var myVar = "local";   // ==> Declare a local variable
   document.write(myVar); // ==> local
}

Callback:

A callback is a plain JavaScript function passed to some method as an argument or option. Some callbacks are just events, called to give the user a chance to react when a certain state is triggered.
jQuery's event system uses such callbacks everywhere for example:
$("body").click(function(event) {
console.log("clicked: " + event.target);
 });
Most callbacks provide arguments and a context. In the event-handler example, the callback is called with one argument, an Event.
Some callbacks are required to return something, others make that return value optional. To prevent a form submission, a submit event handler can return false as follows:
$("#myform").submit(function() {
return false;
 });

Closures:

Closures are created whenever a variable that is defined outside the current scope is accessed from within some inner scope.
Following example shows how the variable counter is visible within the create, increment, and print functions, but not outside of them:
  function create() {
  var counter = 0;
  return {
    increment: function() {
      counter++;
    },
    print: function() {
      console.log(counter);
    }
  }
}
var c = create();
c.increment();
c.print();     // ==> 1
This pattern allows you to create objects with methods that operate on data that isn't visible to the outside world. It should be noted that data hiding is the very basis of object-oriented programming.

Proxy Pattern:

A proxy is an object that can be used to control access to another object. It implements the same interface as this other object and passes on any method invocations to it. This other object is often called the real subject.
A proxy can be instantiated in place of this real subject and allow it to be accessed remotely. We can saves jQuery's setArray method in a closure and overwrites it as follows:
  (function() {
  // log all calls to setArray
  var proxied = jQuery.fn.setArray;

  jQuery.fn.setArray = function() {
    console.log(this, arguments);
    return proxied.apply(this, arguments);
  };
})();
The above wraps its code in a function to hide the proxied variable. The proxy then logs all calls to the method and delegates the call to the original method. Using apply(this, arguments) guarantees that the caller won't be able to notice the difference between the original and the proxied method.

Built-in Functions:

JavaScript comes along with a useful set of built-in functions. These methods can be used to manipulate Strings, Numbers and Dates.
Following are important JavaScript functions:
Method Description
charAt() Returns the character at the specified index.
concat() Combines the text of two strings and returns a new string.
forEach() Calls a function for each element in the array.
indexOf() Returns the index within the calling String object of the first occurrence of the specified value, or -1 if not found.
length() Returns the length of the string.
pop() Removes the last element from an array and returns that element.
push() Adds one or more elements to the end of an array and returns the new length of the array.
reverse() Reverses the order of the elements of an array -- the first becomes the last, and the last becomes the first.
sort() Sorts the elements of an array.
substr() Returns the characters in a string beginning at the specified location through the specified number of characters.
toLowerCase() Returns the calling string value converted to lower case.
toString() Returns the string representation of the number's value.
toUpperCase() Returns the calling string value converted to uppercase.
  

The Document Object Model:

The Document Object Model is a tree structure of various elements of HTML as follows:
<html>
<head>
   <title>the title</title>
</head>
<body>
   <div>
      <p>This is a paragraph.</p>
      <p>This is second paragraph.</p>
      <p>This is third paragraph.</p>
   </div>
</body>
</html>
Following are the important points about the above tree structure:

  • The <html> is the ancestor of all the other elements; in other words, all the other elements are descendants of <html>.
  • The <head> and <body> elements are not only descendants, but children of <html>, as well.
  • Likewise, in addition to being the ancestor of <head> and <body>, <html> is also their parent.
  • The <p> elements are children (and descendants) of <div>, descendants of <body> and <html>, and siblings of each other <p> elements.

jQuery overview - jQuery basic tutorial series 1

jQuery Introduction :

jQuery is a fast and concise JavaScript Library created by John Resig in 2006 with a nice motto: Write less, do more.
jQuery simplifies HTML document traversing, event handling, animating, and Ajax interactions for rapid web development.
jQuery is a JavaScript toolkit designed to simplify various tasks by writing less code. Here is the list of important core features supported by jQuery:

  • DOM manipulation: The jQuery made it easy to select DOM elements, traverse them and modifying their content by using cross-browser open source selector engine called Sizzle.
  • Event handling: The jQuery offers an elegant way to capture a wide variety of events, such as a user clicking on a link, without the need to clutter the HTML code itself with event handlers.
  • AJAX Support: The jQuery helps you a lot to develop a responsive and feature-rich site using AJAX technology.
  • Animations: The jQuery comes with plenty of built-in animation effects which you can use in your websites.
  • Lightweight: The jQuery is very lightweight library - about 19KB in size ( Minified and gzipped ).
  • Cross Browser Support: The jQuery has cross-browser support, and works well in IE 6.0+, FF 2.0+, Safari 3.0+, Chrome and Opera 9.0+
  • Latest Technology: The jQuery supports CSS3 selectors and basic XPath syntax.
  • How to use jQuery library?

    Now you can include jquery library in your HTML file as follows:
    <html>
    <head>
    <title>The jQuery Example</title>
       <script type="text/javascript" 
       src="/jquery/jquery-1.3.2.min.js"></script>
       <script type="text/javascript">
          // you can add our javascript code here 
       </script>   
    </head>
    <body>
    ........
    </body>
    </html>
    
    

    How to call a jQuery library functions?

    As almost everything we do when using jQuery reads or manipulates the document object model (DOM), we need to make sure that we start adding events etc. as soon as the DOM is ready.
    If you want an event to work on your page, you should call it inside the $(document).ready() function. Everything inside it will load as soon as the DOM is loaded and before the page contents are loaded.
    To do this, we register a ready event for the document as follows:
    $(document).ready(function() { // do stuff when DOM is ready });
  • To call upon any jQuery library function, use HTML script tags as shown below:
    <html>
    <head>
    <title>The jQuery Example</title>
       <script type="text/javascript" 
       src="/jquery/jquery-1.3.2.min.js"></script>
       
       <script type="text/javascript" language="javascript">
       // <![CDATA[
       $(document).ready(function() {
          $("div").click(function() {
            alert("Hello world!");
          });
       });
       // ]]>
       </script>
    
    </head>
    <body>
    <div id="newdiv">
    Click on this to see a dialogue box.
    </div>
    </body>
    </html>
    
    

    How to use Custom Scripts?

    It is better to write our custom code in the custom JavaScript file : custom.js, as follows:
  •     
    /* Filename: custom.js */
    $(document).ready(function() {
      $("div").click(function() {
     alert("Hello world!");
      });
    });
    Now we can include custom.js file in our HTML file as follows:
    
    <html>
    <head>
    <title>The jQuery Example</title>
       <script type="text/javascript" 
       src="/jquery/jquery-1.3.2.min.js"></script>
       <script type="text/javascript" 
       src="/jquery/custom.js"></script>
    </head>
    <body>
    <div id="newdiv">
    Click on this to see a dialogue box.
    </div>
    </body>
    </html>

Check if a class extends another at Runtime : Java

Summary :

  • If you want to know whether or not a Class extends another, use Class#isAssignableFrom(Class)
  • Class#isAssignableFrom(Class) also returns true if both classes are same
  • To find if an object is instance of a class use instanceof operator
  • To know if a class is direct sub class of another class then use Class#getSuperClass().equals(Class)

Setup :

We have an interface MyInterface and three classes MyBaseClass, MySubClass and SomeOtherClass with the below hierarchy.

interface MyInterface {
}

class MyBaseClass implements MyInterface {
}

class MySubClass extends MyBaseClass {
}

class SomeOtherClass {
}   

Tests:

   

public class Test {
  
  public static void main( String[] args ) {
    
    /*
     * Checking if a class is same as or is a superclass or superinterface
     * 
     * of another class (the class in parameter)
     */
    System.out.println( MyBaseClass.class.isAssignableFrom( MyBaseClass.class ) );// true : same class
    System.out.println( MyBaseClass.class.equals( MyBaseClass.class ) );// true : same class
    System.out.println( MyBaseClass.class.isAssignableFrom( MySubClass.class ) );// true : superclass
    System.out.println( MyInterface.class.isAssignableFrom( MySubClass.class ) );// true : superinterface
    System.out.println( MyBaseClass.class.isAssignableFrom( SomeOtherClass.class ) );// false : the two classes has no relation
    System.out.println( MySubClass.class.isAssignableFrom( MyBaseClass.class ) );// false : MySubClass is not the superclass
    
    /*
     * Checking if a object is instance of a class
     */
    
    IMyInterface object = new MyBaseClass( );
    System.out.println( object instanceof MyInterface ); // true
    System.out.println( object instanceof MyBaseClass ); // true
    System.out.println( object instanceof MySubClass ); // false
    System.out.println( object instanceof SomeOtherClass );// false
    
    /*
     * check if a class is direct superclass of another
     */
    
    System.out.println( MySubClass.class.getSuperclass( ).equals( MyInterface.class ) );// false : its not a directsuper class, interface
    System.out.println( MyBaseClass.class.getSuperclass( ).equals( MyInterface.class ) );// false : its not a directsuper class, interface
    System.out.println( MySubClass.class.getSuperclass( ).equals( MyBaseClass.class ) );// true : MyBaseClass is extending MySubClass
  }
}
   

Full code :

   

public class Test {
  
  public static void main( String[] args ) {
    
    /*
     * Checking if a class is same as or is a superclass or superinterface
     * 
     * of another class (the class in parameter)
     */
    System.out.println( MyBaseClass.class.isAssignableFrom( MyBaseClass.class ) );// true : same class
    System.out.println( MyBaseClass.class.equals( MyBaseClass.class ) );// true : same class
    System.out.println( MyBaseClass.class.isAssignableFrom( MySubClass.class ) );// true : superclass
    System.out.println( MyInterface.class.isAssignableFrom( MySubClass.class ) );// true : superinterface
    System.out.println( MyBaseClass.class.isAssignableFrom( SomeOtherClass.class ) );// false : the two classes has no relation
    System.out.println( MySubClass.class.isAssignableFrom( MyBaseClass.class ) );// false : MySubClass is not the superclass
    
    /*
     * Checking if a object is instance of a class
     */
    
    IMyInterface object = new MyBaseClass( );
    System.out.println( object instanceof MyInterface ); // true
    System.out.println( object instanceof MyBaseClass ); // true
    System.out.println( object instanceof MySubClass ); // false
    System.out.println( object instanceof SomeOtherClass );// false
    
    /*
     * check if a class is direct superclass of another
     */
    
    System.out.println( MySubClass.class.getSuperclass( ).equals( MyInterface.class ) );// false : its not a directsuper class, interface
    System.out.println( MyBaseClass.class.getSuperclass( ).equals( MyInterface.class ) );// false : its not a directsuper class, interface
    System.out.println( MySubClass.class.getSuperclass( ).equals( MyBaseClass.class ) );// true : MyBaseClass is extending MySubClass
  }
}

interface MyInterface {
}

class MyBaseClass implements MyInterface {
}

class MySubClass extends MyBaseClass {
}

class SomeOtherClass {
}

      
   

superclass "javax.servlet.http.HttpServlet" not found on Java Build Path - solution

You might (normally) get the error following error on a dynamic java web project created through maven on Eclipse IDE. The solution is simple :
Error :
The superclass "javax.servlet.http.HttpServlet" was not found on the Java Build Path   
Error Location :
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
Solution 1)
Edit pom.xml to include servlet-api-x.x.jar in your dependencies:
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.1.1</version>
  <scope>provided</scope>
</dependency>   
Solution 2)
Go to Project->Properties->Target Runtimes . And add your server container eg. : Apache Tomcat


Java Obsfucate Password - Replace with asterisk

Obsfucate password : 

Rreplace everything except first and last character by asterisk ( * ), if  the password is less than ALLOWED_LENGTH characters long obfuscate it entirely i.e., prints asterisks

Code :
   
//Test 
System.out.println( getObfuscatedPassword( "" ) ); //returns null
System.out.println( getObfuscatedPassword( "pwdd" ) ); //returns ****
System.out.println( getObfuscatedPassword( "mySecurePassword" ) ); // returns m**************d


//Method 
public static String getObfuscatedPassword( String password ) {
   
   int ALLOWED_LENGTH = 5;
   
   if ( null == password || "".equals( password.trim( ) ) ) {
    return null;
   }
   
   StringBuilder builder = new StringBuilder( );
   
   if ( password.length( ) < ALLOWED_LENGTH ) {
   
    for ( int i = password.length( ); i != 0; i-- ) {
     builder.append( "*" );
    }
   
    return builder.toString( );
   }
   
   builder.append( password.charAt( 0 ) );
   
   for ( int i = password.length( ) - 2; i != 0; i-- ) {
    builder.append( "*" );
   }
   
   return builder.append( password.substring( password.length( ) - 1 ) ).toString( );
}

   

change maven local repository path - symbolic links

Let's suppose we want to change the local maven repo path (default : c:\users\user_name\.m2\repository) to some other real folder - lets say e:\repo  - so that the contents from e:\repo folder are mapped to the default folder location.

This might be useful when .m2 folder on your C: drive is taking too much space. In such case, you can move the content to another drive ( e:\repo) and have a symbolic link on C:\ drive instead - so that all the configuration remains intact.


The following command creates a link folder "repository" in /.m2 folder and points to the source e:\REPO

C:\>mklink /d c:\users\gtiwari\.m2\repository e:\REPO


Note:


using symbolic links on windows

Using symbolic links (MKLINK comand) on windows:

Suppose we want to create a link of folder 'e:\source' to c:\target\bridge then, use the following command:

C:\>mklink /d c:\target\bridge e:\source

Syntax : mklink /d TARGET SOURCE_DIR

  • This command creates a link folder "bridge" in c:\target\ where you can see the contents from e:\source.
For more info :
Visit: http://ss64.com/nt/mklink.html - 

Linux find command

The find command is one of the most important and much used command in Linux systems. find command is used to search and locate list of files and directories based on conditions you specify for files that match the arguments. In this article we will get familier with linux find command.

First things first, to get more knowledge on any linux command we can use linux manual page using man <command_name>. For more information about find you can use man find and you'll get in depth description on how we can use linux command.

Basic use of find looks somewhat like below

find .

Let's get familier which the syntax of find. In above example we have two parts

  1. find : find is the command itself
  2. . : . (dot) represents the path from where we want to search. We can pass any path here and find will start to look from the path what was provided.

If you run the command, you will get list of all the files and directories that is inside the path that was given as argument.

But I assume you don't want to search for all files. You may want to search for file from / directories that has specific name. To seach for specific file / directories we can use -name option. Here's an example of find which search for the file / directories with the name .gitignore

find . -name '.gitignore'

# OUTPUT

./.gitignore

You can see that we are using . here. If you wanted to start search from root you are free to pass / as you seach directory.

Did you notice that I kept on saying search for file or directories. By default find will try to match the option of -name on both directories and files. If you want to limit your search for file or directories you can use -type option.

find . -type d -name 'img'

# OUTPUT

./_site/img
./img

If you pass d argument on -type option your search will limit to directories only.

find . -type f -name '.gitignore'

# OUTPUT

./.gitignore

If you pass f argument on -type option your search will limit to files.

Linux system are case sensitive. What if you want to seach file ignoring the case. -iname can be use to do just that.

find . -iname '.gitignore'

You can also search file with certain extention. Let's search file with .css extention

find . -type f -name '*.css'

# OUTPUT
./css/bootstrap-theme.css
./css/pygment_highlights.css
./css/main-minimal.css
./css/bootstrap.css
./css/bootstrap.min.css
./css/normalize.css
./css/bootstrap-theme.min.css
./css/main.css

We can use * to indicate any character. We can also search files with multiple extention. Suppose you want to search file with .css and .html. You can do that with

find . -name '*.css' -or -name '*.html'

# OUTPUT

./_layouts/post.html
./_layouts/default.html
./_layouts/page.html
./_layouts/base.html
./index.html
./css/bootstrap-theme.css
./css/pygment_highlights.css
./css/main-minimal.css
./css/bootstrap.css
./css/bootstrap.min.css
./css/normalize.css
./css/bootstrap-theme.min.css
./css/main.css

Notice how we are joining the option -name in above syntax using -or. -or can be used with its alias -o You may have guessed that we can use -and too. Here's an example of find using -and.

# find . -name 'm*' -name '*.css'
find . -name 'm*' -and -name '*.css'

# OUTPUT
./_site/css/main-minimal.css
./_site/css/main.css
./css/main-minimal.css
./css/main.css

Now that you know about -or and -and, you may have imagined endless possibilities of search patterns. Just a quick note, if you use two -name without -and on above example it would act as -and. Quick hint !! you have -not option too. -not can be used with its alias !. -or , -and and -not can be used with other option too.

You can also control how deep you want to search usign -maxdepth

find . -maxdepth 1 -name '*.html'

# OUTPUT
./index.html

You can use find to search the files / directories based on modified, changed or accessed days and minutes.

For days you have -mtime, -atime, -ctime and for minutes you have -mmin, -amin, -cmin. Option prefixed with m denotes modified, a denotes accessed and c denotes changed.

find . -mtime 20
find . -atime 20
find . -ctime 20
find . -mmin 20
find . -amin 20
find . -cmin 20

We can also use + and - symbol number provied. For example

find . -mtime +5

Above command find the file which was not modified in last 5 days.

find . -mtime -5

Above command find the file which was modified within last 5 days.

You can also go for range of days and minutes. Here's an example

find . -mtime +5 -mtime -10

Above command finds the files / directories that are modifined between 5 to 10 days

find . -mmin +5 -mtime -10

Above command finds the files / directories that are modifined between 5 to 10 minutes.

To search the file that has specific size you can use -size option

find . -type f -size 2M

Above command search file that has exactly 50M. We can also use + and - symbol on the number here. For example

find . -type f -size -2M

This command will find the files that has size of 2MB and less

For range you can do

find . -type f -size +2M -size -10M

To find empty file or directory you can use -empty option

find . -empty

find also has option -user, -group and -perm which lets you search the file that is associated with specific user, group or if the file has certain permission.

You can also perform certain operation on the files / directories that are searched and found using -exec option.

For this example here is the list of files and dir that I have

-rw-rw-r--  1 aman aman    0 Oct  7 10:30 four.html
-rw-rw-r--  1 aman aman    0 Oct  7 10:30 one.txt
drwxrwxr-x  2 aman aman 4096 Oct  7 10:31 somedir
-rw-rw-r--  1 aman aman    0 Oct  7 10:30 three.txt
-rw-rw-r--  1 aman aman    0 Oct  7 10:30 two.php

To rename the two.php to two.html you can issue following command

find . -type f -name 'two.php' -exec mv -f {} two.html \;

# ls -l

-rw-rw-r--  1 aman aman    0 Oct  7 10:30 four.html
-rw-rw-r--  1 aman aman    0 Oct  7 10:30 one.txt
drwxrwxr-x  2 aman aman 4096 Oct  7 10:31 somedir
-rw-rw-r--  1 aman aman    0 Oct  7 10:30 three.txt
-rw-rw-r--  1 aman aman    0 Oct  7 10:30 two.html

Let's explain what -exec is performing. After -exec we are writing the command that we want to execute. In our example we wanted to change two.php to two.html. Notice we are using {} placeholder in source section. To end the -exec command we are using \;.

I know on destination we used static text. What if we want to use change all html files to php now. Here's the command

find . -type f -name '*.html' -exec bash -c 'mv "$1" "${1%.html}".php' - {} \;

Now that's a complex command. Let's me explain what's happening.

First we are passing bash -c '<command_to_execute_inside_bash>' - <param_to_send> on -exec. The command will execute for each entry that is found by find command. If find finds 5 files with *.html it will run the command 5 times.

Lets look at the command that we passed for execution i.e mv "$1" "${1%.html}".php.

$1 is the first argument that was passed to command. For example if we have 2 file with html extention. It will send 1st file found to command as its 1st argument and command execution will take place. Then, it goes for 2nd find found and will again pass the file name as its 1st argument.So if we have two file one.html and two.html our find command will find the one.html first and it will execute our command which argument one.html. So on first execution $1 value will be one.html and on second execution $1 will be two.html

Next we have "${1%.html}".php. In a simple term if $1 represents one.html then "${1%.html}" will represent one. So "${1%.html}".php will represent one.php. Visit Bash Referrence Manural for more detail.

If we have two file one.html and two.html. When our command execute the first time ti will look like bash -c 'mv one.html one.php' and second time bash -c 'mv two.html two.php'.

Here's the output

-rw-rw-r-- 1 aman aman    0 Oct  7 10:30 four.php
-rw-rw-r-- 1 aman aman    0 Oct  7 10:30 one.txt
drwxrwxr-x 2 aman aman 4.0K Oct  7 10:31 somedir
-rw-rw-r-- 1 aman aman    0 Oct  7 10:30 three.txt
-rw-rw-r-- 1 aman aman    0 Oct  7 10:30 two.php
find is very handy command and I hope this article helped you get an insight on how you can use find to search files and directories you need.

Java - OS independent line separator

 You might already knew, the new line character depends on your OS.
  • \n for Unix
  • \r\n for Windows and 
  • \r for old Macs
  • and so on

Always use
System.getProperty("line.separator")
OR
Java 7's way: System.lineSeparator()

This will let you find out OS specific line separator instead of judging yourself and hard coding it. It also helps you in avoiding bugs.

Bonus information:
The new line characters originated from the old type writer era.
  • Carriage return - CR = \r
  • Line feed - LF = \n
Read wikipedia article for more information about new line characters.

Spring Interview Questions Answers - Mostly Asked 2

Spring Interview Questions - 2

Question: What are the pros or benefits of Spring framework ?

The pros of Spring framework are as follows:
  • Spring is an open source framework and free to download.
  • Spring has layered architecture. You can select the feature you wants, you can have Struts MVC and Springs IOC container in one application itself. Eventhough spring has MVC framework if you want you can opt out.
  • Spring Enables Plain Old Java Object (POJO) Programming. POJO programming enables continuous integration and testability.
  • Dependency Injection is really cool stuff, spring 3.0 onwards the introduction of component-scan/autowiring and Spring Expression Language makes it even spicier.
  • spring is lightweight.

Question: What is Dependency Injection/Inversion Of Control(IOC) in Spring framework ?

The basic concept of the Dependency Injection or Inversion of Control is that, programmer do not need to create the objects, instead just describe how it should be created. No need to directly connect your components and services together in program, instead just describe which services are needed by which components in a configuration file/xml file. The Spring IOC container is then responsible for binding it all up.
In other words, while applying Inversion Of Control, at the time of object creation, objects are given their dependencies by some external entity that coordinates each object in the system. That means, dependencies are injected into objects at the time of their creation. So, Inversion of Control means an inversion of responsibility with regard to how an object obtains references to collaborating objects.

Question: What are the different types of Inversion of Control or dependency injection ?

There are three different types of Inversion of Control or dependency injection:
  • Setter Injection: Dependencies are injected through JavaBeans properties (ex: setter/Getter methods in bean objects).
  • Constructor Injection: Dependencies are assigned as constructor parameters.
  • Interface Injection: Injection is done through an interface.

Constructor and Setter Injection are the two dependency injection method which Spring supports.

Question: What are the advantages or Pros of IOC (Dependency Injection) ?

Advantages of Dependency Injection/Inversion of Control are as follows:
  • Dependency Injection minimizes the amount of code in any application. Dependency is handled by the framework itself.
  • Dependency Injection makes developers life easier. With Inversion of Control containers developers do not need to think about how services are created and how to get references to the ones he needs.
  • Easily scalable applications. It’s very easy to add additional services by adding a new constructor or a getter/setter method with a minimal configuration. With Spring Framework 3.0, its even easier as <context:component-scan base-package=”com.blah.blah”/> will do everything for you, you don’t need to add getter and setter method and beans for each dependency injection, just autowire the services wherever it needed.<Read how spring 3.0 made a developers life easier>
  • Dependency Injection makes your application more test-friendly by not demanding any JNDI lookup mechanisms or singletons in your test cases. IOC containers make testing and switching implementations easy by allowing you to inject your own objects into the object under test.
  • Comparing to other options like factory design pattern the IOC container is injecting the dependency into requesting piece of code where as the factory design pattern is more intrusive and components or services need to be requested explicitly.
  • IOC containers support eager instantiation and lazy loading of services.
  • IOC Containers provide support for instantiation of cyclical dependencies, managed objects, life cycles management and dependency resolution between managed objects etc.

Question: What are the difference between BeanFactory and ApplicationContext in spring?


ApplicationContext.

BeanFactory
Here we can have more than one config files possible
In this only one config file or .xml file
Application contexts can publish events to beans that are registered as listeners
Doesn’t support.
Support internationalization (I18N) messages
It’s not
Support application life-cycle events, and validation.
Doesn’t support.
Support  many enterprise services such JNDI access, EJB integration, remoting
Doesn’t support.


Question: What is difference between singleton and prototype bean?

Ans: Basically a bean has scopes which defines their existence on the application

Singleton: means single bean definition to a single object instance per Spring IOC container.
Prototype: means a single bean definition to any number of object instances.
Whatever beans we defined in spring framework are singleton beans. There is an attribute in bean tag named ‘singleton’ if specified true then bean becomes singleton and if set to false then the bean becomes a prototype bean. By default it is set to true. So, all the beans in spring framework are by default singleton beans.
<bean id="createNewStock" class="springexample.stockMarket.CreateNewStockAccont" singleton=”false”
     <property name="newBid"/>
</bean>

Question: What is bean wiring?

Ans: Combining together beans within the Spring container is known as bean wiring or wiring. When wiring beans, you should tell the container what beans are needed and how the container should use dependency injection to tie them together.


Question: What are the important beans lifecycle methods?

Ans: There are two important bean lifecycle methods. The first one is setup which is called when the bean is loaded in to the container. The second method is the teardown method which is called when the bean is unloaded from the container.

Question: Explain Bean-LifeCycle.

Ans: Spring framework is based on IOC so we call it as IOC container also. So Spring beans reside inside the IOCcontainer. Spring beans are nothing but Plain old java object (POJO).

Following steps explain their life cycle inside container.
  • Container will look the bean definition inside configuration file (e.g. bean.xml).
  • Using the dependency injection, spring populates all of the properties as specified in the bean definition.
  • If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean’s ID.
  • If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.
  • If there are any BeanPostProcessors associated with the bean, their post- ProcessBeforeInitialization()methods will be called before the properties for the Bean are set.
  • If an init() method is specified for the bean, it will be called.
  • If the Bean class implements the DisposableBean interface, then the method destroy() will be called when the Application no longer needs the bean reference.
  • If the Bean definition in the Configuration file contains a 'destroy-method' attribute, then the corresponding method definition in the Bean class will be called.

Question: How can you override beans default lifecycle methods?

Ans:The bean tag has two more important attributes with which you can define your own custom initialization and destroy methods. Here I have shown a small demonstration. Two new methods fooSetup and fooTeardown are to be added to your Foo class.
<beans>
  <bean id="bar" class="com.act.Foo"
     init-method="fooSetup" destroy="fooTeardown"/>
</beans>

Question: What are Inner Beans?

When wiring beans, if a bean element is embedded to a property tag directly, then that bean is said to the Inner Bean. The drawback of this bean is that it cannot be reused anywhere else.

Question: What is Auto wiring?

You can wire the beans as you wish. But spring framework also does this work for you. It can auto wire the related beans together. All you have to do is just set the autowire attribute of bean tag to an autowire type.



<beans>
     <bean id="bar" class="com.act.Foo" Autowire="autowire type"/>
</beans>

Question: How do add a bean in spring application?








<?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
<beans>
   <bean id="foo" class="com.act.Foo"/>
        <bean id="bar" class="com.act.Bar"/
</beans>
In the bean tag the id attribute specifies the bean name and the class attribute specifies the fully qualified class name.

Question: What are different types of Autowire types?

There are four different types by which autowiring can be done.
  • byName
  • byType
  • constructor
  • autodetect

Question: What is an Aspect?

An aspect is the cross-cutting functionality that you are implementing. It is the aspect of your application you are modularizing. An example of an aspect is logging. Logging is something that is required throughout an application. However, because applications tend to be broken down into layers based on functionality, reusing a logging module through inheritance does not make sense. However, you can create a logging aspect and apply it throughout your application using AOP.

Question: What is a Jointpoint?

A joinpoint is a point in the execution of the application where an aspect can be plugged in. This point could be a method being called, an exception being thrown, or even a field being modified. These are the points where your aspect’s code can be inserted into the normal flow of your application to add new behavior.

Question: What is an Advice?

Advice is the implementation of an aspect. It is something like telling your application of a new behavior. Generally, and advice is inserted into an application at joinpoints.

Question:  What is a Pointcut?

A pointcut is something that defines at what joinpoints an advice should be applied. Advices can be applied at any joinpoint that is supported by the AOP framework. These Pointcuts allow you to specify where the advice can be applied.

Question: What is an Introduction in AOP?

An introduction allows the user to add new methods or attributes to an existing class. This can then be introduced to an existing class without having to change the structure of the class, but give them the new behavior and state.


Question: What is a Target?

A target is the class that is being advised. The class can be a third party class or your own class to which you want to add your own custom behavior. By using the concepts of AOP, the target class is free to center on its major concern, unaware to any advice that is being applied.


Question: What is a Proxy?

A proxy is an object that is created after applying advice to a target object. When you think of client objects the target object and the proxy object are the same.

Question: What is meant by Weaving?

The process of applying aspects to a target object to create a new proxy object is called as Weaving. The aspects are woven into the target object at the specified joinpoints.


Question: What are the different points where weaving can be applied?

  • Compile Time
  • Classload Time
  • Runtime

Question: What are the different advice types in spring?

  • Around : Intercepts the calls to the target method
  • Before : This is called before the target method is invoked
  • After : This is called after the target method is returned
  • Throws : This is called when the target method throws and exception
  • Around : org.aopalliance.intercept.MethodInterceptor
  • Before : org.springframework.aop.BeforeAdvice
  • After : org.springframework.aop.AfterReturningAdvice
  • Throws : org.springframework.aop.ThrowsAdvice

 

Question: Explain about PreparedStatementCreator?

Ans: PreparedStatementCreator is one of the most common used interfaces for writing data to database. The interface has one method createPreparedStatement().
1
2
PreparedStatement <strong>createPreparedStatement</strong>
(Connection conn) throws SQLException;
When this interface is implemented, we should create and return a PreparedStatement from the Connection argument, and the exception handling is automatically taken care off. When this interface is implemented, another interface SqlProvider is also implemented which has a method called getSql()which is used to provide sql strings to JdbcTemplate.