Practical Software

Wanna study in Portugal?

2015-06-15T10:08:00.005+01:00

Everything you need to know to apply for higher education studies in Portugal, may be found in the following links:

http://www.studyinportugal.edu.pt

http://www.studyinportugal.edu.pt/images/guide.pdf

JSP - Enhance the first JSP example with Java Beans

2013-12-09T22:53:00.001+00:00

In the previous article, we saw a first example of using JSP, where Java was embedded into the HTML to perform the dynamic part.
In this article, we are going to enhance the structure of the previous example, by making use of a Java Bean.
This structure enhances readability, and separates the code of the user interface from the code to perform computations.

In the case of more complex applications, the structure of the first example would lead to a solution difficult to understand and maintain. The structure of the solution presented in this article is more flexible, readable and so more easy to maintain and evolve.

So, we shall create a Net Beans project, just like in the first example, and make the same modifications to index.jsp. Then, we create the new JSP file (newjsp.jsp):

Contrary to what we saw in the First JSP Example, this file has not embedded the code to obtain the parameters or the calculation of the operation result. It has, instead, a JavaBean component that is no more than a class who are passed the parameters and performs the required calculations.

Tag <jsp:useBean> is an action element used to instanciate a JavaBean component. In this case, the component to instanciate is class Calculator that is localized in the package Beans.

The scope of the useBean is defined as page, meaning that the instanced bean may be used anywhere in the current page.
Other possible scopes are:
- request: the bean may be used from any JSP that processes the same request.
- session: the bean may be used from any JSP in the same session of the JSP that created the bean.
- application: the bean may be used from any page in the same application of the JSP that created the bean.

Tag <jsp:setProperty> is used to set the bean's parameter values. It is equivalent to invoking the setter of the identified class' property, and assigning it the value of the identified parameter (obtained in the request via URL).

Now, we only have to create our JavaBean:
- Create a package Beans:

- Then create a new class (Calculator) in that package:

The class' code is:

package Beans;

public class Calculator {
  private int lhs = 0;
  private int rhs = 0;
  private int result= 0;
  private String oper = "";

  public int getLhs() {
  return lhs;
}

public void setLhs(int lhs) {
  this.lhs = lhs;
}

  public int getRhs() {
  return rhs;
}

  public void setRhs(int rhs) {
  this.rhs = rhs;
}

  public String getOper() {
  return oper;
}

  public void setOper(String oper) {
  this.oper = oper;
}

  public int getResult() {
  if(oper.equals("add")){
result = lhs + rhs;
}
  else if(oper.equals("sub")){
result = lhs - rhs;
}
  else if(oper.equals("mul")){
result = lhs * rhs;
}
  else if(oper.equals("div")){
result = lhs / rhs;
}
  return result;
}
}

The result is exactly the same as the one obtained in the First JSP Example.

See you next time!!!

Related articles:

First JSP Example

First JSP example

2013-12-09T21:43:00.000+00:00

Java Server Pages (JSP) is a Java technology that allows creating web pages with a mix of static HTML and dynamic HTML. The dynamic part is generated by using Java language scripts that are embbeded in the HTML code through special Tags, recognized by the application server.

In this article we will see a small example that will serve to introduce some of the JSP tags and help in understanding how does Java work in the middle of all the rest.

The example is made with NetBeans IDE 7.2.1, and it consists of a small calculator that will allow to perform the four arithmetic operations on two integer operands.

Let's start by creating a new project in NetBeans, of type Web Application:

As applicational server we will use GlassFish:

