38、Java开发综合实践：从JSP到Hibernate再到JavaFX

Java开发综合实践：从JSP到Hibernate再到JavaFX

1. JSP代码修改实践

1.1 实践要求

在这个实践中，需要对 hello.jsp 的代码进行修改，使其能够接受多个变量。同时，要更改 ModelAndView 的代码，让它携带一个值的映射（Map）。进行此实践前，需要安装Java和GlassFish v3。可以从指定网页（www.wrox.com）下载相关代码和资源，这些资源位于下载文件的 Lesson35 文件夹中。

1.2 步骤说明

1. 修改 hello.jsp ：在 $greetings 之外添加一个新的变量。
2. 修改 HelloWorldController ：创建一个包含两个字符串的映射（Map），示例代码如下：

Map helloModel = new HashMap();
helloModel.put("Hello Mary");
helloModel.put("My name is John");

3. 使用 ModelAndView 的双参数构造函数 ：将映射（Map）作为第二个参数传递。
4. 验证结果 ：在浏览器中访问 http://localhost:8080/Lesson35/hello.html ，观察 hello.jsp 是否显示映射（Map）中的值。

2. Hibernate框架介绍

2.1 Hibernate概述

Hibernate是一个开源的对象关系映射（ORM）框架，由Gavin King于2001年发起。Java Persistence API（JPA）借鉴了Hibernate的许多思想，Hibernate 3.5及以上版本支持JPA 2.0规范。Hibernate的官方网站是www.hibernate.org，在该网站可以找到相关文档、代码示例和工具。尽管有人更喜欢使用SQL和JDBC进行数据处理，但如今许多招聘信息都要求掌握Hibernate。如果打算在工作中使用Hibernate，可以考虑使用Eclipse插件（可在www.hibernate.org/subprojects/tools.html获取）。

2.2 ORM框架的核心思想

ORM框架的主要思想是用对象操作替代SQL编写。在Java中，就是在JDBC之上添加一层，使得开发者可以简单地创建一个普通Java对象（POJO），为其字段赋值，然后让它“将自己持久化到数据库中”。Hibernate就是为实现这一目标而设计的。

2.3 Hibernate的优缺点

• 优点 ：支持者认为，摆脱对特定数据库管理系统（DBMS）的SQL语法依赖，使得在不同DBMS之间切换时无需修改负责查询和持久化数据的Java代码。此外，Hibernate还提供了诸如延迟加载和轻松配置内存缓存的功能，可大大减少磁盘访问（磁盘访问比内存访问慢得多）。例如，当用户看到一个客户列表，每个客户可能有多个订单时，使用延迟加载，最初只加载客户列表，只有当用户选择某个客户时，才会向数据存储发送查询以获取相应的订单。
• 缺点 ：在实际项目中，很少需要从一个DBMS切换到另一个。而且，如果项目需要快速执行查询，手动调整SQL并使用特定于DBMS的技巧可能会更有帮助。

2.4 Hibernate数据检索流程

使用Hibernate检索数据的过程与之前的某些操作类似。首先，创建实体与数据库表的映射，然后实例化创建 SessionFactory 和 Session 所需的 Configuration 对象。完成这些步骤后，可以使用Hibernate查询语言（HQL）、条件查询或原生SQL对这些实体执行查询。

3. Hibernate的安装与配置

3.1 下载Hibernate

Hibernate是一个开源框架，托管在SourceForge（http://sourceforge.net/projects/hibernate/files/hibernate3/）上。当前最新版本是3.6，需要下载文件 hibernate-distribution-3.6.0.Final-dist.zip ，该文件包含所需的jar文件、编写良好的参考手册以及可能用于支持内存缓存的库文件夹。

3.2 在Eclipse项目中添加Hibernate Jars

1. 创建新项目 ：在Eclipse中，通过选择 File -> New -> Other -> Java Project 创建一个名为 Lesson36 的新项目。这是一个Java SE项目，不使用Java EE应用服务器。
2. 添加必要的jar文件 ：确保项目包含 hibernate3.jar 、 required 文件夹中的所有jar文件以及 jpa 文件夹中的jar文件。此外，由于许可原因，需要从www.slf4j.org/download.html下载 slf4j-1.6.1.zip ，并将其中的 slf4j-simple-1.6.1.jar 添加到构建路径中。可以在创建项目时，在Java设置窗口的 Libraries 选项卡中添加这些外部jar文件，也可以在项目创建后，通过 Properties -> Java Build Path -> Libraries -> Add External Jars 进行添加。

