If you have java applets or other java applications and you want to connect them with standard SQL databases like SLQ Server, Oracle, Informix, Sybase and others JDBC is the one who can help you to do that.The combination of Java’s JDBC and standard SQL makes a simple and powerful database solution. Using JDBC things are easy without making the complex tasks too difficult either.

During this article we’ll teach you haw to establish a connection between your java applications and SQL data base and we’ll do that step-by-step to understand better.

Obtaining the JDBC driver

For using JDBC you need to install the JAVA JDK. If you don’t have it already installed you can download it(free) at Sun’s Java web site .Also many IDE’s have already integrated it so you have nothing more to do just to use.Next thing you have to do is to obtain correctly the JDBC driver.In most cases the JDBC driver will be provided by your database vendor.Once you have this driver you have to install it.

Establishing a connection is a two-step process

If you installed the JDBC driver correctly it’s very easy to establish the connection between java application and the SQL database. So for establishing that connection you have to follow the next two steps:

- Load the JDBC driver.

- Establish the connection.

For undestanding better what you have to do we give you an example:

//  Establish a connection to a mSQL database using JDBC.import java.sql.*;class JdbcTest1 {        public static void main (String[] args) {        try {            // Step 1: Load the JDBC driver.

            Class.forName(”com.imaginary.sql.msql.MsqlDriver“);

            // Step 2: Establish the connection to the database.

            String url = “jdbc:msql://www.myserver.com:1114/contact_mgr“;

            Connection conn = DriverManager.getConnection(url,”user1″,”password”);

        } catch (Exception e) {

            System.err.println(”Got an exception! “);

            System.err.println(e.getMessage());

        }

    }

}

The JDBC Driver

The name of the JDBC driver will be supplied to you by your database
vendor. As you can see in the class.forName() statements, these
names will vary.

The URL

The syntax of the DriverManager.getConection() method is: DriverManager.getConnection(String url, String username, String password);

Username and password are used for login to the data base.

Java 2 Enterprise Edition (J2EE) follows the General Web Architecture which was described on a separate page. As discussed in the evolution of Java, Java was initially touted as a strong client-side contender in the mid-1990s. However in the late 1990s, it evolved and gained much more acceptance as a solid middle tier tool. Over time, Sun added components to its middle tier solution (Servlets, EJB) until in mid-1999, Sun released its J2EE specification which provided a comprehensive view of the Java middle tier solution. Java solution providers have embraced J2EE which we will now explore.

J2EE uses a 4-level model for web development. The browser runs on the client displaying HTML and optionally runs JavaScript. The middle tier is comprised of two layers: a Presentation Layer and a Business Logic Layer. The data manages persistent data in a database and, where appropriate, legacy data stores.

J2EE implements the Presentation Layer with Servlets and, more recently, Java provides the option to generate webpages with dynamic content using JavaServer Pages (JSP). Servlets/JSP generate webpages with dynamic content (typically originating from the database). They also parse webpages submitted from the client and pass them to Enterprise JavaBeans for handling. Servlets and JSPs run inside a Web Server.

J2EE implements the Business Logic layer with Enterprise JavaBeans (EJB). Enterprise JavaBeans are responsible for logic like validation and calculations as well as provided data access (e.g. database I/O) for the application. Enterprise JavaBeans run inside an Application Sever.

Under J2EE, EJBs access a database through one of two means:

• using a JDBC interface which requires a lower level of coding and/or
• using SQLJ which provides a higher level interface to the database

In addition to these components for web application, J2EE provides for access by non-web clients to the business logic layer. A standalone Java application (IIOP client) can access an EJB directly using J2EE’s Remote Method Invocation (RMI) API.

Supporting J2EE APIs

J2EE provides a number of “supporting” APIs. The purpose of most of these APIs is to enable interaction between the “main” software layers/components in the J2EE architecture.

• Remote Method Interface (RMI)
• Java Naming and Directory Interface (JNDI)
• Java Message Service (JMS)
• Java Transaction API (JTA)
• Java Database Connectivity (JDBC) / SQLJ
• JavaMail /JMC

Remote Method Interface (RMI)

RMI is an important API used for supporting distributed computing and has been supported in core Java since version 1.1. RMI allows a Java client application to communicate with a Java server application by invoking methods on that remote object. With RMI, the client gets a reference to a server object and then it can invoke methods on that object as if it were a local object within the same virtual machine.

For server objects developed in other languages, you must employ other techniques like using Java IDL with CORBA or RMI/IIOP to access the server object.

Java Naming and Directory Interface (JNDI)

JNDI allows Java programs to use name servers and directory servers to look up objects or data by name. This important feature allows a client object to locate a remote server object or data.

JNDI is a generic API that can work with any name or directory servers. Server providers have been implemented for many common protocols (e.g. NIS, LDAP and NDS) and for CORBA object registries. Of particular interest to users of J2EE, JNDI is used to locate Enterprise JavaBean (EJB) components on the network.

Java Message Service (JMS)

JMS is an API for using networked messaging services. Data sent in a message is often intended as a sort of event notification (e.g. a Email-handling process may need to be notified when a request is enqueued). Another common use for messaging (thus JMS) is for interfacing with “external”, third party or legacy applications, typically via a Message Oriented Middleware product like IBM’s MQ Series (now WebSphere MQ). It can be complex/risky to use RPC/RMI to directly invoke remote applications while a messaging solution can provide a simpler and more reliable interconnection.

Java Transaction API (JTA)

JTA is used for managing distributed transactions (e.g. updates to multiple databases that must be handled in a single transaction). JTA is a low-level API and associated coding is complex and error-prone.

Fortunately, EJB containers (or application servers) generally provide support for distributed transactions using JTA. For this reason, the EJB developer is able to gain the benefit of distributed transaction while leaving the complex implementation details to the provider of the EJB container.

