Search This Blog

Friday 14 April 2017

Spring Modules

Spring Modules


The Spring Framework contains a lot of features, which are well-organized in about twenty modules. These modules can be grouped together based on their primary features into 
Ø  Core Container 
Ø  Data Access/Integration 
Ø  Web 
Ø  AOP (Aspect Oriented Programming) 
Ø  Instrumentation 
Ø  Test

Core Container Module
The Core Container consists of the Core, Beans, Context and Expression modules.

The Core and Beans modules provide the most fundamental parts of the framework and provides the IoC and Dependency Injection features.

The Context module build on top of the Core and Beans modules. The Context module inherits its features from the Beans module and adds support for internationalization (I18N), event-propagation, resource-loading, and the transparent creation of contexts. The ApplicationContext interface is the focal point of the Context module that provides these features.

The Expression Language module provides a powerful expression language for querying and manipulating an object graph at runtime. The language supports setting and getting of property values, property assignment, method invocation, accessing the context of arrays, collections and indexers, logical and arithmetic operators, named variables, and retrieval of objects by name from Spring's IoC container.

Data Access/Integration Module
The Data Access/Integration layer consists of the JDBC, ORM, OXM, JMS and Transaction modules.

The JDBC module provides a JDBC-abstraction layer that removes the need to do tedious JDBC coding and parsing of database-vendor specific error codes.

The ORM module provides integration layers for popular object-relational mapping APIs, including JPA, JDO, Hibernate, and iBatis.

The OXM module provides an abstraction layer for using a number of Object/XML mapping implementations for JAXB, Castor, XMLBeans, JiBX and XStream.

The JMS module provides Spring's support for the Java Messaging Service. It contains features for both producing and consuming messages.

The Transaction module provides a way to do programmatic as well as declarative transaction management, not only for classes implementing special interfaces, but for all your POJOs.

Web Module
The Web layer consists of the Web, Web-Servlet and Web-Portlet modules.

Spring's Web module provides basic web-oriented integration features, such as multipart file-upload functionality, the initialization of the IoC container using servlet listeners and a web-oriented application context.

The Web-Servlet module provides Spring's Model-View-Controller (MVC) implementation for web-applications

The Web-Portlet module provides the MVC implementation to be used in a portlet environment and mirrors what is provided in the Web-Servlet module.

AOP and Instrumentation Module
Spring's AOP module provides an aspect-oriented programming implementation allowing you to define, method-interceptors and pointcuts to cleanly decouple code implementing functionality that should logically be separated.

The Instrumentation module provides class instrumentation support and classloader implementations to be used in certain application servers.

Test Module

The Test module contains the Test Framework that supports testing Spring components using JUnit or TestNG. 

Spring Modules

Thursday 13 April 2017

Spring Framework

Spring Framework

The Spring Framework is an open source application framework for the Java platform which aims to make J2EE development easier. Spring framework offers a lot of freedom to Java developers yet provides well-documented and easy to use solutions for common practices in the industry.

Spring is a glue framework that gives an easy way of configuring and resolving dependencies throughout the J2EE stack. The core features of the Spring Framework can be used in developing any Java application, but there are extensions for building web applications on top of the Java EE platform. Spring framework targets to make J2EE development easier to use and promote good programming practice by enabling a POJO-based programming model.

Goals of Spring Framework
          Reduce glue code/plumbing work
        Spring Framework takes lot of load off the programmer by providing dependencies when required and by using AOP.
          Externalize dependencies
        Dependencies are described in a separate file (xml) rather than mixing it with the business logic code itself. This gives a better control over the application.
          Manage dependencies at a single place
        Dependencies can be managed better due to this.
          Improve testability
        Actual code can easily be replaced by a stub for testing purposes.
          Foster good application design
        Since the actual implementation sits behind the interfaces, it fosters good application design.
          Flexibility
        Spring offers integration points with several other frameworks. So, you do not have to write them yourself.
        Programmers are free to choose the modules that suit their application. Spring has a well layered architecture of 7 modules:
          Spring Core
          Spring Context
          Spring AOP
          Spring DAO
          Spring ORM
          Spring WebFlow
          Spring Web MVC

Spring Framework


