手记

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

SpringBoot入门：新手必读指南

青春有我 2024-11-15 19:55:31 浏览 10
青春有我
关注TA
已关注
手记 1199
粉丝 205
获赞 1008
概述

SpringBoot入门介绍了Spring Boot框架的基本概念和优势，包括自动配置、快速启动、嵌入式Servlet容器等功能。文章详细讲解了开发环境的搭建、第一个Spring Boot项目的创建以及常用注解的使用。此外，还涵盖了数据库集成和配置文件的管理等内容。

SpringBoot简介

SpringBoot是什么

Spring Boot是由Pivotal团队提供的框架，其目的是用来简化新Spring应用的初始搭建以及开发过程。它通过配置来减少初始的代码，并且通过默认配置来简化开发。基于Spring Boot可以快速搭建独立的、生产级别的应用。

SpringBoot的优势

  1. 减少初始配置：Spring Boot通过约定优于配置的理念，自动配置应用程序，使得初始配置变得简单。
  2. 自动配置：Spring Boot能够自动配置许多常用的框架，如Spring MVC、Thymeleaf等，大大减少了开发者的配置工作。
  3. 快速启动：Spring Boot可以快速创建独立的、生产级别的应用。
  4. 嵌入式Servlet容器：Spring Boot可以直接内嵌Servlet容器（如Tomcat、Jetty等），简化了应用的部署。
  5. 开箱即用：Spring Boot提供了许多常用的库，可以直接使用，减少开发时间。
  6. 支持DevOps：Spring Boot支持热部署，方便了开发和测试过程。
  7. 强大的社区支持：Spring Boot有庞大的社区支持，提供了大量的插件和工具。

SpringBoot的核心概念

  1. 自动配置：Spring Boot会自动配置一些常用的框架，如数据库连接、日志配置等。
  2. Starter依赖：Spring Boot提供了一整套的依赖管理，减少了手动配置依赖的麻烦。例如，spring-boot-starter-web包含了构建Web应用所需的所有依赖。
  3. 命令行界面：Spring Boot支持通过命令行方式启动和停止应用。
  4. Actuator管理：Spring Boot Actuator提供了生产级别的监控和管理功能，帮助开发者在生产环境中更容易地监控应用状态。
  5. 嵌入式Servlet容器：Spring Boot可以内嵌Tomcat、Jetty等Servlet容器，简化部署。
  6. 外部化配置：Spring Boot允许在外部配置文件中定义属性，使得配置更加灵活。
开发环境搭建

安装Java环境

  1. 下载Java SE Development Kit (JDK)。推荐使用最新版本的JDK。
  2. 安装JDK。
  3. 设置环境变量。需要配置JAVA_HOME和PATH环境变量。例如：
export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH
  1. 验证安装。打开终端并输入java -version，应该能够看到安装的JDK版本信息。

安装IDE（如IntelliJ IDEA或Eclipse）

IntelliJ IDEA

  1. 下载并安装IntelliJ IDEA。
  2. 打开IntelliJ IDEA，选择File > New > Project，然后选择Spring Initializr。
  3. 填写项目信息，包括项目名称、项目位置、语言（Java）、依赖管理工具（Maven或Gradle），以及依赖（例如Web、Spring Web）。
  4. 点击Project按钮创建项目。

Eclipse

  1. 下载并安装Eclipse。
  2. 打开Eclipse，选择File > New > Dynamic Web Project，然后选择Spring Starter。
  3. 填写项目信息，包括项目名称、项目位置、语言（Java）、依赖管理工具（Maven或Gradle），以及依赖（例如Web、Spring Web）。
  4. 点击Finish按钮创建项目。

配置Maven或Gradle

Maven

  1. 确保Maven已安装。可以通过命令mvn -v验证。
  2. 在项目根目录下创建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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.0</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
  1. 在IDE中导入Maven项目。在IntelliJ IDEA中，选择File > Import > Maven > Project，然后选择你的项目文件夹。

Gradle

  1. 确保Gradle已安装。
  2. 在项目根目录下创建build.gradle文件，示例如下：
plugins {
    id 'org.springframework.boot' version '2.4.0'
    id 'io.spring.dependency-management' version '1.0.10.RELEASE'
    id 'java'
}

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

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
  1. 在IDE中导入Gradle项目。在IntelliJ IDEA中，选择File > New > Project，然后选择Spring Initializr，并选择Gradle作为依赖管理工具。
第一个SpringBoot项目

创建SpringBoot项目

使用IDE创建新的Spring Boot项目。以IntelliJ IDEA为例：

  1. 打开IntelliJ IDEA，选择File > New > Project。
  2. 选择Spring Initializr，并选择Language为Java。
  3. 填写项目名称（例如demo），选择Java，选择Maven或Gradle作为依赖管理工具。
  4. 选择Dependencies，添加Spring Web依赖。
  5. 点击Next按钮，然后点击Finish创建项目。

添加依赖

在pom.xml或build.gradle文件中添加Spring Boot依赖，如下所示：

pom.xml

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

build.gradle

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

运行第一个SpringBoot应用

创建一个简单的Spring Boot应用，创建一个主类DemoApplication，如下所示：

DemoApplication.java

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

}

在IDE中运行主类，或使用命令行运行应用。在命令行中，可以使用以下命令：

