轻松掌握SSH整合：Java Web开发实战范例

本文还有配套的精品资源，点击获取

简介：SSH整合是Java开发中构建Web应用的经典框架组合，涵盖了Spring、Struts2和Hibernate三个组件。Spring负责应用上下文和依赖注入，Struts2处理用户请求及展示结果，Hibernate简化数据库操作。本实践教程将详细介绍如何整合这三个框架，并通过步骤及代码示例来展示如何实现一个完整的SSH集成开发流程。

1. Spring框架核心概念与应用上下文管理

1.1 Spring框架简介

Spring是一个开源的Java平台，它最初由Rod Johnson创建，并且在企业开发领域得到了广泛的应用。Spring框架旨在解决企业应用开发的复杂性，通过提供一系列的模块，能够简化企业级应用的开发流程。Spring的核心特性包括依赖注入（DI）和面向切面编程（AOP），这两个特性极大地改善了Java应用的开发和测试。

1.2 应用上下文的创建

在Spring框架中，应用上下文（ApplicationContext）是Spring IoC容器的核心，它负责加载配置文件并创建bean的实例，同时管理这些bean的生命周期。通过应用上下文，可以实现bean的声明式管理，包括自动装配、事务管理等高级功能。创建一个应用上下文可以通过读取XML配置文件、Java配置类或注解的方式来完成。

示例代码（使用XML配置）:

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
MyService myService = (MyService) context.getBean("myService");

以上代码展示了如何通过Spring的 ClassPathXmlApplicationContext 类加载一个XML配置文件，并从中获取名为 myService 的bean实例。

1.3 Spring配置详解

Spring配置文件通常定义了应用中所有bean的创建和装配细节。在Spring 3.0之后，推荐使用Java配置类（使用 @Configuration 注解）来代替传统的XML配置。无论是XML还是Java配置，都需要明确指定bean的作用域（如单例）、生命周期、依赖关系等。

示例配置（Java配置）:

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }

    // 可以定义更多的bean...
}

这段代码定义了一个配置类 AppConfig ，其中使用了 @Bean 注解来声明一个bean，这个bean将由Spring容器管理。

Spring框架作为一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架，它的核心概念和应用上下文的管理是开发者必须掌握的基础知识，无论是在快速开发还是在维护复杂应用中都能起到关键作用。

2. Struts2框架MVC模式实现及拦截器应用

2.1 Struts2框架MVC模式详解

2.1.1 MVC模式基础与Struts2的实现

MVC（Model-View-Controller）模式是一种设计模式，用于将应用程序分为三个核心组件，以实现关注点分离和更好的代码维护。Model代表应用程序的数据结构，View负责显示数据，而Controller处理用户输入。

Struts2框架作为MVC模式的一种实现，它通过扩展Action接口来定义Controller组件，将Model的职责交由Java Beans来承担，而View则是由JSP和Velocity模板等页面技术构成。Struts2的核心是一个过滤器 StrutsPrepareAndExecuteFilter ，它负责拦截进入应用的请求，并根据配置文件中的信息，将请求分发给相应的Action来处理。

2.1.2 Struts2中Action的配置与执行流程

在Struts2中，Action的配置通常位于 struts.xml 文件中，它定义了请求的路径（namespace和action name）、处理请求的Action类以及返回结果视图的名称。下面是一个简单的Action配置示例：

<action name="loginAction" class="com.example.LoginAction">
    <result name="success">/login_success.jsp</result>
    <result name="input">/login.jsp</result>
</action>

执行流程如下：

1. 用户向服务器提交请求。
2. 请求被 StrutsPrepareAndExecuteFilter 拦截。
3. 根据请求的URL，Struts2查找对应的Action配置。
4. 创建Action实例并调用其方法，处理请求。
5. 根据返回的结果码，Struts2选择一个结果视图返回给用户。

2.2 Struts2拦截器的作用与实现

2.2.1 拦截器的基本概念和作用

拦截器是Struts2框架中的一个重要的组件，它提供了一种在请求执行Action方法之前或之后拦截请求的机制。拦截器可以用来实现日志记录、权限检查、数据验证等功能。

Struts2的拦截器功能是基于Java的动态拦截器（Interceptor）机制实现的。拦截器通过实现 Interceptor 接口或继承 AbstractInterceptor 类来定义自己的拦截逻辑。

