Lecture 18

farrightΛογισμικό & κατασκευή λογ/κού

15 Αυγ 2012 (πριν από 5 χρόνια και 3 μήνες)

334 εμφανίσεις

1

Lecture 18

George
Koutsogiannakis
/Spring 2011

CS441


CURRENT TOPICS IN
PROGRAMMING LANGUAGES

Topics


Registering a database with the IDE.


Creating a Derby Data Source.


Create Tables with SQL scripting.


Create Tables using a Dialog Box.


Building a Persistence Unit with NetBeans.


Web Tier Persistence.


EJB Tier Persistence.

2

Databases


NetBeans comes with Derby database (visible
in the services window).


New databases ( i.e. MySQL, Oracle etc) can be
added but they need to register with the IDE.


Once a database is registered, a data source or
connection can be created or a connection to
an existing data source can be opened.


Once the data source is created a Persistence
Unit can be created.

3

Java DB (Derby)


The Java DB database is Sun's supported
distribution of the open source Apache Derby
database.


Java DB is a fully transactional, secure,
standards
-
based database server, written fully
in the Java programming language, and fully
supports SQL, JDBC API, and Java EE
technology.

4

Java DB (Derby)


The Java DB database server is bundled with
the Sun Java System Application
Server/Glassfish.



If you install the Sun Java Application
Server/GlassFish during the IDE installation,
the Java DB database server is automatically
registered in the IDE.



5

Registering A Data Source


First make sure that the proper drivers are
registered with the IDE.


In services window expand the database node and
then expand the drivers node.


Next, you need to register a connection to your
data source:



6

7

Drivers

Sample databases


Under Services you will see the
Java DB
node


You can right click on the name and choose
start server
to start the database server.



Example of using Derby can be found in


http://netbeans.org/kb/docs/ide/java
-
db.html

8

Sample databases


At least two sample databases are available


You can click on the node of the sample
database:jdbc:derby//localhost:1527/sample[
app on API] and expand it to see the tables of
the database and their fields :


Right click on the node and click on connect


Then right click on a table’ s name and choose
view data

9

10

Table Customer data

Customer Table Fields

Query

Registering A Data Source
-
Creating
a connection


Right
-
click the Databases node and choose
New Connection
.
Alternatively, expand the Drivers node, right
-
click your driver's
instance node and choose
Connect Using
.


Provide the JDBC database URL for the database connection in
the Database URL field.


This URL typically begins with jdbc:and a short code name for the
driver, followed by another colon. The rest of the URL depends on the
type of driver you are using. For example, you might need to specify a
host and port; alternatively, the name of a database file might suffice,
or an ODBC DSN.


For MySQL, the Database URL might look as follows:


jdbc:mysql://localhost:3306/mydatabase


11

Registering A Data Source
-
Creating
a connection


Provide the user name and password, if required by your
database configuration.



Click OK to create the database connection and connect to
the database from the IDE.


To disconnect from the database:



Right
-
click the database connection node and choose
Disconnect.



12

Connecting to a database


After you create the database connection you
can do the following:


Disconnect and reconnect to the database


Browse the database structure


View data contained in a table in the database


13

Creating A Data Source


A database needs to be registered with
NetBeans.


Notice that a number of data sources can be
part of the domain of the application.


Each database needs to be registered with a
separate JNDI name.


For example, a database name MyDatabase, specify
jdbc/MyDatabase as the JNDI name.


14

Creating A Data Source


Specify a table generation strategy for your database.


Click Finish.


When you click Finish, the file persistence.xml opens in the
Source Editor.


In the IDE, you can find persistence.xml in the Projects
window under the Configuration Files node. In the Files
window, persistence.xml is located in the src/conf directory.


When packaged, persistence.xml is located in the META
-
INF
directory of an EJB JAR file or the WEB
-
INF/classes directory of
a WAR file



15

Creating A Derby Data Source

16


In services window right click on databases and choose create database


In the Create Java DB Database Window:

Type a name for the database
i.e

MyTestDB

Type a User Name
i.e

george

Type a Password
i.e

george

Click O.K.



Two things will take place

1.
The DB server for Derby should be activated

2.
The new database name should appear under databases node in



services window

First of course the database needs to be created outside the IDE.

17

Creating A Derby Data Source


Right
-
click the MyTestDB node and choose Connect.


If the Connect dialog box appears, type the password that you
have set for the database server.



If the Advanced tab of the dialog box opens, click OK to close the
dialog box.
--
> Scroll down to the node for connection that you have
just created. The node should have the icon.


Right
-
click the connection node and choose Execute
Command.


In the editor part of the IDE type the SQL script to create the
tables of the database :


