JDBC - Introduction

What is JDBC?

JDBC stands for Java Database Connectivity, which is a standard Java API for database-independent connectivity between the Java programming language and a wide range of databases.

The JDBC library includes APIs for each of the tasks mentioned below that are commonly associated with database usage.

◉ Making a connection to a database.

◉ Creating SQL or MySQL statements.

◉ Executing SQL or MySQL queries in the database.

◉ Viewing & Modifying the resulting records.

Fundamentally, JDBC is a specification that provides a complete set of interfaces that allows for portable access to an underlying database. Java can be used to write different types of executables, such as −

◉ Java Applications

◉ Java Applets

◉ Java Servlets

◉ Java ServerPages (JSPs)

◉ Enterprise JavaBeans (EJBs).

All of these different executables are able to use a JDBC driver to access a database, and take advantage of the stored data.

JDBC provides the same capabilities as ODBC, allowing Java programs to contain database-independent code.

JDBC Architecture

The JDBC API supports both two-tier and three-tier processing models for database access but in general, JDBC Architecture consists of two layers −

◉ JDBC API: This provides the application-to-JDBC Manager connection.

◉ JDBC Driver API: This supports the JDBC Manager-to-Driver Connection.

The JDBC API uses a driver manager and database-specific drivers to provide transparent connectivity to heterogeneous databases.

The JDBC driver manager ensures that the correct driver is used to access each data source. The driver manager is capable of supporting multiple concurrent drivers connected to multiple heterogeneous databases.

Following is the architectural diagram, which shows the location of the driver manager with respect to the JDBC drivers and the Java application −

Common JDBC Components

The JDBC API provides the following interfaces and classes −

◉ DriverManager: This class manages a list of database drivers. Matches connection requests from the java application with the proper database driver using communication sub protocol. The first driver that recognizes a certain subprotocol under JDBC will be used to establish a database Connection.

◉ Driver: This interface handles the communications with the database server. You will interact directly with Driver objects very rarely. Instead, you use DriverManager objects, which manages objects of this type. It also abstracts the details associated with working with Driver objects.

◉ Connection: This interface with all methods for contacting a database. The connection object represents communication context, i.e., all communication with database is through connection object only.

◉ Statement: You use objects created from this interface to submit the SQL statements to the database. Some derived interfaces accept parameters in addition to executing stored procedures.

◉ ResultSet: These objects hold data retrieved from a database after you execute an SQL query using Statement objects. It acts as an iterator to allow you to move through its data.

◉ SQLException: This class handles any errors that occur in a database application.

The JDBC 4.0 Packages

The java.sql and javax.sql are the primary packages for JDBC 4.0. This is the latest JDBC version at the time of writing this tutorial. It offers the main classes for interacting with your data sources.

The new features in these packages include changes in the following areas −

◉ Automatic database driver loading.

◉ Exception handling improvements.

◉ Enhanced BLOB/CLOB functionality.

◉ Connection and statement interface enhancements.

◉ National character set support.

◉ SQL ROWID access.

◉ SQL 2003 XML data type support.

◉ Annotations.

Continue reading

Java: Introduction to Collections

A collection — sometimes called a container — is simply an object that groups multiple elements into a single unit. Collections are used to store, retrieve, manipulate, and communicate aggregate data. Typically, they represent data items that form a natural group, such as a poker hand (a collection of cards), a mail folder (a collection of letters), or a telephone directory (a mapping of names to phone numbers). If you have used the Java programming language — or just about any other programming language — you are already familiar with collections.

What Is a Collections Framework?

A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following:

◉ Interfaces: These are abstract data types that represent collections. Interfaces allow collections to be manipulated independently of the details of their representation. In object-oriented languages, interfaces generally form a hierarchy.

◉ Implementations: These are the concrete implementations of the collection interfaces. In essence, they are reusable data structures.

◉ Algorithms: These are the methods that perform useful computations, such as searching and sorting, on objects that implement collection interfaces. The algorithms are said to be polymorphic: that is, the same method can be used on many different implementations of the appropriate collection interface. In essence, algorithms are reusable functionality.

Apart from the Java Collections Framework, the best-known examples of collections frameworks are the C++ Standard Template Library (STL) and Smalltalk's collection hierarchy. Historically, collections frameworks have been quite complex, which gave them a reputation for having a steep learning curve. We believe that the Java Collections Framework breaks with this tradition, as you will learn for yourself in this chapter.

Benefits of the Java Collections Framework

The Java Collections Framework provides the following benefits:

