Java Database Connectivity

Java Database Connectivity

Java JDBC is a java API to connect and execute query with the database. JDBC API uses jdbc drivers to connect with the database.

Java Database Connectivity (JDBC) is an application programming interface (API) for the programming language Java, which allows to connect and execute query with the database. JDBC is a part of the Java Standard Edition platform. JDBC provides methods to query and update data in a database, and is oriented towards relational databases.

The JDBC classes are contained in the Java package java.sql and javax.sql.

The latest version is JDBC 4.2, and is included in Java SE 8.

JDBC allows multiple implementations to exist and be used by the same application. The API provides a mechanism for dynamically loading the correct Java packages and registering them with the JDBC Driver Manager. The Driver Manager is used as a connection factory for creating JDBC connections.

JDBC connections support creating and executing statements. These are SQL's CREATE, INSERT, UPDATE and DELETE statements, or they may be SELECT statement to query the database.

Also we can execute the stored procedures available in the database through a JDBC connection.

In order to execute queries in databases JDBC uses statements using one of the following interfaces:

·         Statement – the statement is sent to the database server each and every time.

·         PreparedStatement – the statement is cached and then the execution path is pre-determined on the database server allowing it to be executed multiple times in an efficient manner.

·         CallableStatement – used for executing stored procedures on the database.

SELECT Query statements return a JDBC row result set. The row result set is used to iterate over the result set. Individual columns in a row are retrieved either by name or by column number. There may be any number of rows in the result set.

Update statements such as INSERT, UPDATE and DELETE return an update count that indicates how many rows were affected in the database.

Session Bean

Session Bean

A session bean encapsulates business logic that can be invoked programmatically by a client over local, remote, or web service client views. The session bean performs work for its client, by executing business tasks inside the server.

A session bean is not persistent.

Types of Session Beans

Session beans are of three types: 

·         Stateful 

·         Stateless 

·         Singleton.

Stateful Session Beans

A stateful session bean is a type of enterprise bean which preserve the conversational state with client. A stateful session bean as per its name keeps associated client state in its instance variables. EJB Container creates a separate stateful session bean to process client's each request. As soon as request scope is over, statelful session bean is destroyed.

The state of an object is the values of its instance variables. In a stateful session bean, the instance variables represent the state of a unique client/bean session.

A session bean is not shared; it can have only one client. When the client terminates, its session bean terminates and is no longer associated with the client.

The state is retained for the duration of the client/bean session. If the client removes the bean, the session ends and the state disappears.

Stateful session beans are appropriate in any of the following conditions.

·         The bean’s state represents the interaction between the bean and a specific client.

·         The bean needs to hold information about the client across method invocations.

·         The bean mediates between the client and the other components of the application, presenting a simplified view to the client.

·         Behind the scenes, the bean manages the work flow of several enterprise beans.

Stateless Session Beans

A stateless session bean is a type of enterprise bean which is normally used to do independent operations. A stateless session bean does not have any associated client state, but it may preserve its instance state. EJB Container normally creates a pool of few stateless bean's objects and use these objects to process client's request.

A stateless session bean does not maintain a conversational state with the client. When a client invokes the methods of a stateless bean, the bean’s instance variables may contain a state specific to that client but only for the duration of the invocation. When the method is finished, the client-specific state should not be retained.

Because they can support multiple clients, stateless session beans can offer better scalability for applications that require large numbers of clients. Typically, an application requires fewer stateless session beans than stateful session beans to support the same number of clients.

A stateless session bean can implement a web service, but a stateful session bean cannot.

Stateless session bean are appropriate in following circumstances

·         The bean’s state has no data for a specific client.

·         In a single method invocation, the bean performs a generic task for all clients.

·         The bean implements a web service.

Singleton Session Beans

A singleton session bean is instantiated once per application and exists for the lifecycle of the application. Singleton session beans are designed for circumstances in which a single enterprise bean instance is shared across and concurrently accessed by clients.

Singleton session beans offer similar functionality to stateless session beans but differ from them in that there is only one singleton session bean per application.

Singleton session beans maintain their state between client invocations but are not required to maintain their state across server crashes or shutdowns.

Applications that use a singleton session bean may specify that the singleton should be instantiated upon application startup, which allows the singleton to perform initialization tasks for the application. The singleton may perform cleanup tasks on application shutdown as well, because the singleton will operate throughout the lifecycle of the application.

Singleton session beans are appropriate in the following circumstances.

·         State needs to be shared across the application.

·         A single enterprise bean needs to be accessed by multiple threads concurrently.

·         The application needs an enterprise bean to perform tasks upon application startup and shutdown.

·         The bean implements a web service.

Enterprise Beans

Enterprise Beans

Enterprise beans are Java EE components that implement Enterprise JavaBeans (EJB) technology. Enterprise beans run in the EJB container. The EJB container provides system-level services, such as transactions and security, to its enterprise beans

What Is an Enterprise Bean?

An enterprise bean is a server-side component that encapsulates the business logic of an application. The business logic is the code that fulfils the purpose of the application.

For Example :

In an ecommerce site the enterprise beans might implement the business logic in methods called checkOut and orderProduct. By invoking these methods, clients can access the services provided by the application.

Benefits of Enterprise Beans

