首页手记 Springboot项目开发学习：初学者指南

Springboot项目开发学习：初学者指南

标签：

SpringBoot

概述

本文将详细介绍Spring Boot项目开发的相关内容，涵盖从环境准备到实战开发的全过程，帮助开发者掌握快速开发Spring Boot应用的技巧。Spring Boot是一个基于Spring框架的开源框架，它通过简化应用开发流程，帮助开发者快速搭建独立运行的Spring应用。

Spring Boot简介

什么是Spring Boot

Spring Boot旨在简化Spring应用的初始搭建和开发过程，它通过约定优于配置的方式，帮助开发者快速搭建独立运行的Spring应用。Spring Boot自带嵌入式Servlet容器（例如Tomcat、Jetty或Undertow），并且内置了大量常用的库和框架，开发者可以快速配置和使用，而无需手动引入大量的依赖项。

Spring Boot的优势

快速启动：Spring Boot提供了快速开发的特性，使得开发人员可以专注于编写业务逻辑，而不需要花费大量时间在配置和依赖管理上。
自动配置：Spring Boot能够自动配置所需的组件，开发者只需关注关键配置，大大简化了配置过程。
内置功能：包括内嵌的Servlet容器、安全配置、日志管理等，使开发者能够快速集成常用功能。
开箱即用：提供了大量的起步依赖，开发者只需要在pom.xml或build.gradle文件中添加相应的依赖，即可启用相关功能。
微服务支持：支持断路器、服务发现、配置中心等多种微服务特性，便于构建分布式系统。

Spring Boot与传统Spring的区别

依赖管理：传统Spring需要手动配置项目所需的依赖，而Spring Boot通过起步依赖（Starter）自动管理。
配置简化：传统Spring需要大量配置文件（如applicationContext.xml），而Spring Boot通过约定优于配置的方式减少了配置工作。
运行环境：传统Spring需要外部的Servlet容器（如Tomcat），而Spring Boot内嵌了Servlet容器。
快速启动：Spring Boot简化了创建Spring应用的过程，减少了启动时间，使得开发变得更加快捷、高效。

Spring Boot项目搭建

开发环境准备

在开始开发Spring Boot项目之前，需要确保已经安装了以下工具和软件：

Java开发工具包 (JDK)：建议使用JDK 8或更高版本。
IDE：推荐使用IntelliJ IDEA或Eclipse。
依赖管理工具：常见的有Maven和Gradle，这里以Maven为例。

Maven配置示例

在项目根目录下创建一个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.7.3</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

创建第一个Spring Boot项目

使用Spring Initializr创建一个新的Spring Boot项目，步骤如下：

访问 Spring Initializr。
选择项目类型：Spring Boot项目。
选择语言：Java。
选择依赖：选择所需的起步依赖，例如Spring Web。
填写项目基本信息，如组ID (groupId) 和项目名 (artifactId)。
点击Generate生成项目压缩包，下载并解压。

使用Spring Initializr创建项目

示例项目信息：

Group ID：com.example
Artifact ID：demo
Version：0.0.1-SNAPSHOT
Packaging：jar
Java Version：11
Dependencies：Spring Web

生成的项目结构如下：

demo
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com.example.demo
│   │   │       ├── DemoApplication.java
│   │   │       └── controller
│   │   │           └── HelloWorldController.java
│   │   └── resources
│   │       ├── application.properties
│   │       └── application.yml
│   └── test
│       └── java
│           └── com.example.demo
│               └── DemoApplicationTests.java
└── pom.xml

项目结构解析

主应用类

主应用类通常位于src/main/java目录下，项目名和包名的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);
    }
}

@SpringBootApplication：用于标记主应用类，该注解包含@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解，分别表示配置类、自动配置和组件扫描。

控制器示例

控制器类通常位于src/main/java目录下，包名controller中的HelloWorldController.java：

package com.example.demo.controller;

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

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

@RestController：用于标记控制器类，表示该类中的方法会返回字符串或JSON数据。
@GetMapping：用于标记处理GET请求的方法。

实战教程：开发一个简单的Web应用

创建控制器

控制器主要处理HTTP请求并返回响应，使用@RestController注解标记控制器类，@GetMapping注解标记具体处理方法：

package com.example.demo.controller;

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

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

使用Thymeleaf模板引擎

Thymeleaf是一个Java模板引擎，可以将HTML文件转换成动态页面。Spring Boot内置了对Thymeleaf的支持，只需添加相应的依赖即可。

添加Thymeleaf依赖

在pom.xml文件中添加spring-boot-starter-thymeleaf依赖：

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

创建Thymeleaf模板

在src/main/resources/templates目录下创建一个index.html文件：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Thymeleaf Example</title>
</head>
<body>
    <h1 th:text="'Hello, ' + ${name} + '!'" />
</body>
</html>

控制器中使用Thymeleaf

在控制器中返回Thymeleaf模板：

package com.example.demo.controller;

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

@Controller
public class ThymeleafController {
    @GetMapping("/thymeleaf")
    public String thymeleaf(Model model) {
        model.addAttribute("name", "World");
        return "index";
    }
}

配置简单的RESTful API