◉ Reduces programming effort: By providing useful data structures and algorithms, the Collections Framework frees you to concentrate on the important parts of your program rather than on the low-level "plumbing" required to make it work. By facilitating interoperability among unrelated APIs, the Java Collections Framework frees you from writing adapter objects or conversion code to connect APIs.

◉ Increases program speed and quality: This Collections Framework provides high-performance, high-quality implementations of useful data structures and algorithms. The various implementations of each interface are interchangeable, so programs can be easily tuned by switching collection implementations. Because you're freed from the drudgery of writing your own data structures, you'll have more time to devote to improving programs' quality and performance.

◉ Allows interoperability among unrelated APIs: The collection interfaces are the vernacular by which APIs pass collections back and forth. If my network administration API furnishes a collection of node names and if your GUI toolkit expects a collection of column headings, our APIs will interoperate seamlessly, even though they were written independently.

◉ Reduces effort to learn and to use new APIs: Many APIs naturally take collections on input and furnish them as output. In the past, each such API had a small sub-API devoted to manipulating its collections. There was little consistency among these ad hoc collections sub-APIs, so you had to learn each one from scratch, and it was easy to make mistakes when using them. With the advent of standard collection interfaces, the problem went away.

◉ Reduces effort to design new APIs: This is the flip side of the previous advantage. Designers and implementers don't have to reinvent the wheel each time they create an API that relies on collections; instead, they can use standard collection interfaces.

◉ Fosters software reuse: New data structures that conform to the standard collection interfaces are by nature reusable. The same goes for new algorithms that operate on objects that implement these interfaces.

Continue reading

How to use Callable Statement in Java to call Stored Procedure? JDBC Example

The CallableStatement of JDBC API is used to call a stored procedure from Java Program. Calling a stored procedure follows the same pattern as creating PreparedStatment and than executing it. You first need to create a database connection by supplying all the relevant details e.g. database URL, which comprise JDBC protocol and hostname, username, and password. Make sure your JDBC URL is acceptable by JDBC driver you are using to connect to the database. Every database vendor uses different JDBC URL and they have different driver JAR which must be in your classpath before you can run the stored procedure from Java Program.

Once you are done with initial setup, you can obtain CallableStatement from Connection by calling prepareCall(String SQL) method, where SQL must be in the format required by your database vendor e.g. Microsoft SQL Server requires curly braces e.g.
{call Books.BookDetails_Get(?)}.

This stored proc requires an INPUT parameter which must be set by calling setXXX() method on the CallableStatement object before you can execute the query.

Once this is done, just call the executeQuery() method of CallableStatement and it will return the ResultSet contains all the rows returned by this stored proc.

Just loop through ResultSet and extract all the rows. You have successfully run the stored procedure from Java Program using CallableStatement.

Steps to call a stored procedure from Java

1) Create a database connection.

Connection con = null;
try {
   Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
   String url = "jdbc:sqlserver://localhost:42588;";
   con = DriverManager.getConnection(url, "username", "pw");
} catch (Exception e) {
   e.printStackTrace();
}

2) Create a SQL String

You need to create SQL using a String variable to call the stored procedure, for example, CallableStatement e.g. {call Books.BookDetails_Get(?)}. This is database dependent, for Oracle the format is different it starts with BEGIN and ends with ENDS instead of curly braces e.g.

String SQL = "{call Books.BookDetails_Get(?)}" // for Microsoft SQL Server
String Oracle = "BEGIN BOOKDETAILS_GET(?); END;";

3) Create CallableStatement Object

You can create a CallableStatement by calling Connection.prepareCall(SQL) method, pass the SQL created in the previous step.

CallableStatement cs = con.prepareCall(SQL);

4)  Provide Input Parameters

You can set the input parameter by calling various setXXX() method depending upon the data type of query parameters on the CallableStatement object, similar to PreparedStatment e.g.

cs.setString(1, "982928");

5)  Call Stored Procedure

You can execute a stored procedure on the database by calling executeQuery() method of CallableStatement class, as shown below:

ResultSet rs = cs.executeQuery();

This will return a ResultSet object which contains rows returned by your stored procedure.

6) Extract Rows from ResultSet

You can get the data from the ResultSet by Iterating over ResultSet and print the results or create Java objects, as shown below:

while(rs.next()){
  System.out.println(rs.getString(1));
}

This will print the first column of every row. You should also close the ResultSet object once you are done with it.

Java Program to call Stored Procedure in SQL Server using CallableStatement

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;

/**
 *
 * A Simple example to use CallableStatement in Java Program.
 */
public class Hello {

