Spring Boot 基础篇（章节1）

最新推荐文章于 2022-08-31 07:51:48 发布

麦田里的守望者·

最新推荐文章于 2022-08-31 07:51:48 发布

阅读量357

点赞数 2

分类专栏： Java编程文章标签： Spring SpringBoot Maven IDEA

本文链接：https://blog.csdn.net/weixin_38231448/article/details/90053580

版权

Java编程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

作者：jiangzz 电话：15652034180 微信：jiangzz_wx 微信公众账号：jiangzz_wy

Spring Boot是构建所有基于Spring的应用程序的起点，旨在只需最少的Spring前端配置尽可能快地启动和运行。 Spring Boot对构建生产就绪应用程序有着自己的态度和观点。

使用Spring Initializr在几秒钟内开始使用一个基于Spring的应用程序
构建任何东西：REST API，WebSocket，Web，Streaming，Task等
支持NoSQL和SQL
嵌入式运行时支持：Tomcat，Jetty和Undertow
开发人员生产工具，如LiveReload和Auto Restart
精心策划的依赖项
生产就绪功能，例如trace，metrics和运行状况

第一个SpringBoot应用程序

环境准备

在开始之前，打开终端并运行以下命令以确保安装了有效的Java和Maven版本：

C:\Users\Administrator>java -version
java version "1.8.0_161"
Java(TM) SE Runtime Environment (build 1.8.0_161-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.161-b12, mixed mode)

C:\Users\Administrator>mvn -v
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47+08:00)
Maven home: D:\Program Files\apache-maven-3.3.9
Java version: 1.8.0_121, vendor: Oracle Corporation
Java home: D:\Program Files\Java\jdk1.8.0_121\jre
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 7", version: "6.1", arch: "amd64", family: "dos"

POM文件

<?xml version="1.0" encoding="UTF-8"?>
<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.jiangzz</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>
    
    
</project>

Spring Boot提供了许多“Starters”，可以将jar添加到类路径中。我们的示例应用程序已经在POM的父节中使用了spring-boot-starter-parent。 spring-boot-starter-parent是一个特殊的启动器，提供有用的Maven默认值。它还提供了一个依赖项管理部分，以便您可以省略依赖项的版本标记。

Classpath依赖

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

告知Spring使用内嵌tomcat和SpringMVC

写启动代码

要完成应用程序，需要创建一个Java文件。默认情况下，Maven从src / main / java编译源代码，因此您需要创建该文件夹结构，然后添加名为src/main/ java /Example.java的文件以包含以下代码：

@RestController
@EnableAutoConfiguration
public class Example {
    @RequestMapping("/")
    String home() {
        return "Hello World!";
    }

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

@EnableAutoConfiguration这个注释告诉Spring Boot根据你添加的jar依赖关系“猜测”你想要如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，因此自动配置假定您正在开发Web应用程序并相应地设置Spring。SpringApplication引导我们的应用程序，启动Spring，然后启动自动配置的Tomcat Web服务器。你打开一个浏览器到http://localhost:8080，你应该看到以下输出：Hello World输出。

创建可执行jar

我们通过创建一个完全自包含的可执行jar文件来完成我们的示例，我们可以在生产中运行它。可执行jar（有时称为“fat jar”）是包含已编译类以及代码需要运行的所有jar依赖项的归档。要创建可执行jar，我们需要将spring-boot-maven-plugin添加到我们的pom.xml中。为此，请在依赖项部分下方插入以下行：

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

运行mvn package，可以获取一个可以执行的jar，运行该jar：

C:\Users\Administrator\IdeaProjects\20190304\springboot\target>java -jar springb
oot-0.0.1-SNAPSHOT.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.1.4.RELEASE)

启动方式

SpringApplication#run

package com.jiangzz;

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

@SpringBootApplication
public class Application {

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

}

实例化 SpringApplication

package com.jiangzz;

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

@SpringBootApplication
public class Application {

    public static void main(String[] args) throws Exception {
       
        SpringApplication app = new SpringApplication(Application.class);
        app.setBannerMode(Banner.Mode.CONSOLE);
        app.run(args);
    }

}

SpringApplicationBuilder启动

package com.jiangzz;

import org.springframework.boot.Banner;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;

