BlogJava-网路冷眼@BlogJava-文章分类-Java

Using Hibernate-specific features with JPA

网路冷眼@BlogJava — Mon, 07 May 2007 15:34:00 GMT

原文地址：http://wiki.netbeans.org/wiki/view/UsingHibernateWithJPA

Using Hibernate-specific features with JPA

The Java Persistence API offers a powerful standard for persisting POJOs.It includes all the most important features which you would expect from an object-relational mapping tool, but there are still some areas where you might need to use vendor-specific features. In this tutorial, we will show how to use Hibernate-specific features for validating and querying while using the standard API for the rest.

Prerequisites

This tutorial assumes you have some basic knowledge of, or programming experience with, the following technologies:

Java Server Faces
Java Persistence API.
NetBeans IDE

This tutorial is partly based on the Using Hibernate With Java Persistence API tutorial, you might want to go through it first.

Software Needed for the Tutorial

Before you begin, you need to install the following software on your computer:

NetBeans IDE 5.5.1 (download)
Sun Java System Application Server, Platform Edition 9 (download)
Hibernate Core 3.2.1.GA, Hibernate EntityManager 3.2.1.GA(download)

Setting up your Environment

First we will create a library in the IDE for the Hibernate entity manager.

Unzip the Hibernate JAR files to any temporary location
Choose Tools > Library Manager from the main menu. Click New Library, name the library Hibernate, and click OK.
In the Libraries pane of the Library Manager dialog box, select the Hibernate library you just created.
Click the Classpath tab and then click Add JAR/Folder and locate the following JAR files:

From Hibernate EntityManager:
- hibernate-entitymanager.jar
- lib/hibernate-annotations.jar
- lib/jboss-archive-browsing.jar
- lib/javassist.jar
From Hibernate Core:
- hibernate3.jar
- lib/antlr-2.7.6.jar
- lib/asm-attrs.jar
- lib/asm.jar
- lib/c3p0-0.9.0.jar
- lib/cglib-2.1.3.jar
- lib/commons-collections-2.1.1.jar
- lib/concurrent-1.3.2.jar
- lib/commons-logging-1.0.4.jar
- lib/dom4j-1.6.1.jar
- lib/ehcache-1.2.3.jar
- lib/log4j-1.2.11.jar

Creating a Web Application

Next we will create a web application with entity classes and a JSF interface. To speed up the process, we will use the CRUD generators in the IDE.

Choose File > New Project (Ctrl-Shift-N). Select Web Application from the Web category.
Name the project HibernateWithJPA, set the server to Sun Java System Application Server, the Java EE version to Java EE 5 and make sure that the Set Source Level to 1.5 checkbox is checked. Click Next.
Select the JavaServer Faces framework and click Finish.
Add the Hibernate library we created earliead to the project by right-clicking the project node and choosing Properties > Libraries > Add Library > Hibernate
In the Projects window, right-click the project node and choose New > Entity Classes from Database.
In the Data Source drop-down, select the jdbc/sample database. If prompted for a user name and password, use app and app. Select the CUSTOMER table from the list, click Add and then click Next. * Leave the tables and class names as their default, and set the package to sample.entities.
Now it is time to create the persistence unit. Click the Create Persistence Unit button. Accept the default name, select Hibernate as the persistence provider, and select None as the table generation strategy. Click OK.
Click Finish in the Entity Classes from Database wizard. The IDE creates the persistence unit (persistence.xml under Configuration Files node) and the entity classes (under Source Packages).
Set a correct SQL dialect for Hibernate. Double-click persistence.xml and click the XML button at the top of the editor to switch to the XML view. Add the following property to the persistence unit:

Coding the JSF Interface

Now we can quickly generate JSF pages for the entity classes with the NetBeans IDE CRUD generation.

Right-click the project node and choose New > JSF Pages from Entity Class. Add both Customer.java and DiscountCode.java to the list of selected classes and click Next.
Change the package to sample.controller and click Finish.

Testing the Project

At this point we will try to run the application and see whether everything is working as expected.

Right-click the project and choose Run Project. The IDE starts the application server, builds and deploys the application, and shows index.jsp in the external web browser.
Click the List of Customer link and you should see the following web page:

Use the New Customer link to create a customer

Adding validation

When creating a new customer you might have noticed that values were not validated before attempting to persist the newly created customer. We could use the validation facilities in JSF for ensuring that only correct values are inserted, but since this tutorial is about Hibernate we will instead demonstrate how to use the Hibernate validation framework. This approach has an additional advantage that the validation rules need to be specified only once even if another type of client is added.

Open Customer.java in the editor and add the following annotations on its member variables:

    @Column(name = "STATE")
@Length(min=2, max=2, message="not a valid state")
private String state;
@Column(name = "EMAIL")
@Email
private String email;

For simplicity's sake we will only add validation to state and email properties. The @Length annotation validates that the length of the property will be within the range specified by min and max attributes. We apply it on the state property to make sure that it is exactly 2 characters long. We also specify a value for the message attribute, it will be the shown error message when the validation fails. The @Email annotation in turn validates that the property represents a valid email address, as you might have guessed.

Now that we have our domain object annotated, we need to add handling of validation errors to our controller class. So open CustomerController.java and add the following method there:

    /**
* Validates the given customer.
* @return true if there were no validation errors, false otherwise.
*/
private boolean validate(Customer customer){
ClassValidator customerValidator = new ClassValidator(Customer.class);
// get the invalid values
InvalidValue[] msgs = customerValidator.getInvalidValues(customer);
if (msgs.length > 0){
for(InvalidValue msg : msgs){
// add an error message for each invalid value, these
// messages will be shown to the user
addErrorMessage(msg.getMessage());
}
return false;
}
return true;
}

