Java主流框架入门教程

本文主要是介绍Java主流框架入门教程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

本文介绍了Java主流框架入门的详细内容，涵盖了Spring、MyBatis、Hibernate和Struts等框架的基本概念、安装配置和实例操作。通过本文，读者可以了解这些框架的核心特性和应用场景。文章还提供了实践项目建议，帮助读者进一步巩固所学知识。Java主流框架入门教程旨在帮助开发者高效地使用这些框架进行应用开发。

Java框架概述

Java框架是为了解决特定领域（如Web开发、数据库操作、企业应用等）中的常见问题而设计的库。这些框架提供了可重用的组件和预定义的结构，能够帮助开发人员高效地开发和维护软件应用程序。Java框架通常基于特定的编程模式和设计原则，如面向对象编程、MVC设计模式等。

框架的优势

减少重复代码：通过提供现成的解决方案，框架避免了开发人员重复编写相同的功能代码。
提高开发效率：使用框架可以加速项目的开发进度，提高开发效率。
提高代码质量：框架通常经过了广泛的测试和优化，使用框架可以提高代码质量。
易于维护：由于框架提供了统一的结构和接口，维护和升级现有的应用程序变得更加容易。

常见的Java框架介绍

Spring：Spring是一个轻量级框架，它通过依赖注入实现了轻松的IoC（Inversion of Control）管理。
MyBatis：MyBatis是一个持久层框架，它简化了数据库操作，允许开发人员使用简单的SQL语句来处理数据库中的数据。
Hibernate：Hibernate是一个持久层框架，它简化了数据库操作，提供了强大的对象关系映射功能。
Struts：Struts是一个MVC框架，用于构建Web应用程序，它支持松耦合的、基于组件的设计。

接下来我们将逐一介绍这些框架的基础知识和使用方法。

Spring框架入门

Spring框架简介

Spring框架是一个开源的轻量级Java开发框架，它提供了一个易于使用的IoC（Inversion of Control）容器、AOP（Aspect-Oriented Programming）支持、事务管理，以及与其他框架集成的能力。Spring框架在企业级应用开发中扮演着重要角色。

Spring框架基本概念

IoC（控制反转）：通过容器管理对象的依赖关系，而不是在程序代码中直接创建对象。
DI（依赖注入）：将对象的依赖关系由容器注入，而不是在代码中直接创建依赖对象。
AOP（面向切面编程）：允许将通用功能（如事务管理、日志记录等）以切面的形式应用到业务逻辑中。

Spring框架的安装与配置

安装Spring框架，需要在项目中导入Spring的核心库和其他相关库。这里以Maven项目为例，首先在项目的pom.xml文件中添加Spring依赖。

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.10</version>
    </dependency>
    <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框架实例操作

以下是一个简单的Spring IoC容器示例。我们将定义一个Person类和一个依赖于Person的HelloWorld类。

package com.example.demo;

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

package com.example.demo;

public class HelloWorld {
    private Person person;

    public HelloWorld(Person person) {
        this.person = person;
    }

    public void sayHello() {
        System.out.println("Hello " + person.getName());
    }
}

接下来，我们使用Spring配置文件来管理这些对象的依赖关系。

<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="person" class="com.example.demo.Person">
        <constructor-arg>
            <value>John Doe</value>
        </constructor-arg>
    </bean>

    <bean id="helloWorld" class="com.example.demo.HelloWorld">
        <constructor-arg ref="person"/>
    </bean>
</beans>

最后，我们创建一个测试类来验证配置是否正确。

package com.example.demo;

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

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        HelloWorld helloWorld = context.getBean("helloWorld", HelloWorld.class);
        helloWorld.sayHello();
    }
}

我们来构建一个完整的Spring项目实例，该实例将展示如何使用Spring框架创建一个简单的博客系统。

完整的Spring博客系统实例

定义一个BlogPost实体类。

package com.example.demo;

