为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 Springboot企业级开发学习：从入门到初级实战

Springboot企业级开发学习：从入门到初级实战

标签：
SpringBoot
概述

Spring Boot企业级开发学习涵盖从环境搭建到核心功能介绍，再到实战项目开发、安全与权限控制、高级功能实现以及部署与监控等多方面内容，帮助开发者快速构建功能丰富的企业级应用。

Spring Boot基础概念与环境搭建

Spring Boot简介

Spring Boot 是一个基于 Spring 框架的微服务开发工具，它极大地简化了 Spring 应用的初始配置和依赖管理。通过使用默认配置和约定优于配置的原则，Spring Boot 允许开发者快速开发出独立运行、功能丰富的应用。Spring Boot 的核心特性包括：

  • 内嵌的 Tomcat/Netty/Undertow 服务器
  • 自动配置功能
  • 开箱即用的依赖管理
  • 测试支持
  • 命令行界面支持
  • 静态资源处理
  • 健康检查

Spring Boot 版本的选择和更新是开发过程中的重要部分。建议使用最新的稳定版本，以确保获得最新的功能和安全更新。

开发环境搭建

要开始使用 Spring Boot，需要先搭建开发环境。以下是搭建步骤：

  1. 安装 JDK：确保安装了 Java 开发工具包（JDK），建议安装 Java 8 及以上版本。
  2. 安装 IDE：推荐使用 IntelliJ IDEA 或 Eclipse。
  3. 安装 Maven 或 Gradle：Spring Boot 可以通过 Maven 或 Gradle 构建项目，这里以 Maven 为例。
  4. 安装 Spring Boot CLI：可选，但是可以简化开发流程。

Maven 项目创建示例

通过 Maven 创建一个新的 Spring Boot 项目。创建一个名为 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.7.1</version>
    </parent>

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

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

第一个Spring Boot项目

创建一个简单的 Spring Boot 应用程序，用于显示 "Hello World!" 消息。步骤如下：

  1. 创建主类：创建一个带有 @SpringBootApplication 注解的主类，该注解集成了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 三个注解。
  2. 编写控制器：创建一个控制器类来处理 HTTP 请求。
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DemoApplication {

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

}

@RestController
class HelloWorldController {

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

}
Spring Boot核心功能介绍

自动配置原理

Spring Boot 使用自动配置来简化应用的配置。自动配置通过 @EnableAutoConfiguration 注解激活，它会根据应用的类路径内容来推测你想要的配置，并自动配置相应的 Bean。例如，如果类路径中有 spring-boot-starter-web，则会自动配置一个嵌入式的 Tomcat 服务器，并使用 Spring MVC 来处理 HTTP 请求。

依赖注入与组件扫描

Spring Boot 使用依赖注入（DI）来管理对象的创建和配置。@ComponentScan 注解负责扫描指定包及其子包下的所有标注了 @Component、@Service、@Repository 和 @Controller 的类，并将它们注册为 Spring 容器中的 Bean。

依赖注入示例

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
class SomeService {

    private final AnotherService anotherService;

    @Autowired
    public SomeService(AnotherService anotherService) {
        this.anotherService = anotherService;
    }

    public void doSomething() {
        anotherService.doSomething();
    }

}

@Component
class AnotherService {

    public void doSomething() {
        System.out.println("Doing something...");
    }

}

假设 SomeService 需要一个 OrderService 来处理订单逻辑，我们可以这样实现：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
class SomeService {

    private final OrderService orderService;

    @Autowired
    public SomeService(OrderService orderService) {
        this.orderService = orderService;
    }

    public void processOrder() {
        orderService.placeOrder();
    }

}

@Component
class OrderService {

    public void placeOrder() {
        System.out.println("Placing an order...");
    }

}

静态资源处理与视图解析

Spring Boot 默认会将静态资源文件（如 HTML、CSS、JavaScript 文件和图片文件）放在 src/main/resources/static 目录下。可以通过 @Controller 类中的方法返回视图名称来渲染视图。Spring Boot 使用 ViewResolver 来解析视图，并将请求转发到指定的视图。

视图解析示例

package com.example.demo;

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

@Controller
public class MyController {

    @GetMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("message", "Hello, World!");
        return "hello";
    }

}