Features of Spring Framework

          Lightweight
        Objects in a Spring-enabled application often have no dependencies on Spring specific classes. It’s jar file is just over 2.5 MB.
        Provides support to not only J2EE applications but also to stand alone applications
          Inversion of Control (IoC) and Dependency Injection
        The core of the Spring Framework is based on the principle of IoC. Applications that follow the IoC principle use configuration that describes the dependencies between its components.
        Ioc or to be more descriptive, Dependency Injection aims to offer a simpler mechanism for providing components dependencies.
          AOP
        Aspect Oriented Programming can be used to separate cross-cutting concerns from business logic. These concerns, then can be applied to many parts of the application. Logging and security are typical examples of such concerns.
          Pojo based programming
        Spring based applications need not extend/implement any spring specific classes. It leads to a simpler yet extensible programming model.


Thursday 6 April 2017

Continuous Integration

Continuous Integration
Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly. 
The basic idea behind the continuous integration is to ensure that there are no compilation issues at the end of the day by numerous check ins made by the developers in a team. Also, this would enable to identify any compilation issues at the early stages of the development process.
In this process, all the developers’ activities are collaborated and merged at the central system.  The main aim in this process is to eliminate the “integration problems”. Each and every integration is automatically built, deployed and tested thoroughly.
The main aim of CI is to prevent integration problems.
Continuous integration is the practice of frequently integrating one's new or changed code with the existing code repository which should occur frequently enough that no intervening window remains between commit and build, and such that no errors can arise without developers noticing them and correcting them immediately. 
Rather than a periodically scheduled build, in CI the normal practice is to trigger these builds by every commit to a repository.

Best Practices of CI
1.      Maintain a proper code repository.
2.      Automate the build process.
3.      Ensure every developer commits the files to the main stream every day.
4.      Every commits made should be built.
5.      Results of the build should be made transparent, so that all the developers will be aware of the quality of the build every day.
6.      Test the build in a production look-like environment.
7.      Broken builds should be fixed immediately.
8.      Everyone should be able to get the latest build from the main stream.
9.      Automate the deployment process.
 Advantages of CI
1.      Integration bugs are detected early and are easy to track down due to small change sets. 
2.      Avoids last-minute chaos at release dates
3.      Constant availability of a "current" build for testing, demo, or release purposes.
4.      Frequent code check-in pushes developers to create modular, less complex code
5.      Enforces discipline of frequent automated testing.
6.      Immediate feedback on system-wide impact of local changes


Monday 3 April 2017

Constructors in Java

Constructors in Java

A constructor in Java is a block of code similar to a method that’s called when an instance of an object is created. A constructor is a special method that is used to initialize an object. Every class has a constructor, if we don't explicitly declare a constructor for any java class the compiler builds a default constructor for that class. A constructor does not have any return type.
A constructor has same name as the class in which it resides. Constructor in Java cannot be abstract, static, final or synchronized. These modifiers are not allowed for constructor.
public class Student {
int rollNumber;
String name;

public Student() {
            rollNumber=0;
            name="";
            System.out.println("Inside Default Constructor");
}
}

There are two types of Constructor

·         Default Constructor – is the one which does not have any parameters
·         Parameterized constructor – may contain 1 or more parameter list.

If we don't explicitly declare a constructor for any java class the compiler builds a default constructor for that class

public class Student {
int rollNumber;
String name;

// Default Constructor
public Student() {
            rollNumber=0;
            name="";
            System.out.println("Inside Default Constructor");
}
// parameterized constructor
Student(int rno,String sname){
            rollNumber=rno;
            name=sname;
System.out.println("Inside Parametrized Constructor");
}
}

Constructor Overloading

Like methods, constructors can also be overloaded. Overloaded constructors are different on the basis of their type of parameters or number of parameters. Constructor overloading is not much different than method overloading. In case of method overloading you have multiple methods with same name but different signature, whereas in Constructor overloading you have multiple constructor with different signature.

Let’s create a class with the main method to class the Student Class
public class MainClass {
public static void main(String[] args) {
            // Default Constructor will be called
            Student s1=new Student();
           
            // Calling Parametrized Constructor
            Student s2=new Student(1,"Bond");
}
}

Once we execute the above class, we get the following output
Inside Default Constructor
Inside Parametrized Constructor

Some of the key points to remember regarding Constructors
·         A constructor doesn’t have a return type.
·         The name of the constructor must be the same as the name of the class.
·         Unlike methods, constructors are not considered members of a class.
·         A constructor is called automatically when a new instance of an object is created.
·         Constructors can be overloaded just like normal methods.
·         Constructors can be private. This facilitates Singleton Design Pattern.