A sample script is given on the next slides:

18

Creating A Derby Data Source

CREATE TABLE WEB_BOOKSTORE_BOOKS

(bookId VARCHAR(8),

surname VARCHAR(24),

firstName VARCHAR(24),

title VARCHAR(96),

price FLOAT,

onSale SMALLINT,

calendar_year INT,

description VARCHAR(30),

inventory INT)

PRIMARY KEY (bookId)

);


19

Creating A Derby Data Source

INSERT INTO WEB_BOOKSTORE_BOOKS VALUES('201', 'Duke', '',



'My Early Years: Growing up on *7',



30.75, 0, 1995, 'What a cool book.', 20);


INSERT INTO WEB_BOOKSTORE_BOOKS VALUES('202', 'Jeeves', '',



'Web Servers for Fun and Profit', 40.75, 1,


2000, 'What a cool book.', 20);


INSERT INTO WEB_BOOKSTORE_BOOKS VALUES('203', 'Masterson', 'Webster',



'Web Components for Web Developers',



27.75, 0, 2000, 'What a cool book.', 20);



20

Creating A Derby Data Source

INSERT INTO WEB_BOOKSTORE_BOOKS VALUES('205', 'Novation', 'Kevin',



'From Oak to Java: The Revolution of a Language',


10.75, 1, 1998, 'What a cool book.', 20);


INSERT INTO WEB_BOOKSTORE_BOOKS VALUES('206', 'Gosling', 'James',



'Java Intermediate Bytecodes', 30.95, 1,


2000, 'What a cool book.', 20);


INSERT INTO WEB_BOOKSTORE_BOOKS VALUES('207', 'Thrilled', 'Ben',


'The Green Project: Programming for Consumer Devices',


30.00, 1, 1998, 'What a cool book', 20);



21

Creating A Derby Data Source

INSERT INTO WEB_BOOKSTORE_BOOKS VALUES('208', 'Tru', 'Itzal',


'Duke: A Biography of the Java Evangelist',


45.00, 0, 2001, 'What a cool book.', 20);


22

23

Creating A Derby Data Source


Next we need to run the script:


Click the Run SQL button () in the toolbar of the Source
Editor to run the script. Output of the script should appear
in the Output window.


Right
-
click the connection node of the database and choose
refresh.


Expand the node, and expand its Tables subnode. You
should see the database tables created.


In the properties window you should have a view of the
properties of the table.


24

25

Creating A Derby Data Source


The data sources are located in C:
\
Documents and
Settings
\
George
\
.netbeans
-
derby on my machine.


You can discover the location of your Derby data sources by
right clicking on JavaDB (services window) and choosing
properties
.


By default, the IDE creates the database in the .netbeans
-
derby folder of your home directory.


To change the default location, click Properties in the Create
Java DB Database dialog box, or in the Services window, right
-
click the Java DB node and choose Properties. Type the new
database location in the appropriate field.


26

View Table Data


To view Table data expand the Data Source
node


Expand the Tables node


Right click on the name of the Table and choose
view data.


The Table data can be viewed as in the next slide:

27

28

Using the Create Table Dialog


We can create a Table via a dialog box without having
to write the SQL statements:


This dialog box appears when you right
-
click a database's Tables node
in the Services window and choose Create Table. Using this dialog box,
you can create a table, add columns, specify parameters for columns,
and select an owner for the table.


The Create Table dialog opens.


In the Table name text field, type the name of the Table


In the first row displayed, select the Key check box.



You are specifying the primary key for your table. All tables found in relational
databases must contain a primary key.


29

Using the Create Table Dialog


Note that when you select the Key check box, the Index and Unique
check boxes are also automatically selected and the Null check box is
deselected. This is because primary keys are used to identify a
unique row in the database, and by default form the table index.
Because all rows need to be identified, primary keys cannot contain a
Null value.


For Column Name, enter id for example. For Data Type, choose
SMALLINT for example from the drop
-
down list, then click the Add
Column button
.


Keep repeating the procedure adding columns and their data types.


Check.

When the check box is selected, the IDE performs a
check of the column to determine if it meets the required
criteria.


30

Web Client for a Data Source

31

We can create a simple web client that communicates with

The Database Server where the Data Source is deployed

(Derby) .


Web Client for a Data Source


Data that is shared between web components
and is persistent between invocations of a
web application is usually maintained by a
database.


Web components use the Java Persistence API
(JPA) to access relational databases.

32

Persistence Unit


A Persistence Unit is a collection of entities (data
tables) that are managed together.


A Persistence Unit specifies some or all of:


Persistence provider name i.e.
xmlsn=“http://java.sun.com/xml/ns/persistence


Persistence Unit name i.e. name=OnlineStore


Entity class names i.e. org.com.Orders


Database connection URL


Driver


User and password


The type of Entity Manager Object


Other properties of a data source.


33

Persistence Unit


The information about the Persistence Unit is
kept in the descriptor file
persistence.xml


An Entity Manager object needs to be created
that will manage the persistence unit created.

34

Persistence.xml


<persistence> <persistence
-
unit name="OrderManagement">
<description>This unit manages orders and customers. It does not rely on
any vendor
-
specific features and can therefore be deployed to any
persistence provider. </description>


<jta
-
data
-
source>jdbc/MyOrderDB</jta
-
data
-
source>


<jar
-
file>MyOrderApp.jar</jar
-
file>


<class>com.widgets.Order</class>


<class>com.widgets.Customer</class> </persistence
-
unit>
</persistence>

35


Building a Persistence Unit with
NetBeans


1.
Let us create a new project in NetBeans. Under categories
choose Enterprise Application. Allow for ejb and web
applications inside the Enterprise Application.



Let us name the project
ExampleEnterpiseApplication


Follow the steps in the next slide to create a persistence
unit within either the web application or the ejb
application of the Enterprise Application project.



36


Building a Persistence Unit with
NetBeans



To create a persistence unit (from NetBeans IDE):



In the Projects window, right
-
click a web or EJB module
project node
and choose New > Other.


Select Persistence Unit in the Persistence category and click
Next.


Specify a unique Persistence Unit Name. In most cases you
can keep the default name suggested by the IDE.


Select a persistence provider or library from the drop
-
down
menu, or add a new library by choosing New Persistence
Library. Notice that a number of choice providers are shown
including CODO (openSource JPA).

37

Building a Persistence Unit with
NetBeans


Select a data source from the drop
-
down menu. The data
source can be a JDBC connection or a database connection. To
appear in the list, the data source needs to be registered with
the IDE.


Select Use Java Transaction APIs if you want the container to
manage the entities.


Java Transaction APIs are only available if you are
deploying to a Java EE 5 or EE6 container. If you are not
deploying to a Java EE 5 or EE6 container, the transaction
needs to be managed by the application. For more, see
Transaction Types.

38

39

40

Sample data source is chosen for the

example

Ejb module of the example

project

Building a Persistence Unit with
NetBeans


When we click finish the persistence.xml file is
added to the ejb module part of the project.


Right clicking and choosing edit displays the
contents of the file on the editor section of
NetBeans

41

42

Persistence.xml

Persistence Unit name and

Other information

43

44

Double clicking on the persistence.xml file can allow us to view

properties of the file in a graphical type of a presentation. You can change

data source, add/delete entity classes etc.

Web Tier Management of JPA


Data shared between web components that needs to be
persistent, between invocations by the client, needs to be
stored in a data source.


In Web Tier management we will use the JPA from the web
tier (the web server)


Suppose we have a data source created named Books with a
single Table named WEB_BOOKSTORE_BOOKS already
populated (from Java EE5 Tutorial).

45

Web Tier Management of JPA


We need to create a Persistence Unit.


It identifies the schema


The name of the Persistence Unit and the
transaction type


A jta
-
data
-
source element to indicate JTA
transactions container managed.


We need to create an entity class to represent
eachTable in the database.


46

Web Tier Management of JPA


Entity classes.

Entity classes are used to represent tables in a
database. The Java Persistence API enables you to use entity
classes directly in your web application.


Entity Manager.

An entity manager manages the entities and
performs database functions.


Persistence Unit.

A persistence unit specifies the data source
and which entities are managed by the entity manager.


47

Web Tier Management of JPA


About Entity Classes


Each entity class usually represents a table in a relational database.


Each instance of an entity corresponds to a row in a table.


Persistent fields or properties correspond to columns in a table.



Unlike entity beans, entity classes are not restricted to EJB modules in
enterprise applications. Entity classes can be located in an EJB module
or
a web module
.


48

Web Tier Management of JPA


@Entity


@Table(name = "WEB_BOOKSTORE_BOOKS")