public class BlogPost {
    private int id;
    private String title;
    private String content;

    public BlogPost(int id, String title, String content) {
        this.id = id;
        this.title = title;
        this.content = content;
    }

    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 getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

定义一个BlogPostService接口和实现类。

package com.example.demo;

public interface BlogPostService {
    void addBlogPost(BlogPost post);
}

package com.example.demo;

import org.springframework.stereotype.Service;

@Service
public class BlogPostServiceImpl implements BlogPostService {
    @Override
    public void addBlogPost(BlogPost post) {
        System.out.println("Adding blog post: " + post.getTitle());
    }
}

配置Spring的applicationContext.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="blogPostService" class="com.example.demo.BlogPostServiceImpl"/>
</beans>

创建一个测试类来验证配置是否正确。

package com.example.demo;

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

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        BlogPostService blogPostService = context.getBean("blogPostService", BlogPostService.class);
        BlogPost post = new BlogPost(1, "First Post", "This is my first blog post.");
        blogPostService.addBlogPost(post);
    }
}

运行上述代码，将输出Adding blog post: First Post，表明Spring成功地创建了对象并管理了它们之间的依赖关系。

MyBatis框架入门

MyBatis框架简介

MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis避免了大多数ORM框架的性能问题，能够将接口和Java的POJO（Plain Old Java Objects）映射成数据库中的记录。

MyBatis框架基本概念

Mapper接口：MyBatis定义了Mapper接口，用于编写SQL语句。
XML配置文件：通过XML配置文件可以更好地控制SQL语句的执行。
SQL映射文件：将SQL语句映射到Java类的方法中。

MyBatis框架的安装与配置

在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.23</version>
    </dependency>
</dependencies>

配置数据库连接信息。

<bean id="dataSource"
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydatabase"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
</bean>

MyBatis的核心配置文件mybatis-config.xml。

<configuration>
    <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/demo/UserMapper.xml"/>
    </mappers>
</configuration>

MyBatis框架实例操作

定义一个User实体类。

package com.example.demo;

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

    public User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // Getters and Setters
}

定义一个UserMapper接口。

package com.example.demo;

public interface UserMapper {
    User getUserById(int id);
}

编写对应的SQL映射文件UserMapper.xml。

<mapper namespace="com.example.demo.UserMapper">
    <select id="getUserById" resultType="com.example.demo.User">
        SELECT id, name, email FROM users WHERE id = #{id}
    </select>
</mapper>

编写测试代码。

package com.example.demo;

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

import java.io.IOException;
import java.io.InputStream;

public class App {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);
            User user = mapper.getUserById(1);
            System.out.println(user);
        }
    }
}

我们来构建一个完整的MyBatis项目实例，该实例将展示如何使用MyBatis创建一个简单的图书管理系统。

完整的MyBatis图书管理系统实例

定义一个Book实体类。

package com.example.demo;

public class Book {
    private int id;
    private String title;
    private String author;

    public Book(int id, String title, String author) {
        this.id = id;
        this.title = title;
        this.author = author;
    }

    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;
    }
}

定义一个BookMapper接口。

package com.example.demo;

public interface BookMapper {
    Book getBookById(int id);
}

编写对应的SQL映射文件BookMapper.xml。

<mapper namespace="com.example.demo.BookMapper">
    <select id="getBookById" resultType="com.example.demo.Book">
        SELECT id, title, author FROM books WHERE id = #{id}
    </select>
</mapper>

编写测试代码。

package com.example.demo;

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

import java.io.IOException;
import java.io.InputStream;

public class App {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            BookMapper mapper = session.getMapper(BookMapper.class);
            Book book = mapper.getBookById(1);
            System.out.println(book);
        }
    }
}

运行上述代码，将查询数据库中的books表，并输出查询到的图书记录。

Hibernate框架入门

Hibernate框架简介

