Java主流框架入门教程-原创手记-慕课网

概述

本文介绍了Java主流框架的作用和重要性，详细讲解了Spring、Spring Boot和MyBatis等框架的基本概念和使用方法，帮助读者快速入门Java主流框架。文章还提供了这些框架的实际应用示例，帮助读者更好地理解和掌握相关技术。

Java主流框架概览

Java框架的作用和重要性

Java框架在Java开发中扮演着至关重要的角色。框架是一种半成品软件，它提供了可重用的代码结构，帮助开发者快速构建应用程序。使用框架可以帮助开发者避免重复造轮子，同时提高开发效率和代码的可维护性。除此之外，框架还常常提供了许多高级功能，比如事务管理、安全性、缓存等，这些都是单个开发者可能需要花费大量时间和精力才能实现的功能。

常见Java主流框架介绍

Spring框架

Spring框架是Java企业级开发中最广泛使用的开源框架之一。它由Rod Johnson在2003年发起，旨在简化企业级应用开发。Spring框架支持依赖注入（DI）和面向切面编程（AOP），并且提供了丰富的模块，涵盖了从基础的IoC容器到复杂的事务处理、数据库访问、安全控制等各个领域。

Spring Boot框架

Spring Boot是Spring框架的一个子项目，它简化了Spring应用的创建过程。Spring Boot旨在通过提供默认配置、自动配置等特性来减少开发者的配置工作，使得创建独立的、生产级别的基于Spring的应用变得更加简单。Spring Boot非常适合微服务架构，因为它能够快速地启动程序，并且很容易进行单元测试和集成测试。

MyBatis框架

MyBatis是一个优秀的持久层框架，它简化了使用关系数据库的操作，提供了一种更简单的方式来映射数据库表和对应的Java对象。MyBatis通过XML配置文件或注解的方式来描述如何处理SQL查询，并将结果映射到Java对象中。MyBatis非常适合需要高效处理数据库操作的应用场景。

Spring框架入门

Spring框架的基本概念

Spring框架的核心是Spring容器，它负责管理应用的所有对象，并通过控制这些对象之间的依赖关系来实现应用的配置和管理。Spring容器通过读取配置文件（XML或Java配置）来创建和管理Bean对象，从而实现了依赖注入（DI）和面向切面编程（AOP）等功能。

Spring IOC和AOP原理简介

依赖注入（DI）：依赖注入是Spring框架的核心特性之一。它将对象之间的依赖关系通过配置文件或注解方式注入到对象中，从而实现了对象之间的松耦合。这种设计使得代码更加灵活，易于维护和测试。
面向切面编程（AOP）：面向切面编程（AOP）是一种编程范式，它将横切关注点（如日志、事务管理等）从业务逻辑中分离出来。Spring框架通过代理模式实现了AOP。在Spring中，你可以定义一个切面，它包含多个通知（Before、After、Around等），这些通知可以在业务逻辑的方法执行之前、之后或者环绕执行。

创建第一个Spring应用实例

下面以一个简单的Spring应用为例，演示如何使用Spring框架进行基本的依赖注入。

项目结构

src/main/java/
    com/example/
        applicationContext.xml
        HelloWorld.java
        HelloWorldTest.java

HelloWorld.java

package com.example;

public class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Your Message : " + message);
    }
}

HelloWorldTest.java

package com.example;

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

public class HelloWorldTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
        helloWorld.getMessage();
    }
}

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="helloWorld" class="com.example.HelloWorld">
        <property name="message" value="Hello World"/>
    </bean>

</beans>

运行结果

Your Message : Hello World

Spring IOC和AOP原理代码示例

下面通过一个简单的代码示例展示如何实现依赖注入和面向切面编程。

HelloWorld.java（增加AOP示例）

package com.example;

public class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Your Message : " + message);
    }
}

HelloWorldTest.java（增加AOP示例）

package com.example;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;

@Component
public class HelloWorldTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
        helloWorld.getMessage();
    }
}

applicationContext.xml（增加AOP示例）

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

    <bean id="helloWorld" class="com.example.HelloWorld">
        <property name="message" value="Hello World"/>
    </bean>

    <aop:config>
        <aop:pointcut id="MyPointcut" expression="execution(* com.example.HelloWorld.getMessage(..))"/>
        <aop:aspect ref="myAspect">
            <aop:before method="doBefore" pointcut-ref="MyPointcut"/>
        </aop:aspect>
    </aop:config>

    <bean id="myAspect" class="com.example.MyAspect"/>
</beans>

MyAspect.java

package com.example;

public class MyAspect {
    public void doBefore() {
        System.out.println("Doing before advice");
    }
}

Spring Boot框架入门

Spring Boot的优势和特性

Spring Boot通过提供自动配置、起步依赖、内置的开发工具等特性，使得创建独立的、生产级别的基于Spring的应用变得更加简单。

自动配置：Spring Boot通过自动配置帮助开发者快速启动项目。它能够自动配置很多常用的功能，比如数据源、事务管理等，使开发者可以专注于业务逻辑的实现。
起步依赖：Spring Boot通过引入起步依赖（starter）来简化项目的配置。起步依赖是一个约定的jar包，它包含了开发中需要的所有依赖，开发者只需在pom.xml中添加相应的依赖，就可以快速搭建起一个Spring应用。
内置的开发工具：Spring Boot内置了开发工具（devtools），它能够自动地重新加载应用，使得开发过程更加高效。

创建Spring Boot项目的基本步骤

创建一个简单的Spring Boot应用，包括创建Spring Boot项目、配置基本设置、创建主类等步骤。

项目结构

