手记

回到首页 个人中心 反馈问题 注册登录
下载APP
首页 课程 实战 体系课 手记 专栏 慕课教程
继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持，我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

SpringBoot项目开发学习入门

DIEA 2024-12-30 12:13:27 浏览 17
DIEA
关注TA
已关注
手记 450
粉丝 63
获赞 387
概述

SpringBoot项目开发学习入门主要介绍了SpringBoot框架的基本概念和优势，包括快速构建独立应用、自动配置和嵌入式Servlet容器等功能。文章详细讲解了开发环境的搭建、HelloWorld项目的创建以及数据库集成和常用注解的使用。通过实战案例，进一步展示了如何实现数据库操作、前端视图渲染以及日志记录和异常处理。

SpringBoot简介

SpringBoot是由Spring团队开发的一个框架，旨在简化基于Spring的应用开发过程。它通过约定优于配置的原则，减少了项目的配置和样板代码的编写。SpringBoot可以快速构建独立的、生产级别的应用，支持嵌入式的运行时容器，并提供了一系列的默认配置，使开发者可以专注于业务逻辑的实现。

SpringBoot是什么

SpringBoot是一个用来简化新Spring应用初始搭建以及开发过程的框架。它通过约定优于配置的方式来减少项目配置文件的数量。SpringBoot自带一个嵌入式的Servlet容器（如Tomcat或Jetty），并且提供了一整套的默认配置，使新项目搭建变得简单快捷。

SpringBoot的优点

SpringBoot的主要优点包括：

  1. 快速构建应用：SpringBoot提供了Spring配置的默认实现，减少了大量配置项。
  2. 自动配置：SpringBoot可以自动配置Spring应用，使开发者专注于应用的核心业务逻辑。
  3. 嵌入式Servlet容器：内置了Tomcat、Jetty以及Undertow作为应用的Web服务器，无需部署到外部的Web服务器。
  4. 独立运行：SpringBoot应用可以打包为可执行的jar包，通过命令行直接运行。
  5. 后续维护方便：提供了一系列的监控和健康检查工具，方便后续维护。
  6. 强大的整合能力：支持与各种第三方库的整合，如MyBatis、JPA、Redis、RabbitMQ等。
  7. 约定优于配置：SpringBoot遵循约定优于配置的原则，只需少量配置即可快速搭建一套可用的应用。

SpringBoot的使用场景

SpringBoot最适合用于构建小型到中型规模的Web应用，尤其是需要快速开发和部署的应用。以下是常见的使用场景：

  1. Web应用：SpringBoot提供了集成的Web模块，可以快速构建RESTful API或者传统的Web应用。
  2. 微服务：在微服务架构中，SpringBoot可以用来创建轻量级且独立的服务实例。
  3. 快速原型：对于需要快速验证想法或原型的项目，SpringBoot可以提供快速的开发和部署支持。
  4. 企业应用：对于企业级应用，SpringBoot可以集成各种企业级的组件，如安全、事务、日志等。
  5. 大数据处理：结合SpringBoot与大数据处理的技术栈，如Spring Kafka、Spring Data Hadoop等，可以快速构建大数据处理应用。
开发环境搭建

开发SpringBoot应用需要配置Java开发环境，并安装SpringBoot开发工具，同时还需要配置Maven或Gradle作为构建工具。

Java开发环境配置

SpringBoot要求Java环境至少为Java 8。以下是配置Java开发环境的步骤：

  1. 下载并安装JDK：

    • 访问Oracle官网或其他来源下载JDK 8及以上版本。
    • 安装JDK，并设置环境变量JAVA_HOME和PATH。
  2. 验证安装：
    • 打开命令行窗口，输入java -version，查看Java版本信息。
    • 输入javac -version，验证JDK编译器是否安装成功。
    • 示例命令： 
      java -version
javac -version

SpringBoot开发工具简介

SpringBoot开发推荐使用IntelliJ IDEA或Eclipse。这两种工具都提供了丰富的SpringBoot插件和工具支持。

IntelliJ IDEA

  • 安装IntelliJ IDEA：
    • 访问IntelliJ官网下载并安装适合的操作系统版本。
  • 配置SpringBoot插件：
    • 打开IntelliJ IDEA，进入插件市场，搜索并安装Spring Boot插件。
  • 创建SpringBoot项目：
    • 打开IntelliJ IDEA，选择创建新项目，选择Spring Initializr，填写项目相关信息，点击完成即可创建新的SpringBoot项目。