RESTful API遵循REST（Representational State Transfer）架构风格，通常通过HTTP请求来实现资源的增删改查操作。

创建资源控制器

在控制器中定义RESTful API：

package com.example.demo.controller;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;

@RestController
public class ResourceController {
    @GetMapping("/data")
    public String getData() {
        return "Data fetched successfully!";
    }

    @PostMapping("/data")
    public String postData(@RequestBody String data) {
        return "Data received: " + data;
    }

    @DeleteMapping("/data")
    public String deleteData() {
        return "Data deleted successfully!";
    }

    @PutMapping("/data")
    public String updateData(@RequestBody String data) {
        return "Data updated: " + data;
    }
}

@GetMapping：用于处理GET请求。
@PostMapping：用于处理POST请求。
@DeleteMapping：用于处理DELETE请求。
@PutMapping：用于处理PUT请求。
@RequestBody：用于将请求体中的数据绑定到方法参数上。

Spring Boot配置详解

properties与YAML配置文件

Spring Boot支持两种配置文件格式：properties和YAML。通常使用配置文件来定义应用程序的属性，例如数据库连接、缓存配置等。

properties配置文件示例

在src/main/resources目录下创建一个application.properties文件：

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

YAML配置文件示例

在src/main/resources目录下创建一个application.yml文件：

server:
  port: 8080

spring:
  datasource:
  url: jdbc:mysql://localhost:3306/mydb
  username: root
  password: root

自动配置原理

Spring Boot自动配置通过@EnableAutoConfiguration注解启用，并根据类路径中的依赖来推断和配置应用的组件。例如，如果项目中引入了spring-boot-starter-web依赖，Spring Boot会自动配置一个用于处理HTTP请求的DispatcherServlet。

自动配置示例

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

@SpringBootApplication：包含了@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解，自动配置Spring Boot应用。

开箱即用的特性

Spring Boot提供了许多开箱即用的功能，包括内置的Servlet容器、安全配置、缓存管理等。开发者只需引入相应的起步依赖，即可快速启用这些功能。

常见起步依赖

在pom.xml文件中添加常见的起步依赖：

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

spring-boot-starter-web：包含Spring MVC和Servlet容器。
spring-boot-starter-data-jpa：包含JPA和Hibernate。
spring-boot-starter-security：包含Spring Security。

连接数据库

Spring Boot支持多种数据库，包括MySQL、PostgreSQL、Oracle等。这里以MySQL为例，介绍如何连接数据库。

配置数据库连接

在application.properties文件中配置数据库连接：

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

添加数据库依赖

在pom.xml文件中添加MySQL依赖：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

配置DataSource

在项目中配置DataSource，以便更好地管理和配置数据库连接：

package com.example.demo.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;

@Configuration
public class DatabaseConfig {
    @Primary
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

使用JPA进行数据操作

Spring Boot内置了对JPA的支持，方便地进行数据库操作。

创建实体类

在src/main/java目录下创建一个实体类User.java：

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;

    // Getters and Setters
}

@Entity：用于标记实体类。
@Id和@GeneratedValue：用于指定主键。

创建仓库接口

在src/main/java目录下创建一个仓库接口UserRepository.java：

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

JpaRepository：继承自CrudRepository，提供了基本的增删改查方法。

创建服务类

在src/main/java目录下创建一个服务类UserService.java：

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

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

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

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

@Autowired：用于自动注入依赖。

实现简单的增删改查功能

在控制器中使用服务类实现增删改查操作：

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.findAll();
    }

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

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

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

安全性与测试

Spring Security简介

Spring Security是一个强大且灵活的安全框架，用于保护基于Spring的应用。它提供了认证（Authentication）和授权（Authorization）的功能，支持多种认证机制，如用户名密码认证、OAuth2认证等。

基本的认证与授权配置

添加安全依赖

在pom.xml文件中添加Spring Security依赖：

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

配置安全规则

在src/main/resources目录下创建一个security-config.java文件：

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

实现用户服务

在src/main/java目录下创建一个UserDetailsServiceImpl.java文件：

package com.example.demo.service;

import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 根据用户名加载用户信息
        return new User("user", "password", new String[] {"USER"});
    }
}

单元测试与集成测试

单元测试

单元测试主要是对单个类或方法进行测试，Spring Boot提供了@SpringBootTest注解来创建Spring上下文。

示例单元测试代码：

package com.example.demo.service;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testSaveUser() {
        User user = new User();
        user.setName("John");
        user.setEmail("john@example.com");
        User savedUser = userService.save(user);
        assertEquals("John", savedUser.getName());
        assertEquals("john@example.com", savedUser.getEmail());
    }
}

集成测试

集成测试是对多个组件进行联合测试。Spring Boot提供了@IntegrationTest注解来创建完整的Spring上下文，并启动应用服务器。

示例集成测试代码：

package com.example.demo.controller;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.beans.factory.annotation.Autowired;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
public class UserControllerTest {
    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGetAllUsers() throws Exception {
        mockMvc.perform(get("/users"))
            .andExpect(status().isOk())
            .andExpect(content().string("[]"));
    }
}

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

交互式爱情

手记
篇

粉丝

23

获赞与收藏

76

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

Pandas 入门教程

25个小节 18499 337

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空