src/main/java/
    com/example/myapp/
        MyApplication.java
src/main/resources/
    application.properties

MyApplication.java

package com.example.myapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

application.properties

server.port=8080

运行结果

2023-01-01 12:00:00.000 [main] INFO  o.s.b.SpringApplication - Application run complete

Spring Boot项目实战

下面将演示一个简单的Spring Boot应用，包括创建RESTful API和控制器。

MyApplication.java（添加一个控制器）

package com.example.myapp;

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 MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

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

访问API

通过访问http://localhost:8080/hello，可以看到返回结果为Hello, World!。

进一步的Spring Boot特性示例

在Spring Boot中，还可以通过添加更多的注解和配置来启用其他特性，比如健康检查、邮件发送等。下面展示如何通过添加JPA支持来实现数据库操作。

MyApplication.java（添加JPA支持）

package com.example.myapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.Bean;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@SpringBootApplication
@EntityScan(basePackages = "com.example.myapp.model")
@EnableJpaRepositories(basePackages = "com.example.myapp.repository")
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

User.java

package com.example.myapp.model;

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 Long id;
    private String name;
    private String email;

    // Getter and Setter
}

UserRepository.java

package com.example.myapp.repository;

import com.example.myapp.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

UserController.java

package com.example.myapp.controller;

import com.example.myapp.model.User;
import com.example.myapp.repository.UserRepository;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {
    private final UserRepository userRepository;

    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @GetMapping("/users")
    public List<User> getUsers() {
        return userRepository.findAll();
    }
}

MyBatis框架入门

MyBatis的工作原理

MyBatis通过XML配置文件或注解的方式来描述如何处理SQL查询，并将结果映射到Java对象中。MyBatis使用JDBC来执行SQL查询，并返回结果集，然后通过映射文件将结果集映射到Java对象中。

MyBatis的环境配置

要使用MyBatis，首先需要设置环境配置。环境配置包括数据库连接信息、映射文件位置、MyBatis配置文件等。

pom.xml

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

mybatis-config.xml

<configuration>
    <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="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/myapp/UserMapper.xml"/>
    </mappers>
</configuration>

UserMapper.xml

<mapper namespace="com.example.myapp.UserMapper">
    <select id="selectUser" resultType="com.example.myapp.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

使用MyBatis进行持久层开发

下面通过一个简单的例子演示如何使用MyBatis进行持久层开发。

User.java

package com.example.myapp;

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

    // Getter and Setter
}

UserMapper.java

package com.example.myapp;

import java.util.List;

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

UserMapperImpl.java

package com.example.myapp;

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 UserMapperImpl implements UserMapper {
    private SqlSessionFactory sqlSessionFactory;

    public UserMapperImpl() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }

    @Override
    public User selectUser(int id) {
        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);
            return mapper.selectUser(id);
        }
    }
}

测试代码

package com.example.myapp;

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 Main {
    public static void main(String[] args) throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.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());
        }
    }
}

其他主流框架简介

如何选择适合项目的框架

选择适合项目的框架要从项目的业务需求、技术栈、团队经验、开发效率等多方面考虑。通常，一个成熟的框架需要满足项目的业务需求，并且能够提供良好的性能、可扩展性、安全性等特性。此外，开发团队也需要考虑框架的学习曲线、社区支持、文档质量等因素。

Hibernate框架简介

Hibernate是一个ORM（对象关系映射）框架，它能够将Java对象映射到关系型数据库表中。Hibernate提供了一种透明的对象持久化机制，使得开发者可以专注于业务逻辑的实现，而无需关心底层的数据库操作。Hibernate还支持缓存、事务管理、查询缓存等高级特性，使得开发人员能够更加高效地进行数据库操作。

Hibernate简单示例

package com.example.myapp;

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();
        session.save(new User());
        session.getTransaction().commit();
        session.close();
        sessionFactory.close();
    }
}

Struts框架简介

Struts是一个成熟的MVC（模型-视图-控制器）框架，它能够帮助开发者快速构建Web应用。Struts通过提供一个插件体系结构来支持各种插件和扩展，使得开发者可以灵活地选择和使用各种功能。Struts还支持国际化、验证、国际化的标签库等特性，使得开发者能够更加方便地开发国际化应用。

Struts简单示例

package com.example.myapp;

import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport {
    private String message;

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

    public String getMessage() {
        return message;
    }
}

总结与进阶方向

常见问题解答

Spring和Spring Boot的区别是什么？
Spring是一个全面的企业级应用框架，提供了IoC容器、AOP等功能，而Spring Boot则是Spring的一个子项目，它简化了Spring应用的创建过程，提供了自动配置、起步依赖等功能。
MyBatis和Hibernate有什么区别？
MyBatis是一个持久层框架，它通过XML配置文件或注解来描述如何处理SQL查询，并将结果映射到Java对象中。Hibernate是一个ORM框架，它能够将Java对象映射到关系型数据库表中。
如何提高Spring Boot应用的性能？
提高Spring Boot应用的性能可以通过优化配置、使用缓存、减少数据库查询等方法来实现。

进一步学习资源推荐

官方网站和文档
Spring官网：https://spring.io/
Spring Boot官网：https://spring.io/projects/spring-boot
MyBatis官网：https://mybatis.org/mybatis-3/zh/index.html
慕课网
慕课网提供了丰富的Spring框架、Spring Boot框架、MyBatis框架等课程资源，帮助开发者提高技能。
社区和技术论坛
Stack Overflow、Reddit的Java和Spring社区等都是不错的技术论坛，开发者可以在这些社区里提问、交流，或者寻找答案。