3.3 测试数据库连接

在本实践中，使用之前创建的数据库（最初在Lesson 22中创建，后在Lesson 33中复用），该数据库包含一个名为 Employee 的表，并且连接已经配置好。此连接使用位于 derbyclient.jar 中的Derby JDBC驱动。需要将该jar文件（位于 glassfish/javadb/lib ）添加到新Eclipse项目的构建路径中。
1. 在Eclipse中，右键单击数据库连接 Lesson22 ，选择 Properties -> JDBC Connection Properties 。
2. 将用户ID保持为 user ，将密码更改为 password123 。
3. 将连接URL复制到文本编辑器中，后续配置Hibernate时会用到这些连接参数。
4. 点击带有星号的小按钮，查看所选DerbyDB驱动的属性，并复制JDBC驱动类的名称。

3.4 配置Hibernate与DBMS

现在需要将与DBMS相关的条目添加到 hibernate.cfg.xml 文件中。不需要从头创建该文件，可以从Hibernate附带的文件中复制一个，例如位于 documentation/quickstart/tutorials/basic/src/test/resources 文件夹中的文件，然后将其复制到Eclipse项目的 src 文件夹中。
1. 修改驱动类和连接URL ：使用上一步中复制的值进行修改。
2. 避免数据库模式的删除和重新创建 ：确保文件中没有设置在启动时删除并重新创建数据库模式。
3. 指定方言 ：由于每个DBMS在实现标准SQL的基础上还添加了一些额外功能，Hibernate包含可配置的方言，用于隐藏这些差异。对于使用的Derby数据库，需要在配置文件中指定方言为 DerbyDialect 。
4. 设置默认模式 ：由于 Employee 表最初是在数据库模式 APP 中创建的，而默认查询会在 USER 模式中查找引用的数据库对象（该模式不存在），因此需要在配置文件中指定默认模式为 APP 。
5. 启用SQL语句输出 ：为了便于调试，希望Hibernate在Eclipse控制台中打印与数据库通信时使用的底层SQL语句。

修改后的 hibernate.cfg.xml 文件示例如下：

<?xml version='1.0' ?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings -->
        <property name="connection.driver_class">
            org.apache.derby.jdbc.ClientDriver
        </property>

        <property name="connection.url">
            jdbc:derby://localhost:1527/Lesson22;create=true
        </property>

        <property name="connection.username">user</property>
        <property name="connection.password">password123</property>
        <!-- Set the default schema to be APP, where table Employee was created -->
        <property name="hibernate.default_schema">APP</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.DerbyDialect</property>
        <!--  Enable Hibernate’s current session context -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">
            org.hibernate.cache.NoCacheProvider
        </property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
    </session-factory>
</hibernate-configuration>

4. 使用Hibernate检索数据

4.1 创建Java实体

需要创建一个Java的 Employee 实体，在这个简单的示例中，它对应于数据库表 Employee 。由于Hibernate支持JPA 2，因此可以直接复用之前的 Employee 实体。以下是 Employee 实体的代码：

package com.practicaljava.lesson36;
import java.io.Serializable;
import javax.persistence.*;
@Entity
public class Employee implements Serializable {
  private static final long serialVersionUID = 1L;
  @Id
  private int empno;
  private String ename;
  @Column(name="JOB_TITLE")
  private String jobTitle;
  public Employee() {}
  public int getEmpno() {
    return this.empno;
  }
  public void setEmpno(int empno) {
    this.empno = empno;
  }
  public String getEname() {
   return this.ename;
  }
  public void setEname(String ename) {
   this.ename = ename;
  }
  public String getJobTitle() {
   return this.jobTitle;
  }
  public void setJobTitle(String jobTitle) {
   this.jobTitle = jobTitle;
  }
}

4.2 编写数据检索代码

以下是用于检索员工数据的 HRManager 程序代码：

import java.util.List;
import org.hibernate.*;
import org.hibernate.cfg.Configuration;
import com.practicaljava.lesson36.Employee;
public class HRManager {
public static void main(String[] args){
  Configuration config = new Configuration().configure();
  config.addAnnotatedClass(Employee.class);

  SessionFactory sf = config.buildSessionFactory();
  Session session = sf.getCurrentSession();

  session.beginTransaction();

  List<Employee> employee = session.createQuery("from Employee").list();

  session.getTransaction().commit();

  for (Employee emp: employee){
       System.out.println("Got " + emp.getEmpno() + ", "
                            + emp.getEname() + ", "+ emp.getJobTitle());
  }
 }   
}

