Java主流框架入门教程

概述

本文介绍了Java主流框架的基本概念和应用场景，包括Spring、Hibernate、MyBatis和Struts等框架，详细阐述了它们的核心功能和使用方法。通过这些框架，开发人员可以更高效地构建高质量的Java应用程序，简化开发流程并提升应用性能。

引入Java主流框架

Java框架在现代软件开发中扮演着至关重要的角色。框架是一种半成品软件，它提供了一组通用的解决方案和工具，帮助开发人员更高效地构建应用程序。框架的作用不仅在于简化开发流程，还在于提高代码的可重用性、可维护性和扩展性。通过框架，开发人员可以专注于业务逻辑的实现，而不必过分关注底层技术细节。

在Java开发中，有许多主流框架被广泛应用，这些框架不仅简化了开发流程，还提升了应用的性能和可靠性。以下是一些常用的Java主流框架：

1. Spring：Spring是一个非常流行的轻量级框架，提供了全面的解决方案，包括依赖注入、AOP（面向切面编程）、Web开发、事务管理等。
2. Hibernate：Hibernate是一个开源的持久层框架，用于实现Java对象和数据库之间的映射。它解决了对象关系映射（ORM）的问题，简化了数据库操作。
3. MyBatis：MyBatis是一个持久层框架，与Hibernate类似，但更注重SQL语句的编写。它允许开发人员手动编写SQL语句，提供了更多的灵活性。
4. Struts：Struts是一个MVC（Model-View-Controller）框架，用于开发Web应用。它提供了请求的处理、模型视图分离等功能。

这些框架各有特点，可以根据项目需求选择合适的框架进行开发。在接下来的部分，我们将详细介绍每个框架的基础知识和使用方法。

Spring框架基础

Spring框架简介

Spring是一个广泛使用的Java开发框架，由Rod Johnson在2003年首次发布。Spring框架的核心模块是依赖注入（DI）和控制反转（IoC），这两个概念是Spring框架的核心设计理念。

依赖注入（Dependency Injection, DI）是指将对象的依赖关系通过外部配置文件或其他方式注入到对象中，而不是在对象内部直接创建这些依赖对象。这样做的好处是可以更好地管理对象之间的依赖关系，提高代码的可测试性和可维护性。

控制反转（Inversion of Control, IoC）是指将控制权从应用程序代码转移到框架中。通过IoC容器，Spring可以管理对象的生命周期，并负责对象之间的依赖关系注入。

除了DI和IoC，Spring框架还包括其他多个子模块，例如Spring MVC（用于Web开发）、Spring Security（用于安全控制）、Spring Data（用于简化数据访问）等。

Spring的基本用法和配置

基本概念

要使用Spring框架，首先需要在项目中引入Spring的核心依赖。对于基于Maven的项目，可以通过在pom.xml文件中添加以下依赖来引入Spring的核心库：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.3.10</version>
    </dependency>
</dependencies>

配置方式

Spring框架提供了多种配置方式，包括基于XML配置、基于注解配置和Java配置。在现代开发中，基于注解和Java配置的方式更为常用。

基于XML配置

传统的Spring配置文件通常使用XML格式。以下是一个简单的Spring配置文件示例，定义了两个简单的Bean：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="helloBean" class="com.example.HelloBean" />

    <bean id="printer" class="com.example.Printer">
        <property name="message" value="Hello, Spring!" />
    </bean>
</beans>

基于注解配置

在现代Spring开发中，更推荐使用注解配置。以下是一个简单的示例，展示了如何使用@Component、@Autowired等注解来定义和注入Bean：

import org.springframework.stereotype.Component;