  public static void main(String args[]) {
   
    Connection con = null;
    try {
       Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
       String url = "jdbc:sqlserver://localhost:42588;";
       con = DriverManager.getConnection(url, "username", "pw");
    } catch (Exception e) {
       e.printStackTrace();
    }

    String SQL = "{call Books.dbo.usp_BookDetails_Get(?)}";

    CallableStatement cs = con.prepareCall(SQL);

    cs.setString(1, "978-0132778046");

    cs.setString(2, "978-0132778047");

    ResultSet rs = cs.executeQuery();
   
    while(rs.next()){
      System.out.println(rs.getString(1));
    }
   
    rs.close();
  }
}

That's all about how to run CallableStatement in Java JDBC. If you are thinking to build your Data Access layer around stored procedures, which is a great design, then you should have a good understanding of CallableStatement.

They are the ones which are used to run the stored procedure from Java programs. By encapsulating your data access logic and SQL on a stored procedure, allow you to change them easily on SQL editor without making any change on Java side, which means you can implement new functionalities without building and deploying a new JAR file on Java side.

Continue reading

How to convert JSON String to Java object - Jackson Example

JSON stands for JavaScript object notation, is a lightweight text or string representation of an object and quickly becoming a popular data exchange format. Though it's pretty early to say that JSON is going to replace XML as popular data interchange format, It is certainly providing an alternative. JSON represent data in two format either an object or an array. JSON object is an unordered collection of key and value, similar to String representation of hash table. On the other hand, JSON Array is an ordered collection of values. The main difference between  JSON Object and  JSON array is there representation. JSON object is started with left brace { and ends with right brace } and key values are separated using a colon (:). On the other hand, JSON Array starts with left bracket [ and ends with right bracket ] and each value is separated by comma. By looking at structure, You can write  your JSON parser to parse JSON object or array to Java object, but you don't need to.

There are lot of open source library in Java which provides tried and tested way of converting JSON String to Java object e.g. Jackson and GSON. In this Java tutorial we will see example of converting a JSON String to Java object using Jackson library

How to convert JSON String to Java object using Jackson

It's very easy to create Java object from JSON String using Jackson library. It's literally require two lines of code to do this, as shown in following Java example. If you look at code, most of code is for creating Java class e.g. User in this case, while code required to convert JSON String to Java object is just two lines in fromJson(String json) method.

This method takes an Jon String which represent a User object in JSON format and convert it into Java User object. In this Java example I have create User as nested static class for convenience, You may create a separate top level class if needed.

import java.io.IOException;

import org.apache.log4j.Logger;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;

/*
 * Java program to convert JSON String into Java object using Jackson library.
 * Jackson is very easy to use and require just two lines of code to create a Java object
 * from JSON String format.
 *
 * @author http://javarevisited.blogspot.com
 */
public class JsonToJavaConverter {

        private static Logger logger = Logger.getLogger(JsonToJavaConverter.class);
   
   
        public static void main(String args[]) throws JsonParseException
                                                    , JsonMappingException, IOException{

                JsonToJavaConverter converter = new JsonToJavaConverter();
           
                String json = "{\n" +
                "    \"name\": \"Garima\",\n" +
                "    \"surname\": \"Joshi\",\n" +
                "    \"phone\": 9832734651}";
           
                //converting JSON String to Java object
                converter.fromJson(json);
        }
   
   
        public Object fromJson(String json) throws JsonParseException
                                                   , JsonMappingException, IOException{
                User garima = new ObjectMapper().readValue(json, User.class);
                logger.info("Java Object created from JSON String ");
                logger.info("JSON String : " + json);
                logger.info("Java Object : " + garima);
           
                return garima;
        }
   
   
        public static class User{
                private String name;
                private String surname;
                private long phone;
           
                public String getName() {return name;}
                public void setName(String name) {this.name = name;}

                public String getSurname() {return surname;}
                public void setSurname(String surname) {this.surname = surname;}

                public long getPhone() {return phone;}
                public void setPhone(long phone) {this.phone = phone;}

                @Override
                public String toString() {
                        return "User [name=" + name + ", surname=" + surname + ", phone="
                                        + phone + "]";
                }
           
             
        }
}

Output:
2013-01-07 01:15:05,287 0    [main] INFO  JsonToJavaConverter  - Java Object created from JSON String
2013-01-07 01:15:05,287 0    [main] INFO  JsonToJavaConverter  - JSON String : {
    "name": "Garima",
    "surname": "Joshi",
    "phone": 9832734651}
2013-01-07 01:15:05,287 0    [main] INFO  JsonToJavaConverter  - Java Object : User [name=Garima, surname=Joshi, phone=9832734651]