This method will first create a class validator for our Customer class and then process the validation rules we specified earlier when. We collect the invalid value messages and add each of them as error messages to the FacesContext (this is done by the addErrorMessage method). If there were no validation errors the will return true, false otherwise. Of course, as such this method is not very useful unless we invoke it in the right places. We probably want to validate the values both when a new customer is created and when an existing customer is edited. So let's first modify the create method to check whether there were any validation errors before attempting to persist:

    public String create() {
if (!validate(customer)){
// return to the input page if there were any validation errors
return null;
}
EntityManager em = getEntityManager();
try {
utx.begin();
em.joinTransaction();
em.persist(customer);
...

As you can see, we return null if any errors were found - this means JSF will display the same page again. Make a similar modification to the edit method as well and run the application. Try to create a new customer with an invalid email address and with a 3 characters long state code. This is what you should see:

Query by Example

While the Java Persistence QL is an impressive query language, there are cases when a different kind of API is more suitable. Luckily, in addition to JPQL support, Hibernate features a criteria query API which you can leverage for the cases it is needed and stick to the standard API elsewhere in the application. In the following example we will demonstrate the Query By Example approach using Hibernate's Criteria API.

First we need to create a new page for our new query functionality. Create a new page named Query.jsp in the customer folder and paste the following to it:

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<%@taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<%@taglib uri="http://java.sun.com/jsf/html" prefix="h" %>



Query By Example



Query By Example













Back to index

There are a couple of things to note here. Firstly, we have specified "stringConverter" converter for the input fields. Secondly, the 'search' link will try to execute customer.queryByExample method, which we haven't yet implemented. Thirdly, the data table uses customer.model as its underlying model. We will get back to these in a minute, but before that we still need to create a link to our new page. To keep things simple, we will just add it to the customer/List.jsp page, right after the link to the New Customer page:

Now, this link will cause querySetup method to be invoked in the CustomerController.java, so let's implement it next. To do that, add the following to the CustomerController.java:

   public String querySetup(){
this.customer = new Customer();
this.model = null;
return "customer_query";
}

And to complete the UI side of things, we still need to add a navigation rule to faces-config.xml:



customer_query
/customer/Query.jsp

What is still missing is the actual implementation of the query, and the converter we mentioned earlier. Let's tackle the implementation of the query method first. In the Query.jsp page we defined that the 'Search' link will invoke customer.queryByExample method and that customer.model will be used for the data table. To satisfy the latter, we just need to create a getter for the model in CustomerController.java - press ctrl-space and choose 'create getter getModel for field model'. After that, add the following method:

    /**
* Queries customers based on the values in our customer.
*/
public String queryByExample(){
// get the native hibernate session
Session session = (Session) getEntityManager().getDelegate();
// create an example from our customer, exclude all zero valued numeric properties
Example customerExample = Example.create(customer).excludeZeroes();
// create criteria based on the customer example
Criteria criteria = session.createCriteria(Customer.class).add(customerExample);
// perform the query and set the result to our model.
this.model = new ListDataModel(criteria.list());
return "customer_query";
}

You can see how easily you can access Hibernate's native API - just invoke getDelegate() on the entity manager and cast it to org.hibernate.Session. Once we have the access to Session we can take advantage of the Criteria API. In the above method we create an example criteria based on the customer and execute the query. If you are not familiar with the Criteria API, it is probably worth explaining a bit. By default, all null values will be excluded, which means that the properties on our customer that were null, will not be part of the criteria. In addition, we specify that all zero valued numeric properties will be excluded as well. Here it gets a bit complicated: since JSF by default converts strings without values to empty strings (instead of nulls), we need to create a special converter for dealing with the conversion of strings from the query page. The implementation of the converter is as simple as:

package sample.controller;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.convert.Converter;
/**
* A converter for string values that does not
* convert null values to empty strings.
*/
public class StringConverter implements Converter{
/** Creates a new instance of StringConverter */
public StringConverter() {
}
public Object getAsObject(FacesContext context, UIComponent component, String value) {
if(value == null || "".equals(value)){
return null;
}
return value;
}
public String getAsString(FacesContext context, UIComponent component, Object value) {
return value != null ? value.toString() : null;
}
}

Don't forget to register the converter in faces-config.xml:


stringConverter>
sample.controller.StringConverter

Finally, we are ready to run the application once again and test the new functionality:

Troubleshooting

In case you are using NetBeans 5.5 instead of 5.5.1, you might run into issue 90031, which causes silent failures when inserting data. The workaround is to upgrade to 5.5.1 or to manually add em.joinTransaction() after each call to utx.begin() in the generated controller classes.

Download the source code for this tutorial here

Attachments

HibernateWithJPA.zip		46352 bytes
jsf-from-entities.JPG		50178 bytes
list-of-customers.JPG		185621 bytes
not-valid-customer.JPG		32670 bytes
query-by-example.JPG		81683 bytes
query-by-example.PNG		152412 bytes
query-by-example.png		152355 bytes
jsf-from-entities.png		151411 bytes
list-of-customers.png		314586 bytes
not-valid-customer.png		84493 bytes

Front Page

Page Info My Prefs Log in

This page (revision-27) last changed on 09:13 16-Mar-2007 by Erno Mononen.

Referenced by:

网路冷眼@BlogJava 2007-05-07 23:34 发表评论

Using Hibernate with the Java Persistence API（转载）

网路冷眼@BlogJava — Mon, 07 May 2007 15:30:00 GMT

原文地址： http://testwww.netbeans.org/kb/articles/hibernate-javaee.html

Using Hibernate with the Java Persistence API

One of the main features of the new Java Persistence API that was introduced with the Java EE 5 platform is that you can plug in any persistence provider that you want. The Sun Java System Application Server 9 ships with Oracles's Toplink persistence provider. In this tutorial, we will install the Hibernate persistence provider on the application server and use it to develop a quick application that accesses a database with the Java Persistence API.

Software Required for this Tutorial

NetBeans IDE 5.5 (download)
Sun Java System Application Server, Platform Edition 9.0 (download)
Hibernate Core 3.2.2.GA and Hibernate EntityManager 3.2.1.GA (download)

Setting up your Environment

Before we start, we have to register the application server with the IDE and copy over the Hibernate JAR files to the application server's lib folder. We also have to create a library in the IDE for the Hibernate entity manager.

If the application server is not registered in the IDE, register it by choosing Tools > Server Manager and clicking the Add Server button. You can see all registered application servers by opening the Runtime window and expanding the Servers node.
Unzip the Hibernate JAR files to any temporary location and then copy the following JAR files to your application server's lib folder:
- From Hibernate EntityManager:
  - hibernate-entitymanager.jar
  - lib/hibernate-annotations.jar
  - lib/jboss-archive-browsing.jar
  - lib/javassist.jar
- From Hibernate Core
  - hibernate3.jar
  - lib/antlr-2.7.6.jar
  - lib/asm-attrs.jar
  - lib/asm.jar
  - lib/c3p0-0.9.0.jar
  - lib/cglib-2.1.3.jar
  - lib/commons-collections-2.1.1.jar
  - lib/commons-logging-1.0.4.jar
  - lib/concurrent-1.3.2.jar
  - lib/dom4j-1.6.1.jar
  - lib/ehcache-1.2.3.jar
  - lib/log4j-1.2.11.jar
Restart the server if it is running. You can restart the server by right-clicking its node in the Runtime window and choosing Restart.
Choose Tools > Library Manager from the main menu. Click New Library, name the library Hibernate, and click OK.
In the Libraries pane of the Library Manager dialog box, select the Hibernate library you just created. Click the Classpath tab and then click Add JAR/Folder and locate the hibernate-entitymanager.jar and javaee.jar in your application server's lib folder. Click Add JAR / Folder and then click OK.

Creating the Entity Classes and Persistence Unit

Now that we have added the Hibernate libraries to the lib directory of our application server, we can create the entity classes and web interface. We will create a web application named HibernateApp with entity classes and a JSF interface. We will use the NetBeans CRUD facilities.

Choose File > New Project (Ctrl-Shift-N). Select Web Application from the Web category.
Name the project HibernateApp, set the server to Sun Java System Application Server and the Java EE version to Java EE 5. Click Next.
Select the JavaServer Faces framework and click Finish.
In the Projects window, right-click the project node and choose New > Entity Classes from Database. In the Data Source drop-down, select the jdbc/sample database. If prompted for a user name and password, use app and app. Select the CUSTOMER table from the list, click Add and then click Next.
Leave the tables and class names as their default, and set the package to hibernatesample.db.
Now it is time to create the persistence unit. Click the Create Persistence Unit button. Set HibernateApp as the persistence unit name, select Hibernate as the persistence provider, and select None as the table generation strategy. Click Create.
Click Finish in the Entity Classes from Database wizard. The IDE creates the persistence unit (persistence.xml under Configuration Files node) and the entity classes (under Source Packages).
Finally, let's add some Hibernate-specific properties. Double-click persistence.xml and click the XML button at the top of the editor to switch to the XML view. Add the following property to the persistence unit:
```
  
    org.hibernate.ejb.HibernatePersistence
    jdbc/sample
    
    
    
    
    
```
This property causes all SQL statements to be printed to the application server's log file.

Coding the JSF Interface

Now we can quickly generate JSF pages for the entity classes with the NetBeans IDE CRUD generation.

Right-click the project node and choose New > JSF Pages from Entity Class. Add both Customer.java and DiscountCode.java to the list of selected classes and click Next.
Change the package to hibernatesample.controller and click Finish.
To make this application work correctly, we need to make some changes to CustomerController.java and DiscountCodeController.java. We need to modify the create, edit and destroy methods in the files to change the order in which we get the entity manager.
Open CustomerController.java and DiscountCodeController.java in the Source Editor. Each of the files contains create, edit and destroy methods with the following code:
```
EntityManager em = getEntityManager();
    try {
    utx.begin();
    
```
Modify the code in each of the methods to change the order in which we get the entity manager.
```
EntityManager em = null;
    try {
    utx.begin();
    em = getEntityManager();
    
```
For example, the modified code in the create method of CustomerController.java should look like the following (changes in bold):
```
public String create() {
    EntityManager em = null;
    try {
    utx.begin();
    em = getEntityManager();
    em.persist(customer);
    utx.commit();
    ...
    
```

After creating the JSF pages and modifying the code in the controller classes, you should be able to run and test the application.

Testing the Project

Now we need to run the project to test whether the connection to our database is working correctly.

Right-click the project and choose Run Project. The IDE starts the application server, builds and deploys the application, and shows index.jsp in the external web browser.
Click the List of Customer link and you should see the following web page:
Use the New Customer link to create a customer. Then check the server log by right-clicking the application server node in the Runtime window and choosing View Server Log. The SQL statements for creating the customer should be listed in the server log.

Send Us Your Feedback

Next Steps

For more information about using NetBeans IDE 5.5 to develop Java EE applications, see the following resources:

To send comments and suggestions, get support, and keep informed on the latest developments on the NetBeans IDE Java EE development features, join the nbj2ee@netbeans.org mailing list.

网路冷眼@BlogJava 2007-05-07 23:30 发表评论

Java EE 5 中的 Web 服务 (JAX-WS)（转载）

网路冷眼@BlogJava — Mon, 07 May 2007 15:24:00 GMT

原文地址：http://testwww.netbeans.org/kb/55/websvc-jax-ws_zh_CN.html

Java EE 5 中的 Web 服务 (JAX-WS)

由 Geertjan Wielenga、Manisha Umbarje、Martin Grebac、Milan Kuchtiak 和 Radko Najman 撰稿并修订

Java API for XML Web Services (JAX-WS) 2.0，JSR 224 是 Java EE 5 平台的重要组成部分。作为 Java API for XML-based RPC 1.1 (JAX-RPC) 的后续发行版本，JAX-WS 简化了使用 Java 技术开发 Web 服务的工作。并且通过对多种协议（如 SOAP 1.1、SOAP 1.2、XML）的支持，以及提供用于支持其他协议和 HTTP 的工具，它解决了 JAX-RPC 1.1 中存在的一些问题。JAX-WS 使用 JAXB 2.0 提供数据绑定服务，并支持通过定制来控制生成的服务端点接口。通过对标注的支持，JAX-WS 简化了 Web 服务开发，并缩小了运行时 JAR 文件的大小。

本文档向您介绍了有关使用 IDE 开发 JAX-WS Web 服务以及在三个不同的客户端（Java SE 应用程序中的 Java 类、Web 应用程序中的 Servlet 或 JSP 页）中使用该服务的基础知识。在本文档中创建的三个客户端是独立的应用程序，它们都使用同一个 Web 服务。

预计持续时间：25 分钟

本教程所需的软件

在开始之前，您需要在计算机中安装以下软件：

NetBeans IDE 5.5（下载）
Java Standard Development Kit (JDK) 版本 5.0 或版本 6.0（下载）
Sun Java System Application Server 9.0（如果未与安装的 NetBeans IDE 捆绑在一起，请下载并单独安装它）。

教程练习

安装并配置教程环境

如果尚未注册 Sun Java System Application Server 9.0 的实例，则必须先进行注册，然后才可以着手开发 Java EE 5 应用程序：

从主窗口中，选择“工具”>“服务器管理器”。
单击“添加服务器”。选择 "Sun Java System Application Server"，并为此实例指定一个名称，然后，单击“下一步”。
指定服务器信息、应用服务器本地实例的位置以及要将 Web 服务部署到的域。
单击“完成”。

注意：也可以部署到 Tomcat Web Server，但由于它仅具有一个 Web 容器，因此应在下一部分创建 Web 应用程序，而不是 EJB 模块。与 JSR-109 Web 服务不同的是，JAX-WS Web 服务可以成功地部署到 Tomcat Web 容器中。

创建 Web 服务

本练习的目的是创建一个适用于您决定使用的部署容器的项目。在建立项目后，您将在其中创建 Web 服务。

选择容器

您可以在 Web 容器或 EJB 容器中部署 Web 服务。这要取决于具体的选择。例如，如果您计划部署到仅具有 Web 容器的 Tomcat Web Server 上，则应该选择创建 Web 应用程序，而不是 EJB 模块。

选择“文件”>“新建项目”(Ctrl-Shift-N)。从 "Web" 类别中，选择“Web 应用程序”，或者从“企业”类别中，选择“EJB 模块”。
将项目命名为 CalculatorWSApplication。
根据要使用的部署服务器，请执行以下操作：
- 对于 Sun Java System Application Server，将 J2EE 版本设置为 "Java EE 5"。
- 对于 Tomcat Web Server，请取消选中“将源代码级别设置为 1.4”复选框。
单击“完成”。

通过 Java 类创建 Web 服务

右键单击 CalculatorWSApplication 节点，然后选择“新建”>“Web 服务”。
将 Web 服务命名为 CalculatorWS，在“包”中键入 org.me.calculator，然后单击“完成”。
将在“项目”窗口中显示新建的 Web 服务。例如，对于 Web 应用程序，现在“项目”窗口将如下所示：

IDE 将自动创建服务器所需的部署描述符（如果有）。对于 Sun Java System Application Server，则不需要部署描述符。对于部署到 Tomcat Web Server 的 Web 服务，将添加 sun-jaxws.xml 以及 web.xml 中的 WSServlet 项。

小结

在本练习中，您创建了一个 NetBeans 项目并建立了 Web 服务。

对 Web 服务进行编码

本练习的目的是对 IDE 生成的文件和代码执行一些有意义的操作。您将添加一个操作，该操作将从客户端接收到的两个数字相加起来。

将业务逻辑添加到 Web 服务

展开“Web 服务”节点，然后双击 "CalculatorWS" 节点。将在源代码编辑器中打开 Web 服务。请注意，代码中已存在了一个操作。它被注释掉了。现在，我们将从头开始创建一个新的操作。创建此操作的另一种方法是删除代码注释掉的行。
在类主体（位于注释掉的代码之上或之下）中单击鼠标右键，然后选择“Web 服务”>“添加操作”。
在“添加操作”对话框的上半部分，在“名称”中键入 add，并从“返回类型”下拉列表中选择 int。
在“添加操作”对话框的下半部分，单击“添加”，然后创建一个类型为 int、名为 i 的参数。单击“确定”。
重新单击“添加”，然后创建一个类型为 int、名为 j 的参数。

单击位于“添加操作”对话框底部的“确定”。请注意，add 方法的框架已添加到源代码编辑器中：

    @WebMethod
    public int add(@WebParam(name = "i") int i, @WebParam(name = "j") int j) {
    // TODO implement operation
    return 0;
    }

按如下所示更改 add 方法（更改内容以粗体显示）：

    @WebMethod
    public int add(@WebParam(name = "i") int i, @WebParam(name = "j") int j) {
    int k = i + j;
    return k;
    }

小结

在本练习中，您已为 Web 服务添加了代码。

部署并测试 Web 服务

在将 Web 服务部署到 Web 容器时，IDE 允许您测试 Web 服务以查看它是否能够按预期的那样工作。鉴于此目的，我们在 IDE 中集成了 Sun Java System Application Server 提供的 Tester 应用程序。对于 Tomcat Web Server，也存在类似的工具。但是，Sun Java System Application Server 的 Tester 页允许您输入值并对其进行测试，而 Tomcat Web Server 则不允许这样做。在后一种情况下，您只能看到已部署了 Web 服务，但是不能对值进行测试。目前还没有用于测试 EJB 模块是否已成功部署的工具。

测试是否已成功部署到 Web 容器：

右键单击项目节点，选择“属性”，然后单击“运行”。根据要使用的部署服务器，请执行以下操作：
- 对于 Sun Java System Application Server，在“相对 URL”字段中键入 /CalculatorWSService?Tester。
- 对于 Tomcat Web Server，在“相对 URL”字段中键入 /CalculatorWS?Tester。
注意：由于部署的 EJB 模块的结果不会显示在浏览器中，因此，如果您使用的是 EJB 模块，则不能执行上述步骤。
右键单击项目节点，然后选择“运行项目”。
IDE 将启动应用服务器、生成应用程序，并在浏览器中打开 tester 页（如果已将 Web 应用程序部署到 Sun Java System Application Server）。对于使用 Tomcat Web Server 和部署 EJB 模块来说，情况则有所不同：
- 如果部署到 Tomcat Web Server，将看到以下内容（表明已成功部署了 Web 服务）：
- 如果部署了 EJB 模块，则“输出”窗口显示下面的消息才表明已成功部署：
```
    Deployment of application CalculatorWSApplication  completed successfully
        Enable of CalculatorWSApplication in target server   completed successfully
        Enable of application in all targets  completed successfully
        All operations completed successfully
        run-deploy:
        run:
        BUILD SUCCESSFUL
```
如果部署到 Sun Java System Application Server，在 tester 页上键入两个数字，如下所示：
将显示这两个数字的和：

小结

在本练习中，您已部署了 Web 服务并对其进行了测试。

使用 Web 服务

部署 Web 服务后，我们需要创建一个客户端来使用 Web 服务的 add 方法。在本练习中，我们将创建三个客户端，即 Java SE 应用程序中的 Java 类、Web 应用程序中的 Servlet 和 JSP 页。

客户端 1：Java SE 应用程序中的 Java 类

选择“文件”>“新建项目”(Ctrl-Shift-N)。从“常规”类别中，选择“Java 应用程序”。将项目命名为 CalculatorWS_Client_Application。
注意：在编写本文档时，问题 10 还仍未得到解决，您必须在其路径不包含空格的项目文件夹中创建 Web 服务客户端。例如，路径不能为 "C:\Documents and Settings\..."。

单击“完成”。
右键单击 "CalculatorWS_Client_Application" 节点，然后选择“新建”>“Web 服务客户端”。
在“项目”中，单击“浏览”。找到要使用的 Web 服务。选择 Web 服务后，单击“确定”。
在“包”中键入 org.me.calculator.client，然后单击“完成”。
将在“项目”窗口中显示新建的 Web 服务客户端：
双击 "Main.java" 以在源代码编辑器中将其打开。删除 TODO 注释，并在该行中单击鼠标右键。选择“Web 服务客户端资源”>“调用 Web 服务操作”。
找到“添加”操作，然后单击“确定”。

将带红色下划线的行更改为以下内容：

    System.out.println("Sum: " + port.add(3,4));

右键单击项目节点，然后选择“运行项目”。
现在“输出”窗口会显示以下内容：
```
    compile:
        run:
        Sum: 7
        BUILD SUCCESSFUL (total time: 1 second)
```

客户端 2：Web 应用程序中的 Servlet

选择“文件”>“新建项目”(Ctrl-Shift-N)。从 "Web" 类别中，选择“Web 应用程序”。将项目命名为 CalculatorWSServletClient。
注意：在编写本文档时，问题 10 还仍未得到解决，您必须在其路径不包含空格的项目文件夹中创建 Web 服务客户端。例如，路径不能为 "C:\Documents and Settings\..."。
单击“完成”。
右键单击 "CalculatorWSServletClient" 节点，然后选择“新建”>“Web 服务客户端”。
在“项目”中，单击“浏览”。找到要使用的 Web 服务。选择 Web 服务后，单击“确定”。
在“包”中键入 org.me.calculator.client，然后单击“完成”。
将在“项目”窗口中显示新建的 Web 服务客户端：
右键单击项目节点，然后选择“新建”> "Servlet"。将 Servlet 命名为 ClientServlet，并将它放置在名为 org.me.calculator.client 的包中。单击“完成”。要使 Servlet 成为应用程序的入口点，请右键单击该项目节点，选择“属性”，单击“运行”，然后在“相对 URL”中键入 /ClientServlet。单击“确定”。
在源代码编辑器中，删除注释掉 processRequest 方法主体的行。该行是注释掉代码部分的起始行：
```
    /* TODO output your page here
```
然后，删除注释掉代码部分的结束行：
```
    */
```
在以下行之后添加一些空行：
```
    out.println("Servlet ClientServlet at " + request.getContextPath () + "
");
```
现在，在您添加的一个空行中单击鼠标右键，选择“Web 服务客户端资源”>“调用 Web 服务操作”。将出现“选择要调用的操作”对话框。

找到 add 操作，然后单击“确定”。

现在 processRequest 方法应该如下所示（下面以粗体显示添加的代码）：

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.println("");
        out.println("");
        out.println("Servlet ClientServlet");
        out.println("");
        out.println("");
        out.println("Servlet ClientServlet at " + request.getContextPath () + "");
        try { // Call Web Service Operation
        org.me.calculator.client.CalculatorWSService service = new org.me.calculator.client.CalculatorWSService();
        org.me.calculator.client.CalculatorWS port = service.getCalculatorWSPort();
        // TODO initialize WS operation arguments here
        int arg0 = 0;
        int arg1 = 0;
        // TODO process result here
        int result = port.add(arg0, arg1);
        System.out.println("Result = "+result);
        } catch (Exception ex) {
        // TODO handle custom exceptions here
        }
        out.println("");
        out.println("");
        out.close();
        }

将 arg0 和 arg1 的值更改为其他数值，如 3 和 4。

将 System.out.println 语句更改为 out.println。

添加输出异常的行（如果抛出异常）。

现在 try/catch 块应该如下所示（会突出显示新行和更改行）：

    try { // Call Web Service Operation
        org.me.calculator.client.CalculatorWSService service = new org.me.calculator.client.CalculatorWSService();
        org.me.calculator.client.CalculatorWSApplication port = service.getCalculatorWSApplicationPort();
        // TODO initialize WS operation arguments here
        int arg0 = 3;
        int arg1 = 4;
        // TODO process result here
        int result = port.add(arg0, arg1);
        out.println("Result: " + result);
        } catch (Exception ex) {
        out.println("
Exception: " + ex);
        }

右键单击项目节点，然后选择“运行项目”。
将启动服务器（如果它尚未运行），生成并部署应用程序，并且打开浏览器以显示计算结果。

客户端 3：Web 应用程序中的 JSP 页

选择“文件”>“新建项目”(Ctrl-Shift-N)。从 "Web" 类别中，选择“Web 应用程序”。将项目命名为 CalculatorWSJSPClient。
注意：在编写本文档时，问题 10 还仍未得到解决，您必须在其路径不包含空格的项目文件夹中创建 Web 服务客户端。例如，路径不能为 "C:\Documents and Settings\..."。
单击“完成”。
右键单击 "CalculatorWSJSPClient" 节点，然后选择“新建”>“Web 服务客户端”。
在“项目”中，单击“浏览”。找到要使用的 Web 服务。选择 Web 服务后，单击“确定”。
在“包”中键入 org.me.calculator.client，然后单击“完成”。
将在“项目”窗口中显示新建的 Web 服务客户端。
在“Web 页”文件夹中，双击 "index.jsp" 以在源代码编辑器中将其打开。
在“Web 服务引用”节点中，展开表示 Web 服务的节点。现在将公开要从客户端调用的 add 操作。
将 add 操作拖动到客户端的 index.jsp 页上，并将其放在 H1 标记之下。现在，将在 index.jsp 页中生成用于调用服务操作的代码。
将 arg0 和 arg1 的值更改为其他数值，如 3 和 4。
右键单击项目节点，然后选择“运行项目”。
将启动服务器（如果它尚未运行），生成并部署应用程序，并且打开浏览器以显示计算结果：

请将您的意见和建议发送给我们

后续步骤

有关使用 NetBeans IDE 5.5 开发 Java EE 应用程序的更多信息，请参见以下资源：

要发送意见和建议、获得支持以及随时了解 NetBeans IDE Java EE 开发功能的最新开发情况，请加入 nbj2ee@netbeans.org 邮件列表。

网路冷眼@BlogJava 2007-05-07 23:24 发表评论

EJB 3.0 Enterprise Beans（转载）

网路冷眼@BlogJava — Mon, 07 May 2007 15:19:00 GMT

原文地址：http://testwww.netbeans.org/kb/55/ejb30_zh_CN.html

EJB 3.0 Enterprise Beans

本文档介绍了有关使用 EJB 3.0 技术（作为 Java EE 5 平台的一部分）开发企业应用程序的基础知识，同时说明了 EJB 3.0 技术是如何简化企业应用程序的开发过程的。本文档使用的是 NetBeans IDE 5.5 发行版本。

预计持续时间：30 分钟

先决条件

本文档假定您已具备了以下技术的一些基本知识或编程经验：

Java 编程
NetBeans IDE

本教程所需的软件

在学习本教程之前，您需要在计算机中安装以下软件：

NetBeans IDE 5.5（下载）
Java Standard Development Kit (JDK) 版本 5.0 或版本 6.0（下载）
Sun Java System Application Server Platform Edition 9（下载）

在学习本教程之前，您需要在 IDE 中注册 Sun Java System Application Server 的本地实例。

教程练习

建立企业应用程序项目

本练习的目的是：创建包含一个 EJB 模块和一个 Web 模块的 NewsApp 企业应用程序项目。NewsApp 应用程序使用消息驱动 Bean 接收和处理 Servlet 发送到队列中的消息。该应用程序使用 Servlet 将消息发送到消息驱动 Bean 并显示消息。

创建企业应用程序

从主菜单中选择“文件”>“新建项目”(Ctrl-Shift-N)。
从“企业”类别中选择“企业应用程序”，然后单击“下一步”。
将项目命名为 NewsApp，并将服务器设置为 Sun Java System Application Server。
将 J2EE 版本设置为 "Java EE 5"，然后选中“创建 EJB 模块”和“创建 Web 应用程序模块”（如果未选中）。
单击“完成”。

小结

在本练习中，我们创建了包含一个 EJB 模块和一个 Web 模块的 Java EE 5 企业应用程序。

对 EJB 模块进行编码

在本练习中，我们将在 EJB 模块中创建对象。我们将创建实体类、消息驱动 Bean 和会话 Facade。我们还将创建一个持久性单元，以便为容器提供用于管理实体的信息，以及消息驱动 Bean 将使用的 Java 消息服务 (Java Message Service, JMS) 资源。

创建持久性单元

首先，我们将创建一个持久性单元，它用于定义在应用程序中使用的数据源和实体管理器。

右键单击 EJB 模块，然后选择“新建”>“文件/文件夹”。
从“持久性”类别中，选择“持久性单元”，然后单击“下一步”。
保留缺省的持久性单元名称。
对于持久性提供程序，请选择“TopLink（缺省）”。
对于数据源，请选择缺省的数据源 jdbc/sample。
检查是否为持久性单元选中了“使用 Java 事务 API”，以及“表生成策略”是否设置为“创建”，以便在部署应用程序时创建基于实体类的表。
单击“完成”。

单击“完成”后，IDE 将创建 persistence.xml，并在源代码编辑器中将其打开。关闭 persistence.xml。

创建 `NewsEntity` 实体类

在本练习中，我们将创建 NewsEntity 实体类。实体类是一个简单的 Java 类。在创建实体类时，IDE 会添加 @Entity 标注以将该类定义为实体类。当创建了类后，我们将在该类中创建字段以表示表中所需的数据。

每个实体类都必须具有一个主键。在创建实体类时，IDE 会添加 @Id 标注以声明要用作主键的字段。此外，IDE 还会添加 @Generated 标注以指定主 Id 的键生成策略。

要创建 NewsEntity 类，请执行以下操作：

在“项目”窗口中右键单击 EJB 模块，然后选择“新建”>“文件/文件夹”打开“新建文件”向导。
从“持久性”类别中，选择“实体类”，然后单击“下一步”。
键入 NewsEntity 作为类名，键入 ejb 作为包名，并将“主键类型”保留为 Long。单击“完成”。

单击“完成”后，将在源代码编辑器中打开实体类 NewsEntity.java。在源代码编辑器中，请执行以下操作：

将以下字段声明添加到类中：
```
String title;
    String body;
```
在源代码编辑器中单击鼠标右键，然后选择“重构”>“封装字段”以便为每个字段生成 getter 和 setter。在“封装字段”对话框中，确保选中了字段 id、title 和 body 的 getter 和 setter 复选框。
在“封装字段”对话框中单击“下一步”，然后在“输出”窗口的“重构”标签中单击“执行重构”。IDE 将为各字段添加 getter 和 setter 方法，并将字段的可视性更改为 private。
保存对文件所做的更改。

在接下来的步骤中，我们将创建 NewMessage 消息驱动 Bean。

创建 `NewMessage` 消息驱动 Bean

现在我们将在 EJB 模块中创建 NewMessage 消息驱动 Bean。我们将使用“新建消息驱动 Bean”向导来创建 Bean 和所需的 JMS 资源。

要创建 NewMessage 消息驱动 Bean，请执行以下操作：

在“项目”窗口中右键单击 EJB 模块，然后选择“新建”>“文件/文件夹”以打开“新建文件”向导。
从“企业”类别中，选择“消息驱动 Bean”，然后单击“下一步”。
键入 NewMessage 作为类名。
从“包”下拉列表中选择 "ejb"。
选择“队列”作为目标类型，然后单击“完成”。

单击“完成”后，将在源代码编辑器中打开新建的消息驱动 Bean 类 NewMessage.java。您可以看到该类具有以下标注：

@MessageDriven(mappedName = "jms/NewMessage")

此标注向容器说明：该组件是一个消息驱动 Bean 并且该 Bean 使用 JMS 资源。当 IDE 生成类时，将从类 (NewMessage.java) 名称派生资源的映射名 (jms/NewMessage)。JMS 资源被映射到目标的 JNDI 名称，Bean 从该目标中接收消息。“新建消息驱动 Bean”向导已为我们创建了 JMS 资源。通过 EJB 3.0 API，我们可以从 Bean 类中查找 JNDI 名称空间中的对象，这样就不需要配置部署描述符来指定 JMS 资源了。

EJB 3.0 规范允许您使用标注将资源直接引入类中。现在，我们准备使用标注将 MessageDrivenContext 资源引入类中，然后注入 PersistenceContext 资源，EntityManager API 将使用该资源来管理持久性实体实例。我们要在源代码编辑器中将标注添加到类中。

通过在类中添加以下带标注的字段（以粗体显示），将 MessageDrivenContext 资源注入到类中：
```
public class NewMessage implements MessageListener {
    @Resource
    private MessageDrivenContext mdc;
```
在代码中单击鼠标右键，然后从弹出式菜单中选择“持久性”>“使用实体管理器”，将实体管理器引入类中。
这会在源代码中添加以下标注：
```
@PersistenceContext
    private EntityManager em;
```
并在代码中生成以下方法：
```
public void persist(Object object) {
    // TODO:
    // em.persist(object);
    }
```

按如下所示修改 persist 方法：

public void save(Object object) {
    em.persist(object);
    }

通过将以下代码添加到主体中来修改 onMessage 方法：

    ObjectMessage msg = null;
    try {
    if (message instanceof ObjectMessage) {
    msg = (ObjectMessage) message;
    NewsEntity e = (NewsEntity) msg.getObject();
    save(e);
    }
    } catch (JMSException e) {
    e.printStackTrace();
    mdc.setRollbackOnly();
    } catch (Throwable te) {
    te.printStackTrace();
    }

按 Alt-Shift-F 组合键生成所有必要的 import 语句。在生成 import 语句时，我们需要确保导入 jms 和 javax.annotation.Resource; 库。
保存该文件。

创建会话 Bean

接下来，我们将为 NewsEntity 实体类创建一个会话 Facade。要创建会话 Facade，请执行以下操作：

右键单击 EJB 模块，然后选择“新建”>“文件/文件夹”。
从“持久性”类别中，选择“实体类的会话 Bean”，然后单击“下一步”。
从可用的实体类列表中，选择 "NewsEntity"，单击“添加”，然后单击“下一步”。
检查是否将包设置为 ejb 以及是否选中了创建本地接口。
单击“完成”。

单击“完成”后，将创建会话 Facade 类 NewsEntityFacade.java，并在源代码编辑器中将其打开。IDE 还将创建本地接口 NewsEntityFacadeLocal.java。

EJB 3.0 技术通过减少所需的代码量来简化会话 Bean 的创建。您可以看到，标注 @Stateless 用于将类声明为无态会话 Bean 组件，并且该类不再需要实现 javax.ejb.SessionBean 的语句。此外，代码也更为简洁了，因为利用 EJB 3.0 技术，业务方法不再需要使用代码来声明其抛出了所检查到的异常。

您会看到，在创建会话 Facade 时，PersistenceContext 资源已直接注入到会话 Bean 组件中。

小结

在本练习中，我们已对 EJB 模块中的实体类和消息驱动 Bean 进行了编码，然后为实体类创建了会话 Facade。此外，我们还创建了应用程序使用的 JMS 资源。

对 Web 模块进行编码

现在，我们将在 Web 模块中创建 Servlet ListNews 和 PostMessage。这些 Servlet 将用于读取和添加消息。

创建 `ListNews` Servlet

在本练习中，我们将创建一个用于显示数据的简单 Servlet。我们将使用标注从 Servlet 中调用实体 Bean。

右键单击 Web 模块项目，然后选择“新建”> "Servlet"。
键入 ListNews 作为类名。
输入 web 作为包名，然后单击“完成”。

单击“完成”后，将在源代码编辑器中打开类 ListNews.java。在源代码编辑器中，请执行以下操作：

在源代码中，单击鼠标右键，然后选择“企业资源”>“调用 Enterprise Bean”。
在“调用 Enterprise Bean”对话框中，选择 "NewsEntityFacade"，然后单击“确定”。单击“确定”后，将使用 @EJB 标注在 Servlet 中注入实体 Bean 资源。

在 processRequest 方法中，对其进行如下修改：取消代码注释，然后将下面以粗体显示的行添加到方法主体中。

out.println("Servlet ListNews at " + request.getContextPath () + "");
    List news = newsEntityFacade.findAll();
    for (Iterator it = news.iterator(); it.hasNext();) {
    NewsEntity elem = (NewsEntity) it.next();
    out.println(" "+elem.getTitle()+" 
");
    out.println(elem.getBody()+"
 ");
    }
    out.println("Add new message");
    out.println("");

按 Alt-Shift-F 组合键为类生成所有必要的 import 语句。在生成 import 语句时，我们希望从 util 包中导入类。
保存对文件所做的更改。

创建 `PostMessage` Servlet

在本练习中，我们将创建用于传递消息的 PostMessage Servlet。我们将使用标注将所创建的 JMS 资源直接注入 Servlet 中，并且指定变量名称及其映射到的名称。然后，添加用于发送 JMS 消息的代码，以及用于在 HTML 表单中添加消息的代码。

右键单击 Web 模块项目，然后选择“新建”> "Servlet"。
键入 PostMessage 作为类名。
输入 web 作为包名，然后单击“完成”。

单击“完成”后，将在源代码编辑器中打开类 PostMessage.java。在源代码编辑器中，请执行以下操作：

通过添加下面以粗体显示的字段声明，使用标注来注入 ConnectionFactory 和 Queue 资源：

public class PostMessage extends HttpServlet {
    @Resource(mappedName="jms/NewMessageFactory")
    private  ConnectionFactory connectionFactory;
    @Resource(mappedName="jms/NewMessage")
    private  Queue queue;

现在，通过将下面以粗体显示的代码添加到 processRequest 方法中，添加用于发送 JMS 消息的代码：

response.setContentType("text/html;charset=UTF-8");
    // Add the following code to send the JMS message
    String title=request.getParameter("title");
    String body=request.getParameter("body");
    if ((title!=null) && (body!=null)) {
    try {
    Connection connection = connectionFactory.createConnection();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageProducer messageProducer = session.createProducer(queue);
    ObjectMessage message = session.createObjectMessage();
    // here we create NewsEntity, that will be sent in JMS message
    NewsEntity e = new NewsEntity();
    e.setTitle(title);
    e.setBody(body);
    message.setObject(e);
    messageProducer.send(message);
    messageProducer.close();
    connection.close();
    response.sendRedirect("ListNews");
    } catch (JMSException ex) {
    ex.printStackTrace();
    }
    }
    PrintWriter out = response.getWriter();

现在，将对输出 HTML 的代码取消注释，并添加用于添加消息的 Web 表单。将下面以粗体显示的代码行添加到 processRequest 方法中：

out.println("Servlet PostMessage at " + request.getContextPath() + "");
    // Add the following code to add the form to the web page
    out.println("");
    out.println("Title: 
");
    out.println("Message: 
");
    out.println("
");
    out.println("
");
    out.println("");

按 Alt-Shift-F 组合键为类生成所有必要的 import 语句。在选择 Connection、ConnectionFactory、Session 和 Queue 的 import 语句时，将导入 java.jms 库。
保存对文件所做的更改。

运行项目

现在可以运行项目了。在运行项目时，我们希望浏览器打开包含 ListNews Servlet 的页面。可以通过在企业应用程序的“属性”对话框中指定该页的 URL 来实现这一目的。该 URL 是应用程序的上下文路径的相对 URL。输入相对 URL 后，可以从“项目”窗口中生成、部署并运行应用程序。

要设置相对 URL 并运行应用程序，请执行以下操作：

在“项目”窗口中，右键单击 "NewsApp" 企业应用程序节点，然后从弹出式菜单中选择“属性”。
在“类别”窗格中选择“运行”。
在“相对 URL”文本字段中，键入 /ListNews。
单击“确定”。
在“项目”窗口中，右键单击 "NewsApp" 企业应用程序节点，然后选择“运行项目”。

运行项目时，将在浏览器中打开 ListNews Servlet，该 Servlet 用于显示数据库中的消息列表。如果您是第一次运行项目，则数据库为空，但是您可以单击“添加消息”来添加消息。

当您使用 PostMessage Servlet 添加消息时，消息会发送到消息驱动 Bean 以写入到持久性存储中，并会调用 ListNews Servlet 来显示数据库中的消息。由 ListNews 检索的数据库中的消息列表通常不包含新消息，这是因为消息服务是异步的。

疑难解答

下面是您创建项目时可能会遇到的一些问题。

JMS 资源问题

使用向导来创建 JMS 资源时，您可能会在输出窗口中看到以下服务器错误消息：

[com.sun.enterprise.connectors.ConnectorRuntimeException:
JMS resource not created : jms/Queue]

此消息可能表明没有创建 JMS 资源，或者没有在应用服务器中注册该资源。您可以使用 Sun Java System Application Server 管理控制台来检查、创建以及编辑 JMS 资源。

要打开管理控制台，请执行以下操作：

在 IDE 的“运行环境”中，展开“服务器”节点以确认 Sun Java System Application Server 正在运行。"Sun Java System Application Server" 节点旁边的小绿色箭头表示服务器正在运行。
右键单击 "Sun Java System Application Server" 节点，然后选择“查看管理控制台”以在浏览器中打开登录窗口。
登录到 Sun Java System Application Server。缺省的用户名为 admin，口令为 adminadmin。
在浏览器的管理控制台中，依次展开左框架中的“资源”节点和“JMS 资源”节点。
在左框架中单击“连接工厂”和“目标资源”链接以检查是否在服务器中注册了这些资源，并在必要时修改这些资源。如果这些资源不存在，您可以在管理控制台中创建这些资源。

您需要确保将 PostMessage Servlet 中的 JMS 连接工厂资源映射到在 Sun Java System Application Server 中注册的 JMS 连接工厂资源的对应 JNDI 名称上。

应在 Sun Java System Application Server 中注册以下资源：

具有 JNDI 名称 jms/NewMessage 和类型 javax.jms.Queue 的目标资源
具有 JNDI 名称 jms/NewMessageFactory 和类型 javax.jms.QueueConnectionFactory 的连接工厂资源

请将您的意见和建议发送给我们

后续步骤

有关使用 NetBeans IDE 5.5 开发 Java EE 应用程序的更多信息，请参见以下资源：

您可以在 Java EE 5 教程中找到有关使用 EJB 3.0 Enterprise Beans 的详细信息。

要发送意见和建议、获得支持以及随时了解 NetBeans IDE Java EE 开发功能的最新开发情况，请加入 nbj2ee 邮件列表。

网路冷眼@BlogJava 2007-05-07 23:19 发表评论

Java EE 5 平台中的 Java 持久性（转载）

网路冷眼@BlogJava — Mon, 07 May 2007 15:17:00 GMT

原文地址：http://testwww.netbeans.org/kb/55/persistence_zh_CN.html

Java EE 5 平台中的 Java 持久性

本文档向您介绍了有关使用 Java™ 持久性开发 Web 应用程序的基础知识。Java 持久性 API 是作为 Java EE 5 平台的一部分引入的。在本教程中，您将创建一个简单的 Web 应用程序项目。我们将在项目中使用持久性，但是 Java 持久性 API 允许我们在无需创建 EJB 模块的情况下使用持久性。

在项目中使用 Java 持久性可以大大简化应用程序的开发，因为您不需要配置部署描述符为持久性字段或属性提供对象关系映射信息，而可以使用标注直接在简单的 Java 类中定义这些属性。

实体持久性是通过 EntityManager API 来管理的。EntityManager API 用于处理持久性上下文，而每个持久性上下文是一组实体实例。在开发应用程序时，您可以在类中使用标注来指定实体实例的持久性上下文实例，然后通过容器处理实体实例的生命周期。

本文档使用的是 NetBeans IDE 5.5 发行版本。

预计持续时间：15 分钟

先决条件

本文档假定您已具备以下技术的一些基本知识或编程经验：

Java 编程
NetBeans IDE

本教程所需的软件

在学习本教程之前，您需要在计算机中安装以下软件：

NetBeans IDE 5.5（下载）
Java Standard Development Kit (JDK) 版本 5.0 或版本 6.0（下载）
Sun Java System Application Server Platform Edition 9（下载）

在学习本教程之前，您需要在 IDE 中注册 Sun Java System Application Server 的本地实例。

教程练习

建立 Web 应用程序项目

本练习的目的是创建 ZooApp Web 应用程序项目。此应用程序将利用新增的 Java 持久性模型的功能。其中一项功能就是，实体对象可以成为简单的 Java 类，因此不再需要将它们放置在 EJB 模块中并将其打包到 EAR 文件中。这意味着，我们可以直接在 Web 应用程序内创建实体类。

选择“文件”>“新建项目”(Ctrl-Shift-N)。从 "Web" 类别中选择“Web 应用程序”，然后单击“下一步”。
将项目命名为 ZooApp，将服务器设置为 "Sun Java System Application Server"，将 Java EE 版本设置为 "Java EE 5"，然后单击“下一步”。
选中 "JavaServer Faces" 复选框，然后单击“完成”。

小结

在本练习中，您创建了一个将包含实体类的 Java EE 5 Web 应用程序。

创建持久性单元

在本练习中，我们将创建一个持久性单元，目的在于通知容器哪些实体类需要由实体管理器进行管理，以及这些实体需要使用哪些数据源信息。

我们通过在 persistence.xml（将在 Web 模块中创建此文件）中定义持久性单元的属性来创建持久性单元。指定持久性单元的名称后，将指定持久性提供程序，它包含容器将用于管理实体实例的 API。此外，还需要指定数据源和表生成策略。我们将使用“新建持久性单元”向导创建持久性单元。

注意：也可以在“新建 - 实体类”向导中创建持久性单元。创建实体类时，如果不存在持久性单元，该向导将提示我们进行创建。

创建持久性单元

在“项目”窗口中右键单击 "ZooApp" Web 应用程序节点，然后选择“新建”>“文件/文件夹”以打开“新建文件”向导。
从“持久性”类别中，选择“持久性单元”，然后单击“下一步”。
保留缺省的持久性单元名称。
对于“持久性提供程序”，使用 TopLink(default)。
缺省提供程序是 TopLink Essential.jar。TopLink Essential.jar 包含了 Java 持久性的库。并且实体管理器位于 TopLink Essential.jar 中。
对于“数据源”，使用缺省的数据源 jdbc/sample。
缺省数据源 jdbc/sample 用于连接到与 Sun Java System Application Server 捆绑在一起的 Java DB 数据库。
检查是否为持久性单元选中了“使用 Java 事务 API”，以及“表生成策略”是否设置为“创建”，以便在部署应用程序时创建基于实体类的表。
单击“完成”。

单击“完成”后，IDE 将创建 persistence.xml，并在源代码编辑器中将其打开。通过单击源代码编辑器工具栏中的 "XML"，可以查看 persistence.xml 的 XML。此文件包含了 Java EE 5 容器管理应用程序的实体和持久性所需的所有信息。

小结

在本练习中，您创建了一个持久性单元，用来指定数据源、要永久保存的实体类以及容器将用于管理实体生命周期的实体管理器。

创建实体类

在本练习中，我们将创建两个实体类，即 Animal.java 和 Pavilion.java，它们用于表示要创建的关系数据库中的表。此外，还将在类中定义一些字段来表示数据。Java 持久性规范允许我们使用标注为容器提供有关字段的信息，如对象关系映射信息。

创建 `Animal` 实体类

首先，我们将创建实体类 Animal。此类用于表示数据库中的 ANIMAL 表。在创建实体类时，IDE 会添加 @Entity 标注以将该类定义为实体类。创建类后，我们将在类中创建字段以表示表中所需的数据，并使用标注提供有关一些字段的其他信息。

要创建 Animal 类，请执行以下操作：

右键单击 "ZooApp" 项目节点，然后选择“新建”>“文件/文件夹”。
从“持久性”类别中，选择“实体类”，然后单击“下一步”。
键入 Animal 作为类名，键入 entity 作为包名，并将“主键类型”保留为 Long。单击“完成”。

单击“完成”后，将在源代码编辑器中打开新建的实体类 Animal.java。在源代码编辑器中，请执行以下操作：

将以下字段声明添加到类中：

  String name;
    String kind;
    String weight;
    Pavilion pavilion;

在源代码编辑器中单击鼠标右键，然后选择“重构”>“封装字段”以便为每个字段生成 getter 和 setter。在“封装字段”对话框中，确保选中所有字段的 getter 和 setter 复选框。
在“封装字段”对话框中单击“下一步”，然后在“输出”窗口的“重构”标签中单击“执行重构”。
现在我们希望更改将在 Animal 表中创建的其中一列的名称。我们希望该列的名称是 animalName 而不是 name。通过在 name 字段声明之上添加以下标注，可以使用标注来指定生成列的名称：
```
    @Column(name="animalName")
```
我们还希望 Animal 表中的 pavilion 列具有多对一的关系。通过在 pavilion 声明之上添加以下标注，可以实现这一目的：
```
    @ManyToOne
```
按 Alt-Shift-F 组合键为类生成所有必要的 import 语句。
保存您所做的更改。

在下一步中，我们将创建 Pavilion 实体类。

创建 `Pavilion` 实体类

现在我们将创建实体类 Pavilion，它用于表示数据库中的 PAVILION 表。我们将再次在类中使用标注指定一些字段的对象关系映射。要创建 Pavilion 类，请执行以下操作：

右键单击 "ZooApp" 项目节点，然后选择“新建”>“文件/文件夹”。
从“持久性”类别中，选择“实体类”，然后单击“下一步”。
键入 Pavilion 作为类名，键入 entity 作为包名，并将“主键类型”保留为 Long。单击“完成”。

单击“完成”后，将在源代码编辑器中打开新建的实体类 Pavilion.java。在源代码编辑器中，请执行以下操作：

将以下字段声明添加到类中：

  String name;
    String address;
    Collection  animals;

选择“重构”>“封装字段”以便为字段生成 getter 和 setter。
在 name 声明之上添加以下标注以更改生成列的名称：
```
    @Column(name="pavilionName")
```
在 animals 声明之上添加以下标注，为实体指定一对多的关系：
```
    @OneToMany(mappedBy="pavilion")
```
按 Alt-Shift-F 组合键生成所有缺少的 import 语句。
保存您所做的更改。

小结

在本练习中，您创建了两个实体类并定义了字段，而且还使用标注定义了在部署应用程序时将在表中生成的某些列的属性。

创建 Web 接口

现在我们希望创建一些简单的 Web 页，以查看是否创建了数据库表以及是否可以添加数据。我们将为应用程序添加 Java Server Faces (JSF) 页，并使用“通过实体类创建 JSF 页”向导快速创建一个简单的 Web 接口。

从主菜单中，选择“文件”>“新建文件”。从“持久性”类别中，选择“通过实体类创建 JSF 页”，然后单击“下一步”。
在“新建 - 通过实体类创建 JSF 页”向导中，单击“全部添加”以选择两个实体类，然后单击“下一步”。
将“JSF 页文件夹”文本字段保留为空，以便在缺省位置保存 JSF 文件。
将 entity 指定为已生成类的包，然后单击“完成”。

单击“完成”后，IDE 将生成所需的 JavaServer Faces 文件，以便我们可以运行并测试 ZooApp。

运行项目

在本练习中，我们将部署 ZooApp Web 应用程序项目并测试该应用程序。

启动 Java DB 数据库，方法是：选择“工具”>“Java DB 数据库”>“启动 Java DB 服务器”。
右键单击 "ZooApp" 项目节点，然后选择“运行项目”。

单击“运行项目”后，将在浏览器中打开一个页面，您可以通过该页面包含的菜单，查看场馆 (Pavilions) 和动物 (Animals) 的列表。

您还可以添加、编辑或删除动物 (Animals) 和场馆 (Pavilions) 数据。

小结

在本练习中，您生成了为 Java EE 5 平台开发的 ZooApp Web 应用程序，然后部署并测试了该 Web 应用程序。

疑难解答

下面是您创建项目时可能会遇到的一些问题。

使用“新建 - 通过实体类创建 JSF 页”向导时的问题

使用该向导通过实体类创建 JSF 页时，您可能会在向导中看到以下错误消息：

"This wizard can only be used in a web project with JSF support."（此向导只能在具有 JSF 支持的 Web 项目中使用。）

如果看到此消息，则需要检查是否已将 Java Server Faces 框架添加到项目属性中。通过执行以下操作，可以将 Java Server Faces 支持添加到 Web 项目中：

在“项目”窗口中，右键单击 Web 应用程序节点，然后选择“属性”。
在“项目属性”对话框的“类别”窗格中选择“框架”，然后单击“添加”。
在“选择框架”对话框中，选择 "Java Server Faces"，然后单击“确定”。
在“项目属性”对话框中，单击“确定”以关闭窗口。

将 JSF 框架添加到项目属性后，您应该能够使用该向导创建 JSF 页了。

请将您的意见和建议发送给我们

后续步骤

有关使用 NetBeans IDE 5.5 开发 Java EE 应用程序的更多信息，请参见以下资源：

您可以在 Java EE 5 教程中找到有关使用 Java 持久性的详细信息。

要发送意见和建议、获得支持以及随时了解 NetBeans IDE Java EE 开发功能的最新开发情况，请加入 nbj2ee 邮件列表。

网路冷眼@BlogJava 2007-05-07 23:17 发表评论

Java EE 5 技术简介(转载）

网路冷眼@BlogJava — Mon, 07 May 2007 15:15:00 GMT

原文地址：http://testwww.netbeans.org/kb/55/javaee-intro_zh_CN.html

Java EE 5 技术简介

Java EE 5 教程

NetBeans IDE 5.5 的开发是在 Java EE 和 Glassfish 工作组的密切合作下完成的，它实现了与新的 Java EE 5 规范的完美集成，从而可以在此 IDE 中轻松地使用新规范。NetBeans IDE 5.5 是您快速学习 Java EE 5 编程并使用它高效工作的最佳途径。

本文档介绍了 Java EE 5 规范的一些重要概念，以及它们如何与您目前的编程项目相关联的。下面将介绍以下主题：

您可以在 Java EE 5 教程中找到有关开发 Java EE 5 应用程序并在 Sun Java System Application Server Platform Edition 9 上部署该应用程序的信息。

标注取代部署描述符

Java EE 5 平台不需要任何部署描述符（Servlet 规范所需的部署描述符 web.xml 文件除外），从而简化了部署过程。其他部署描述符（如 ejb-jar.xml 以及在 web.xml 中与 Web 服务相关的条目）已过时。J2EE 1.4 部署描述符通常很复杂，在填充它们时很容易出错。但是，Java EE 5 平台使用的是“标注”。标注是 Java 修饰符，与代码中指定的 public 和 private 类似。例如，EJB 3 规范（Java EE 5 规范的子集）为 Bean 类型、接口类型、资源引用、事务属性、安全性等定义了标注。JAX-WS 2.0 规范为 Web 服务提供了一组类似的标注。有些标注用来生成工件，另外一些标注用来描述代码，还有一些标注用来提供增强的服务，如安全性或特定于运行时的逻辑。总之，Java EE 5 平台为以下任务（以及其他任务）提供了标注：

定义和使用 Web 服务
开发 EJB 软件应用程序
将 Java 技术类映射到 XML
将 Java 技术类映射到数据库
将方法映射到操作
指定外部依赖关系
指定部署信息，其中包括安全属性

标注使用 @ 字符来标记。在 IDE 中，当您创建了使用 Java EE 5 中的标注的类型时，将在生成的代码中提供相关的占位符。例如，当您使用 IDE 创建无态会话 Bean 时，将生成以下代码，其中包括 @Stateless() 标注：

package mypackage;
import javax.ejb.*;
@Stateless()
public class HelloWorldSessionBean implements mypackage.HelloWorldSessionLocal {
}

通过代码完成，您可以对特定于光标下的项的标注属性进行访问。例如，在 @WebService() 标注的括号中按 Ctrl-空格键时，将看到以下内容：

每个属性都具有缺省值。因此，除非您需要使用缺省值以外的其他值，否则不必指定任何属性。在一些简单的示例中，使用缺省值就可以了，这意味着您根本不需要提供属性。

简化的 EJB 软件开发

使用新的 EJB 3.0 API，可以减少并简化开发者需要完成的工作量，从而可以更轻松地进行软件开发。换句话说，就是使用了更少的类和代码。这是因为现在容器承担了更多的工作，从而实现了这一目的。下面是新 EJB 3.0 API 的一些功能和优点：

只需很少的类和接口。您不再需要 EJB 组件的 Home 接口和对象接口，因为现在容器负责公开必要的方法。您只需提供业务接口。您可以使用标注来声明 EJB 组件，并且通过容器来管理事务。
不再需要部署描述符。您可以在类中直接使用标注，为容器提供以前在部署描述符中定义的依赖关系和配置信息。如果没有任何特殊说明，容器将使用缺省规则来处理最常见的情况。
查找简单。您可以通过 EJBContext 直接在类中查找 JNDI 名称空间中的对象。
简化了对象关系映射。新的 Java 持久性 API 允许您使用 POJO 中的标注将 Java 对象映射到关系数据库，从而使对象关系映射变得更简单透明。

在 IDE 中，您可以对 Enterprise Beans 进行编码，就像对其他 Java 类进行编码一样，方法是：使用代码完成和编辑器提示实现正确的方法并使类与其接口保持同步。您不必使用特殊命令和对话框生成诸如业务方法或 Web 服务操作之类的内容，虽然这些命令仍可以帮助您熟悉 Java EE 5 代码的语法。

使用依赖关系注入来访问资源

通过依赖关系注入，对象可以使用标注直接请求外部资源。这样代码会更简洁，因为您不再需要将代码与资源创建和查找代码混杂在一起。您可以在 EJB 组件、Web 容器和客户端中使用资源注入。

要请求资源注入，组件需要使用 @Resource 标注或针对一些专用资源的 @EJB 和 @WebServiceRef 标注。您可以注入以下资源：

SessionContext 对象
DataSources 对象
EntityManager 接口
其他 Enterprise Beans
Web 服务
消息队列和主题
资源适配器的连接工厂

在 IDE 中，源代码编辑器为 Java EE 5 平台提供的资源注入标注提供了完整的代码完成。此外，当您运行诸如“调用 EJB”和“使用数据库”之类的命令时，IDE 会自动将资源注入到文件中。

Java 持久性 API 模型

Java EE 5 平台引入了新的 Java 持久性 API（它是作为 JSR-220 的一部分开发的）。Java 持久性 API 不但可以在 EJB 组件外部使用（例如，在 Web 应用程序和应用程序客户端中使用），而且还可以在 Java EE 平台之外的 Java SE 应用程序中使用。

Java 持久性 API 具有以下主要功能：

实体是 POJO。与使用容器管理持久性 (Container-Managed Persistence, CMP) 的 EJB 组件不同，使用新 API 的实体对象不再是组件，并且它们不再需要位于 EJB 模块中。
标准化的对象关系映射。新规范将对对象关系映射的处理方式进行标准化，从而使开发者不再需要了解特定于供应商的策略。Java 持久性 API 使用标注来指定对象关系映射信息，但它仍支持 XML 描述符。
命名查询。现在命名查询是用元数据表示的静态查询。查询可以是 Java 持久性 API 查询或本地查询。这样会使重用查询变得非常简单。
简单的打包规则。由于实体 Bean 是简单的 Java 技术类，因此几乎可以在 Java EE 应用程序中的任意位置将其打包。例如，实体 Bean 可以是 EJB JAR、应用程序客户端 JAR、WEB-INF/lib、WEB-INF/classes 的一部分，甚至是企业应用程序归档 (Enterprise Application Archive, EAR) 文件中实用程序 JAR 的一部分。通过这些简单的打包规则，您不再需要创建 EAR 文件以使用来自 Web 应用程序或应用程序客户端的实体 Bean。
分离的实体。由于实体 Bean 是 POJO，因此可以对它们执行序列化，通过网络将其发送到其他地址空间，并在不识别持久性的环境中使用它们。这样，您就不再需要使用数据传输对象 (Data Transfer Object, DTO)。
EntityManager API。现在，应用程序编程人员可以使用标准 EntityManager API 来执行涉及实体的创建、读取、更新和删除 (Create Read Update Delete, CRUD) 操作。

IDE 提供了处理新 Java 持久性 API 的工具。您可以通过数据库自动生成实体类，或手动对实体类进行编码。IDE 还提供了用于创建和维护持久性单元的模板和图形编辑器。有关使用新 Java 持久性 API 的详细信息，请参见 Java EE 5 平台中的 Java 持久性。

Web 服务

在 Java EE 5 平台中，通过使用标注显著改进和简化了 Web 服务支持。以下规范已应用于此领域中：JSR 224，Java API for XML-Based Web Services (JAX-WS) 2.0；JSR 222，Java Architecture for XML Binding (JAXB) 2.0 以及 JSR 181，Web Services Metadata for the Java Platform。

JAX-WS 2.0

JAX-WS 2.0 是 Java EE 5 平台中用于 Web 服务的新 API。作为 JAX-RPC 1.1 的后继者，JAX-WS 2.0 保留了自然的 RPC 编程模型，同时在以下几个方面进行了改进：数据绑定、协议和传输的独立性、对 Web 服务的 REST 样式的支持以及易开发性。

与 JAX-RPC 1.1 的主要区别在于，现在所有数据绑定都委托给了 JAXB 2.0。这样，基于 JAX-WS 的 Web 服务就可以使用百分之百的 XML 架构，从而提高了互操作性和易使用性。这两种技术已很好地集成在一起了，因此用户不必再为使用两套不同的工具而勉为其难了。从 Java 技术类开始开发时，JAXB 2.0 可以生成自动嵌入到 Web 服务描述语言 (Web Service Description Language, WSDL) 文档内的 XML 架构文档，从而用户无需手动执行这一容易出错的集成。

现成的 JAX-WS 2.0 本身可以支持 SOAP 1.1、SOAP 1.2 和 XML/HTTP 协议。协议可扩展性从一开始就是人们所希望实现的目标，JAX-WS 2.0 允许供应商支持其他协议和编码来获取更佳的性能（例如 FAST Infoset）或专用的应用程序。Web 服务（使用附件来优化大型二进制数据的发送和接收）可以利用 W3C 制订的 MTOM/XOP（“消息传输优化机制/XML 二进制优化打包”的简称）标准，且对编程模型没有任何不利的影响（有关 MTOM/XOP 的信息，请参见此页）。在 Java EE 5 技术出现之前，定义 Web 服务需要使用很长且复杂的描述符。现在，定义它却非常简单，只需将 @WebService 标注放置在 Java 技术类上即可。类上的所有公共方法会自动发布为 Web 服务操作，并且其所有参数都将使用 JAXB 2.0 映射到 XML 架构数据类型。

异步 Web 服务

由于 Web 服务调用是通过网络来实现的，因此这种调用所花费的时间是无法预测的。许多客户端（特别是交互式客户端，如基于 JFC/Swing 的桌面应用程序）由于必须等待服务器的响应而严重地影响了它们的性能。为了避免出现性能降低，JAX-WS 2.0 提供了新的异步客户端 API。使用此 API，应用程序编程人员不再需要自己创建线程，而是依赖于 JAX-WS 运行时为他们管理长时间运行的远程调用。

异步方法可以与 WSDL 生成的任何接口以及动态性更强的 Dispatch API 联合使用。为了方便起见，在导入 WSDL 文档时，您可以要求为 Web 服务定义的任何操作生成异步方法。

以下提供了两种使用模型：

在轮询模型中，发出调用。准备就绪后，请求结果。
在回调模型中，注册处理程序。在响应到达后，立即向您发出通知。

请注意，异步调用支持是完全在客户端上实现的，因此不需要对目标 Web 服务进行任何更改。

IDE 提供了处理 JAX-WS 的工具。您可以使用“新建文件”向导中的模板生成 JAX-WS 工件。异步 Web 服务可以通过 Web 服务定制编辑器来创建。代码完成功能包括可以在 Web 服务中使用的标注。

请将您的意见和建议发送给我们

后续步骤

有关使用 NetBeans IDE 5.5 开发 Java EE 应用程序的更多信息，请参见以下资源：

要发送意见和建议、获得支持以及随时了解 NetBeans IDE Java EE 开发功能的最新开发情况，请加入 nbj2ee@netbeans.org 邮件列表。

网路冷眼@BlogJava 2007-05-07 23:15 发表评论

Java EE SDK Update 2 提供下载

网路冷眼@BlogJava — Thu, 21 Dec 2006 14:13:00 GMT

Glassfish 项目组宣布 Java EE SDK Update 2 发布了.

Glassfish 项目组在今年5月发布了Java EE 5的SDK. Java EE 5的关注重点是简化应用开发，尤其是大量采用元数据标注（annotation）和POJO驱动的开发方式，对平台进行了重新定义。对比此前的J2EE 1.4规范，Java EE 5最重要的新增特性包括Java持久化API（即EJB 3 entity bean）、JSF、JSTL等。

这次发布的Java EE SDK Update 2, 包括的更新有:

与Java SE 6测试兼容；
SDK整合了Access Manager , 7.1 Beta版本；
SDK整合了来自Open ESB 项目的 JBI Runtime；
SDK还整合了一个测试版本的Portlet Container, 开发者可以测试JSR 168 portlets

同时还提供了更新的Java EE samples, Api docs等等.

官方博客:
http://blogs.sun.com/theaquarium/entry/java_ee_sdk_update_2

网路冷眼@BlogJava 2006-12-21 22:13 发表评论

[原创]利用Google Web Toolkit(GWT) SDK 开发AJAX应用程序(1)

网路冷眼@BlogJava — Wed, 15 Nov 2006 23:25:00 GMT

Google的GMail是一个Web 2.0 AJAX的典型示例。Google Web Toolkit(GWT) SDK 提供一个Java框架，采用开发和调试一般Java应用程序的方式来编写AJAX的软件。简便而快捷。面对炙手可热的Web 2.0,咱们可以说，I can do it!

网路冷眼@BlogJava 2006-11-16 07:25 发表评论

BlogJava-网路冷眼@BlogJava-文章分类-Java

Using Hibernate-specific features with JPA

Using Hibernate-specific features with JPA

Prerequisites

Software Needed for the Tutorial

Setting up your Environment

Creating a Web Application

Coding the JSF Interface

Testing the Project

Adding validation

Query by Example

Query By Example

Troubleshooting

Attachments

Using Hibernate with the Java Persistence API（转载）

Using Hibernate with the Java Persistence API

Software Required for this Tutorial

Setting up your Environment

Creating the Entity Classes and Persistence Unit

Coding the JSF Interface

Testing the Project

Next Steps

Java EE 5 中的 Web 服务 (JAX-WS)（转载）

Java EE 5 中的 Web 服务 (JAX-WS)

本教程所需的软件

教程练习

安装并配置教程环境

创建 Web 服务

选择容器

通过 Java 类创建 Web 服务

小结

对 Web 服务进行编码

将业务逻辑添加到 Web 服务

小结

部署并测试 Web 服务

小结

使用 Web 服务

客户端 1：Java SE 应用程序中的 Java 类

客户端 2：Web 应用程序中的 Servlet

Servlet ClientServlet at " + request.getContextPath () + "

Servlet ClientServlet at " + request.getContextPath () + "

客户端 3：Web 应用程序中的 JSP 页

后续步骤

EJB 3.0 Enterprise Beans（转载）

EJB 3.0 Enterprise Beans

先决条件

本教程所需的软件

教程练习

建立企业应用程序项目

创建企业应用程序

小结

对 EJB 模块进行编码

创建持久性单元

创建 NewsEntity 实体类

创建 NewMessage 消息驱动 Bean

创建会话 Bean

小结

对 Web 模块进行编码

创建 ListNews Servlet

Servlet ListNews at " + request.getContextPath () + "

创建 PostMessage Servlet

运行项目

疑难解答

JMS 资源问题

后续步骤

Java EE 5 平台中的 Java 持久性（转载）

Java EE 5 平台中的 Java 持久性

先决条件

本教程所需的软件

教程练习

建立 Web 应用程序项目

小结

创建持久性单元

创建持久性单元

小结

创建实体类

创建 Animal 实体类

创建 Pavilion 实体类

小结

创建 Web 接口

创建 `NewsEntity` 实体类

创建 `NewMessage` 消息驱动 Bean

创建 `ListNews` Servlet

创建 `PostMessage` Servlet

创建 `Animal` 实体类

创建 `Pavilion` 实体类