2.2.2 自定义拦截器的步骤与示例

自定义拦截器的实现步骤如下：

1. 创建拦截器类，实现 Interceptor 接口或继承 AbstractInterceptor 。
2. 在 intercept 方法中定义拦截逻辑。
3. 在 struts.xml 中注册拦截器。
4. 配置拦截器应用到具体的Action上。

下面是一个简单的自定义拦截器示例：

public class MyInterceptor extends AbstractInterceptor {
    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("Interceptor is running before the Action executes.");
        String result = invocation.invoke(); // 执行Action方法
        System.out.println("Interceptor is running after the Action executes.");
        return result;
    }
}

在 struts.xml 中注册并应用拦截器：

<interceptors>
    <interceptor name="myInterceptor" class="com.example.MyInterceptor"/>
    <interceptor-stack name="myStack">
        <interceptor-ref name="myInterceptor"/>
        <interceptor-ref name="defaultStack"/>
    </interceptor-stack>
</interceptors>
<action name="someAction" class="com.example.SomeAction">
    <interceptor-ref name="myStack"/>
    <result name="success">/some_success.jsp</result>
</action>

在这个配置中，定义了一个名为 myInterceptor 的拦截器和一个拦截器栈 myStack ，并将其应用到名为 someAction 的Action上。当请求 someAction 时， myInterceptor 将先于Action的执行运行其 intercept 方法。

3. Hibernate ORM映射与数据库操作优化

3.1 Hibernate ORM基础与配置

3.1.1 ORM概念及其在Hibernate中的应用

对象关系映射（Object-Relational Mapping，简称ORM）是现代软件开发中一种流行的编程技术，它将程序中的对象与数据库中的表建立映射关系，使开发者能够用面向对象的方式来操作数据库。这种技术极大地简化了传统数据库编程中所涉及的繁琐SQL语句的编写工作，同时也提高了代码的可维护性和可扩展性。

在Hibernate中，ORM的实现使得Java对象能够自动持久化到数据库中，通过Hibernate的API，开发者可以像操作Java对象一样来执行数据库操作。Hibernate底层通过反射机制动态生成代理对象，并且通过拦截器模式将对象的属性变化与数据库的操作进行映射。它提供了丰富的API来支持CRUD（创建、读取、更新、删除）操作，还能够处理对象之间的关系映射，如一对多、多对多等。

使用Hibernate，开发人员只需关注业务逻辑层的编码，无需直接编写SQL语句。Hibernate框架会负责把业务对象的状态变化转化为相应的数据库操作，并自动处理好底层的数据持久化。

3.1.2 Hibernate的配置文件与映射关系

Hibernate的配置主要分为两个部分，一个是Hibernate自身的配置文件，另一个是实体类与数据库表之间的映射关系配置。

Hibernate配置文件（通常是 hibernate.cfg.xml ）包含了Hibernate操作数据库时所需的所有配置信息，如数据库的连接参数、方言、缓存配置等。通过这个文件，Hibernate可以获取数据库连接信息，了解如何与数据库交互。此外，Hibernate还提供了Java配置的方式来设置这些参数，通常利用 Configuration 类和 Properties 类来完成。

实体类与数据库表之间的映射关系在Hibernate中是通过映射文件（通常是 .hbm.xml 文件）来实现的。在这些映射文件中，定义了实体类与数据库表的对应关系，包括表的名称、字段的名称、数据类型、主键设置以及类与类之间的关联关系等。虽然Hibernate支持注解的方式来进行映射配置，但映射文件的使用仍然很广泛，尤其是在维护旧项目或者某些复杂的映射场景中。

开发者需要在映射文件中详细描述每个实体类的映射信息，例如：

<hibernate-mapping>
    <class name="com.example.domain.User" table="users">
        <id name="id" column="user_id" type="integer">
            <generator class="native"/>
        </id>
        <property name="name" column="user_name" type="string"/>
        <property name="email" column="user_email" type="string"/>
        <!-- 其他映射配置 -->
    </class>
</hibernate-mapping>

此映射文件定义了一个 User 类与 users 表的映射关系。通过配置文件的方式，Hibernate能够将 User 类的实例持久化到 users 表中，并能通过配置描述来识别实体的属性与表字段的对应关系。

