第七色在线视频,2021少妇久久久久久久久久,亚洲欧洲精品成人久久av18,亚洲国产精品特色大片观看完整版,孙宇晨将参加特朗普的晚宴

為了賬號安全，請及時(shí)綁定郵箱和手機(jī)立即綁定

Springboot框架入門：新手必讀教程

標(biāo)簽：
SpringBoot
概述

Spring Boot框架入门教程旨在帮助新手快速掌握Spring Boot框架的核心概念和开发技巧，通过自动配置、嵌入式服务器和开箱即用的功能简化开发过程。本文详细介绍了环境搭建、常用注解详解、项目实战及错误排查等内容，帮助开发者提升开发效率和应用质量。

Spring Boot框架入门：新手必读教程
Spring Boot简介

Spring Boot概述

Spring Boot 是一个由 Pivotal 团队提供的框架，它基于 Spring 框架，旨在简化新 Spring 应用程序的初始搭建以及开发过程。Spring Boot 设计的主要目标是简化 Spring 应用的初始搭建以及开发过程，使得开发者可以更加专注于业务逻辑的开发，而不需要过多地关注配置细节。

Spring Boot 通过约定优于配置的思想，大幅减少了代码量和配置文件量，使得开发者能够更快速地搭建和开发应用。它可以自动配置 Spring 应用，包括创建和配置各种组件，如数据源、事务管理器、视图解析器等。

Spring Boot的优势

  • 快速开发：Spring Boot 减少了配置文件的编写，降低了复杂度，使得开发人员可以快速搭建开发环境。
  • 开箱即用：Spring Boot 提供了很多开箱即用的功能，如 Web 服务、数据库连接、缓存管理等，使得开发者可以专注于业务逻辑的实现。
  • 嵌入式服务器：Spring Boot 可以嵌入 Tomcat、Jetty 等服务器，使得开发者可以直接运行应用，而不需要额外部署到服务器上。
  • 自动配置：Spring Boot 可以自动配置各种组件，如数据源、事务管理器、视图解析器等，使得开发者可以更加专注于业务逻辑的实现。
  • 健康检查：Spring Boot 提供了健康检查的功能，可以自动检测应用的运行状态，帮助开发者及时发现和解决问题。

Spring Boot的核心概念

  • 自动配置：Spring Boot 通过 @EnableAutoConfiguration 注解实现了自动配置的功能，它会根据类路径中的依赖设置默认配置。例如，如果项目中存在 spring-webmvc 依赖，那么 Spring Boot 会自动配置 DispatcherServlet 和相关组件。
  • Spring Boot Starter：Spring Boot Starter 是一系列的依赖管理模块，它们包含了各种配置和依赖，可以帮助开发者快速搭建应用。例如，spring-boot-starter-web 模块包含了 Web 服务的配置和依赖，spring-boot-starter-data-jpa 模块包含了 JPA 的配置和依赖。
  • Spring Boot Actuator：Spring Boot Actuator 是一个提供生产就绪功能的模块，它可以监控应用的运行状态，提供健康检查、指标收集等功能。
环境搭建

开发工具选择

开发 Spring Boot 应用推荐使用 IntelliJ IDEA 或 Eclipse。这两款开发工具都支持 Spring Boot 插件，可以方便地创建、运行和调试 Spring Boot 应用。

IntelliJ IDEA

  1. 安装 IntelliJ IDEA；
  2. 创建一个新的 Spring Boot 项目；
  3. 选择所需的依赖和配置；
  4. 点击“Finish”完成项目创建；
  5. 可以使用 IDE 的内置终端或者外部终端来运行项目。

示例代码：

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

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

Eclipse

  1. 安装 Eclipse；
  2. 创建一个新的 Spring Boot 项目；
  3. 选择所需的依赖和配置；
  4. 点击“Finish”完成项目创建；
  5. 可以使用 IDE 的内置终端或者外部终端来运行项目。

示例代码：

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

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

Maven和Gradle的使用