addAnnotatedClass(Employee.class) 方法告诉Hibernate存在一个使用注解配置的名为 Employee 的实体。运行 HRManager 程序后，在Eclipse的控制台视图中会打印出类似以下的内容：

Hibernate: select employee0_.empno as empno0_, employee0_.ename as ename0_,
 employee0_.JOB_TITLE as JOB3_0_ from APP.Employee employee0_
Got 7369, John Smith, Clerk
Got 7499, Joe Allen, Salesman
Got 7521, Mary Lou, Director

5. Hibernate实践：创建数据库对象

5.1 实践要求

本实践将展示如何使用Hibernate从Java实体创建数据库对象。需要声明一个Java实体 Address ，并让Hibernate创建并填充数据库中对应的表。进行此实践前，需要安装Java和GlassFish v3。可以从指定网页（www.wrox.com）下载相关代码和资源，这些资源位于下载文件的 Lesson36 文件夹中。

5.2 步骤说明

1. 创建 Address 实体 ：代码如下：

package com.practicaljava.lesson36;
import javax.persistence.*;
@Entity
public class Address {
   private long addressID;   
   private String streetAddress;
   private String city;
   private String zip;
   @Id
   public long getAddressID() {
      return addressID;
   }
   public void setAddressID(long addressID) {
      this.addressID = addressID;
   }
   public String getStreetAddress() {
      return streetAddress;
   }
   public void setStreetAddress(String streetAddress) {
      this.streetAddress = streetAddress;
   }
   public String getCity() {
      return city;
   }
   public void setCity(String city) {
      this.city = city;
   }
   public String getZip() {
      return zip;
   }
   public void setZip(String zip) {
      this.zip = zip;
   }
} 

2. 创建 AddressCreator 类 ：代码如下：

import java.util.List;
import org.hibernate.*;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import com.practicaljava.lesson36.Address;
public class AddressCreator {
      public static void main(String[] args){
         Configuration config = new Configuration().configure();
         config.addAnnotatedClass(Address.class);

         //Create the Address table
         new SchemaExport(config).create(true,true);

         SessionFactory sf = config.buildSessionFactory();
         Session session = sf.getCurrentSession();

         session.beginTransaction();
         // Instantiate and Populate the entity Address
         Address addr1 = new Address();
         addr1.setStreetAddress("123 Main St.");
         addr1.setAddressID(1);
         addr1.setCity("New York");
         addr1.setZip("10001");

       session.save(addr1);         

       // Save the new entity in the database 
         session.getTransaction().commit();

      }      
}

3. 运行 AddressCreator 程序 ：观察Eclipse控制台的输出，应该会看到Hibernate生成的以下SQL语句：

drop table APP.Address
create table APP.Address (addressID bigint not null, city varchar(255),
 streetAddress varchar(255), 
zip varchar(255), primary key (addressID))
Hibernate: insert into APP.Address (city, streetAddress, zip, addressID) 
values (?, ?, ?, ?)

4. 验证结果 ：在 Data Source Explorer 视图中，重新连接到 Lesson22 数据库，观察 APP 模式下的 Address 表。右键单击 Address 表，选择 Data -> Sample Contents ，会看到一行包含在 AddressCreator 中指定的纽约地址的记录。

6. JavaFX概述

6.1 JavaFX简介

JavaFX旨在作为创建富互联网应用程序（RIAs）的工具，与Adobe Flex和Microsoft Silverlight等RIA工具竞争。其他竞争技术通常使用两种语言来创建RIAs，一种用于UI组件的声明性定义，另一种用于处理逻辑的编码。例如，Adobe Flex使用MXML定义UI组件，使用ActionScript编写处理逻辑；Microsoft Silverlight使用XAML定义UI组件，使用.NET语言（如C#）进行处理。

JavaFX最初设计为使用JavaFX Script定义UI组件，使用Java编写处理逻辑。但最近情况发生了变化，Oracle宣布JavaFX将在2011年进行重大重新设计。JavaFX 1.3包含JavaFX Script语言，而JavaFX 2.0将完全基于Java。目前，JavaFX 2.0没有预发布版本，因此本课程中关于客户端部分的应用内容可能会过时。不过，无论JavaFX 2.0如何变化，部署的应用程序都将在安装了JavaFX运行时的JVM中运行，并且希望Java社区能够继续支持JavaFX Script的开源版本。