Hibernate提供了灵活的配置选项，允许开发者根据实际需要选择最适合项目的方式进行配置。此外，Hibernate社区还提供了许多扩展和第三方插件，来进一步增强ORM框架的功能。

3.2 Hibernate数据库操作优化策略

3.2.1 会话管理与数据持久化

在Hibernate中，会话（Session）是进行数据库操作的接口，它是应用程序与数据库之间的桥梁。每个 Session 对象维护了一个与数据库交互的连接，并负责持久化实体对象到数据库中。

会话的生命周期通常很短，从打开到关闭，开发者应该在完成数据库操作后尽快关闭会话。会话管理不当可能导致资源泄漏和性能问题，因此Hibernate提供了一些机制来帮助开发者管理会话的生命周期。

在Hibernate中，数据持久化通常通过以下步骤完成：

1. 打开一个会话（ Session 对象）。
2. 开启事务（使用 Transaction 对象）。
3. 进行CRUD操作，将操作反映到数据库中。
4. 提交事务，确保所有更改被持久化。
5. 关闭会话。

一个简单的会话管理与数据持久化示例代码如下：

// 步骤1: 打开一个Session
Session session = sessionFactory.openSession();
// 步骤2: 开启事务
Transaction transaction = session.beginTransaction();
try {
    // 步骤3: CRUD操作
    User user = new User("Alice", "***");
    session.save(user);
    // 步骤4: 提交事务
    ***mit();
} catch (Exception e) {
    // 出错时回滚事务
    transaction.rollback();
    throw e;
} finally {
    // 步骤5: 关闭Session
    session.close();
}

为了提高性能和效率，Hibernate允许开发者使用Session的缓存（一级缓存），它可以减少对数据库的访问次数。此外，通过使用批量操作（如 saveOrUpdate() ）和延迟加载（LAZY加载）等机制，可以进一步优化数据持久化的过程。

3.2.2 查询优化与性能分析

在使用Hibernate进行数据库操作时，查询优化是提高系统性能的关键环节。Hibernate提供了多种查询方式，包括HQL（Hibernate Query Language）、Criteria API和原生SQL查询等。优化查询主要包括减少查询次数、限制返回记录数量、避免N+1查询问题以及合理利用二级缓存等策略。

Hibernate的二级缓存（可选的二级缓存组件如EHCache、 OSCache）能够跨会话持久化数据，减少对数据库的访问频率。在配置了二级缓存的情况下，只有当缓存中不存在所需数据时，Hibernate才会访问数据库。

使用HQL和Criteria API时，开发者可以通过选择合适的查询方法和构建优化的查询语句来提高性能。例如：

// 使用HQL进行查询
String hql = "FROM User WHERE name = :name";
Query query = session.createQuery(hql);
query.setParameter("name", "Alice");
List<User> users = query.list();

为了分析Hibernate查询的性能，开发者可以使用日志记录和性能分析工具。Hibernate的日志记录功能可以帮助开发者查看生成的SQL语句和执行时间，从而确定潜在的性能瓶颈。此外，许多第三方监控工具也可以帮助分析Hibernate应用的性能，比如VisualVM、JProfiler等。

性能分析通常包括对慢查询的识别、缓存命中率的检查以及频繁执行的操作的监控。通过分析这些数据，开发者可以对应用程序进行调优，从而达到提升性能的目的。

4. SSH整合环境配置方法

4.1 SSH整合架构概述

4.1.1 SSH框架的定义与整合意义

SSH，即Spring + Struts2 + Hibernate的组合，是Java EE开发中广泛使用的轻量级框架组合。Spring框架作为企业应用开发的粘合剂，提供了声明式事务管理、依赖注入以及服务抽象等功能。Struts2作为MVC模式的实现框架，负责控制Web层的请求转发及数据展示。Hibernate则作为ORM框架，实现了Java对象与关系数据库的映射，简化了数据持久化操作。

将这三个框架进行整合，不仅能够利用各自的优点，还能实现应用架构的分层设计，从而降低组件间的耦合度，提高应用的可维护性和扩展性。整合后的SSH框架能够帮助开发者更有效地管理应用的各个层次，提升开发效率。

4.1.2 整合开发环境的搭建步骤

要搭建一个SSH整合开发环境，首先需要确保你的开发机上安装了以下软件：

