Download the JDK
Search the Tutorials
Hide the TOC
Trail: JDBC(TM) Database Access
Lesson: JDBC Basics
JDBC Basics
Getting Started
Setting Up a Database
Establishing a Connection
Setting Up Tables
Retrieving Values from Result Sets
Updating Tables
Milestone: The Basics of JDBC
Using Prepared Statements
Using Joins
Using Transactions
Stored Procedures
SQL Statements for Creating a Stored Procedure
Creating Complete JDBC Applications
Running the Sample Applications
Creating an Applet from an Application
Home Page > JDBC(TM) Database Access > JDBC Basics
« Previous • Trail • Next »
Establishing a Connection

> First, you need to establish a connection with the DBMS you want to use. Typically, a JDBC™ application connects to a target data source using one of two mechanisms:

> - `DriverManager`: This fully implemented class requires an application to load a specific driver, using a hardcoded URL. As part of its initialization, the `DriverManager` class attempts to load the driver classes referenced in the `jdbc.drivers` system property. This allows you to customize the JDBC Drivers used by your applications.
> - `DataSource`: This interface is preferred over `DriverManager` because it allows details about the underlying data source to be transparent to your application. A `DataSource` object's properties are set so that it represents a particular data source.

> Establishing a connection involves two steps: Loading the driver, and making the connection.

> #### Loading the Driver

> Loading the driver you want to use is very simple. It involves just one line of code in your program. To use the Java DB driver, add the following line of code:

> >     Class.forName("org.apache.derby.jdbc.EmbeddedDriver");

> Your driver documentation provides the class name to use. In the example above, `EmbeddedDriver` is one of the drivers for Java DB.

> Calling the `Class.forName` automatically creates an instance of a driver and registers it with the `DriverManager`, so you don't need to create an instance of the class. If you were to create your own instance, you would be creating an unnecessary duplicate, but it would do no harm.

> After you have loaded a driver, it can make a connection with a DBMS.

> #### Making the Connection

> The second step in establishing a connection is to have the appropriate driver connect to the DBMS.

> #### Using the DriverManager Class

> The `DriverManager` class works with the `Driver` interface to manage the set of drivers available to a JDBC client. When the client requests a connection and provides a URL, the `DriverManager` is responsible for finding a driver that recognizes the URL and for using it to connect to the corresponding data source. Connection URLs have the following form:

> `jdbc:derby:<dbName>[propertyList]`

> The `dbName` portion of the URL identifies a specific database. A database can be in one of many locations: in the current working directory, on the classpath, in a JAR file, in a specific Java DB database home directory, or in an absolute location on your file system.

> If you are using a vendor-specific driver, such as Oracle, the documentation will tell you what subprotocol to use, that is, what to put after `jdbc:` in the JDBC URL. For example, if the driver developer has registered the name `OracleDriver` as the subprotocol, the first and second parts of the JDBC URL will be `jdbc.driver.OracleDriver` . The driver documentation will also give you guidelines for the rest of the JDBC URL. This last part of the JDBC URL supplies information for identifying the data source.

> The `getConnection` method establishes a connection:

> >     Connection conn = DriverManager.getConnection("jdbc:derby:COFFEES");

> In place of "`myLogin` " you insert the name you use to log in to the DBMS; in place of "`myPassword` " you insert your password for the DBMS. So, if you log in to your DBMS with a login name of "`Fernanda` " and a password of "`J8,` " just these two lines of code will establish a connection:

> >     String url = "jdbc:derby:Fred";
> >     Connection con = DriverManager.getConnection(url, "Fernanda", "J8");

> If one of the drivers you loaded recognizes the JDBC URL supplied to the method `DriverManager.getConnection`, that driver establishes a connection to the DBMS specified in the JDBC URL. The `DriverManager` class, true to its name, manages all of the details of establishing the connection for you behind the scenes. Unless you are writing a driver, you probably won't use any of the methods in the interface `Driver`, and the only `DriverManager` method you really need to know is `DriverManager.getConnection`

> The connection returned by the method `DriverManager.getConnection` is an open connection you can use to create JDBC statements that pass your SQL statements to the DBMS. In the previous example, `con` is an open connection, and you use it in the examples that follow.

> #### Using a DataSource Object for a connection

> Using a `DataSource` object increases application portability by making it possible for an application to use a logical name for a data source instead of having to supply information specific to a particular driver. The following example shows how to use a `DataSource` to establish a connection:

> You can configure a `DataSource` using a tool or manually. For example, Here is an example of a `DataSource` lookup:

> >      InitialContext ic = new InitialContext()

> >      DataSource ds = ic.lookup("java:comp/env/jdbc/myDB");
> >      Connection con = ds.getConnection();
> >      DataSource ds = (DataSource) org.apache.derby.jdbc.ClientDataSource()
> >      ds.setPort(1527);
> >      ds.setHost("localhost");
> >      ds.setUser("APP")
> >      ds.setPassword("APP");

> >     Connection con = ds.getConnection();

> `DataSource` implementations must provide getter and setter methods for each property they support. These properties typically are initialized when the `DataSource` object is deployed.

> >     VendorDataSource vds = new VendorDataSource();
> >     vds.setServerName("my_database_server");
> >     String name = vds.getServerName();

> #### JDBC-ODBC Bridge Driver

> For normal use, you should obtain a commercial JDBC driver from a vendor such as your database vendor or your database middleware vendor. The JDBC-ODBC Bridge driver provided with JDBC is recommended only for development and testing, or when no other alternative is available.

« Previous • Trail • Next »
Previous page: Setting Up a Database
Next page: Setting Up Tables