首页手记 Java主流框架教程：入门与实践指南

Java主流框架教程：入门与实践指南

标签：

Java Spring

概述

本文介绍了Java主流框架的基本概念和分类，涵盖了Spring、Hibernate、MyBatis和Struts等框架的入门知识，详细讲解了每个框架的核心功能和使用方法，帮助开发者高效构建企业级Web应用程序。

Java主流框架简介

框架的基本概念

在编程领域，框架是一个提供通用功能和结构的软件平台，它允许开发者使用预定义的代码模板来简化和加速开发过程。框架通常包含一系列类和接口，这些类和接口提供了应用程序开发所需的基本结构和功能。框架可以减少开发工作和维护成本，因为它提供了许多常用的功能，例如数据访问、错误处理、用户界面等。

例如，Spring框架提供了依赖注入和控制反转（IoC）功能，Hibernate框架实现了对象关系映射（ORM），而MyBatis框架则提供了一种基于XML或注解的持久化方案。这些框架大大简化了开发过程，使开发者能够专注于业务逻辑而非底层细节。

Java主流框架的分类

Java主流框架可以分为多种类型，每种框架都有其特定的功能和使用场景。这些框架主要分为以下几类：

Web框架：这些框架主要用于开发Web应用程序。它们提供了处理HTTP请求、会话管理、路由等功能。例如，Spring MVC、Struts等。
持久层框架：这些框架用于处理数据库操作，例如对象关系映射（ORM）。Hibernate和MyBatis是这两个领域的代表性框架。
依赖注入（DI）和控制反转（IoC）框架：Spring框架是一个典型的DI/IoC框架，它通过控制对象的创建和依赖关系来简化应用程序的开发。
RESTful框架：例如Spring Boot和Jersey，用于构建RESTful Web服务，处理HTTP请求和响应，便于构建前后端分离的应用。
企业服务总线（ESB）框架：如Apache ServiceMix和Mule，用于企业级集成和消息传递。

选择适合的Java框架

选择合适的Java框架需要根据项目的需求和特性来决定。以下是一些选择框架时可以考虑的因素：

技术栈：根据已有的技术栈选择适合的框架。例如，如果项目已经使用了Spring，那么选择Spring Boot或Spring Data会更方便。
项目规模：大型项目可能需要更成熟的框架，如Spring，而小型项目可能选择简单的框架，如MyBatis。
性能需求：对于高并发和高性能的应用，可以选择轻量级的框架，如MyBatis，而对于复杂的企业级应用，Spring会更合适。
学习曲线：新手开发者可能需要选择易于上手的框架，如Spring Boot。
社区支持：选择有活跃社区支持的框架，可以确保在遇到问题时能够得到及时的帮助。

Spring框架入门

Spring框架概述

Spring是一个开源的Java应用程序框架，旨在简化企业应用程序的开发。Spring框架提供了一个全面的解决方案，它不仅包括依赖注入（DI）和控制反转（IoC）功能，还包括数据访问、事务处理、Web服务、安全性和测试支持等功能。Spring框架的模块化设计使得可以根据具体需求选择模块使用。

Spring框架由多个模块组成，包括核心容器、AOP模块、数据访问模块、Web模块等。Spring的核心容器是所有其他模块的基础，提供了IoC容器和DI功能。

依赖注入与控制反转

依赖注入（DI）和控制反转（IoC）是Spring框架的核心概念。依赖注入是一种设计模式，它将对象之间的依赖关系从代码中分离出来，通过外部配置文件或注解来管理对象之间的依赖关系。

控制反转（IoC）是指控制对象的创建和依赖关系的管理，将对象的控制权交给框架。例如，Spring框架会通过IoC容器管理对象的创建和依赖注入。

在下面的例子中，我们定义了一个简单的Bean，并使用Spring的IoC容器管理这个Bean的依赖关系。

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

public class SpringIoCExample {
    public static void main(String[] args) {
        // 初始化IoC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

        // 获取Bean
        SimpleBean simpleBean = (SimpleBean) context.getBean("simpleBean");

        // 使用Bean
        simpleBean.doSomething();
    }
}