mvn spring-boot:run

或

./gradlew bootRun

启动应用后，可以在浏览器中访问http://localhost:8080，会显示默认的欢迎页面。

SpringBoot常用注解

@SpringBootApplication

@SpringBootApplication是一个组合注解，包含@Configuration、@EnableAutoConfiguration和@ComponentScan。

@Configuration

@Configuration表示该类是一个配置类，可以包含@Bean方法。

@EnableAutoConfiguration

@EnableAutoConfiguration启用Spring Boot的自动配置功能。

@ComponentScan

@ComponentScan扫描指定包下的组件（如@Controller、@Service、@Repository等）。

@Controller、@Service、@Repository、@Component

@Controller

@Controller用于标记控制器类，处理HTTP请求。

@Service

@Service用于标记服务类，处理业务逻辑。

@Repository

@Repository用于标记数据访问层类，如DAO类。

@Component

@Component是一个通用的注解，标记为Spring组件。

@RestController、@RequestMapping

@RestController

@RestController是@Controller和@ResponseBody的组合，表示该类是一个REST控制器，返回JSON或XML等数据类型。

@RequestMapping

@RequestMapping用于映射HTTP请求到控制器处理方法。可以指定请求的URL路径、HTTP方法（GET、POST等）。

示例代码

定义一个简单的REST控制器：

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class UserController {

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

访问http://localhost:8080/api/hello会返回Hello, World!。

数据库集成

使用SpringBoot集成MySQL数据库

配置application.properties

在src/main/resources/application.properties文件中配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/dbname
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update

创建实体类

定义一个简单的实体类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 Long id;

    private String name;

    private String email;

    // Getters and Setters
}

创建Repository接口

定义一个简单的Repository接口UserRepository：

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

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

创建Service类

定义一个简单的Service类UserService：

package com.example.demo;

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> getAllUsers() {
        return userRepository.findAll();
    }
}

创建Controller类

定义一个简单的Controller类UserController：

package com.example.demo;

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 java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

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

配置JPA或MyBatis

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'

MyBatis配置

在pom.xml或build.gradle文件中添加MyBatis依赖：

pom.xml

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>

build.gradle

implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.1.4'

定义Mapper接口和配置文件：

UserMapper.java

package com.example.demo.mapper;

import com.example.demo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users")
    List<User> getAllUsers();
}

mybatis-config.xml

<?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>
    <typeAliases>
        <typeAlias type="com.example.demo.User" alias="User"/>
    </typeAliases>
    <mappers>
        <mapper resource="com/example/demo/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

UserMapper.xml

<?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.demo.mapper.UserMapper">
    <select id="getAllUsers" resultType="User">
        SELECT * FROM users
    </select>
</mapper>

实现简单的CRUD操作

创建实体类

定义一个简单的实体类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 Long id;

    private String name;

    private String email;

    // Getters and Setters
}

创建Repository接口

定义一个简单的Repository接口UserRepository：

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

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

创建Service类

定义一个简单的Service类UserService：

package com.example.demo;

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> getAllUsers() {
        return userRepository.findAll();
    }

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

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

    public User updateUser(Long id, User user) {
        User existingUser = userRepository.findById(id).orElse(null);
        if (existingUser != null) {
            existingUser.setName(user.getName());
            existingUser.setEmail(user.getEmail());
            return userRepository.save(existingUser);
        }
        return null;
    }

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

创建Controller类

定义一个简单的Controller类UserController：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

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

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

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

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

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}
SpringBoot配置文件

application.properties与application.yml

application.properties

配置文件application.properties示例：

spring.datasource.url=jdbc:mysql://localhost:3306/dbname
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update
server.port=8080

application.yml

配置文件application.yml示例：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dbname
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: update
server:
  port: 8080

配置文件的常用属性设置

数据源配置

spring.datasource.url=jdbc:mysql://localhost:3306/dbname
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

日志配置

logging.level.root=INFO
logging.file.path=/path/to/logfile

服务器端口配置

server.port=8080

Spring MVC配置

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

Profile环境配置

可以在application.yml或application.properties文件中定义不同的配置文件，用于不同的环境（如开发、测试、生产）。

多环境配置

spring.profiles.active=dev

或者

spring:
  profiles:
  active: dev

在不同环境下的配置文件，例如application-dev.properties、application-test.properties、application-prod.properties。

示例代码

在src/main/resources目录下创建不同的配置文件，例如：

application-dev.properties：

spring.datasource.url=jdbc:mysql://localhost:3306/devdb
spring.datasource.username=root
spring.datasource.password=root

application-test.properties：

spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=root
spring.datasource.password=root

application-prod.properties：

spring.datasource.url=jdbc:mysql://localhost:3306/proddb
spring.datasource.username=root
spring.datasource.password=root

在主类中指定激活的profile：

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 app = new SpringApplication(DemoApplication.class);
        app.setAdditionalProfiles("dev");
        app.run(args);
    }

}
打开App，阅读手记
相关标签
SpringBoot
0人推荐
发表评论
随时随地看视频慕课网APP

相关课程

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

¥399 中级 2189

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

¥388 初级 1737

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

¥366 中级 1409

Spring Boot进阶之Web进阶

免费 中级 104019

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

免费 中级 42416

移动端架构师

¥5388 561