Differences between revisions 5 and 6
Revision 5 as of 2008-04-17 14:34:53
Size: 7204
Editor: JoshJuneau
Revision 6 as of 2008-11-15 09:16:01
Size: 7204
Editor: localhost
Comment: converted to 1.6 markup
No differences found!

Jython Basics - Article 1

Simple Java-Based Data Access Model Using Oracle

Submitted By: Josh Juneau

Article Date: 04/15/2008


Almost every application written today requires data access of some kind. The most common forms of data access today are based upon selection, update, delete processes against a database or XML. While data access has been around for many years now and may be quite trivial, it is an essential concept for any programming language. Not only is it important to know the concepts behind data access, but it is also important to adhere to the basics of object orientation while doing so. A well formed application will use objects to pass data around, which makes it more flexible and easy to maintain.

In this short article, I will quickly walk through the basics of setting up and using a simple data access model based upon well known Java models. Please note that this model is incomplete because it only touches upon the beginnings of creating such a model. Most Java applications use interfaces to access data from a controller class, whereas this simple model leaves that concept out completely.

Setting Up the Database

I'll create a simple object for our Oracle database, although this same process can be used with almost every other RDBMS just as efficiently. If you don't have access to an Oracle database server, then I recommend downloading Oracle Database Express edition for free.

Nothing new here at all...I want to create a database table and insert some data. In a real world application the table would definitely include more fields, but you should get the idea.

create table person(
id              number,
first           varchar2(30),
last            varchar2(50),
constraint person_pk primary key (id));

insert into person values(1, 'PETER','PARKER');
insert into person values(2, 'MARY','JANE');
insert into person values(3, 'HARRY','OSBORNE');

Create An Object Container

I want to create a simple Jython object to use for passing these person data rows around. I'll create a POJO "Plain Old Jython Object" for this purpose. The structure of this model is as follows.

org.jythonMonthly.bean - Object Container Package

org.jythonMonthly.data - Data Access Objects

org.jythonMonthly.control - Data Controller Classes

# File: Person.py
# Package:  org.jythonMonthly.data

import java
from org.jythonMonthly.data import PersonDA

# Person object for passing the data around

class Person(java.lang.Object):
    def __init__(self, id, first, last):
        self.id = id
        self.first = first
        self.last = last

    def getId(self):
        return self.id
    def getFirst(self):
        return self.first
    def getLast(self):
        return self.last
    def setId(self):
        self.id = id
    def setFirst(self):
        self.first = first

    def setLast(self):
        self.last = last
    def toString(self):
        return self.first + " " + self.last

Data Access Object

The data access object performs all of the database work in most Java apps. Similarly, we can implement the same type of object with Jython...less coding too! I chose to use a Java prepared statement for the data access in this example.

# File: PersonDA.py
# Package:  org.jythonMonthly.data

import java
from java.util import ArrayList
from oracle.jdbc.driver import OracleDriver
from java.sql import DriverManager
from org.jythonMonthly.bean import Person

class PersonDA(java.lang.Object):
    def __init__(self, un, pw, sid, host, port):
        driver = OracleDriver()
        connection_string = "jdbc:oracle:thin:@%s:%s:%s" % (host, port, sid)
        self.connection = DriverManager.getConnection(connection_string, un, pw)

#   This method is used for searching the person table

    def findPersonByName(self, person):
        stmt = self.connection.prepareStatement(sql)
        stmt.setString(1, person.getFirst())
        stmt.setString(2, person.getLast())
        personList = ArrayList()
        rset = stmt.executeQuery();
        while (rset.next()):
            id = rset.getInt("id")
            first = rset.getString("first")
            last = rset.getString("last")
            person = Person.Person(id,first,last)
        return personList
#   This method is an example for saving values into our database table
    def persist(self, person):
        sql = "INSERT INTO PERSON VALUES (?,?,?)"
        stmt = self.connection.prepareStatement(sql)
        stmt.setString(2, person.getFirst())
        stmt.setString(3, person.getLast())

Using the Data

Once that these two objects have been defined, it is easy to create a facade or controller class to obtain and use the data. This controller class can then be used to invoke methods on the data access object from ant desktop or web based application. Here is a simple controller example. While it does not effectively do much, hopefully you can get the idea of how to write something that will be more useful in a real world application.

# PersonController.py
# Package:  org.jythonMonthly.controller

import java
from java.util import ArrayList
from org.jythonMonthly.bean import Person
from org.jythonMonthly.data import PersonDA

class PersonController(java.lang.Object):
    def __init__(self):
        self.data = PersonDA.PersonDA("USER","PASSWORD","SID","HOST","PORT")
    def findPerson(self, search):
        person = Person.Person(search.id, search.first, search.last)
        #personArray = ArrayList()
        personArray = self.data.findPersonByName(person)
        return personArray
    def save(self, person):

#  Initiate the process using this main method
#  First, we will create a new person object and 
#  populate it with the person whom we'd like to find.
#  Next, we will pass that person object to the controller.findPerson method
#  and return a list of matching objects.    
if __name__ == "__main__":
    person = Person.Person(1, 'none','PARKER')
    controller = PersonController()
    personList = controller.findPerson(person)
    for x in range(0,personList.size()):
        person = personList.get(x)
        print person.toString()


All in all, this is an old and simple recipe for obtaining data in software development. If you don't follow a model such as this, your application can become unscalable and hard to maintain. Hopefully this article will help some Jython newcomers in the data realm. Next month, I will choose another basic concept to explain.

JythonMonthly/Articles/April2008/1 (last edited 2008-11-15 09:16:01 by localhost)