微信登录

环境搭建 - 项目创建 - 使用 Maven 或 Gradle 创建

Java - Web - Spring 《环境搭建 - 项目创建 - 使用 Maven 或 Gradle 创建》

一、引言

在 Java Web 开发中，Spring 框架是一个非常强大且广泛使用的框架。它提供了丰富的功能，如依赖注入、面向切面编程等，能够帮助开发者更高效地构建企业级应用。而 Maven 和 Gradle 是 Java 项目中常用的构建工具，它们可以帮助我们管理项目的依赖、编译、打包等任务。本文将详细介绍如何使用 Maven 和 Gradle 来创建 Spring Web 项目。

二、环境准备

在开始创建项目之前，我们需要确保以下环境已经安装并配置好：

  1. JDK（Java Development Kit）：建议安装 JDK 8 或更高版本。可以从 Oracle 官方网站或 OpenJDK 官网下载并安装。安装完成后，配置好 JAVA_HOME 环境变量。
  2. Maven 或 Gradle：根据自己的喜好选择其中一个构建工具进行安装。
    • Maven：从 Apache Maven 官方网站下载 Maven 压缩包，解压后配置 MAVEN_HOME 环境变量，并将 %MAVEN_HOME%\bin 添加到系统的 PATH 环境变量中。
    • Gradle：从 Gradle 官方网站下载 Gradle 压缩包，解压后配置 GRADLE_HOME 环境变量，并将 %GRADLE_HOME%\bin 添加到系统的 PATH 环境变量中。
  3. IDE（Integrated Development Environment）：推荐使用 IntelliJ IDEA 或 Eclipse，本文以 IntelliJ IDEA 为例进行演示。

三、使用 Maven 创建 Spring Web 项目

3.1 创建项目

  1. 打开 IntelliJ IDEA，选择 File -> New -> Project。
  2. 在左侧面板中选择 Maven，确保右侧的 Create from archetype 选项被勾选。
  3. 选择 org.apache.maven.archetypes:maven-archetype-webapp 作为项目原型，点击 Next。
  4. 填写项目的 GroupId、ArtifactId 和 Version 等信息，点击 Next。
  5. 配置 Maven 的 Settings.xml 文件路径和本地仓库路径，点击 Next。
  6. 填写项目名称和存储位置，点击 Finish。

3.2 添加 Spring 依赖

打开项目中的 pom.xml 文件，添加以下 Spring 相关的依赖：

  1. <dependencies>
  2.     <!-- Spring Web -->
  3.     <dependency>
  4.         <groupId>org.springframework</groupId>
  5.         <artifactId>spring-webmvc</artifactId>
  6.         <version>5.3.18</version>
  7.     </dependency>
  8.     <!-- Servlet API -->
  9.     <dependency>
  10.         <groupId>javax.servlet</groupId>
  11.         <artifactId>javax.servlet-api</artifactId>
  12.         <version>4.0.1</version>
  13.         <scope>provided</scope>
  14.     </dependency>
  15. </dependencies>

3.3 配置 Spring MVC

  1. 在 src/main/webapp/WEB-INF 目录下创建 spring-servlet.xml 文件，添加以下配置：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.     xmlns:context="http://www.springframework.org/schema/context"
    5.     xmlns:mvc="http://www.springframework.org/schema/mvc"
    6.     xsi:schemaLocation="http://www.springframework.org/schema/beans
    7.                         http://www.springframework.org/schema/beans/spring-beans.xsd
    8.                         http://www.springframework.org/schema/context
    9.                         http://www.springframework.org/schema/context/spring-context.xsd
    10.                         http://www.springframework.org/schema/mvc
    11.                         http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    13.  <!-- 开启注解扫描 -->
    14.  <context:component-scan base-package="com.example.controller"/>
    16.  <!-- 开启 Spring MVC 注解驱动 -->
    17.  <mvc:annotation-driven/>
    19.  <!-- 视图解析器 -->
    20.  <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    21.      <property name="prefix" value="/WEB-INF/views/"/>
    22.      <property name="suffix" value=".jsp"/>
    23.  </bean>
    24. </beans>

  2. 在 src/main/webapp/WEB-INF 目录下创建 web.xml 文件，添加以下配置：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.       xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
    5.                           http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
    6.       version="4.0">
    8.  <!-- Spring MVC 前端控制器 -->
    9.  <servlet>
    10.      <servlet-name>spring</servlet-name>
    11.      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    12.      <init-param>
    13.          <param-name>contextConfigLocation</param-name>
    14.          <param-value>/WEB-INF/spring-servlet.xml</param-value>
    15.      </init-param>
    16.      <load-on-startup>1</load-on-startup>
    17.  </servlet>
    19.  <servlet-mapping>
    20.      <servlet-name>spring</servlet-name>
    21.      <url-pattern>/</url-pattern>
    22.  </servlet-mapping>
    23. </web-app>