@Component
public class HelloBean {
    public void sayHello() {
        System.out.println("Hello from HelloBean");
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Printer {
    private String message;

    @Autowired
    public Printer(HelloBean helloBean) {
        this.message = helloBean.sayHello(); // 自动注入HelloBean实例
    }

    public void print() {
        System.out.println(message);
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDemo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Printer printer = context.getBean(Printer.class);
        printer.print();
    }
}

在上述代码中，@Component注解用于标记类作为Spring Bean，@Autowired注解用于自动注入依赖的Bean。通过这种方式，可以减少XML配置文件的使用，使代码更加清晰和简洁。

依赖注入

依赖注入是Spring框架的核心特性之一。通过依赖注入，可以将一个对象所需的依赖关系从对象内部转移到外部配置文件或注解中。以下是依赖注入的一些常见方式：

1. 构造器注入：通过构造器参数传递依赖关系。
2. setter方法注入：通过setter方法注入依赖关系。
3. 字段注入：通过注解直接注入依赖关系。

以下是一个简单的构造器注入示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Printer {
    private HelloBean helloBean;

    @Autowired
    public Printer(HelloBean helloBean) {
        this.helloBean = helloBean;
    }

    public void print() {
        System.out.println(helloBean.sayHello());
    }
}

在上述代码中，Printer类通过构造器参数注入HelloBean实例。Spring框架负责在创建Printer实例时自动注入所需的HelloBean实例。

总之，Spring框架提供了强大的依赖注入和控制反转功能，帮助开发人员更高效地构建高质量的Java应用程序。通过本节的学习，你可以掌握Spring框架的基本用法和配置方式。

Hibernate框架入门

Hibernate简介

Hibernate是一个开源的持久层框架，用于实现Java对象和关系数据库之间的映射。它是一种对象关系映射（ORM）工具，可以简化Java对象与数据库表之间的交互。Hibernate的核心功能在于将Java对象持久化到数据库中，以及从数据库中读取持久化对象。

Hibernate的基本操作与持久化

配置Hibernate

使用Hibernate的第一步是配置Hibernate环境。以下是一些基本的配置步骤：

1. 引入依赖：在基于Maven的项目中，需要在pom.xml文件中添加Hibernate的依赖。

<dependencies>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.6.0.Final</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.26</version>
    </dependency>
</dependencies>

1. 配置文件：创建一个hibernate.cfg.xml配置文件，配置数据库连接信息等。

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>
</hibernate-configuration>

1. 实体类：定义一个Java类，使用注解或XML映射文件将其与数据库表关联起来。

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "person")
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String firstName;
    private String lastName;

    // 构造器、getter和setter方法
    public Person() {
    }

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

基本操作

1. 保存对象（持久化）：
   • 使用Session对象的save()方法将对象持久化到数据库。
   • Session对象是Hibernate的核心接口，代表数据库会话（session）。

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateDemo {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        session.beginTransaction();

        Person person = new Person("John", "Doe");
        session.save(person);

        session.getTransaction().commit();
        session.close();
    }
}

1. 查询对象：
   • 使用Session对象的get()方法或createQuery()方法查询数据库中的对象。
   • createQuery()方法可以用来执行HQL（Hibernate Query Language）语句。

public class HibernateDemo {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        session.beginTransaction();

        Person person = session.get(Person.class, 1); // 获取id为1的Person对象
        System.out.println(person);

        session.getTransaction().commit();
        session.close();
    }
}

1. 更新对象：
   • 通过Session对象的update()方法更新数据库中的对象。

public class HibernateDemo {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        session.beginTransaction();

        Person person = session.get(Person.class, 1);
        person.setFirstName("Jane");
        session.update(person);

        session.getTransaction().commit();
        session.close();
    }
}

1. 删除对象：
   • 使用Session对象的delete()方法从数据库中删除对象。

public class HibernateDemo {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        session.beginTransaction();

        Person person = session.get(Person.class, 1);
        session.delete(person);

        session.getTransaction().commit();
        session.close();
    }
}

事务管理

Hibernate提供了事务管理功能，可以帮助开发者管理数据库事务。以下是一个简单的事务管理示例：

public class HibernateDemo {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();