(we don't select any framework, in step 4 of creating a new project)

NetBeans creates a project structure with a file index.jsp, which will generate the initial page of the project:

Initial contents of file index.jsp:

Let's now modify the contents of file index.jsp so that it contains a form with our calculator:

When submitting this form, another jsp file will be called and the form data will be passed to it. We named this new file newjsp.jsp.
To create this new file we select File --> New File --> category=Web / File Type = JSP, in the menu bar, or New --> JSP, in the contextual menu that shows up when clicking the mouse's right button on our project's name.

Initial contents of file newjsp.jsp:

Then, we modify the generated contents as follows:

The tag <% ... %> allows to embed java code in the HTML code existing inside a JSP file.

What the code above is doing is receiving (GET) the parameters sent to the server when submitting the form, in index.jsp, through parameters sent via the URL (request.getParameter(...)); convert the values that we need into numeric integer values (int), (Integer.valueOf(...).intValue()); and, then, make the computations, depending on the previously selected operator, which is passed to newjsp.jsp with the key "oper".

Our example, when executing, looks like this:
- File index.jsp generates the following HTML contents:

- When submiting the form, the file newjsp.jsp generates the following:

(Note, in the previous figure, the URL with the parameters passed to newjsp.jsp appearing in the URL field, in the browser).

If, when executing the project in NetBeans, a message appears stating that the URL doesn't exist in the server, then we must access the Glassfish's administration page, and start/launch the project from there.

The port where GlassFish has its administration page may be found in Glassfish's startup log, which appears in NetBeans when making Build or Deploy of the project:

INFO: WEB0169: Created HTTP listener [http-listener-1] on host/port [0.0.0.0:8080]
INFO: WEB0169: Created HTTP listener [http-listener-2] on host/port [0.0.0.0:8181]
INFO: WEB0169: Created HTTP listener [admin-listener] on host/port [0.0.0.0:4848]

See you next time!!!

Related articles:

JSP - Enhance the first JSP example with Java Beans

Mobile Computing - evolution and current status

2012-08-17T15:40:00.001+01:00

When people talk about mobile devices, what immediately comes up to memory is the mobile phone. The mobile phone appeared after a sequence of about 100 years of inventions, which aim was to be able to communicate from a long distance.
The first successfull telephone transmission was accomplished by Alexander Graham Bell in 1876. He and Thomas Edisson competed in the race that lead to the invention of the first telephone.
Immediately in 1877 the first commercial telephone line entered into operation.

The mobile phone only appeared nearly 100 years after the first phone, adding mobility to the initial goal of speaking at a long distance.
The first (analog) mobile phone appeared in 1960. It was too big to be transported personally, so it had to be installed in vehicles.
In 1973 appeared the first handheld mobile phone (analog).

Only in 1977 appeared the first digital cellular networks.

Currently, mobile devices, including most mobile phones have processing power, having added the goal of mobile computing to the previous goals of distance communication and mobility.

Today, in a confluence of different lines and different research goals, we have IP phones (VoIP), cellular packet switching networks (3G, 4G), mobile devices of various sizes, manufacturers, and with different operating systems, incorporating sensors, GPS , electronic compass, accelerometer, etc..

The number of mobile subscriptions rose from just over 1 billion in 2002 to almost 5 billion in 2008. We currently have 6.8 billion people worldwide, and more than 5 billion mobile subscriptions, of which 50% are prepaid.

Only in the second quarter of 2010, the number of smartphones (mobile phones with computing capacity) sold worldwide was 61.7 million.A study by IDC (International Data Corp.) predicts that by 2015 the number of Internet access via mobile networks will exceed the number of accesses through cable or local networks in the U.S.. The scenery in Western Europe and Japan should be similar.

Globaly, online advertising is expected to double between 2010 and 2015. The share of online advertising within all media will increase from 12% to 18% over the same period.

The following figure shows the distribution of mobile devices in the world.

MOBILE DEVICES IN THE WORLD

The most popular operating systems for mobile devices with computing capacity (smartphones, PDAs or tablets) are:

Android
iOS
Windows Phone 7 / Windows 8
Blackberry OS
Symbian / Meego / Tizen

The programming languages most used in these operating systems (OS) are:

Android (Java)
iOS (objective-C)
Windows Phone... /XAML/Silverlight, C#, VB.Net)
Blackberry OS (Java, C/C++, HTML5, ...)
Symbian (C/C++)
and, in any OS, Java ME

When developing software for mobile devices, it is necessary to "think small" in the sense that we do not have the screen space of a desktop system, nor its processing power or information storage. In mobile devices there are less features, less processing speed and less memory than on desktop computers or laptops. Communication is also typically more expensive because it tends to be done through mobile networks.

The mobile web currently reaches 3.4 billion people (about half the world population).

The "mobile" market is more than the sale of apps. Only in 2010, the market for mobile advertising earned 11.5 billion dollars (about 8.7 billion euros).

The features of the mobile devices, such as GPS, associated with the processing capability, allow new types of applications.
For example, location-based services (LBS, Location Based Services).
This type of service (LBS) can be "pulled" by the client - the client is actively seeking and using the service - or can be "pushed" by the vendor - the vendor is offering information...

As with personal computers, servers, or other larger machines, also for mobile devices we consider different levels of software:

applications level
middleware or communications software level
low-level software (operating system kernel, device drivers, etc.)

The following table shows a set of characteristics of mobile applications by application type:

(Brian Fling, Mobile Design and Development. O'Reilly Media, Inc., August 2009.)

(for ex.: native apps for the device have all device support, are typically complex, have excellent usability, can be developed in different programming languages, depending on the operating system, and, if well done, they offer offline support (ie, can be used even when there is no connection to the Internet))

Programming for mobile devices have some drawbacks:

smaller screen
lower memory capacity
lower processing speed
lower "disk" capacity

But it also has some advantages:

allows one to take advantage of a touch screen
take advantage of GPS
take advantage of accelerometer
allows access anywhere
...
light sensor
proximity sensor
dígital compass

Simple examples of programming for mobile devices:
- First Windows Phone App

First Windows Phone App

2012-05-07T19:34:00.001+01:00

In this article we make a first approach to software development for Windows Phone.

To start, we need to install the Windows Phone SDK 7.1, wich comes with a free IDE (Visual Studio Express) and with a Windows Phone Emulator, which allows you to test your apps before deploying them to a Windows Phone-based mobile device.

In this example app, the Visual Studio 2010 has been used, but, of-course, Windows Phone SDK 7.1 must allways be installed.

Windows Phone execution model

Before starting the development of our first app, just some words about the Windows Phone execution model:

Just one App may run in foreground at a given moment in time;
Other Apps in execution are put into a dormant state;
When the device's memory isn't enough, the operating system (OS) starts terminating Apps in the dormant state.
Through their programming framework, Apps can manage their state when they are activated or deactivated. This can be used to give the user the impression that an app has always been running, even when it is stopped and later reactivated.

Create the Windows Phone Project

In Visual Studio (or Visual Studio Express), create a new project with the template for "Silverlight for Windows Phone", and type Windows Phone Application:

Then, select the OS version:

Visual studio creates the architecture of the application, which consists of only one page:

Windows Phone applications are made of Silverlight UI page descriptions (Silverlight is a subset of XAML, a XML-based User Interface description language created by Microsoft), and code behind files in C# (although VB.Net may also be used).

At the center of the image above, you can see two views of the MainPage.XAML, which is the description of the user interface for our application. The two views are, in the left, a graphical view of the page, and in the righ, the XAML description. You can modify the page in any of these two views, and those modifications are automatically reflected in the other view.

By dragging and droping controls from the toolbox to the graphical view of the XAML page, you can start composing the App UI:

We are building an app for converting Farenheith degrees into Celsius degrees, so we drag a few TextBlocks, a TextBox and a Button:

The XAML equivalent is:
<phone:PhoneApplicationPage
    x:Class="MinhaPhoneApp.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d" d:DesignWidth="480" d:DesignHeight="768"
    FontFamily="{StaticResource PhoneFontFamilyNormal}"
    FontSize="{StaticResource PhoneFontSizeNormal}"
    Foreground="{StaticResource PhoneForegroundBrush}"
    SupportedOrientations="PortraitOrLandscape" Orientation="Portrait"
    shell:SystemTray.IsVisible="True">

    
    <Grid x:Name="LayoutRoot" Background="Transparent">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        
        <StackPanel Orientation="Vertical" x:Name="TitlePanel" Margin="12,17,0,28" Grid.ColumnSpan="7">
            <TextBlock x:Name="ApplicationTitle" Text="Minha Phone App" Style="{StaticResource PhoneTextNormalStyle}"/>
            <TextBlock x:Name="PageTitle" Text="ºF --> ºC" TextAlignment="Center" Margin="9,-7,0,0" Style="{StaticResource PhoneTextTitle1Style}"/>
        </StackPanel>

        
        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0">
            <TextBlock Height="50" HorizontalAlignment="Left" Margin="17,37,0,0" Name="textBlock1" Text="Temperatura ºF : " VerticalAlignment="Top" Style="{StaticResource PhoneTextLargeStyle}" />
            <TextBox Height="72" HorizontalAlignment="Left" Margin="236,25,0,0" Name="textBox1" Text="" VerticalAlignment="Top" Width="220" TextChanged="textBox1_TextChanged" />
            <Button Content="Converter temperatura" Height="72" HorizontalAlignment="Left" Margin="57,117,0,0" Name="button1" Click="button1_Click" VerticalAlignment="Top" Width="344" />
            <TextBlock Height="173" HorizontalAlignment="Left" Margin="57,209,0,0" Name="textBlock2" Text="TextBlock" VerticalAlignment="Top" Width="344" Style="{StaticResource PhoneTextTitle1Style}"/>
        </Grid>
    </Grid>

</phone:PhoneApplicationPage>

Note the XAML code for the button:

<Button Content="Converter temperatura" Height="72" HorizontalAlignment="Left"
        Margin="57,117,0,0" Name="button1" Click="button1_Click"
        VerticalAlignment="Top" Width="344" />

The event handler that shall run when the button is clicked is button1_Click.
Now we need to provide the code for the event handler:

Here is all the code behind for MainPage.XAML.cs:

using System.Windows.Shapes;
using Microsoft.Phone.Controls;

namespace MinhaPhoneApp
{
    public partial class MainPage : PhoneApplicationPage
    {
        // Constructor
        public MainPage()
        {
            InitializeComponent();
        }

private void button1_Click(object sender, RoutedEventArgs e)
        {
            int fahrenheit = 0;

            if (Int32.TryParse(textBox1.Text, out fahrenheit))
            {
// C = 5 * ((F-32)/9)

                decimal celsius = 5 * (((decimal)fahrenheit - 32) / 9);

                textBlock2.TextAlignment = TextAlignment.Center;
                textBlock2.Text = Decimal.Round(celsius, 0).ToString() + "º C";
            }
            else
            {
// Show message "Invalid Data"
                textBlock2.Text = "Dados inválidos!!!";
            }
        }

        private void textBox1_TextChanged(object sender, TextChangedEventArgs e)
        {

        }

    }
}

Then, we may run or new App on the Windows Phone device emulator:

Using Hibernate for Java - 2

2012-04-17T16:02:00.001+01:00

In the previous article we saw how to use Hibernate as a middleware layer between the class structure of our Java program and the representation of instances of these classes in a database.

The previous article illustrated the mapping between a Java class and a database table, namelly the class Book and the table with the same name.

Let us now see how to map the class relationships, of type 1-to-N and N-to-N, to the database.

Let's start by adding to our model, which only had one class, two new classes:
- BookCopy (A Book contains the information of a book, and is related to several BookCopy, which correspond to the book copies a library has of that book) --> 1-N relationship.
- Author (A Book has several Author and vice-versa) --> relação N-N relationship.

In the Java project, developed in the previous post, let's start by adding class BookCopy and the respective Hibernate mapping file BookCopy.hbm.xml.

Class BookCopy:

Note that, in BookCopy, we must declare an instance of Book, which corresponds to the attribute, with cardinality 1, imported by the relation between Book and BookCopy.

File BookCopy.hbm.xml:

In class Book, we need to add an instance of Set<BookCopy>, corresponding to the attribute, of cardinality 0..*, imported by Book from the relation between Book and BookCopy:

File Book.hbm.xml after modification:

Note that, in the Book's mapping file, we added:

<set name="bookcopies" table="BOOKCOPY" inverse="true" lazy="true" fetch="select">
    <key column="BOOKID" not-null="true"/>
    <one-to-many class="javahibernateexample.beans.BookCopy" />
</set> 

corresponding to the bookcopies associated to a given Book.

And, in BookCopy's mapping file, we put:

<many-to-one name="book" class="javahibernateexample.beans.Book" fetch="select">
    <column name="BOOKID" not-null="true" />
</many-to-one>

corresponding to the book associated to a given BookCopy.

--------------------------------------------------------------------------------------------

Let us now add the information relative to the authors.
For that, let's create class Author:

And the respetive hibernate's mapping file Author.hbm.xml:

Class Book needs, now, to reference the book's authors, through an attribute of type Set<Author>:

In the end, the file Book.hbm.xml will look like this:

Note the attribute authors, in Book:

<set name="authors" table="BOOKAUTHOR" cascade="all">
    <key column="BOOKID" />
    <many-to-many column="AUTHORID"  class="javahibernateexample.beans.Author" />
</set> 

and the corresponding attribute books in Author:

<set name="books" table="BOOKAUTHOR" cascade="all">
    <key column="AUTHORID" />
    <many-to-many column="BOOKID"  class="javahibernateexample.beans.Book" />
</set>

--------------------------------------------------------------------------------------------

It's still missing the reference to the new resources in file hibernate.cfg.xml, which we shall now add:

We can now use the created infrastructure with some test cases:

Some test results:

Finally, we may also modify, in the hibernate configuration file, property hibernate.show_sql to false, which will hide all the SQL output generated by the hibernate:

Testes output with show_sql set to false:

I hope you were able to follow this example and that you are ready to use hibernate in your future projects.

Using Hibernate for Java - 1

2012-04-15T12:14:00.000+01:00

Hibernate is a framework for object-relational mapping with Java language. It facilitates mapping classes, attributes and class relationships between an application class model and its implementation in a relational database. For defining the mappings, XML files or Java anotations can be used.

Hibernate works as a middleware layer between the Java objects and the relational database.

In this article, and in the next one, we will use Hibernate version 3 to ilustrate, through a small example, the utilization of Hibernate in a Java program.

As database system we will be using Oracle 10g.

To start with, we need to crate the database tables. In the article Example of Java Swing Application with Oracle Database - 1 this process is explained.

In this article, we will only be mapping class BOOK.

Using Netbeans, or other Java IDE, we create a new Java application:

We create a package for the classes corresponding to database tables, and create class Book:

We add the attributes to the class (the attributes' names can be different from the ones used in the table's columns):

And, we add getters and setters for each attribute:

As the value of column ID in table BOOK is automatically assigned by the database, we change the corresponding setter access mode to private:

And, we create a constructor without parameters, for class Book:

Now, we are going to create the mapping file between class Book and the database table BOOK.
In the same folder of class Book, we create a XML file, called Book.hbm.xml, which will contain the mappings:

The file will be constrained by a DTD, but we can add that information later:

We add the following contents to the file:

The syntax used in the file conforms to the DTD in http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd.

Elemento class defines the mapping between the Java class and the corresponding database table.
Elemento id maps an attribute to the table primary key.
Elemento property maps a non-key attribute.

We, now, need to create a configuration file for Hibernate, which will contain the database conection data, the reference to all mapping files, and other configuration information.

This file will be used to configure the object hibernate.connection, for database connection.
It contains, also, information about the mapping files.
All this information could be, in alternative, supplied through code.

Now, we're going to create a class, HibernateUtil, which will supply a singleton instance of class SessionFactory. This instance will be used to create a database session object everytime it is needed.
We create a new package:

Import Hibernate's relevant classes:

And, we declare, as static, the object sessionfactory instance of SessionFactory, and also its initialization.

The invocation of method configure(), in the instance new Configuration(), will trigger the reading of configuration file hibernate.cfg.xml.

Let us now test the database operations using Hibernate. In the file of the class containing the method main(), we add some imports:

And, in method main(), we add code for, in a transaction aware mode, insert a book.

And then, to list all books:

In the next article, we will see how to configure and use tables related by foreign key constraints.

Example of Java Swing desktop application without the JSR - 2

2012-03-03T19:24:00.002+00:00

In this article we are going to create a Java Swing-based GUI project to complement the ones we previously made, and whose developments are addressed in:
   - Example of Java Swing Application with Oracle Database – 1
   - Example of Java Swing Application with Oracle Database – 2
   - Example of Java Swing Application with Oracle Database – 3
     - Example of Java Swing desktop application without the JSR - 1

In NetBeans 7.1, we need to create a Java Application Project:

A Java Application Project automatically creates a class with method main().
We really don't need that class, because we are going to create a JFrame, which automatically creates a main() method that launches it and makes the frame visible.

Anyway, and before creating the JFrame, let's add the needed references to our new project. We need to add, in the project libraries, references to projects HelperDB and librarySystemBLL. References to "ojdbc" jars that come with Oracle XE also need to be added, just like we did before in the other two projects.

Now, let's create the JFrame, that will be the application's main window:

- with the mouse cursor over the package name (librarysystemgui), right click and select New --> JFrame Form...

- Give it a name (librarySystem):

And it is created:

A JFrame, just like a JDialog and a JPanel, is a Swing class, and NetBeans allows to grafically compose Swing elements on it, by dragging them from the pallete and droping them on where we want them to be:

Drag a menu bar from the pallete, onto the JFrame, then two menus (Book and Loans).
And, drag a menuItem into menu Books, and change its text to List Books:

Then, you may delete the initial class with the main method that we don't need.

Now, we want to have several panels laid out on the main frame central area. For that, we drag a panel to the JFrame's central area and name it mainPanel:

Now, we let the main panel empty, and create a new JPanel Form (listBooksJPanel.java).

Drag a JTable onto the new JPanel, and size it to occupy all available space.
Then, we need to configure the JTable, so that its columns have the name we want them to have. So right click on the JTable object and select Costumize Code.
On the Code customizer window, change the "default code" to "custom property", as in the figure below, and make the illustrated changes:

Now the columns are named Title, Author, Editor, Edition and Isbn.

Now, click the Source button (near the Design button), on NetBeans, when editing the ListBooksJPanel.java, so that you can see the code that has been generated.

We need to populate the JTable, when the ListBooksJPanel is created in execution time.
For that, we are going to add some code in the generated class creator method, after the call to InitComponents().

Add the following code:

try {
   List<Book> lsBooks = Book.retrieveAllBooks(new DBAccessObj());
   limparJTableBooks();
   if(!lsBooks.isEmpty()){
     javax.swing.table.DefaultTableModel model1 = (javax.swing.table.DefaultTableModel)jTable1.getModel();

     Iterator<Book> iterBooks = lsBooks.iterator();
     while(iterBooks.hasNext()){
        Book book = iterBooks.next();
        //
        int id = book.getID();
        String title = book.getTitle();
        //
        String authors = "";
        //
        Iterator<Author> bookAuthors = book.getAuthors().iterator();
        while(bookAuthors.hasNext()){
           Author au = bookAuthors.next();
           authors += au.getSurname() + ", " + au.getName() + "; ";
        }
        //
        String editor = book.getEditor();
        String edition = "";
        edition = book.getEdition();
        //
        String isbn = book.getISBN();
        //
        model1.addRow(new Object[]{title, authors, editor, edition, isbn});
     }
   }
} catch (SQLException ex) {
    System.out.println(ex);
}

Remember that you need to reference the previously developed projects in this project's libraries.

Now, getting back to the JFrame, we want to make the listBooksJPanel visible, when the user chooses the ListBooks menu item.

Double click the ListBooks menu item, so that a handler method is created. Add to it the code in the following figure:

Now let's run the example... (of course you need to add data in the database).

As usual, you may add comments to this article with questions about unclear issues...

Virtual Developer Day - Java (free event)

2012-02-24T15:35:00.000+00:00

Example of Java Swing desktop application without the JSR - 1

2012-02-24T12:50:00.002+00:00

From NetBeans 7.1, Swing application framework (JSR) left being supported by NetBeans, and is no longer part of the official JDK (Java Development Kit).

So, in this article, and the next one, we'll make a small application with Swing classes without using the Swing application framework.

We will make use of the application layers previously developed in:

   - Example of Java Swing Application with Oracle Database – 1 (database creation)
   - Example of Java Swing Application with Oracle Database – 2 (HelperDB project for accessing the database)
   - Example of Java Swing Application with Oracle Database – 3 (librarySystemBLL project / BLL classes)

So, after creating the database, and having present projects HelperDB and librarySystemBLL, we will create a new project (librarySystemGUI) for the user interface.
Firstly, we will see how to import a project to NetBeans, having only the java sources developed in any IDE.

Import previous projects to NetBeans 7.1

To import, in NetBeans 7.1, project HelperDB, we create a new project (with existing sources):

Here, we identify the folder where the Java sources are:

Confirm the included packages and source files:

And the new NetBeans project is obtained:

For these particular project, it is still needed to include the JAR files from Oracle to access the database:

For the librarySystemBLL project we proceed the same way. At the end, besides the JARs from ORACLE, it is also needed to include the HelperDB project in the libraries.

We are now in condition to create the graphical user interface (GUI) project, which will be treated in the next article.

Related articles:
   - Example of Java Swing Application with Oracle Database – 1
   - Example of Java Swing Application with Oracle Database – 2
   - Example of Java Swing Application with Oracle Database – 3

Swing-based desktop applications after NetBeans 7.1

2012-02-23T15:04:00.000+00:00

In the articles
   - Example of Java Swing Application with Oracle Database – 1
   - Example of Java Swing Application with Oracle Database – 2
   - Example of Java Swing Application with Oracle Database – 3
   - Example of Java Swing Application with Oracle Database – 4

we developed a small example application, for desktop, using Java/JavaSwing.
For that we used NetBeans IDE, and created a project of type Java Desktop Application for the user interface.

Since NetBeans 7.1, however, Swing application framework is no longer supported by NetBeans, and stopped being part of the official JDK (Java Development Kit). In fact, in NetBeans 7.0.1, the following message already appeared every time one created a Java Desktop Application project:

In NetBeans 7.1 we have, at least, two alternatives:

To create an application from scratch, or

To create a project of type Netbeans Platform Application

In the next article we will address the first option, lefting the second alternative to a future article.

First Eclipse Modeling Framework (EMF) example - 3

2012-02-17T23:11:00.002+00:00

In the previous article we've created a domain model for a Library Management System, and we've generated a set of corresponding Java classes, by using Eclipse Modeling Framework (EMF).

Now, we're going to test those classes through a new Eclipse project, which references the one with the generated classes.

So, we now create a new plug-in project:
File --> Create --> New --> Project... --> Plug-in Project.

And, in folder src, we create a new class with a stub for method main:

And we create, in method main(), a few lines of code:

package javaUsingEMFModel.LibrarySystem;

import org.eclipse.emf.ecore.*;

import LibraryModel.*;

import LibraryModel.impl.*;

import LibraryModel.util.*;

public class MainClass {

    public static void main(String[] args) {

// Inicialize the LibraryModelPackageImpl

        LibraryModelPackageImpl.init();

        LibraryModelFactory factory = LibraryModelFactory.eINSTANCE;

        // Create a new Book

        Book book = factory.createBook();

        // Give a title to the book

        book.setTitle("Os Lusiadas");

        // Create an Author, and define his/her name and surname

        Author author1 = factory.createAuthor();

        author1.setName("Luis");

        author1.setSurname("Camoes");

        // Add that author as an author of the previously created book

        book.getAuthors().add(author1);

        System.out.println(book.getTitle());

    }

}

This is only the beginning. Now you should create instances of the remaining classes, inter-relate them, and query its attribute values and the values of the relation attributes.

Related articles:
- First Eclipse Modeling Framework (EMF) example - 1
- First Eclipse Modeling Framework (EMF) example - 2

First Eclipse Modeling Framework (EMF) example - 2

2012-02-16T23:05:00.003+00:00

In the previous article we started exploring Eclipse EMF. In this article we will build a domain model (persistent data model) of a small library management system.

To start, let us create a new project:

- select File --> New --> Project
- Then, in the opening window, select Eclipse Modeling Framework --> Empty EMF Project

Let's name our project testemf.

Then, in folder model, use the mouse's right button,

and select New --> Other. A new window opens:

Here, select EcoreTools --> Ecore Diagram. The goal is to create a domain model by using the UML class diagram editor.

Creating the Ecore Diagram is a nice way of creating an Ecore model, instance of the Ecore metamodel. We can, then, understand this as the creation of a DSL (Domain Specific Language). Let us name our DSL as LibraryModel.

In the diagrams editor, we create the intended class model:

To do that, we drag and drop metamodel elements from the Pallete, of which we want to create instances. For example, to create class Book (instance of EClass) we drag element EClass from the Pallete, and name it Book. To create attributes we drag element EAttribute, and drop it in the class' attributes area, and so on.

As we want to generate code from our diagram, this must be complete. Thus, we shall specify the data type of each attribute.

To create relations (associations) between classes, we must drag fro the Pallete the element EReference. A relation is, by default, of type one to many and is navigable in that direction, that is only the side "many" is referrable. In the relation's properties we may modify the name and cardinality of the relation attribute.

If we want a relation to be navigable in both directions, we must create two relations and specify one as the opposite relation of the other.

More information about editting diagrams using this editor can be obtained from:

- Eclipse Modeling Framework (EMF) - Tutorial

More information about UML (Unified Modeling Language) can be obtained, for example, in:

- Capítulo 2. Fundamentos do UML

When creating the Ecore diagram (LibraryModel.ecorediag), an Ecore model (LibraryModel.ecore) is automatically created with the same information.

From the ecore model, we are going to create a model for code generation. With the right hand mouse button over the ecore model file (LibraryModel.ecore), we select New --> Other,

Then, select EclipseModelingFramework --> EMF Generator Model:

And we select the Ecore model importer:

Model LibraryModel.genmodel is then generated:

From this model, we are going to generate Java code corresponding to the classes in the initial model:

The project, then, becomes with the following files:

Three Java packages have been generated:

        - LibraryModel - contains the Java interfaces corresponding to the classes in the model, and the Factory class that enables the creation of classes' instances.
        - LibraryModel.impl - contains the classes that implement the interfaces.
        - LibraryModel.util - contains the AdapterFactory.

Let's look at the generated code for class Author in our model:

- Author.java:

package LibraryModel;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;

public interface Author extends EObject {
    String getName();
    void setName(String value);
    String getSurname();
    void setSurname(String value);
    EList<Book> getBooks();
} // Author

- AuthorImpl.java:

package LibraryModel.impl;

import LibraryModel.Author;
import LibraryModel.Book;
import LibraryModel.LibraryModelPackage;
import java.util.Collection;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.EList;
...

public class AuthorImpl extends EObjectImpl implements Author {
    protected static final String NAME_EDEFAULT = null;
    protected String name = NAME_EDEFAULT;
    protected static final String SURNAME_EDEFAULT = null;
    protected String surname = SURNAME_EDEFAULT;
    protected EList<Book> books;

    protected AuthorImpl() {
        super();
    }

    @Override
    protected EClass eStaticClass() {
        return LibraryModelPackage.Literals.AUTHOR;
    }

    public String getName() {
        return name;
    }

    public void setName(String newName) {
        String oldName = name;
        name = newName;
        if (eNotificationRequired())
            eNotify(new ENotificationImpl(this, Notification.SET, LibraryModelPackage.AUTHOR__NAME, oldName, name));
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String newSurname) {
        String oldSurname = surname;
        surname = newSurname;
        if (eNotificationRequired())
            eNotify(new ENotificationImpl(this, Notification.SET, LibraryModelPackage.AUTHOR__SURNAME, oldSurname, surname));
    }

    public EList<Book> getBooks() {
        if (books == null) {
            books = new EObjectWithInverseResolvingEList.ManyInverse<Book>(Book.class, this, LibraryModelPackage.AUTHOR__BOOKS, LibraryModelPackage.BOOK__AUTHORS);
        }
        return books;
    }

. . .

    @Override
    public String toString() {
        if (eIsProxy()) return super.toString();

        StringBuffer result = new StringBuffer(super.toString());
        result.append(" (name: ");
        result.append(name);
        result.append(", surname: ");
        result.append(surname);
        result.append(')');
        return result.toString();
    }

} //AuthorImpl

We may create the documentation about the generated classes, using Javadoc. For that, in the Project menu, select Generate Javadoc...:

And the documentation is generated:

In the next article we will test the generated classes through a simple method Main()...

Related articles:
- First Eclipse Modeling Framework (EMF) example - 1
- First Eclipse Modeling Framework (EMF) example - 3

First Eclipse Modeling Framework (EMF) example - 1

2012-02-14T20:23:00.001+00:00

Eclipse is an IDE (Interactive Development Environment) that allows the development of programs in different programming languages. Some characteristics of Eclipse are the use of the Standard Widget Toolkit (SWT) as graphics library, instead of Swing, the plugin oriented way of programming, and its extensibility, there existing lots of projects that extend Eclipse in diverse directions.
One of those directions is model-driven-development, and the subsequent code generation from models. Eclipse Modeling Framework (EMF) project is a modeling environment and code generation functionality that enables the construction of tools and other software applications based on a structured data model (domain model). From a domain model specified in XMI, or in another supported format, EMF provides tools and runtime support for the production of Java classes that implement the model, and a set of adapter classes that allow editting and viewing the model through Java code, and a basic model editor.

Eclipse can be downloaded from:
- http://www.eclipse.org/downloads/

In this article we will use the version Indigo (3.7.1r1).

Eclipse Modeling Framework, for Eclipse Indigo, can be obtained in:
        - http://www.eclipse.org/downloads/packages/eclipse-modeling-tools/indigor

After downloading EMF, it must be copied to the directories plugins and features of Eclipse instalation.
Alternatively, Eclipse's new packages installation functionality can be used (HELP --> Install New Software) to install EMF.

Page of Eclipse EMF project:
        - http://www.eclipse.org/modeling/emf/

Documentation and tutorials about Eclipse EMF:
- http://www.eclipse.org/modeling/emf/docs/
- The Eclipse Modeling Framework (EMF) Overview
- Eclipse Modeling Framework (EMF) - Tutorial

In the next article we will begin a new EMF project for constructing a domain model from which we will generate Java classes, which will then be used from a small test Main() method.

Related articles:
        - First Eclipse Modeling Framework (EMF) example - 2
        - First Eclipse Modeling Framework (EMF) example - 3

Example of Java Swing Application with Oracle Database – 4

2012-02-07T16:42:00.000+00:00

In this article we're going to develop the presentation layer of our software application. This layer is also know as User Interface or Graphical User Interface Layer.

In blog entry Example of Java Swing Application with Oracle Database - 1, the first one of this series, we've handled the Oracle database creation. In the 2nd article a database access package has been created, HelperDB. The 3rd article addressed the creation of a class library at the level of business logic layer and data access layer.

This article addresses the construction of the user interface project (GUI - Graphical User Interface) using Java Swing classes. To do that, we need to create a new Net Beans project, which we will name LibrarySystem:

This project must be a Java Desktop Application. This kind of project supplies a template with the basic infrastructure of a desktop application, such as a main window with a menu bar and a status bar.

Then, we select Basic Application (the other type, Database Application, will be treated in another series of articles).

This kind of project creates beforehand 3 classes:
- LibrarySystemApp.java - this is the application's main class. The main method will launch the main window. From there, the whole application will be event-driven.

- LibrarySystemView.java - is the main window:

- LibrarySystemAboutBox.java - is an About window:

In the Net Beans' window with the project's View we can see the new project, together with the ones we've created before. To keep the projects' names withing a logical rationale, we've modified this project's name to libraryProjectGUI:

1. User interface (GUI) construction
From the Pallete (where the Swing containers, Swing controls and Swing Windows are, together with other graphical elements), we drag the user interface objects that we intend to see in our application's window.

Here, we will develop all the application within one window.
We start by adding menus (JMenu) and menu items (JMenuItem) in the menu bar that has been initially generated in the main window.

We create a menu item, Initial Panel, in the File menu, that will allow us to get back to the initial panel:

And, we create a new menu, Books, with a menu item, Manage Books, which will lead us to the books' list and book maintenance panels:

Now, we need to create new panels (JPanel) that will substitute the initial panel in the application's main window when the appropriate menu items are selected by the user.
We create a new panel for creating and editting a book:

And, a new panel for listing all existing books:

2. GUI triggered events' handling methods creation

Let us now change the visible panel within the main window, everytime the Manage Books menu option is selected from menu Books.

When a "select menu item" event occurs, we want it to be handled by a new method that will change the panels. We have two ways of doing it:

2.1 With the right hand mouse button over the Manage Books menu item, we select Events --> Action --> actionPerformed:

This causes code to be generated in class LibrarySystemView.java, associating a new method to the menu item selection event, and also creating a template for that new method:

private void jMenuItem1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}

2.2 With the right hand mouse button over the Manage Books menu item, we select Set Action. This leads us to a window for entering details about the code that will be generated:

In Action, we select Create New Action, and in Action's Method, we write listBooks. The methods listBooks() is then created, and is associated to the menu item selection event.

    @Action
    public void listBooks() {
    }

In the listBooks() method, or jMenuItem1ActionPerformed() if we opt by the first approach, we're going to write code for switching panels.

@Action
public void listBooks() {
    ListBooksJPanel listbooksP = new ListBooksJPanel(this, this.dbo);
    this.visiblePanel.setVisible(false);
    this.visiblePanel = listbooksP;
    listbooksP.setVisible(true);
    this.getFrame().setContentPane(listbooksP);
    this.getFrame().repaint();
    //
}

Before, we needed to create the following instance variables in class LibrarySystemView:

private HelperDB.DBAccessObj dbo;
private JPanel visiblePanel = null;

It is also needed to create code for retrieving books from the database and filling the tables in the ListBooksJPanel. There you need to use the class library we've created in the previous article.

If you have any difficulties with the code or if you wish to have the source files with the example, please ask for it in the comments section of this post.

Other related articles:
   - Example of Java Swing Application with Oracle Database - 1
   - Example of Java Swing Application with Oracle Database - 2
   - Example of Java Swing Application with Oracle Database - 3

Example of Java Swing Application with Oracle Database - 3

2012-01-26T16:40:00.004+00:00

Today, we will develop a class library that will consist in a software layer that maps to concepts of the problem domain, and bridges the gap between the user interface, whose development will be addressed in the next article, and data persistence layer, treated in the first article of this series.

This layer, with concepts and operations of the problem domain, is commonly called the middle-tier or business logic layer.

We may consider, then, that our small application system will have a 3-layered (or 3-tier) software architecture (we'll discuss the topic of software architecture in a future article).

There are several ways to develop this middle tier, which may itself comprise one or more layers. We will develop a class for each domain concept, which, within this small example, corresponds more or less to develop a class for each table in the database.

There are various ways to do this. In particular, we will look at two possible ways, each with its own group of supporters, and with its own advantages and disadvantages.

1 – Some authors advocate the development of only one layer of classes with attributes and getters and setters (eg class Book below) separated from a layer with classes containing operations with meaning for the business (eg class BookBLL below), being this latter layer the one with knowledge for interfacing with the database.

1.1 classe Book:
public class Book {
    private int idBook;
    private String title;
    private String editor;
    private java.sql.Date date;
    private String ISBN;
    private String edition;
    //
    private List<Author> authors = new ArrayList<Author>();


    public Book() {    }

    public int getID() { return this.idBook;    }

    public void setTitle(String title) { this.title = title;    }

    public String getTitle() { return title;    }

    public void setEditor(String editor) { this.editor = editor;    }

    public String getEditor() { return editor;    }

    public void setDate(java.sql.Date date) { this.date = date;    }

    public java.sql.Date getDate() { return date;    }

    public void setISBN(String ISBN) { this.ISBN = ISBN;    }

    public String getISBN() { return ISBN;    }

    public void setEdition(String edition) { this.edition = edition;    }

    public String getEdition() { return edition;    }

    public List<Author> getAuthors() { return this.authors;    }
}

1.2 classe BookBLL:

public class BookBLL {
    private DBAccessObj dbo;

    public BookBLL() {
        this.dbo = new DBAccessObj();
        this.dbo.openConnection();
    }

    public BookBLL(DBAccessObj dbo) {
        this.dbo = dbo;
        this.dbo.openConnection();
    }

     public void create(Book b) throws SQLException{

            String sqlCommand =
                         "INSERT INTO Book (ISBN, Title, Edition, Editor) VALUES('" +
                                                                b.getISBN() + "', '" + b.getTitle() + "', '" +
                                                                b. getEdition() + "', '" + b.getEditor() + "')";

            this.dbo.executeSQL(sqlCommand);
     }

…
// remaining methods
…
}

This first approach does not explore the encapsulation of data and operations on the data (fundamental concept of the object-oriented programming paradigm).

2 – Another way is to develop:

• a layer of classes with attributes and getters and setters, plus CRUD operations (Create, Retrieve, Update, Delete) (eg: class BookDAL below) separated from,

• a layer of classes with operations with meaning for the business, and that do not depend directly on the database and can be obtained by composition of primitive CRUD operations (eg class BookBLL below).

In this approach, the layer with knowledge for interfacing with the database is the first one (the data access layer, DAL).

2.1 classe BookDAL:

public class BookDAL {
    private int idBook;
    private String title;
    private String editor;
    private java.sql.Date date;
    private String ISBN;
    private String edition;
    //
    private List<Author> authors = new ArrayList<Author>();

    private DBAccessObj dbo;

    public BookDAL() {
        this.dbo = new DBAccessObj();
        this.dbo.openConnection();
    }

    public BookDAL(DBAccessObj dbo) {
        this.dbo = dbo;
        this.dbo.openConnection();
    }

    public int getID() { return this.idBook;    }

    public void setTitle(String title) { this.title = title;    }

    public String getTitle() { return title;    }

    public void setEditor(String editor) { this.editor = editor;    }

    public String getEditor() { return editor;    }

    public void setDate(java.sql.Date date) { this.date = date;    }

    public java.sql.Date getDate() { return date;    }

    public void setISBN(String ISBN) { this.ISBN = ISBN;    }

    public String getISBN() { return ISBN;    }

    public void setEdition(String edition) { this.edition = edition;    }

    public String getEdition() { return edition;    }

    public List<Author> getAuthors() { return this.authors;    }

    public void create() throws SQLException{
              String sqlCommand =
                         "INSERT INTO Book (ISBN, Title, Edition, Editor) VALUES('" +
                         this.ISBN + "', '" + this.title + "', '" + this.edition + "', '" + this.editor + "')";
              this.dbo.executeSQL(sqlCommand);
    }

    public void retrieve(int id) throws SQLException{
         String sqlCommand =
            "SELECT ISBN, Title, DateEdition, Edition, Editor FROM Book WHERE ID = '" + id + "'";

         ResultSet book;

         book = this.dbo.executeQuery(sqlCommand);

         if (book.next()){
                    this.idBook = id;
                    this.ISBN = book.getString("ISBN");
                    this.title = book.getString("Title");
                    this.date = book.getDate("DateEdition");
                    this.edition = book.getString("Edition");
                    this.editor = book.getString("Editor");
         }
    }

    public void retrieveByISBN(String isbn) throws SQLException{
        String sqlCommand =
         "SELECT ID, Title, DateEdition, Edition, Editor FROM Book WHERE ISBN = '" + isbn + "'";

        ResultSet book;

        book = this.dbo.executeQuery(sqlCommand);

        if (book.next()){
             this.idBook = book.getInt("ID");
             this.title = book.getString("Title");
             this.date = book.getDate("DateEdition");
             this.edition = book.getString("Edition");
             this.editor = book.getString("Editor");
             this.ISBN = isbn;
        }
    }

    public void update() {
        String sqlCommand =
             "UPDATE Book SET ISBN = '" + this.ISBN + "', Title = '" + this.title + "', Edition = '" +
                   this.edition + "', Editor = '" + this.editor + "' WHERE ID = '" + this.idBook + "'";

        this.dbo.executeSQL(sqlCommand);
    }

    public void delete() {
        String sqlCommand = "DELETE FROM Book WHERE ID = '" + this.idBook + "'";
        this.dbo.executeSQL(sqlCommand);
    }

    public ResultSet retrieveThisBookAuthors(DBAccessObj dbo) throws SQLException{
        String sqlCommand =
              "SELECT B.ID, B.ISBN, B.Title, A.ID, A.Name, A.Surname FROM BookAuthor BA, Author A, Book B WHERE BA.BookID = B.ID AND BA.AuthorID = A.ID AND B.ID = " + this.getID() + " ORDER BY 3, 2";

        ResultSet books;

        dbo.openConnection();
        books = dbo.executeQuery(sqlCommand);
        return books;
    }

    public void fillThisBookAuthors() throws SQLException{
        String sqlCommand = "SELECT A.ID, A.Name, A.Surname FROM BookAuthor BA, Author A, Book B WHERE BA.BookID = B.ID AND BA.AuthorID = A.ID AND B.ID = " + this.getID() + " ORDER BY 3, 2";
        ResultSet booksA;

        this.dbo.openConnection();
        booksA = this.dbo.executeQuery(sqlCommand);

        while (booksA.next()){
            Author au = new Author();
            au.setName(booksA.getString("Name"));
            au.setSurname(booksA.getString("Surname"));
            this.authors.add(au);
        }

    }

    public static ResultSet retrieveAllBooks(DBAccessObj dbo) throws SQLException{
        String sqlCommand = "SELECT ISBN, Title, DateEdition, Edition, Editor FROM Book";
        ResultSet books;

        dbo.openConnection();
        books = dbo.executeQuery(sqlCommand);
        return books;
    }

    public static ResultSet retrieveAllBooksAuthors(DBAccessObj dbo) throws SQLException{

        String sqlCommand = "SELECT B.ID, B.ISBN, B.Title, A.ID, A.Name, A.Surname FROM BookAuthor BA, Author A, Book B WHERE BA.BookID = B.ID AND BA.AuthorID = A.ID ORDER BY 1, 6, 5";
        ResultSet books;

        dbo.openConnection();
        books = dbo.executeQuery(sqlCommand);
        return books;
    }

2.2 classe ManageBooksBLL:

public class ManageBooksBLL {
    public ManageBooksBLL () {    }

    public int borrowBook (Book book, Borrower leitor) throws ManageBookException {
          …
    }

    public int borrowBook (int bookID, int leitorID) throws ManageBookException {
          …
    }

    public int returnBook (Book book) throws ManageBookException{
          …
    }

    public int returnBook (int bookID) throws ManageBookException {
          …
    }
}

In this approach, the encapsulation of data and operations appears, oriented to the problem domain entities (persistent classes or Entity), in the data access layer (DAL).

Business Logic Layer (BLL) contains operations oriented to the use cases to be implemented in the software application, and can therefore be seen as a layer providing services to the layer above, the User Interface (UI) or Presentation layer.

In practical terms, depending on the amount of complex operations in a program (operations other than CRUD), we can still mix the DAL and BLL of the 2nd approach, by adding in classes DAL the few BLL methods that we'd have, eliminating the BLL classes.

Note, in both approaches, the use of class DBAccessObj, whose development has been addressed in the previous article, to access the database.

The zip with the end result may, as usual, be asked for as a comment to this article.

Other related articles:
- Example of Java Swing Application with Oracle Database - 1
- Example of Java Swing Application with Oracle Database - 2
- Example of Java Swing Application with Oracle Database – 4

Example of Java Swing Application with Oracle Database - 2

2012-01-22T10:40:00.000+00:00

In the previous blog entry we initiated the construction of a series of articles for constructing a small example application for managing a library, for desktop environment and using Java Swing classes, and accessing an Oracle database.

The previous article addressed the Oracle database creation. This article will handle the construction of a Java class for accessing the database.

We will be using NetBeans IDE 7.0.1, which may be downloaded from http://netbeans.org/community/releases/70/.

After installing NetBeans IDE 7.0.1, we must create a new "Java Class Library" project, which we will name HelperDB, because it will consist only of a single class for helping us access the database.

We also create a Java class, that we named DBAccessObj, in file DBAccessObj.java.

It is needed to include two or three (depending on the ORACLE version) JAR library classes to access the Oracle database by using a JDBC driver:

These jar files may be found in directory

                              oraclexe\app\oracle\product\10.2.0\server\jdbc\lib

being oraclexe the directory where Oracle XE has been installed.

Let's now create a package, which we name HelperDB, that will contain our class, and let's import package java.sql, which contains classes for connecting and sending SQL statements to the database:

package HelperDB;

import java.sql.*;

public class DBAccessObj{
       private Connection conn;

       public DBAccessObj()
       {
       }
}

As the only instance variable in our class, we shall create conn of "type" java.sql.Connection.
Actually, Connection is a Java interface, and so conn may contain an object of any type (class) that implements that interface. So, conn may contain an instance of any type of connection. The type will be given by the DriverManager according to the driver that is being used.

The class constructor will then be modified to create a database connection:

       public DBAccessObj()
       {
              this.createDBConnection();
       }

       private void createDBConnection()
       {
            try {
               Class.forName("oracle.jdbc.driver.OracleDriver");
            }
            catch(ClassNotFoundException e) {
             System.out.println("Oops! Can't find class oracle.jdbc.driver.OracleDriver");
             System.exit(1);
            }
            try{
               conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "libraryuser","libraryuser");
            }
            catch(Exception e){
                 System.out.println("ERRO " + e.getMessage());
            }
       }

The driver we will be using is "oracle.jdbc.driver.OracleDriver" and the database connection string is:

"jdbc:oracle:thin:@localhost:1521:XE"

being "libraryuser","libraryuser", respectively the user and password of the user we want to use in the database access (refer to the previous article).

At this point, if we write a small test class (TestClass.java) to create an instance of our class, it will be possible to see if the connection is correctly made:

import HelperDB.DBAccessObj;

public class TestClass {
    public static void main(String[] args) {
        DBAccessObj conexao = new DBAccessObj();

    }
}

If the connection isn't made, one of the error messages that we put in the catch part of the above try/catchs will appear.

After creating the database connection we want to send SQL statements to the database, to insert data in a table (INSERT), modify data (UPDATE), delete data (DELETE) or consult data (SELECT).

For that purpose, we need an instance of a class that implements interface java.sql.Statement:

       public Statement   createStatement()
       {
          Statement st=null;
          if (this.conn==null)
             this.createDBConnection();
          try{
             st = this.conn.createStatement();
          }
          catch(Exception e){
             System.out.println("ERRO " + e.getMessage());
          }
          return st;
       }

To execute an SQL command using the created Statement instance, we'll create another couple of methods in our class:

- To execute an SQL command that doesn't yield a result (INSERT, UPDATE or DELETE):

       public void executeSQL(String SqlComm)
       {
        Statement st = this.createStatement();
        try{
                   st.execute(SqlComm);
              }
          catch(Exception e){
             System.out.println("ERRO " + e.getMessage());
          }

       }

- To execute an SQL command that yields a result (SELECT):

       public ResultSet executeQuery(String SqlComm)
       {
          Statement st = this.createStatement();
          ResultSet rs=null;

          try{
                   rs = st.executeQuery(SqlComm);
          }
          catch(Exception e){
             System.out.println("ERRO " + e.getMessage());
          }
          return rs;
       }

Finally, let's write methods for opening and closing a database connection:

       public Connection openConnection()
       {
           if(this.conn==null)
                 this.createDBConnection();

           return this.conn;
       }

       public void   closeConnection()
       {
              if(this.conn!=null)
              {
                  try{
                    this.conn.close();
                   }
                   catch(Exception e){
                      System.out.println("ERRO " + e.getMessage());
                   }
              }
       }

This ends our class. To test it, we may now modify the test class:

import HelperDB.DBAccessObj;
import java.sql.*;

public class TestClass {
    public static void main(String[] args) {
       DBAccessObj conexao = new DBAccessObj();

     conexao.executeSQL("Insert into Author columns (Name, SURNAME) VALUES ('XICO', 'MENDES')");

             ResultSet rs = conexao.executeQuery("SELECT * FROM AUTHOR");

             try{
              while(rs.next()){
                   String aName = ((String)rs.getString("Name"));
                   String aSurname = ((String)rs.getString("Surname"));
                   //
                       System.out.println(aName + " " + aSurname);
                    }
             }
       catch(Exception e){
             System.out.println("ERRO " + e.getMessage());
             }
    }
}

If everything is OK, the result of our test will be the insertion of author named XICO MENDES in table AUTHOR and the ulterior listing of the contents of the same table.
Methods for opening and closing a connection have not been tested, but we'll see their utility in a forthcoming article.

Other related articles:
     - Example of Java Swing Application with Oracle Database - 1
     - Example of Java Swing Application with Oracle Database - 3
- Example of Java Swing Application with Oracle Database – 4

Example of Java Swing Application with Oracle Database - 1

2012-01-19T17:59:00.000+00:00

Today we're beginning a series of blog entries that will culminate in a small example Java application for a library management, for desktop environments and using Java Swing classes, and accessing an Oracle database (DB).

This first article addresses the creation of a small Oracle database. It was used Oracle Express 10g, which can be freely downloaded from http://www.oracle.com/technetwork/database/express-edition/downloads/102xewinsoft-090667.html. There is a more recent version of Oracle Express, the 11g release 2, which may be downloaded from http://www.oracle.com/technetwork/database/express-edition/downloads/index.html and with which the example shall also execute correctly.

After installing Oracle, we may access the database administration tool by going to button Start --> All Programs --> Oracle Database 10g Express Edition --> Go to the Database Home Page or, in a browser, go to http://localhost:8080/apex.

Then, it shall appear a page for us to login in the administration tool:

We shall login with user SYSTEM and the password that we defined for that user during the instalation process.
After logging in the work space appears:

At this point, we must, in the first place, create a new user (Administration --> Database Users --> Create User). We have created user libraryuser, which will then be used to create the database tables, and also to access the database from the Java application. It is needed to grant the new user privileges for CREATE TABLE and CREATE SEQUENCE, and we may also grant him privileges to CREATE VIEW, CREATE PROCEDURE, and CREATE TRIGGER.

The user name of the user with which the database tables are created will then be set as a prefix to the database tables (schema) and, depending on the privileges granted to him, he/she may be restricted to his/her "own" tables.

The reference to a table column, in Oracle, has the following structure:

"schema"."table"."column"

The schema name may have 30 bytes, the table name another 30 bytes, and the column name still more 30 bytes.
The total length of a column identifier may, then, be up to 98 bytes (if we count the dots and commas).

We, then, shall not use the user SYSTEM to create user tables in the database, and even less to access the database from a software application.

Of course, in this toy application this isn't an important issue.

The next step is to logout from the SYSTEM account, in the administration tool, and login as the newly created user (libraryuser).

Now we can create the tables that we need for our application's database, which will be created within schema libraryuser, because that is the user that we'll be using in their creation.

We want to create tables according to the following model:

Now, let's create the tables.

Here is the process for creating the table AUTHOR:

Table Author has a Primary Key, which we want to be populated from a new sequence:

ORACLE will create the new sequence and a trigger for populating the primary key.

Table AUTHOR has no foreign keys, nor other check constraints.

But, note that, in our database schema, table BookAuthor must have two foreign keys (referencing Book and Author), and table BookCopy must have one foreign key referencing Book.

After all tables being created...

In the next article we'll create a Java class for accessing the newly created database.
If you have any trouble, please put you questions as comments to this article.

Other related articles:
- Example of Java Swing Application with Oracle Database - 2
- Example of Java Swing Application with Oracle Database - 3
- Example of Java Swing Application with Oracle Database – 4

2012-01-18T16:49:00.001+00:00

Today, we are striking against censorship. Join us in this historic moment: tell congress to stop this bill now!

Start using .Net Entity Framework - 3

2012-01-03T10:41:00.001+00:00

This article illustrates the usage of ADO.Net Entity Framework in creating, updating and deleting data records.

This article comes after:
- Start using .Net Entity Framework - 1 , and
- Start using .Net Entity Framework - 2

where we saw how to create a data model (ADO.Net Entity Data Model) from a pre-existing database, and how to use that model to query the database and fill a comboBox, by using a small example. The example database has only one table (Pais) with countries.

Taking the same example, we added a label to Form1, which will enable the visualization of each record's ID, and a text box that enables the user to modify the name of a country or create a new country in the database.

Buttons have also been added to Create New, Update and Delete a country in the table, and a Cancel button that closes the application.

To start, we add, in the method that handles the selection of a new line in the comboBox, the code to fill the label (label1) with the country ID, and the text box (paisTextBox) with the name (nome) of the country. This allows the user to edit the current name of a country, in order to modify it, or to insert a new country's name, in order to create it in the database.

private void paisesBox1_SelectedIndexChanged(object sender, EventArgs e)

{

label1.Text = paisesBox1.SelectedValue.ToString();

paisAtual = (Pais)paisesBox1.SelectedItem;

paisTextBox.Text = paisAtual.nome;

}

Update the Name of a Country:

We create a clich handler for button Update:

private void UpdateBut_Click(object sender, EventArgs e)

{

paisAtual.nome = paisTextBox.Text;

int rowsAffected = dbContext.SaveChanges();

MessageBox.Show("Updated " + rowsAffected.ToString() + " table records.");

}

Create a New Country:

We create a click handler for button Create:

private void CreateBut_Click(object sender, EventArgs e)

{

Pais novoPais = new Pais();

novoPais.nome = paisTextBox.Text;

dbContext.AddToPaises(novoPais);

int rowsAffected = dbContext.SaveChanges();

paisAtual = novoPais;

MessageBox.Show("Created " + rowsAffected.ToString() + " new record(s) in the table.");

dbContext = new simpleEntityFrameworkApp.bdExemploEntities();

paisesBox1.DataSource = dbContext.Paises;

paisesBox1.DisplayMember = "nome";

paisesBox1.Invalidate();

}

Delete a Country:

We create a click handler for button Delete:

private void delButton_Click(object sender, EventArgs e)

{

dbContext.DeleteObject(paisAtual);

int rowsAffected = dbContext.SaveChanges();

MessageBox.Show("Deleted " + rowsAffected.ToString() + " table records.");

label1.Text = paisesBox1.SelectedValue.ToString();

paisAtual = (Pais)paisesBox1.SelectedItem;

paisTextBox.Text = paisAtual.nome;

}

Finally, the click handler of the Cancel button only disposes of the database mapping context and closes the form.

private void Cancelbotao_Click(object sender, EventArgs e)

{

dbContext.Dispose();

this.Close();

}

Other related articles:
    - ADO.Net Entity Framework
    - Start using .Net Entity Framework - 1
    - Start using .Net Entity Framework - 2

Once again, whoever is interested in obtaining the code with the example, please ask for it in a comment to this post.

Object-Relational Mapping Tools

2011-12-30T12:33:00.001+00:00

Object-Relational Mapping Tools or ORM tools are middleware tools used to create an object-oriented abstraction layer, to the programmer, while dealing with the data in a relational format, in the database.

ORM tools provide, thus, an abstraction layer that allows the programmer to abstract away from the physical format in which data is stored. Managing data persistence is delegated in the ORM tool, allowing the programmer to work at the code level with objects that instantiate the domain model, developed in the software modelling phase, instead of having to use structures with the format of the database tables.

The object-relational mapping tools establish a bidirectional connection between the objects in the code and data in a relational database.

There are several ORM tools, both commercial and free (see List of object-relational mapping software), among which the most widely-used in Java world is certainly Hibernate, and in .Net world is ADO.Net Entity Framework and NHibernate.

Read more:
      - Choosing an object-relational mapping tool
      - Hibernate.org
      - ADO.Net Entity Framework at a glance

Other related articles:
    - ADO.Net Entity Framework
    - Start using .Net Entity Framework - 1
    - Start using .Net Entity Framework - 2

Start using .Net Entity Framework - 2

2011-12-29T17:01:00.002+00:00

After having created the Windows Forms Application project and generated the data model from the database let's see how we can access the database through the model, using a small illustrative example.

In the Form1 form, created automatically when creating the Windows Forms Application project, we will create a comboBox, dragging it from the toolbox.

In the Properties tab we change its name to paisesBox1.

Then we add an event handler for the Load event of Form1 form (last line of code in the InitializeComponent () method below):

And create the method corresponding to the event handler (Form1_Load ()):

This method will fill the paisesBox1 comboBox when the form Form1 starts.
Let's see how this is done in more detail:
   - Line            simpleEntityFrameworkApp.bdExemploEntities dbContext;

     declares variable dbContext of type bdExemploEntities, which corresponds to the created data model.

   - Line
            dbContext = new simpleEntityFrameworkApp.bdExemploEntities();

     creates the object with the data model, responsible for the mapping to the database, and assigns it to the variable dbContext.

   - Line
            paisesBox1.DataSource = dbContext.Paises;

     assigns Paises, in the database context created before, to the DataSource property of the comboBox, indicating that this is from where data for the comboBox should be read.

   - Lines
            paisesBox1.DisplayMember = "nome";
            paisesBox1.ValueMember = "idPais";

     identify attributes of Pais (one country; whether Paises are several countries) that shall be displayed in the comboBox (property DisplayMember) and yelded as selectedValue property of the comboBox when a country (país) is selected (ValueMember).

This code excerpt reads all lines of table Pais and fills the comboBox.

If, for example, we intended to filter the data by some criteria we could use LiNQ to do it, before we associate the result to the comboBox.

For instance, line

paisesBox1.DataSource = dbContext.Paises;

could be replaced by:

          List<Pais> listaPaises;
          IQueryable<Pais> paisesQuery = from p in dbContext.Paises
                                 where p.idPais > 20
                                 select p;
          listaPaises = paisesQuery.ToList<Pais>();
          paisesBox1.DataSource = listaPaises;

In this case, the comboBox would be filled only with the countries (países) with ID (idPais) higher than 20.

In a forthcoming article we will see how to update the database using the model created with the Entity Framework.

If anyone is interested in the C# code used in this example, please ask for it in a comment to this blog entry.

Other related articles:
- ADO.Net Entity Framework
- Start using .Net Entity Framework - 1

Start using .Net Entity Framework - 1

2011-12-29T16:08:00.000+00:00

This article illustrates the creation of an Entity Framework model and its use with a small program in C # for Windows (Windows Application).
To implement this example you must have installed Visual Studio 2010 (with 2008 should also work), as well as .Net framework 3.5 SP1 or higher.
In addition, it is necessary to access a database service, so as the first approach, it is advisable to use Microsoft SQL Server 2008.

1. The first step is to create a new project of type Windows Forms Application.

2. Then we add a new item to the project, of type ADO.Net Entity Data Model (see next two images). In the example it has been given the name ModeloDeDados.edmx to the file that will contain the data model and the database mapping.

3. Then, to make things much easier, we generate the data model from an existing database. To do this, select "Generate from database" (see the figure below).

This option requires us to set up the database connection, from which the data model and mappings will be generated:
- Select the server where the database service is running, the database name, and test the connection:

- choose to save the connection string in App.Config:

4. Then, choose the database objects that will be part of the model and will be mapped between the model and the database (in this case we have only one table, Paises (meaning countries)):

Finally, we get a graphical view of the model generated from the database.

Next article will illustrate the use of the generated data model from a small C# program.

If anyone wants the code used in the example please ask for it as a comment to this article.

Other related articles:
- ADO.Net Entity Framework
- Start using .Net Entity Framework - 2

ADO.Net Entity Framework

2011-12-29T15:10:00.003+00:00

Entity Framework is a set of ADO.NET technologies that support the data-oriented software development.

Typically, today, developers of data-driven applications perform the modelling of entities and relationships in an object-oriented way, and then have to deal with the format in which these entities have to be put in a database engine. The data can be physically distributed across multiple storage systems and even applications that work with only one database system have to make trade-offs between the logical format of the modelled data, present in the data model, and the physical format, easy to maintain and oriented to an efficient access.

Entity Framework enables developers to work with data in the form of domain-specific objects, as modelled in the data abstract model, without worrying about the tables of the database where they are stored.

With Entity Framework, developers can work at an abstraction level higher than when they have to deal directly with the data, and can create and maintain data-driven applications with less code than with traditional applications.

As Entity Framework is a component of the .NET Framework, applications that use Entity Framework can run on any computer that has .Net framework version 3.5 SP1 or above installed.

In the next article we will see a small example of how to use ADO.Net Entity Framework.

Other related articles:
- Start using .Net Entity Framework - 1
- Start using .Net Entity Framework - 2

How to install an extension in Joomla (1.7)

2011-12-28T21:36:00.004+00:00

Joomla is very good. It takes only the original features to make complete websites with a professional look.

But after some time the need to include something that is not possible with the original modules arises.

So you need to install an extension in Joomla. You can search and find various extensions for Joomla in http://extensions.joomla.org/ or http://developer.Joomla.org, amongst other sites.

There are five main extension types in Joomla: Components, Modules, Plugins, Templates, and Languages. Each type deals with specific functionality (see http://docs.joomla.org/Extension_types_(general_definitions)).

Other possible extensions are File and Library. Libraries are code packages that provide functionality to the Joomla framework or its extensions.

Components are content elements or mini-applications, usually to include in the center of the main content area of a template.

A component usually has two parts: the part of the site, and the part of the administrator. A component forms the major part of a Joomla page, because every component is guided by a menu item and every menu item runs a component.

Some of the core functionality of Joomla is based on components (eg: Banners, Contact, News Feeds, Polls, ...).

The modules are lightweight extensions that extend the capabilities of Joomla with new functionality.

Modules are small content items that can be displayed anywhere allowed by the template. They are usually the boxes arranged around a component (eg, the login module). The page bottom (footer) is a module. Modules are assigned per menu item, so you can decide which menu item should appear as a module.

Some modules are connected to components such as the module "latest news", which is connected to the component com_content and shows links to the most recent content items.

Some modules that originally come with Joomla are: Main Menu, Top menu, Template Chooser, Polls, Newsflash, ...

Plugins are advanced extensions. Essentially they are event handlers. Plugins are registered in Joomla to deal with some event triggered when using the Joomla site. When an event is triggered, Joomla sees if it has a plugin to handle this event and, if so, executes it. In the early days of Joomla, plugins were known as mambots.

A template is the basic design of a Joomla website. It allows you to change the look & feel of a website. Templates have certain fields where components (only one field) and modules (several fields) are shown.

Languages are basic extensions that are available as an extension package or as a core package, which basically consists of files of key/value pairs providing the translation of Joomla static text in another language. These language packages affect the main site (front end) and the administrator site (back end).

Modules, plugins, templates and language packages are easily installed in the administrator site (backend), going to the menu Site -> Control Panel -> Extension Manager.

There, it is possible to select the package file (.zip) and click in “Upload & Install”, or opt by one of the alternative solutions.

After installing the extension, you need to configure it so that it appears in the correct place in the website.