为了账号安全,请及时绑定邮箱和手机立即绑定

Springboot框架学习之入门指南

标签:
SpringBoot
概述

本文提供了Spring Boot框架学习的入门指南,涵盖了Spring Boot的基本概念、优势和特点,以及环境搭建和项目开发的具体步骤。文章详细介绍了从创建项目到配置环境、编写代码和运行应用的全过程,并讲解了异常处理和日志管理。

Spring Boot简介

Spring Boot是什么

Spring Boot 是由 Pivotal 团队提供的一个基于 Spring 平台的快速开发框架。它的设计旨在简化 Spring 应用的初始配置和开发流程,使开发者能更快地开发出独立的、生产级别的应用。Spring Boot 最大的特点是通过约定大于配置的方式,使得开发人员无需编写大量的配置代码,可以快速地创建和运行项目。例如,一个简单的启动类可以这样定义:

package com.example.demo;

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

Spring Boot的优势和特点

  1. 自动配置:Spring Boot 能够根据项目中的依赖自动配置相应的组件,从而减少大量的 XML 配置。
  2. starter 依赖管理:使用 Spring Boot starter,可以轻松地在项目中添加所需的依赖,如 Spring Boot Starter Data JPA、Spring Boot Starter Web 等,减少手动管理依赖的工作量。
  3. 嵌入式服务器:Spring Boot 默认集成了嵌入式的 Tomcat、Jetty 或者 Undertow,无需手动安装和配置外部服务器。
  4. 外部化配置:配置信息可以从文件、系统环境变量、命令行参数或 Java 系统属性等方式获取,支持多种配置方式。
  5. 健康检查:提供了一系列的健康检查功能,便于监控应用的健康状况。
  6. Actuator:提供了大量生产中常用的端点,帮助监控和管理应用,例如查看应用的环境信息、线程信息、HTTP 请求统计等。
  7. Spring MVC:内嵌了 Spring MVC,简化了 Web 应用的开发流程。

Spring Boot与Spring的区别

  1. 传统 Spring 配置繁琐:传统的 Spring 开发需要大量的 XML 配置文件,而 Spring Boot 通过约定优于配置的方式,大大减少了配置的工作量。
  2. 自动配置简化开发:Spring Boot 自动配置了许多常用的组件,如数据源、事务管理器等,开发人员只需要引入相应的依赖,即可完成配置。
  3. 嵌入式Web服务器:Spring Boot 默认集成了嵌入式的 Web 服务器,而传统 Spring 需要手动配置 Web 服务器。
  4. starter 依赖简化配置:Spring Boot 提供了大量的 starter 依赖,可以直接引入,简化了依赖管理和配置过程。
  5. 快速原型开发:Spring Boot 适合快速原型开发和微服务开发,可以快速搭建起一个完整的应用。
环境搭建

开发工具的选择和下载

开发 Spring Boot 应用通常推荐使用以下工具:

  1. IDEA:推荐使用 IntelliJ IDEA,因为它对 Spring Boot 有良好的支持,提供了代码补全、项目结构管理等特性。
  2. Eclipse:也可以使用 Eclipse,同样支持 Spring Boot 的开发。
  3. Maven:使用 Maven 进行依赖管理和构建。
  4. Gradle:也可以选择使用 Gradle,它是一个更为现代的构建工具,支持更复杂的构建逻辑。
  5. Spring Boot CLI:命令行工具,可以用于快速创建和运行 Spring Boot 应用。

创建Spring Boot项目

创建一个 Spring Boot 项目,可以通过 Spring Initializr 来快速搭建。以下是创建项目的基本步骤:

  1. 访问 Spring Initializr
  2. 选择合适的项目类型(如 Maven 项目)。
  3. 选择合适的语言(如 Java)和版本。
  4. 选择 Spring Boot 的版本(如 2.4.0)。
  5. 选择项目基本信息,包括组ID(如 com.example)、项目名(如 demo)等。
  6. 选择需要的依赖(如 Web、Thymeleaf、JPA 等)。
  7. 点击生成,下载压缩包。
  8. 解压下载的压缩包,导入 IDE 中进行开发。

配置项目环境

在 IDE 中打开生成的项目后,需要进行一些基本的配置:

  1. Maven 配置
    打开项目的 pom.xml 文件,查看依赖配置。Spring Boot Starter 依赖已经自动添加,如:

    <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-thymeleaf</artifactId>
       </dependency>
       <dependency>
           <groupId>com.h2database</groupId>
           <artifactId>h2</artifactId>
           <scope>runtime</scope>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
    </dependencies>
  2. IDE 配置
    在 IDE 中设置 Java 版本、编码格式等。例如,在 IntelliJ IDEA 中,设置项目 SDK 和文件编码为 UTF-8。

  3. 启动类配置
    在项目的主目录下创建启动类(通常命名为 Application),例如:

    package com.example.demo;
    
    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);
       }
    }
第一个Spring Boot应用

创建控制器(Controller)

