Java主流框架学习：从入门到实践

概述

本文介绍了Java主流框架学习的相关内容，涵盖了Spring、MyBatis、Hibernate、Struts等常见框架的作用和特点。文章不仅详细讲解了每个框架的基本概念、核心配置和实际应用场景，还提供了配置示例和代码示例以帮助读者快速上手。通过学习这些主流框架，开发者可以提高开发效率和代码质量。

Java主流框架简介

框架的作用与意义

Java框架是一种软件架构，它提供了一套预定义的组件和接口，简化了开发过程。以下是框架的一些主要作用和意义：

1. 减少重复编码：框架提供了一些通用的功能，避免了程序员一次次从头开始编写相同的代码。
2. 提高开发效率：使用框架可以加快开发速度，因为许多常见的功能已经被实现。
3. 增强可维护性和可扩展性：框架可以提供一个结构化的开发环境，使得软件更容易维护和扩展。
4. 简化错误处理：框架通常包含了处理常见错误和异常的机制，减少了代码出错的可能性。
5. 组件重用：开发人员可以重用框架中的组件，从而节省时间和资源。

常见的Java主流框架

1. Spring：Spring框架提供了一种简单且一致的方式来进行软件开发，它覆盖了从基本的依赖注入到复杂的事务管理。
2. MyBatis：MyBatis是一种持久层框架，它将Java对象映射到数据库表，简化了数据库操作。
3. Hibernate：Hibernate是一个对象关系映射（ORM）框架，提供了一种方式，将Java对象映射到关系数据库表。
4. Struts：Struts是一个基于MVC模式的Web应用框架，用于构建企业级Web应用。
5. Spring Boot：Spring Boot是Spring框架的一个模块，简化了使用Spring进行开发的过程，自动配置了许多常见的设置。

选择适合自己的框架

选择合适的框架取决于项目的需求和团队的技术背景。以下是一些选择框架的建议：

1. 项目规模：对于小规模项目，可能只需要简单的框架支持；对于大规模复杂项目，则需要功能丰富的框架。
2. 团队技术栈：选择团队成员熟悉的技术栈，以提高开发效率。
3. 框架特性：根据项目的需求选择具有相应特性的框架，例如ORM、Web开发、依赖注入等。
4. 社区支持：选择有活跃的社区和支持的框架，这可以确保开发过程中遇到的问题能够得到及时解决。

Spring框架入门

Spring框架的基本概念

Spring框架是一个广义的企业级应用开发框架，支持面向切面编程、声明式事务管理、持久化和Web服务。Spring的核心优势在于其依赖注入（Dependency Injection, DI）和控制反转（Inversion of Control, IoC）。

依赖注入与控制反转

• 依赖注入：指对象之间的依赖关系通过外部配置文件（如XML配置文件或注解）来管理，而不是在代码中硬编码。
• 控制反转：对象A依赖于对象B，对象A不需要自己完成创建对象B的过程，而是由外部容器负责对象B的创建和依赖注入。

Spring框架的核心特性

Spring框架提供了一系列核心组件，下面列出一些主要特性：

1. 依赖注入（DI）：Spring提供了多种方式实现依赖注入，包括XML配置文件和注解配置。
2. 面向切面编程（AOP）：Spring支持创建切面，可以将横切关注点（如日志、事务管理）从业务逻辑中分离出去。
3. 声明式事务管理：通过配置来管理事务，而不需要在代码中编写事务管理逻辑。
4. Spring MVC：Spring MVC是一个基于MVC架构的Web框架，用于构建Web应用程序。
5. Spring Boot：简化了传统Spring应用开发，自动配置了许多常见组件。

Spring框架的快速上手

构建第一个Spring应用

首先，需要一个Maven项目来管理依赖。创建一个Maven项目，并在pom.xml中添加Spring的依赖：

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

接下来创建一个简单的Java类，并使用注解进行依赖注入：

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

@Component
public class GreetingService {
    private String greeting = "Hello!";

    public String getGreetingMessage() {
        return greeting;
    }