Eclipse

  • 安装Eclipse：
    • 访问Eclipse官网下载并安装适合的操作系统版本。
  • 配置SpringBoot插件：
    • 打开Eclipse，进入Eclipse Marketplace，搜索并安装Spring Tools插件。
  • 创建SpringBoot项目：
    • 打开Eclipse，选择创建新项目，选择Spring Boot，填写项目相关信息，点击完成即可创建新的SpringBoot项目。

Maven或Gradle的安装与配置

Maven

Maven是一个强大的项目管理和构建工具。以下是安装和配置Maven的步骤：

  1. 下载并安装Maven：

    • 访问Maven官网下载Maven 3.6.0及以上版本。
    • 解压下载的压缩包，并设置环境变量MAVEN_HOME和PATH。
  2. 验证安装：
    • 打开命令行窗口，输入mvn -version，查看Maven版本信息。
    • 示例命令： 
      mvn -version

Gradle

Gradle是另一个流行的构建工具，它比Maven更灵活，配置起来也更简单。以下是安装和配置Gradle的步骤：

  1. 下载并安装Gradle：

    • 访问Gradle官网下载Gradle 5.0及以上版本。
    • 解压下载的压缩包，并设置环境变量GRADLE_HOME和PATH。
  2. 验证安装：
    • 打开命令行窗口，输入gradle -version，查看Gradle版本信息。
    • 示例命令： 
      gradle -version
HelloWorld项目

创建一个简单的SpringBoot项目，并运行第一个SpringBoot应用。

创建SpringBoot项目

以下是创建HelloWorld SpringBoot项目的步骤：

  1. 使用Spring Initializr创建项目：

    • 访问Spring Initializr网站（https://start.spring.io/）。
    • 选择项目类型（Maven项目），选择Java语言。
    • 选择Spring Boot版本，填写项目基本信息（如项目名、模块名、包名等）。
    • 点击"Generate"按钮下载项目压缩包。

    • 示例代码：

      <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.example</groupId>
 <artifactId>demo</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>

 <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.2.2.RELEASE</version>
     <relativePath/> <!-- lookup parent from repository -->
 </parent>

 <dependencies>
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
 </dependencies>

 <properties>
     <java.version>1.8</java.version>
 </properties>

 <build>
     <plugins>
         <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
     </plugins>
 </build>