Enterprise beans simplify the development of large, distributed applications.

• The EJB container provides system-level services to enterprise beans, the bean developer can concentrate on solving business problems. The EJB container, rather than the bean developer, is responsible for system-level services, such as transaction management and security authorization.
• The beans contain the application’s business logic, the client developer can focus on the presentation of the client. The client developer does not have to code the routines that implement business rules or access databases. As a result, the clients are thinner, a benefit that is particularly important for clients that run on small devices.
• Enterprise beans are portable components, the application assembler can build new applications from existing beans. Provided that they use the standard APIs, these applications can run on any compliant Java EE server.

When to Use Enterprise Beans

• The application must be scalable.
• Transactions must ensure data integrity. Enterprise beans support transactions, the mechanisms that manage the concurrent access of shared objects.
• The application will have a variety of clients. 

There are two types of enterprise beans.

• Session Beans : Performs a task for a client; optionally, may implement a web service
• Message-driven Beans : Acts as a listener for a particular messaging type, such as the Java Message Service API

Prototype Design Pattern in Java

Prototype Design Pattern in Java

Intent

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

Motivation

When we talk about object creation there is a better way to have new objects. If the cost of creating a new object is large and creation is resource intensive, we clone the object. Prototyping allows an object to create customized objects without knowing their class or any details of how to create them. This pattern involves implementing a prototype interface which tells to create a clone of the current object. 

The best example to understand Prototype Patter is, the mitotic division of a cell — resulting in two identical cells —that plays an active role in copying itself and thus, demonstrates the Prototype pattern. When a cell splits, two cells of identical genotype result. In other words, the cell clones itself.

Applicability

Use the Prototype pattern when a system should be independent of how its products are created, composed, and represented; and

·         When the classes to instantiate are specified at run-time.

·         To avoid building a class hierarchy of factories that parallels the class hierarchy of products.

·         When instances of a class can have one of only a few different combinations of state.

Consequences

The Prototype pattern has several benefits:

·         Adding and removing products at run-time.

·         Specifying new objects by varying values.

·         Specifying new objects by varying structure.

·         Reduced subclassing.

·         Configuring an application with classes dynamically.

Implementation

import java.util.ArrayList; import java.util.List; public class Employees implements Cloneable{       private List<String> empList;             public Employees(){             empList = new ArrayList<String>();       }             public Employees(List<String> list){             this.empList=list;       }       public void loadData(){ //This part can be used to read data from the Database and add to List             empList.add("Ravi");             empList.add("Ajay");             empList.add("Sumit");             empList.add("Pooja");       }             public List<String> getEmpList() {             return empList;       }       @Override       public Object clone() throws CloneNotSupportedException{                   List<String> temp = new ArrayList<String>();                   for(String s : this.getEmpList()){                         temp.add(s);                   }                   return new Employees(temp);       }       }

import java.util.List; public class TestPrototypePattern {       public static void main(String[] args) throws CloneNotSupportedException {             Employees emps = new Employees();             emps.loadData();                         //Use the clone method to get the Employee object             Employees empsNew = (Employees) emps.clone();             Employees empsNew1 = (Employees) emps.clone();             List<String> list = empsNew.getEmpList();             list.add("Simran");             List<String> list1 = empsNew1.getEmpList();             list1.remove("Sumit");                   System.out.println("Existing Employee List: "+emps.getEmpList()); System.out.println("Employee List after adding an Employee : "+list); System.out.println("Employee List after removing an Employee : "+list1);       } }

Output :

Existing Employee List: [Ravi, Ajay, Sumit, Pooja] Employee List after adding an Employee : [Ravi, Ajay, Sumit, Pooja, Simran] Employee List after removing an Employee : [Ravi, Ajay, Pooja]

What is GIT

What is GIT

Git is the most widely used modern version control system in the world today. Git is a  actively maintained open source project. A lot of software projects rely on Git for version control, including commercial projects as well as open source. Git works well on a wide range of operating systems and IDEs (Integrated Development Environments). Git is an example of a DVCS (Distributed Version Control System).

Git has been designed with performance, security and flexibility in mind.

Performance

Committing new changes, branching, merging and comparing past versions are all optimized for performance.

Security

Git has been designed with the integrity of managed source code as a top priority. The content of the files as well as the true relationships between files and directories, versions, tags and commits, all of these objects in the Git repository are secured with a cryptographically secure hashing algorithm called SHA1.

Flexibility

Git is flexible in several respects, in support for various kinds of nonlinear development workflows, in its efficiency in both small and large projects and in its compatibility with many existing systems and protocols.Git has been designed to support branching and tagging and operations that affect branches and tags are also stored as part of the change history

Version control with Git

The main reasons why version control with Git is preferred over other Version Control

Git is good

Git has the functionality, performance, security and flexibility that most teams and individual developers need.

Git is in fact a standard

Git is the most broadly adopted version control tool. Vast numbers of developers have Git experience.

The predominance of Git also means that many third party software tools and services are already integrated with Git including IDEs, and project tracking software, JIRA, and code hosting service, Bitbucket.

Git is a quality open source project

Git is a very well supported open source project with over a decade. Git enjoys great community support and a vast user base. Documentation is excellent and plentiful, including books, tutorials and dedicated web sites.