Maven 和 Gradle 是两个常用的构建工具，它们可以管理项目的依赖、编译、打包和部署等任务。Spring Boot 项目可以使用 Maven 或 Gradle 来进行构建。

Maven

项目中需要添加 spring-boot-starter-parent 作为父模块，并在 pom.xml 配置文件中添加相应依赖。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.4</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>

Gradle

项目中需要添加 springBootPlugin 作为插件，并在 build.gradle 配置文件中添加相应依赖。

plugins {
    id 'org.springframework.boot' version '2.7.4'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
}

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

创建第一个Spring Boot项目

创建一个简单的 Spring Boot 应用，实现一个简单的 HTTP 服务，响应客户端的请求。

使用Maven创建项目

  1. 创建一个新的 Maven 项目；
  2. 指定 ArtifactId 和 GroupId，并引入 spring-boot-starter-web 依赖；
  3. 在 src/main/java 目录下创建一个简单的控制器，实现一个 HTTP 服务；
  4. 配置 pom.xml 文件，添加 spring-boot-starter-parent 作为父模块；
  5. 通过 IDEA 或 Eclipse 运行项目，访问 http://localhost:8080 查看结果。

示例代码：

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
@RestController
public class Application {
    @GetMapping("/")
    public String hello() {
        return "Hello, World!";
    }

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

使用Gradle创建项目

  1. 创建一个新的 Gradle 项目；
  2. 添加 spring-boot-starter-web 依赖；
  3. 在 src/main/java 目录下创建一个简单的控制器，实现一个 HTTP 服务；
  4. 通过 IDEA 或 Eclipse 运行项目，访问 http://localhost:8080 查看结果。

示例代码：

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
@RestController
public class Application {
    @GetMapping("/")
    public String hello() {
        return "Hello, World!";
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
Spring Boot常用注解详解

@SpringBootApplication

@SpringBootApplication 注解是一个组合注解，它包含了以下几个注解的功能：

  • @Configuration：表示该类是一个配置类，可以包含 @Bean 注解的方法，用于定义和配置 Spring 应用中的组件。
  • @EnableAutoConfiguration：表示开启自动配置功能。
  • @ComponentScan：表示扫描当前包及其子包下的 @Component 及其派生注解（@Service, @Repository, @Controller）定义的类。

示例代码：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@EnableAutoConfiguration
@ComponentScan
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Controller, @Service, @Repository, @Component

  • @Controller：用于定义控制器类，它会将 HTTP 请求映射到类的方法上。
  • @Service：用于定义服务类，它通常包含业务逻辑。
  • @Repository：用于定义数据访问层类，它通常包含数据访问逻辑。
  • @Component：是一个通用的注解，用于定义 Spring 组件。它可以用于定义控制器、服务、数据访问层等类。

示例代码：

import org.springframework.stereotype.Component;

@Component
public class MyComponent {
    // 组件的逻辑代码
}
import org.springframework.stereotype.Service;

@Service
public class MyService {
    // 服务的逻辑代码
}
import org.springframework.stereotype.Repository;

@Repository
public class MyRepository {
    // 数据访问层的逻辑代码
}
import org.springframework.stereotype.Controller;

@Controller
public class MyController {
    // 控制器的逻辑代码
}

@RestController和@RequestMapping

  • @RestController：用于定义 RESTful 风格的控制器类，它会将 HTTP 请求映射到类的方法上，并返回 JSON 或 XML 格式的响应。
  • @RequestMapping：用于定义 URL 映射规则，它可以定义在类或方法上。

示例代码：

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 MyController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}
Spring Boot项目实战

数据库集成（JPA、MyBatis等）

JPA

  1. 添加 spring-boot-starter-data-jpa 和数据库驱动依赖；
  2. 配置数据库连接信息；
  3. 创建实体类；
  4. 创建一个继承 JpaRepository 的接口，用于定义持久层操作。

示例代码：

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

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

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

实体类定义：

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

@Entity
public class MyEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // 构造函数、getter和setter方法
}

持久层接口定义：

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

public interface MyRepository extends JpaRepository<MyEntity, Long> {
}

MyBatis

