手记

Java主流框架实战：初学者必备指南

潇潇雨雨
2024-10-31 18:15:35浏览 75
概述

Java主流框架实战涵盖了Spring、MyBatis、Hibernate等框架的入门知识和实战案例，旨在帮助初学者快速掌握这些主流框架的核心概念和实际应用。本文详细介绍了每个框架的基本配置和使用方法，并通过用户管理系统实战案例，加深读者对框架的理解和应用能力。

Java主流框架实战：初学者必备指南

1. Java基础回顾

1.1 Java语言简介

Java是一种广泛使用的面向对象编程语言，由James Gosling在Sun Microsystems开发，如今由Oracle公司维护。Java语言设计的特点包括“一次编写，到处运行”，具有良好的跨平台特性。Java的主要优势包括内存管理、强大的类库支持、跨平台开发等。

1.2 Java编程环境搭建

要开始使用Java编程，首先需要安装Java开发工具包（JDK），然后配置环境变量。以下是安装JDK和配置环境变量的步骤：

  1. 下载JDK：

    • 访问Oracle官方网站的Java下载页面或使用开源替代品如OpenJDK。
    • 根据操作系统选择合适的版本进行下载。

  2. 安装JDK：

    • 执行安装文件，按照提示完成安装。
    • 安装过程中，确保安装路径正确。
    • 安装完成后，系统会自动将JDK的bin目录添加到环境变量中。

  3. 配置环境变量：

    • 打开系统环境变量设置窗口，例如在Windows中可以通过“控制面板 -> 系统 -> 高级系统设置 -> 环境变量”。
    • 在“系统变量”区域添加新的环境变量：
      • JAVA_HOME：设置为JDK的安装目录，例如C:\Program Files\Java\jdk-17.0.1。
      • PATH：在原有的值后添加;%JAVA_HOME%\bin，确保JDK的bin目录在系统搜索路径中。
  4. 验证安装：
    • 打开命令行工具，输入java -version和javac -version命令来验证安装是否成功。
    • 如果安装成功，命令行会显示Java版本信息。

1.3 Java基础语法复习

1.3.1 变量与类型

在Java中，变量用于存储数据。Java支持多种基本数据类型，包括整型、浮点型、字符型和布尔型。以下是一些基本数据类型的示例代码：

public class DataTypes {
    public static void main(String[] args) {
        // 整型
        int num1 = 10;
        long num2 = 1234567890L;
        short num3 = 123;
        byte num4 = 127;

        // 浮点型
        float flt1 = 3.14f;
        double flt2 = 3.14;

        // 字符型
        char ch1 = 'A';
        char ch2 = '\u0041'; // Unicode编码

        // 布尔型
        boolean bool1 = true;
        boolean bool2 = false;

        System.out.println("整型: " + num1 + " " + num2 + " " + num3 + " " + num4);
        System.out.println("浮点型: " + flt1 + " " + flt2);
        System.out.println("字符型: " + ch1 + " " + ch2);
        System.out.println("布尔型: " + bool1 + " " + bool2);
    }
}

1.3.2 控制流

Java支持多种控制流，包括if-else、switch、for、while和do-while循环。以下是一些控制流的示例代码：

public class ControlFlow {
    public static void main(String[] args) {
        // if-else
        int num = 10;
        if (num < 0) {
            System.out.println("num is less than 0");
        } else if (num > 0) {
            System.out.println("num is greater than 0");
        } else {
            System.out.println("num is 0");
        }

        // switch
        String day = "Monday";
        switch (day) {
            case "Monday":
                System.out.println("It's Monday");
                break;
            case "Tuesday":
                System.out.println("It's Tuesday");
                break;
            default:
                System.out.println("It's not Monday or Tuesday");
        }

        // for loop
        for (int i = 0; i < 5; i++) {
            System.out.println("for loop: " + i);
        }

        // while loop
        int j = 0;
        while (j < 5) {
            System.out.println("while loop: " + j);
            j++;
        }

        // do-while loop
        int k = 0;
        do {
            System.out.println("do-while loop: " + k);
            k++;
        } while (k < 5);
    }
}

1.3.3 数组

Java中的数组用于存储相同类型的数据。以下是一些数组的示例代码：

public class Arrays {
    public static void main(String[] args) {
        // 声明一个整型数组
        int[] nums = new int[5];
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;

        // 遍历数组
        for (int i = 0; i < nums.length; i++) {
            System.out.println("数组元素: " + nums[i]);
        }

        // 声明一个字符数组
        char[] chars = new char[] {'a', 'b', 'c', 'd', 'e'};
        for (char c : chars) {
            System.out.println("字符数组元素: " + c);
        }
    }
}

1.3.4 类与对象