</project>
      plugins {
 id 'org.springframework.boot' version '2.2.2.RELEASE'
 id 'io.spring.dependency-management' version '1.0.8.RELEASE'
 id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

repositories {
 mavenCentral()
}

dependencies {
 implementation 'org.springframework.boot:spring-boot-starter-web'
}

test {
 useJUnitPlatform()
}
  2. 解压项目文件：
    • 将下载的压缩包解压到开发工具的项目目录中。

配置项目基本信息

在项目根目录下的pom.xml或build.gradle文件中，可以配置项目的依赖和版本信息。

pom.xml示例

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

build.gradle示例

plugins {
    id 'org.springframework.boot' version '2.2.2.RELEASE'
    id 'io.spring.dependency-management' version '1.0.8.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

test {
    useJUnitPlatform()
}

运行第一个SpringBoot应用

  1. 创建主启动类：
    • 在src/main/java/com/example/demo目录下创建DemoApplication.java文件。
    • 指定SpringBootApplication注解，并编写启动方法。
package com.example.demo;

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

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
  1. 创建简单的控制器：
    • 在src/main/java/com/example/demo目录下创建HelloController.java文件。
    • 使用@Controller注解定义控制器，并使用@RequestMapping注解映射URL到方法。
package com.example.demo;

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

@Controller
public class HelloController {

    @RequestMapping("/")
    @ResponseBody
    public String hello() {
        return "Hello World!";
    }
}
  1. 运行应用：
    • 使用开发工具中的运行功能启动应用，或在命令行中执行mvn spring-boot:run。
    • 打开浏览器访问http://localhost:8080，可以看到输出"Hello World!"。
    • 示例命令： 
      mvn spring-boot:run
常用注解和配置

SpringBoot提供了多种注解来简化应用开发，同时提供了灵活的配置选项。

ModelAndView和@Controller注解

@Controller注解用来标记控制器类，处理HTTP请求。ModelAndView类用于传递数据和视图名称。

示例代码

package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String hello(@RequestParam(value = "username", required = false, defaultValue = "World") String username, Model model) {
        model.addAttribute("name", username);
        return "hello";
    }
}

@RequestMapping和@PathVariable注解

@RequestMapping注解用于映射HTTP请求，@PathVariable注解用于获取URL中的路径变量。

示例代码

package com.example.demo;

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

@Controller
public class HelloController {

    @RequestMapping("/hello/{id}")
    @ResponseBody
    public String hello(@PathVariable("id") String id) {
        return "Hello " + id;
    }
}

springboot.yml配置文件详解

SpringBoot使用application.yml或application.properties文件进行配置。以下是部分常用配置：

spring:
  application:
    name: demo-app
  datasource:
    url: jdbc:mysql://localhost:3306/dbname
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect
server:
  port: 8080

配置解释

  • spring.application.name：应用的名称。
  • spring.datasource.url：数据库连接URL。
  • spring.datasource.username：数据库连接用户名。
  • spring.datasource.password：数据库连接密码。
  • spring.jpa.hibernate.ddl-auto：数据库创建策略。
  • spring.jpa.show-sql：是否显示SQL语句。
  • spring.jpa.properties.hibernate.dialect：数据库方言。
  • server.port：应用运行的端口。
数据库集成

SpringBoot支持多种数据库的集成，包括MySQL、PostgreSQL、Oracle等。本节将介绍如何通过SpringBoot整合JPA和MySQL数据库。

SpringBoot整合JPA

JPA（Java Persistence API）是一种Java持久化框架，它定义了持久化操作的标准接口。SpringBoot支持JPA的自动配置。

示例代码

  1. 添加JPA依赖：

    • 在pom.xml或build.gradle文件中添加JPA依赖。
    • pom.xml示例： 
      <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
    • build.gradle示例： 
      implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

  2. 创建Entity类：

    • 创建一个简单的Entity类，使用@Entity注解标记为实体类。

    • 例如，创建一个User类：

      package com.example.demo.entity;

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

  3. 创建Repository接口：

    • 创建一个Repository接口，继承JpaRepository接口。
    • 自动实现CRUD操作。

    • 例如，创建一个UserRepository接口：

      package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

使用SpringBoot连接MySQL数据库

SpringBoot可以通过application.yml或application.properties文件配置MySQL数据库连接。

示例代码

  1. 配置数据库连接：

    • 在application.yml文件中配置数据库连接信息。
    • 示例： 
      spring:
datasource:
 url: jdbc:mysql://localhost:3306/dbname
 username: root
 password: root
jpa:
 hibernate:
   ddl-auto: update
 show-sql: true
 properties:
   hibernate:
     dialect: org.hibernate.dialect.MySQL5InnoDBDialect

  2. 创建数据库表：

    • 使用数据库工具（如MySQL Workbench）创建数据库表。
    • 或者使用JPA的@Entity注解自动生成表结构。

    • 示例：

      package com.example.demo.entity;

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

数据库迁移工具SpringBoot Flyway

Flyway是一个数据库迁移工具，可以自动处理数据库版本升级和回滚。SpringBoot通过spring.flyway属性配置Flyway。

示例代码

  1. 添加Flyway依赖：

    • 在pom.xml或build.gradle文件中添加Flyway依赖。
    • pom.xml示例： 
      <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-flyway</artifactId>
</dependency>
    • build.gradle示例： 
      implementation 'org.springframework.boot:spring-boot-starter-flyway'

  2. 配置Flyway：

    • 在application.yml文件中配置Flyway。
    • 示例： 
      spring:
flyway:
 url: jdbc:mysql://localhost:3306/dbname
 user: root
 password: root
 schemas: public
 locations: db/migration
  3. 创建迁移脚本：
    • 在src/main/resources/db/migration目录下创建迁移脚本文件。
    • 脚本文件名格式为V1__init.sql，V2__add_user_table.sql等。
    • 示例： 
      -- V1__init.sql
CREATE TABLE user (
 id SERIAL PRIMARY KEY,
 name VARCHAR(255),
 email VARCHAR(255)
);
实战案例

本节将通过一个简单的CRUD应用示例，展示如何使用SpringBoot实现数据库操作，并使用Thymeleaf实现前端视图。同时，还将介绍日志记录和异常处理。

创建简单的CRUD应用

  1. 创建Entity类：

    • 创建User实体类，包含id、name和email字段。

    • 示例：

      package com.example.demo.entity;

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

  2. 创建Repository接口：

    • 创建UserRepository接口，继承JpaRepository接口。
    • 自动实现CRUD操作。

    • 示例：

      package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

  3. 创建Service类：

    • 创建UserService类，实现用户相关的业务逻辑。

    • 示例：

      package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

 @Autowired
 private UserRepository userRepository;

 public List<User> findAllUsers() {
     return userRepository.findAll();
 }

 public User findUserById(Long id) {
     return userRepository.findById(id).orElse(null);
 }

 public User saveUser(User user) {
     return userRepository.save(user);
 }

 public void deleteUser(Long id) {
     userRepository.deleteById(id);
 }
}

  4. 创建Controller类：

    • 创建UserController类，处理用户的HTTP请求。

    • 示例：

      package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class UserController {

 @Autowired
 private UserService userService;

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

 @GetMapping("/users/{id}")
 public User getUserById(@PathVariable Long id) {
     return userService.findUserById(id);
 }

 @PostMapping("/users")
 public User createUser(@RequestBody User user) {
     return userService.saveUser(user);
 }

 @PutMapping("/users/{id}")
 public User updateUser(@PathVariable Long id, @RequestBody User user) {
     user.setId(id);
     return userService.saveUser(user);
 }

 @DeleteMapping("/users/{id}")
 public void deleteUser(@PathVariable Long id) {
     userService.deleteUser(id);
 }
}

