首页手记 Spring Boot企业级开发实战入门教程

Spring Boot企业级开发实战入门教程

标签：

SpringBoot

概述

本文档深入介绍了Spring Boot企业级开发实战，涵盖了从环境搭建到核心概念配置的各个方面。通过详细示例，讲解了数据访问、RESTful服务开发以及企业级功能实现等内容。此外，文章还介绍了如何进行应用打包与部署，以及使用Spring Boot Actuator进行应用监控。阅读本文，你将全面掌握Spring Boot企业级开发实战所需的各项技能。

Spring Boot简介与环境搭建

什么是Spring Boot

Spring Boot是由Pivotal团队提供的框架，旨在简化Spring应用的开发过程。Spring Boot提供了一种全新的方式来创建独立的、生产级别的基于Spring的应用程序，特别适合现代化的开发需求。它使用约定优于配置的原则，使得开发人员不需要编写大量的配置代码，而只需关注业务逻辑。Spring Boot集成了大量的第三方库，简化了依赖管理，并且支持自动配置，使得开发者能够快速地创建一个可运行的Spring应用。

快速搭建开发环境

安装Java

确保你的系统安装了Java开发工具包（JDK）。推荐版本为Java 8或更高版本。安装完成后，可以通过命令行验证Java是否安装成功：

java -version

安装Maven或Gradle

Spring Boot项目推荐使用Maven或Gradle进行构建和依赖管理。这里以Maven为例，Gradle的安装也非常简单，只需下载并配置环境变量。

安装Maven：

下载Maven的压缩包。
解压到指定目录。
设置环境变量MAVEN_HOME和路径PATH。

验证Maven安装：

mvn -version

安装IDEA

选择一个集成开发环境（IDE），如IntelliJ IDEA或Eclipse。这里以IntelliJ IDEA为例：

下载并安装IntelliJ IDEA。
打开IDEA，选择安装插件，安装Spring Boot插件。

使用IDEA创建Spring Boot项目

打开IntelliJ IDEA。
点击“Start a new Project”。
选择“Maven”，然后点击“Next”。
填写Group Id（如：com.example）和Artifact Id（如：demo），点击“Next”。
在“Project SDK”中选择Java版本。
在“Packaging”中选择“jar”。
在“Name”中输入项目名称（如：spring-boot-demo），点击“Finish”。

项目创建完成后，会自动生成一个pom.xml文件。添加Spring Boot的相关依赖：

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

最后，创建一个主类，使用@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);
    }
}

运行主类，启动Spring Boot应用。

Spring Boot核心概念与配置

Spring Boot的核心特性

简化配置

Spring Boot通过约定优于配置的方式，自动配置了许多常见的组件。例如，它可以通过读取配置文件来自动配置数据库连接、安全设置等。

内嵌容器

Spring Boot可以内嵌各种Web服务器，如Tomcat、Jetty、Undertow等。通过spring-boot-starter-web依赖，你无需额外配置就可以启动一个Web服务器。

自动装配

Spring Boot通过自动装配，让开发人员无需显式配置bean，只需在类上添加注解即可。

命令行参数

Spring Boot提供了一个命令行界面，可以通过命令行参数来配置应用的行为。

应用自动配置

Spring Boot的核心是自动配置。它会根据类路径中的依赖来自动配置应用。例如，如果有Spring Data JPA依赖，Spring Boot会自动配置JPA。

当我们添加spring-boot-starter-data-jpa依赖时，Spring Boot会自动配置相关组件：

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

自动配置的类位于org.springframework.boot包下，这些类通常命名为*AutoConfiguration。例如，JpaAutoConfiguration自动配置了JPA。

属性配置管理

Spring Boot通过配置属性来管理应用的行为，这些属性可以定义在application.properties或application.yml文件中。

例如，设置数据库连接属性：

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

这些属性可以通过@Value注解注入到Spring Bean中：

package com.example.demo;

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

@Component
public class DataSourceConfig {