@SpringBootApplication
public class Application {

    public static void main(String[] args) throws Exception {
        new SpringApplicationBuilder()
                .sources(Application.class)
                .bannerMode(Banner.Mode.OFF)
                .run(args);
    }

}

如果在SpringApplication启动后需要运行某些特定代码，则可以实现ApplicationRunner或CommandLineRunner接口。

@Component
public class SpringApplicationListener implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("==========================================");
        System.out.println(args);
        for (String nonOptionArg : args.getNonOptionArgs()) {
            System.out.println(nonOptionArg+"="+args.getOptionValues(nonOptionArg));
        }
        System.out.println("==========================================");
    }
}

@Component
public class SpringApplicationListener implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("==========================================");
        System.out.println(args);
        System.out.println("==========================================");
    }
}

配置类信息

Spring Boot支持基于Java的配置。虽然可以将SpringApplication与XML源一起使用，但我们通常建议您使用@Configuration.

配置信息导入

导入额外配置类

无需将所有@Configuration放入单个类中。@Import注释可用于导入其他配置类。或者，您可以使用@ComponentScan自动获取所有Spring组件，包括@Configuration类.

导入XML配置

如果您绝对必须使用基于XML的配置，我们建议您仍然使用@Configuration类。当然你可以使用@ImportResource批注来加载XML配置文件。

自动配置

Spring Boot自动配置尝试根据您添加的jar依赖项自动配置Spring应用程序。需要通过将@EnableAutoConfiguration或@SpringBootApplication注释添加到其中一个@Configuration类来选择自动配置。其中@SpringBootApplication等价@EnableAutoConfiguration、@ComponentScan、@Configuration注解一般在项目推荐写@SpringBootApplication注解，同时要求需要将Application该类写在所有类所在包的外面，这样Spring Boot在启动的时候就可以主动的扫描Application类所在的包以及子包中的类。

package com.jiangzz;

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

@SpringBootApplication
public class Application {

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

Application位置

com
 +- jiangzz
         +- Application.java
         |
         +- controller
         |   +- HelloController.java
         |
         +- service
         |   +- OrderService.java
         |   +- UserService.java

替换 Auto-configuration

自动配置是非侵入性的。在任何时候，您都可以开始定义自己的配置以替换自动配置的特定部分。例如，如果添加自己的DataSource bean，则默认的嵌入式数据库支持会退回。如果您需要了解当前正在应用的自动配置以及原因，请使用–debug开关启动您的应用程序。

关闭特点的Auto-configuration Classes

如果发现正在应用您不需要的特定自动配置类，则可以使用@EnableAutoConfiguration的exclude属性禁用它们，如以下示例所示：

import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;

@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
}

如果类不在类路径上，则可以使用批注的excludeName属性并指定完全限定名称。最后，您还可以使用spring.autoconfigure.exclude属性控制要排除的自动配置类列表。

外部配置

Spring Boot允许您外部化配置，以便您可以在不同的环境中使用相同的应用程序代码。您可以使用属性文件，YAML文件，环境变量和命令行参数来外部化配置。属性值可以通过使用@Value注释直接注入您的bean当中，也可以通过Spring的Environment抽象访问，或者是通过@ConfigurationProperties绑定到结构化对象。

@Value使用

@RestController
public class HelloController {
    @Value("${name}")
    private String name;
    @RequestMapping("/")
    String test() {
        return "Hello ~"+name;
    }
}

application.properties

name=zhangsan

Environment

@RestController
public class HelloController {
    @Autowired
    private Environment env;
    
    @RequestMapping("/")
    String test() {
        return "Hello ~"+ env.getProperty("name");
    }
}

ConfigurationProperties

有时候属性太多了，一个个绑定到属性字段上太累，官方提倡绑定一个对象的bean，这里我们建一个UserPropertiesConfigure.java类，顶部需要使用注解@ConfigurationProperties(prefix = “user”)来指明使用哪个

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
</dependency>

@ConfigurationProperties(prefix = "user")
public class UserPropertiesConfigure {
    private String username;
    private Boolean sex;
    @DateTimeFormat(pattern = "yyyy-MM-dd hh:mm:ss")
    private Date birthDay;
    private List<Address> addresses=new ArrayList<>();
  // ...

}