<!-- 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="simpleBean" class="com.example.SimpleBean"/>
</beans>

public class SimpleBean {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

在这个例子中，SimpleBean对象的创建和依赖注入由Spring的IoC容器管理，代码中不再显式创建SimpleBean对象，而是通过IoC容器获取。

Spring Boot快速开发

Spring Boot是一个基于Spring框架的快速开发框架，它简化了Spring应用程序的开发过程。Spring Boot提供了自动配置、内置的Web服务器、外部化配置等功能，使得开发Web应用程序更加简单。

在下面的例子中，我们将创建一个简单的Spring Boot应用程序，用于返回"Hello World"。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SpringBootApplicationExample {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootApplicationExample.class, args);
    }

    @GetMapping("/hello")
    public String hello() {
        return "Hello World!";
    }
}

在这个例子中，我们使用了@SpringBootApplication注解来启用Spring Boot的自动配置功能，@RestController注解用于定义一个REST控制器。通过@GetMapping注解定义了一个HTTP GET请求处理方法，返回"Hello World!"。

Hibernate框架入门

ORM（对象关系映射）简介

对象关系映射（ORM）是一种将对象模型映射到关系数据库模型的技术。通过ORM，对象之间的关系可以转换为数据库表之间的关系，使得对象模型能够直接存储到关系数据库中。ORM的主要优点是可以将对象和数据库操作分离，避免了繁琐的SQL写入和维护。

Hibernate是一个流行的ORM框架，它提供了丰富的API，使得Java对象能够透明地映射到关系型数据库。Hibernate的映射文件定义了对象属性与数据库表字段之间的关系，从而实现了对象和数据库之间的数据交换。

Hibernate框架概述

Hibernate是一个独立的开源ORM框架，它实现了Java Persistence API（JPA）。Hibernate提供了数据映射和持久化功能，能够将Java对象持久化到关系数据库中。Hibernate支持多种数据库，包括MySQL、Oracle、SQL Server等。

下面是使用Hibernate创建一个简单的持久化对象的例子。

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

public class HibernateExample {
    public static void main(String[] args) {
        // 创建SessionFactory
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

        // 获取Session
        Session session = sessionFactory.openSession();

        // 开启事务
        session.beginTransaction();

        // 创建对象并保存到数据库
        User user = new User();
        user.setName("John Doe");
        session.save(user);

        // 提交事务
        session.getTransaction().commit();

        // 关闭Session
        session.close();
    }
}