  1. 添加 mybatis-spring-boot-starter 和数据库驱动依赖；
  2. 配置数据库连接信息；
  3. 创建实体类；
  4. 创建映射文件；
  5. 创建一个继承 Mapper 的接口，用于定义持久层操作。

示例代码：

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

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

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

实体类定义：

public class MyEntity {
    private Long id;
    private String name;

    // 构造函数、getter和setter方法
}

映射文件定义：

<mapper namespace="com.example.demo.MyMapper">
    <select id="selectById" resultType="com.example.demo.MyEntity">
        SELECT * FROM my_table WHERE id = #{id}
    </select>
</mapper>

持久层接口定义：

import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface MyMapper {
    MyEntity selectById(Long id);
}

RESTful API的开发

  1. 创建一个控制器类，定义 RESTful API；
  2. 使用 @RequestMapping 和 @GetMapping、@PostMapping 等注解定义 URL 映射规则；
  3. 定义服务类，实现业务逻辑；
  4. 定义持久层接口，实现数据访问逻辑。

示例代码：

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 MyController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}
import org.springframework.stereotype.Service;

@Service
public class MyService {
    public String sayHello() {
        return "Hello, World!";
    }
}
import org.springframework.stereotype.Repository;

@Repository
public class MyRepository {
    public String sayHello() {
        return "Hello, World!";
    }
}

静态资源的处理

  1. 在 src/main/resources 目录下创建一个 static 目录，用于存放静态资源文件；
  2. 配置 application.properties 文件，设置静态资源的访问路径。

示例代码：

