1 Lecture 18 George Koutsogiannakis/Spring 2011 CS441 CURRENT TOPICS IN PROGRAMMING LANGUAGES.

1

Lecture 18George 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 dataCustomer Table FieldsQuery

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 MyTestDBType a User Name i.e georgeType a Password i.e georgeClick O.K.

Two things will take place1.The DB server for Derby should be activated2.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


• 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 SourceCREATE 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 SourceINSERT 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 SourceINSERT 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 SourceINSERT 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


• 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


• 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 withThe 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


• 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


• 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 exampleproject


• 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


• 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


• 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


• 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


• @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


• 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:@Statefulpublic 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 Beantry { 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


• 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


• 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


• 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


• 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

Date post:	23-Dec-2015
Category:	Documents
Upload:	hollie-hunt
View:	214 times
Download:	0 times