CSCI399 Laboratory Manual

Lab setup
The NetBeans IDE will be used for both PHP and Java development in CSCI399. You
should have previous experience with NetBeans from CSCI110, and maybe also CSCI222.
The version for Session 1 2015 is 8.02 (screenshots in this document will be from this version
and from earlier versions).

The Glassfish appserver has been installed along with NetBeans. This will be used to run
servlets in the Java component of the subject.

Most of the assignments require database access. MySQL is the standard database for
CSCI399, and you will have MySQL accounts on the laboratory machines. But you can use
other databases such as Oracle if you have an account on wraith (or even Derby or Postgres;
if you install all the software on Windows, you can use SQLServer but not Microsoft
Access). The arrangements for using MySQL are the same as in CSCI110. Each laboratory
computer is running its own instance of MySQL; the MySQL engine creates databases on the
local hard disk. This means that if you create tables on one computer, they will not be
available to you if you move to another computer. Remember also that there is no backup; if
the software on a computer is refreshed, your data tables will vanish. So whichever database
you choose, you should keep the scripts that create your tables and the scripts that populate
tables with initial data. (Oracle will not be an option for PHP projects; I no longer configure
the Apache/PHP system with an Oracle client; there should be an Oracle .jar file in /share/cs-
pub/399 that you can use for accessing Oracle from Java.)

MySQLs Workbench application is installed on the laboratory machines (there are tutorials
for Workbench at the MySQL site). You can use Workbench to connect to the local MySQL
engine and create tables. Alternatively, you can work from the Services/Databases tab in
NetBeans where you can run SQL scripts or individual SQL commands.

There is a standard Apache running at port 80 on each machine. This has been configured to
allow user directories. It runs in single thread mode because it includes the PHP
interpreter. The PHP interpreter has been configured with modules for MySQL (mysqli), and
has the GD graphics libraries installed.

The arrangements for user directories are the same as in CSCI110. You should create a
public_html directory in your home directory and allocate execute permission to
others. Your home directory on Linux usually has permissions drwx------; these
permissions prevent other students from looking at your work, but also prevent the Apache
web server from accessing your public_html directory. As in CSCI110, you should change
the permissions on your home directory to maybe drwx-----x.
The PHP environment in NetBeans should include the Zend framework (1.11) and the Smarty
(3) template engine. The installed PHP libraries include the ADOdb ORM package as well as
GD graphics.

When you first use NetBeans (or maybe every time you start NetBeans) you may get
challenged for a Keyring password. This is a feature of the Linux system and its gnome
window manger; it depends on how your account has been set up whether or not you get this
challenge. If you cannot remember your Keyring password, you should remove all files from
the directory .gnome2/keyrings and then try again.

If you have used NetBeans previously, you may have a set of directories such as .netbeans,
.netbeans-derby, .netbeans-registration, mydomain and others. (You will also probably
have a NetBeansProjects directory.) Data in these directories may relate to older versions of
the NetBeans system and can under some circumstances prevent you from starting NetBeans.
If you have problems, delete any old NetBeans directories to give it a clean start.

Reasonably current versions of Firefox and Chrome have been installed on both Linux and
Windows OSs. These should support fairly substantial subsets of HTML5.

The Apache logs are in /var/logs/apache2 but you cannot access these directly. There
should be two locally defined commands apacheerrortail, and apacheaccesstail that let
you see recent entries in these logs. The data in the logs can be useful for debugging or for
providing evidence for your reports, i.e. evidence showing that your version runs.

Starting in the laboratory

It will probably be best if in the first week of session you set up your laboratory environment
both the PHP parts and the Java parts. You should also reprise work that you have done
previously on creating and using tables in MySQL.

1 Directory setup
Create a public_html directory in your home directory. Assign appropriate access
permissions to both your home directory and the public_html subdirectory. If you cannot
remember how to do that, go and look at the CSCI110 exercises. Create a text file
helloworld.html containing the text:
<!doctype html>
<html>
<head>
<title>Directory test</title>
</head>
<body>
<h1>Hello!</h1>
<p>Hello your user identifier here</p>
</body>
</html>