    @Value("${spring.datasource.url}")
    private String url;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    public String getUrl() {
        return url;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }
}

Spring Boot数据访问

数据库连接与操作

Spring Boot通过spring-boot-starter-data-jpa依赖自动配置了JPA，简化了数据库访问。首先，需要添加数据库驱动依赖：

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

创建一个简单的实体类：

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接口：

package com.example.demo;

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

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

在服务类中使用Repository：

package com.example.demo;

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

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

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

使用JPA进行数据访问

JPA（Java Persistence API）是Java EE平台的一部分，用于访问和管理持久化对象。Spring Boot通过spring-boot-starter-data-jpa依赖集成了JPA。

通过UserRepository接口，可以直接执行CRUD操作：

package com.example.demo;

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

@Service
public class UserService {

    @Autowired
.
.
.

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

连接MyBatis完成复杂的数据访问

MyBatis是一个优秀的持久层框架，能够灵活地通过XML方式配置和映射原始类型、接口和Java POJO（普通旧Java对象）。对于复杂的SQL查询，MyBatis提供了更好的灵活性。

首先，添加MyBatis依赖：

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

创建一个实体类：

package com.example.demo;

public class User {

    private Long id;
    private String name;
    private String email;

    // Getters and setters
}

定义Mapper接口：

package com.example.demo.mapper;

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

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM user WHERE id = #{id}")
    User getUserById(Long id);

    @Select("INSERT INTO user (name, email) VALUES (#{name}, #{email})")
    void insertUser(User user);
}

在配置文件中配置MyBatis：