Java Database Connectivity (JDBC) / SQLJ

In principle, JDBC serves the same purpose as ODBC. JDBC provides a database-independent protocol for accessing relational databases from Java. JDBC supports Data Manipulation Language (DML) statements like insert, update, delete, select. It also includes Data Definition Language (DDL) statements like Create Table, Alter Table, etc.

JDBC was included in core Java starting with version 1.1. With JDBC, the SQL is always dynamically generated at runtime and sent to the database.

A easier-to-use industry standard for Java database access has emerged and is called SQLJ. SQLJ allows static SQL to be used and it requires less cumbersome syntax than JDBC. Other SQLJ advantages over JDBC include better code quality (due to compile-time syntax checking) and better performance (due to compile-time optimization). James Woodger co-authored an in-depth article on SQLJ for the November 2000 issue of Java Enterprise Developer.

JavaMail /JMC

JavaMail is an independent mail platform which works with major industry protocols (SMTP, POP3, etc.).

Source http://www.woodger.ca/jv_top.htm

The 1.8 version has new fields and methods renaming scheme that makes the resulting jars even smaller, improved control flow obfuscation and enhanced J2ME support.

Allatori Java Obfuscator web site and demo version download

• A bean class must have a constructor with no arguments. We know that an empty constructor is automatically created.

• A bean class shouldn’t have public instance variables.

• Persistent values should be accessed through methods called get and set. For example name=bean.getName();getName() has no arguments and return in a variable the name. Although we can use JSP scriptlets or expressions to access arbitrary methods of a class, the standard JSP methods are: the getXxx/setXxx or isXxx/setXxx.

The jsp:useBean action lets you load a bean to be used in the JSP page. Here is the syntax for specifying the using of a bean: <jsp:useBean id="name" class="MyClass" /> Here we initiate an object of the package class and bind it to the name variable. We also can attach a scope attribute that makes the bean associated with more than just the current page.

The local variable has the same type as the object created, but if we want that the variable has the type of a superclass or interface we can use the type attribute like here: <jsp:useBean id="name" class="MyClass" type="Runnable" />;

If we have created a bean we can access its properties with jsp:getProperty. For example the course class has a property called name and we have an instance called java - we can have the value of the period property like this:

<jsp:getProperty name="java" property="period" />
<%= java.getPeriod() %>

If we are not familiar with something like this we can use methods called getFoo and setFoo - this means the bean has a property of type T called foo.

Bellow is an example of a simple bean.

public class firstBean {

private String name= "";

public String getName() {

return(name);

}

public void setName(String name) {

this.name= name;

}

}

Next is an example of using JavaBeans with JSP.

<jsp:useBean id="user" class="UserData" scope="session"/>
<HTML>
<BODY>
<blx:getProperty name="user" property="*">
<FORM METHOD=POST ACTION="SaveName.jsp">
   What's your name? <INPUT TYPE=TEXT NAME=username SIZE=20><BR>
   What's your e-mail address? <INPUT TYPE=TEXT NAME=email SIZE=20><BR>
   What's your age? <INPUT TYPE=TEXT NAME=age SIZE=4>
<P><INPUT TYPE=SUBMIT>
</FORM>
</blx:getProperty>
</BODY>
</HTML>

<HTML>
<BODY>
<jsp:useBean id="user" class="UserData" scope="session"/>
<blx:setProperty name="user" property="*" onError="errorHandler"/>
<%
  pageContext.include( "GetName.jsp" );
%>
</BODY>
</HTML>

Java, the well known OOP language developed by Sun Microsystems, is very very powerful when it comes to communications. We don’t speak here about the Internet oriented java part that is the beans, servlets stuffs. We are just using java as a desktop programming language.

As I mentioned before, when it comes to communications, anything i possible in JAVA. Be it sockets or datagrams, client or server program. All are easy to accomplish.

Those being said, you probably need to send a XML message to a server, via POST method, because that’s what this article intends to talk about. We don’t want to do here a fancy GUI for that. The purpose of this is only the communication part. The script proposed here will be a console based one. Let’s consider the snippet:

try {        URL url = new URL(args[0]);String document = args[1];FileReader fr = new FileReader(document);char[] buffer = new char[1024*10];

int b_read = 0;

if ((b_read = fr.read(buffer)) != -1)

{

URLConnection urlc = url.openConnection();

urlc.setRequestProperty("Content-Type","text/xml");

urlc.setDoOutput(true);

urlc.setDoInput(true);

PrintWriter pw = new PrintWriter(urlc.getOutputStream());

pw.write(buffer, 0, b_read);

pw.close();

BufferedReader in = new BufferedReader(new InputStreamReader(urlc.getInputStream()));

String inputLine;

while ((res_line = in.readLine()) != null)

System.out.println(res_line);

in.close();

}

}

catch (Exception e) {

//Threat the exceptions here

}

This piece of snippet read the XML from a file given as the second parameter into the command line and put it into the “buffer” object. Off course if you have the xml in an object in your code you can just put it into the buffer object or use your own object. Also the url of the server that post the xml to is given from the command line ( args[0] ).

First we send the buffer’s content by setting the connection object to accept input, taking the PrintWriter instance of the connection and writing the contents to it :

urlc.setDoInput(true);

urlc.setDoInput(true);PrintWriter pw = new PrintWriter(urlc.getOutputStream());pw.write(buffer, 0, b_read);

Next we read the response and print in to the console via an usual method using a BufferedReader object:

BufferedReader in = new BufferedReader(new InputStreamReader(urlc.getInputStream()));String inputLine;

while ((res_line = in.readLine()) != null)

System.out.println(res_line);