3.4 创建控制器和视图

  1. 在 src/main/java 目录下创建 com.example.controller 包，并在该包下创建 HelloController.java 文件：
    ```java
    package com.example.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

  1. @RequestMapping("/hello")
  2. @ResponseBody
  3. public String hello() {
  4.     return "Hello, Spring Web!";
  5. }

}

  1. 2. 在 `src/main/webapp/WEB-INF` 目录下创建 `views` 目录，并在该目录下创建 `hello.jsp` 文件：
  2. ```jsp
  3. <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
  4. <!DOCTYPE html>
  5. <html>
  6. <head>
  7.     <meta charset="UTF-8">
  8.     <title>Hello Spring</title>
  9. </head>
  10. <body>
  11.     <h1>Hello, Spring Web!</h1>
  12. </body>
  13. </html>

3.5 运行项目

在 IntelliJ IDEA 中，点击 Run -> Edit Configurations，添加一个 Tomcat Server 配置，将项目部署到 Tomcat 服务器上，然后启动服务器。在浏览器中访问 http://localhost:8080/hello，即可看到 Hello, Spring Web! 的输出。

四、使用 Gradle 创建 Spring Web 项目

4.1 创建项目

  1. 打开 IntelliJ IDEA，选择 File -> New -> Project。
  2. 在左侧面板中选择 Gradle，选择 Java 作为项目语言，点击 Next。
  3. 填写项目的 GroupId、ArtifactId 和 Version 等信息，点击 Next。
  4. 配置 Gradle 的 JVM 和 Gradle 发行版，点击 Next。
  5. 填写项目名称和存储位置，点击 Finish。

4.2 添加 Spring 依赖

打开项目中的 build.gradle 文件，添加以下 Spring 相关的依赖：

  1. plugins {
  2.     id 'org.springframework.boot' version '2.6.7'
  3.     id 'io.spring.dependency-management' version '1.0.11.RELEASE'
  4.     id 'war'
  5. }
  7. group = 'com.example'
  8. version = '0.0.1-SNAPSHOT'
  9. sourceCompatibility = '1.8'
  11. repositories {
  12.     mavenCentral()
  13. }
  15. dependencies {
  16.     implementation 'org.springframework.boot:spring-boot-starter-web'
  17.     providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'
  18.     testImplementation 'org.springframework.boot:spring-boot-starter-test'
  19. }
  21. test {
  22.     useJUnitPlatform()
  23. }

4.3 创建主类

在 src/main/java 目录下创建 com.example 包，并在该包下创建 DemoApplication.java 文件：

  1. package com.example;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class DemoApplication {
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(DemoApplication.class, args);
  11.     }
  12. }

4.4 创建控制器

在 src/main/java/com.example 包下创建 controller 子包，并在该包下创建 HelloController.java 文件：

  1. package com.example.controller;
  3. import org.springframework.web.bind.annotation.GetMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  6. @RestController
  7. public class HelloController {
  9.     @GetMapping("/hello")
  10.     public String hello() {
  11.         return "Hello, Spring Boot!";
  12.     }
  13. }

4.5 运行项目

在 IntelliJ IDEA 中，右键点击 DemoApplication.java 文件，选择 Run 'DemoApplication.main()'，启动 Spring Boot 应用程序。在浏览器中访问 http://localhost:8080/hello，即可看到 Hello, Spring Boot! 的输出。

五、Maven 和 Gradle 的对比

比较项 Maven Gradle
配置文件格式 XML Groovy 或 Kotlin DSL
依赖管理 声明式，通过 <dependency> 标签 更灵活，支持动态版本、排除依赖等
构建速度 相对较慢，尤其是大型项目 较快，支持增量构建
学习成本 容易上手，XML 格式直观 相对较高，需要学习 Groovy 或 Kotlin

六、总结

本文详细介绍了使用 Maven 和 Gradle 创建 Spring Web 项目的步骤，包括环境准备、项目创建、依赖添加、配置文件编写等。Maven 和 Gradle 各有优缺点，开发者可以根据项目的规模和个人喜好选择合适的构建工具。希望本文能够帮助你快速搭建 Spring Web 开发环境，开启 Java Web 开发之旅。

环境搭建 - 项目创建 - 使用 Maven 或 Gradle 创建