Make sure that this file has read permission for others.

Aim a browser at http://localhost/~youruserid/helloworld.html.

You should get a greeting delivered via the local Apache web server.

(Dont open the file by double clicking on it! That has it delivered by the local file system
not the web server.)

2 NetBeans
Start NetBeans.

If you are challenged for a Keyring password get that sorted out and try again.

NetBeans will typically display a start page (you can turn off this feature). If you configure
your NetBeans (in Tools/Options/General) you can set your name and password so allowing
NetBeans to access the Internet via the Universitys proxy; if Internet access is available, the
start page will include news from netbeans.org.

Close the start page and get to the standard tab pane view.

2.1 New PHP project

Create a new PHP project (right-click in Projects tab and select new).
The first time you create a project of any particular kind (Java, Java Web, PHP, ) NetBeans
will have to run some activation code to initialize configuration data.

This first project is a basic PHP project (PHP version 5.5 with namespace support):
No frameworks needed yet:

Write the code:

What do you mean I cant read that?

OK, here is the code again

It should run:

2.2 Activate Java

Next create a Java project (nothing to do with the web, just checking that all parts are
working!). Since this is the first Java action, the Java components must be activated

Activation can take a little time

Fill in all those dialogs:

Implement your Java Standard Edition hello-world program:

What do you mean I cant read that?

OK, here is the code again

Now run it:

2.3 Activate Web and Enterprise Java

Create another project this time the type is Java Web.

There is a lot more activation work this is the point where NetBeans must create a lot of
extra configuration data for the Glassfish appserver.

At some stage in the activation process it will ask which server you wish:
It will default to creating a complete copy of all server code in a hidden sub-directory in your
home directory. This wastes too much of your limited disk quota (it is fine if you are
working on your own computer).

Instead, set the server as the installation in /usr/local/glassfish.

It is still going to use a lot of your filespace (but not quite as much). It always has to create
many preferences files, and history files recording your use of the server. It will also let
you install additional plugins extra NetBeans features that you may wish. (The idea is that
the /usr/local/glassfish installation has the components that every user will use, but each
individual user has a customised instance of the server with the extras that they wish.)
It will create a personal domain a subdirectory with your own preferences and extra
plugins.

It will print details of the ports that it has set for your server (port numbers will change if any
of the default ports were in use when you create your personal domain).

(Some error messages will appear during this process. Some of these relate to an out-of-date
security certificate this has been complained about since at least 2008; there must be some
reason why they dont fix it.)

Note that PHP projects (that will be served via the Apache/PHP system) go in your
public_html directory but Java web applications that run on Glassfish go in subdirectories of
your NetBeansProjects directory.
You should eventually get an empty web app with just a HTML page (index.html) (in some
versions of NetBeans, you get a JSP page index.jsp instead).

Edit the HTML code so that it will produce some output.

Just select the project in the projects tab, and right-click and select Run.
It gets exciting. (?)

NetBeans has to

1. If necessary, compile the JSP page (converting it into a servlet that prints output)
this isnt required if a HTML page was created.

2. Prepare it for deployment.

3. Start servers (Derby database and glassfish).

4. Deploy the application onto the server. Start a browser.

5. Aim the browser at the new Java Web application.

(If you have followed instructions from elsewhere like some of the lecture notes and you
have already set an administrator password on your glassfish, you will be prompted to enter
this password at some point during the deployment operation. You really should set an
administrator password see later.)

Derby database starts, and glassfish starts reports appear in the output logs shown in
NetBeans:

It does actually have quite a lot of work to do to get the appserver up and running:
Eventually we get there:

I dont know why it creates two entries in your servers table:

Right-click on the running server (the one with the green marker) to get controls for restarting
and setting properties.