6.2 JavaFX在股票报价应用中的应用

在本课程中，将展示一个用JavaFX编写的Web客户端如何通过消息传递订阅服务器端发布的价格报价。该股票服务器示例使用了多种技术，涉及的主要组件和数据流程如下：
1. PriceProvider 单例会话Bean ：负责生成随机价格报价，在GlassFish应用服务器启动时自动实例化。
2. MessageService 无状态会话Bean ：通过资源注入获取JMS管理对象的引用，并将价格报价发布到名为 jms/StockPrices 的JMS主题，该主题映射到Open MQ消息服务器中的物理主题 Prices 。
3. Java客户端 ：订阅主题 Prices ，包含 Messages 、 JMSListener 类和 MessageHandler 接口，但不包含任何表示逻辑。
4. Main.fx 表示客户端 ：使用JavaFX Script编写，包装Java客户端消息类并从中获取价格报价。当新报价到来时，旧报价会通过特殊动画效果向上推离屏幕。
5. 简单HTTP客户端 ：允许用户输入任何文本，文本通过 SendMessage servlet路由到 MessageService EJB，后续数据流程与上述步骤2 - 4相同。

6.3 代码分析

6.3.1 PriceProvider 单例Bean

@Singleton
@Startup
public class PriceProvider {
    @EJB
    private MessageService messageService;
    // In this example the method getQuotes() simply generates
    // prices, but in the real world it will get the quote
    // from some external data feed

    @Schedule(second = "*/5", minute="*", hour="*")
    public void getPriceQuote() {

        String price = Double.toString(generator.nextDouble() * 100.0);
        String symbol = symbols[generator.nextInt(symbols.length)];
        messageService.sendMessage(symbol + " " + price);
    }
    private static final Random generator = new Random();
    private static final String[] symbols = 
                    {"AAPL", "MSFT", "YHOO", "AMZN", "MOT"};
}

该单例Bean作为股票报价数据源的模拟器。 @Startup 注解确保Java EE应用服务器在启动时自动实例化该Bean， @Schedule 注解是一个基于日历的定时器，每五秒调用一次 getPriceQuote() 方法。

6.3.2 MessageService 无状态会话Bean

@Stateless
public class MessageService {
    @Resource(mappedName = "jms/StockPrices")
    private Topic topic;
    @Resource(mappedName = "TopicConnectionFactory")
    private TopicConnectionFactory topicConnectionFactory;
    public void sendMessage(String text) {
        try {
            Connection connection = topicConnectionFactory.createConnection();
            Session session = connection.createSession(true, 0);
            MessageProducer producer = session.createProducer(topic);
            TextMessage textMessage = session.createTextMessage(text);
            producer.send(textMessage);
            connection.close();
        }
        catch (JMSException e) {
            throw new RuntimeException(e);
        }
    }
}

该无状态会话Bean将传入的文本消息发布到绑定在GlassFish JNDI树中的 jms/StockPrices JMS主题，该主题映射到Open MQ消息服务器中的物理主题 Prices 。

6.3.3 Java客户端订阅者

public class Messages {
    public static void startListening(MessageHandler messageHandler) 
                                                     throws Exception {
       JMSListener jmsListener = new JMSListener(messageHandler);
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setProperty(ConnectionConfiguration.imqAddressList,
                                                      "mq://localhost:7676");
        connection = connectionFactory.createQueueConnection("admin","admin");
        Session session = connection.createSession(false, 
                                                  Session.AUTO_ACKNOWLEDGE);
        Topic topic = session.createTopic("Prices");
        // 后续代码省略
    }
}

Java客户端直接连接到Open MQ，订阅主题 Prices 。由于GlassFish v3没有提供轻量级的方式将JNDI相关类添加到applet中，因此采用了直接连接的方式。

6.4 总结

通过以上内容，我们完成了从JSP代码修改到Hibernate框架的使用，再到JavaFX在股票报价应用中的实践。每个部分都有其独特的功能和应用场景，掌握这些技术可以帮助开发者构建更加复杂和强大的Java应用程序。在实际开发中，可以根据具体需求选择合适的技术和工具，灵活运用这些知识来解决问题。

以下是一个简单的mermaid流程图，展示了JavaFX股票报价应用的数据流程：