创建一个名为 src/main/resources/templates/hello.html 的视图文件：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello World</title>
</head>
<body>
<h1 th:text="${message}"></h1>
</body>
</html>
实战：Spring Boot RESTful API开发

创建RESTful服务

创建一个简单的 RESTful API，用于提供数据的增删改查（CRUD）操作。例如，定义一个 User 实体类和一个 UserController 来处理用户数据的请求。

用户实体类

package com.example.demo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class UserEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

用户控制器

package com.example.demo;

import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
public class UserController {

    private List<UserEntity> users = new ArrayList<>();

    @GetMapping("/users")
    public List<UserEntity> getUsers() {
        return users;
    }

    @PostMapping("/users")
    public UserEntity createUser(@RequestBody UserEntity user) {
        this.users.add(user);
        return user;
    }

    @GetMapping("/users/{id}")
    public UserEntity getUser(@PathVariable Long id) {
        return this.users.stream().filter(user -> user.getId().equals(id)).findFirst().orElse(null);
    }

    @PutMapping("/users/{id}")
    public UserEntity updateUser(@PathVariable Long id, @RequestBody UserEntity user) {
        UserEntity existingUser = getUser(id);
        existingUser.setName(user.getName());
        existingUser.setEmail(user.getEmail());
        return existingUser;
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        UserEntity user = getUser(id);
        this.users.remove(user);
    }

}

使用Spring Data JPA操作数据库

Spring Data JPA 是一个简化数据访问的框架，它提供了自动的方法生成器，使得数据库操作变得非常简单。使用 JPA 可以减少开发人员编写数据访问对象（DAO）层代码的工作量。

配置数据库连接

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

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

用户持久层

package com.example.demo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class UserEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
    private boolean active;

    // Getters and Setters
}

用户仓库

package com.example.demo;

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

@Repository
public interface UserRepository extends JpaRepository<UserEntity, Long> {
}

用户控制器（更新）

更新 UserController 以使用 UserRepository：

package com.example.demo;

import org.springframework.web.bind.annotation.*;

import java.util.Optional;

@RestController
public class UserController {

    private final UserRepository userRepository;

    @Autowired
    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @GetMapping("/users")
    public List<UserEntity> getUsers() {
        return userRepository.findAll();
    }

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

    @GetMapping("/users/{id}")
    public Optional<UserEntity> getUser(@PathVariable Long id) {
        return userRepository.findById(id);
    }

    @PutMapping("/users/{id}")
    public UserEntity updateUser(@PathVariable Long id, @RequestBody UserEntity user) {
        return userRepository.save(user);
    }

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

}

处理更为复杂的逻辑或状态

例如，我们可以在 UserController 中添加一个方法来更新用户状态：

@GetMapping("/users/{id}/activate")
public UserEntity activateUser(@PathVariable Long id) {
    UserEntity user = userRepository.findById(id).orElseThrow(() -> new RuntimeException("User not found"));
    user.setActive(true);
    return userRepository.save(user);
}
企业级开发必备：安全与权限控制

用户认证与授权

Spring Boot 提供了 spring-boot-starter-security 依赖，简化了安全管理的配置。通过 @EnableWebSecurity 注解启用 Web 安全配置，并通过 UserDetails 接口定义用户数据。

安全配置类

package com.example.demo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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("/users", "/users/page/**", "/users/sorted").permitAll()
                .antMatchers("/users/privileged").hasRole("ADMIN")
                .anyRequest().authenticated()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user")
            .password(passwordEncoder().encode("password"))
            .roles("USER")
            .and()
            .withUser("admin")
            .password(passwordEncoder().encode("password"))
            .roles("ADMIN");
    }

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

}

使用Spring Security实现安全控制

通过上述配置，Spring Security 实现了基本的安全控制，包括登录、认证和权限控制。

登录页面

@GetMapping("/login")
public String loginPage() {
    return "login";
}

创建一个名为 src/main/resources/templates/login.html 的登录视图文件：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login</title>
</head>
<body>
<h2>Login Form</h2>
<form th:action="@{/login}" method="post">
    <p>
        <label>Email:</label>
        <input type="text" name="username" />
    </p>
    <p>
        <label>Password:</label>
        <input type="password" name="password" />
    </p>
    <p>
        <input type="submit" value="Login" />
    </p>