public class User {
    private int id;
    private String name;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

<!-- hibernate.cfg.xml -->
<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 class="com.example.User"/>
    </session-factory>
</hibernate-configuration>

在这个例子中，我们定义了一个User类，并使用hibernate.cfg.xml配置文件配置了数据库连接信息。通过Hibernate的SessionFactory和Session来管理对象的持久化操作。

Hibernate的基本使用

使用Hibernate进行持久化操作的基本步骤包括创建SessionFactory、获取Session、开启事务、执行数据操作、提交事务和关闭Session。下面是一个更详细的示例，展示了如何使用Hibernate进行基本的CRUD操作。

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

public class HibernateCRUDExample {
    public static void main(String[] args) {
        // 创建SessionFactory
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

        // 获取Session
        Session session = sessionFactory.openSession();

        // 开启事务
        session.beginTransaction();

        // 创建对象并保存到数据库
        User user = new User();
        user.setName("Jane Doe");
        session.save(user);

        // 提交事务
        session.getTransaction().commit();

        // 关闭Session
        session.close();

        // 读取数据
        session = sessionFactory.openSession();
        session.beginTransaction();
        user = session.get(User.class, user.getId());
        System.out.println("User Name: " + user.getName());

        // 更新数据
        session = sessionFactory.openSession();
        session.beginTransaction();
        user.setName("Jane Smith");
        session.update(user);

        // 提交事务
        session.getTransaction().commit();

        // 关闭Session
        session.close();

        // 删除数据
        session = sessionFactory.openSession();
        session.beginTransaction();
        session.delete(user);

        // 提交事务
        session.getTransaction().commit();

        // 关闭Session
        session.close();
    }
}

在这个例子中，我们展示了如何使用Hibernate进行创建（Create）、读取（Read）、更新（Update）和删除（Delete）操作。通过Session对象的save、get、update和delete方法来实现这些操作。

MyBatis框架入门

MyBatis框架概述

MyBatis是一个持久层框架，它提供了相对简单的SQL映射，使得Java对象能够直接映射到数据库表。MyBatis使用XML或注解来配置SQL映射文件，通过这些配置文件将SQL语句映射到Java对象。

MyBatis的主要优点是灵活性高，支持动态SQL和复杂查询。它允许开发者编写自己的SQL语句，提供了丰富的API来处理数据库操作，使得数据库操作更加灵活和高效。

MyBatis的基本配置与使用

使用MyBatis的基本步骤包括配置MyBatis环境、编写SQL映射文件、编写Java代码来调用SQL映射文件中的SQL语句。

下面是一个简单的MyBatis配置文件mybatis-config.xml，它定义了数据库连接信息和映射文件的位置。

<configuration>
    <properties>
        <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"/>
    </properties>
    <typeAliases>
        <typeAlias alias="User" type="com.example.User"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/UserMapper.xml"/>
    </mappers>
</configuration>

接下来是一个简单的UserMapper.xml映射文件，它定义了SQL语句和对应的Java对象。

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

最后是Java代码，它使用MyBatis的SqlSessionFactory来执行SQL映射文件中的SQL语句。

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

public class MyBatisExample {
    public static void main(String[] args) {
        // 创建SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(MyBatisExample.class.getClassLoader().getResourceAsStream("mybatis-config.xml"));

        // 获取SqlSession
        try (SqlSession session = factory.openSession()) {
            // 执行SQL语句
            UserMapper mapper = session.getMapper(UserMapper.class);
            User user = mapper.selectUser(1);
            System.out.println("User Name: " + user.getName());

            // 更新数据
            user.setName("Jane Smith");
            mapper.updateUser(user);

            // 删除数据
            mapper.deleteUser(1);
        }
    }
}

在这个例子中，我们展示了如何使用MyBatis执行基本的查询、插入、更新和删除操作。通过SqlSession对象的getMapper方法获取到映射器接口，然后通过映射器接口的方法来执行数据库操作。

动态SQL与Mapper映射器

MyBatis支持动态SQL，使得可以灵活地编写复杂的SQL语句。通过条件标签（如if、where、foreach等）来实现动态SQL的构建。

下面是一个使用动态SQL的示例，展示了如何根据条件动态构建SQL语句。

<mapper namespace="com.example.UserMapper">
    <select id="selectUserByCondition" parameterType="java.util.Map" resultType="com.example.User">
        SELECT id, name FROM user
        <where>
            <if test="name != null">
                AND name = #{name}
            </if>
        </where>
    </select>
</mapper>

在这个例子中，我们定义了一个selectUserByCondition方法，它根据传入的Map参数中的name字段来动态构建SQL查询语句。如果name字段不为null，则在SQL语句中添加相应的条件。

Struts框架入门

Struts框架概述

Struts是一个基于MVC模式的Web应用程序框架，它提供了创建企业级Web应用程序的功能。Struts框架的核心是Struts ActionServlet，它负责处理HTTP请求并调用相应的Action对象来执行业务逻辑。

Struts框架的主要优点是模块化、可扩展性强，支持插件扩展，提供了丰富的标签库和过滤器等特性。Struts框架适用于大型企业级Web应用程序，能够处理复杂的业务逻辑和高并发访问。

Struts框架的基本结构

Struts框架采用了MVC（模型-视图-控制器）设计模式，其基本结构包括：

模型（Model）：负责处理业务逻辑和数据操作，通常由Action类实现。
视图（View）：负责显示数据，通常是JSP页面。
控制器（Controller）：负责处理用户请求并调用相应的Action对象，通常由ActionServlet（或者Struts2中的FilterDispatcher）实现。

Struts控制器的使用

下面是一个简单的Struts控制器示例，展示了如何处理HTTP请求并调用相应的Action对象。

首先，需要定义一个Action类，实现业务逻辑处理。

import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport {
    private String name;

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

    public String execute() throws Exception {
        return SUCCESS;
    }
}

接下来，需要在struts.xml配置文件中定义Action映射，将URL路径映射到具体的Action类。

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

最后，需要创建一个JSP页面来显示结果。

<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
    <title>Hello World</title>
</head>
<body>
    <h1>Hello World!</h1>
    <p>Welcome, ${name}!</p>
</body>
</html>

在这个例子中，我们定义了一个HelloWorldAction类，它实现了ActionSupport接口，并在execute方法中返回SUCCESS。在struts.xml配置文件中，我们将helloWorld路径映射到了HelloWorldAction，并使用JSP页面来显示结果。

实战案例：使用Spring和MyBatis构建简单项目

构建项目环境

在本节中，我们将使用Spring和MyBatis构建一个简单的项目，演示如何通过Spring的IoC容器管理MyBatis的SqlSessionFactory，并完成基本的数据访问操作。

假设我们已经创建了一个简单的Spring Boot项目，并已经添加了Spring和MyBatis的相关依赖。下面是一个简单的pom.xml文件示例，展示了如何引入Spring和MyBatis依赖。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.3</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.22</version>
    </dependency>
</dependencies>

实现基本功能

接下来，我们实现项目的基本功能，包括创建User实体类、MyBatis的映射文件、Spring的配置类和控制器。

User实体类

public class User {
    private int id;
    private String name;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

MyBatis映射文件（UserMapper.xml）

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

Spring配置类（UserMapperConfig）

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

@Configuration
@MapperScan("com.example")
public class UserMapperConfig {
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource());
        factoryBean.setMapperLocations(new ClassPathResource("com/example/UserMapper.xml"));
        return factoryBean.getObject();
    }
}