Since we dont use Derby, this database process is just extra overhead. You might as well
switch off the automatic start of Derby. The HTTP Monitor option may help debugging; it
provides additional log data about the requests that your server received.

2.4 Check out database connections

Do this once you have got your database password and identifier.

The lecturer will send mail with the identifier and password for MySQL it will be
something like student13/V1hJ4kuio.

You may not get passwords until the second week of session.

You should be able to use MySQL workbench. There is a little file babynames.sql in
/share/cs-pub/399 on banshee. Get this file.

Connect to your MySQL account using Workbench:

(Use the password that you were sent, and the username username gets used as
connectionname, username, and default schema name.)

Create the table:

(The data are the most popular names for boys and girls as based on Birth Announcement
data in some USA newspapers in 2012. The idbabynames field is one of those terrible
surrogate keys the only reason that its there is a later exercise will use a simple ORM
(object relational mapping system) that requires primary keys and has a very very strong
preference for simple integer primary keys with names starting id.)

Then in NetBeans, check the Services/databases tab, it should show provision for connections
to a variety of databases, and will probably also have an entry for administering the local
MySQL (which you cannot use as Im not telling you the administrator password) and for
using Derby (which you dont particularly want to use I suppose you could use it if you
have some deeply held conviction that MySQL was not right for you).

It sets the wrong schema as the default find your own schema and right click to set it as
your default. (You should change that JDBC URL something easier like
student13connection or, as for this example, mcleodconnection.)
2.5 Check the data table

2.5 Using the databases from PHP

Create a new PHP web application that simply displays the contents of the babynames table:

/home/mcleod/public_html/Babynames1/index.php
<!DOCTYPE html>

<html>
<head>
<meta charset="UTF-8">
<title>Database tests</title>
</head>
<body>
<h2>MySQL</h2>

<p>Connect to local mysql, list all in babynames table</p>

<?php
$mysqli = new mysqli('localhost', mcleod, 'notmypassword', mcleod);
if (mysqli_connect_errno()) {
$e = mysqli_connect_error();
die($e);
}
$stmt2 = $mysqli->prepare("select idbabynames, name, gender from babynames");
$stmt2->execute();
$stmt2->bind_result($id, $name, $gender);
print "<table border='1'>";
while ($stmt2->fetch()) {
print "<tr>";
print "<td>" . $name . "</td>";
print "<td>" . $gender . "</td>";
print "</tr>";
 }
print "</table>";
?>
</body>
</html>

It should work (of course, you did remember to change the user-name and password).
2.6 Getting smart
There is a demonstration PHP/Smarty project in /share/cs-pub/399/A3.

Fetch it, and unpack into your public_html folder:

(Of course, you log in to banshee using your user id and password, not mine!)
This project has the standard smarty structure with sub-directories for cache, configs,
templates, and templates_c. (The sub-directories for cache and templates_c need
permissions that let the Apache web server write files.)

The example has a form and PHP response page for Rasmuss Name/Age example, and
another PHP script that gets data from a simple table. Both the demo and showpeople PHP
scripts use smarty templates for their output.

You need to create and populate the table with details of Rasmuss friends.

The index.php page is just Rasmuss form:

The data entered in the form are picked up by the PHP script, set as attributes in an instance
of class Smarty, and this smarty object is then used to output a HTML response page using
the rasmus.tpl Smarty template:
That part should run:

The showpeople.php script fetches data from the peopletable that you created; packs required
data into an array structure; and finally passes this array of data to a smarty object that will
display the data using the showpeople.tpl template.
This part should also run (yes, you do need to first change the username and password in the
connection request.)
2.7 Setting up Zend
You can leave this part of the exercise until you are about to start Assignment 4. The Zend
framework is introduced in the Still More PHP segment of the subject.

First, you should add the Zend library to the global include path used by NetBeans for PHP
(this is under the Tools/Options menu):

(The library is currently in /usr/share/php/libzend-framework-php.)

