MyEclipse Logo

MyEclipse Hibernate 和 Spring 教程(含官方视频)
翻译: 刘长炯 BeanSoft@126.com 2007.11
http://www.blogjava.net/beansoft/

内容

  1. 简介
  2. 建议的听众
  3. 系统需求
  4. 开始工作
  5. 反向工程
  6. 编写和运行 Hibernate 整合 Spring 代码
  7. 小结
  8. 常见问题 FAQ
  9. 资源
  10. 反馈 

1. 简介

欢迎阅读 MyEclipse Hibernate 和 Spring 教程. 这个教程用来展示如何在 MyEclipse 中快速的在同一个项目上使用 Hibernate 和 Spring 来进行工作. 

在开始这个教程之前, 我们鼓励你首先去阅读在资源部分单独的 Introduction to Hibernate 和 Introduction to Spring 教程, 这些教材中包含了更多的单独每个模块的细节内容. 这个教程中使用的 users 项目和 Introduction to Hibernate 教程中所使用的那个项目是相似的.

这个教程中, 我们通过在持久化代码(Hibernate)和业务逻辑层来创建一个抽象层来展示如何使用 Spring 和 Hibernate. 业务逻辑层通常和"web 应用程序"所做的工作一样, 为了简化期间, 在这个例子里我们用了一个 main 方法来表示业务层. 通过添加这么一层抽象, 我们可以在幕后使用 Spring 来控制可插入的持久化框架, 而我们的业务代码来使用这个抽象层(通过 main 方法).

对于小型的应用程序来说这个项目看起来是不合逻辑的, 但是你可以看到使用 Spring, 通过简单的修改一个 bean 配置文件中的引用, 就可以更改整个项目的结构, 因此你可以感受到这个工具的强大威力. 很明显, 它使代码的测试变得简单多了. 可以说通过切换持久化实现, 可以调用一个嵌入式的数据库服务器(DBMS)或者打印一下调用日志(译者注:也就是在实现类里用 System.out.println() 输出一下方法调用). 当程序发布到生产机的时候,   持久层的实现可以切换回真实的生产机数据库并且不再输出任何日志, 以免影响服务器性能(译者注: 服务器输出日志会严重影响性能, 是因为日志输出是单线程加同步的, 要不然输出的日志文件就坏了, 所以服务器上不要输出无意义的日志, 如调试信息).

使用 Spring 有无数可能 (译者注: 典型废话一句,  用 EJB 也有无数可能).

2. 建议的听众

这个教程的目标受众是那些好歹对 MyEclipse 或者 Eclipse 有所了解的开发人员, 应该对使用 IDE 进行代码浏览以及理解一些常见的概念例如 "View 视图". 另外, 开发人员最好熟悉 Java 中的持久化开发 (JDBC, EJB, iBatis, JPA, 等等.), 以及 Spring 和依赖注入,  这样才能更快的理解 Hibernate 扮演的角色.

如果读者不太清楚这些单独的技术如何工作, 强烈建议你来学习位于下面的资源部分列出的单独的 Hibernate 和 Spring 教程.
 

3. 系统需求

这个教程基于 MyEclipse 5.1 制作, 捆绑的是 Hibernate 3.1 和 Spring 1.2 的类库. 如果你在使用其它版本的 MyEclipse, Hibernate 或者 Spring, 绝大部分的屏幕操作和说明都将是十分相似的.

如果你使用的是最新版本的 MyEclipse, 并且发现本教程的一些部分和你使用 MyEclpse 时所看到的屏幕不一样, 请 告诉我们 , 我们(注: MyEclipse 文档团队, 不是我, 翻译这份文档的人) 将会确保解决任何不一致的地方.

4. 开始工作

如果你需要这个教程所创建的项目文件, 以及所使用的数据库表格的建表 SQL 脚本, 可以在文末的 资源 部分找到. 不过还是强烈鼓励读者自己照着教程来创建这个项目.

要在 MyEclipse 中开始使用 Hibernate 和 Spring, 首先我们需要有一个数据库连接来供程序来使用. 在这里, 使用的是 MySQL 5, 事先创建了一张示例表格  user table . 我们使用 MySQL Connector/J JDBC 驱动来连接到安装好的 MySQL. 现在首先来创建一个新的连接, 在 MyEclipse 中连接到我们的数据库 (注意: 这个是和我们上文提到的 Hibernate 教程中同一个项目一样的):

