Oracle
MyEclipse数据库教程：使用Java项目查看JPA工作方式
Java EE开发 • momo77 发表了文章 • 0 个评论 • 273 次浏览 • 2019-11-27 16:57
**建立一个项目**
一般情况，JPA Facet将被添加到Java或Web项目中。在本教程中，您将使用一个简单的Java项目来查看JPA的工作方式。
注意：您可以[下载本教程中开发的项目](https://www.evget.com/resource/detail-demo-14494)，然后导入到您的工作区中。
1、单击下拉箭头，然后选择Java Project。
2、在“Project Name”字段中输入SampleJPAProject，选择默认选项，然后单击“完成”。
3、单击，选择MyEclipse Database Explorer打开透视图。
4、在数据库浏览器中，选择MyEclipse Derby连接，然后单击。
**注意：**在建立数据库连接之前，无法添加JPA Facet，因为需要选择要使用的连接。
5、切换回MyEclipse Java Enterprise透视图，右键单击项目，然后选择**[MyEclipse](https://www.myeclipsecn.com/)** > Project Facets > Install JPA Facet。
6、在目标运行时下拉列表中选择MyEclipse通用Java运行时，然后单击下一步。
7、从平台下拉列表中选择一个平台，如果JPA实现类型默认为用户库，则选择与所选平台相对应的库。如果未列出任何库，可单击下载适当的库。
8、在“Connection”字段中选择MyEclipse Derby，选中“Add driver library to build path”和“Override default schema”复选框，然后从“Schema”下拉列表中选择CLASSICCARS。单击完成。
现在，项目中已添加了完全配置的JPA Facet，其中包括JPA配置信息/DB连接信息以及添加到项目构建路径中的所有必需的JDBC和JPA库。如果这是一个Web项目，在将项目部署到应用程序服务器上并在其中运行时，所有构建路径的附加内容都将准备好进行部署。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
**创建一个Java包**
在下一个步骤中，对数据库表中的数据进行反向工程，并为项目生成实体。在进行逆向工程之前，需要创建一个Java包，并在其中放置这些实体。
1、展开项目，右键单击src文件夹，然后选择New > Package。
2、在“Name”字段中输入com.myeclipseide.jpa，然后单击“完成”。
**逆向工程数据库表**
现在已经建立了项目，可以将PRODUCTLINE表反向工程到项目中，并开始使用所生成的实体。
1、右键单击该项目，然后选择JPA Tools > Generate Entities & DAOs。
**注意：**您可以选择使用MyEclipse逆向工程工具或DALI实体生成器。选择，单击“确定”，然后完成向导。本教程使用MyEclipse逆向工程工具。
2、选择PRODUCTLINE表，单击添加，然后单击下一步。
在“Java Package”字段中，单击“ Browse”，然后选择先前创建的com.myeclipseide.jpa程序包。选中以下复选框：
- Entity Bean Generation：让MyEclipse生成注释为用作JPA实体的普通Java类。
- Create abstract class；如果您希望自定义生成的类，而不必每次都覆盖更改，则MyEclipse可以生成基本抽象类以及您可以自定义和使用的具体子类。每次进行反向工程时，MyEclipse只会覆盖抽象基类，并在具体子类中保留更改。
- Update persistence.xml：与Hibernate类似，您可以在JPA配置文件中列出正在使用的所有JPA实体。
- Java Data Access Generation：让MyEclipse生成DAO实用程序类，让您可以立即从数据库中保存/查找/更新/删除实体。此代码包含了JPA实体管理器，使得使用实体和数据库变得非常容易。
- Generate Precise findBy Methods：让MyEclipse生成findByXXX方法，其中XXX与反转的实体上的每个属性有关。这样一来，可以使用任何属性作为查找实体的方法，轻松地从数据库访问实体。
- Generate Java Interfaces：选择此选项将创建带有相应DAO实现类的接口类。取消选择此选项仅生成DAO实现类，而没有用于定义接口的单独类。
3、单击完成。查看通过展开com.myeclipseide.jpa包生成的MyEclipse资源。
生成的实体描述如下：
- EntityManagerHelper：使用直接JPA时，开发人员需要使用EntityManager class。EntityManager通过提供用于访问管理器的静态方法以及易于调用的最常用操作，此生成的帮助程序类让使用EntityManager的过程变得更加容易。
- IProductline：定义相应DAO实现类的接口的类。
- Productline：此类是表示数据库表PRODUCTLINE的JPA实体（POJO）。该POJO包含PRODUCTLINE表的字段，并表示数据库中的一行。
- ProductlineDAO：此类包含EntityManagerHelper以便为我们提供易于使用的方法，专门用于在数据库中添加/查找/更新和删除产品。
注意：逆向工程完成后，您可以打开“Persistence”透视图，使用某些持久性和数据源工具来分析数据库和项目中的数据。
**编写应用程序**
由于MyEclipse生成了许多代码，所以您可以快速将精力放在“Business Logic”上，或更具体地说是“实际完成工作的代码”。在本部分中，您将编写一个具有main方法的Java类，该方法将Productline插入数据库，对其进行检索、更新并删除。使用此代码，您会发现在应用程序中使用JPA实体是多么容易！
**一、创建一个类**
1、右键单击com.myeclipseide.jpa软件包，然后选择New Class。
2、在“Name”字段中键入RunJPA，选中Public static void main复选框，然后单击“Finish”。
在构建新类和main方法之后，需要编写代码来操作Productline实例。
**注意：**以下代码看起来很长而且很复杂，这是因为我们试图在一个代码块中显示四个不同的示例。如果您查看每个操作（保存、加载、更新、删除），就会发现它们都不由几行代码组成。
3、将以下代码添加到main方法中，然后按CTRL + S保存。
{{{
/* 1. Create a reference to our ID */
String productLineID = "Men's Shoes";
/* 2. Create a new Productline instance */
Productline newProductline = new Productline(
productLineID,
"Shoes for men.", "Men's Shoes", null);
/* 3. Create a DAO instance to use */
ProductlineDAO dao = new ProductlineDAO();
/* 4. Store our new product line in the DB */
EntityManagerHelper.beginTransaction();
dao.save(newProductline);
EntityManagerHelper.commit();
/* 5. Now retrieve the new product line,
using the ID we created */
Productline loadedProductline = dao.findById(productLineID);
/* 6. Print out the product line information */
System.out.println("*NEW* Product Line
[productLine="
+
loadedProductline.getProductline() + ",
textDescription="
+
loadedProductline.getTextdescription() + ", image="
+
loadedProductline.getImage() + "]");
/*
* 7. Now let's change same value on the product line, and save the
* change
*/
loadedProductline.setTextdescription("Product line for men's shoes.");
EntityManagerHelper.beginTransaction();
dao.save(loadedProductline);
EntityManagerHelper.commit();
/*
* 8. Now let's load the product line from the DB again, and make sure
* it text description changed
*/
Productline secondLoadedProductline =
dao.findById(productLineID);
System.out.println("*REVISED* Product Line ["
+ "productLine=" +
secondLoadedProductline.getProductline()
+ ", textDescription=" +
secondLoadedProductline.getTextdescription()
+ ", image=" +
secondLoadedProductline.getImage() + "]");
/* 9. Now let's delete the product line from the DB */
EntityManagerHelper.beginTransaction();
dao.delete(secondLoadedProductline);
EntityManagerHelper.commit();
/*
* 10. To confirm the deletion, try and load it again and make sure it
* fails
*/
Productline deletedProductline = dao.findById(productLineID);
/*
* We use a simple inlined IF clause to test for null and print
* SUCCESSFUL/FAILED
*/
System.out.println("Productline deletion: "
+ (deletedProductline ==
null ? "SUCCESSFUL" : "FAILED"));
}}}
上面的代码看起来很复杂，但它做了很多简单的事情。例如，如果您只对在数据库中存储新项目感兴趣，则只需要程序中第1-3步中的代码，这相当于（减去注释）三行代码。以下是每个编号部分的细分：
PRODUCTLINE表使用产品线的名称作为主键。为了使本教程更容易理解，我们在字符串中定义了产品线名称，并在代码中多次运用（创建和存储产品线，然后检索两次）。
这将创建由MyEclipse生成的Productline POJO的新实例，并将其插入数据库中。对于本教程而言，这些值并不重要，所以我们只使用示例信息。
这将创建要使用的DAO实例。数据库访问需要DAO（这也是由MyEclipse生成的）。
这让DAO将新的产品系列存储在数据库中。因为要向数据库中写入一些内容，所以将save调用包含在事务中。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
为了确保使用第1步中定义的ID正确存储了产品系列，我们要求DAO获取产品系列，并将结果分配给一个全新的对象，以完全确保从数据库中加载了什么。（我们可以将值分配回newProductline，但是出于本教程的目的，我们必须清楚地知道对象来源，并且加载的实例之前在代码中不存在）。
这将从已加载的实体中打印出值，以确保它只是存储在数据库中的值。
这将更改刚刚加载的POJO的值，以显示更新记录的工作方式。然后，使用DAO将更改提交回数据库。同样的，此操作被包含在事务中，以确保安全地更改数据库。
与步骤5一样，使用在步骤1中定义的ID从数据库中重新加载记录，以确保更新操作有效。然后打印出POJO值，以确保新描述已保存到数据库中。
这显示了如何从数据库删除记录。同样的，由于这需要更改数据库，因此该代码被包含在事务中。
与第8步和第5步类似，为了证明删除有效，我们尝试使用给定的ID从数据库加载实体。因为我们已经删除了Productline，所以这个操作应该是失败的。从DAO获得结果后，将使用嵌入式IF子句打印一条语句，以确保结果为null。
**二、运行应用程序**
1、右键单击项目，然后选择Run As > Java Application。
2、选择RunJPA应用程序，然后单击“确定”。
输出显示在Console视图中。
红色文本是来自MyEclipse中生成的DAO和EntityHelper类的默认日志消息。黑色文本是代码中用于跟踪进度的System.out.println文本。如您所见，第6步中的第一个打印输出和第8步中的更新打印输出都按预期工作。并且查询没有返回Productline，证明删除也很成功。
**资源**
[Oracle JPA注释参考](https://www.oracle.com/technet ... 1.html)
[BEA JPQL参考](https://www.evget.com/resource ... -17577) 查看全部
一般情况，JPA Facet将被添加到Java或Web项目中。在本教程中，您将使用一个简单的Java项目来查看JPA的工作方式。
注意：您可以[下载本教程中开发的项目](https://www.evget.com/resource/detail-demo-14494)，然后导入到您的工作区中。
1、单击下拉箭头，然后选择Java Project。
2、在“Project Name”字段中输入SampleJPAProject，选择默认选项，然后单击“完成”。
3、单击，选择MyEclipse Database Explorer打开透视图。
4、在数据库浏览器中，选择MyEclipse Derby连接，然后单击。
**注意：**在建立数据库连接之前，无法添加JPA Facet，因为需要选择要使用的连接。
5、切换回MyEclipse Java Enterprise透视图，右键单击项目，然后选择**[MyEclipse](https://www.myeclipsecn.com/)** > Project Facets > Install JPA Facet。
6、在目标运行时下拉列表中选择MyEclipse通用Java运行时，然后单击下一步。
7、从平台下拉列表中选择一个平台，如果JPA实现类型默认为用户库，则选择与所选平台相对应的库。如果未列出任何库，可单击下载适当的库。
8、在“Connection”字段中选择MyEclipse Derby，选中“Add driver library to build path”和“Override default schema”复选框，然后从“Schema”下拉列表中选择CLASSICCARS。单击完成。
现在，项目中已添加了完全配置的JPA Facet，其中包括JPA配置信息/DB连接信息以及添加到项目构建路径中的所有必需的JDBC和JPA库。如果这是一个Web项目，在将项目部署到应用程序服务器上并在其中运行时，所有构建路径的附加内容都将准备好进行部署。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
**创建一个Java包**
在下一个步骤中，对数据库表中的数据进行反向工程，并为项目生成实体。在进行逆向工程之前，需要创建一个Java包，并在其中放置这些实体。
1、展开项目，右键单击src文件夹，然后选择New > Package。
2、在“Name”字段中输入com.myeclipseide.jpa，然后单击“完成”。
**逆向工程数据库表**
现在已经建立了项目，可以将PRODUCTLINE表反向工程到项目中，并开始使用所生成的实体。
1、右键单击该项目，然后选择JPA Tools > Generate Entities & DAOs。
**注意：**您可以选择使用MyEclipse逆向工程工具或DALI实体生成器。选择，单击“确定”，然后完成向导。本教程使用MyEclipse逆向工程工具。
2、选择PRODUCTLINE表，单击添加，然后单击下一步。
在“Java Package”字段中，单击“ Browse”，然后选择先前创建的com.myeclipseide.jpa程序包。选中以下复选框：
- Entity Bean Generation：让MyEclipse生成注释为用作JPA实体的普通Java类。
- Create abstract class；如果您希望自定义生成的类，而不必每次都覆盖更改，则MyEclipse可以生成基本抽象类以及您可以自定义和使用的具体子类。每次进行反向工程时，MyEclipse只会覆盖抽象基类，并在具体子类中保留更改。
- Update persistence.xml：与Hibernate类似，您可以在JPA配置文件中列出正在使用的所有JPA实体。
- Java Data Access Generation：让MyEclipse生成DAO实用程序类，让您可以立即从数据库中保存/查找/更新/删除实体。此代码包含了JPA实体管理器，使得使用实体和数据库变得非常容易。
- Generate Precise findBy Methods：让MyEclipse生成findByXXX方法，其中XXX与反转的实体上的每个属性有关。这样一来，可以使用任何属性作为查找实体的方法，轻松地从数据库访问实体。
- Generate Java Interfaces：选择此选项将创建带有相应DAO实现类的接口类。取消选择此选项仅生成DAO实现类，而没有用于定义接口的单独类。
3、单击完成。查看通过展开com.myeclipseide.jpa包生成的MyEclipse资源。
生成的实体描述如下：
- EntityManagerHelper：使用直接JPA时，开发人员需要使用EntityManager class。EntityManager通过提供用于访问管理器的静态方法以及易于调用的最常用操作，此生成的帮助程序类让使用EntityManager的过程变得更加容易。
- IProductline：定义相应DAO实现类的接口的类。
- Productline：此类是表示数据库表PRODUCTLINE的JPA实体（POJO）。该POJO包含PRODUCTLINE表的字段，并表示数据库中的一行。
- ProductlineDAO：此类包含EntityManagerHelper以便为我们提供易于使用的方法，专门用于在数据库中添加/查找/更新和删除产品。
注意：逆向工程完成后，您可以打开“Persistence”透视图，使用某些持久性和数据源工具来分析数据库和项目中的数据。
**编写应用程序**
由于MyEclipse生成了许多代码，所以您可以快速将精力放在“Business Logic”上，或更具体地说是“实际完成工作的代码”。在本部分中，您将编写一个具有main方法的Java类，该方法将Productline插入数据库，对其进行检索、更新并删除。使用此代码，您会发现在应用程序中使用JPA实体是多么容易！
**一、创建一个类**
1、右键单击com.myeclipseide.jpa软件包，然后选择New Class。
2、在“Name”字段中键入RunJPA，选中Public static void main复选框，然后单击“Finish”。
在构建新类和main方法之后，需要编写代码来操作Productline实例。
**注意：**以下代码看起来很长而且很复杂，这是因为我们试图在一个代码块中显示四个不同的示例。如果您查看每个操作（保存、加载、更新、删除），就会发现它们都不由几行代码组成。
3、将以下代码添加到main方法中，然后按CTRL + S保存。
{{{
/* 1. Create a reference to our ID */
String productLineID = "Men's Shoes";
/* 2. Create a new Productline instance */
Productline newProductline = new Productline(
productLineID,
"Shoes for men.", "Men's Shoes", null);
/* 3. Create a DAO instance to use */
ProductlineDAO dao = new ProductlineDAO();
/* 4. Store our new product line in the DB */
EntityManagerHelper.beginTransaction();
dao.save(newProductline);
EntityManagerHelper.commit();
/* 5. Now retrieve the new product line,
using the ID we created */
Productline loadedProductline = dao.findById(productLineID);
/* 6. Print out the product line information */
System.out.println("*NEW* Product Line
[productLine="
+
loadedProductline.getProductline() + ",
textDescription="
+
loadedProductline.getTextdescription() + ", image="
+
loadedProductline.getImage() + "]");
/*
* 7. Now let's change same value on the product line, and save the
* change
*/
loadedProductline.setTextdescription("Product line for men's shoes.");
EntityManagerHelper.beginTransaction();
dao.save(loadedProductline);
EntityManagerHelper.commit();
/*
* 8. Now let's load the product line from the DB again, and make sure
* it text description changed
*/
Productline secondLoadedProductline =
dao.findById(productLineID);
System.out.println("*REVISED* Product Line ["
+ "productLine=" +
secondLoadedProductline.getProductline()
+ ", textDescription=" +
secondLoadedProductline.getTextdescription()
+ ", image=" +
secondLoadedProductline.getImage() + "]");
/* 9. Now let's delete the product line from the DB */
EntityManagerHelper.beginTransaction();
dao.delete(secondLoadedProductline);
EntityManagerHelper.commit();
/*
* 10. To confirm the deletion, try and load it again and make sure it
* fails
*/
Productline deletedProductline = dao.findById(productLineID);
/*
* We use a simple inlined IF clause to test for null and print
* SUCCESSFUL/FAILED
*/
System.out.println("Productline deletion: "
+ (deletedProductline ==
null ? "SUCCESSFUL" : "FAILED"));
}}}
上面的代码看起来很复杂，但它做了很多简单的事情。例如，如果您只对在数据库中存储新项目感兴趣，则只需要程序中第1-3步中的代码，这相当于（减去注释）三行代码。以下是每个编号部分的细分：
PRODUCTLINE表使用产品线的名称作为主键。为了使本教程更容易理解，我们在字符串中定义了产品线名称，并在代码中多次运用（创建和存储产品线，然后检索两次）。
这将创建由MyEclipse生成的Productline POJO的新实例，并将其插入数据库中。对于本教程而言，这些值并不重要，所以我们只使用示例信息。
这将创建要使用的DAO实例。数据库访问需要DAO（这也是由MyEclipse生成的）。
这让DAO将新的产品系列存储在数据库中。因为要向数据库中写入一些内容，所以将save调用包含在事务中。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
为了确保使用第1步中定义的ID正确存储了产品系列，我们要求DAO获取产品系列，并将结果分配给一个全新的对象，以完全确保从数据库中加载了什么。（我们可以将值分配回newProductline，但是出于本教程的目的，我们必须清楚地知道对象来源，并且加载的实例之前在代码中不存在）。
这将从已加载的实体中打印出值，以确保它只是存储在数据库中的值。
这将更改刚刚加载的POJO的值，以显示更新记录的工作方式。然后，使用DAO将更改提交回数据库。同样的，此操作被包含在事务中，以确保安全地更改数据库。
与步骤5一样，使用在步骤1中定义的ID从数据库中重新加载记录，以确保更新操作有效。然后打印出POJO值，以确保新描述已保存到数据库中。
这显示了如何从数据库删除记录。同样的，由于这需要更改数据库，因此该代码被包含在事务中。
与第8步和第5步类似，为了证明删除有效，我们尝试使用给定的ID从数据库加载实体。因为我们已经删除了Productline，所以这个操作应该是失败的。从DAO获得结果后，将使用嵌入式IF子句打印一条语句，以确保结果为null。
**二、运行应用程序**
1、右键单击项目，然后选择Run As > Java Application。
2、选择RunJPA应用程序，然后单击“确定”。
输出显示在Console视图中。
红色文本是来自MyEclipse中生成的DAO和EntityHelper类的默认日志消息。黑色文本是代码中用于跟踪进度的System.out.println文本。如您所见，第6步中的第一个打印输出和第8步中的更新打印输出都按预期工作。并且查询没有返回Productline，证明删除也很成功。
**资源**
[Oracle JPA注释参考](https://www.oracle.com/technet ... 1.html)
[BEA JPQL参考](https://www.evget.com/resource ... -17577) 查看全部
**建立一个项目**
一般情况，JPA Facet将被添加到Java或Web项目中。在本教程中，您将使用一个简单的Java项目来查看JPA的工作方式。
注意：您可以[下载本教程中开发的项目](https://www.evget.com/resource/detail-demo-14494)，然后导入到您的工作区中。
1、单击下拉箭头，然后选择Java Project。
2、在“Project Name”字段中输入SampleJPAProject，选择默认选项，然后单击“完成”。
3、单击，选择MyEclipse Database Explorer打开透视图。
4、在数据库浏览器中，选择MyEclipse Derby连接，然后单击。
**注意：**在建立数据库连接之前，无法添加JPA Facet，因为需要选择要使用的连接。
5、切换回MyEclipse Java Enterprise透视图，右键单击项目，然后选择**[MyEclipse](https://www.myeclipsecn.com/)** > Project Facets > Install JPA Facet。
6、在目标运行时下拉列表中选择MyEclipse通用Java运行时，然后单击下一步。
7、从平台下拉列表中选择一个平台，如果JPA实现类型默认为用户库，则选择与所选平台相对应的库。如果未列出任何库，可单击下载适当的库。
8、在“Connection”字段中选择MyEclipse Derby，选中“Add driver library to build path”和“Override default schema”复选框，然后从“Schema”下拉列表中选择CLASSICCARS。单击完成。
现在，项目中已添加了完全配置的JPA Facet，其中包括JPA配置信息/DB连接信息以及添加到项目构建路径中的所有必需的JDBC和JPA库。如果这是一个Web项目，在将项目部署到应用程序服务器上并在其中运行时，所有构建路径的附加内容都将准备好进行部署。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
**创建一个Java包**
在下一个步骤中，对数据库表中的数据进行反向工程，并为项目生成实体。在进行逆向工程之前，需要创建一个Java包，并在其中放置这些实体。
1、展开项目，右键单击src文件夹，然后选择New > Package。
2、在“Name”字段中输入com.myeclipseide.jpa，然后单击“完成”。
**逆向工程数据库表**
现在已经建立了项目，可以将PRODUCTLINE表反向工程到项目中，并开始使用所生成的实体。
1、右键单击该项目，然后选择JPA Tools > Generate Entities & DAOs。
**注意：**您可以选择使用MyEclipse逆向工程工具或DALI实体生成器。选择，单击“确定”，然后完成向导。本教程使用MyEclipse逆向工程工具。
2、选择PRODUCTLINE表，单击添加，然后单击下一步。
在“Java Package”字段中，单击“ Browse”，然后选择先前创建的com.myeclipseide.jpa程序包。选中以下复选框：
- Entity Bean Generation：让MyEclipse生成注释为用作JPA实体的普通Java类。
- Create abstract class；如果您希望自定义生成的类，而不必每次都覆盖更改，则MyEclipse可以生成基本抽象类以及您可以自定义和使用的具体子类。每次进行反向工程时，MyEclipse只会覆盖抽象基类，并在具体子类中保留更改。
- Update persistence.xml：与Hibernate类似，您可以在JPA配置文件中列出正在使用的所有JPA实体。
- Java Data Access Generation：让MyEclipse生成DAO实用程序类，让您可以立即从数据库中保存/查找/更新/删除实体。此代码包含了JPA实体管理器，使得使用实体和数据库变得非常容易。
- Generate Precise findBy Methods：让MyEclipse生成findByXXX方法，其中XXX与反转的实体上的每个属性有关。这样一来，可以使用任何属性作为查找实体的方法，轻松地从数据库访问实体。
- Generate Java Interfaces：选择此选项将创建带有相应DAO实现类的接口类。取消选择此选项仅生成DAO实现类，而没有用于定义接口的单独类。
3、单击完成。查看通过展开com.myeclipseide.jpa包生成的MyEclipse资源。
生成的实体描述如下：
- EntityManagerHelper：使用直接JPA时，开发人员需要使用EntityManager class。EntityManager通过提供用于访问管理器的静态方法以及易于调用的最常用操作，此生成的帮助程序类让使用EntityManager的过程变得更加容易。
- IProductline：定义相应DAO实现类的接口的类。
- Productline：此类是表示数据库表PRODUCTLINE的JPA实体（POJO）。该POJO包含PRODUCTLINE表的字段，并表示数据库中的一行。
- ProductlineDAO：此类包含EntityManagerHelper以便为我们提供易于使用的方法，专门用于在数据库中添加/查找/更新和删除产品。
注意：逆向工程完成后，您可以打开“Persistence”透视图，使用某些持久性和数据源工具来分析数据库和项目中的数据。
**编写应用程序**
由于MyEclipse生成了许多代码，所以您可以快速将精力放在“Business Logic”上，或更具体地说是“实际完成工作的代码”。在本部分中，您将编写一个具有main方法的Java类，该方法将Productline插入数据库，对其进行检索、更新并删除。使用此代码，您会发现在应用程序中使用JPA实体是多么容易！
**一、创建一个类**
1、右键单击com.myeclipseide.jpa软件包，然后选择New Class。
2、在“Name”字段中键入RunJPA，选中Public static void main复选框，然后单击“Finish”。
在构建新类和main方法之后，需要编写代码来操作Productline实例。
**注意：**以下代码看起来很长而且很复杂，这是因为我们试图在一个代码块中显示四个不同的示例。如果您查看每个操作（保存、加载、更新、删除），就会发现它们都不由几行代码组成。
3、将以下代码添加到main方法中，然后按CTRL + S保存。
{{{
/* 1. Create a reference to our ID */
String productLineID = "Men's Shoes";
/* 2. Create a new Productline instance */
Productline newProductline = new Productline(
productLineID,
"Shoes for men.", "Men's Shoes", null);
/* 3. Create a DAO instance to use */
ProductlineDAO dao = new ProductlineDAO();
/* 4. Store our new product line in the DB */
EntityManagerHelper.beginTransaction();
dao.save(newProductline);
EntityManagerHelper.commit();
/* 5. Now retrieve the new product line,
using the ID we created */
Productline loadedProductline = dao.findById(productLineID);
/* 6. Print out the product line information */
System.out.println("*NEW* Product Line
[productLine="
+
loadedProductline.getProductline() + ",
textDescription="
+
loadedProductline.getTextdescription() + ", image="
+
loadedProductline.getImage() + "]");
/*
* 7. Now let's change same value on the product line, and save the
* change
*/
loadedProductline.setTextdescription("Product line for men's shoes.");
EntityManagerHelper.beginTransaction();
dao.save(loadedProductline);
EntityManagerHelper.commit();
/*
* 8. Now let's load the product line from the DB again, and make sure
* it text description changed
*/
Productline secondLoadedProductline =
dao.findById(productLineID);
System.out.println("*REVISED* Product Line ["
+ "productLine=" +
secondLoadedProductline.getProductline()
+ ", textDescription=" +
secondLoadedProductline.getTextdescription()
+ ", image=" +
secondLoadedProductline.getImage() + "]");
/* 9. Now let's delete the product line from the DB */
EntityManagerHelper.beginTransaction();
dao.delete(secondLoadedProductline);
EntityManagerHelper.commit();
/*
* 10. To confirm the deletion, try and load it again and make sure it
* fails
*/
Productline deletedProductline = dao.findById(productLineID);
/*
* We use a simple inlined IF clause to test for null and print
* SUCCESSFUL/FAILED
*/
System.out.println("Productline deletion: "
+ (deletedProductline ==
null ? "SUCCESSFUL" : "FAILED"));
}}}
上面的代码看起来很复杂，但它做了很多简单的事情。例如，如果您只对在数据库中存储新项目感兴趣，则只需要程序中第1-3步中的代码，这相当于（减去注释）三行代码。以下是每个编号部分的细分：
PRODUCTLINE表使用产品线的名称作为主键。为了使本教程更容易理解，我们在字符串中定义了产品线名称，并在代码中多次运用（创建和存储产品线，然后检索两次）。
这将创建由MyEclipse生成的Productline POJO的新实例，并将其插入数据库中。对于本教程而言，这些值并不重要，所以我们只使用示例信息。
这将创建要使用的DAO实例。数据库访问需要DAO（这也是由MyEclipse生成的）。
这让DAO将新的产品系列存储在数据库中。因为要向数据库中写入一些内容，所以将save调用包含在事务中。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
为了确保使用第1步中定义的ID正确存储了产品系列，我们要求DAO获取产品系列，并将结果分配给一个全新的对象，以完全确保从数据库中加载了什么。（我们可以将值分配回newProductline，但是出于本教程的目的，我们必须清楚地知道对象来源，并且加载的实例之前在代码中不存在）。
这将从已加载的实体中打印出值，以确保它只是存储在数据库中的值。
这将更改刚刚加载的POJO的值，以显示更新记录的工作方式。然后，使用DAO将更改提交回数据库。同样的，此操作被包含在事务中，以确保安全地更改数据库。
与步骤5一样，使用在步骤1中定义的ID从数据库中重新加载记录，以确保更新操作有效。然后打印出POJO值，以确保新描述已保存到数据库中。
这显示了如何从数据库删除记录。同样的，由于这需要更改数据库，因此该代码被包含在事务中。
与第8步和第5步类似，为了证明删除有效，我们尝试使用给定的ID从数据库加载实体。因为我们已经删除了Productline，所以这个操作应该是失败的。从DAO获得结果后，将使用嵌入式IF子句打印一条语句，以确保结果为null。
**二、运行应用程序**
1、右键单击项目，然后选择Run As > Java Application。
2、选择RunJPA应用程序，然后单击“确定”。
输出显示在Console视图中。
红色文本是来自MyEclipse中生成的DAO和EntityHelper类的默认日志消息。黑色文本是代码中用于跟踪进度的System.out.println文本。如您所见，第6步中的第一个打印输出和第8步中的更新打印输出都按预期工作。并且查询没有返回Productline，证明删除也很成功。
**资源**
[Oracle JPA注释参考](https://www.oracle.com/technet ... 1.html)
[BEA JPQL参考](https://www.evget.com/resource ... -17577)
一般情况，JPA Facet将被添加到Java或Web项目中。在本教程中，您将使用一个简单的Java项目来查看JPA的工作方式。
注意：您可以[下载本教程中开发的项目](https://www.evget.com/resource/detail-demo-14494)，然后导入到您的工作区中。
1、单击下拉箭头，然后选择Java Project。
2、在“Project Name”字段中输入SampleJPAProject，选择默认选项，然后单击“完成”。
3、单击，选择MyEclipse Database Explorer打开透视图。
4、在数据库浏览器中，选择MyEclipse Derby连接，然后单击。
**注意：**在建立数据库连接之前，无法添加JPA Facet，因为需要选择要使用的连接。
5、切换回MyEclipse Java Enterprise透视图，右键单击项目，然后选择**[MyEclipse](https://www.myeclipsecn.com/)** > Project Facets > Install JPA Facet。
6、在目标运行时下拉列表中选择MyEclipse通用Java运行时，然后单击下一步。
7、从平台下拉列表中选择一个平台，如果JPA实现类型默认为用户库，则选择与所选平台相对应的库。如果未列出任何库，可单击下载适当的库。
8、在“Connection”字段中选择MyEclipse Derby，选中“Add driver library to build path”和“Override default schema”复选框，然后从“Schema”下拉列表中选择CLASSICCARS。单击完成。
现在，项目中已添加了完全配置的JPA Facet，其中包括JPA配置信息/DB连接信息以及添加到项目构建路径中的所有必需的JDBC和JPA库。如果这是一个Web项目，在将项目部署到应用程序服务器上并在其中运行时，所有构建路径的附加内容都将准备好进行部署。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
**创建一个Java包**
在下一个步骤中，对数据库表中的数据进行反向工程，并为项目生成实体。在进行逆向工程之前，需要创建一个Java包，并在其中放置这些实体。
1、展开项目，右键单击src文件夹，然后选择New > Package。
2、在“Name”字段中输入com.myeclipseide.jpa，然后单击“完成”。
**逆向工程数据库表**
现在已经建立了项目，可以将PRODUCTLINE表反向工程到项目中，并开始使用所生成的实体。
1、右键单击该项目，然后选择JPA Tools > Generate Entities & DAOs。
**注意：**您可以选择使用MyEclipse逆向工程工具或DALI实体生成器。选择，单击“确定”，然后完成向导。本教程使用MyEclipse逆向工程工具。
2、选择PRODUCTLINE表，单击添加，然后单击下一步。
在“Java Package”字段中，单击“ Browse”，然后选择先前创建的com.myeclipseide.jpa程序包。选中以下复选框：
- Entity Bean Generation：让MyEclipse生成注释为用作JPA实体的普通Java类。
- Create abstract class；如果您希望自定义生成的类，而不必每次都覆盖更改，则MyEclipse可以生成基本抽象类以及您可以自定义和使用的具体子类。每次进行反向工程时，MyEclipse只会覆盖抽象基类，并在具体子类中保留更改。
- Update persistence.xml：与Hibernate类似，您可以在JPA配置文件中列出正在使用的所有JPA实体。
- Java Data Access Generation：让MyEclipse生成DAO实用程序类，让您可以立即从数据库中保存/查找/更新/删除实体。此代码包含了JPA实体管理器，使得使用实体和数据库变得非常容易。
- Generate Precise findBy Methods：让MyEclipse生成findByXXX方法，其中XXX与反转的实体上的每个属性有关。这样一来，可以使用任何属性作为查找实体的方法，轻松地从数据库访问实体。
- Generate Java Interfaces：选择此选项将创建带有相应DAO实现类的接口类。取消选择此选项仅生成DAO实现类，而没有用于定义接口的单独类。
3、单击完成。查看通过展开com.myeclipseide.jpa包生成的MyEclipse资源。
生成的实体描述如下：
- EntityManagerHelper：使用直接JPA时，开发人员需要使用EntityManager class。EntityManager通过提供用于访问管理器的静态方法以及易于调用的最常用操作，此生成的帮助程序类让使用EntityManager的过程变得更加容易。
- IProductline：定义相应DAO实现类的接口的类。
- Productline：此类是表示数据库表PRODUCTLINE的JPA实体（POJO）。该POJO包含PRODUCTLINE表的字段，并表示数据库中的一行。
- ProductlineDAO：此类包含EntityManagerHelper以便为我们提供易于使用的方法，专门用于在数据库中添加/查找/更新和删除产品。
注意：逆向工程完成后，您可以打开“Persistence”透视图，使用某些持久性和数据源工具来分析数据库和项目中的数据。
**编写应用程序**
由于MyEclipse生成了许多代码，所以您可以快速将精力放在“Business Logic”上，或更具体地说是“实际完成工作的代码”。在本部分中，您将编写一个具有main方法的Java类，该方法将Productline插入数据库，对其进行检索、更新并删除。使用此代码，您会发现在应用程序中使用JPA实体是多么容易！
**一、创建一个类**
1、右键单击com.myeclipseide.jpa软件包，然后选择New Class。
2、在“Name”字段中键入RunJPA，选中Public static void main复选框，然后单击“Finish”。
在构建新类和main方法之后，需要编写代码来操作Productline实例。
**注意：**以下代码看起来很长而且很复杂，这是因为我们试图在一个代码块中显示四个不同的示例。如果您查看每个操作（保存、加载、更新、删除），就会发现它们都不由几行代码组成。
3、将以下代码添加到main方法中，然后按CTRL + S保存。
{{{
/* 1. Create a reference to our ID */
String productLineID = "Men's Shoes";
/* 2. Create a new Productline instance */
Productline newProductline = new Productline(
productLineID,
"Shoes for men.", "Men's Shoes", null);
/* 3. Create a DAO instance to use */
ProductlineDAO dao = new ProductlineDAO();
/* 4. Store our new product line in the DB */
EntityManagerHelper.beginTransaction();
dao.save(newProductline);
EntityManagerHelper.commit();
/* 5. Now retrieve the new product line,
using the ID we created */
Productline loadedProductline = dao.findById(productLineID);
/* 6. Print out the product line information */
System.out.println("*NEW* Product Line
[productLine="
+
loadedProductline.getProductline() + ",
textDescription="
+
loadedProductline.getTextdescription() + ", image="
+
loadedProductline.getImage() + "]");
/*
* 7. Now let's change same value on the product line, and save the
* change
*/
loadedProductline.setTextdescription("Product line for men's shoes.");
EntityManagerHelper.beginTransaction();
dao.save(loadedProductline);
EntityManagerHelper.commit();
/*
* 8. Now let's load the product line from the DB again, and make sure
* it text description changed
*/
Productline secondLoadedProductline =
dao.findById(productLineID);
System.out.println("*REVISED* Product Line ["
+ "productLine=" +
secondLoadedProductline.getProductline()
+ ", textDescription=" +
secondLoadedProductline.getTextdescription()
+ ", image=" +
secondLoadedProductline.getImage() + "]");
/* 9. Now let's delete the product line from the DB */
EntityManagerHelper.beginTransaction();
dao.delete(secondLoadedProductline);
EntityManagerHelper.commit();
/*
* 10. To confirm the deletion, try and load it again and make sure it
* fails
*/
Productline deletedProductline = dao.findById(productLineID);
/*
* We use a simple inlined IF clause to test for null and print
* SUCCESSFUL/FAILED
*/
System.out.println("Productline deletion: "
+ (deletedProductline ==
null ? "SUCCESSFUL" : "FAILED"));
}}}
上面的代码看起来很复杂，但它做了很多简单的事情。例如，如果您只对在数据库中存储新项目感兴趣，则只需要程序中第1-3步中的代码，这相当于（减去注释）三行代码。以下是每个编号部分的细分：
PRODUCTLINE表使用产品线的名称作为主键。为了使本教程更容易理解，我们在字符串中定义了产品线名称，并在代码中多次运用（创建和存储产品线，然后检索两次）。
这将创建由MyEclipse生成的Productline POJO的新实例，并将其插入数据库中。对于本教程而言，这些值并不重要，所以我们只使用示例信息。
这将创建要使用的DAO实例。数据库访问需要DAO（这也是由MyEclipse生成的）。
这让DAO将新的产品系列存储在数据库中。因为要向数据库中写入一些内容，所以将save调用包含在事务中。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
为了确保使用第1步中定义的ID正确存储了产品系列，我们要求DAO获取产品系列，并将结果分配给一个全新的对象，以完全确保从数据库中加载了什么。（我们可以将值分配回newProductline，但是出于本教程的目的，我们必须清楚地知道对象来源，并且加载的实例之前在代码中不存在）。
这将从已加载的实体中打印出值，以确保它只是存储在数据库中的值。
这将更改刚刚加载的POJO的值，以显示更新记录的工作方式。然后，使用DAO将更改提交回数据库。同样的，此操作被包含在事务中，以确保安全地更改数据库。
与步骤5一样，使用在步骤1中定义的ID从数据库中重新加载记录，以确保更新操作有效。然后打印出POJO值，以确保新描述已保存到数据库中。
这显示了如何从数据库删除记录。同样的，由于这需要更改数据库，因此该代码被包含在事务中。
与第8步和第5步类似，为了证明删除有效，我们尝试使用给定的ID从数据库加载实体。因为我们已经删除了Productline，所以这个操作应该是失败的。从DAO获得结果后，将使用嵌入式IF子句打印一条语句，以确保结果为null。
**二、运行应用程序**
1、右键单击项目，然后选择Run As > Java Application。
2、选择RunJPA应用程序，然后单击“确定”。
输出显示在Console视图中。
红色文本是来自MyEclipse中生成的DAO和EntityHelper类的默认日志消息。黑色文本是代码中用于跟踪进度的System.out.println文本。如您所见，第6步中的第一个打印输出和第8步中的更新打印输出都按预期工作。并且查询没有返回Productline，证明删除也很成功。
**资源**
[Oracle JPA注释参考](https://www.oracle.com/technet ... 1.html)
[BEA JPQL参考](https://www.evget.com/resource ... -17577)
【教程连载-数据库篇】Oracle使用方法
Java EE开发 • besy 发表了文章 • 0 个评论 • 60 次浏览 • 2015-03-02 10:07
**1. 在MyEclipse中使用Oracle功能**
在MyEclipse中开发应用程序时需要进行数据处理，同时你也可以直接访问Oracle数据库的许多功能。
浏览、创建和编辑Oracle类型：
别名
视图
序列
触发器
存储过程
功能
包
包主体
java程序
会话
数据库链接
监视器（活动会话，顶端SQL，进程）
安全性（用户信息）
实例信息（系统数据，表空间等）
**点击查看完整原文：[MyEclipse中的Oracle使用方法](http://www.myeclipsecn.com/lea ... lipse/)**
## 还没有MyEclipse？[立即下载](http://www.myeclipsecn.com/download/) ## 查看全部
在MyEclipse中开发应用程序时需要进行数据处理，同时你也可以直接访问Oracle数据库的许多功能。
浏览、创建和编辑Oracle类型：
别名
视图
序列
触发器
存储过程
功能
包
包主体
java程序
会话
数据库链接
监视器（活动会话，顶端SQL，进程）
安全性（用户信息）
实例信息（系统数据，表空间等）
**点击查看完整原文：[MyEclipse中的Oracle使用方法](http://www.myeclipsecn.com/lea ... lipse/)**
## 还没有MyEclipse？[立即下载](http://www.myeclipsecn.com/download/) ## 查看全部
**1. 在MyEclipse中使用Oracle功能**
在MyEclipse中开发应用程序时需要进行数据处理，同时你也可以直接访问Oracle数据库的许多功能。
浏览、创建和编辑Oracle类型：
别名
视图
序列
触发器
存储过程
功能
包
包主体
java程序
会话
数据库链接
监视器（活动会话，顶端SQL，进程）
安全性（用户信息）
实例信息（系统数据，表空间等）
**点击查看完整原文：[MyEclipse中的Oracle使用方法](http://www.myeclipsecn.com/lea ... lipse/)**
## 还没有MyEclipse？[立即下载](http://www.myeclipsecn.com/download/) ##
在MyEclipse中开发应用程序时需要进行数据处理，同时你也可以直接访问Oracle数据库的许多功能。
浏览、创建和编辑Oracle类型：
别名
视图
序列
触发器
存储过程
功能
包
包主体
java程序
会话
数据库链接
监视器（活动会话，顶端SQL，进程）
安全性（用户信息）
实例信息（系统数据，表空间等）
**点击查看完整原文：[MyEclipse中的Oracle使用方法](http://www.myeclipsecn.com/lea ... lipse/)**
## 还没有MyEclipse？[立即下载](http://www.myeclipsecn.com/download/) ##
MyEclipse数据库教程：使用Java项目查看JPA工作方式
Java EE开发 • momo77 发表了文章 • 0 个评论 • 273 次浏览 • 2019-11-27 16:57
**建立一个项目**
一般情况，JPA Facet将被添加到Java或Web项目中。在本教程中，您将使用一个简单的Java项目来查看JPA的工作方式。
注意：您可以[下载本教程中开发的项目](https://www.evget.com/resource/detail-demo-14494)，然后导入到您的工作区中。
1、单击下拉箭头，然后选择Java Project。
2、在“Project Name”字段中输入SampleJPAProject，选择默认选项，然后单击“完成”。
3、单击，选择MyEclipse Database Explorer打开透视图。
4、在数据库浏览器中，选择MyEclipse Derby连接，然后单击。
**注意：**在建立数据库连接之前，无法添加JPA Facet，因为需要选择要使用的连接。
5、切换回MyEclipse Java Enterprise透视图，右键单击项目，然后选择**[MyEclipse](https://www.myeclipsecn.com/)** > Project Facets > Install JPA Facet。
6、在目标运行时下拉列表中选择MyEclipse通用Java运行时，然后单击下一步。
7、从平台下拉列表中选择一个平台，如果JPA实现类型默认为用户库，则选择与所选平台相对应的库。如果未列出任何库，可单击下载适当的库。
8、在“Connection”字段中选择MyEclipse Derby，选中“Add driver library to build path”和“Override default schema”复选框，然后从“Schema”下拉列表中选择CLASSICCARS。单击完成。
现在，项目中已添加了完全配置的JPA Facet，其中包括JPA配置信息/DB连接信息以及添加到项目构建路径中的所有必需的JDBC和JPA库。如果这是一个Web项目，在将项目部署到应用程序服务器上并在其中运行时，所有构建路径的附加内容都将准备好进行部署。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
**创建一个Java包**
在下一个步骤中，对数据库表中的数据进行反向工程，并为项目生成实体。在进行逆向工程之前，需要创建一个Java包，并在其中放置这些实体。
1、展开项目，右键单击src文件夹，然后选择New > Package。
2、在“Name”字段中输入com.myeclipseide.jpa，然后单击“完成”。
**逆向工程数据库表**
现在已经建立了项目，可以将PRODUCTLINE表反向工程到项目中，并开始使用所生成的实体。
1、右键单击该项目，然后选择JPA Tools > Generate Entities & DAOs。
**注意：**您可以选择使用MyEclipse逆向工程工具或DALI实体生成器。选择，单击“确定”，然后完成向导。本教程使用MyEclipse逆向工程工具。
2、选择PRODUCTLINE表，单击添加，然后单击下一步。
在“Java Package”字段中，单击“ Browse”，然后选择先前创建的com.myeclipseide.jpa程序包。选中以下复选框：
- Entity Bean Generation：让MyEclipse生成注释为用作JPA实体的普通Java类。
- Create abstract class；如果您希望自定义生成的类，而不必每次都覆盖更改，则MyEclipse可以生成基本抽象类以及您可以自定义和使用的具体子类。每次进行反向工程时，MyEclipse只会覆盖抽象基类，并在具体子类中保留更改。
- Update persistence.xml：与Hibernate类似，您可以在JPA配置文件中列出正在使用的所有JPA实体。
- Java Data Access Generation：让MyEclipse生成DAO实用程序类，让您可以立即从数据库中保存/查找/更新/删除实体。此代码包含了JPA实体管理器，使得使用实体和数据库变得非常容易。
- Generate Precise findBy Methods：让MyEclipse生成findByXXX方法，其中XXX与反转的实体上的每个属性有关。这样一来，可以使用任何属性作为查找实体的方法，轻松地从数据库访问实体。
- Generate Java Interfaces：选择此选项将创建带有相应DAO实现类的接口类。取消选择此选项仅生成DAO实现类，而没有用于定义接口的单独类。
3、单击完成。查看通过展开com.myeclipseide.jpa包生成的MyEclipse资源。
生成的实体描述如下：
- EntityManagerHelper：使用直接JPA时，开发人员需要使用EntityManager class。EntityManager通过提供用于访问管理器的静态方法以及易于调用的最常用操作，此生成的帮助程序类让使用EntityManager的过程变得更加容易。
- IProductline：定义相应DAO实现类的接口的类。
- Productline：此类是表示数据库表PRODUCTLINE的JPA实体（POJO）。该POJO包含PRODUCTLINE表的字段，并表示数据库中的一行。
- ProductlineDAO：此类包含EntityManagerHelper以便为我们提供易于使用的方法，专门用于在数据库中添加/查找/更新和删除产品。
注意：逆向工程完成后，您可以打开“Persistence”透视图，使用某些持久性和数据源工具来分析数据库和项目中的数据。
**编写应用程序**
由于MyEclipse生成了许多代码，所以您可以快速将精力放在“Business Logic”上，或更具体地说是“实际完成工作的代码”。在本部分中，您将编写一个具有main方法的Java类，该方法将Productline插入数据库，对其进行检索、更新并删除。使用此代码，您会发现在应用程序中使用JPA实体是多么容易！
**一、创建一个类**
1、右键单击com.myeclipseide.jpa软件包，然后选择New Class。
2、在“Name”字段中键入RunJPA，选中Public static void main复选框，然后单击“Finish”。
在构建新类和main方法之后，需要编写代码来操作Productline实例。
**注意：**以下代码看起来很长而且很复杂，这是因为我们试图在一个代码块中显示四个不同的示例。如果您查看每个操作（保存、加载、更新、删除），就会发现它们都不由几行代码组成。
3、将以下代码添加到main方法中，然后按CTRL + S保存。
{{{
/* 1. Create a reference to our ID */
String productLineID = "Men's Shoes";
/* 2. Create a new Productline instance */
Productline newProductline = new Productline(
productLineID,
"Shoes for men.", "Men's Shoes", null);
/* 3. Create a DAO instance to use */
ProductlineDAO dao = new ProductlineDAO();
/* 4. Store our new product line in the DB */
EntityManagerHelper.beginTransaction();
dao.save(newProductline);
EntityManagerHelper.commit();
/* 5. Now retrieve the new product line,
using the ID we created */
Productline loadedProductline = dao.findById(productLineID);
/* 6. Print out the product line information */
System.out.println("*NEW* Product Line
[productLine="
+
loadedProductline.getProductline() + ",
textDescription="
+
loadedProductline.getTextdescription() + ", image="
+
loadedProductline.getImage() + "]");
/*
* 7. Now let's change same value on the product line, and save the
* change
*/
loadedProductline.setTextdescription("Product line for men's shoes.");
EntityManagerHelper.beginTransaction();
dao.save(loadedProductline);
EntityManagerHelper.commit();
/*
* 8. Now let's load the product line from the DB again, and make sure
* it text description changed
*/
Productline secondLoadedProductline =
dao.findById(productLineID);
System.out.println("*REVISED* Product Line ["
+ "productLine=" +
secondLoadedProductline.getProductline()
+ ", textDescription=" +
secondLoadedProductline.getTextdescription()
+ ", image=" +
secondLoadedProductline.getImage() + "]");
/* 9. Now let's delete the product line from the DB */
EntityManagerHelper.beginTransaction();
dao.delete(secondLoadedProductline);
EntityManagerHelper.commit();
/*
* 10. To confirm the deletion, try and load it again and make sure it
* fails
*/
Productline deletedProductline = dao.findById(productLineID);
/*
* We use a simple inlined IF clause to test for null and print
* SUCCESSFUL/FAILED
*/
System.out.println("Productline deletion: "
+ (deletedProductline ==
null ? "SUCCESSFUL" : "FAILED"));
}}}
上面的代码看起来很复杂，但它做了很多简单的事情。例如，如果您只对在数据库中存储新项目感兴趣，则只需要程序中第1-3步中的代码，这相当于（减去注释）三行代码。以下是每个编号部分的细分：
PRODUCTLINE表使用产品线的名称作为主键。为了使本教程更容易理解，我们在字符串中定义了产品线名称，并在代码中多次运用（创建和存储产品线，然后检索两次）。
这将创建由MyEclipse生成的Productline POJO的新实例，并将其插入数据库中。对于本教程而言，这些值并不重要，所以我们只使用示例信息。
这将创建要使用的DAO实例。数据库访问需要DAO（这也是由MyEclipse生成的）。
这让DAO将新的产品系列存储在数据库中。因为要向数据库中写入一些内容，所以将save调用包含在事务中。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
为了确保使用第1步中定义的ID正确存储了产品系列，我们要求DAO获取产品系列，并将结果分配给一个全新的对象，以完全确保从数据库中加载了什么。（我们可以将值分配回newProductline，但是出于本教程的目的，我们必须清楚地知道对象来源，并且加载的实例之前在代码中不存在）。
这将从已加载的实体中打印出值，以确保它只是存储在数据库中的值。
这将更改刚刚加载的POJO的值，以显示更新记录的工作方式。然后，使用DAO将更改提交回数据库。同样的，此操作被包含在事务中，以确保安全地更改数据库。
与步骤5一样，使用在步骤1中定义的ID从数据库中重新加载记录，以确保更新操作有效。然后打印出POJO值，以确保新描述已保存到数据库中。
这显示了如何从数据库删除记录。同样的，由于这需要更改数据库，因此该代码被包含在事务中。
与第8步和第5步类似，为了证明删除有效，我们尝试使用给定的ID从数据库加载实体。因为我们已经删除了Productline，所以这个操作应该是失败的。从DAO获得结果后，将使用嵌入式IF子句打印一条语句，以确保结果为null。
**二、运行应用程序**
1、右键单击项目，然后选择Run As > Java Application。
2、选择RunJPA应用程序，然后单击“确定”。
输出显示在Console视图中。
红色文本是来自MyEclipse中生成的DAO和EntityHelper类的默认日志消息。黑色文本是代码中用于跟踪进度的System.out.println文本。如您所见，第6步中的第一个打印输出和第8步中的更新打印输出都按预期工作。并且查询没有返回Productline，证明删除也很成功。
**资源**
[Oracle JPA注释参考](https://www.oracle.com/technet ... 1.html)
[BEA JPQL参考](https://www.evget.com/resource ... -17577) 查看全部
一般情况，JPA Facet将被添加到Java或Web项目中。在本教程中，您将使用一个简单的Java项目来查看JPA的工作方式。
注意：您可以[下载本教程中开发的项目](https://www.evget.com/resource/detail-demo-14494)，然后导入到您的工作区中。
1、单击下拉箭头，然后选择Java Project。
2、在“Project Name”字段中输入SampleJPAProject，选择默认选项，然后单击“完成”。
3、单击，选择MyEclipse Database Explorer打开透视图。
4、在数据库浏览器中，选择MyEclipse Derby连接，然后单击。
**注意：**在建立数据库连接之前，无法添加JPA Facet，因为需要选择要使用的连接。
5、切换回MyEclipse Java Enterprise透视图，右键单击项目，然后选择**[MyEclipse](https://www.myeclipsecn.com/)** > Project Facets > Install JPA Facet。
6、在目标运行时下拉列表中选择MyEclipse通用Java运行时，然后单击下一步。
7、从平台下拉列表中选择一个平台，如果JPA实现类型默认为用户库，则选择与所选平台相对应的库。如果未列出任何库，可单击下载适当的库。
8、在“Connection”字段中选择MyEclipse Derby，选中“Add driver library to build path”和“Override default schema”复选框，然后从“Schema”下拉列表中选择CLASSICCARS。单击完成。
现在，项目中已添加了完全配置的JPA Facet，其中包括JPA配置信息/DB连接信息以及添加到项目构建路径中的所有必需的JDBC和JPA库。如果这是一个Web项目，在将项目部署到应用程序服务器上并在其中运行时，所有构建路径的附加内容都将准备好进行部署。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
**创建一个Java包**
在下一个步骤中，对数据库表中的数据进行反向工程，并为项目生成实体。在进行逆向工程之前，需要创建一个Java包，并在其中放置这些实体。
1、展开项目，右键单击src文件夹，然后选择New > Package。
2、在“Name”字段中输入com.myeclipseide.jpa，然后单击“完成”。
**逆向工程数据库表**
现在已经建立了项目，可以将PRODUCTLINE表反向工程到项目中，并开始使用所生成的实体。
1、右键单击该项目，然后选择JPA Tools > Generate Entities & DAOs。
**注意：**您可以选择使用MyEclipse逆向工程工具或DALI实体生成器。选择，单击“确定”，然后完成向导。本教程使用MyEclipse逆向工程工具。
2、选择PRODUCTLINE表，单击添加，然后单击下一步。
在“Java Package”字段中，单击“ Browse”，然后选择先前创建的com.myeclipseide.jpa程序包。选中以下复选框：
- Entity Bean Generation：让MyEclipse生成注释为用作JPA实体的普通Java类。
- Create abstract class；如果您希望自定义生成的类，而不必每次都覆盖更改，则MyEclipse可以生成基本抽象类以及您可以自定义和使用的具体子类。每次进行反向工程时，MyEclipse只会覆盖抽象基类，并在具体子类中保留更改。
- Update persistence.xml：与Hibernate类似，您可以在JPA配置文件中列出正在使用的所有JPA实体。
- Java Data Access Generation：让MyEclipse生成DAO实用程序类，让您可以立即从数据库中保存/查找/更新/删除实体。此代码包含了JPA实体管理器，使得使用实体和数据库变得非常容易。
- Generate Precise findBy Methods：让MyEclipse生成findByXXX方法，其中XXX与反转的实体上的每个属性有关。这样一来，可以使用任何属性作为查找实体的方法，轻松地从数据库访问实体。
- Generate Java Interfaces：选择此选项将创建带有相应DAO实现类的接口类。取消选择此选项仅生成DAO实现类，而没有用于定义接口的单独类。
3、单击完成。查看通过展开com.myeclipseide.jpa包生成的MyEclipse资源。
生成的实体描述如下：
- EntityManagerHelper：使用直接JPA时，开发人员需要使用EntityManager class。EntityManager通过提供用于访问管理器的静态方法以及易于调用的最常用操作，此生成的帮助程序类让使用EntityManager的过程变得更加容易。
- IProductline：定义相应DAO实现类的接口的类。
- Productline：此类是表示数据库表PRODUCTLINE的JPA实体（POJO）。该POJO包含PRODUCTLINE表的字段，并表示数据库中的一行。
- ProductlineDAO：此类包含EntityManagerHelper以便为我们提供易于使用的方法，专门用于在数据库中添加/查找/更新和删除产品。
注意：逆向工程完成后，您可以打开“Persistence”透视图，使用某些持久性和数据源工具来分析数据库和项目中的数据。
**编写应用程序**
由于MyEclipse生成了许多代码，所以您可以快速将精力放在“Business Logic”上，或更具体地说是“实际完成工作的代码”。在本部分中，您将编写一个具有main方法的Java类，该方法将Productline插入数据库，对其进行检索、更新并删除。使用此代码，您会发现在应用程序中使用JPA实体是多么容易！
**一、创建一个类**
1、右键单击com.myeclipseide.jpa软件包，然后选择New Class。
2、在“Name”字段中键入RunJPA，选中Public static void main复选框，然后单击“Finish”。
在构建新类和main方法之后，需要编写代码来操作Productline实例。
**注意：**以下代码看起来很长而且很复杂，这是因为我们试图在一个代码块中显示四个不同的示例。如果您查看每个操作（保存、加载、更新、删除），就会发现它们都不由几行代码组成。
3、将以下代码添加到main方法中，然后按CTRL + S保存。
{{{
/* 1. Create a reference to our ID */
String productLineID = "Men's Shoes";
/* 2. Create a new Productline instance */
Productline newProductline = new Productline(
productLineID,
"Shoes for men.", "Men's Shoes", null);
/* 3. Create a DAO instance to use */
ProductlineDAO dao = new ProductlineDAO();
/* 4. Store our new product line in the DB */
EntityManagerHelper.beginTransaction();
dao.save(newProductline);
EntityManagerHelper.commit();
/* 5. Now retrieve the new product line,
using the ID we created */
Productline loadedProductline = dao.findById(productLineID);
/* 6. Print out the product line information */
System.out.println("*NEW* Product Line
[productLine="
+
loadedProductline.getProductline() + ",
textDescription="
+
loadedProductline.getTextdescription() + ", image="
+
loadedProductline.getImage() + "]");
/*
* 7. Now let's change same value on the product line, and save the
* change
*/
loadedProductline.setTextdescription("Product line for men's shoes.");
EntityManagerHelper.beginTransaction();
dao.save(loadedProductline);
EntityManagerHelper.commit();
/*
* 8. Now let's load the product line from the DB again, and make sure
* it text description changed
*/
Productline secondLoadedProductline =
dao.findById(productLineID);
System.out.println("*REVISED* Product Line ["
+ "productLine=" +
secondLoadedProductline.getProductline()
+ ", textDescription=" +
secondLoadedProductline.getTextdescription()
+ ", image=" +
secondLoadedProductline.getImage() + "]");
/* 9. Now let's delete the product line from the DB */
EntityManagerHelper.beginTransaction();
dao.delete(secondLoadedProductline);
EntityManagerHelper.commit();
/*
* 10. To confirm the deletion, try and load it again and make sure it
* fails
*/
Productline deletedProductline = dao.findById(productLineID);
/*
* We use a simple inlined IF clause to test for null and print
* SUCCESSFUL/FAILED
*/
System.out.println("Productline deletion: "
+ (deletedProductline ==
null ? "SUCCESSFUL" : "FAILED"));
}}}
上面的代码看起来很复杂，但它做了很多简单的事情。例如，如果您只对在数据库中存储新项目感兴趣，则只需要程序中第1-3步中的代码，这相当于（减去注释）三行代码。以下是每个编号部分的细分：
PRODUCTLINE表使用产品线的名称作为主键。为了使本教程更容易理解，我们在字符串中定义了产品线名称，并在代码中多次运用（创建和存储产品线，然后检索两次）。
这将创建由MyEclipse生成的Productline POJO的新实例，并将其插入数据库中。对于本教程而言，这些值并不重要，所以我们只使用示例信息。
这将创建要使用的DAO实例。数据库访问需要DAO（这也是由MyEclipse生成的）。
这让DAO将新的产品系列存储在数据库中。因为要向数据库中写入一些内容，所以将save调用包含在事务中。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
为了确保使用第1步中定义的ID正确存储了产品系列，我们要求DAO获取产品系列，并将结果分配给一个全新的对象，以完全确保从数据库中加载了什么。（我们可以将值分配回newProductline，但是出于本教程的目的，我们必须清楚地知道对象来源，并且加载的实例之前在代码中不存在）。
这将从已加载的实体中打印出值，以确保它只是存储在数据库中的值。
这将更改刚刚加载的POJO的值，以显示更新记录的工作方式。然后，使用DAO将更改提交回数据库。同样的，此操作被包含在事务中，以确保安全地更改数据库。
与步骤5一样，使用在步骤1中定义的ID从数据库中重新加载记录，以确保更新操作有效。然后打印出POJO值，以确保新描述已保存到数据库中。
这显示了如何从数据库删除记录。同样的，由于这需要更改数据库，因此该代码被包含在事务中。
与第8步和第5步类似，为了证明删除有效，我们尝试使用给定的ID从数据库加载实体。因为我们已经删除了Productline，所以这个操作应该是失败的。从DAO获得结果后，将使用嵌入式IF子句打印一条语句，以确保结果为null。
**二、运行应用程序**
1、右键单击项目，然后选择Run As > Java Application。
2、选择RunJPA应用程序，然后单击“确定”。
输出显示在Console视图中。
红色文本是来自MyEclipse中生成的DAO和EntityHelper类的默认日志消息。黑色文本是代码中用于跟踪进度的System.out.println文本。如您所见，第6步中的第一个打印输出和第8步中的更新打印输出都按预期工作。并且查询没有返回Productline，证明删除也很成功。
**资源**
[Oracle JPA注释参考](https://www.oracle.com/technet ... 1.html)
[BEA JPQL参考](https://www.evget.com/resource ... -17577) 查看全部
**建立一个项目**
一般情况，JPA Facet将被添加到Java或Web项目中。在本教程中，您将使用一个简单的Java项目来查看JPA的工作方式。
注意：您可以[下载本教程中开发的项目](https://www.evget.com/resource/detail-demo-14494)，然后导入到您的工作区中。
1、单击下拉箭头，然后选择Java Project。
2、在“Project Name”字段中输入SampleJPAProject，选择默认选项，然后单击“完成”。
3、单击，选择MyEclipse Database Explorer打开透视图。
4、在数据库浏览器中，选择MyEclipse Derby连接，然后单击。
**注意：**在建立数据库连接之前，无法添加JPA Facet，因为需要选择要使用的连接。
5、切换回MyEclipse Java Enterprise透视图，右键单击项目，然后选择**[MyEclipse](https://www.myeclipsecn.com/)** > Project Facets > Install JPA Facet。
6、在目标运行时下拉列表中选择MyEclipse通用Java运行时，然后单击下一步。
7、从平台下拉列表中选择一个平台，如果JPA实现类型默认为用户库，则选择与所选平台相对应的库。如果未列出任何库，可单击下载适当的库。
8、在“Connection”字段中选择MyEclipse Derby，选中“Add driver library to build path”和“Override default schema”复选框，然后从“Schema”下拉列表中选择CLASSICCARS。单击完成。
现在，项目中已添加了完全配置的JPA Facet，其中包括JPA配置信息/DB连接信息以及添加到项目构建路径中的所有必需的JDBC和JPA库。如果这是一个Web项目，在将项目部署到应用程序服务器上并在其中运行时，所有构建路径的附加内容都将准备好进行部署。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
**创建一个Java包**
在下一个步骤中，对数据库表中的数据进行反向工程，并为项目生成实体。在进行逆向工程之前，需要创建一个Java包，并在其中放置这些实体。
1、展开项目，右键单击src文件夹，然后选择New > Package。
2、在“Name”字段中输入com.myeclipseide.jpa，然后单击“完成”。
**逆向工程数据库表**
现在已经建立了项目，可以将PRODUCTLINE表反向工程到项目中，并开始使用所生成的实体。
1、右键单击该项目，然后选择JPA Tools > Generate Entities & DAOs。
**注意：**您可以选择使用MyEclipse逆向工程工具或DALI实体生成器。选择，单击“确定”，然后完成向导。本教程使用MyEclipse逆向工程工具。
2、选择PRODUCTLINE表，单击添加，然后单击下一步。
在“Java Package”字段中，单击“ Browse”，然后选择先前创建的com.myeclipseide.jpa程序包。选中以下复选框：
- Entity Bean Generation：让MyEclipse生成注释为用作JPA实体的普通Java类。
- Create abstract class；如果您希望自定义生成的类，而不必每次都覆盖更改，则MyEclipse可以生成基本抽象类以及您可以自定义和使用的具体子类。每次进行反向工程时，MyEclipse只会覆盖抽象基类，并在具体子类中保留更改。
- Update persistence.xml：与Hibernate类似，您可以在JPA配置文件中列出正在使用的所有JPA实体。
- Java Data Access Generation：让MyEclipse生成DAO实用程序类，让您可以立即从数据库中保存/查找/更新/删除实体。此代码包含了JPA实体管理器，使得使用实体和数据库变得非常容易。
- Generate Precise findBy Methods：让MyEclipse生成findByXXX方法，其中XXX与反转的实体上的每个属性有关。这样一来，可以使用任何属性作为查找实体的方法，轻松地从数据库访问实体。
- Generate Java Interfaces：选择此选项将创建带有相应DAO实现类的接口类。取消选择此选项仅生成DAO实现类，而没有用于定义接口的单独类。
3、单击完成。查看通过展开com.myeclipseide.jpa包生成的MyEclipse资源。
生成的实体描述如下：
- EntityManagerHelper：使用直接JPA时，开发人员需要使用EntityManager class。EntityManager通过提供用于访问管理器的静态方法以及易于调用的最常用操作，此生成的帮助程序类让使用EntityManager的过程变得更加容易。
- IProductline：定义相应DAO实现类的接口的类。
- Productline：此类是表示数据库表PRODUCTLINE的JPA实体（POJO）。该POJO包含PRODUCTLINE表的字段，并表示数据库中的一行。
- ProductlineDAO：此类包含EntityManagerHelper以便为我们提供易于使用的方法，专门用于在数据库中添加/查找/更新和删除产品。
注意：逆向工程完成后，您可以打开“Persistence”透视图，使用某些持久性和数据源工具来分析数据库和项目中的数据。
**编写应用程序**
由于MyEclipse生成了许多代码，所以您可以快速将精力放在“Business Logic”上，或更具体地说是“实际完成工作的代码”。在本部分中，您将编写一个具有main方法的Java类，该方法将Productline插入数据库，对其进行检索、更新并删除。使用此代码，您会发现在应用程序中使用JPA实体是多么容易！
**一、创建一个类**
1、右键单击com.myeclipseide.jpa软件包，然后选择New Class。
2、在“Name”字段中键入RunJPA，选中Public static void main复选框，然后单击“Finish”。
在构建新类和main方法之后，需要编写代码来操作Productline实例。
**注意：**以下代码看起来很长而且很复杂，这是因为我们试图在一个代码块中显示四个不同的示例。如果您查看每个操作（保存、加载、更新、删除），就会发现它们都不由几行代码组成。
3、将以下代码添加到main方法中，然后按CTRL + S保存。
{{{
/* 1. Create a reference to our ID */
String productLineID = "Men's Shoes";
/* 2. Create a new Productline instance */
Productline newProductline = new Productline(
productLineID,
"Shoes for men.", "Men's Shoes", null);
/* 3. Create a DAO instance to use */
ProductlineDAO dao = new ProductlineDAO();
/* 4. Store our new product line in the DB */
EntityManagerHelper.beginTransaction();
dao.save(newProductline);
EntityManagerHelper.commit();
/* 5. Now retrieve the new product line,
using the ID we created */
Productline loadedProductline = dao.findById(productLineID);
/* 6. Print out the product line information */
System.out.println("*NEW* Product Line
[productLine="
+
loadedProductline.getProductline() + ",
textDescription="
+
loadedProductline.getTextdescription() + ", image="
+
loadedProductline.getImage() + "]");
/*
* 7. Now let's change same value on the product line, and save the
* change
*/
loadedProductline.setTextdescription("Product line for men's shoes.");
EntityManagerHelper.beginTransaction();
dao.save(loadedProductline);
EntityManagerHelper.commit();
/*
* 8. Now let's load the product line from the DB again, and make sure
* it text description changed
*/
Productline secondLoadedProductline =
dao.findById(productLineID);
System.out.println("*REVISED* Product Line ["
+ "productLine=" +
secondLoadedProductline.getProductline()
+ ", textDescription=" +
secondLoadedProductline.getTextdescription()
+ ", image=" +
secondLoadedProductline.getImage() + "]");
/* 9. Now let's delete the product line from the DB */
EntityManagerHelper.beginTransaction();
dao.delete(secondLoadedProductline);
EntityManagerHelper.commit();
/*
* 10. To confirm the deletion, try and load it again and make sure it
* fails
*/
Productline deletedProductline = dao.findById(productLineID);
/*
* We use a simple inlined IF clause to test for null and print
* SUCCESSFUL/FAILED
*/
System.out.println("Productline deletion: "
+ (deletedProductline ==
null ? "SUCCESSFUL" : "FAILED"));
}}}
上面的代码看起来很复杂，但它做了很多简单的事情。例如，如果您只对在数据库中存储新项目感兴趣，则只需要程序中第1-3步中的代码，这相当于（减去注释）三行代码。以下是每个编号部分的细分：
PRODUCTLINE表使用产品线的名称作为主键。为了使本教程更容易理解，我们在字符串中定义了产品线名称，并在代码中多次运用（创建和存储产品线，然后检索两次）。
这将创建由MyEclipse生成的Productline POJO的新实例，并将其插入数据库中。对于本教程而言，这些值并不重要，所以我们只使用示例信息。
这将创建要使用的DAO实例。数据库访问需要DAO（这也是由MyEclipse生成的）。
这让DAO将新的产品系列存储在数据库中。因为要向数据库中写入一些内容，所以将save调用包含在事务中。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
为了确保使用第1步中定义的ID正确存储了产品系列，我们要求DAO获取产品系列，并将结果分配给一个全新的对象，以完全确保从数据库中加载了什么。（我们可以将值分配回newProductline，但是出于本教程的目的，我们必须清楚地知道对象来源，并且加载的实例之前在代码中不存在）。
这将从已加载的实体中打印出值，以确保它只是存储在数据库中的值。
这将更改刚刚加载的POJO的值，以显示更新记录的工作方式。然后，使用DAO将更改提交回数据库。同样的，此操作被包含在事务中，以确保安全地更改数据库。
与步骤5一样，使用在步骤1中定义的ID从数据库中重新加载记录，以确保更新操作有效。然后打印出POJO值，以确保新描述已保存到数据库中。
这显示了如何从数据库删除记录。同样的，由于这需要更改数据库，因此该代码被包含在事务中。
与第8步和第5步类似，为了证明删除有效，我们尝试使用给定的ID从数据库加载实体。因为我们已经删除了Productline，所以这个操作应该是失败的。从DAO获得结果后，将使用嵌入式IF子句打印一条语句，以确保结果为null。
**二、运行应用程序**
1、右键单击项目，然后选择Run As > Java Application。
2、选择RunJPA应用程序，然后单击“确定”。
输出显示在Console视图中。
红色文本是来自MyEclipse中生成的DAO和EntityHelper类的默认日志消息。黑色文本是代码中用于跟踪进度的System.out.println文本。如您所见，第6步中的第一个打印输出和第8步中的更新打印输出都按预期工作。并且查询没有返回Productline，证明删除也很成功。
**资源**
[Oracle JPA注释参考](https://www.oracle.com/technet ... 1.html)
[BEA JPQL参考](https://www.evget.com/resource ... -17577)
一般情况，JPA Facet将被添加到Java或Web项目中。在本教程中，您将使用一个简单的Java项目来查看JPA的工作方式。
注意：您可以[下载本教程中开发的项目](https://www.evget.com/resource/detail-demo-14494)，然后导入到您的工作区中。
1、单击下拉箭头，然后选择Java Project。
2、在“Project Name”字段中输入SampleJPAProject，选择默认选项，然后单击“完成”。
3、单击，选择MyEclipse Database Explorer打开透视图。
4、在数据库浏览器中，选择MyEclipse Derby连接，然后单击。
**注意：**在建立数据库连接之前，无法添加JPA Facet，因为需要选择要使用的连接。
5、切换回MyEclipse Java Enterprise透视图，右键单击项目，然后选择**[MyEclipse](https://www.myeclipsecn.com/)** > Project Facets > Install JPA Facet。
6、在目标运行时下拉列表中选择MyEclipse通用Java运行时，然后单击下一步。
7、从平台下拉列表中选择一个平台，如果JPA实现类型默认为用户库，则选择与所选平台相对应的库。如果未列出任何库，可单击下载适当的库。
8、在“Connection”字段中选择MyEclipse Derby，选中“Add driver library to build path”和“Override default schema”复选框，然后从“Schema”下拉列表中选择CLASSICCARS。单击完成。
现在，项目中已添加了完全配置的JPA Facet，其中包括JPA配置信息/DB连接信息以及添加到项目构建路径中的所有必需的JDBC和JPA库。如果这是一个Web项目，在将项目部署到应用程序服务器上并在其中运行时，所有构建路径的附加内容都将准备好进行部署。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
**创建一个Java包**
在下一个步骤中，对数据库表中的数据进行反向工程，并为项目生成实体。在进行逆向工程之前，需要创建一个Java包，并在其中放置这些实体。
1、展开项目，右键单击src文件夹，然后选择New > Package。
2、在“Name”字段中输入com.myeclipseide.jpa，然后单击“完成”。
**逆向工程数据库表**
现在已经建立了项目，可以将PRODUCTLINE表反向工程到项目中，并开始使用所生成的实体。
1、右键单击该项目，然后选择JPA Tools > Generate Entities & DAOs。
**注意：**您可以选择使用MyEclipse逆向工程工具或DALI实体生成器。选择，单击“确定”，然后完成向导。本教程使用MyEclipse逆向工程工具。
2、选择PRODUCTLINE表，单击添加，然后单击下一步。
在“Java Package”字段中，单击“ Browse”，然后选择先前创建的com.myeclipseide.jpa程序包。选中以下复选框：
- Entity Bean Generation：让MyEclipse生成注释为用作JPA实体的普通Java类。
- Create abstract class；如果您希望自定义生成的类，而不必每次都覆盖更改，则MyEclipse可以生成基本抽象类以及您可以自定义和使用的具体子类。每次进行反向工程时，MyEclipse只会覆盖抽象基类，并在具体子类中保留更改。
- Update persistence.xml：与Hibernate类似，您可以在JPA配置文件中列出正在使用的所有JPA实体。
- Java Data Access Generation：让MyEclipse生成DAO实用程序类，让您可以立即从数据库中保存/查找/更新/删除实体。此代码包含了JPA实体管理器，使得使用实体和数据库变得非常容易。
- Generate Precise findBy Methods：让MyEclipse生成findByXXX方法，其中XXX与反转的实体上的每个属性有关。这样一来，可以使用任何属性作为查找实体的方法，轻松地从数据库访问实体。
- Generate Java Interfaces：选择此选项将创建带有相应DAO实现类的接口类。取消选择此选项仅生成DAO实现类，而没有用于定义接口的单独类。
3、单击完成。查看通过展开com.myeclipseide.jpa包生成的MyEclipse资源。
生成的实体描述如下：
- EntityManagerHelper：使用直接JPA时，开发人员需要使用EntityManager class。EntityManager通过提供用于访问管理器的静态方法以及易于调用的最常用操作，此生成的帮助程序类让使用EntityManager的过程变得更加容易。
- IProductline：定义相应DAO实现类的接口的类。
- Productline：此类是表示数据库表PRODUCTLINE的JPA实体（POJO）。该POJO包含PRODUCTLINE表的字段，并表示数据库中的一行。
- ProductlineDAO：此类包含EntityManagerHelper以便为我们提供易于使用的方法，专门用于在数据库中添加/查找/更新和删除产品。
注意：逆向工程完成后，您可以打开“Persistence”透视图，使用某些持久性和数据源工具来分析数据库和项目中的数据。
**编写应用程序**
由于MyEclipse生成了许多代码，所以您可以快速将精力放在“Business Logic”上，或更具体地说是“实际完成工作的代码”。在本部分中，您将编写一个具有main方法的Java类，该方法将Productline插入数据库，对其进行检索、更新并删除。使用此代码，您会发现在应用程序中使用JPA实体是多么容易！
**一、创建一个类**
1、右键单击com.myeclipseide.jpa软件包，然后选择New Class。
2、在“Name”字段中键入RunJPA，选中Public static void main复选框，然后单击“Finish”。
在构建新类和main方法之后，需要编写代码来操作Productline实例。
**注意：**以下代码看起来很长而且很复杂，这是因为我们试图在一个代码块中显示四个不同的示例。如果您查看每个操作（保存、加载、更新、删除），就会发现它们都不由几行代码组成。
3、将以下代码添加到main方法中，然后按CTRL + S保存。
{{{
/* 1. Create a reference to our ID */
String productLineID = "Men's Shoes";
/* 2. Create a new Productline instance */
Productline newProductline = new Productline(
productLineID,
"Shoes for men.", "Men's Shoes", null);
/* 3. Create a DAO instance to use */
ProductlineDAO dao = new ProductlineDAO();
/* 4. Store our new product line in the DB */
EntityManagerHelper.beginTransaction();
dao.save(newProductline);
EntityManagerHelper.commit();
/* 5. Now retrieve the new product line,
using the ID we created */
Productline loadedProductline = dao.findById(productLineID);
/* 6. Print out the product line information */
System.out.println("*NEW* Product Line
[productLine="
+
loadedProductline.getProductline() + ",
textDescription="
+
loadedProductline.getTextdescription() + ", image="
+
loadedProductline.getImage() + "]");
/*
* 7. Now let's change same value on the product line, and save the
* change
*/
loadedProductline.setTextdescription("Product line for men's shoes.");
EntityManagerHelper.beginTransaction();
dao.save(loadedProductline);
EntityManagerHelper.commit();
/*
* 8. Now let's load the product line from the DB again, and make sure
* it text description changed
*/
Productline secondLoadedProductline =
dao.findById(productLineID);
System.out.println("*REVISED* Product Line ["
+ "productLine=" +
secondLoadedProductline.getProductline()
+ ", textDescription=" +
secondLoadedProductline.getTextdescription()
+ ", image=" +
secondLoadedProductline.getImage() + "]");
/* 9. Now let's delete the product line from the DB */
EntityManagerHelper.beginTransaction();
dao.delete(secondLoadedProductline);
EntityManagerHelper.commit();
/*
* 10. To confirm the deletion, try and load it again and make sure it
* fails
*/
Productline deletedProductline = dao.findById(productLineID);
/*
* We use a simple inlined IF clause to test for null and print
* SUCCESSFUL/FAILED
*/
System.out.println("Productline deletion: "
+ (deletedProductline ==
null ? "SUCCESSFUL" : "FAILED"));
}}}
上面的代码看起来很复杂，但它做了很多简单的事情。例如，如果您只对在数据库中存储新项目感兴趣，则只需要程序中第1-3步中的代码，这相当于（减去注释）三行代码。以下是每个编号部分的细分：
PRODUCTLINE表使用产品线的名称作为主键。为了使本教程更容易理解，我们在字符串中定义了产品线名称，并在代码中多次运用（创建和存储产品线，然后检索两次）。
这将创建由MyEclipse生成的Productline POJO的新实例，并将其插入数据库中。对于本教程而言，这些值并不重要，所以我们只使用示例信息。
这将创建要使用的DAO实例。数据库访问需要DAO（这也是由MyEclipse生成的）。
这让DAO将新的产品系列存储在数据库中。因为要向数据库中写入一些内容，所以将save调用包含在事务中。
**[下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[即日起至11月30日，慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购MyEclipse、CodeMix享折上（MyEclipse最高省48元，CodeMix最高省36元）！](https://www.evget.com/game/index/techsrv)**
为了确保使用第1步中定义的ID正确存储了产品系列，我们要求DAO获取产品系列，并将结果分配给一个全新的对象，以完全确保从数据库中加载了什么。（我们可以将值分配回newProductline，但是出于本教程的目的，我们必须清楚地知道对象来源，并且加载的实例之前在代码中不存在）。
这将从已加载的实体中打印出值，以确保它只是存储在数据库中的值。
这将更改刚刚加载的POJO的值，以显示更新记录的工作方式。然后，使用DAO将更改提交回数据库。同样的，此操作被包含在事务中，以确保安全地更改数据库。
与步骤5一样，使用在步骤1中定义的ID从数据库中重新加载记录，以确保更新操作有效。然后打印出POJO值，以确保新描述已保存到数据库中。
这显示了如何从数据库删除记录。同样的，由于这需要更改数据库，因此该代码被包含在事务中。
与第8步和第5步类似，为了证明删除有效，我们尝试使用给定的ID从数据库加载实体。因为我们已经删除了Productline，所以这个操作应该是失败的。从DAO获得结果后，将使用嵌入式IF子句打印一条语句，以确保结果为null。
**二、运行应用程序**
1、右键单击项目，然后选择Run As > Java Application。
2、选择RunJPA应用程序，然后单击“确定”。
输出显示在Console视图中。
红色文本是来自MyEclipse中生成的DAO和EntityHelper类的默认日志消息。黑色文本是代码中用于跟踪进度的System.out.println文本。如您所见，第6步中的第一个打印输出和第8步中的更新打印输出都按预期工作。并且查询没有返回Productline，证明删除也很成功。
**资源**
[Oracle JPA注释参考](https://www.oracle.com/technet ... 1.html)
[BEA JPQL参考](https://www.evget.com/resource ... -17577)
【教程连载-数据库篇】Oracle使用方法
Java EE开发 • besy 发表了文章 • 0 个评论 • 60 次浏览 • 2015-03-02 10:07
**1. 在MyEclipse中使用Oracle功能**
在MyEclipse中开发应用程序时需要进行数据处理，同时你也可以直接访问Oracle数据库的许多功能。
浏览、创建和编辑Oracle类型：
别名
视图
序列
触发器
存储过程
功能
包
包主体
java程序
会话
数据库链接
监视器（活动会话，顶端SQL，进程）
安全性（用户信息）
实例信息（系统数据，表空间等）
**点击查看完整原文：[MyEclipse中的Oracle使用方法](http://www.myeclipsecn.com/lea ... lipse/)**
## 还没有MyEclipse？[立即下载](http://www.myeclipsecn.com/download/) ## 查看全部
在MyEclipse中开发应用程序时需要进行数据处理，同时你也可以直接访问Oracle数据库的许多功能。
浏览、创建和编辑Oracle类型：
别名
视图
序列
触发器
存储过程
功能
包
包主体
java程序
会话
数据库链接
监视器（活动会话，顶端SQL，进程）
安全性（用户信息）
实例信息（系统数据，表空间等）
**点击查看完整原文：[MyEclipse中的Oracle使用方法](http://www.myeclipsecn.com/lea ... lipse/)**
## 还没有MyEclipse？[立即下载](http://www.myeclipsecn.com/download/) ## 查看全部
**1. 在MyEclipse中使用Oracle功能**
在MyEclipse中开发应用程序时需要进行数据处理，同时你也可以直接访问Oracle数据库的许多功能。
浏览、创建和编辑Oracle类型：
别名
视图
序列
触发器
存储过程
功能
包
包主体
java程序
会话
数据库链接
监视器（活动会话，顶端SQL，进程）
安全性（用户信息）
实例信息（系统数据，表空间等）
**点击查看完整原文：[MyEclipse中的Oracle使用方法](http://www.myeclipsecn.com/lea ... lipse/)**
## 还没有MyEclipse？[立即下载](http://www.myeclipsecn.com/download/) ##
在MyEclipse中开发应用程序时需要进行数据处理，同时你也可以直接访问Oracle数据库的许多功能。
浏览、创建和编辑Oracle类型：
别名
视图
序列
触发器
存储过程
功能
包
包主体
java程序
会话
数据库链接
监视器（活动会话，顶端SQL，进程）
安全性（用户信息）
实例信息（系统数据，表空间等）
**点击查看完整原文：[MyEclipse中的Oracle使用方法](http://www.myeclipsecn.com/lea ... lipse/)**
## 还没有MyEclipse？[立即下载](http://www.myeclipsecn.com/download/) ##