Friday 31 March 2017

JDBC - The Steps

JDBC : The Steps

In this article we are highlighting the steps to connect and process data in JDBC. For this article we are using Oracle Database. For other databases the drivers will vary but the steps will remain the same.
The steps involved in the process of connecting to a database and executing a query are as follows:
·         Load and register the JDBC driver.
·         Open a connection to the database.
·         Create a statement object to perform a query.
·         Execute the statement object and return a query resultset.
·         Process the resultset.
·         Close the resultset and statement objects.
·         Close the connection.

Load and Register the JDBC Driver
The first step is to establish a communication between the JDBC program and the database. This is done by using the static registerDriver() method of the DriverManager class of the JDBC API.
DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

Alternatively, we can use the forName() method of the java.lang.Class class can be used to load and register the JDBC driver:
Class.forName("oracle.jdbc.driver.OracleDriver");

Connecting to a Database
Once the JDBC driver has been loaded and registered, a database connection needs be established. This is done by using the getConnection() method of the DriverManager class. A call to this method creates an object instance of the java.sql.Connection class. The getConnection() requires three input parameters, namely, a connect string, a username, and a password.
Connection conn = DriverManager.getConnection(URL, username, passwd);

Connection conn = DriverManager.getConnection ("jdbc:oracle:thin:@training:1521:Oracle",
 "oratest", "oratest");


Querying the Database
Querying the database involves two steps:
·         Creating a statement object to perform a query
·         Executing the query and returning a resultset.

Creating a Statement Object
The next step is to instantiate objects that run the query against the database connected. This is done by the createStatement() method of the Connection object created above. A call to this method creates an object instance of the Statement
Statement stmt = conn.createStatement();

Executing the Query and Returning a ResultSet
Once a Statement object has been constructed, the next step is to execute the query. This is done by using the executeQuery() method of the Statement object. A call to this method takes as parameter a SQL SELECT statement and returns a JDBC ResultSet object.
ResultSet rset = stmt.executeQuery
      ("SELECT empno, ename, sal, deptno FROM emp ");

Processing the Results of a Database Query That Returns Multiple Rows
Once the query has been executed, there are two steps to be carried out:
After the query execution we need to perform 2 things
·         Process the output resultset to fetch the rows
·         Retrievethe column values of the current row
The first step is using the next() method of the ResultSet object. A call to next() is executed in a loop to fetch the rows one row at a time, with each call to next() advancing the control to the next available row.
The second step is to fetch the values in the columnsby using the getXXX() methods of the JDBC rset object. Here getXXX() corresponds to the getInt(), getString() etc with XXX being replaced by a Java datatype.
String str;
while (rset.next())
 {
 str = rset.getInt(1)+ " "+ rset.getString(2)+ "
         "+rset.getFloat(3)+ " "rset.getInt(4)+ "\n";
 }

Here 1, 2, 3, and 4 in rset.getInt(), rset.getString(), getFloat(), and getInt() respectively denote the position of the columns in the SELECT statement, that is, the first column empno, second column ename, third column sal, and fourth column deptno of the SELECT statement respectively.
The parameters for the getXXX() methods can be specified by position of the corresponding columns as numbers 1, 2, and so on, or by directly specifying the column names enclosed in double quotes, as getString("ename") and so on, or a combination of both.
Closing the ResultSet and Statement
Once the ResultSet and Statement objects have been used, they must be closed.
rset.close();
stmt.close();

Closing the Connection
The last step is to close the database connection which is done by a call to the close() method.
conn.close();

Here is a complete example of JDBC Select using Type 4 driver and Oracle Database
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBC01 {
public static void main(String[] args) {
                try {
                                                                Class.forName("oracle.jdbc.OracleDriver");
                } catch (ClassNotFoundException e) {
                                e.printStackTrace();
                }
                try {
                               
Connection con =DriverManager.getConnection ("jdbc:oracle:thin:@localhost:1521:orcl","scott","tiger");
                                Statement s=con.createStatement();
                                String query01="select * from emp";
                                ResultSet rs=s.executeQuery(query01);
                                while(rs.next()){
                System.out.println(rs.getInt("empno")+"    "+rs.getString("ename")+"   "+rs.getDouble("sal"));          
                                }

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