Adding this directory allows NetBeans to check calls to methods of Zend classes.

The Zend libraries must also be added to your Apache configuration (this has been done in
the laboratory, but it is something that you would have to do if trying to configure similar
software on your own computer).

You must also register a command supplier:

(Again if you are creating a version of the software on your own computer, you will have
additional work to do. There is a file NetBeansCommandSupplier.php (or something like
that) among your NetBeans IDE files; this has to be copied to the directory with the Zend
PHP files.)
You should now create a new PHP project, this time specifying the use of the Zend
framework.

NetBeans will run Zends script and create a project with the elaborate structure required by
Zend, along with a few files. This project directory is created in your public_html directory.

The Zend install script actually gives you a running application one that displays an
advertisement for the framework:
(Note the URL - ~youruserid/Projectname/public. It runs the index.php script there. This
odd URL relates to the simple way of setting up Zend. The proper way to setup Zend
involves many additional steps creating virtual hosts in your Apache, modifying DNS
records, reconfiguring browsers and proxies.)

You edit the files of the script generated application to create your own application.

Initially, just change the default output. This is defined in the file application/views/
scripts/index/index.phtml.
 It has the same role as a Smarty template. As initially generated it has a CSS style section
and the HTML with the links back to Zend that produce the output shown above.

Change it to something like:

This should result in an advert free starting page.

Another thing that you should do at this point is add extra information to the .htaccess file
that Zend generated (the one with the rewrite rules for Apache). This change relates to the
simple way of configuring Zend. There has to be a line specifying where the Zend projects
public directory is relative to your public_html directory:

Add a RewriteBase entry:

2.8 Zend handles babynames
Your Zend installation needs a few more tests to check that all is working correctly, so create
another version of the babynames application.

The default output from your updated babynames Zend application should be a HTML page
showing the babynames records from your MySQL database.

This will involve:

1. Adding a database adapter to your project. Details of your database, password etc
should be added to the application/configs/application.ini file. This can be done using
a Zend command script (in NetBeans, this works with dialogs). Most commands are
best done using the scripts and dialogs but it is actually easier to just edit the
application.ini file when adding an adapter.

2. Create a model with a data table class related to the babynames table in the
database. (Should definitely be done using the Zend script).

3. Modifying the code of the indexAction method in the indexController to use a

data table object to retrieve the data. (Does this sound confusing? Just magical
incantations? Of course. But all will be explained in lectures.)

4. Changing the index.phtml view template to output the data.

In NetBeans, you can run Zend commands by right-clicking the project and selecting
Zend/Run Command.
The configure db-adapter command can be used; you must specify host, adapter, port,
username, etc. It is easier to copy and paste the information directly into the application.ini
file!

This specifies use of the PDO_MYSQL. The host is localhost etc. (Create appropriate
resource.db.* entries for username and password).
Next create a Zend db-table class (and the rest of the model). Here, you should use the
Zend command and its NetBeans dialog:

You pick a name for the class BabynamesTable and identify the table babynames.

The Zend script creates a set of directories for the model and a file with the class definition:

This is the class used to access the table:

No code?

Magic?

Of course it is a form of magic it is an auto-generated Object-Relational-Mapping class.

All details of accessing the table and retrieving data will be handled for you.

Our new application is to use an instance of this class to retrieve the data from the babynames
table as part of its default indexAction of the IndexController.

The auto-generated code will have an empty body for indexAction(), i.e.
public function indexAction()
{
}

Replace the empty body for indexAction. We want to create a table access object. Then use
it to retrieve all records. We add these to the associated view (very similar to passing the data
to a Smarty object).
We also have to edit the view object (that index.phtml file again). Zend uses standard PHP
for scripting (it doesnt have a special view scripting language like Smarty):

It should run:
2.9 Configuring admin and users for Glassfish
You can leave this part of the exercise until you are about to start Assignment 5.

Connect to the administrator console for your Glassfish server (this is a right-click option on
your server in the Service/servers tab in NetBeans):