    public void setGreetingMessage(String greeting) {
        this.greeting = greeting;
    }
}

创建一个Spring容器并获取所需的服务：

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        GreetingService greetingService = (GreetingService) context.getBean("greetingService");
        System.out.println(greetingService.getGreetingMessage());
    }
}

在Beans.xml中配置依赖关系：

<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="greetingService" class="com.example.GreetingService"/>
</beans>

运行MainApp类，可以看到输出的问候信息。此外，下面是一个简单的事务管理示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class TransactionService {
    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void addUser(User user) {
        userRepository.save(user);
    }
}

MyBatis框架入门

MyBatis框架的基本概念

MyBatis是一个优秀的持久层框架，它是基于Java的持久化SQL框架，可以使用简单的方式来完成数据库持久化操作。MyBatis通过配置文件来映射SQL语句，将Java对象与数据库表之间进行关联。

MyBatis框架的核心配置

MyBatis的配置文件mybatis-config.xml包含多方面的配置信息：

1. Environment settings：设置数据库连接的信息，包括数据库的URL、驱动类等。
2. Mappers：配置映射器（Mapper）的位置，映射器文件中定义了SQL语句和对应的Java方法。
3. TypeAliases：定义一些类型别名，便于在接口中使用简短的类型名。

使用MyBatis进行数据库操作

配置文件示例

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

映射文件示例

UserMapper.xml中定义了与User表相关的SQL语句：

<mapper namespace="com.example.UserMapper">
    <select id="selectUser" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
    <insert id="addUser">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>
    <update id="updateUser">
        UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}
    </update>
    <delete id="deleteUser">
        DELETE FROM users WHERE id = #{id}
    </delete>
</mapper>

Java代码示例

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

import java.io.InputStream;

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

        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);
            User user = new User();
            user.setName("John Doe");
            user.setEmail("[e-mail]");
            mapper.addUser(user);
            session.commit();
            System.out.println("User added successfully");

            User selectedUser = mapper.selectUser(1);
            System.out.println(selectedUser.getName());

            user.setName("John Smith");
            user.setEmail("[e-mail]");
            mapper.updateUser(user);
            session.commit();
            System.out.println("User updated successfully");

            mapper.deleteUser(1);
            session.commit();
            System.out.println("User deleted successfully");
        }
    }
}

Hibernate框架入门

Hibernate框架的基本概念

Hibernate是一个轻量级的对象关系映射（ORM）框架，它允许Java对象与数据库表进行关联，简化了数据库操作。

Hibernate框架的核心配置

Hibernate的核心配置文件是hibernate.cfg.xml，其中包含数据库连接信息、映射文件位置等配置。此外，还需要创建Java类与数据库表进行映射。

配置文件示例

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.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">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <mapping resource="com/example/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

映射文件示例

User.hbm.xml中定义了User类与数据库表之间的映射关系：

<hibernate-mapping>
    <class name="com.example.User" table="users">
        <id name="id" column="id" type="int">
            <generator class="native"/>
        </id>
        <property name="name" column="name" type="string"/>
        <property name="email" column="email" type="string"/>
    </class>
</hibernate-mapping>

Hibernate框架的简单操作

Java代码示例

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

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

        User user = new User();
        user.setName("John Doe");
        user.setEmail("[e-mail]");
        session.save(user);
        session.getTransaction().commit();
        System.out.println("User saved successfully");

        session.beginTransaction();
        User selectedUser = session.get(User.class, 1);
        System.out.println(selectedUser.getName());
        session.getTransaction().commit();
        System.out.println("User selected successfully");

        session.beginTransaction();
        user.setName("John Smith");
        user.setEmail("[e-mail]");
        session.update(user);
        session.getTransaction().commit();
        System.out.println("User updated successfully");

        session.beginTransaction();
        session.delete(user);
        session.getTransaction().commit();
        System.out.println("User deleted successfully");

        session.close();
        sessionFactory.close();
    }
}

Struts框架入门

Struts框架的基本概念

Struts是一个基于MVC模式的Web应用框架，用于构建企业级Web应用。它提供了一组标签库、插件和辅助工具，简化了Web应用开发。