• Java开发环境（JDK）
• Apache Maven或Gradle（用于依赖管理和构建）
• Tomcat或其他支持的Servlet容器（用于部署Web应用）

接下来是搭建步骤：

1. 项目结构创建 ： 使用Maven创建一个Web项目，添加Spring、Struts2和Hibernate相关的依赖配置文件（pom.xml或build.gradle）。

2. Spring配置 ： 创建Spring配置文件，配置数据源、Session工厂、事务管理器等关键组件。

3. Struts2配置 ： 在 struts.xml 文件中配置Action映射关系，并通过Spring的依赖注入来管理Struts2 Action。

4. Hibernate配置 ： 创建 hibernate.cfg.xml 配置文件，并配置实体类与数据库表的映射关系。

5. 整合应用上下文 ： 在Spring配置文件中整合Struts2和Hibernate的配置，使用Spring的 ContextLoaderListener 和 ContextLoaderPlugIn 来管理整个应用的生命周期。

6. 测试整合 ： 创建测试用例，验证配置的整合是否正确，所有的组件是否能够协同工作。

下面是一个示例化的 pom.xml 片段，用于展示整合开发环境中的依赖配置：

<!-- Spring -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.10</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.3.10</version>
</dependency>
<!-- Struts2 -->
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-core</artifactId>
    <version>2.5.23</version>
</dependency>
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-spring-plugin</artifactId>
    <version>2.5.23</version>
</dependency>
<!-- Hibernate -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.4.30.Final</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>5.4.30.Final</version>
</dependency>
<!-- 其他依赖省略... -->
</dependencies>

整合SSH框架的核心在于将各框架的配置与组件进行合理规划，确保它们在应用中能够无缝协作。接下来的章节将深入探讨如何在整合环境中实现依赖注入与Bean的管理。

5. 依赖注入与Bean管理

5.1 Spring依赖注入原理与实践

依赖注入（Dependency Injection，简称DI）是Spring框架的核心特性之一，它是一种控制反转（Inversion of Control，IoC）的表现形式。依赖注入通过容器管理对象之间的依赖关系，从而实现解耦，提高系统组件的重用性和系统的可测试性。

5.1.1 依赖注入的基本概念与优势

依赖注入意味着将对象间的直接依赖关系交由第三方来管理，通常是通过注入器容器（如Spring）来完成。这种方式减轻了对象间的耦合度，允许程序组件更加专注于业务逻辑的实现，而不是如何寻找依赖关系。

• 解耦 ：依赖注入降低了代码间的耦合性，使得每个组件都能够独立地进行单元测试。
• 灵活性 ：通过依赖注入，开发者能够灵活地更改配置，而无需修改组件的实现代码。
• 配置管理 ：依赖关系的管理可以通过外部配置文件或者注解来完成，提高了系统的可维护性。

5.1.2 常见的依赖注入方式与示例

Spring提供了几种不同的依赖注入方式，包括构造器注入（Constructor Injection）、设值注入（Setter Injection）和字段注入（Field Injection）。

构造器注入 通过类的构造函数来传递依赖项，它保证了依赖项被实例化时，注入的对象不会是null。

public class SomeService {
    private SomeDependency dependency;