You need to configure the admin-realm and later, when adding users and roles for
authentication and authorization, you need to configure the file-realm.
These are both parts of the Configurations/server-config/Security section of common tasks.

You will need the Manage Users option in this section:

There should be an existing entry in the users for admin create a new entry with a
password for your userid and set passwords:
Logout from the admin console, then log back in using an account with a password:

While logged in as an administrator, create some users in the file-realm.

With an application server like glassfish, user authentication and authorization is handled by
the server not by the individual applications.

With GlassFish, you have users and groups (for authentication), and roles (for authorization).
The authentication data are configured using the admin console of the server. Roles tend to
be application specific. When creating an application you specify the roles, and provide a
mapping between roles and users/groups.

Group names should be chosen to be meaningful but that is kind of organization dependent
so here Im just going to use group1 etc.

Select the security/file realm option, then pick manage users and create users, making them
members of various groups:

You should create a few users assigned to various combinations of groups. (In a real world
context, the groups would be things like developer, manager, tech-support, privileged
user, user).
Those users and groups will get referenced in a later example where restrictions are placed on
the use of web applications.
2.10 Checking database access from Java
You can probably omit this task and get straight on with the web-application in the next
section. But it could help identify configuration problems if there are any.

The task is to use database drivers from a Java Standard Edition application (command line
Java program). Create a new project in your NetBeans projects directory a Java SE project.

Add the database driver code. MySQL is considered standard, so you use Add Library and
pick an entry for the list. If you were to use a different database such as Oracle, you would
use Add Jar file and find the .jar file with the database driver.
It should run:
2.11 A babynames servlet
What else?

In Netbeans, create another Java Web Application Babynames. NetBeans creates the
project with an empty index.html page (well that depends on version of NetBeans, some
versions create an empty index.jsp). In more complex cases, you will discard this; but for
simple applications you can use it as a Welcome page that will provide links to servlets and
JSP pages.

All code for servlets (and JSPs) must be part of defined packages, and not in the default
package. So, your first task is to add a new Java package e.g. mystuff.
Then, add a servlet to the project, making its code part of the new package.

Servlets require deployment data that are used by the application engine Glassfish, Tomcat,
Oracle Application Server etc. Traditionally, all deployment data were held in a web.xml
file. Since Servlets 3, an alternative scheme has existed where deployment data are defined
in annotations in the source code. The annotations approach is supposedly easier for the
developer (I havent found it that helpful) while the web.xml approach is better for
production environments. When you create a servlet, you have the option of adding its
details to web.xml select this for now (you can try the annotations approach some other
time).
NetBeans generates an outline for your servlet.

This generated outline has definitions for doGet() and doPost() (the methods that you are
most likely to need for the typical servlet). The code supplied for both methods invokes a
NetBeans defined processRequest() function that prints some predefined text when either Get
or Post is invoked. This processRequest function exists simply to help you test whether the
servlet system has been set up correctly (its code shows how to open and write to the servlet
output stream a useful model that you can copy into your own functions). Once you have
tested the setup, you should remove processRequest() and define effective methods for doGet
(get a form) and doPost (process a submission).

It is best to start by running a quick test using this default processRequest() function. This
lets you confirm that you can successfully deploy the web application.

Edit the index.html page so that it will display some content including a link that can be used
to activate the servlet:
If you right-click on the project and select run, NetBeans will deploy the web app (if not
already deployed) and cause the default browser to open the index.html file in the project.

Use the link, you should get the output from supplied processRequest() function:
Next edit the servlet to include some real code!

You should remove the editor fold, and define meaningful methods for doGet(), doPost(),
and getServletInfo().

Remove the doPost method entirely (an attempt to post to this servlet will then fail,
generating a standard error response). Copy the content of processRequest into doGet and
remove the processRequest function.
Copy code from your database checking exercise into the revised doGet function:
NetBeans will help sort out the includes just right-click in the editing window and pick
the fix up include files option. There could be several Java classes with the same name,
e.g. Statement NetBeans offers a list, it is your responsibility to pick the right one:
Add the MySQL driver to the project!