Java是一种面向对象的编程语言，主要通过类和对象来进行程序设计。以下是一个简单的类和对象的示例代码：

public class Student {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 成员方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // toString方法重写
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Student student = new Student("张三", 20);
        System.out.println("学生信息: " + student);

        // 修改属性
        student.setName("李四");
        student.setAge(22);
        System.out.println("更新后学生信息: " + student);
    }
}

2. Spring框架入门

2.1 Spring框架介绍

Spring框架是Java领域最流行的框架之一，由Rod Johnson在2003年创建。Spring框架旨在简化Java开发，提供了一组全面的解决方案，从面向对象的设计模式到企业级开发的最佳实践。Spring框架的核心是依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP），这些核心特性使得Spring框架成为一个强大的企业级开发框架。

2.2 Spring项目搭建

搭建一个Spring项目，需要首先通过 Maven 或 Gradle 等构建工具来管理项目依赖，并通过Spring的配置文件来配置应用所需的Bean。以下是使用Maven构建一个Spring项目的步骤：

  1. 创建Maven项目：

    • 使用Maven创建一个新的Java项目，打开命令行窗口，输入以下命令： 
      mvn archetype:generate -DgroupId=com.example -DartifactId=springApp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
    • 这个命令会创建一个新的Maven项目，项目结构如下： 
      springApp/
├── pom.xml
└── src
  ├── main
  │   ├── java
  │   │   └── com
  │   │       └── example
  │   │           └── App.java
  │   └── resources
  └── test
      └── java
          └── com
              └── example
                  └── AppTest.java

  2. 配置依赖：

    • 在项目的pom.xml文件中添加Spring的依赖： 
      <dependencies>
  <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>
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.3.10</version>
  </dependency>
</dependencies>

  3. 配置Spring容器：

    • 在src/main/resources目录下创建一个applicationContext.xml文件，定义Spring Bean：

      <?xml version="1.0" encoding="UTF-8"?>
<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 -->
  <bean id="messagePrinter" class="com.example.MessagePrinter">
      <property name="message" value="Hello, Spring!"/>
  </bean>

</beans>

  4. 创建Bean：

    • 在src/main/java/com/example目录下创建MessagePrinter.java类：

      package com.example;

public class MessagePrinter {
  private String message;

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

  public void printMessage() {
      System.out.println(message);
  }
}

  5. 运行测试：

    • 在主类App.java中，通过Spring容器获取Bean并调用方法：

      package com.example;

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");
      MessagePrinter printer = (MessagePrinter) context.getBean("messagePrinter");
      printer.printMessage();
  }
}

2.3 Spring核心模块详解

Spring框架的核心模块包括Spring Context、Spring Beans、Spring Core等。以下是这些模块的详细解释：

  • Spring Context：提供了配置文件解析、依赖注入、事件处理等功能。
  • Spring Beans：提供Bean的生命周期管理和依赖注入等功能。
  • Spring Core：提供IoC容器和依赖注入等功能。

这些核心模块通过配置文件或者注解的方式，实现了对Bean的管理。以下是一个简单的示例代码，展示了如何通过配置文件来定义Bean及其依赖关系：

<?xml version="1.0" encoding="UTF-8"?>
<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="messagePrinter" class="com.example.MessagePrinter">
        <property name="message" value="Hello, Spring!"/>
    </bean>

    <bean id="userService" class="com.example.UserService">
        <property name="messagePrinter" ref="messagePrinter"/>
    </bean>

</beans>

在上面的配置文件中，定义了两个Bean，一个是MessagePrinter，另一个是UserService。UserService依赖于MessagePrinter，通过ref属性引用messagePrinter Bean。

3. MyBatis框架入门

3.1 MyBatis框架介绍

MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了典型的基于对象/关系映射的繁琐，它通过XML配置文件或注解来灵活配置SQL映射语句，使得数据库操作变得更加简单和高效。

3.2 MyBatis环境配置

要开始使用MyBatis，首先需要在项目中引入MyBatis的依赖，并配置MyBatis的核心配置文件。

  1. 引入MyBatis依赖：

    • 在Maven项目的pom.xml文件中添加MyBatis的依赖： 
      <dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.6</version>
</dependency>

  2. 配置MyBatis核心配置文件：

    • 在src/main/resources目录下创建mybatis-config.xml文件，配置MyBatis的核心设置，例如数据源配置、事务管理器配置等： 
      <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<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>
  3. 创建Mapper XML文件：
    • 在src/main/resources目录下创建UserMapper.xml文件，定义SQL语句与Java对象之间的映射关系： 
      <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
  <select id="selectUserById" resultType="com.example.User">
      SELECT id, name, email FROM user WHERE id = #{id}
  </select>
</mapper>