    @Autowired
    public SomeService(SomeDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

设值注入 通过类的setter方法来注入依赖项，这种方式允许对象在注入之前就已经创建，甚至可以允许依赖项为null。

public class SomeService {
    private SomeDependency dependency;

    @Autowired
    public void setDependency(SomeDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

字段注入 通过使用注解直接在类的字段上注入依赖项，是最为简洁的方法，但这也导致了类的可测试性降低。

public class SomeService {
    @Autowired
    private SomeDependency dependency;
    // ...
}

每种依赖注入方式都有其优缺点，通常推荐使用构造器注入或设值注入，这两种方式有助于创建不可变的对象，并且更易于单元测试。

5.2 Spring Bean的作用域与生命周期

Spring Bean定义了Spring容器中对象的作用范围以及这些对象的生命周期各个阶段。

5.2.1 Bean作用域的定义与区别

在Spring中，Bean的作用域决定了Bean实例的生命周期和共享状态。

• singleton ：默认作用域，Spring IoC容器中只会创建Bean的一个实例。
• prototype ：每次请求Bean时都会创建一个新的实例。
• request ：每次HTTP请求都会创建一个新的Bean实例，仅适用于Web应用。
• session ：对于每个HTTP Session，容器都会创建一个新的实例。
• application ：在一个ServletContext的生命周期内，容器会创建一个新的实例。
• websocket ：为每个WebSocket会话创建一个新的实例。

5.2.2 Bean生命周期各阶段的作用与管理

Bean的生命周期包含多个阶段，开发者可以通过自定义配置来管理Bean的初始化和销毁过程。

• 实例化Bean
• 设置对象属性
• 如果Bean实现了BeanNameAware、BeanFactoryAware等接口，则调用相应的方法
• 调用BeanPostProcessor的前置方法
• 如果Bean实现了InitializingBean接口，则调用afterPropertiesSet方法
• 调用Bean自身的初始化方法
• 调用BeanPostProcessor的后置方法
• 当容器关闭时，调用DisposableBean的destroy方法
• 调用Bean自身的销毁方法

public class SomeBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化代码
    }

    @Override
    public void destroy() throws Exception {
        // 销毁代码
    }
}

开发者也可以使用 @PostConstruct 和 @PreDestroy 注解来标注初始化和销毁方法。

通过以上两个小节的内容，我们对Spring中的依赖注入和Bean管理有了更深入的理解。下一节我们将继续深入了解依赖注入的更多实践技巧，以及Bean在实际应用中如何管理其生命周期。

6. Struts2 Action类定义与视图映射

6.1 Action类的设计原则与开发步骤

6.1.1 Action类的基本结构与职责

在Struts2框架中，Action类扮演着处理HTTP请求和与业务逻辑进行交互的角色。一个典型的Action类应该遵循MVC模式中的控制器职责，主要负责接收用户的输入，并调用业务逻辑层完成处理，最后返回结果。

在定义一个Struts2 Action类时，它必须实现 Action 接口或继承 ActionSupport 类。 ActionSupport 类提供了许多便利的方法和属性，例如 getText() 和 addActionError() ，使得开发过程更加简便。

6.1.2 Action类与后端逻辑的交互模式

Action类通常不包含复杂的业务逻辑，它仅作为一个调度中心，负责调用业务逻辑层（通常是一个服务层）的方法，并将请求转发到相应的视图组件。在与后端逻辑的交互中，Action类可以依赖注入业务逻辑层的组件，以实现松耦合。

public class MyAction extends ActionSupport {
    private MyService myService;

    public String execute() {
        myService.doSomething();
        return SUCCESS;
    }

    public void setMyService(MyService myService) {
        this.myService = myService;
    }
}

在上面的代码中， MyAction 类依赖于 MyService 类来完成业务逻辑。 execute 方法是Action类的主要方法，当Struts2框架接收到对应的请求后，会调用这个方法。如果业务逻辑执行成功，返回 SUCCESS ，否则返回相应的错误码。

6.2 视图组件映射与动态返回结果处理

6.2.1 视图的配置与映射机制

Struts2框架提供了灵活的方式来配置和映射视图组件。在 struts.xml 文件中定义Action时，可以指定其结果与视图页面的对应关系。当Action的 execute 方法执行完毕后，框架根据返回的结果码来决定跳转到哪个视图页面。

<action name="myAction" class="com.example.MyAction">
    <result name="success">/success.jsp</result>
    <result name="error">/error.jsp</result>
</action>

在上述配置中，当 MyAction 的 execute 方法返回 success 时，用户将会被重定向到 /success.jsp 页面；若返回 error 则会跳转到 /error.jsp 页面。

6.2.2 动态返回结果的实现与实践

Struts2支持动态返回结果，即在 execute 方法中根据实际的业务处理结果动态返回结果码。此外，可以使用 Result 类的子类来实现更复杂的结果返回逻辑，如重定向到不同的Action，或者在结果中插入数据到值栈。

public class MyAction extends ActionSupport {
    @Override
    public String execute() {
        // Some logic here...
        if (someCondition) {
            return SUCCESS;
        } else if (anotherCondition) {
            return ERROR;
        } else {
            return "someOtherResult";
        }
    }
}

在上述代码示例中，根据业务逻辑执行的条件， execute 方法动态地返回了不同的结果码。Struts2框架将根据这些结果码跳转到相应的视图组件或者执行其他定义在配置文件中的逻辑。这种方式为视图的返回提供了极大的灵活性，适用于各种复杂的业务场景。

7. Hibernate实体类配置与会话工厂使用

Hibernate是一个开源的对象关系映射（ORM）框架，用于简化Java应用程序与数据库之间的交互。本章将介绍实体类的映射策略、优化技巧以及会话工厂的使用和事务控制。

7.1 实体类的映射策略与优化技巧

7.1.1 实体类映射的类型与配置方法

Hibernate支持多种映射类型，包括类映射（Class Mapping）、集合映射（Collection Mapping）和组件映射（Component Mapping）。每种类型的映射都适用于不同的场景，并且需要在映射文件中或使用注解来配置。

• 类映射 ：通常将一个Java类映射到数据库中的一个表。例如，一个 User 类可以映射到 users 表。
• 集合映射 ：适用于映射一对多或多对多的关系，如一个 User 可以拥有多个 Order ，这需要在 User 类中映射一个 Order 集合。
• 组件映射 ：当一个Java对象的属性需要映射到数据库表的多个列时，可以使用组件映射。例如， Address 类包含 street 、 city 等属性，可以映射为 user 表中的多个列。

在XML映射文件中配置示例：

<class name="User" table="users">
    <id name="id" column="id" type="int">
        <generator class="native"/>
    </id>
    <property name="name" column="name" type="string"/>
    <set name="orders" inverse="true">
        <key column="user_id"/>
        <one-to-many class="Order"/>
    </set>
</class>

或者使用注解的方式：

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;

    @Column(name = "name")
    private String name;

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
    private Set<Order> orders = new HashSet<>();
}

7.1.2 映射优化与性能提升手段

在使用Hibernate时，映射优化是提升应用程序性能的关键。一些常见的优化手段包括：

• 二级缓存的使用 ：二级缓存可以减少数据库访问次数，提高读取性能。
• 懒加载（Lazy Loading） ：通过延迟加载关联数据，可以减少初次加载时的数据量，加快对象加载速度。
• 批量抓取（Batch Fetching） ：对于需要加载大量关联对象的情况，可以一次性加载，减少查询次数。
• SQL优化 ：分析生成的SQL语句，优化查询条件和查询结构。

7.2 Hibernate会话管理与事务控制

7.2.1 会话工厂的初始化与管理

Hibernate通过会话（Session）来访问数据库，会话工厂（SessionFactory）负责会话的创建。一个 SessionFactory 实例通常对应一个数据库，创建 SessionFactory 是一个相对昂贵的过程，所以通常应用中只需要一个 SessionFactory 实例。

初始化 SessionFactory 的代码示例：

Configuration configuration = new Configuration().configure("hibernate.cfg.xml");
StandardServiceRegistryBuilder serviceRegistryBuilder = new StandardServiceRegistryBuilder();
serviceRegistryBuilder.applySettings(configuration.getProperties());
ServiceRegistry serviceRegistry = serviceRegistryBuilder.build();
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);