Run:
I had enabled the HTTP Monitor for my glassfish, so I got a log of the requests:
2.12 Application engine applied access control
The application of security constraints can be illustrated by restricting access to the
babynames servlet to a subset of the users defined earlier.

Part of this security configuration is common to all servlet environments, and part is
implementation specific. The common part defines roles and privileges you specify the
roles allowed access to the servlet (you can be more specific and define things like GET
being available to two roles, POST only available to one). The implementation specific part
is the bit that maps users (or groups) to roles this is implementation specific because
obviously Glassfish stores its user data differently from Tomcat or the Oracle Web Server.

You can refine things further by having the code of the servlet check the role of the current
user. This is illustrated in the worker/manager/boss servlet example in the lectures. There
any worker (and managers are themselves workers) can use a servlet that lets them see the
number of hours that they have recorded as working; but when used by a manager, the same
servlet allows that manager to also view the hours worked by any of the people that he or she
manages. The babynames application doesnt require such refinements.

Select the projects web.xml file and pick the security tab:

There are several sections in the security tab.

First you must select the Login Configuration. We will normally use Form
Configuration but for this baby example we run with Basic. Basic simply uses the
realm prompt in the browser to get name and password. This is OK for a test, but shouldnt
be used in a real environment where all logins should be customised.

The Realm name has to be supplied it will appear in the login dialog presented by the
browser.

Next add a security role along with a description. Parents-to-be are the ones likely to be
interested in babynames so have a role newparent.

Then add some constraints. What is constrained? Access to all methods of the babynames
servlet:

What kind of constraint? An authentication constraint access only allowed to persons

authenticated to be in the newparent role.
(The user data constraint allows you to specify extras like use of SSL or message digests to
increase the security of communications.)

Its worth looking at the source of the web.xml file to see how these constraints are actually
expressed.

Once the generic controls have been defined, you must set up the implementation specific
controls. Select the project and pick New File/Other. The new file has to be a Glassfish
descriptor:
Need to add a Security constraint to the glassfish-web.xml file:

This constraint essential says that persons in group1 can take the role of newparent and use
this servlet.

Redeploy the web application and restart your browser. When you attempt to access the
servlet you should see a standard browser challenge for name and password:
If you use the name and password of a person not in group1, you will get a rejection
response. (It seems that it leaves a logged in as cookie on your browser that prevents
you from trying again. You have to restart your browser to try with another user name.)

Restart your browser and enter the name and password of a group1 member:

You should once again be able to see the names:

2.13 Customised login form
Basic authorization, using the browser dialog for access to a realm, is only for
development tests. A real application should have at least form authorization with a
customized login page.

This page obviously should use site-wide styling from CSS stylesheets, and be customized to
the organisation. But it also has to follow a standard structure defined by the servlet
specifications. The name and password fields must have specific names and its action is to
post to a built-in component within the application server.

The security checked babynames application can be extended with a minimal version of the
required form and login pages.

Add HTML pages loginpage.html and errorpage.html to the project.

Then re-configure the login section of the web.xml file:
An attempt to access the servlet will now bring up the login page (which obviously needs
prettying):

If an invalid user-name/password combination is entered, the error page gets displayed:

But if the user-name and password correspond to a user who does not have the right to access
the resource the standard HTTP access denied response gets sent:
2.13 Using a DataSource
The direct use of a JDBC driver to connect to a database was deprecated years ago. (Of
course, most of us still do things that way.) Instead you are supposed to use a DataSource.

A DataSource is an initialized object that contains the information needed to connect to a

database which driver, what URL, which user, what password etc. Your program is
supposed to load in a DataSource object and ask it for the connection.

But this means that somehow you have to

1. create an instance of a DataSource object with all the right data;