        try {
            Person person1 = new Person("John", "Doe");
            Person person2 = new Person("Jane", "Smith");
            session.save(person1);
            session.save(person2);

            transaction.commit();
        } catch (Exception e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
}

在上述示例中，通过transaction.commit()方法提交事务，如果发生异常则通过transaction.rollback()方法回滚事务。

总之，Hibernate框架提供了强大的持久化功能，帮助开发人员更轻松地实现Java对象与数据库表之间的交互。通过本节的学习，你可以掌握Hibernate的基本配置和操作方法。

MyBatis框架简述

MyBatis框架介绍

MyBatis是一个持久层框架，用于实现Java对象和关系数据库之间的映射。与Hibernate不同，MyBatis更注重SQL语句的编写，提供了更多的灵活性。MyBatis的核心功能在于将SQL语句与Java代码相结合，通过配置文件或注解实现数据的持久化操作。

MyBatis的基本配置与使用

基本配置

使用MyBatis的第一步是配置MyBatis环境。以下是一些基本的配置步骤：

1. 引入依赖：在基于Maven的项目中，需要在pom.xml文件中添加MyBatis的依赖。

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.26</version>
    </dependency>
</dependencies>

1. 配置文件：创建一个mybatis-config.xml配置文件，配置数据库连接信息等。

<configuration>
    <typeAliases>
        <typeAlias type="com.example.Person" alias="Person"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/PersonMapper.xml"/>
    </mappers>
</configuration>

1. 实体类：定义一个Java类，用于表示数据库中的表。

import java.io.Serializable;

public class Person implements Serializable {
    private int id;
    private String firstName;
    private String lastName;

    // 构造器、getter和setter方法
    public Person() {
    }

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

1. Mapper XML文件：创建一个Mapper XML文件，定义SQL语句。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.PersonMapper">
    <select id="selectPerson" resultType="Person">
        SELECT id, firstName, lastName FROM person WHERE id = #{id}
    </select>
    <insert id="insertPerson">
        INSERT INTO person (firstName, lastName) VALUES (#{firstName}, #{lastName})
    </insert>
    <update id="updatePerson">
        UPDATE person SET firstName = #{firstName}, lastName = #{lastName} WHERE id = #{id}
    </update>
    <delete id="deletePerson">
        DELETE FROM person WHERE id = #{id}
    </delete>
</mapper>

使用MyBatis

1. 获取SqlSessionFactory对象：

import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class MyBatisDemo {
    public static void main(String[] args) {
        String resource = "mybatis-config.xml";
        InputStream inputStream = MyBatisDemo.class.getClassLoader().getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }
}

1. 获取SqlSession对象：

SqlSession sqlSession = sqlSessionFactory.openSession();

1. 执行SQL语句：

PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);

Person person = new Person(1, "John", "Doe");
mapper.insertPerson(person);

person = mapper.selectPerson(1);
System.out.println(person);

person.setFirstName("Jane");
mapper.updatePerson(person);

mapper.deletePerson(1);

动态SQL

MyBatis提供了强大的动态SQL功能，可以根据不同的条件生成不同的SQL语句。以下是一个动态SQL的示例：

<select id="selectPerson" resultType="Person">
    SELECT id, firstName, lastName FROM person
    <where>
        <if test="id != null">
            WHERE id = #{id}
        </if>
        <if test="firstName != null">
            AND firstName = #{firstName}
        </if>
        <if test="lastName != null">
            AND lastName = #{lastName}
        </if>
    </where>
</select>

事务管理

MyBatis也提供了事务管理功能，可以通过SqlSession对象来管理事务。

SqlSession sqlSession = sqlSessionFactory.openSession();
try {
    PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);

    Person person1 = new Person(1, "John", "Doe");
    mapper.insertPerson(person1);

    Person person2 = new Person(2, "Jane", "Smith");
    mapper.insertPerson(person2);