mybatis.mapper-locations=classpath:mapper/*.xml

创建Mapper 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="getUserById" resultType="com.example.demo.User">
        SELECT * FROM user WHERE id = #{id}
    </select>
    <insert id="insertUser">
        INSERT INTO user (name, email) VALUES (#{name}, #{email})
    </insert>
</mapper>

在服务类中使用Mapper：

package com.example.demo;

import com.example.demo.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getUserById(Long id) {
        return userMapper.getUserById(id);
    }

    public void insertUser(User user) {
        userMapper.insertUser(user);
    }
}

Spring Boot RESTful服务开发

创建RESTful服务

RESTful架构是一种基于HTTP协议的软件架构风格，强调无状态性和资源的可寻址性。Spring Boot通过Spring MVC支持RESTful服务开发。

定义一个简单的RESTful服务：

package com.example.demo;

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

import java.util.List;

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

    @Autowired
    private UserService userService;

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

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

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

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

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

使用Spring MVC处理HTTP请求

Spring MVC是一个基于Java的Web框架，用于构建Web应用和服务。Spring Boot集成了Spring MVC，提供了简单的方式来处理HTTP请求。

定义请求处理器

package com.example.demo;

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

@RestController
public class ExampleController {

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

    @PostMapping("/greeting")
    public String sendGreeting(@RequestParam String name) {
        return "Hello, " + name + "!";
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        // Retrieve user by ID
        return new User(id, "John Doe", "john@example.com");
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        // Update user by ID
        return user;
    }
}

数据的序列化与反序列化

Spring Boot默认使用Jackson库进行JSON序列化和反序列化。可以自定义Jackson的配置来满足特定的需求。

自定义Jackson配置

package com.example.demo;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JSR310Module;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JacksonConfig {

    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.registerModule(new JSR310Module());
        return objectMapper;
    }
}

Spring Boot企业级功能实现

日志管理与配置

Spring Boot使用SLF4J作为日志门面，并默认集成了一个简单的日志实现，如Logback。

日志配置文件位于src/main/resources/logback-spring.xml。默认情况下，Spring Boot会自动加载该文件。

<configuration>
    <property name="LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss} - %msg%n"/>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>logs/app.log</file>
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>

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

在服务类中使用@Log注解来获取日志记录器：

package com.example.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private static final Logger log = LoggerFactory.getLogger(UserService.class);

    @Autowired
    private UserRepository userRepository;

    public User saveUser(User user) {
        log.info("Saving user: {}", user.getName());
        return userRepository.save(user);
    }
}

异常处理与全局异常捕获

Spring Boot提供了异常处理机制，可以捕获并处理未被捕获的异常。

定义一个全局异常处理器：

package com.example.demo;

import com.example.demo.exception.UserNotFoundException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex) {
        ErrorResponse errorResponse = new ErrorResponse(ex.getMessage());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception ex) {
        ErrorResponse errorResponse = new ErrorResponse(ex.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

定义一个异常响应类：

package com.example.demo;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;

import java.time.LocalDateTime;

@Data
public class ErrorResponse {

    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS")
    private LocalDateTime timestamp;

    private int status;

    private String error;

    private String message;

    public ErrorResponse(String message) {
        this.timestamp = LocalDateTime.now();
        this.message = message;
        this.status = 500;
    }
}

安全性配置与认证

Spring Boot集成了Spring Security框架，提供了强大的安全性支持。通过spring-boot-starter-security依赖来引入Spring Security。

添加安全依赖：

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

配置Spring Security：

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(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user")
            .password(passwordEncoder().encode("password"))
            .roles("USER");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .antMatchers("/user/**").hasRole("USER")
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

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

Spring Boot应用部署与监控

应用打包与部署

Spring Boot应用可以通过Maven或Gradle构建工具进行打包。Maven通常生成一个包含所有依赖的可执行JAR文件。

在pom.xml中配置打包插件：

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

运行mvn clean package命令生成JAR文件：

mvn clean package

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

java -jar target/spring-boot-demo.jar

应用监控与健康检查

Spring Boot提供了一系列健康检查端点，可以用来监控应用的运行状态。默认的健康检查端点是/actuator/health。

添加Spring Boot Actuator依赖：

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

访问健康检查端点：

curl http://localhost:8080/actuator/health

输出如下：

{
  "status": "UP"
}

使用Spring Boot Actuator进行应用监控

Spring Boot Actuator提供了许多端点，可以用来监控应用的各个方面。例如，/actuator/info用于获取应用基本信息，/actuator/metrics用于获取应用的度量信息。

在application.properties中配置Actuator端点：

management.endpoints.web.exposure.include=health,info,metrics

查看应用基本信息：

curl http://localhost:8080/actuator/info

输出如下：

{
  "app.name": "spring-boot-demo",
  "app.version": "0.0.1-SNAPSHOT"
}

查看应用度量信息：

curl http://localhost:8080/actuator/metrics

输出如下：

{
  "metrics": [
    {
      "name": "counter.count",
      "description": "A count of the number of times this metric has been incremented.",
      "baseUnit": "none",
      "measurements": [
        {
          "statistic": "COUNT",
          "value": 0
        }
      ],
      "availableMetrics": []
    }
  ]
}

以上是Spring Boot企业级开发实战入门教程的全部内容，涵盖了从环境搭建到应用部署与监控的各个重要环节。希望这些内容能够帮助你快速入门Spring Boot开发。如果你希望进一步学习Spring Boot的相关技术，可以参考慕课网的相关课程。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

Qyouu

手记
篇

粉丝

88

获赞与收藏

414

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30980 346

网络编程入门教程

20个小节 12758 240

Pandas 入门教程

25个小节 18643 345

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Spring Boot企业级开发实战入门教程

什么是Spring Boot

快速搭建开发环境

安装Java

安装Maven或Gradle

安装IDEA

使用IDEA创建Spring Boot项目

Spring Boot的核心特性

简化配置

内嵌容器

自动装配

命令行参数

应用自动配置

属性配置管理

数据库连接与操作

使用JPA进行数据访问

连接MyBatis完成复杂的数据访问

创建RESTful服务

使用Spring MVC处理HTTP请求

定义请求处理器

数据的序列化与反序列化

自定义Jackson配置

日志管理与配置

异常处理与全局异常捕获

安全性配置与认证

应用打包与部署

应用监控与健康检查

使用Spring Boot Actuator进行应用监控

阅读免费教程