Struts框架的核心组件

Struts主要包括以下几个核心组件：

1. ActionServlet：负责处理客户端请求，调用相应的Action来执行业务逻辑。
2. ActionForm：用于封装HTTP请求参数，提供标准的表单数据访问。
3. Action：处理业务逻辑，实现业务功能。
4. ActionMapping：配置Action的映射关系，指定Action的URL路径。
5. ActionForward：定义了请求处理后的转发路径。

Struts框架的简单应用

配置文件示例

struts-config.xml中配置了Action、Form和Forward的关系：

<struts-config>
    <form-beans>
        <form-bean name="UserForm" type="com.example.UserForm"/>
    </form-beans>
    <action-mappings>
        <action path="/userAction" type="com.example.UserAction" name="UserForm" scope="request">
            <forward name="success" path="/success.jsp"/>
            <forward name="failure" path="/failure.jsp"/>
        </action>
    </action-mappings>
</struts-config>

Java代码示例

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

public class UserAction extends Action {
    public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
        UserForm userForm = (UserForm) form;
        String userName = userForm.getUserName();
        if (isValidUserName(userName)) {
            return mapping.findForward("success");
        } else {
            return mapping.findForward("failure");
        }
    }

    private boolean isValidUserName(String userName) {
        // 检查用户名是否有效
        return true;
    }
}

JSP页面示例

<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>
<html>
<body>
<h1>User Form</h1>
<html:form action="userAction">
    <label for="username">Username:</label>
    <html:text property="username"/>
    <html:submit value="Submit"/>
</html:form>
</body>
</html>

实战项目：应用主流框架构建一个简单应用

项目需求分析

假设我们需要开发一个简单的图书管理系统，系统需要实现以下功能：

1. 图书管理：添加、编辑、删除图书。
2. 作者管理：添加、编辑、删除作者信息。
3. 用户管理：添加、编辑、删除用户信息。
4. 用户借阅：用户可以借阅图书，系统记录借阅情况。

项目设计与实现

数据库设计

CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(255),
    password VARCHAR(255)
);

CREATE TABLE authors (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255)
);

CREATE TABLE books (
    id INT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(255),
    author_id INT,
    FOREIGN KEY (author_id) REFERENCES authors(id)
);

CREATE TABLE borrowings (
    id INT PRIMARY KEY AUTO_INCREMENT,
    user_id INT,
    book_id INT,
    borrow_date DATE,
    return_date DATE,
    FOREIGN KEY (user_id) REFERENCES users(id),
    FOREIGN KEY (book_id) REFERENCES books(id)
);

使用Spring进行依赖注入

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

@Component
public class UserService {
    private UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

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

使用MyBatis进行数据库操作

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

import java.io.InputStream;

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

        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);
            mapper.addUser(new User("John Doe", "password"));
            session.commit();
        }
    }
}

使用Hibernate进行数据库操作

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

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

        session.save(new User("John Doe", "password"));
        session.getTransaction().commit();
        session.close();
        sessionFactory.close();
    }
}

使用Struts进行Web应用开发

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

public class UserAction extends Action {
    public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
        UserForm userForm = (UserForm) form;
        User user = new User(userForm.getUsername(), userForm.getPassword());
        userService.addUser(user);
        return mapping.findForward("success");
    }
}

项目测试与部署

测试数据库操作

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

import java.io.InputStream;

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

        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);
            User user = mapper.selectUser(1);
            System.out.println(user.getName());
        }
    }
}

部署Web应用

将Struts应用部署到Tomcat服务器：

1. 创建Web应用目录：

   • src/main/webapp：Web应用资源，如HTML、JSP页面。
   • src/main/resources：资源文件，如配置文件struts-config.xml。

2. 打包为WAR文件：

   • 使用Maven或IDE打包项目，生成target目录下的WAR文件。
3. 部署WAR文件：
   • 将WAR文件复制到Tomcat的webapps目录下。
   • 启动Tomcat服务器，可以访问http://localhost:8080/your-app/。