# application.properties
spring.mvc.static-path-pattern=/static/**

在 src/main/resources/static 目录下创建一个 index.html 文件，可以访问 http://localhost:8080/static/index.html 查看结果。

<!DOCTYPE html>
<html>
<head>
    <title>My App</title>
</head>
<body>
    <h1>Hello, World!</h1>
</body>
</html>

配置文件的使用（application.properties, application.yml）

Spring Boot 支持使用 application.properties 和 application.yml 文件来配置应用。

  1. 在 src/main/resources 目录下创建 application.properties 或 application.yml 文件；
  2. 在文件中配置应用的各种属性；
  3. 在代码中使用 @Value 注解或 Environment 接口来读取配置文件中的属性。

示例代码：

# application.properties
app.name=My App
app.version=1.0.0
# application.yml
app:
  name: My App
  version: 1.0.0

在代码中读取配置文件中的属性：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

@Configuration
public class AppConfig implements ApplicationRunner {
    @Value("${app.name}")
    private String appName;

    @Value("${app.version}")
    private String appVersion;

    @Override
    public void run(ApplicationArguments args) {
        Environment env = args.getEnvironment();
        System.out.println("App Name: " + appName);
        System.out.println("App Version: " + appVersion);
    }
}
错误排查与常见问题

日志配置

日志配置文件通常位于 src/main/resources 目录下的 logback-spring.xml 或 log4j2.xml 文件中。

  1. 创建日志配置文件；
  2. 配置日志输出级别、文件路径等；
  3. 配置日志的格式；
  4. 配置日志的滚动策略。

示例代码：

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

    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>
<!-- log4j2.xml -->
<Configuration>
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} - %-5level - %logger{36} - %msg%n"/>
        </Console>
    </Appenders>
    <Loggers>
        <Root level="info">
            <AppenderRef ref="Console"/>
        </Root>
    </Loggers>
</Configuration>

常见异常分析

  • No qualifying bean of type：当 Spring Boot 无法找到类型匹配的 Bean 时，会抛出该异常。
  • Circular reference：当依赖关系形成环时，会抛出该异常。
  • ClassNotFound：当类路径中找不到指定的类时，会抛出该异常。
  • HttpMediaTypeNotAcceptableException：当客户端请求的媒体类型与服务端提供的媒体类型不匹配时，会抛出该异常。
  • DuplicateComponentDefinitionException：当定义了多个相同名称的组件时，会抛出该异常。

案例分享及解决方法

案例1：No qualifying bean of type

当 Spring Boot 无法找到类型匹配的 Bean 时，会抛出该异常。解决方法是检查依赖的配置是否正确，确保所有需要的依赖都已经被添加到项目中。

示例代码：

import org.springframework.stereotype.Component;

@Component
public class MyComponent {
    // 组件的逻辑代码
}

在配置文件中添加相应的依赖：

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

案例2：Circular reference

当依赖关系形成环时，会抛出该异常。解决方法是检查依赖的定义是否正确，避免循环依赖。

示例代码：

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

@Component
public class ComponentA {
    @Autowired
    private ComponentB componentB;

    @Autowired
    private ComponentC componentC;
}

@Component
public class ComponentB {
    @Autowired
    private ComponentA componentA;
}

@Component
public class ComponentC {
    @Autowired
    private ComponentA componentA;
}

可以通过引入中间对象来避免循环依赖：

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

@Component
public class ComponentA {
    @Autowired
    private ComponentB componentB;

    @Autowired
    private ComponentC componentC;
}

@Component
public class ComponentB {
    @Autowired
    private ComponentA componentA;
}

@Component
public class ComponentC {
    @Autowired
    private ComponentA componentA;
}
总结与进阶指南

项目部署与打包

  1. 使用 spring-boot-maven-plugin 或 spring-boot-gradle-plugin 打包项目；
  2. 生成的 *.jar 文件可以使用 java -jar 命令运行；
  3. 部署到 Linux 服务器上。

示例代码：

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

tasks.named('bootJar') {
    manifest {
        attributes 'Implementation-Title': 'My Application',
                   'Implementation-Version': version
    }
}

常见框架集成

  • Spring Security：用于实现安全管理，如用户认证、权限控制等。
  • Spring Data JPA：用于简化数据访问逻辑。
  • Spring WebFlux：用于构建响应式 Web 应用。
  • Spring Cloud：用于构建微服务应用。
  • Spring Boot Actuator：提供生产就绪功能，如健康检查、指标收集等。

推荐资源与学习路径

  • 慕课网：提供丰富的 Spring Boot 课程和实战项目，适合不同层次的学习者。
  • 官方文档：Spring Boot 官方文档提供了详细的教程和示例，适合深入学习。
  • Spring Boot官方GitHub仓库：提供了大量的示例代码和文档，适合动手实践。
  • Stack Overflow：提供大量的 Spring Boot 相关问题和解决方案，适合解决实际问题。
  • Spring Boot开发者邮件列表：提供最新的 Spring Boot 开发者新闻和指南，适合跟踪 Spring Boot 的最新动态。

通过持续的学习和实践，逐步掌握 Spring Boot 的核心概念和实战技巧，提升开发效率和应用质量。

點(diǎn)擊查看更多內(nèi)容
為 TA 點(diǎn)贊

若覺得本文不錯(cuò)，就分享一下吧！

評論

作者其他優(yōu)質(zhì)文章

正在加載中
  • 推薦
  • 評論
  • 收藏
  • 共同學(xué)習(xí)，寫下你的評論
感謝您的支持，我會繼續(xù)努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進(jìn)行掃碼打賞哦
今天注冊有機(jī)會得

100積分直接送

付費(fèi)專欄免費(fèi)學(xué)

大額優(yōu)惠券免費(fèi)領(lǐng)

立即參與 放棄機(jī)會
微信客服

購課補(bǔ)貼
聯(lián)系客服咨詢優(yōu)惠詳情

 幫助反饋 APP下載

慕課網(wǎng)APP
您的移動學(xué)習(xí)伙伴

 公眾號

掃描二維碼
關(guān)注慕課網(wǎng)微信公眾號

舉報(bào)

0/150
提交
取消