    sqlSession.commit();
} catch (Exception e) {
    sqlSession.rollback();
} finally {
    sqlSession.close();
}

总之，MyBatis框架提供了强大的SQL执行和动态SQL生成功能，帮助开发人员更灵活地实现Java对象与数据库的交互。通过本节的学习，你可以掌握MyBatis的基本配置和使用方法。

Struts框架入门

Struts框架简介

Struts是一个开源的MVC（Model-View-Controller）框架，用于开发Web应用。它提供了一套成熟的解决方案，包括请求处理、模型视图分离、表单验证等功能。Struts框架由Apache基金会维护，是Java Web开发中非常流行的选择。

Struts的基本结构及配置方法

基本结构

Struts框架的MVC架构如下：

1. Model：模型层负责处理业务逻辑，通常包含Java Bean和DAO（数据访问对象）。
2. View：视图层负责显示数据，通常由JSP页面实现。
3. Controller：控制器层负责处理用户请求，并将控制权传递给模型和视图。控制器通常由Action类实现。

配置文件

Struts框架需要配置文件来定义Action、视图和请求映射等信息。常用的配置文件包括struts.xml或web.xml。

struts.xml配置文件

<struts>
    <package name="default" namespace="/" extends="struts-default">
        <action name="helloAction" class="com.example.HelloAction">
            <result name="success">/success.jsp</result>
        </action>
    </package>
</struts>

在上述配置文件中，定义了一个helloAction Action，其类为com.example.HelloAction，并指定了成功请求的视图为/success.jsp。

web.xml配置文件

<web-app>
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

在web.xml配置文件中，定义了一个Struts2的过滤器，拦截所有请求并进行处理。

Action类

Action类是控制器层的核心部分，负责处理用户请求。以下是一个简单的Action类示例：

import com.opensymphony.xwork2.ActionSupport;

public class HelloAction extends ActionSupport {
    private String message;

    public String execute() {
        message = "Hello, Struts!";
        return SUCCESS;
    }

    public String getMessage() {
        return message;
    }
}

在上述示例中，HelloAction类继承自ActionSupport，并在execute()方法中处理业务逻辑并返回结果。

视图层

视图层通常由JSP页面实现。以下是一个简单的JSP页面示例：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello, Struts!</title>
</head>
<body>
<h1><%= ((HelloAction) request.getAttribute("helloAction")).getMessage() %></h1>
</body>
</html>

在上述JSP页面中，通过request.getAttribute()方法获取Action对象，并显示其返回的消息。

表单验证

Struts框架提供了多种表单验证方式，包括通过Action类中的validate()方法进行验证，或者通过struts.xml配置文件中的<validators>标签进行验证。

使用validate()方法

import com.opensymphony.xwork2.validator.ValidationAwareSupport;

public class UserAction extends ValidationAwareSupport {
    private String name;
    private String email;

    public void validate() {
        if (name == null || name.trim().isEmpty()) {
            addFieldError("name", "Name is required");
        }
        if (email == null || email.trim().isEmpty()) {
            addFieldError("email", "Email is required");
        }
    }

    // getter和setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

在上述示例中，UserAction类重写了validate()方法，并在其中进行了表单字段的验证。

使用struts.xml配置文件

<validators>
    <field name="name">
        <field-validator type="requiredstring">
            <param name="trim">true</param>
            <message>Name is required</message>
        </field-validator>
    </field>
    <field name="email">
        <field-validator type="email">
            <message>Email is invalid</message>
        </field-validator>
    </field>
</validators>

在上述配置文件中，使用<validators>标签定义了字段验证规则。

总之，Struts框架提供了成熟的MVC架构和丰富的功能，帮助开发人员更高效地开发Web应用。通过本节的学习，你可以掌握Struts框架的基本结构和配置方法。

实战练习与项目应用

实战项目案例

在本节中，我们将通过一个实际的项目案例来应用前面介绍的Spring、Hibernate、MyBatis和Struts框架。这个案例是一个简单的图书管理系统，包括图书的增删改查等基本功能。

项目需求

图书管理系统需要实现以下功能：

1. 图书管理：