7.2.2 事务的声明式与编程式控制方式

在Hibernate中，事务控制可以通过声明式和编程式两种方式实现。

• 声明式事务控制 ：通过配置文件来管理事务，这种方式简化了代码，降低了耦合度。
• 编程式事务控制 ：通过直接编写代码来管理事务，提供了更高的灵活性和控制力。

编程式事务控制示例：

Session session = sessionFactory.openSession();
Transaction tx = null;

try {
    tx = session.beginTransaction();
    // 数据库操作代码
    ***mit();
} catch (Exception e) {
    if (tx != null) {
        tx.rollback();
    }
    e.printStackTrace();
} finally {
    session.close();
}

通过上述章节内容的深入分析，我们了解到了Hibernate实体类配置与会话工厂使用的多个方面。这不仅涉及到了实体类的基本映射配置，还包括了进一步的性能优化策略，以及会话管理和事务控制方法。理解这些概念对于构建高效稳定的Java企业级应用程序至关重要。

本文还有配套的精品资源，点击获取

简介：SSH整合是Java开发中构建Web应用的经典框架组合，涵盖了Spring、Struts2和Hibernate三个组件。Spring负责应用上下文和依赖注入，Struts2处理用户请求及展示结果，Hibernate简化数据库操作。本实践教程将详细介绍如何整合这三个框架，并通过步骤及代码示例来展示如何实现一个完整的SSH集成开发流程。

本文还有配套的精品资源，点击获取