3.3 MyBatis常用标签与注解

MyBatis提供了多种标签和注解来定义SQL映射语句，以下是一些常用的标签和注解：

  1. <select>标签：用于查询数据库中的数据。
  2. <insert>标签：用于插入新的数据记录。
  3. <update>标签：用于更新数据库中的数据记录。
  4. <delete>标签：用于删除数据库中的数据记录。
  5. <resultMap>标签：用于定义结果映射，将数据库查询结果映射到Java对象。
  6. 注解：如@Select、@Insert、@Update、@Delete等，用于在Java代码中直接定义SQL语句。

以下是一个使用注解的示例代码：

package com.example;

import org.apache.ibatis.annotations.Select;

public interface UserMapper {
    @Select("SELECT id, name, email FROM user WHERE id = #{id}")
    User selectUserById(int id);
}

4. Hibernate框架入门

4.1 Hibernate框架介绍

Hibernate是Java领域中一个非常流行的持久层框架，它提供了一套ORM（对象关系映射）解决方案，使得开发者可以将Java对象映射到关系数据库中，从而简化了数据库操作。Hibernate通过XML配置文件或注解来定义对象与数据库表之间的映射关系，从而实现了自动化的数据库操作。

4.2 Hibernate环境配置

要开始使用Hibernate，首先需要在项目中引入Hibernate的依赖，并配置Hibernate的核心配置文件。

  1. 引入Hibernate依赖：

    • 在Maven项目的pom.xml文件中添加Hibernate的依赖： 
      <dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>5.6.1.Final</version>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>8.0.29</version>
</dependency>

  2. 配置Hibernate核心配置文件：

    • 在src/main/resources目录下创建hibernate.cfg.xml文件，配置Hibernate的核心设置，例如数据源配置、持久化类配置等： 
      <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
  "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
  <session-factory>
      <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
      <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.hbm2ddl.auto">update</property>
      <mapping resource="com/example/User.hbm.xml"/>
  </session-factory>
</hibernate-configuration>
  3. 创建映射文件：
    • 在src/main/resources目录下创建User.hbm.xml文件，定义Java对象与数据库表之间的映射关系： 
      <hibernate-mapping>
  <class name="com.example.User" table="user">
      <id name="id" column="id">
          <generator class="native"/>
      </id>
      <property name="name" column="name"/>
      <property name="email" column="email"/>
  </class>
</hibernate-mapping>

4.3 Hibernate对象状态管理

Hibernate通过Session对象来管理对象的状态，主要包括以下几种状态：

  • 瞬时状态（Transient）：对象已经被实例化，但是还没有保存到数据库中。
  • 持久化状态（Persistent）：对象已经被保存到数据库中，与数据库中的记录相对应。
  • 游离状态（Detached）：对象曾经是持久化的，但是已经与数据库会话断开连接。

以下是一个使用Hibernate进行对象状态管理的示例代码：

package com.example;

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

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("张三");
        user.setEmail("zhangsan@example.com");
        session.save(user);
        session.getTransaction().commit();

        // 游离状态
        session.close();
        user.setName("李四");

        // 瞬时状态
        StatelessSession statelessSession = sessionFactory.openStatelessSession();
        statelessSession.beginTransaction();
        User newUser = new User();
        newUser.setName("王五");
        newUser.setEmail("wangwu@example.com");
        statelessSession.insert(newUser);
        statelessSession.getTransaction().commit();

        // 关闭Session
        statelessSession.close();
        sessionFactory.close();
    }
}

5. Spring Boot快速搭建项目

5.1 Spring Boot简介

Spring Boot是Spring生态系统中的一个子项目，旨在简化新Spring应用的初始搭建以及开发过程。Spring Boot通过提供默认配置和约定优于配置的原则，使得开发者能够快速搭建起一个完整的Spring应用。Spring Boot还支持自动配置、嵌入式Servlet容器、起步依赖、整合Spring Cloud等功能，为开发者提供了极大的便利。

5.2 Spring Boot项目搭建

要开始使用Spring Boot，首先需要创建一个Spring Boot项目，然后配置Spring Boot的核心配置文件和启动类。

  1. 创建Spring Boot项目：

    • 使用Spring Initializr或Maven插件，创建一个新的Spring Boot项目。
    • 在命令行中使用Spring Initializr插件： 
      mvn io.spring initializr-maven-plugin:run
    • 在Maven项目的pom.xml文件中添加Spring Boot的依赖： 
      <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.6.8</version>
</parent>
<dependencies>
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
</dependencies>

  2. 配置Spring Boot核心配置文件：

    • 在src/main/resources目录下创建application.properties或application.yml文件，配置Spring Boot的核心设置，例如端口号、数据源配置等： 
      server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password

  3. 创建启动类：

    • 在src/main/java目录下创建一个启动类，使用@SpringBootApplication注解定义主程序入口：

      package com.example;

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

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