控制器（UserController）

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserMapper userMapper;

    @GetMapping("/{id}")
    public User getUserById(@PathVariable int id) {
        return userMapper.selectUser(id);
    }

    @PostMapping
    public User insertUser(@RequestBody User user) {
        userMapper.insertUser(user);
        return user;
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable int id, @RequestBody User user) {
        user.setId(id);
        userMapper.updateUser(user);
        return user;
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable int id) {
        userMapper.deleteUser(id);
    }
}

运行与调试

在本节中，我们将展示如何运行项目并调试基本功能。首先，确保数据库已经准备好了，创建一个名为user的表，并插入一些测试数据。

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

接下来，启动Spring Boot应用程序。可以通过IDE或命令行启动应用程序。

mvn spring-boot:run

启动后，可以通过访问http://localhost:8080/users/{id}来测试用户查询功能，通过http://localhost:8080/users来测试插入用户功能，通过http://localhost:8080/users/{id}来测试更新和删除用户功能。

例如，可以通过以下步骤测试插入用户功能：

向http://localhost:8080/users发送POST请求，请求体为：
```
{
    "id": 1,
    "name": "John Doe"
}
```
查看数据库中的user表，应该能看到新插入的用户数据。

通过以上步骤，我们可以验证Spring和MyBatis的集成，完成基本的数据访问操作。

总结

本文介绍了Java主流框架的基本概念、分类和选择方法，并详细介绍了Spring、Hibernate、MyBatis和Struts框架的入门和实践指南。通过这些框架的学习和实践，开发者能够更加高效地构建企业级Web应用程序，简化开发过程，提高开发质量和效率。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

紫衣仙女

手记
篇

粉丝

71

获赞与收藏

334

关注作者，订阅最新文章

相关文章推荐

Maven入门指南

Java Mybatis 框架入门教程

Java工程师学习指南（入门篇）

Java工程师学习指南（入门篇）

Java工程师学习指南入门篇

阅读免费教程

Java并发工具

23个小节 19133 310

Java 并发原理入门教程

26个小节 38736 565

Java 入门教程

50个小节 339380 3141

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空