graph LR
    A[PriceProvider] -->|生成报价| B[MessageService]
    B -->|发布消息| C[JMS Topic: jms/StockPrices]
    C -->|映射| D[Physical Topic: Prices]
    D -->|订阅| E[Java客户端]
    E -->|提供报价| F[Main.fx客户端]
    G[HTTP客户端] -->|输入文本| H[SendMessage Servlet]
    H -->|路由消息| B

这个流程图清晰地展示了各个组件之间的关系和数据流向，帮助我们更好地理解整个应用的工作原理。

7. JavaFX应用代码详细分析

7.1 PriceProvider 单例Bean深入解析

PriceProvider 单例Bean是整个股票报价系统的报价生成源头。以下是对其代码的详细分析：

@Singleton
@Startup
public class PriceProvider {
    @EJB
    private MessageService messageService;
    // In this example the method getQuotes() simply generates
    // prices, but in the real world it will get the quote
    // from some external data feed

    @Schedule(second = "*/5", minute="*", hour="*")
    public void getPriceQuote() {

        String price = Double.toString(generator.nextDouble() * 100.0);
        String symbol = symbols[generator.nextInt(symbols.length)];
        messageService.sendMessage(symbol + " " + price);
    }
    private static final Random generator = new Random();
    private static final String[] symbols = 
                    {"AAPL", "MSFT", "YHOO", "AMZN", "MOT"};
}

• 注解说明 ：
  • @Singleton ：表明该类是单例的，在整个应用程序中只会有一个实例。
  • @Startup ：确保在Java EE应用服务器启动时，该Bean会自动实例化。
  • @Schedule ：这是一个基于日历的定时器注解， second = "*/5", minute="*", hour="*" 表示每5秒调用一次 getPriceQuote() 方法。
• 方法逻辑 ：
  • getPriceQuote() 方法中，首先使用 Random 类生成一个随机价格，范围是0 - 100，然后将其转换为字符串。
  • 从预定义的股票符号数组 symbols 中随机选择一个股票符号。
  • 最后调用 MessageService 的 sendMessage() 方法，将股票符号和价格组合成一个字符串发送出去。

7.2 MessageService 无状态会话Bean分析

MessageService 无状态会话Bean负责将价格报价发布到JMS主题。代码如下：

@Stateless
public class MessageService {
    @Resource(mappedName = "jms/StockPrices")
    private Topic topic;
    @Resource(mappedName = "TopicConnectionFactory")
    private TopicConnectionFactory topicConnectionFactory;
    public void sendMessage(String text) {
        try {
            Connection connection = topicConnectionFactory.createConnection();
            Session session = connection.createSession(true, 0);
            MessageProducer producer = session.createProducer(topic);
            TextMessage textMessage = session.createTextMessage(text);
            producer.send(textMessage);
            connection.close();
        }
        catch (JMSException e) {
            throw new RuntimeException(e);
        }
    }
}

• 注解说明 ：
  • @Stateless ：表示该Bean是无状态的，不保存任何客户端的状态信息。
  • @Resource ：用于注入资源，这里分别注入了JMS主题 jms/StockPrices 和主题连接工厂 TopicConnectionFactory 。
• 方法逻辑 ：
  • sendMessage() 方法中，首先通过主题连接工厂创建一个连接。
  • 然后创建一个会话， true 表示使用事务， 0 表示事务模式。
  • 创建一个消息生产者，用于向主题发送消息。
  • 创建一个文本消息，并将传入的文本内容设置到消息中。
  • 最后将消息发送到主题，并关闭连接。如果发生 JMSException ，则抛出运行时异常。

7.3 Java客户端订阅者代码详解

Java客户端订阅者负责订阅主题并接收价格报价。以下是代码：

public class Messages {
    public static void startListening(MessageHandler messageHandler) 
                                                     throws Exception {
       JMSListener jmsListener = new JMSListener(messageHandler);
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setProperty(ConnectionConfiguration.imqAddressList,
                                                      "mq://localhost:7676");
        connection = connectionFactory.createQueueConnection("admin","admin");
        Session session = connection.createSession(false, 
                                                  Session.AUTO_ACKNOWLEDGE);
        Topic topic = session.createTopic("Prices");
        // 后续代码省略
    }
}