</form>
</body>
</html>

授权规则配置

Spring Security 支持细粒度的权限控制。通过 @PreAuthorize 和 @PostAuthorize 注解可以实现更细粒度的安全控制。

细粒度权限控制

@GetMapping("/users/privileged")
public List<UserEntity> getPrivilegedUsers() {
    return userRepository.findByRoles("ADMIN");
}

配置细粒度权限：

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
            .antMatchers("/users", "/users/page/**", "/users/sorted").permitAll()
            .antMatchers("/users/privileged").hasRole("ADMIN")
            .anyRequest().authenticated()
        .and()
        .formLogin()
            .loginPage("/login")
            .permitAll()
        .and()
        .logout()
            .permitAll();
}
高级功能：异步处理与任务调度

异步方法执行

Spring Boot 支持通过 @Async 注解实现异步方法执行。可以将耗时任务变成异步方法，以提高应用性能。

异步方法示例

package com.example.demo;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    @Async
    public void performLongRunningTask() {
        // 模拟耗时任务
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task completed");
    }

}

配置异步支持

启用异步支持需要在配置类中添加 @EnableAsync 注解：

package com.example.demo;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {

}

调用异步方法

package com.example.demo;

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

@RestController
public class AsyncController {

    @Autowired
    private AsyncService asyncService;

    @GetMapping("/async")
    public String async() {
        asyncService.performLongRunningTask();
        return "Task started";
    }

}

例如，我们可以将一个耗时的任务（如发送邮件）改为异步执行：

package com.example.demo;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    @Async
    public void sendEmailAsync() {
        // 模拟发送邮件
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Email sent");
    }

}

任务调度与定时任务

Spring Boot 支持使用 @Scheduled 注解来创建定时任务。可以配置任务的执行频率，例如每分钟、每小时等。

定时任务示例

package com.example.demo;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    @Scheduled(fixedRate = 10000)
    public void reportCurrentTime() {
        System.out.println("The time is now " + new Date());
    }

}

配置定时任务支持

启用定时任务支持需要在配置类中添加 @EnableScheduling 注解：

package com.example.demo;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

@Configuration
@EnableScheduling
public class ScheduledConfig {

}
部署与监控：Spring Boot应用上线

应用打包与部署

Spring Boot 应用可以打包成独立的 JAR 文件或 WAR 文件，方便部署到生产环境。

打包成 JAR 文件

使用 Maven 打包：

mvn clean package

生成的 JAR 文件位于 target 目录下，可以直接使用 java -jar 命令运行：

java -jar target/demo-0.0.1-SNAPSHOT.jar

打包成 WAR 文件

如果项目需要部署到标准的 Servlet 容器（如 Tomcat），可以修改 pom.xml 文件，添加 spring-boot-starter-tomcat 和 spring-boot-starter-tomcat 依赖：

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

部署到云平台如 AWS、Google Cloud 或阿里云时，可以使用云平台提供的部署工具或服务。例如，阿里云的 ECS 可以通过 Jenkins 或其他 CI/CD 工具自动化部署过程。

应用监控与日志管理

Spring Boot 提供了内置的监控和日志管理功能。默认使用 Logback 作为日志框架，可以通过 logback-spring.xml 文件自定义日志配置。

日志配置

创建 src/main/resources/logback-spring.xml 文件：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

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

应用监控

Spring Boot Actuator 提供了丰富的监控和管理端点，包括健康检查、JVM 信息、HTTP 请求跟踪等。

启用 Actuator：

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

通过访问 /actuator 路径可以查看所有可用的监控端点。

此外，可以结合 Prometheus 和 Grafana 来进行更详细的监控和可视化。例如，配置 Prometheus 收集 Spring Boot 应用的指标，并通过 Grafana 进行展示。

总结

本文详细介绍了 Spring Boot 的入门及实战应用，包括环境搭建、核心功能、RESTful API 开发、安全与权限控制、高级功能、部署与监控等。通过学习，开发者可以快速构建出功能丰富的企业级应用。更多 Spring Boot 学习资源可以参考 慕课网。

点击查看更多内容
发表于 2024.12.27 19:39， 共 78 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

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

评论

作者其他优质文章

正在加载中

ITMISS

手记
篇
粉丝
51
获赞与收藏
244

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消