Dependency

As I said, You can either use Jackson or Gson to convert JSON String to Java object and in this Java tutorial we have used Jackson library for JSON to Java object conversion. If you are using Maven for dependency management than you can add following dependency in POM.xml :

<dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-xc</artifactId>
      <version>1.9.11</version>
</dependency>

Or you can simply add following JAR files into your application’s classpath :

jackson-xc-1.9.11.jar
jackson-core-asl-1.9.11.jar
jackson-mapper-asl-1.9.11.jar

That's all on How to convert JSON String to Java object using Jackson library. Though, this is a trivial example and actual object could be more complex, it demonstrate the process of creating Java object from JSON String. You can also use other JSON library like GSON instead of Jackson to convert JSON String to Java object.

Continue reading

Java - Convert String to Boolean Example

There are two ways to convert a String to boolean in Java, first, by using Boolean.parseBoolean() method and second, by using Boolean.valueOf() method.The parseBoolean() method returns an equivalent boolean value of given String, for example, if you pass "true" it will return the primitive boolean value true. Similarly, if you pass "false" it will return false. The good thing about this method is that it is case insensitive, which means if you pass "true", "TRUE", or "True" you will still get a true boolean value.

 Another good thing about this method is that it doesn't throw an exception if you pass any String value other than true and false. For example, if you pass "YES" it will return false, which is not obvious but that's still better than throwing an exception like NumberFormatException.

The Boolean.valueOf() method work similar, it returns a true boolean value for a non-null String equal to true, ignoring case and returns false for everything else. It also returns a Boolean object instead of a primitive boolean value.

Also, both valueOf() and parseBoolean() methods are null safe, which means they will return false if you pass null i.e. parseBoolean(null) and valueOf(null) will return false instead of throwing NullPointerExcpeiton.

1. Boolean.parseBoolean() Examples

// parseBoolean returns a boolean primitive value
String value = "true";
boolean b = Boolean.parseBoolean(value);
System.out.println(b);

Output
true

2. Boolean.valueOf() Examples

// valueOf returns a Boolean object
String data = "false";
boolean f = Boolean.valueOf(data);
System.out.println(f);
Output
false

Btw, there is another way to convert String to Boolean in Java, by using the constructor of Boolean class e.g. new Boolean(String input) but I won't advise you to use that because everytime you will use this method it will return a new Boolean Object.

Instead, you should always use valueOf() method because Boolean instances are immutable and just two instances are enough to cover all scenarios.

Difference between parseBoolean and valueOf() in Java

Even though both methods can be used to parse a String to a boolean value, there is a slight difference between them. The parseBoolean() method returns a primitive boolean value while the valueOf() returns a Boolean object.

Though in the age of auto-boxing, a Boolean can easily be stored in a boolean variable, this is an important difference which you should remember.

Another benefit of using the valueOf() method is that it caches the boolean value and returns the already created Boolean.TRUE and Boolean.FALSE value instead of creating a new instance every time.

RUE and Boolean.FALSE value instead of creating a new instance every time.

If you don't need a new instance of the Boolean object then you should always use Boolean.valueOf() method to create Boolean objects to get better performance.

This method is also overloaded to create a Boolean object from both Strings as well as primitive boolean value e.g. both valueOf(true) and valueOf("true") will return same Boolean.TRUE object.

In short:

Java Program to Convert String to Boolean

Here is our complete Java program to convert String to Boolean in Java. It's quite similar to the earlier program for converting String to Integer, Long, Double, Float, Short, and Byte in Java. All of them follow same technique to convert String to other data types. 

/**

 * 

 * A simple example to convert String to Boolean in Java

 */

public class Hello {

  public static void main(String args[]) {

    // parseBoolean returns a boolean primitive value

    String value = "true";

    boolean b = Boolean.parseBoolean(value);

    System.out.println(b);

    // valueOf returns a Boolean object

    String data = "false";

    boolean f = Boolean.valueOf(data);

    System.out.println(f);

    value = "NO";

    b = Boolean.parseBoolean(value);

    System.out.println(b);

    // null String will return false

    System.out.println(Boolean.parseBoolean(null));

    System.out.println(Boolean.valueOf(null));

    // any value other than true (Case-insensitive) will

    // return false

    System.out.println(Boolean.parseBoolean("YES"));

    System.out.println(Boolean.valueOf("Y"));

  }

}

Output

true

false

false

false

false

false

false

Important Points

Some important points about parseBoolean and valueOf methods which are worth remembering:

1. Both parseBoolean() and valueOf() are static methods defined in java.lang.Boolean class.

2. The parseBoolean() returns a primitive boolean value while valueOf() returns a Boolean object.

3. Both parseBoolean() and valueOf() are null-safe which means if you pass null String to them they will return false boolean value instead of throwing NullPointerException.

4. Both methods are also case-insensitive, which means "true", "TRUE", and "True" will return same Boolean.TRUE value.

5. Prefer valueOf() over parseBoolean() if you need Boolean object because it returns cached Boolean objects, defined in the Boolean class itself i.e. Boolean.TRUE for true and Boolean.FALSE for false.

6. The valueOf() provides better performance because of caching.

7. Autoboxing boolean primitive to Boolean object also uses the Boolean.valueOf() method.

That's all about how to convert a String to boolean in Java. You should use the Boolean.parseBoolean() method if you need a primitive boolean value and Boolean.valueOf() if you need a Boolean object. The valueOf() method also provide better performance because it always returns the two pre-created instance i.e. Boolean.TRUE and Boolean.FALSE instead of creating a new object everytime you parse a String to boolean.

Continue reading

How to Subtract two Binary Numbers in Java

Binary subtraction is very similar to binary addition which we have learned in the last article. In this tutorial, you will learn how to subtract two binary numbers. Similar to the last article, we'll see two ways, first by converting binary String to a binary number and then doing subtraction. You can use the Java API Integer.toString(number, radix) for that. On second solution you will learn to develop the logic to perform binary subtraction in Java program by using rules you might have learned in your computer classes. Here is a little summary of how binary subtraction works.

Subtraction works in much the same way:

0 − 0 → 0
0 − 1 → 1, borrow 1
1 − 0 → 1
1 − 1 → 0

Subtracting a "1" digit from a "0" digit produces the digit "1", while 1 will have to be subtracted from the next column. This is known as borrowing. The principle is the same as for carrying. When the result of a subtraction is less than 0, the least possible value of a digit, the procedure is to "borrow" the deficit divided by the radix (that is, 10/10) from the left, subtracting it from the next positional value.

There are also a couple of other ways to perform binary subtraction e.g. binary subtraction using 1's complement and binary subtraction using 2's complement. Let's see how those work by first subtracting two binary number using 1's complement:

How to subtract two binary numbers using 1's complement

In one's complement, you negate the binary number where 1 turned to zero and zero turned to 1. Here are the exact steps to subtract two binary number using 1's complement:

1) Calculate1’s complement of the subtrahend.
2) Add 1's complement with the minuend.
3) If the result of addition has a carryover then it is dropped and a 1 is added in the last bit.
4) If there is no carryover, then 1’s complement of the result of the addition is obtained to get the final result and it is negative.

Example: What is the difference between two binary numbers 110101 – 100101?

Solution: 1’s complement of 10011 is 011010.
Hence

Minuted - 110101
1’s complement of subtrahend - 011010
Carryover - 1 001111
1
010000
The required difference is 10000

Here is another example of subtracting 101011 – 111001. First, let's calculate 1’s complement of 111001, which is 000110.
Hence

Minued - 101011
1’s complement - 000110
difference - 110001

Hence the difference between two binary numbers 101011 and 111001 is 1110

Java Program to subtract two binary numbers

import java.util.Scanner;

/*

 * Java Program to add subtract two binary numbers.

 * You can either write your own method or you 

 * can use Java API for doing binary subtraction.

 * 

 * input: 110101 - 100101

 * output = 1111

 */

public class Main {

  public static void main(String[] args) {

    System.out.println("Welcome to Java program to add two binary numbers");

    Scanner scnr = new Scanner(System.in);

    System.out.println("Please enter first binary number");

    String first = scnr.nextLine();

    System.out.println("Please enter second binary number");

    String second = scnr.nextLine();

    String difference = subtract(first, second);

    System.out.println("difference between two binary number is : "

        + difference);

    scnr.close();

  }

  /**

   * Java method to calculate the difference between two binary numbers this method

   * calculate sum by first converting binary String to binary numbers and then

   * subtracting them using binary arithmetic.

   * 

   * @param first

   * @param second

   * @return sum of two given binary numbers

   */

  public static String subtract(String first, String second) {

    int b1 = Integer.parseInt(first, 2);

    int b2 = Integer.parseInt(second, 2);

    int sum = b1 - b2;

    return Integer.toBinaryString(sum);

  }

}

Output

Welcome to Java program to add two binary numbers

Please enter the first binary number

110101

Please enter the second binary number

100101

difference between two binary number is: 10000

Continue reading