• 方法逻辑 ：
  • startListening() 方法接收一个 MessageHandler 对象，用于处理接收到的消息。
  • 创建一个 JMSListener 对象，并将 MessageHandler 传递给它。
  • 创建一个连接工厂，并设置连接地址为 mq://localhost:7676 。
  • 使用连接工厂创建一个队列连接，使用 admin 作为用户名和密码。
  • 创建一个会话， false 表示不使用事务， Session.AUTO_ACKNOWLEDGE 表示自动确认消息。
  • 创建一个主题对象，主题名称为 Prices 。

7.4 各组件关系总结

组件名称	功能	与其他组件的关系
PriceProvider	生成股票报价	调用 MessageService 的 sendMessage() 方法发送报价
MessageService	发布消息到JMS主题	接收 PriceProvider 的消息，将其发布到 jms/StockPrices 主题
JMS Topic: jms/StockPrices	消息中转	接收 MessageService 发布的消息，映射到物理主题 Prices
Physical Topic: Prices	实际消息存储	被Java客户端订阅，提供消息给Java客户端
Java客户端	订阅消息	订阅 Physical Topic: Prices ，接收消息并传递给 Main.fx 客户端
Main.fx 客户端	显示报价	从Java客户端获取报价并显示
HTTP客户端	输入文本消息	通过 SendMessage Servlet 将消息路由到 MessageService
SendMessage Servlet	消息路由	接收HTTP客户端的消息，将其路由到 MessageService

8. 不同技术在实际项目中的应用建议

8.1 JSP的应用场景

• 简单页面展示 ：当需要快速开发一些简单的Web页面，并且页面逻辑相对较少时，JSP是一个不错的选择。例如，企业内部的一些简单信息展示页面，如公告栏、员工信息列表等。
• 与Servlet结合 ：可以与Servlet结合使用，Servlet负责处理业务逻辑，JSP负责页面展示。这样可以将业务逻辑和页面展示分离，提高代码的可维护性。

8.2 Hibernate的应用场景

• 数据库操作简化 ：当项目中涉及大量的数据库操作，并且希望简化数据库操作代码时，Hibernate可以发挥很大的作用。它可以将数据库表映射为Java对象，通过操作对象来实现数据库的增删改查操作。
• 多数据库支持 ：如果项目需要支持多种数据库，Hibernate的可配置方言可以隐藏不同数据库之间的差异，使得代码在不同数据库之间的迁移更加方便。

8.3 JavaFX的应用场景

• 富互联网应用开发 ：当需要开发具有丰富用户界面和交互效果的互联网应用时，JavaFX是一个很好的选择。它可以创建出类似于桌面应用的用户体验，并且可以在浏览器中运行。
• 多媒体应用 ：JavaFX对多媒体的支持非常好，可以用于开发视频播放器、音频播放器等多媒体应用。

不同技术应用场景对比表格

技术名称	应用场景	优点	缺点
JSP	简单页面展示、与Servlet结合	开发速度快、与Servlet配合良好	页面逻辑和业务逻辑容易混淆
Hibernate	数据库操作简化、多数据库支持	简化数据库操作、支持多种数据库	学习成本较高、性能可能有一定损失
JavaFX	富互联网应用开发、多媒体应用	界面丰富、多媒体支持好	兼容性可能存在问题、开发工具相对较少

9. 总结与展望

9.1 总结

通过本次实践，我们深入学习了JSP、Hibernate和JavaFX三种技术。JSP可以用于快速开发简单的Web页面，Hibernate可以简化数据库操作，JavaFX可以创建富互联网应用。每种技术都有其独特的优势和适用场景，在实际开发中，我们可以根据项目的需求和特点选择合适的技术。

9.2 展望

随着技术的不断发展，这些技术也在不断更新和完善。未来，JSP可能会与更多的前端框架结合，提供更好的用户体验；Hibernate可能会在性能优化和功能扩展方面有更多的改进；JavaFX可能会在兼容性和开发工具方面得到进一步提升。我们需要不断学习和关注这些技术的发展，以便在实际项目中更好地应用它们。

以下是一个mermaid流程图，展示了不同技术在项目中的应用关系：

graph LR
    A[JSP] -->|页面展示| B[Web应用]
    C[Hibernate] -->|数据库操作| B
    D[JavaFX] -->|富界面展示| B
    B -->|部署| E[服务器]
    F[用户] -->|访问| E

这个流程图展示了JSP、Hibernate和JavaFX在Web应用中的作用，以及它们与服务器和用户之间的关系。通过合理运用这些技术，我们可以开发出功能强大、用户体验良好的Java应用程序。