2. Store it somewhere in the filespace;

3. Have your program load this object from filespace.

This is a little inconvenient if you are writing a simple stand-alone Java SE application. But
it isnt too difficult if you are using servlets deployed into an application server. In addition,
the current environments are likely to work with a connection pool so you get a reusable
connection. When you dutifully close a reusable connection, it goes back into the pool. This
can improve performance as database connections are not being repeatedly opened and
closed.

An environment like NetBeans can provide a wizard that helps you build a valid
DataSource object for your chosen database. The Glassfish server provides facilities for
storing such objects and retrieving them by name.

So the next improvement to the babynames project should be use of a DataSource.

Add a new Glassfish/JDBC Resource to the Babynames project:

You have to give the resource a name; something like jdbc/localmysql

NetBeans can correctly initialize such a resource using data from the database connections
that you previously created.
The details of the new DataSource object will be stored in Glassfish when you next deploy
the application.
You must rewrite the code to use the DataSource rather than a JDBC driver when getting a
connection:
The revised program should work.
2.14 Using Java Persistence (JPA)
Create a new Java Web Project Babynames2; add a Java package (mystuff).

This version of the project will need to use a library that implements the JPA specification.
There are now several versions available; the versions from the Hibernate project or the
Eclipse project seem to be those preferred for use with Glassfish 3.

You need to add a JPA implementation library to the libraries for the Babynames2 project
(this is Add Library rather than Add JAR/Folder). You will need a JPA implementation
library and also the Persistence Library.

Then you will want NetBeans to generate an entity class based on the meta-data that the
database has describing its tables:

In the dialog, select the datasource use your MySQL data source.
NetBeans will retrieve the meta-data on all your tables and list them as Available Tables (if
an entry is greyed out, it is a table without a primary key). Pick the table and add it to the
Selected Tables (NetBeans will use foreign key relations and identify any related tables
that would also have to be added obviously there are none for the babynames example).

NetBeans generates an EntityClass which is a simple Java class with fields for the different
columns in the database, get/set access/mutator methods for the fields, and a few extra
methods like toString(). The MySQL meta-data is easy to interpret and NetBeans has been
able to pick up the fact that the babynames table has an auto-increment primary key field.
You usually change the generated implementation of toString to one that gives a string with
summary data about the record (more than just the primary key):
NetBeans has also created some NamedQuery objects that embody simple queries (these
are expressed in the Java Persistence Query Language which is similar to but not identical to
SQL).

At run-time, the code is going to need the data that specify that this record is in your MySQL
database. These data are created in a persistence.xml file associated with the project.
NetBeans will offer to create this at the same time as you create the entity classes from the
database (or you can create it at a later stage). The persistence.xml file contains an identifier
that will be used later in the program when it needs use the configuration data.

Note the Table Generation Strategies you will usually have already created the tables and
filled them with data so you will want None. If creating the persistence.xml file manually,
you will need to specify the Persistence Provider and the data source.

By default it will include the Entity Classes that are defined in the project. (In more complex
examples, the entity classes may well be part of a separate Java library project in that
case you have to add them manually.) You should note the Persistence Unit Name.

Use NetBeans to create a new BabynamesServlet as before remove doPost() and

processRequest() and edit doGet().
This BabynamesServlet will be using a connection to a database as defined in the
persistence.xml file. Here, code injection is being used. (Code injection is another form
of magic that will be explained in the lectures!).

The servlet will need to use an EntityManager to handle its connection to a database and
the storage and retrieval of entities. (EntityManagers are not thread safe so they are created
as local variables of functions therefore in thread storage). EntityManagers are created
using an EntityManagerFactory which interprets the persistence.xml file. An
EntityManagerFactory is thread safe and should be created as an instance member of the
servlet. The @PersistenceUnit annotation provides a mechanism for automatically
initializing the EntityManagerFactory with data defining a particular persistence unit the
one whose name you remembered earlier in the persistence.xml file.