Hibernate是一个强大的持久层框架，它提供了对象关系映射（ORM）的功能，使得Java对象可以透明地映射到关系数据库中。Hibernate简化了数据库操作，提供了强大的查询语言（HQL）。

Hibernate框架基本概念

实体类：定义数据库表对应的Java类。
映射文件：定义实体类与数据库表之间的映射关系。
配置文件：定义数据库连接信息等。

Hibernate框架的安装与配置

在Maven项目中，需要在pom.xml中添加Hibernate依赖。

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

配置数据库连接信息。

hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class=com.mysql.cj.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost:3306/mydatabase
hibernate.connection.username=root
hibernate.connection.password=password
hibernate.show_sql=true

Hibernate框架实例操作

定义一个User实体类。

package com.example.demo;

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

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String email;

    // Getters and Setters
}

创建映射文件User.hbm.xml。

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

编写测试代码。

package com.example.demo;

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

public class App {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration()
                .addAnnotatedClass(User.class)
                .addResource("User.hbm.xml")
                .setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLDialect")
                .setProperty("hibernate.connection.driver_class", "com.mysql.cj.jdbc.Driver")
                .setProperty("hibernate.connection.url", "jdbc:mysql://localhost:3306/mydatabase")
                .setProperty("hibernate.connection.username", "root")
                .setProperty("hibernate.connection.password", "password")
                .setProperty("hibernate.show_sql", "true")
                .buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();

        User user = new User();
        user.setName("John Doe");
        user.setEmail("john.doe@example.com");

        session.save(user);
        transaction.commit();
        session.close();
        sessionFactory.close();
    }
}

我们来构建一个完整的Hibernate项目实例，该实例将展示如何使用Hibernate创建一个简单的电子商务系统。

完整的Hibernate电子商务系统实例

定义一个Product实体类。

package com.example.demo;

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

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String description;
    private double price;

    // Getters and Setters
}

创建映射文件Product.hbm.xml。

<hibernate-mapping>
    <class name="com.example.demo.Product" table="products">
        <id name="id" type="int" column="id">
            <generator class="assigned"/>
        </id>
        <property name="name" column="name"/>
        <property name="description" column="description"/>
        <property name="price" column="price"/>
    </class>
</hibernate-mapping>

编写测试代码。

package com.example.demo;

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

public class App {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration()
                .addAnnotatedClass(Product.class)
                .addResource("Product.hbm.xml")
                .setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLDialect")
                .setProperty("hibernate.connection.driver_class", "com.mysql.cj.jdbc.Driver")
                .setProperty("hibernate.connection.url", "jdbc:mysql://localhost:3306/mydatabase")
                .setProperty("hibernate.connection.username", "root")
                .setProperty("hibernate.connection.password", "password")
                .setProperty("hibernate.show_sql", "true")
                .buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();

        Product product = new Product();
        product.setName("Laptop");
        product.setDescription("High performance laptop.");
        product.setPrice(999.99);

        session.save(product);
        transaction.commit();
        session.close();
        sessionFactory.close();
    }
}

运行上述代码，将向数据库中的products表插入一条新记录。

Struts框架入门

Struts框架简介

Struts是一个开源的、基于Java的Web应用框架，主要用于构建基于MVC（Model-View-Controller）模式的Web应用程序。Struts提供了强大的标签库、插件和扩展，支持快速开发。

Struts框架基本概念

Action：处理用户的请求，执行业务逻辑。
ActionForm：封装表单数据。
ActionMapping：定义请求与Action之间的映射关系。
ActionServlet：处理请求的控制中心。
Struts配置文件：定义各种映射和配置信息。

Struts框架的安装与配置

在Maven项目中，需要在pom.xml中添加Struts依赖。

<dependencies>
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-core</artifactId>
        <version>2.5.21</version>
    </dependency>
</dependencies>

配置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>

Struts框架实例操作

定义一个UserAction类。

package com.example.demo;