   • 添加新图书
   • 查看所有图书列表
   • 更新图书信息
   • 删除图书
2. 用户管理：
   • 用户登录
   • 用户注册
   • 用户信息管理

项目结构

项目结构如下：

- src/main/java/
  - com/example/
    - service/
      - BookService.java
      - UserService.java
    - dao/
      - BookDao.java
      - UserDao.java
    - controller/
      - BookController.java
      - UserController.java
    - model/
      - Book.java
      - User.java
- src/main/resources/
  - application.properties
  - applicationContext.xml
  - mybatis-config.xml
  - PersonMapper.xml
- src/main/webapp/
  - WEB-INF/
    - struts.xml
    - lib/
- src/main/webapp/
  - index.jsp
  - login.jsp
  - userRegister.jsp
  - bookList.jsp
  - addBook.jsp
  - updateBook.jsp
  - deleteBook.jsp

实现步骤

1. 数据库设计：

CREATE TABLE `book` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `title` VARCHAR(255) NOT NULL,
  `author` VARCHAR(255) NOT NULL,
  `price` DECIMAL(10, 2) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `user` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `username` VARCHAR(255) NOT NULL,
  `password` VARCHAR(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

1. 实体类：

import java.io.Serializable;

public class Book implements Serializable {
    private int id;
    private String title;
    private String author;
    private double price;

    // 构造器、getter和setter方法
    public Book() {
    }

    public Book(String title, String author, double price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

import java.io.Serializable;

public class User implements Serializable {
    private int id;
    private String username;
    private String password;

    // 构造器、getter和setter方法
    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

1. DAO接口及实现：

import java.util.List;

public interface BookDao {
    List<Book> getAllBooks();
    Book getBookById(int id);
    void addBook(Book book);
    void updateBook(Book book);
    void deleteBook(int id);
}

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import java.util.List;
import java.util.ArrayList;

public class BookDaoImpl implements BookDao {
    private SessionFactory sessionFactory;

    public BookDaoImpl() {
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }

    @Override
    public List<Book> getAllBooks() {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        List<Book> books = session.createQuery("from Book").list();
        transaction.commit();
        session.close();
        return books;
    }

    @Override
    public Book getBookById(int id) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        Book book = session.get(Book.class, id);
        transaction.commit();
        session.close();
        return book;
    }

    @Override
    public void addBook(Book book) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        session.save(book);
        transaction.commit();
        session.close();
    }

    @Override
    public void updateBook(Book book) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        session.update(book);
        transaction.commit();
        session.close();
    }

    @Override
    public void deleteBook(int id) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        Book book = session.get(Book.class, id);
        session.delete(book);
        transaction.commit();
        session.close();
    }
}

import java.util.List;
import java.util.Map;

public interface UserDao {
    void addUser(User user);
    User getUserByUsername(String username);
    void updateUser(User user);
    void deleteUser(int id);
}

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import java.util.Map;
import java.util.HashMap;

public class UserDaoImpl implements UserDao {
    private SessionFactory sessionFactory;

    public UserDaoImpl() {
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }

    @Override
    public void addUser(User user) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        session.save(user);
        transaction.commit();
        session.close();
    }

    @Override
    public User getUserByUsername(String username) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        User user = session.createQuery("from User where username = :username")
                .setParameter("username", username)
                .uniqueResult();
        transaction.commit();
        session.close();
        return user;
    }

    @Override
    public void updateUser(User user) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        session.update(user);
        transaction.commit();
        session.close();
    }

    @Override
    public void deleteUser(int id) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        User user = session.get(User.class, id);
        session.delete(user);
        transaction.commit();
        session.close();
    }
}

1. Service接口及实现：

import java.util.List;

public interface BookService {
    List<Book> getAllBooks();
    Book getBookById(int id);
    void addBook(Book book);
    void updateBook(Book book);
    void deleteBook(int id);
}

import com.example.dao.BookDao;
import com.example.dao.BookDaoImpl;

import java.util.List;

public class BookServiceImpl implements BookService {
    private BookDao bookDao;

    public BookServiceImpl() {
        bookDao = new BookDaoImpl();
    }

    @Override
    public List<Book> getAllBooks() {
        return bookDao.getAllBooks();
    }

    @Override
    public Book getBookById(int id) {
        return bookDao.getBookById(id);
    }

    @Override
    public void addBook(Book book) {
        bookDao.addBook(book);
    }

    @Override
    public void updateBook(Book book) {
        bookDao.updateBook(book);
    }

    @Override
    public void deleteBook(int id) {
        bookDao.deleteBook(id);
    }
}

import com.example.dao.UserDao;
import com.example.dao.UserDaoImpl;

public interface UserService {
    void addUser(User user);
    User getUserByUsername(String username);
    void updateUser(User user);
    void deleteUser(int id);
}