图 1. 创建数据库连接

现在已经创建好了连上了数据库的连接, 第二步就是创建一个启用了Hibernate 和 Spring 功能的项目 (Java, Web, Web Service, 等等, 都可以). 可以先创建一个任意类型的基本项目, 例如 Java 或者 Web 项目, 然后通过MyEclipse 菜单下的选项来添加 Hibernate 和 Spring capabilities 给当前项目, 如下所示:

图 2. 创建一个支持 Hibernate 和 Spring 的项目

5. 反向工程

现在已经建好了数据库连接和配置好的项目, 接下来要干的就是使用 MyEclipse 来进行反向工程, 从数据库表格生成 Hibernate (Java) 对象并把这些对象放到当前的项目中去.

另外, 由于当前的项目是个 Hibernate-Spring 项目, MyEclipse 可以让你在反向工程的过程中选择选项来生成 "Spring DAO" , 而不是普通的 DAO. 这个过程会自动生成 Spring DAO 的 bean, 并且自动配置好sessionFactory 属性, 让 Spring 引用到 Hibernate SessionFactory.

在下面的例子中, 我们使用了最简单模式下的反向工程, 全部采用默认设置.  当然, 如果愿意你也可以通过点击 "Next" 按钮切换屏幕时来选择一些选项例如主键生成策略, 对象名字, 类型以及其它设置. 现在让我们开始反向工程:

图 3. 反向工程从 user 表生成 Hibernate (Java) 对象

6. 编写和运行 Hibernate 整合 Spring 代码

现在已经设置好了项目, 可以写点代码测测了. 我们要写两个模块的代码:

  1. 业务逻辑: 在自己写的 main 方法里面放了一些真正需要我们来手写的代码.
  2. 持久层: 这是我们业务逻辑所需要的抽象部分, 这一层用来包含数据库功能. 当我们的业务层使用了持久层的话, 这样可以对业务层屏蔽一些如何持久化的细节. 我们将会使用 Spring 来给持久层注入必要的 DAO 的引用, 这个 DAO 将会进行真正的数据库操作, 不过这里的好处是业务层完全不用知道任何后台实现的细节问题.

首先我们来写持久层, 这一层位于已经自动生成的代码和下一节即将要写的业务逻辑层代码之间.   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);
    }
}
图 4. 实现持久层类

代码简单明了, 不过再总结一下. 这个类的目的是为了获取一个通过 Spring 注入的 UserDAO 实例,   然后再通过这个引用的实例来实现真正的增删改查的功能, 无需关心相关的技术细节. 这样可以让我们快速容易的修改应用里面的持久层代码而不用修改所有的代码. 特别的, 如果我们想更改持久层的实现, 例如更好的管理异常, 事务或者其它任何功能, 我们可以简单的修改这个类就行了, 不需要重构整个应用, 因为所有的方法的声明方式都保持不变.

需要指出的另一个重要之处就是因为这一层的抽象在应用层和持久层代码之间实现了松耦合, 可以很容易的使用 Spring 来注入仅仅用来测试的 UserDAO 的实现类来模拟数据库操作, 而不是真正进行操作(译者注: 例如只是打印一下执行了这个方法来调试) . 这种设计方案有很多优点.

现在我们已经实现了 PersistenceLayer , 接下来让我们看看业务逻辑层 (或者说我们的 main 方法的具体实现):

package com.myeclipse.hibernatespring;

public class BusinessLogic {
    public static void main(String[] args) {
        /* 1. 创建新用户 */
        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. 加载 Spring bean 配置文件并创建 bean 工厂 */
        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource(
                "applicationContext.xml"));

        /* 3. 创建 PersistenceLayer 类的实例 */
        PersistenceLayer persistenceLayer = (PersistenceLayer) beanFactory
                .getBean("persistenceLayer");

        /* 4. 保存新用户到数据库 */
        persistenceLayer.addUser(user);

        /* 5. 确认新用户已经被保存 */
        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. 更新用户 */
        userLoadedFromDB.setFirstName("Johnathan");
        persistenceLayer.updateUser(userLoadedFromDB);