public class Book implements Serializable {



@Id


private String bookId;



private String description;



private String firstName;



private String surname;



private String title;



private boolean onSale;


………………………………………….


……………………………………………


//constructors and accessor/mutator methods

49

Web Tier Management of JPA


A class BookDB has set and get methods that allow access to
Books.


An Application Object of BookDB needs to have access to an
Entity Manager object.


The only way to do that is to have a ServletContextListener
subclass create the EntityManagerFactory object and pass it
to BookDBAO object.


This is called
resource injection
. Its intend is to have the web container
manage the entity bean (which normally is done by the applications
server’s container) .

50

EJB Tier Management of JPA


In this case we will have:



A client application (a web application) that
communicates with a Session Bean.


The Session Bean carries the Business logic and
communicates with the entities.


The entities that persist the data.


Data source.

51

EJB Tier Management of JPA


We can create two applications:


One that holds the session bean and the entities.


One that holds the client application.


It populates the entities with data, retrieves data and
displays it.


Opening the
Order project (available on the
EE5 Tutorial text CD or the course’s web site
javaeetutorial5.zip )
and expanding it we get:

52

53

General Project Files

Client Related Files

Remote Interface for Session Bean

Entity Source files

Session Bean Files

Client


Client is annotated to work with the Session Bean:


public class OrderClient {


@EJB


The client creates data and then displays it by getting it back from the data
source:

public static void main(String[] args) {


OrderClient client = new OrderClient(args);


try {


client.createData();


client.printData();


} catch (Exception ex) {……….}


}

54

Client


For example, method createData in Client does operations to
populate the data source tables i.e. :

private static void createData() {


try {


request.createPart(


"1234
-
5678
-
01",


1,


"ABC PART",


new java.util.Date(),


"PARTQWERTYUIOPASXDCFVGBHNJMKL",


null);

Where request is a reference of the interface Request and createPart is one of the
methods implemented by the Session Bean: RequestBean


55

Session Bean


The Session Bean implements the method createPart:

@Stateful

public class RequestBean implements Request {


@PersistenceContext


private EntityManager em;


public void createPart
(


String partNumber,


int revision,


String description,


java.util.Date revisionDate,


String specification,


Serializable drawing) {



56

Session Bean

try {


Part part = new Part(


partNumber,


revision,


description,


revisionDate,


specification,


drawing);


em.persist(part);

………………………………..

Where Part is one of the entities and em is the Entity Manager object.

57

Entity Part

@Entity

@Table(name = "EJB_ORDER_PART")

@SecondaryTable(name = "EJB_ORDER_PART_DETAIL", pkJoinColumns =

{


@PrimaryKeyJoinColumn(name = "PARTNUMBER",
referencedColumnName = "PARTNUMBER") ,
@PrimaryKeyJoinColumn(name = "REVISION", referencedColumnName =
"REVISION")

}

)


58

Summary


Create Persistence Unit


Create the Entity Classes defined in the
persistence unit’ s descriptor file
persistence.xml


Obtain access to an Entity Manager object


Access data in database by writing the proper
SQL queries in client units to the database.


59

Creating Entity Classes from an
Existing Data Source


In addition to writing entity classes from
scratch, you can also generate a set of
persistent entity classes for an existing
database.


You can use the New Entity Classes from
Database wizard to generate the entity classes
from a connected database or from a
database schema.


60

Creating Entity Classes from an
Existing Data Source


To generate entity classes from a database:



Right
-
click the module project node in the
Projects window and choose New > Other.


In the New File wizard, select Entity Classes
from Database from the Persistence category.


Select the source database that contains the
tables that you want to use to generate the
entity classes:


61

Creating Entity Classes from an
Existing Data Source


To create from a connected data source


Data Source.

Choose a data source from the drop
-
down menu. Alternately, you can choose Add Data
Source to create a new data source. The database
must be running to choose this option.


When choosing a data source, the server must be
running and the data source must be registered with
the server.


After you select the source database, the tables in
that database are listed in the Available Tables pane.


62

Creating Entity Classes from an
Existing Data Source


Select any tables in the left pane and click the Add button.
Any tables related to the tables you select are automatically
added to the list in the right pane. The IDE will generate entity
classes for each table listed in the right pane.


Deselect Include Related Tables if you do not want entity classes
created for related tables.


Click Next.


Confirm the name of the classes that will be generated for
each table listed.


Select the location where you want to save the entity classes.


Select an existing package from the Package drop
-
down menu
or type the name of a new package.


63

Creating Entity Classes from an
Existing Data Source


Confirm that you want the IDE to generate named query
annotations in the entity classes. If you do not want the IDE to
generate the annotations, deselect Generate Named Query
Annotations for Persistent Fields.


Click Finish.


When you click Finish, the IDE creates entity classes for each
of the tables you specified in the wizard. The package
containing the generated entity classes is selected in the
Projects window.


64

Study Guide


Read Chapter 25 of EE5 Tutorial.


Set up and run the bookstore example from the
CD


Read Chapter 26 of EE5 Tutorial.


Set up and run the Order and Roster examples
from the CD.

65