import com.opensymphony.xwork2.ActionSupport;

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

    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;
    }

    public String execute() {
        System.out.println("Name: " + name);
        System.out.println("Email: " + email);
        return SUCCESS;
    }
}

定义一个JSP页面index.jsp。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Login Form</title>
</head>
<body>
<form action="UserAction" method="post">
    Name: <input type="text" name="name"/><br/>
    Email: <input type="text" name="email"/><br/>
    <input type="submit" value="Submit"/>
</form>
</body>
</html>

配置Struts的struts.xml文件。

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

创建一个成功页面success.jsp。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Success</title>
</head>
<body>
<h1>Success!</h1>
</body>
</html>

我们来构建一个完整的Struts项目实例，该实例将展示如何使用Struts创建一个简单的用户管理系统。

完整的Struts用户管理系统实例

定义一个UserAction类。

package com.example.demo;

import com.opensymphony.xwork2.ActionSupport;

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

    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;
    }

    public String execute() {
        System.out.println("Name: " + name);
        System.out.println("Email: " + email);
        return SUCCESS;
    }
}

定义一个UserForm类。

package com.example.demo;

import com.opensymphony.xwork2.validator.ValidationAwareSupport;

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

    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;
    }
}

定义一个JSP页面index.jsp。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Login Form</title>
</head>
<body>
<form action="UserAction" method="post">
    Name: <input type="text" name="name"/><br/>
    Email: <input type="text" name="email"/><br/>
    <input type="submit" value="Submit"/>
</form>
</body>
</html>

配置Struts的struts.xml文件。

<struts>
    <package name="default" namespace="/" extends="struts-default">
        <action name="UserAction" class="com.example.demo.UserAction">
            <interceptor-ref name="defaultStack"/>
            <result name="success">/success.jsp</result>
            <result name="input">/index.jsp</result>
        </action>
    </package>
</struts>

创建一个成功页面success.jsp。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Success</title>
</head>
<body>
<h1>User registered successfully!</h1>
</body>
</html>

运行应用程序，访问index.jsp页面，输入表单数据并提交，将调用UserAction类的execute方法，并输出表单数据，同时跳转到成功页面。

总结与实践

框架之间的比较

Spring：Spring框架主要关注IoC和依赖注入，提供了丰富的功能和支持，如AOP、事务管理、Web框架等。
MyBatis：MyBatis主要关注数据库操作，提供了强大的SQL映射功能，支持自定义SQL和存储过程。
Hibernate：Hibernate提供了强大的ORM功能，简化了数据库操作，并提供了强大的查询语言（HQL）。
Struts：Struts是一个Web框架，主要关注MVC模式，提供了丰富的标签库、插件和扩展。

实践项目建议

基于Spring的Web应用：可以尝试构建一个简单的博客系统，使用Spring的IoC容器管理和依赖注入。
基于MyBatis的数据库操作：可以尝试构建一个简单的图书管理系统，使用MyBatis进行数据库操作。
基于Hibernate的ORM：可以尝试构建一个简单的电子商务系统，使用Hibernate进行数据持久化。
基于Struts的Web应用：可以尝试构建一个简单的用户管理系统，使用Struts进行表单处理和页面跳转。

进一步学习的方向

深入学习Spring：了解Spring的高级特性，如Spring Boot、Spring Data等。
深入学习MyBatis：了解MyBatis的动态SQL、缓存机制等高级特性。
深入学习Hibernate：了解Hibernate的查询语言（HQL）、实体关系映射等高级特性。
深入学习Struts：了解Struts的插件和扩展，如Struts2-i18n、Struts2-Security等。

以上是关于Java主流框架入门教程的详细介绍，通过本文，读者可以了解并掌握Spring、MyBatis、Hibernate和Struts框架的基本使用方法和应用场景。希望读者能够通过实践项目进一步巩固所学知识，并继续深入学习相关框架的高级特性和最佳实践。

更多关于Java的编程学习可以在M慕课网进行。

这篇关于Java主流框架入门教程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！