5.3 Spring Boot常用注解与配置

Spring Boot提供了多种注解来简化应用的开发过程，以下是一些常用的注解：

  • @SpringBootApplication：组合注解，包含了@Configuration、@EnableAutoConfiguration和@ComponentScan。
  • @RestController：用于定义RESTful风格的控制器。
  • @GetMapping：用于定义处理HTTP GET请求的方法。
  • @PostMapping：用于定义处理HTTP POST请求的方法。
  • @Service：用于标记服务层的组件。
  • @Repository：用于标记持久层的组件。
  • @Autowired：用于自动装配依赖的组件。

以下是一个简单的Spring Boot控制器示例代码：

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }
}

6. 实战案例：用户管理系统

6.1 项目需求分析

本项目的目标是实现一个简单的用户管理系统，用户管理功能包括用户注册、登录、修改个人信息、查看用户信息等。系统需要支持数据库存储和查询操作，并具有用户身份验证功能。

6.2 项目结构设计

项目结构设计如下：

  • src/main/java/com/example：存放Java源代码文件，包括控制器、服务层、持久层等。
  • src/main/resources：存放资源配置文件，包括Spring Boot的核心配置文件、MyBatis或Hibernate的映射文件等。
  • src/main/resources/templates：存放Thymeleaf模板文件，用于渲染HTML页面。
  • src/main/resources/static：存放静态资源文件，如CSS、JavaScript等。

6.3 项目实现与调试

项目实现过程中，需要完成以下主要任务：

  1. 定义用户实体类：

    • 在src/main/java/com/example目录下创建User.java类，定义用户实体：

      package com.example;

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

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

  public String getEmail() {
      return email;
  }

  public void setEmail(String email) {
      this.email = email;
  }

  public String getPassword() {
      return password;
  }

  public void setPassword(String password) {
      this.password = password;
  }
}

  2. 创建用户持久层接口：

    • 在src/main/java/com/example目录下创建UserRepository.java接口，定义用户持久层操作：

      package com.example;

import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Integer> {
  User findByEmail(String email);
}

  3. 创建用户服务层接口和实现类：

    • 在src/main/java/com/example目录下创建UserService.java接口：

      package com.example;

import java.util.List;

public interface UserService {
  List<User> getAllUsers();
  User getUserByEmail(String email);
}

    • 创建UserServiceImp.java实现类：

      package com.example;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImp implements UserService {
  @Autowired
  private UserRepository userRepository;

  @Override
  public List<User> getAllUsers() {
      return userRepository.findAll();
  }

  @Override
  public User getUserByEmail(String email) {
      return userRepository.findByEmail(email);
  }
}

  4. 创建用户控制器：

    • 在src/main/java/com/example目录下创建UserController.java类：

      package com.example;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

@RestController
@RequestMapping("/users")
public class UserController {
  @Autowired
  private UserService userService;

  @GetMapping
  public List<User> getAllUsers() {
      return userService.getAllUsers();
  }

  @GetMapping("/email")
  public User getUserByEmail(@RequestParam String email) {
      return userService.getUserByEmail(email);
  }

  @PostMapping
  public void addUser(@RequestParam String name, @RequestParam String email, @RequestParam String password) {
      User user = new User();
      user.setName(name);
      user.setEmail(email);
      user.setPassword(password);
      userService.addUser(user);
  }
}

  5. 配置Spring Boot核心配置文件：

    • 在src/main/resources目录下编辑application.properties文件，配置数据库连接信息： 
      spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password

  6. 数据库表创建：

    • 使用MySQL命令行工具或图形化工具创建user表： 
      CREATE TABLE user (
  id INT AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  email VARCHAR(255) NOT NULL UNIQUE,
  password VARCHAR(255) NOT NULL
);

  7. 启动项目并调试：

    • 运行项目启动类Application.java，确保服务正常启动：

      package com.example;

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

@SpringBootApplication
public class Application {
  public static void main(String[] args) {
      SpringApplication.run(Application.class, args);
  }
}
    • 使用Postman或浏览器访问http://localhost:8080/users，查看用户列表。
    • 使用Postman或浏览器访问http://localhost:8080/users/email?email=example@email.com，查看指定邮箱的用户信息。
    • 使用Postman或浏览器访问http://localhost:8080/users并发送POST请求，添加用户。

通过以上步骤，一个简单的用户管理系统就搭建完成了。你可以根据实际需求进一步完善和扩展这个系统，例如添加用户注册和登录等功能。

相关标签
Java
Spring
0人推荐
随时随地看视频
慕课网APP