首页手记 Java主流框架入门教程

Java主流框架入门教程

标签：

Java Spring

本文介绍了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慕课网进行。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕侠2389804

手记
篇

粉丝

55

获赞与收藏

156

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340925 3155

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Java主流框架入门教程

框架的优势

常见的Java框架介绍

Spring框架入门

Spring框架简介

Spring框架基本概念

Spring框架的安装与配置

Spring框架实例操作

完整的Spring博客系统实例

MyBatis框架简介

MyBatis框架基本概念

MyBatis框架的安装与配置

MyBatis框架实例操作

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

Hibernate框架简介

Hibernate框架基本概念

Hibernate框架的安装与配置

Hibernate框架实例操作

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

Struts框架简介

Struts框架基本概念

Struts框架的安装与配置

Struts框架实例操作

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

框架之间的比较

实践项目建议

进一步学习的方向

阅读免费教程