控制器用于处理 HTTP 请求,并将结果返回给客户端。创建一个简单的控制器类,用于响应 HTTP GET 请求并返回 "Hello World":

package com.example.demo;

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

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

创建服务层(Service)

服务层用于封装业务逻辑,通常与数据库交互。创建一个简单的服务类,用于返回用户信息:

package com.example.demo;

public class UserService {
    public User getUserById(Long id) {
        // 模拟数据库查询
        return new User(id, "John Doe");
    }
}

创建数据访问层(Repository)

数据访问层用于与数据库交互,通常使用 JPA 或 MyBatis 等持久化框架。创建一个简单的 JPA Repository:

package com.example.demo;

import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Repository
public class UserRepository {
    @PersistenceContext
    private EntityManager entityManager;

    public User findUserById(Long id) {
        return entityManager.find(User.class, id);
    }
}

运行项目

  1. 在 IDE 中运行 Application 类的 main 方法。
  2. 打开浏览器,访问 http://localhost:8080/hello,可以看到返回的 "Hello World"。
  3. 测试服务层和数据访问层:

    package com.example.demo;
    
    import org.springframework.boot.CommandLineRunner;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.Bean;
    
    @SpringBootApplication
    public class Application {
       public static void main(String[] args) {
           SpringApplication.run(Application.class, args);
       }
    
       @Bean
       public CommandLineRunner commandLineRunner(UserService userService, UserRepository userRepository) {
           return args -> {
               User user = userService.getUserById(1L);
               User dbUser = userRepository.findUserById(1L);
               System.out.println("User from Service: " + user);
               System.out.println("User from Repository: " + dbUser);
           };
       }
    }
常见配置文件讲解

application.properties和application.yml文件介绍

Spring Boot 支持两种配置文件格式:.properties.yml。以下是它们的使用方法:

application.properties

# 配置端口号
server.port=8081

# 配置数据库
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 配置JPA
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

application.yml

server:
  port: 8081

spring:
  datasource:
   url: jdbc:mysql://localhost:3306/test
   username: root
   password: root
   driver-class-name: com.mysql.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

常见配置项详解

数据库连接

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

JPA 配置

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

日志配置

logging.level.root=INFO
logging.level.org.springframework.web=DEBUG

动态配置

动态配置可以通过环境变量或命令行参数传递。例如,启动应用时通过命令行传递环境变量:

java -jar myapp.jar --server.port=8082
异常处理和日志管理

异常处理概述

Spring Boot 提供了全局异常处理机制,可以捕获和处理应用程序中的异常。通常使用 @ControllerAdvice 注解来实现全局异常处理。

使用@ControllerAdvice进行全局异常处理

创建一个全局异常处理器类:

package com.example.demo;

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(Exception.class)
    public ResponseEntity<String> handleException(Exception e) {
        return new ResponseEntity<>("An error occurred: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

Spring Boot 日志配置

Spring Boot 使用 Logback 作为默认的日志框架。可以通过 application.propertiesapplication.yml 文件配置日志级别和输出格式。

application.properties

logging.level.root=INFO
logging.level.org.springframework.web=DEBUG
logging.file.name=app.log
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n

application.yml

logging:
  level:
    root: INFO
    org.springframework.web: DEBUG
  file:
    name: app.log
  pattern:
    console: '%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n'

日志级别设置

常见的日志级别包括 TRACEDEBUGINFOWARNERROR。通过配置文件设置不同的日志级别,可以控制日志的详细程度。

项目打包与部署

使用 Maven 打包项目

通过 Maven 打包项目,生成一个可执行的 jar 包。在 pom.xml 文件中添加打包插件配置:

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

然后使用 mvn clean package 命令打包项目:

mvn clean package

创建可执行的 jar 包

打包完成后,生成的 jar 包位于 target 目录下,可以直接运行:

java -jar target/myapp.jar

项目部署到 Tomcat 或服务器

部署到 Tomcat

  1. 将生成的 jar 包复制到 Tomcat 的 webapps 目录。
  2. 修改 pom.xml 文件,添加 Tomcat 插件配置:
    <build>
       <plugins>
           <plugin>
               <groupId>org.apache.tomcat.maven</groupId>
               <artifactId>tomcat7-maven-plugin</artifactId>
               <version>2.2</version>
               <configuration>
                   <port>8080</port>
                   <path>/</path>
               </configuration>
           </plugin>
       </plugins>
    </build>
  3. 使用 mvn tomcat7:run 命令启动 Tomcat 服务器。

部署到服务器

  1. 将生成的 jar 包上传到服务器。
  2. 使用 java -jar myapp.jar 命令启动应用。
  3. 设置服务器定时任务或守护进程来保证应用持续运行。

通过以上步骤,可以完成 Spring Boot 项目的配置、开发、打包和部署,从而构建出一个完整的生产级别应用。

点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

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

100积分直接送

付费专栏免费学

大额优惠券免费领

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

举报

0/150
提交
取消