The new version of doGet()

1. uses the factory to create an EntityManager

2. uses the EntityManager to create an instance of the findAll NamedQuery

3. uses this query to retrieve a collection of matching records

4. loops through the records generating HTML markup

(It is all much tidier and simpler than the code using JDBC connections, statements, resultsets
etc.)

Many libraries will need to be imported for Query, List etc. Pick the appropriate ones (there
are at least 5 different List classes to choose from).
If you look at the project, you will see that numerous .jar files have been added to support
Persistence and JPA implementation:

You will need a index.html file to invoke this new sevlet (note that servlet name is the same
as that earlier that is ok as they exist in different projects, they can both be deployed onto
the same server without confusion).

It should run:
2.15 Using Java Server Pages (JSPs) to display results
Those out.println() statements in servlets are so clumsy they are like echo statements
scattered though a PHP script. JSPs were invented long ago (~1999) to provide a better
approach to dynamic content presentation.

It is possible to do the actual work of an application in a JSP, possible but really not that
convenient. Servlets and helper classes provide a better environment for coding issues.
Although JSPs are intended to be more general, it is easiest if you simply use them in the
same way as you used Smarty templates with PHP.

The overall approach is very similar to PHP+Smarty. Work is done in the servlet. Results
are collected. The servlet passes the collections of results to a JSP (just as a PHP script
passed its results to a Smarty object). The JSP has standard markup along with sections that
extract required data from the result objects and slot them into HTML constructs.

Originally, JSPs had HTML markup and static text with the dynamic content created by little
fragments of embedded Java code (scriptlets). The style was similar to the contemporary
approaches like ASP and PHP. Subsequently, embedded Java was deprecated. Instead,
dynamic data were displayed using XML like action tags. These action tags are really a bit
like macros small parameterized templates that get expanded to much more code. Tag
libraries exist with different sets of macros that permit different ways of selecting result data
and incorporating them into the HTML page. We will be using only the Java Standard Tag
Library JSTL.

You will need a new Java Web Project Babynames3. This will have a servlet that retrieves
all names from one of the databases (using JPA). The servlet will forward the collection of
names to a JSP. The JSP will create the report page using JSTL action tags to format the
dynamic parts of the response page.
Babynames3 project:

1. Create the project

2. Add the EclipseLink persistence library

3. Add a persistence.xml file specifying use of a MySQL connection.

4. Create a Babynames entity class from the table in your MySQL database.

5. Add a Babynames servlet; take the definitions from the last example as the starting
point (a doGet method using an EntityManagerFactory to create an EntityManager
etc)

Add the JSTL library to the project:

Add a JSP:
Just get a standard JSP in default location (WebPages).

NetBeans generates the JSP with the standard Hello World content:

Edit the servlet. Its code can be simplified. It just retrieves the records, adds the record
collection to the request, and forwards everything to the DisplayResults.jsp.
Define the JSP:

Note:

1. Its using the JSTL tag library (actually, just the core module of JSTL) so add the
taglib annotation.

2. Its generating a list; the list delimiters <ul> and </ul> can be put into the text.

3. It is to loop through the collection of results outputting each as an item in the HTML
list; so it uses the forEach action from the JSTL core module (c:forEach).

4. This forEach loop needs a working variable name it record.

5. The forEach loop is working with the forwarded collection of name records; it is
going to find them attached as the extra attribute babynamelist on the request object
this is specified by the expression ${requestScope.babynamelist}. (The expression
language used is derived from Javascript.)

6. Each record will have a name member and a gender member. These should be
output using the out action defined in the JSTL core.

It should work:
(If you have a problem deploying e.g. complaints about wrong class for mysql driver, it
might be due to glassfish tidying up and removing the datasource definition that you added in
step 2.13. Redeploy that project again, or add a similar datasource definition to the current
project.)

End
When you have completed all those steps you should have experienced most of the
technologies that will be used in this years version of CSCI399.