import com.example.dao.UserDao;
import com.example.dao.UserDaoImpl;

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserServiceImpl() {
        userDao = new UserDaoImpl();
    }

    @Override
    public void addUser(User user) {
        userDao.addUser(user);
    }

    @Override
    public User getUserByUsername(String username) {
        return userDao.getUserByUsername(username);
    }

    @Override
    public void updateUser(User user) {
        userDao.updateUser(user);
    }

    @Override
    public void deleteUser(int id) {
        userDao.deleteUser(id);
    }
}

1. Controller类：

import com.opensymphony.xwork2.ActionSupport;
import com.example.service.BookService;

public class BookController extends ActionSupport {
    private BookService bookService;

    public BookController() {
        bookService = new BookServiceImpl();
    }

    private List<Book> books;
    private Book book;
    private int id;

    public String execute() {
        books = bookService.getAllBooks();
        return SUCCESS;
    }

    public String addBook() {
        bookService.addBook(book);
        return SUCCESS;
    }

    public String updateBook() {
        bookService.updateBook(book);
        return SUCCESS;
    }

    public String deleteBook() {
        bookService.deleteBook(id);
        return SUCCESS;
    }

    // getter和setter方法
    public List<Book> getBooks() {
        return books;
    }

    public void setBooks(List<Book> books) {
        this.books = books;
    }

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

import com.opensymphony.xwork2.ActionSupport;
import com.example.service.UserService;

public class UserController extends ActionSupport {
    private UserService userService;

    public UserController() {
        userService = new UserServiceImpl();
    }

    private User user;
    private String username;

    public String execute() {
        return SUCCESS;
    }

    public String addUser() {
        userService.addUser(user);
        return SUCCESS;
    }

    public String getUserByUsername() {
        user = userService.getUserByUsername(username);
        return SUCCESS;
    }

    public String updateUser() {
        userService.updateUser(user);
        return SUCCESS;
    }

    public String deleteUser() {
        userService.deleteUser(user.getId());
        return SUCCESS;
    }