使用Thymeleaf实现前端视图

Thymeleaf是一个强大的模板引擎，可以用于生成HTML页面。以下是如何使用Thymeleaf创建简单的视图。

  1. 添加Thymeleaf依赖：

    • 在pom.xml或build.gradle文件中添加Thymeleaf依赖。
    • pom.xml示例： 
      <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
    • build.gradle示例： 
      implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'

  2. 创建Thymeleaf视图：

    • 在src/main/resources/templates目录下创建users.html文件。
    • 示例： 
      <!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
 <title>User List</title>
</head>
<body>
 <h1>User List</h1>
 <ul>
     <li th:each="user : ${users}" th:text="${user.name}">User Name</li>
 </ul>
</body>
</html>

  3. 创建Controller类：

    • 创建UserController类，处理用户的HTTP请求，并返回Thymeleaf视图。

    • 示例：

      package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.List;

@Controller
public class UserController {

 @Autowired
 private UserService userService;

 @GetMapping("/users")
 public String getAllUsers(Model model) {
     List<User> users = userService.findAllUsers();
     model.addAttribute("users", users);
     return "users";
 }
}

日志记录和异常处理

SpringBoot提供了灵活的日志和异常处理机制，可以帮助开发者更好地理解和调试应用。

日志记录

SpringBoot使用Logback作为默认的日志框架。可以通过logback-spring.xml或logback-spring.groovy文件配置日志输出。

异常处理

SpringBoot提供了全局异常处理机制，可以通过@ControllerAdvice和@ExceptionHandler注解来实现。

示例代码

  1. 配置日志文件：

    • 在src/main/resources目录下创建logback-spring.xml文件。

    • 示例：

      <configuration>
 <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
     <encoder>
         <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
     </encoder>
 </appender>

 <root level="info">
     <appender-ref ref="STDOUT" />
 </root>
</configuration>

  2. 创建全局异常处理器：

    • 创建GlobalExceptionHandler类，处理全局异常。

    • 示例：

      package com.example.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.util.HashMap;
import java.util.Map;

@ControllerAdvice
public class GlobalExceptionHandler {

 @ExceptionHandler(Exception.class)
 public ResponseEntity<Map<String, Object>> handleException(Exception e) {
     Map<String, Object> errorMap = new HashMap<>();
     errorMap.put("status", HttpStatus.INTERNAL_SERVER_ERROR.value());
     errorMap.put("message", e.getMessage());
     return new ResponseEntity<>(errorMap, HttpStatus.INTERNAL_SERVER_ERROR);
 }
}
打开App，阅读手记
相关标签
SpringBoot
0人推荐
发表评论
随时随地看视频慕课网APP

相关课程

SpringBoot+Vue3 项目实战，打造企业级在线办公系统

¥399 中级 2203

Spring Cloud+ Vue前后端分离开发企业级在线视频系统

¥388 初级 1739

Dubbo主流版本打造仿猫眼项目 理解微服务核心思想

¥366 中级 1409

Spring Boot进阶之Web进阶

免费 中级 104051

基于SpringBoot 十分钟搞定后台管理平台

免费 中级 42432

Java全栈工程师

¥3680 2057