        /* 7. 确认更新成功 */
        User userLoadedFromDBAgain = persistenceLayer
                .findUserById(id);
        System.out.println("User Loaded from DB Again [firstName="
                + userLoadedFromDBAgain.getFirstName() + "]");

        /* 8. 删除用户 */
        persistenceLayer.deleteUser(user);
    }
}
图 5. 实现我们的业务逻辑 (main) 类

来看看这些代码都做了什么:

  1. 创建一个用于插入数据库的新用户.这就是个 POJO, 没有其它知识点. 这里使用的是 MyEclipse 反向工程 user 表时自动生成的 User POJO 类.
  2. 创建一个 bean 工厂. 详细来讲就是读取 Spring bean 配置文件然后提供一个"工厂" 实例, 可以通过它来读取配置文件中指定的 bean 实例. 这是  Spring 的 "入口点".
  3. 创建 PersistenceLayer 的实例这样我们可以进行数据库操作. 注意我们时如何从 bean 工厂里面来获取实例的, 这样里面的 UserDAO 引用才能正确的注入.
  4. 用刚才创建的 PersistenceLayer 实例来保存用户到数据库. 注意为什么 BusinessLogic 类完全不知道 UserDAO 类或者任何的细节因为所有的调用都是通过 PersistenceLayer 进行的?
  5. 现在通过使用 ID 来真正的从底层的数据刷新用户对象, 来检查已经保存的用户对象是不是正确.
  6. 现在我们来修改用户名来检查更新操作是不是可用
  7. 再次 从数据库加载来确保更新操作成功.
  8. 从数据库删除用户对象.

有些人可能会问自己了: " 为什么 PersistenceLayer 获得了一个 UserDAO 来执行持久化操作? 我没有在任何地方看到这些代码." 答案是:我们需要创建一个新的Spring bean (PersistenceLayer), 这个 Bean 将会自动获得注入的 UserDAO 实例, 因此可以正确运行. 操作过程如下所示:

图 6. 创建业务逻辑所使用的 persistenceLayer Spring bean

现在我们的代码已经可以运行了, 总结一下做过的主要操作步骤:

  • 使用MyEclipse 和 Hibernate 反向工程数据库
  • 编写 Spring 管理的抽象层, 位于持久化技术 (Hibernate) 和业务逻辑 (main 方法) 之间.
  • 编写我们的业务逻辑(main 方法) 并使用抽象层来 增删改查 数据库中的用户.
  • 给抽象层创建一个新的 Spring bean, 并让其正确引用到 MyEclipse 自动生成的和数据库打交道的 DAO.

现在我们可以真正的运行 BusinessLogic 类并立即查看程序的输出:

图 7. 运行示例业务逻辑代码

干得好! 跟我们期待的运行结果一致! 可以看到通过很少几行代码, 就实现了在数据库中保存, 更新和删除用户对象. 可以想象通过使用 PersistenceLayer 接下来的工作将是多么的简单.

7. 小结

正如在 Hibernate 和 Spring 入门教程中(参考 资源) 中所示, 在 MyEclipse 中使用这些技术是非常简单和直接的. 我们在这个教程中展示的不仅仅是共同使用这些技术是一个很好的主意, 还展示了 MyEclipse 甚至能帮助你更好的在同一项目中使用这些技术 .

希望本教程能对您有所帮助. 如果你对本教程有任何评论或者建议和问题, 请 联系我们. 我们一直很重视这样的教程中用户的反馈信息.

8. 常见问题FAQ

暂时没有

译者注: 这个教程没有考虑到 事务管理! 可能出现无法保存数据的问题. 请参考一些 Spring 整合 Hibernate 的教程.

9. 资源

下面是一些资源的链接, 我们希望能帮助解答您在阅读本教程中遇到的大部分关于 Hibernate 的问题:

文件

参考

10. 反馈

我们非常希望听到您的声音! 如果你喜欢本教程, 有建议甚至错误修正建议, 请告诉我们. 我们通过 文档论坛 来跟踪所有用户对学习资料的建议.  请告诉我们您正在评论的是哪份 MyEclipse 资料这样我们可以更快的查明出现问题的章节.