    // getter和setter方法
    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

1. JSP页面：

<!-- index.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>图书管理系统</title>
</head>
<body>
<h1>欢迎来到图书管理系统</h1>
<a href="bookList.jsp">图书列表</a> | <a href="login.jsp">用户登录</a>
</body>
</html>

<!-- bookList.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>图书列表</title>
</head>
<body>
<h1>图书列表</h1>
<table>
    <tr>
        <th>ID</th>
        <th>标题</th>
        <th>作者</th>
        <th>价格</th>
        <th>操作</th>
    </tr>
    <s:iterator value="books">
        <tr>
            <td>${id}</td>
            <td>${title}</td>
            <td>${author}</td>
            <td>${price}</td>
            <td>
                <a href="updateBook.jsp?bookId=${id}">编辑</a> |
                <a href="deleteBook.jsp?bookId=${id}">删除</a>
            </td>
        </tr>
    </s:iterator>
</table>
<a href="addBook.jsp">添加新图书</a>
</body>
</html>

<!-- addBook.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>添加新图书</title>
</head>
<body>
<h1>添加新图书</h1>
<form action="BookController" method="post">
    <input type="hidden" name="action" value="addBook"/>
    <table>
        <tr>
            <td>标题:</td>
            <td><input type="text" name="title" required/></td>
        </tr>
        <tr>
            <td>作者:</td>
            <td><input type="text" name="author" required/></td>
        </tr>
        <tr>
            <td>价格:</td>
            <td><input type="number" name="price" required/></td>
        </tr>
        <tr>
            <td><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form>
</body>
</html>

<!-- updateBook.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>编辑图书</title>
</head>
<body>
<h1>编辑图书</h1>
<form action="BookController" method="post">
    <input type="hidden" name="action" value="updateBook"/>
    <input type="hidden" name="id" value="${param.bookId}"/>
    <table>
        <tr>
            <td>标题:</td>
            <td><input type="text" name="title" value="${book.title}" required/></td>
        </tr>
        <tr>
            <td>作者:</td>
            <td><input type="text" name="author" value="${book.author}" required/></td>
        </tr>
        <tr>
            <td>价格:</td>
            <td><input type="number" name="price" value="${book.price}" required/></td>
        </tr>
        <tr>
            <td><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form>
</body>
</html>

<!-- deleteBook.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>删除图书</title>
</head>
<body>
<h1>删除图书</h1>
<form action="BookController" method="post">
    <input type="hidden" name="action" value="deleteBook"/>
    <input type="hidden" name="id" value="${param.bookId}"/>
    <table>
        <tr>
            <td>是否确定删除该图书？</td>
        </tr>
        <tr>
            <td><input type="submit" value="确定"/></td>
            <td><a href="bookList.jsp">取消</a></td>
        </tr>
    </table>
</form>
</body>
</html>

<!-- login.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>用户登录</title>
</head>
<body>
<h1>用户登录</h1>
<form action="UserController" method="post">
    <input type="hidden" name="action" value="login"/>
    <table>
        <tr>
            <td>用户名:</td>
            <td><input type="text" name="username" required/></td>
        </tr>
        <tr>
            <td>密码:</td>
            <td><input type="password" name="password" required/></td>
        </tr>
        <tr>
            <td><input type="submit" value="登录"/></td>
        </tr>
    </table>
</form>
</body>
</html>

<!-- userRegister.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>用户注册</title>
</head>
<body>
<h1>用户注册</h1>
<form action="UserController" method="post">
    <input type="hidden" name="action" value="register"/>
    <table>
        <tr>
            <td>用户名:</td>
            <td><input type="text" name="username" required/></td>
        </tr>
        <tr>
            <td>密码:</td>
            <td><input type="password" name="password" required/></td>
        </tr>
        <tr>
            <td><input type="submit" value="注册"/></td>
        </tr>
    </table>
</form>
</body>
</html>

1. Struts配置文件：

<struts>
    <package name="default" namespace="/" extends="struts-default">
        <action name="BookController" class="com.example.controller.BookController">
            <result name="success">/bookList.jsp</result>
        </action>
        <action name="UserController" class="com.example.controller.UserController">
            <result name="success">/index.jsp</result>
        </action>
    </package>
</struts>

1. web.xml配置文件：

<web-app>
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

通过以上步骤，我们构建了一个简单的图书管理系统，实现了图书和用户的基本操作。通过这个案例，你可以更好地理解如何在实际项目中应用Java主流框架。

框架应用注意事项与技巧

在实际项目中应用主流框架时，需要注意以下几个方面：

1. 依赖管理：

   • 使用Maven或Gradle等构建工具来管理项目依赖，避免依赖冲突和版本问题。
   • 定期更新框架版本，确保使用最新的稳定版本。

2. 配置管理：

   • 使用配置文件或注解来管理框架配置，避免硬编码。
   • 使用外部化配置，例如通过环境变量或配置文件来管理敏感信息。

3. 代码结构：

   • 保持代码结构清晰，遵循MVC或类似的架构模式。
   • 使用分层结构，如DAO、Service、Controller等，提高代码的可维护性。

4. 事务管理：

   • 在事务边界明确的地方合理使用事务管理，确保数据的一致性。
   • 使用框架提供的事务管理功能，如Spring的@Transactional注解或Hibernate的事务管理。

5. 性能优化：

   • 避免过多的数据库查询和不必要的对象创建。
   • 使用缓存和懒加载等技术来提高性能。

6. 安全性：

   • 对用户输入进行验证和过滤，防止SQL注入等攻击。
   • 使用框架提供的安全功能，如Spring Security或Struts2的安全插件。

7. 异常处理：

   • 提供统一的异常处理机制，确保异常不会暴露给客户端。
   • 使用框架提供的异常处理功能，如Spring的@ExceptionHandler注解。
8. 测试：
   • 编写单元测试和集成测试，确保代码的正确性和稳定性。
   • 使用自动化测试工具，如JUnit和Mockito。

通过遵循这些注意事项和技巧，可以确保项目在使用主流框架时更加稳定、高效和安全。为了进一步提高开发效率，建议参考慕课网等在线学习资源，学习更多关于Java框架的高级用法和最佳实践。