@SpringBootApplication
@EnableConfigurationProperties(UserPropertiesConfigure.class)
public class SpringBootApplicationExample {
    public static void main(String[] args) {
        new SpringApplicationBuilder()
                .sources(SpringBootApplicationExample.class)
                .bannerMode(Banner.Mode.OFF)
                .run(args);
    }
}

application.properties

user.username=zhansgan
user.sex=true
user.birth-day=2019-12-13 10:00:00
user.addresses[0].street=beijing
user.addresses[0].zipcode=001

@RestController
public class HelloController {

    @Autowired
    private SpringBootUserConfigure customConfigure;
    @RequestMapping("/")
    SpringBootUserConfigure test() {
        return customConfigure;
    }
}

可以访问http://localhost:8080/查看以下内容

{
  "username":"zhansgan",
  "sex":true,
  "birthDay":"2019-12-13T02:00:00.000+0000",
  "addresses":[{"zipcode":"001","street":"beijing"}]
}

SpringBoot MyBaits

添加MyBatis依赖

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

application.properties

# 配置数据源
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.type=org.apache.ibatis.datasource.unpooled.UnpooledDataSource

## MyBatis DAO
mybatis.type-aliases-package=com.jiangzz.entities
mybatis.mapper-locations=classpath*:com/jiangzz/dao/*.xml

## 打印SQL
logging.level.root=fatal
logging.level.org.springframework.jdbc=debug
logging.level.com.jiangzz.dao=trace

注意com/jiangzz/dao指的是在Resources目录下创建目录，不是package。注意在配置mybatis.mapper-locations=classpath*:com/jiangzz/dao/*.xml时候必须配置成classpath*:mapper文件，如果不这样配置的在后期的Junit测试会找不到对应的dao接口的Mapper实现。如果不做junit测试可以将修改成classpath:mapper路径。

添加@MapperScans

@SpringBootApplication
@MapperScans(value = {@MapperScan(basePackages = {"com.jiangzz.dao"})})
public class SpringBootApplicationExample {
    public static void main(String[] args) {
        new SpringApplicationBuilder()
                .sources(SpringBootApplicationExample.class)
                .bannerMode(Banner.Mode.OFF)
                .run(args);
    }
}

其中@MapperScan扫描的是IUserDAO所在的接口package信息。

编写DAO、Service类

resource/com/jiangzz/dao/UserDAO.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.jiangzz.dao.IUserDAO">
    <insert id="insert" parameterType="User" useGeneratedKeys="true"  keyProperty="id">
        insert into t_user(name,age,sex,birthDay)values(#{name},#{age},#{sex},#{birthDay})
    </insert>
</mapper>

IUserDAO.java

public interface IUserDAO {
  public void insert(User user);
}

UserService.java

@Service
@Transactional(propagation = Propagation.SUPPORTS)
public class UserService implements IUserService {
  @Autowired
  private IUserDAO userDAO;

  @Transactional(propagation = Propagation.REQUIRED,readOnly = false)
  @Override
  public void saveUser(User user) {
    userDAO.insert(user);
  }
}

集成Junit测试

在原有的依赖中添加如下依赖

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

在maven的测试目录下添加IUserServiceTests测试

@SpringBootTest(classes = SpringBootApplicationExample.class)
@RunWith(SpringRunner.class)
public class IUserServiceTests {
    @Autowired
    private IUserService userService;
    @Test
    public void testInsert(){
        User user = new User("赵小柳", 25, true, new Date());
        userService.saveUser(user);
        System.out.println(user.getId());
    }
}

在这里插入图片描述

Spring Boot Jsp 视图

导入依赖

<dependency>
  <groupId>org.apache.tomcat.embed</groupId>
  <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

创建目录结构

在这里插入图片描述

添加如下配置

## 配置视图解析
spring.mvc.view.prefix= /WEB-INF/views/
spring.mvc.view.suffix=.jsp

# 开启jsp页面热加载
server.servlet.jsp.init-parameters.development=true

创建Controller

@Controller
public class UserController {
    
    @Autowired
    private IUserService userService;

    @RequestMapping("/addUser")
    public String test(User user){
        System.out.println(userService.getClass());
       userService.saveUser(user);
       return "index";
    }
    
}