要说并发语言领域中哪门语言好，肯定每个人都有不同的看法，但Python一定是公认的好语言。
小编最近被Python语言的魅力所折服，特地去了解了这款语言常用的开发工具。
## 专业的Python IDE推荐：Pycharm、CodeMix ##
[PyCharm](https://www.evget.com/product/2998) 带有一整套加速Python开发的工具和高级功能，可在Django框架下进行专业的Web开发，是一款非常专业的Python IDE。而 [CodeMix](https://www.myeclipsecn.com/codemix/) 不仅解锁了VS Code和Code OSS附加扩展的各种技术，还多语言开发且正版价格便宜，对于初学者或老司机来说都是性价比非常高的选择。强烈推荐！

[双旦钜惠，购CodeMix折上折，消费满额享好礼>>>](https://www.evget.com/mall/detail/4078)

鉴于Python自带的编辑器太简单，使用起来不顺手，而本人又对 [MyEclipse](https://www.myeclipsecn.com/features/) 比较熟悉，所以选择在MyEclipse中配置PyDev来进行Python开发。
**提示：**通过正版 [MyEclipse](https://www.myeclipsecn.com/features/) 可直接进入CodeMix。还没有安装MyEclipse 2019.12.5的伙伴赶紧下载安装吧！

[免费下载MyEclipse最新版>>>](https://www.myeclipsecn.com/download/)
[优惠购买MyEclipse正版授权>>>](https://www.evget.com/mall/detail/3016)

由于MyEclipse配置PyDev的网页较少，需要配置的地方有点多。总体来讲，这个过程主要分为两大步：1、从MyEclipse的MarketPlace中下载安装PyDev；2、配置Python插件。
## 首先进行第一步：安装Python ##
小编选择安装的是Python3.6，安装目录：D:\Program Files\python。（安装目录可以自行选择）
安装过程很简单，这里就不多说了。
step1：确保已经正确安装了MyEclipse最新版（2019.12.5）。
step2：打开MyEclipse 2019.12.5执行Help->install from site，在“Find”后面的文本框中输入pydev > 回车键。
Step3：输入安装路径pydev - http://pydev.org/updates/，等待几秒（电脑要连网）。如下图，选择7.3版本，并取消下面的勾。（网传只能3版本以下，笔者证明7.3也可以。）
step4：点击接受协议，myeclipse后台会自动下载。这里需要等待5分钟左右，然后会提示重新启动，点击yes重启。
## 第二步：配置Python插件 ##
上面步骤只是安装了环境，MyEclipse重启后还需要把Python3.6路径导入进去。
Step1：选择Window- >Preferences->PyDev->Interpreter->Python interpreter。
Step2：点击Path，Myeclipse会自动识别Python的安装位置（前提是你已经在系统中设置了Python的环境变量），点击完成“OK”，开发环境就配置完成了！
配置完成后，最好是编写一个Python程序检测PyDev是否配置成功。
## 检测PyDev配置情况 ##
step1：打开已经配置好的Eclipse-PyDev开发环境，选择File –>New –> Other –> PyDev –> PyDev Project（(如果new 后找不到，在other可以找到)），点击Next。
step2：打开刚刚新建的pydev project，右键新建一个文件，命名为HelloWorld.py。在新建的文件中输入“print (“Hello world”)”，按Ctrl+S保存，点击run，并且选择run as Python Run，点击Finish。接着会自动创建时间等等信息。
**注意：**MyEclipse环境默认是GBK，这里需要显示申明 # coding = gbk，因为中文字符在这里不支持。
如果在console中看到输出信息“Hello World”，则表示环境配置成功。
**欢迎加入MyEclipse 中国官方QQ群，和大神们深入探讨：742336981** 查看全部

[MyEclipse](https://www.myeclipsecn.com/features/) 2019开发和运行Python项目的详细教程，将用5个步骤为您详细讲解。
如果您还没有安装CodeMix，[建议点击此处先行安装！](https://www.evget.com/article/2018/10/31/28753.html)
如果说论Pycharm和 [CodeMix](https://www.myeclipsecn.com/codemix/) 的专业程度和美观长度来说，当然Pycharm完胜，但是论多语言开发环境和正版购买成本，CodeMix奖是不错的选择。
因为CodeMix无法下载到本地安装，而且是收费插件，因此在45天试用期过了之后，如果您决定继续使用，需要购买正式授权。
[双旦钜惠，购MyEclipse、CodeMix折上折，消费满额享好礼>>>](https://www.evget.com/game/christmas/index)
## 一、安装代码自动补全 ##
IntelliSense包括智能代码补全、键入时的文档，等等！代码片段可以快速生成常用的代码位；只需为这个不错的时间节省器安装一个python代码片段扩展。
小编也是写代码的，感觉现在没有代码智能补全什么的，完全就不知道该怎么写了，不知道您是否也有体会，如果有或者想和大家一起分享以下Coding经验，欢迎加入MyEclipse官方交流群：742336981.
## 二、命令工具 ##
如果您喜欢使用键盘，Python扩展提供了许多命令，您可以使用这些命令执行从重构到格式化，甚至运行当前Python文件和执行单元测试的所有操作。
## 三、新建一个Python项目，体验以下MyEclipse开发Python和Java的区别 ##
在菜单栏转到File>New>Project>CodeMix并选择Python Project创建一个新的Python模板项目。向导将安装任何缺少的Python扩展，并提示您安装缺少的Python插件。
## 四、语法分析工具 ##
linter将分析您的代码，不仅要查找语法问题，还要查找潜在的错误，或者只是编写不好的代码。使用CodeMix，您可以在多个Python linter之间进行选择，例如Pylint、Pep8、Flake8等。
## 五、尝试Debuger组件，新手建议熟练使用这个工具，杜绝在开发的时候凭借经验猜测bug ##
调试Python的所有功能，从简单的基于控制台的应用程序，到用Django或Flex构建的web应用程序，甚至是用于大数据分析的PySpark应用程序。
MyEclipse官方推荐这几个Python Extensions是必不可少的，因为这是实现Python原生开发体验必不可少的组件！
Python Extended for code completion with arguments.
Django Template & Django Snippets for web development with Django.
Jupyter for data science, and scientific computing.
在下一章节将介绍PyDev集成配置。欢迎加入我们的MyEclipseQQ群，和大神们深入探讨：742336981 查看全部

PHP虽然在近两年热度不比从前，但是依然不可否认PHP依然是开发前端网站最好的方式之一，那么在 [MyEclipse](https://www.myeclipsecn.com/features/) 中开发PHP的官方解决方案你又知道吗？
在很久很久以前，想要在MyEclipse/Eclipse上开发PHP项目，需要下载插件“PHPEclipse”，但是如果开发在项目中又想使用Vue等开发框架的时候，难道再下载一个"VueEclipse"吗？显然不是的！
Eclipse官方推出的 [CodeMix](https://www.myeclipsecn.com/codemix/) 扩展可以完美的帮助开发人员实现多语言和框架开发，包含了PHP\VUE\Python等，本篇小编将为你介绍和解答如何再MyEclipse中开发PHP项目！
[双旦钜惠，购MyEclipse、CodeMix折上折，消费满额享好礼>>>](https://www.evget.com/game/christmas/index)
## 一、安装CodeMix，获得多语言开发环境支持 ##
CodeMix的安装方式需要在线安装，步骤稍微有点多，因此推荐看看CodeMix2上线时的安装教程，点此直达
## 二、安装PHP扩展 ##
通过PHP IntelliSense扩展，您可以获得有用的代码自动补全、工作区范围内的符号搜索以快速导航代码等等！代码片段可以快速生成常用的代码位，您还可以添加PHP代码片段扩展，使您的代码更加高效。
前面这句是从官方复制下来的，总结就是：安装扩展获得原生PHP开发的基本能力，如下图所示。
## 三、设置编码的标准 ##
你的团队使用什么编码标准？PSR2，PEAR，Zend，还是什么定制的？定义一个标准非常重要，特别是在团队环境中。php代码嗅探器扩展允许您指定标准，并为不同类型的冲突配置严重性。
小编认为，用Zend标准比较保险和通用。
## 四、尝试一下PHP开发第一步：创建一个项目，开始体验效果，找到需要添加的其他PHP扩展文件或配置 ##
转到File>New>Project>CodeMix并选择Php Project创建一个新的Php模板项目。该向导功能有个效果，可以通过安装找到丢失的PHP扩展。
官方提示以下几个PHP扩展可以帮助开发者获得很好的开发体验：
- PHP IntelliSense—获得PHP开发中的代码补全、方法推荐等等
- PHP Debug—当然是必备的Debugger工具了，具体用法可以参照文末图例
- php CodeSniffer—添加编码标准和变量分析
- phpfmt – PHP formatter—把PHP代码格式化，小编认为这个扩展比ZendStudio原生的格式化代码更为人道。
debugger
变量分析，快速找到潜在的错误代码
使用CodeMix方式实现Eclipse编辑器中多语言开发已经成为了官方日程上的确定项目了，所以Eclipse使用者们可以赶快加入体验，不得不提的是CodeMix已经是第三个正式版本了，可以理解为其扩展和体验等都受到了很多开发者的校验和官方的优化。
[CodeMix正版授权>>>](https://www.evget.com/mall/detail/4078)
因为CodeMix不支持线下安装方式，而CodeMix是收费的，因此快来获得一个正版CodeMix体验吧，在此之前你有45天试用权限。
[CodeMix安装教程>>>](https://www.evget.com/article/2018/10/31/28753.html) 查看全部

CodeMix3更新，将Vue中的任何内容整合到日常开发中。在正版[MyEclipse](https://www.myeclipsecn.com/features/)中在线学习课程会帮助你快速上手。
- 替换和增强JavaScript、HTML和CSS开发
- 在代码旁边集成web应用的实时预览（新！）
- 无缝HTML和降价预览（新！）
- 添加技术和框架，包括TypeScript
- 优化Eclipse：避免无休止的验证
- 提供交互式教程以快速学习技术
- 在EclipseIDE中解锁VS代码的智能

[CodeMix CI2019.12.11更新详情>>>](https://www.evget.com/article/2019/12/20/34128.html)
[CodeMix安装教程>>>](https://www.evget.com/article/2018/10/31/28753.html)
源源不断的新技术会让你感到无所适从，MyEclipse会让你一直保证你技术在线。[CodeMix](https://www.myeclipsecn.com/codemix/)可以安装在领先的Eclipse解决方案之上，比如MyEclipse、Spring工具套件和JBoss工具，并且与PDT和PyDev等流行插件兼容，给Java开发者更好的多语言开发体验。

[双旦钜惠，购MyEclipse、CodeMix折上折，消费满额享好礼>>>](https://www.evget.com/game/christmas/index) 查看全部

[【版本升级】MyEclipse 2019.12.5正式发布](https://www.myeclipsecn.com/bbs/?/article/211)
[MyEclipse 2019.12.5 Windows/Linux/Mac 版下载地址](https://www.myeclipsecn.com/bbs/?/question/7528)

本文承接[上篇](https://www.myeclipsecn.com/bbs/?/article/213)，继续为大家介绍JSP Code Completion、JSP验证相关内容。
## 四 JSP Code Completion ##
双击一个JSP文件，在MyEclipse JSP编辑器中将其打开。如果您具有与JSP文件关联的外部JSP编辑器，可以右键单击该文件，选择“Open With”，然后选择其他编辑器。按CTRL +空格键来调用MyEclipse代码完成建议。下图演示了一个用于Java scriptlet的JSP代码完成示例。
除脚本完成外，MyEclipse JSP编辑器还为JSP指令（例如<%@ %>、自定义JSP标记（例如 <x:if>和）和HTML标记）提供代码完成。使用CTRL +空格键键盘快捷键可以调用所有相关形式的代码完成。

[双旦钜惠，购MyEclipse、CodeMix折上折，消费满额享好礼>>>](https://www.evget.com/game/christmas/index)

## 五 JSP验证 ##
MyEclipse JSP验证功能可以帮助在开发周期的早期准确识别JSP编码错误。本节介绍了JSP验证的两个级别，以及如何在JSP编辑器和工作台的其他位置识别问题。JSP验证的第一级或类型适用于JSP编辑器，该编辑器是仿照Java编辑器的模式，并提供对编辑器内容的实时输入验证。JSP验证的第二级是在修改和保存JSP文件时或在项目上执行工作区“清理”操作时自动对JSP文件执行的构建时操作。
最后，可以从单个JSP文件的右键单击上下文菜单中激活手动JSP验证，或者从项目、子文件夹级别递归开始。
**5.1 JSP编辑器实时输入问题检测**
输入源文本时，JSP编辑器可以检测到广泛的语法和潜在的编译问题。在JSP编辑器的概述列（右侧注释列）中显示以这种方式检测到的警告和错误。通过选择Window > Preference，展开General > Editors > Text Editors，然后选择“Annotations”，可以启用/禁用此行为来修改注释颜色。
**注意：**实时输入问题不会出现在“Problems”视图中。
**5.2自动建立时间验证**
以下示例在helloworld.jsp中引入了一个简单的语法错误，可查看自动验证的工作方式。第28行包含以下文本：
<％out.println（“ Hello World”）％>
';' 故意省略终止语句来说明错误检测和标记。
在保存期间，内部MyEclipse JSP编译器通过编译JSP来分析JSP文件的语法和Java类型正确性。检测到的错误和警告以与Java编辑器类似的方式呈现。
**5.3手动验证**
可以随时手动调用JSP验证。右键单击Explorer视图中的任意Web项目文件或文件夹，然后选择MyEclipse > Run Validation。这将导致在目标资源上执行JSP验证。对于选定的文件夹或项目，将对所有文件和子文件夹递归执行验证。
 查看全部

[【版本升级】MyEclipse 2019.12.5正式发布](https://www.myeclipsecn.com/bbs/?/article/211)
[MyEclipse 2019.12.5 Windows/Linux/Mac 版下载地址](https://www.myeclipsecn.com/bbs/?/question/7528)

## 一 Web项目结构 ##
用最简单的话来说，MyEclipse Web项目是Eclipse Java项目，其中包括定义项目的Web性质的元数据和以Java EE Web归档（WAR）结构为后缀的目录结构。Java EE Web项目模型的中心是Web应用程序符合的Java EE部署要求：
- 标准的WAR目录（文件夹）结构；
- 支持源文件夹的Eclipse JDT Java模型概念。
下图显示了示例HelloWorld Web项目的结构的带注释的视图。注意，MyEclipse Web项目在项目文件夹的右上角装饰有一个小地球图标。在此示例项目中，显示了两个子文件夹：src和WebRoot。该SRC文件夹包含Java源代码，如Java包和它们的类、接口。WebRoot文件夹是JavaEE的web存档（WAR）结构图案化后的文件夹结构的根/基本文件夹。根文件夹在形式上称为Web根，它包含三个子文件夹。Web内容和资源（例如JSP和HTML文件、标记库和JAR文件）位于Web根文件夹及其子文件夹中。
Web存档结构的根文件夹称为Web根。该文件夹的实际名称可以自定义，但必须遵循以下结构和要求：
WebRoot /
WEB-INF /
lib /
web.xml
Java源文件夹和webroot文件夹的默认名称由Web项目模板定义。
下图描绘了MyEclipse Web项目的Resource透视图，显示了项目的部署信息。可以使用项目的Deployment Assembly属性来定制项目部署。
此外，MyEclipse包括两个特殊的项目成员：.settings文件夹和.myeclipse文件夹。.settings文件夹保存所有项目设置，与项目对应的Eclipse .project和.classpath文件同等重要。如果要在源管理系统（例如CVS）中维护项目，请在版本控制下包含.settings文件夹。
该.myeclipse文件夹是MyEclipse中的用于存储临时数据，如编译的JSP短暂工作区。因为它是一个临时工作区，所以可能由MyEclipse Web工具动态创建和删除，并且不会出现在新项目中，仅在项目需要时自动生成，不需要在源代码控制系统下维护此文件夹。例如，如果在CVS中维护项目，建议您将.myeclipse添加到项目的.cvsignore文件中。
**注意：**.*文件和文件夹在项目中可能不可见。必须使用“Project Explorer”过滤器来查看它们。

[双旦钜惠，购MyEclipse、CodeMix折上折，消费满额享好礼>>>](https://www.evget.com/game/christmas/index)

## 二 Web开发生产力工具 ##
MyEclipse提供了许多用于开发Web应用程序的生产力工具。本节概述了关键工具及其用法。
**编辑器**
- HTML Designer（源代码，所见即所得，预览模式）
- JSP（源，预览模式）
- XML、XSL（源，图形模式）
- DTD/XSD
- Java脚本
- CSS
- Text
所有编辑器均支持用户可自定义的语法颜色突出显示、字体、布局和格式。HTML、JSP和XML编辑器提供类似于Eclipse Java编辑器的实时验证和错误标记。
**向导**
- 创建Web项目
- HTML创建
- JSP创建包括Struts
- web.xml文档的创建和维护
- XML创建
**验证方式**
- 包含自定义标记和Java脚本的JSP
- HTML
- CSS
- XML/XSL
- 部署描述符
**部署、测试和调试**
- 直接从MyEclipse部署来测试应用程序服务器环境
- 支持20多种不同的应用服务器
- 启动和控制应用程序服务器
- JSP和Java代码的热交换/更新调试
**高级功能**
- Struts设计器和向导
- XDoclet支持
- Java Server Faces支持
- Hibernate支持
## 三 Web项目参数 ##
MyEclipse提供了许多可定制的参数，其中有几个带有预填充字段的Web项目向导和窗口。许多预填充字段的值通常来自MyEclipse系统参数。应该注意两个MyEclipse参数是Web项目文件夹模板和部署策略。
要访问MyEclipse参数，请选择Window > Preferences，展开MyEclipse > Java Enterprise Project，然后选择“Web Project”。
若不想要显式的Web根文件夹，可以将Web根文件夹名设置为“/”。
注意：更改Web项目模板只对新项目有影响，不会影响现有项目。 查看全部

[【版本升级】MyEclipse 2019.12.5正式发布](https://www.myeclipsecn.com/bbs/?/article/211)
[MyEclipse 2019.12.5 Windows/Linux/Mac 版下载地址](https://www.myeclipsecn.com/bbs/?/question/7528)

**创建一个Web片段项目**
创建的Web片段将包含在新的动态Web应用程序中，该应用程序将与Web Fragment项目一起创建。
- 选择 File > New > Project，选择“Web Fragment Project”，然后单击“Next”。
- 在“Project name”字段中输入webFrag。
- 接受默认的目标运行时，或为部署服务器选择运行时。
- 选中“Add project to a Dynamic Web project”复选框，然后单击“New”创建主机Web项目。
- 在“Name”字段中键入webProj，然后单击“Finish”创建Web项目。
- 单击Finish，完成Web片段项目。
完成向导后，将创建并配置webFrag Web Fragment项目以及新的Web项目（下图描述了新项目的结构）。
注意两个项目中的JRE System Library文件夹。这些是MyEclipse为项目提供的JavaEE API Jars库，用于编译和代码完成支持。这些API JAR文件仅放置在项目的构建路径中。
**注意：**JavaEE JAR文件或其他资源没有被复制到项目中。
如果要创建与现有Web项目一起使用的Web Fragment项目，必须通过现有Web项目的Deployment Assembly属性定义从属Web Fragment项目。
- 要访问Deployment Assembly属性，请右键单击目标Web项目，然后选择Properties > Deployment > Deployment Assembly。
**注意：**如果在创建Web Fragment项目时指定动态Web项目，依赖关系将自动包含在部署程序集中。

[双旦钜惠，购MyEclipse、CodeMix折上折，消费满额享好礼>>>](https://www.evget.com/game/christmas/index)

**部署一个Web项目**
部署引用Web片段项目的Web项目时，请部署该Web项目。因为引用了Web片段，所以它与主机Web项目一起部署。在本部分中，您可以尝试部署引用Web片段的示例Web项目。
- [下载webfragment.zip](https://www.evget.com/resource/detail-demo-14575)，将现有项目导入MyEclipse。您将有两个项目——WebFragmentHost和WebFragment。
- 在“Servers”视图中，右键单击MyEclipse Tomcat服务器，然后选择“Add/Remove Deployments”。
**注意：**此项目无法在Tomcat 6上运行。
- 在“Available”列中选择WebFragmentHost项目，单击“Add”，然后单击“Finish”。
这会将WebFragmentHost项目以爆炸的WAR格式部署到MyEclipse Tomcat工作区。部署项目的上下文根是 /WebFragmentHost，可以从http：//localhost-name：8080/WebFragmentHost访问。回想一下，上下文根是用户定义的Web项目属性。右键单击项目，然后选择“property”>“ Project Facets”>“ Web”，访问Web属性。
**测试应用程序**
- 右键单击WebFragmentHost，然后选择Run As>MyEclipse Server Application。
- 选择MyEclipse Tomcat服务器，然后单击“Finish”。Web片段中的WelcomeServlet.java文件在浏览器中显示一个页面。
 查看全部

**[12月，欢庆双“旦”，上“慧都网”小程序签到可兑现软件商城通用抵价券，签的越多兑现得越多！活动详情>>>](https://www.evget.com/article/2019/11/30/33697.html)**

**设置CodeLive**
CodeLive将浏览器连接到IDE。您可以选择为每个Java EE服务器打开CodeLive，也可以选择要在Java EE网站的浏览器中实时预览的文件。
- 打开/关闭CodeLive
有两种方法可以打开或关闭此功能。
1、从Servers View Toolbar
从Servers中选择一个Java EE服务器，单击Enable CodeLive按钮（这个按钮起切换的作用），打开或关闭CodeLive。当启用CodeLive时，图标高亮显示。
2、从Servers View Context-Menu
在“Sever”视图中右键单击Java EE服务器，然后选择CodeLive（此菜单选项用作切换）可打开或关闭CodeLive。启用CodeLive时，该图标突出显示。
**选择文件进行实时预览**
启用CodeLive后，可以在Java EE项目中选择要实时预览的文件。
1、在浏览器中查看网页。
2、单击CodeLive图标打开CodeLive仪表板。
3、选择要为其启用实时预览的每个文件。
4、单击关闭按钮。
5、刷新网页。
**使用Live Preview查看对Java EE网站的编辑**
在为Java EE服务器启用CodeLive并为用于加载项目中页面的文件启用实时预览后，就可以查看项目中的页面并实时查看所做的编辑。
**注意：**Live Preview被设计用于包含web socket的现代浏览器，Internet Explorer 9及以下版本与Live Preview不兼容。
1、在一个或多个浏览器中查看项目中的网页。可以使用移动模拟器 来查看更改，就像在移动设备上一样。
**提示：**建议一次查看多个页面以测试CSS更改。
2、编辑与正在查看的文件关联的HTML、CSS或JSP文件。对列表、页面结构、Div样式、颜色、字体和边距等项目的更改会立即反映在浏览器中。
**注意：**在Live Preview的初始版本中，对Java Server Pages（JSP）的支持作为实验性预览功能包括在内。在页面的静态区域中工作时，可以将高质量的内容实时传递到浏览器。但是，由于服务器端处理以未跟踪的方式更改了值，所以使用区域接触动态区域不会完全工作。将来的CI版本中将包含更多增强功能。
3、实时突出显示使您可以快速查看页面上哪些区域受到更改的影响。将光标放在HTML文件中时，相应的元素在浏览器中会突出显示。当光标位于CSS文件中的规则上时，所有受影响的元素都会在浏览器中突出显示。实时高亮显示可从“Source Editor”或“Outline”视图中获得。

**[免费下载MyEclipse试用版>>>](https://www.myeclipsecn.com/download/)**
**[优惠购买MyEclipse正式版>>>](https://www.evget.com/mall/detail/3016)**

**查看源代码**
在浏览器中查看页面时，可以选择查看浏览器中加载的源文件，并在IDE中打开任意文件，或从页面上的元素直接跳转到源文件。
- 查看和打开源文件
1、在浏览器中查看网页。
2、单击CodeLive图标打开CodeLive仪表板。
3、单击 要查看的文件旁边的放大镜图标。该文件将在源代码编辑器中打开。
- 从元素跳转到源代码
1、在浏览器中查看网页。
2、单击魔术棒图标。
3、将鼠标悬停在页面上的元素上，文件名将显示在元素下方。
4、单击元素。该文件将在源代码编辑器的相应行中打开。
**注意：**如果尚未启用实时预览，则会提示您为源文件启用实时预览。选择文件并重新加载页面以打开源文件。
**兼容性矩阵**
Live Preview在以下环境中成功测试。
*通常在Windows测试中使用Internet Explorer。
**已知问题**
在以下情况下，您可能会遇到意外的结果：
- 忽略标记库条目。
- 标签库的元素将作为实时预览的一部分被忽略。页面上静态块中的更改仍然可以正常工作，但是与标签库元素相同的文本或元素节点可能会导致意外结果。
- 不支持完全文件替换。
- 使用文件时，如果您复制/粘贴整个文件来替换当前文件，或者通过GIT更新，则需要重新连接Live Preview会话。Live Preview是为您在文件中所做的更改而优化的，并不适用于大规模重组。 查看全部

**[12月，欢庆双“旦”，上“慧都网”小程序签到可兑现软件商城通用抵价券，签的越多兑现得越多！活动详情>>>](https://www.evget.com/article/2019/11/30/33697.html)**

**1、使用JSF Facet创建一个Web项目**
设计器通过在页面上导入和使用的标记库识别JSF页面，因此可以将Designer与其他JSF页面格式一起使用。
- 选择File > New > Web Project。
- 在“Project name”字段中键入SampleJSFProject，接受默认值，然后单击“Finish”。注意：本教程使用JavaEE 5版本。但是，在创建新项目时，可以使用JavaEE 6或7。
右键单击项目，然后选择MyEclipse > Project Facets > Install JavaServer Faces Facet。
- 单击下一步查看实施设置，然后单击完成以接受默认设置。

**[免费下载MyEclipse试用版>>>](https://www.myeclipsecn.com/download/)**
**[优惠购买MyEclipse正式版>>>](https://www.evget.com/mall/detail/3016)**

**2、创建一个JSF页面**
- 右键单击WebRoot文件夹，然后选择New > JSP (Advanced Templates)。
- 从“Template”中选择要使用的默认JSF模板，然后单击Finish。该页面会自动打开，并且在面板中提供带有JSF控件的JSP设计器。
**3、设计登录表单**
- 单击“Expand”按钮可以在Visual Designer中打开工具选项板。调色板从构建路径中读取标记库并加载它们，这样您就可以使用拖放特性来构建页面。
调色板从构建路径中读取标记库并加载它们，这样您就可以使用拖放特性来构建页面。
下图是一些需要注意的重要标记组。在设计页面时，有最常用的一组标记。使用这些项目可将登录表单拖放到页面上。
- 选择默认文本并将其更改为“Welcome to My Application”。
- 在选用板中展开JSF HTML，然后将“Form”拖动到文本下方的页面上。
典型的登录表单的布局由用户名、密码和登录按钮组成。为了很好地布置这些项目，还需要一个3x2的表，但是如果要包含用于存储登录错误消息的空间，则可以使用3x3的表。面板网格组件以表格形式布置内容。
- 将“Panel Grid”拖到窗体中，然后在“Properties”视图的“Columns”字段中键入3。面板网格包含四个样本项。当添加/删除项目时，布局会随之调整。
将面板网格添加到页面后，Designer会自动向其中添加四个示例组件。
- 将“Output Text”组件从工具栏拖动到第一列第一行，然后在“Properties”视图的“Value”字段中键入Username:。
- 将“Text Input”组件从工具栏拖到第二列第一行，然后在“Text Input”视图的ID字段中键入username。
- 将“Message”组件从工具栏拖到第三列第一行，然后在“ For”字段中键入username。
- 将“Output Text”组件从工具栏拖到第一列第二行，然后在“Properties”视图的“Value”字段中键入“Password:”。
- 将“Secret Input”组件从工具栏拖到第二列第二行，然后在“Properties”视图的ID字段中键入password。
- 将“Message”组件从工具栏拖到第三列第二行，然后在“ For”字段中键入password。
- 从网格中删除示例项目。
尚未添加按钮，但到目前为止，该表单如下所示：

****[免费下载MyEclipse试用版>>>](https://www.myeclipsecn.com/download/)**
**[优惠购买MyEclipse正式版>>>](https://www.evget.com/mall/detail/3016)****

**注意：**仅当有消息要显示时，消息组件才会呈现。
为让表单看起来更漂亮，可以对输入框下的按钮设置为左对齐。如果在每个单元格中放置一个按钮(一个在Password下，一个在Secret Input下)，它们的间隔将是不均匀的。然而Panel Grid将组件直接添加到其中，并将它们逐个单元地放在表中。要将两个按钮组合在一起并将它们置于输入字段之下，需要使用panelGroup。
首先，在“Password”标签下需要一个空组件。其次，您需要在输入字段下添加一个panelGroup。然后在panelGroup内，添加两个按钮。
- 将“Output Text”组件拖到密码标签下方的单元格中，然后在“Properties”视图中删除“Value”字段的内容。这将创建一个空单元格。
- 将“Panel Group”组件拖动到输入字段下方的单元格中。将两个命令按钮组件拖到面板组中，并在Properties面板中键入Login和Clear到相应的值字段中。
**注意：**不用在消息组件下添加空组件。
页面的设计部分已经完成。通过以上内容，您应该了解了Designer的工作原理。如果您要构建完整的JSF应用程序，则需要为按钮分配操作处理程序，并将值绑定到输入字段，以确保托管bean正确地支持此页面上的值。 查看全部

**[12月，欢庆双“旦”，上“慧都网”小程序签到可兑软件商城通用抵价券，签的越多兑得越多！活动详情>>>](https://www.evget.com/article/2019/11/30/33697.html)**

本文承接**[上篇](https://www.myeclipsecn.com/bbs/?/article/206)**，继续为大家介绍使用MyEclipse开发EJB 3 Stateless Session Bean的其他步骤。
**3.部署Bean**
部署和运行步骤是通过使用MyEclipse将Bean部署到符合Java EE 6的应用程序服务器来完成的。本教程使用TomEE。
注意：必须在TomEE system.properties文件中禁用黑名单，以允许远程调用EJB。打开以下文件：
- 在“Servers”视图中右键单击TomEE server，然后选择Add/Remove Deployments。
- 在可用列中选择SampleEJBProject，单击“Add”，然后单击“Finish”。
- 右键单击服务器，如果服务器未运行，选择“Start”。
- 应用程序服务器启动，并向控制台视图显示有关成功部署Session Bean的消息。

**[免费下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[优惠购买MyEclipse>>>](https://www.evget.com/mall/detail/3016)**

**4.测试Bean**
在测试之前，需要在包中创建一个新的Java测试类。
- 右键单击该程序包，然后选择New > Class。
- 在“Name”字段中输入MyBeanClient，然后选择Public static void main复选框，让MyEclipse为其生成主方法。单击Finish。
- 在将代码添加到客户端并运行之前，需要将openejb-client-4.7.4.jar添加到构建路径。该JAR来自TomEE库文件夹，是可实现EJB远程调用规范的客户端。
- 右键单击项目，然后选择Build Path> Configure Build Path。
- 单击“Libraries”选项卡，然后单击“Add External JARs”。
- 导航到TomEE安装文件夹，然后导航到lib文件夹，然后双击openejb-client-4.7.4.jar。
- 单击确定。
现在，您可以将代码添加到测试客户端并运行它了。由于刚刚添加了JAR，实际的代码非常简单。
- 双击MyBeanClient，并将代码替换为以下代码。按Ctrl+S保存。

{{{
package sampleejbproject;

import java.util.Properties;

import javax.naming.InitialContext;
import javax.naming.NamingException;

public class MyBeanClient {

public static void main(String[] args) {
try {
Properties p = new Properties();
p.put("java.naming.factory.initial",
"org.apache.openejb.client.RemoteInitialContextFactory");
p.put("java.naming.provider.url", "http://localhost:8080/tomee/ejb");

InitialContext ctx = new InitialContext(p);
IMyBean bean = (IMyBean) ctx.lookup("MyBeanRemote");
bean.doSomething();
} catch (NamingException e) {
e.printStackTrace();
}
}
}
}}}
在上面的代码中有一些关键的事情需要注意：
- 代码将返回的Bean不是转换为MyBean，而是MyRemoteBean接口，因为它正在从JNDI上下文请求远程Bean。如上所述，不同的本地/远程接口公开的方法可能会有所不同，因此需要坚持使用所请求的接口。
- TomEE对没有指定名称绑定的EBJ使用默认的JNDI名称绑定，如下面的截图。注意，默认名称已在日志中打印出来。此默认名称因应用程序服务器而异，并且大多数人会使用@Stateless批注的maptedName值在所有应用程序服务器之间指定新的绑定。例如：@Stateless(name="MyBean", mappedName="ejb/MyBean")。
- 拥有Bean之后，可以将其视为本地实例，然后简单地调用它。
**5.资源**
[本教程的样例EJB3项目](https://www.evget.com/resource/detail-demo-14512) 查看全部

**[12月，欢庆双“旦”，上“慧都网”小程序签到可兑软件商城通用抵价券，签的越多兑得越多！活动详情>>>](https://www.evget.com/article/2019/11/30/33697.html)**

**1.创建一个EJB 3项目**
首先创建一个新的包含EJB的EJB 3项目。
- 选择File > New > EJB Project。
- 在项目名称字段中键入SampleEJBProject。
- 选择JavaEE 6-EJB 3.1作为JavaEE版本，选择None作为JPA支持，然后单击Finish。向导中的其余字段由 Window>Preferences>Frameworks>EJB Project 设置的MyEclipse EJB项目模板填充。
**注意：**本教程使用JavaEE 6使其能够在TomEE 1.7.2上运行。但是，在创建新项目时，JavaEE 7是一个可用的选项。
您可以选择配置可用于该项目的任何数据源来生成EJB3 Entity Bean，但是如上所述，这不是本教程的内容。
新项目包括默认的ejbModule源文件夹和sampleejbproject包：

**[免费下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[优惠购买MyEclipse>>>](https://www.evget.com/mall/detail/3016)**

**2.创建一个Stateless Session Bean**
创建Stateless Session Bean涉及定义Bean的接口并创建Session Bean。生成Session Bean时，它将实现两个接口，一个接口用于本地调用（在同一VM中），另一个接口用于远程调用（在VM外部、通过网络等）。可以基于调用者公开不同的功能（例如，不要将方法公开给返回大量数据集的远程调用）。
对于本教程，以及在某些情况下，您向Bean的本地和远程调用者公开完全相同的信息。由于这种假设，通过使用其中定义的所有方法实现基本接口（易于扩展Bean的本地和远程版本以及实现Session Bean），仍然可以轻松地遵循代码。结果如下所示：
- 右键单击sampleejbproject包，然后选择New > Interface。
- 在“Class name”字段中输入IMyBean。
- 单击添加，输入java.io。在“Choose interfaces”字段中，选择“Serializable”，然后单击“OK”。这扩展了可序列化，因此应用服务器可以根据需要更好地处理Session Bean。
- 单击完成。
- MyBean接口在Java编辑器中自动打开。添加一个方法签名public void doSomething(); ，然后按Ctrl + S保存。
- 右键单击sampleejbproject包，选择New> Session Bean（EJB 3.x）。
- 在“Name”字段中输入MyBean，选择“Remote”和“Local”复选框生成本地和远程接口版本，然后单击“Finish”。
现在，本地和远程接口已添加到项目中。
需要修改MyBeanLocal和MyBeanRemote接口来扩展IMyBean，并将doSomething()的实现添加到MyBean中。
如果没有定义IMyBean，则必须将方法定义复制粘贴到MyBeanLocal和MyBeanRemote中公开这些方法。在单个接口中定义方法会使事情变得容易一些。注意，您现在具有以下结构：
- 双击MyBean.java，并在最后的括号之前添加以下代码，以实现doSomething()添加到bean接口的方法。按Ctrl + S保存。

{{{
public void doSomething() {
System.out.println("Hello World!");
}
}}}
另外，每个接口都需要扩展IMyBean。打开MyBeanLocal.java和MyBeanRemote.java并添加扩展IMyBean到公共接口。下面是MyBeanLocal的一个例子：

{{{
public interface MyBeanLocal extends IMyBean {
}
}}} 查看全部

**建立一个项目**
一般情况，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) 查看全部

**[在开始本教程之前，请先下载并熟悉MyEclipse数据库工具。](https://www.myeclipsecn.com/download/)**
**[慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购物立减服务升级，购MyEclipse享折上折优惠！](https://www.evget.com/game/index/techsrv)**

**1、配置JPA项目**
JPA是类似于Hibernate的持久性规范，已成为Java EE 5规范的一部分。JPA使用Java 5注释来控制将普通Java类（POJO）映射到数据库表。
您可以通过创建任意受支持的基础项目类型（例如Java或Web项目）来创建启用JPA的项目，然后从MyEclipse菜单中将JPA构面添加到该项目中。右键单击该项目即可添加JPA构面，然后从菜单中选择MyEclipse > Project Facets > Install JPA Facet。同时，还可以通过打开项目的“Project Facets”属性，同时向项目添加多个构面。
**提供持久性**
MyEclipse为OpenJPA、Hibernate和EclipseLink JPA提供程序提供支持。
**数据库配置**
将项目与数据库和架构相关联，为设计时工具提供支持。如下图所示，项目与本地MyEclipse Derby数据库的数据库驱动程序关联。
除了可以依赖MyEclipse附带的库，还可以单击下载图标添加要包含在项目中的用户库。
同时，您还可以右键单击该项目从菜单中选择“Properties”，展开MyEclipse > Project Facets，然后选择Java Persistence，打开Java Persistence properties页面随时更改JPA项目的数据库驱动程序关联。
**2、从数据库反向工程实体和DAO**
右键单击一个JPA项目，然后从菜单中选择“Generate Entities & DAOs”。您可以选择使用MyEclipse逆向工程工具或DALI实体生成器进行选择，将启动相应的JPA逆向工程向导。
右键单击DB Browser视图中的表生成实体。
逆向工程过程是完全可定制的。使用JPA逆向工程向导，可以选择要生成的工件以及该工件所基于的数据库表。
MyEclipse还可以生成具有结果分页支持的DAO findBy<property>查询。生成的结果分页API为DAO客户端提供了细粒度的程序控制，可定位到结果集的特定行号并获取n个实体。
以下是逆向工程处理器生成的代码的几个样本片段：
**3、高级实体编辑工具**
**MyEclipse Java持久性透视图**
MyEclipse Java Persistence透视图为面向jpa的任务提供了最佳的编辑器和视图布局。
**JPA Details视图**
通过“JPA Details”视图，可以轻松编辑实体注释。
**JPA Diagram编辑器**
JPA Diagram编辑器使您可以轻松创建新实体或在现有JPA项目中编辑实体。
**JPA Annotation Table和Column Content Assist**
**JPA Entity Validation**
可检测到映射中的错误并在编辑器和“Problems”视图中显示。
可以在项目级别启用或禁用JPA Entity Validator。
**4、高级Spring-JPA集成**
**Spring 2支持**
将JPA构面添加到已经具有Spring构面的项目时，您可以选择高级Spring-JPA支持（反之亦然）。这种级别的支持使JPA工具可以与项目的Spring工件一起使用。下图显示了Spring-JPA项目配置向导。
选择Spring-JPA支持，主要bean配置文件，并自定义bean id和事务支持。
**逆向工程实体和数据库中的Spring DAO**
对于配置为支持高级Spring-JPA功能的项目，除了从数据库架构生成实体类之外，还可以生成与Spring兼容的DAO。在逆向工程过程中，将使用每个DOA类的生成的bean条目更新Spring应用程序上下文文件。
生成Spring DAO：
生成的Spring应用程序上下文文件：
生成的Spring DAO扩展自Spring的JpaDaoSupport：
 查看全部

**[在开始本教程之前，请先下载并熟悉MyEclipse数据库工具。](https://www.myeclipsecn.com/download/)**
**[慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购物立减服务升级，购MyEclipse享折上折优惠！](https://www.evget.com/game/index/techsrv)**

**1、什么是Hibernate？**
Hibernate是一种非常流行的、基于Java的开源对象关系映射（JORM）引擎，易于启动和运行，提供了丰富的功能，包括：
- 多种映射策略
- 传递持久性
- 单对象到多表的映射
- 集合支持
- 多态关联
- 可自定义的SQL查询
Hibernate用于在运行时将数据库结构映射到Java对象。使用像Hibernate这样的持久性框架，开发人员可以专注于编写业务逻辑，而不是编写准确、高效的持久性层（包括DAO、SQL查询、JDBC代码、连接管理等）。
任何需要在Java应用程序对象和数据库表之间移动数据的Java应用程序都可以使用Hibernate。因此，它在开发两层和三层Java EE应用程序中非常有用。将Hibernate集成到您的应用程序中涉及：
- 将Hibernate核心和支持JAR库安装到项目中
- 创建一个hibernate.cfg.xml文件来描述如何访问数据库
- 为每个可持久的Java类创建单独的映射描述符文件
**1.1导致Hibernate的历史**
在Java数据库和Web编程的早期，开发人员使用java.sql包提供的不同类访问其数据库，这包括从DriverManager获取驱动程序、创建和使用连接、正确处理异常、关闭连接等。在此阶段，一个常见的问题是忘记清理数据库连接，并在它们运行了一段时间后在应用程序中得到连接异常的反馈。
几年后，连接池成为一个大话题，因为它们让开发人员不用再担心创建和管理（清理）数据库连接，而是把精力集中在他们的SQL和ResultSet解析代码上。突然之间，长时间运行的应用程序中数据库连接异常的问题基本解决了。但是，仍然经常看到数百行样板代码用于用值填充查询并解析SQL查询返回的ResultSet。
又过了几年，有人想到了将ResultSet结果直接自动映射到Java对象的方法，这在很大程度上解决了所有冗余样板解析代码的问题。那时，Java数据库开发已经迈出了几大步，并且变得越来越简单。然后，Hibernate模式为人熟知。
随着Hibernate的出现，不仅这些东西会继续自动化，Hibernate也会管理内存中对象的状态，它会担心何时以及如何从数据库读取或写入对象值。现在，开发人员只处理对象（或映射对象），Hibernate则处理其他所有内容。开发人员不再编写JDBC和SQL代码。相反，他们使用的是为他们工作的代码。
当Hibernate出现时，另一种可用的持久性技术是EJB2.x。Hibernate的时间安排、易用性和强大功能都是Java领域在相当长一段时间内所采用的最快技术之一。
**2、Hibernate项目配置**
您可以通过创建任何受支持类型的基础项目（例如Java或Web项目）添加Hibernate facet，来创建启用了hibernate的项目。MyEclipse为您创建一个hibernate.cfg.xml文件，您必须指定数据库连接详细信息。
您也可以通过打开项目的Project Facets属性，将多个构面同时添加到项目中。
**2.1Hibernate映射和配置**
Hibernate用Java编写，可以通过两种类型的配置文件进行高度配置。第一种配置文件名为hibernate.cfg.xml。启动时，Hibernate会查询此XML文件的操作属性，例如数据库连接字符串和密码、数据库方言以及映射文件的位置。Hibernate在类路径上搜索此文件。
第二种类型的配置文件是映射描述（文件扩展名* .hbm），它指示Hibernate如何在特定的Java类和一个或多个数据库表之间映射数据。MyEclipse提供了用于处理所有这些配置文件类型的工具，并在您更改数据库和Hibernate映射的Java类时使它们保持同步。编辑器具有以下功能：
- 基于表单的高级编辑器和随附的向导
- 超链接导航到引用的类和属性
- 类名自动完成
- 属性名称自动完成
- 内容有助于映射文件元素、属性和值
**3、逆向工程数据库表**
您可以将数据库表信息反向工程为Hibernate（Java）对象，然后将它们添加到项目中。为了最大程度地控制生成的Hibernate对象，可以在向导中选择详细信息，例如主键生成策略、对象名称、类型等。
在Database Explorer透视图中，可以查看所连接的数据库的内容。在DB浏览器中，右键单击要反向工程的表，然后从菜单中选择Hibernate Reverse Engineering。完成向导后，系统将提示您切换到Hibernate透视图。
这些类将生成到在向导中选择的Java包中。
对数据库表进行反向工程时，实体将显示在配置文件的Mappings部分中。
**4. HQL Editor**
HQL Editor以及Hibernate透视图中的其他HQL视图可帮助开发、评估或测试HQL查询。HQL是一种类似于SQL的语言，称为Hibernate查询语言。它有时看起来像是简化的SQL，使用对象名和引用而不是表名和列名。该编辑器具有以下功能：
- 内容辅助
- 输入时，Hibernate动态查询转换器视图将HQL查询转换为SQL。
- Hibernate Query Results视图可以包含多个结果集。结果属性显示在Properties视图中。
- 查询参数视图可轻松执行变量查询。
- 项目选择器，可以在不同的Hibernate项目之间切换上下文。
使用HQL Editor，可以即时编写并运行HQL。编辑器利用MyEclipse从数据库进行反向工程的对象，将查询转换为SQL（如右下所示），然后运行它。结果在Java对象中返回，并显示在左下角。
对数据库进行反向工程之后，就可以开始编写应用程序以读取、写入和更新数据库中的对象。放置好Java类和方法后，可以在HQL Editor中运行Hibernate查询来查询数据库，这是查询数据库的另一种方法。您还可以切换到Database Explorer透视图并从那里查询数据库以查看相同的结果。
**5、Criteria Editor**
除了HQL编辑器之外，MyEclipse Hibernate工具还包括一个Criteria编辑器。Hibernate中的Criteria是一种利用对象实例结合查询约束来针对实体创建查询的方法。例如，假设创建一个类型为User的实体实例，将实体指定为查询的条件，并告诉条件只返回前10个结果，这是创建用于实体的复杂查询的有效且快速的方法。
要访问Criteria Editor，请右键单击包含Hibernate facet的项目，然后选择MyEclipse > Open Criteria Editor。
打开Criteria Editor后，可以在编辑器中输入任何表示条件的有效Java代码，并使用编辑器顶部的“Run”图标执行它们。
下面的示例显示了一个基于EchoMessage实体的简单条件，要求Hibernate返回其EchoMessageId值为2的实体。结果出现在Result视图中。
可以使用MyEclipse中的Criteria Editor来编写和执行任何有效的基于条件的代码。在Java编辑器中输入条件时，选择它并调用快速修复将显示“Copy to Criteria”编辑器操作。选择此操作将打开“Criteria”编辑器，并使用所选文本进行初始化。
您可以在Criteria Editor中测试和编辑条件。完成后，关闭编辑器可用修改后的条件查询替换最开始选择的文本。
**6、常见问题**
**Q：**Hibernate与EJB 3/JPA相比如何？
**A：**Hibernate 3.2实际上是与JPA兼容的，它实现了所有新的注释，这些注释让JPA使用起来非常自动化且更简单。因此，除了使用JPA的commercial implementation外，还可以使用Hibernate，所有标准JPA批注仍将保留在类中，而无需进行任何更改。
**Q：**Hibernate可以扩展到非常大的应用程序吗？
**A：**可以。实际上，Hibernate的根源来自于两位创始人在大型企业应用程序中担任顾问的经验，Hibernate是他们对持久性在应用程序中应如何起作用的看法。
几年前，Gavin King向社区提出了一项挑战，要求找到手工调整的JDBC SQL。该SQL执行的幅度要比Hibernate生成的SQL快，由此也能看出该框架非常注重功能、灵活性和性能。 查看全部

在**[上篇](https://www.myeclipsecn.com/bbs/?/article/200)**中，介绍了创建启用了Hibernate的Java项目、自定义Hibernate配置文件、使用逆向工程进行Java表映射等详细操作步骤（点击此处查看更多）。本文承接上篇，继续介绍“使用Hibernate开发Persistence”操作方法的其他内容。
**[在开始本教程之前，请先下载并熟悉MyEclipse数据库工具。](https://www.myeclipsecn.com/download/)**
**[慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购物立减服务升级，购MyEclipse享折上折优惠!](https://www.evget.com/mall/detail/3016)**
**5、使用HQL Editor**
- 通过以下步骤使用ECHO_MESSAGE表（该表是使用本教程开始时提供的SQL命令添加的）。
- 映射到ECHO_MESSAGE表。
- 右键单击HibernateDemo项目，然后选择[MyEclipse](https://www.myeclipsecn.com/)>打开HQL Editor。
**注意：**每次打开扩展名为.hql的文件时，HQL Editor都会打开。
- 编辑器打开后，输入EchoMessage。
- 单击运行图标或按CTRL + F9执行查询。
- 使用查询参数视图执行变量查询。
**注意：**在为项目初始化HQL Editor后更改配置、映射或数据对象，请使用编辑器工具栏上的“Refresh”按钮以确保编辑器选择了最新的更改。
如果您正在编辑一个NamedQuery注释，可以在查询属性重调用quick fix（通常为CTRL + 1）来复制到HQL Editor。这将打开HQL编辑器，并使用查询字符串对其进行初始化。
您可以在HQL Editor中测试和编辑查询。完成后，关闭编辑器可让您将修改后的查询复制回Java编辑器中的query属性。
打开项目的HQL Editor后，将为NamedQueries提供内容辅助和验证（CTRL +空格键）。
**6、测试HibernateDemo应用程序**
测试Hibernate持久性的一种方法是使用main方法创建Java类。测试类使用Java对象和由Hibernate向导创建的HibernateSessionFactory。查看在HibernateSession类中定义的两个重要方法，如下所示，它们在测试代码中使用。
显示的是SessionManager类中的两个重要的静态方法。
- getSession（）：此方法返回一个Session变量，可用于访问Hibernate Session类。每当您要使用Hibernate会话时，都可以调用此方法来获取缓存的Hibernate Session。
- closeSession（）：如果会话已经启动，则此方法可将其关闭。
以下是测试代码中的步骤列表以及源代码示例：
- 选择File > New > Class。
- 输入包名称。
- 在Name字段中输入HibernateReadTest。
- 如图所示完成页面，然后单击“完成”。
- 打开HibernateReadTest.java文件，将源代码替换为下面的代码，然后按CTRL + S保存。

{{{
package com.myeclipse.hibernate;

import java.math.BigDecimal;
import org.hibernate.HibernateException;

public class HibernateReadTest {

public static void main(String[] args) {
// Step 1 - Create the DAO
EchoMessageDAO dao = new EchoMessageDAO();
try {
// Step 2 - Use findById to retrieve the message with ID = 1
EchoMessage echoMessage = dao.findById(new BigDecimal(1));
System.out.println("Entity retrieval successful, message is: "
+ echoMessage.getMsg());
} catch (HibernateException e){
System.err.println("Entity retrieval failed.");
e.printStackTrace();
} finally {
try {
dao.getSession().close();
} catch (Exception e) {
// do nothing
}
}
}
}
}}}
- 在资源管理器中右键单击HibernateReadTest.java文件，然后选择 Run > Run As > Java Application。将打开“Console”视图，如果测试成功，您将看到如下图所示的输出。
**注意：**如果看到log4j警告，可以忽略。
**7、导入示例HibernateDemo项目**
- [下载HibernateDemo.zip。](https://www.evget.com/resource/detail-demo-14454)
- 从菜单中选择Import > Existing Projects into Workspace，选择“Select archive file”选项，然后导航至zip文件。单击完成将项目导入到工作区中。
- 由于此项目是使用旧版本的MyEclipse创建的，因此将打开“Project Migration”向导。请按照向导中的步骤迁移项目。
- 进行以下操作重新配置项目来匹配您的环境：
a、编辑hibernate.cfg.xml并更改连接设置以反映您的数据库设置。提示：可能需要更改EchoMessage.hbm.xml才能改变在class元素中指定的模式。
b、建立与数据库的连接，并执行DDL/DDL.sql文件中的代码创建并填充示例表。在执行之前，可能需要使用模式前缀来限定表，并对数据库特定的DDL进行其他更改。
c、将数据库的JDBC驱动程序JAR复制到项目中。右键单击项目，然后选择build path > Add to build path，将其添加到构建路径中。
本教程还包括以下文件：
- log4j.properties - 用于控制log4j库执行的日志记录级别。
- ehcache.xml - 用于配置ehcache库。
- HibernateWriteTest.java - 一个示例应用程序，演示了如何使用DAO来写数据库。

想与更多人聊MyEclips？加入**MyEclipse中国（官方2）：742336981**畅所欲言吧！
想及时获取MyEclips资讯？扫描下方二维码，MyEclips信息跟你走！
 查看全部

**[在开始本教程之前，请先下载并熟悉MyEclipse数据库工具。](https://www.myeclipsecn.com/download/)**
**[慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购物立减服务升级，购MyEclipse享折上折优惠!](https://www.evget.com/mall/detail/3016)**
在本教程中，将介绍如何：
- 在Java项目中启用Hibernate支持
- 创建一个Hibernate配置文件
- 使用自定义Session Factory
- 使用HQL编辑器生成Java类和数据库映射文件
**1、创建一个示例数据库表**
在开始本教程之前，必须设置受支持的数据库服务器，例如嵌入式Derby数据库或外部安装的数据库。对于本教程，则使用在MyEclipse中连接到数据库中创建的Oracle数据库连接配置文件。
首先，请使用以下SQL命令创建您将映射到Java类的数据库表。为方便测试，该表包括几个记录。
echo_message DDL
创建表echo_message
（
id整数PRIMARY KEY不为null，
msg VARCHAR（255）
）;
插入echo_message值（1，'hello world'）;
插入echo_message值（2，'goodbye world'）;

**注意**：即使本教程使用Oracle，上面的说明和示例表也足够通用，可以用于任何数据库。
**2、创建一个启用了Hibernate的Java项目**
- 选择 File>New>Project>Java Project。
- 在“HibernateDemo”字段中键入HibernateDemo，然后单击“完成”。
- 右键单击HibernateDemo，然后选择MyEclipse> Project Facets> Install Hibernate Facet。
- 从目标运行时下拉列表中选择MyEclipse通用Java Runtime，然后单击下一步。MyEclipse 为您创建一个新的hibernate.cfg.xml文件。
**注：**启用Hibernate注释支持仅适用于Hibernate 3.2和3.3，Hibernate 4.x自动包含注释支持。注释支持在SessionFactory类中创建AnnotationConfiguration而不是常规Configuration。如果您要使用带注释的POJO而不是Hibernate映射文件，这一点很有必要。
- 单击“Java Package”字段旁边的“新建”以为session factory类创建新的软件包。键入com.myeclipse.hibernate作为程序包名称，然后单击“完成”。
- 单击“Next”，然后保留“ Specify数据库连接详细信息”复选框。
- 从DB Driver下拉列表中，选择在MyEclipse中连接数据库时创建的Oracle配置文件。这一操作将自动填充其余字段。
- 您可以通过单击Next添加库，或单击Finish接受默认的库。
**注意：**在这个阶段不需要配置文件。您无需选择概要文件，采用手动填充此页面上显示的其余详细信息。但有一点必须注意，一定要在向导完成后将JDBC驱动程序JAR文件复制到项目中。
现在，可以跳过上面执行的数据源配置，稍后使用Hibernate Configuration编辑器进行。
**注意：**稍后还可以通过选择File > New >Other，展开MyEclipse > Hibernate并选择Hibernate Session Factory来创建Session Factory。如果您选择将库复制到项目中，那么在完成过程中，向导在复制库和更新各种项目资源时最多可能会出现30秒钟的非活动状态。这时，需耐心等待所有操作完成，然后再采取其他措施。
完成向导将执行以下操作：
- 如果选择将Hibernate库（JAR）复制到项目中，则将其安装到项目中
- 更新项目的构建路径以包括已安装的Hibernate库
- 为项目创建和配置hibernate.cfg.xml文件
- 为项目创建一个自定义SessionFactory类（例如HibernateSessionFactory），以简化Hibernate会话处理。
下图突出显示了新创建的HibernateSessionFactory.java文件的重要功能。此类管理单个Hibernate Session对象，该对象由该getSession()方法延迟初始化，并由该方法刷新和释放closeSession()。在运行时，Hibernate会话创建过程必须能够在类路径上找到hibernate.cfg.xml文件。
CONFIG_FILE_LOCATION变量定义了hibernate.cfg.xml文件相对于软件包的路径，默认值由Hibernate支持向导提供。如果您重新定位 hibernate.cfg.xml文件，则必须手动修改CONFIG_FILE_LOCATION值来引用新位置，或者在使用前使用该setConfigFile()方法进行设置。
**3、自定义Hibernate配置文件**
完成添加Hibernate功能的向导后，hibernate配置文件将自动打开。如果在添加功能时跳过了数据源配置，那么现在需要使用以下步骤进行操作。如果您已经配置了数据源，请继续添加属性。
- 选择“Use JDBC Driver”选项，指定在数据库资源管理器中定义的JDBC驱动程序。如果尚未配置JDBC驱动程序，请阅读[MyEclipse教程“连接到数据库”](https://www.evget.com/article/2015/2/4/22120.html)，并继续之前进行的配置。
- 在“Connection Profile”下拉列表中选择配置文件。如果配置了JDBC驱动程序但未配置连接配置文件，则可以单击“New profile”来创建一个新的连接配置文件。如果已经有一个连接配置文件，从下拉列表中选择它时，接下来的四个字段将自动填写。
- 单击 Copy JDBC Driver并添加到类路径链接。
- 从“Dialect”下拉列表中，为数据库选择适当的Hibernate方言。
Configuration页现在应该像这样：
您可以使用“Properties”选项来添加和编辑属性。
映射部分允许您添加项目中可能已经存在的映射文件，同时还支持从资源管理器中拖放映射文件。
下图显示的是完成上述步骤后的Hibernate配置文件源。
**4、使用逆向工程进行Java表映射**
由于大多数公司的Web项目都涉及到与关系数据库中现有的公司数据进行交互，所以本节重点介绍正向工程Java数据对象和来自现有数据库的映射描述符。
- 选择Window > Open Perspective > Other，然后选择MyEclipse Hibernate。
- 使用您在Hibernate配置中使用的配置文件打开数据库连接。
- 浏览数据库架构，直到找到要为其创建Hibernate映射的表/实体。
- 右键单击该表，然后选择“Hibernate Reverse Engineering”。或者从数据库浏览器中拖动表，并将它们放到Hibernate Configuration编辑器中以启动向导。
**注意：**您可以在数据库浏览器中选择多个表，以便同时对它们进行反向工程。
- 单击Java src文件夹字段旁边的浏览，查看可用的Hibernate项目和可在其中生成文件的源文件夹。在HibernateDemo项目中选择src文件夹。
- 单击Java软件包字段旁边的浏览，然后选择com.myeclipse.hibernate软件包。
- 如下所示完成向导的其余部分，然后单击“下一步”。
**注意：**向导的第2页和第3页的设置用于自定义逆向工程过程。无需自定义任何设置，通过单击Finish now就可以启动该过程。
- 接受默认设置，然后单击“下一步”。
- 单击两个“Include Referenced Tables”复选框，使向导在反向工程过程中包括引用表。单击完成。
**注意：**选择表或列可以专门针对表或列定制逆向工程。
逆向工程执行以下操作：
- 创建Abstract <tablename>类。这个抽象类提供了必需的Hibernate兼容性功能，例如用于与数据库表中的列相对应的持久属性的公共getter和setter方法。
- 创建<tablename> Java类，它是Abstract <tablename>类的具体子类。所述<表名> 类旨直接使用附加的业务和验证逻辑进行修改，并且在后续的生成过程中不会被覆盖。
- 创建.hbm.xml Hibernate映射描述符。这个文件指导Hibernate如何<tablename> Java类和数据库表之间映射数据。
- 在hibernate.cfg.xml文件中注册<tablename> .hbm.xml映射描述符。
- 创建<tablename> DAO Java类。该类提供对<tablename>数据对象类的便捷性访问。
- 创建IBaseHibernateDAO接口和BaseHibernateDAO类。这些类对于基本DAO的功能是必需的，它们使用添加Hibernate功能时生成的Session工厂（com.myeclipse.hibernate.HibernateSessionFactory）来获取Hibernate会话。
下图突出显示了所生成的类、关键方法和映射文件，以及对hibernate.cfg.xml文件中添加的映射文件的引用。
**4.1使用Templates对生成的代码进行微调**
- [将模板文件](https://www.evget.com/resource/detail-demo-14454)下载并解压到、文件系统。
- 按照zip文件中README.txt的说明自定义模板。
- 调用逆向工程向导。在向导的第一页上，选择“Use Custom Templates”选项，然后在“Template Directory”字段中，指定包含您下载的模板的文件夹。
**4.2使用Custom Reverse Engineering Strategy**
- 右键单击项目，选择Properties，并选择Java构建路径。
- 单击Libraries标签，然后单击Add Library。
- 选择MyEclipse Library，单击Next，并选择MyEclipse Persistence Tools。单击Finish。
- 在项目中创建一个新类，来扩展org.hibernate.cfg.reveng.DelegatingReverseEngineeringStrategy类。
- 定义单个参数构造函数，例如columnToPropertyName。以下是一个示例MyStrategy.java文件，该文件将ME_前缀添加到所有生成的属性中。

{{{
package com.myeclipse.hibernate;

import org.hibernate.cfg.reveng.DelegatingReverseEngineeringStrategy;
import org.hibernate.cfg.reveng.ReverseEngineeringStrategy;
import org.hibernate.cfg.reveng.TableIdentifier;

public class MyStrategy extends DelegatingReverseEngineeringStrategy {
public MyStrategy(ReverseEngineeringStrategy strategy){
super(strategy);
}

public String
columnToPropertyName(TableIdentifier table, String columnName) { return "ME_" + super.columnToPropertyName(table, columnName);
}
}
}}}

- 在“Reverse Engineering”向导的第二页上，指定刚创建的类。

想与更多人聊MyEclips？加入***MyEclipse中国（官方2）：742336981***畅所欲言吧！
想及时获取MyEclips资讯？扫描下方二维码，MyEclips信息跟你走！
 查看全部

在**[上篇](https://www.myeclipsecn.com/bbs/?/article/198)**中，介绍了设置样本数据库、连接到数据库、创建一个启用了Hibernate的项目、将Spring Facet添加到项目中、逆向工程数据库表以及编写 Hibernate-Spring 代码的详细操作方法。本文承接**[上篇](https://www.myeclipsecn.com/bbs/?/article/198)**，继续为大家介绍使用Hibernate和Spring执行数据库操作的相关内容。
**[免费下载MyEclipse>>>](https://www.myeclipsecn.com/download/)**
**[慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购物立减服务升级，购MyEclipse享折上折优惠!](https://www.evget.com/mall/detail/3016)**
**7、创建一个Spring Bean作为PersistenceLayer**
PersistenceLayer如何获得对UserDAO的引用来真正执行那些持久性操作？答案是：您需要为抽象的持久层创建一个新的Spring bean配置条目，让它通过正确引用MyEclipse生成的DAO，来与数据库进行通信。
- 单击 Window > Show View > Other展开Spring，然后选择Spring Explorer打开Spring Explorer。
- 展开HibernateSpringProject> Beans> applicationContext.xml，右键单击bean，然后选择New Bean。
- 输入持久层的Bean的标识字段，然后输入在Bean类字段中的com.myeclipse.hibernatespring.PersistenceLayer。
- 单击属性标签，然后单击添加。
- 在“Name”字段中键入userDAO，从“Spring Type”下拉列表中选择ref，在“Reference”字段中输入UserDAO，然后单击“完成”。
- 在Bean向导窗口上单击Finish，然后按Ctrl+S保存配置文件。完成以上操作后，业务逻辑代码就可以向BeanFactory请求persistenceLayer Bean，并获取该Bean的准备好的实例。
**8、创建一个数据源Spring Bean**
- 使用Spring Explorer创建一个新的bean。
- 在“Bean Id”字段中输入dataSource，并在“Bean class”字段中输入org.springframework.jdbc.datasource.DriverManagerDataSource。
- 单击“Properties”标签，添加以下属性：
1、名称类型值
2、riverClassName value：com.mysql.jdbc.Drive
3、rurl value jdbc：mysql://localhost:3306/test
4、用户名值root
5、密码值<your password>
- 在Bean向导窗口上单击Finish。
- 在Spring资源管理器中，右键单击sessionFactory bean，并选择Add Properties。
- 在“Name”字段中输入dataSource，将Spring类型保留为ref，在“Reference”字段中输入dataSource。
- 单击“Finish”，然后按Ctrl S保存配置文件。
**9、运行应用程序**
- 在资源管理器中，展开 HibernateSpringProject > src > com.myeclipse.hibernatespring。
- 右键单击BusinessLogic.java，选择 Run As>Java Application。Console视图将显示结果。
通过以上步骤可以看到，使用PersistenceLayer时，仅用几行代码就可以从数据库中存储、更新和删除用户。
**10、使用Hibernate注释和Spring**
MyEclipse为独立的Hibernate项目和Spring/Hibernate项目提供了Hibernate注释支持。以下部分将简要概述对Hibernate Annotations和Spring的支持。
注意：Hibernate 4.x自动包含注释支持。
**10.1 创建具有注释支持的Hibernate / Spring项目（Hibernate 3.x）**
在为Hibernate 3.x创建、启用Hibernate和spring的项目时，需要执行以下操作来启用注释支持。当项目添加Hibernate3.x功能时，一定要选择“启用Hibernate注释支持”复选框。
- 在第3页上添加Spring功能时，请选中“Enable Hibernate annotation support”复选框。这将创建一个AnnotationSessionFactoryBean，而不是LocalSessionFactoryBean。在使用注释时，AnnotationSessionFactoryBean是必需的。
**10.2 逆向工程**
当您选择Spring bean配置文件时，使用上述过程的项目设置中的Hibernate项目属性页会在SessionFactory Bean ID下拉列表中同时列出LocalSessionFactoryBean bean和AnnotationSessionFactoryBean bean。
注意：为了在逆向工程过程中为Hibernate 3.x提供注释支持，必须在Active Configuration File字段中选择Hibernate配置文件，或者为SessionFactory选择Spring bean配置文件和 AnnotationSessionFactoryBean。
为Spring DAO提供的会话工厂bean Ids取决于您是否选择生成带注释的POJO或Hibernate映射文件。如果选择生成带注释的POJO，那么SessionFactory Id下拉列表中将仅显示AnnotationSessionFactoryBeans，否则将同时列出LocalSessionFactoryBean bean和AnnotationSessionFactoryBean bean。

想与更多人聊MyEclips？加入****MyEclipse中国（官方2）：742336981****畅所欲言吧！
想及时获取MyEclips资讯？扫描下方二维码，MyEclips信息跟你走！
 查看全部

在本教程中，您将学习如何：
- 连接到数据库
- 将Hibernate和Spring添加到项目中
- 通过对数据库表进行逆向工程来生成实体
- 创建Spring Beans作为持久层和数据源
- 启用Hibernate 3.x注释支持
**[免费下载MyEclipse](https://www.myeclipsecn.com/download/)**
**[慧都16周年·技术服务月，软件商城优惠券不限量免费领取，购物立减服务升级，购MyEclipse享折上折优惠！](https://www.evget.com/mall/detail/3016)**
**1、设置样本数据库**
本教程中的示例使用了一个带有用户表和数据的MySQL 5实例，用到了以下文件准备样本数据。在开始本教程之前，您必须建立一个数据库。
- 示例数据库内容
- 为用户表创建SQL脚本
**2、连接到数据库**
- 单击打开Database Explorer图标 ，选择MyEclipse数据库浏览器。
- 在数据库浏览器中，单击，然后选择新建。
- 从“Driver Template”下拉菜单中选择“MySQL Connector/J”，在“Driver name field”字段中键入MySQL Connector/J，将<hostname> [<：3306>] / <dbname>替换为localhost：3306 / test，然后输入用户名和密码。
- 单击添加JAR。导航到MySQL Connector/J JAR文件的位置，然后选择文件。“Driver classname field”将自动填充，然后点击Finish。
- 在DB Explorer中选择MySQL Connector/J，然后单击 打开链接。
**3、创建一个启用了Hibernate的项目**
您可以为任何受支持的基础项目（通常是Java或Web）启用Hibernate和Spring。
- 选择File>New>Project，展开Java，选择Java项目，然后单击下一步。
- 在“Project name”字段中输入HibernateSpringProject，然后单击“完成”。系统将提示您切换到Java透视图。选择“Yes”。
- 右键单击该项目，选择 Configure Facets > Install Hibernate Facet。注意，这里需要选择4.1作为Hibernate规范版本。
- 点击下一步。MyEclipse将创建一个新的hibernate.cfg.xml文件。
- 单击Java package字段旁边的New为session factory class创建一个新的软件包，并命名为com.myeclipse.hibernatespring，然后单击“完成”。
- 单击下一步，从数据库驱动程序下拉列表中选择MySQL Connector/J，输入密码，然后单击完成。
现在，该项目包含所有Hibernate和JDBC库，并且hibernate.cfg.xml文件在“Configuration”编辑器中打开。配置文件包含来自连接配置文件的连接信息。当您对数据库表进行反向工程时，实体将出现在配置文件的Mappings部分。
**4、将Spring Facet添加到项目中**
对于小型应用程序来说，Spring并不太适用，但是当您看到使用Spring通过简单地调整bean配置文件中的引用来交换代码库的整个部分有多么容易时，您就会意识到该工具的功能真的很强大。最明显的是，使用Spring来测试将会简单很多。例如，您可以交换一个持久性实现，该实现将其所有调用都发送给嵌入式DBMS，或者记录其所有活动。然后，当应用程序部署到生产环境中时，将持久性实现切换回使用主DBMS的代码，这些代码不使用日志记录就能提高性能。
- 右键单击该项目，然后选择 Configure Facets > Install Spring Facet。
- 接受默认的Spring版本和目标运行时，然后单击Next。
- MyEclipse将创建一个新的applicationContext.xml文件。点击完成。
现在，这个项目就同时具有Hibernate和Spring功能。
**5、逆向工程数据库表**
对数据库表进行反向工程时，会在项目中生成Hibernate（Java）对象。由于该项目是Hibernate-Spring项目，所以MyEclipse在逆向工程期间提供的不仅仅是普通DAO，而是Spring DAO选项。这就意味着系统将自动创建DAO Spring bean，这些bean的sessionFactory属性已经正确配置为对Hibernate SessionFactory的现有Spring引用。接下来，我们将通过几个步骤使用简单的逆向工程形式，让向导获取所有默认值。但是，为了实现最大程度的控制，您可以使用“Nxt”按钮，通过向导一步一步地浏览详细信息，比如主键生成策略、对象名称、类型等。
- 切换回数据库浏览器透视图。
- 在数据库浏览器中，将MySQL Connector/J扩展到用户表。
- 右键单击用户表，然后选择“Hibernate Reverse Engineering”。
- 单击Java src文件夹旁边的浏览，展开 HibernateSpringProject > src，选择com.myeclipse.hibernatespring，然后单击确定。
- 选择 Create POJO <> DB 表映射信息复选框，选择Java数据对象复选框，再选择Java数据访问对象（DAO）复选框，然后单击完成。您将收到系统关于切换到Hibernate透视图的提示，只需要单击“Yes”即可。
- 将Hibernate类生成到Java包中，并创建Spring Bean。
**6、编写 Hibernate-Spring 代码**
设置好项目后，就可以开始编写代码了。本过程需要两段代码：
- 业务逻辑：表示应用程序代码的主要方法。
- 持久层：这是业务逻辑应用于数据库功能的应用程序的抽象部分。如果使用的所有业务逻辑都是持久性层，那么您可以在这一层后面隐藏它工作的一些细节。本例使用Spring将执行数据库操作所需的必要DAO引用填充到持久层，这样做的好处是业务逻辑不需要了解任何相关信息。
将每个名为BusinessLogic.java和PersistenceLayer.java的类添加到com.myeclipse.hibernatespring包。从持久性层开始，因为它位于刚刚生成的所有代码和在业务逻辑层中编写的代码之间。它是持久化技术（Hibernate）和由Spring管理的业务逻辑（main方法）之间的抽象。将以下代码添加到PersistenceLayer类，这个类的目的是获得一个由Spring注入的UserDAO实例，然后使用该引用来实现save/find/update和delete操作（不需要调用代码的）。这使您不用完全更改应用程序的代码就能轻松、快速地修改应用程序中的持久性代码。更具体地说，如果您想更改PersistenceLayer的实现方式，比如说要更好地管理异常、事务或其他任何事情，可以通过编辑此类来完成。只要所有方法标签保持不变，就不需要重构整个应用程序。

{{{
package com.myeclipse.hibernatespring;

public class PersistenceLayer {
private UserDAO userDAO;
public UserDAO getUserDAO() {
return userDAO;
}

public void setUserDAO(UserDAO userDAO) {
this.userDAO = userDAO;
}

public void addUser(User user) {
userDAO.save(user);
}

public User findUserById(Integer id) {
return
userDAO.findById(id);
}

public void updateUser(User user) {
userDAO.merge(user);
}

public void deleteUser(User user) {
userDAO.delete(user);
}
}
}}}
另外，由于此抽象层与应用程序代码中的持久性代码是松散地耦合的，可以轻松的使用Spring注入一个测试UserDAO实现。例如，该实现模拟数据库操作，但实际上并不执行这些操作。现在您已经实现了PersistenceLayer，接下来将以下业务逻辑（或主要方法实现）代码添加到BusinessLogic类。业务逻辑（主要方法）利用抽象的持久层来添加/查找/更新以及从数据库中删除用户。

{{{
package com.myeclipse.hibernatespring;
import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BusinessLogic {

public static void main(String[] args) {

/* 1. Create a new user */
Integer id = new Integer(1);
User user = new User();
user.setId(id);
user.setUsername("jdoe");
user.setPassword("1234");
user.setFirstName("John");
user.setLastName("Doe");
user.setDateCreated(Long.valueOf(System.currentTimeMillis()));

/* 2. Load the Spring bean configuration and create a bean factory */
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

/* 3. Create instance of PersistenceLayer */
PersistenceLayer persistenceLayer = (PersistenceLayer) ctx.getBean("persistenceLayer");

/* 4. Save the new user to the database */
persistenceLayer.addUser(user);

/* 5. Confirm that our user was saved */
User userLoadedFromDB = persistenceLayer.findUserById(id);
System.out.println("User Loaded from DB [username="
+ userLoadedFromDB.getUsername() + ", password="
+ userLoadedFromDB.getPassword() + ", firstName="
+ userLoadedFromDB.getFirstName() + ", lastName="
+ userLoadedFromDB.getLastName() + "]");

/* 6. Update the user */
userLoadedFromDB.setFirstName("Johnathan");
persistenceLayer.updateUser(userLoadedFromDB);

/* 7. Confirm that the update worked */
User userLoadedFromDBAgain = persistenceLayer
.findUserById(id);
System.out.println("User Loaded from DB Again [firstName="
+ userLoadedFromDBAgain.getFirstName() + "]");

/* 8. Delete the user */
persistenceLayer.deleteUser(user);
}
}
}}}
这个代码具有以下功能：
+ 创建一个新用户来插入数据库。它使用MyEclipse在从数据库逆向工程用户表时生成的用户POJO。
+ 创建一个bean工厂。它的作用是读入Spring bean配置文件，然后向“工厂”提供一个实例，该“工厂”可用于根据该文件中的规范获取bean的实例。这是Spring的“入口点”。
+ 创建PersistenceLayer实例，这样就可以执行数据库操作了！注意，为了正确填充UserDAO引用，您必须使用bean工厂来获取实例。
+ 使用创建的PersistenceLayer实例将新用户保存到数据库。注意，由于所有调用都通过PersistenceLayer进行，因此BusinessLogic类不了解UserDAO类或任何底层详细信息。
+ 在保存时，分配给用户的ID将从数据库中重新加载用户，通过这样的方式来检查并确保所有值都是正确的。
+ 更新用户名查看更新记录是否有效。
+ 重新从数据库加载用户，以确保修改的地方已完全更新。
+ 从数据库中删除用户。

想与更多人聊MyEclips？加入****MyEclipse中国（官方2）：742336981****畅所欲言吧！
想及时获取MyEclips资讯？扫描下方二维码，MyEclips信息跟你走！
 查看全部