脚本宝典收集整理的这篇文章主要介绍了Java之初探SpringBoot，脚本宝典觉得挺不错的，现在分享给大家，也给大家做个参考。

Java之初探SPRingBoot

About SpringBoot

引用一段狂神的介绍。个人感觉可以理解为是作为SSM的一个优化，将SpringMVC和Spring中繁杂的配置用SpringBoot来代替，减少对于配置的编写和操作，让开发人员更注重于代码本身。

Spring Boot 基于 Spring 开发，Spirng Boot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发者体验的工具。

HelloSpringBoot

项目创建

1、创建一个新项目

2、选择spring inITalizr ， 可以看到默认就是去官网的快速构建工具那里实现

3、填写项目信息

4、选择初始化的组件（初学勾选 Web 即可）

5、填写项目路径

6、等待项目构建成功

项目结构

HellospringbootApplication.java是这个项目的主启动类，application.proPErties是这个项目的配置文件包括后续需要整合JDBC或者Mybatis时，数据库的配置信息都会在这里。之后写的如controller、service、DAO、pojo包都需要在主启动类的同级目录，不然SpringBoot就无法扫描到我们自己编写的业务代码。

Hello SpringBoot Controller

Controller/HelloSpringBootController

@RestController
public class HelloSpringBootController {

    @RequestMapping("/HelloSpringBoot")
    public String hello() {
        return "Hello SpringBoot";
    }

}

项目打jar包

点击maven插件中的package即可，运行完后会在target目录下生成项目jar包

之后也可以通过java -jar的方式在命令行启动项目（SpringBoot自带tomcat）

项目依赖 Pom.XMl

<!-- 该项目的父依赖项目，这里才是它版本的控制中心 -->
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.5.4</version><!-- lookup parent From repository -->
</parent>
<groupId>com.zh1z3ven</groupId>
<artifactId>hellospringboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>hellospringboot</name>
<description>Demo project for Spring Boot</description>

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <!-- 启动器spring-boot-starter；
 springboot-boot-starter-xxx：就是spring-boot的场景启动器
 spring-boot-starter-web：帮我们导入了web模块正常运行所依赖的组件；
 SpringBoot将所有的功能场景做成了一个个的starter，需要用哪个就导入依赖即可，也可以自定义starter

-->
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
  </dependency>

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

<build>
  <plugins>
    <plugin>
      <!-- 项目打包所需的maven插件 -->
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

主启动类 Application

@SpringBootApplication注解用来标注这是一个SpringBoot的主启动类，运行时SpringBoot会寻找该类的main方法运行整个项目

@SpringBootApplication
public class HellospringbootApplication {

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

}

引用下狂神对于SpringBoot自动配置的结论

1. SpringBoot在启动的时候从类路径下的META-iNF/spring.factories中获取EnableAutoconfiguration指定的值
2. 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；
3. 整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
4. 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并配置好这些组件 ；
5. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；

YaML配置

上面也提到了，关于SpringBoot是有一个全局配置文件application.properties的，这是我们在创建一个SpringBoot项目默认帮我们创建的全局配置文件，但有时候也会用yaml去写配置文件（application.yml） 如果工程中同时存在application.properties文件和 application.yml文件，yml文件会先加载，而后加载的properties文件会覆盖yml文件。

SpringBoot使用一个全局的配置文件 ， 配置文件名称是固定的

• application.properties

• • 语法结构 ：key=value

• application.yml

• • 语法结构 ：key：空格 value

示例

.properties

server.prot=8081

.yml

server:
	port: 8081

About Yaml

相比于xml，yaml语法更简洁也更方便阅读，现在很多的配置文件都在慢慢的用yaml而不是xml。

YAML是 "YAML Ain't a Markup Language" （YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是："Yet Another Markup Language"（仍是一种标记语言）

相关语法

字面量（数字、字符串、布尔）

注意赋值时，在:的后面是存在一个 （空格）的，赋值直接写在:后即可，默认字符串也不需要用引号包裹。

但是当字符串中出现转义字符如n时：

1. 双引号，不会转义字符串里面的特殊字符 ， 特殊字符会作为本身想表示的意思，比如n就是换行符
2. 单引号，会转义特殊字符 ， 特殊字符最终会变成和普通字符一样输出，比如n最后输出就是n

k: v

对象、Map（键值对）

这个有点类似于python中的dict

student:
    name: zh1z3ven
    age: 3

一行形式：

student: {name: zh1z3ven,age: 3}

数组（List 、set）

用 - 值表示数组中的一个元素

pets:
 - cat
 - dog
 - pig

一行形式：

pets: [cat,dog,pig]

Yaml注入配置文件

首先看下之前用Spring是如何给bean注入属性值的

@component  //注册bean
public class ADog {
    @Value("1")
    private int id;
    @Value("HanDog")
    private String name;
    @Value("-1")
    private int age;

测试

@SpringBootTest
class HellospringbootApplicationTests {

    @Autowired
    ADog aDog;

    @Test
    void contextLoads() {
        System.out.println(aDog);
    }
}
//		ADog{id=1, name='HanDog', age=-1}

通过yml给属性赋值

先写一个类型较全的实体类

@Component
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private ADog aDog;
  //有参无参构造，get，set，toString
}

application.yml

person:
  name: Zh1z3ven
  age: 18
  happy: false
  birth: 2005-10-10
  maps: {this: wuhu,that: qifei}
  lists:
    - JavaSE
    - JavaWeb
    - SSH
    - SSM
    - SM
  aDog:
    id: -1
    name: HanDog
    age: 16

通过@ConfigurationProperties(prefix = "person")将yml配置文件中我们设置的属性值映射到实体类中。

/*
@ConfigurationProperties作用：
将配置文件中配置的每一个属性的值，映射到这个组件中；
告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
参数 prefix = “person” : 将配置文件中的person下面的所有属性一一对应
*/
@Component	//注册bean
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private ADog aDog;
}

测试

@Autowired
Person person;

@Test
void contextLoads() {
  //System.out.println(aDog);
  System.out.println(person);
}
/*
Person{name='Zh1z3ven', age=18, happy=false, birth=Mon Oct 10 00:00:00 CST 2005, maps={this=wuhu, that=qifei}, lists=[JavaSE, JavaWeb, SSH, SSM, SM], aDog=ADog{id=-1, name='HanDog', age=16}}
*/

加载指定配置文件

@PropertySource加载指定配置文件

@configurationProperties默认从全局配置文件中获取值

与Spring中的属性值注入一样。使用@ConfigurationProperties方式可以进行配置文件与实体字段的自动映射，但需要字段必须提供set方法才可以。

person.properties

name=Zh1z3ven

Person.java

@Component
//@ConfigurationProperties(prefix = "person")
@PropertySource(value = "classpath:person.properties")
public class Person {
    @Value("${name}")
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private ADog aDog;

测试类

@SpringBootTest
class HellospringbootApplicationTests {

    @Autowired
    Person person;

    @Test
    void contextLoads() {
        System.out.println(person);
    }

JSR303数据校验

Springboot中可以用@validated来校验数据，如果数据异常则会统一抛出异常，方便异常中心统一处理。

常见的校验注解

@NotNull(message="名字不能为空")
private String userName;
@Max(value=120,message="年龄最大不能查过120")
private int age;
@Email(message="邮箱格式错误")
private String email;

空检查
@Null       验证对象是否为null
@NotNull    验证对象是否不为null, 无法查检长度为0的字符串
@NotBlank   检查约束字符串是不是Null还有被Trim的长度是否大于0,只对字符串,且会去掉前后空格.
@NotEmpty   检查约束元素是否为NULL或者是EMPTY.
    
Booelan检查
@AssertTrue     验证 Boolean 对象是否为 true  
@AssertFalse    验证 Boolean 对象是否为 false  
    
长度检查
@Size(min=, max=) 验证对象（Array,Collection,Map,String）长度是否在给定的范围之内  
@Length(min=, max=) string is between min and max included.

日期检查
@Past       验证 Date 和 Calendar 对象是否在当前时间之前  
@Future     验证 Date 和 Calendar 对象是否在当前时间之后  
@Pattern    验证 String 对象是否符合正则表达式的规则

Profile

profile是Spring对不同环境提供不同配置功能的支持，可以通过激活不同的环境版本，实现快速切换环境

多配置文件切换版本

可通过配置文件文件名来标识该配置的版本

application-{profile}.properties/yml

application-test.properties 代表测试环境配置

application-dev.properties 代表开发环境配置

在.properties中通过设置spring.profiles.active属性值来切换{profile}版本

spring.profiles.active=dev

yaml多文档块

和properties配置文件中一样，但是使用yml去实现不需要创建多个配置文件

---
server:
  port: 8083
spring:
  profiles: dev #配置环境的名称


---

server:
  port: 8084
spring:
  profiles: prod  #配置环境的名称

在yaml配置文件中切换版本

#选择要激活那个环境块
spring:
  profiles:
    active: prod

PS:如果yml和properties同时都配置了端口，并且没有激活其他环境 ， 默认会使用properties配置文件的

配置文件加载位置

springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件：

优先级1：项目路径下的config文件夹配置文件
优先级2：项目路径下配置文件
优先级3：资源路径下的config文件夹配置文件
优先级4：资源路径下配置文件

默认只要存在配置文件就会按优先级顺序全部加载，各个配置文件会进行互补。

命令行指定配置文件

java -jar spring-boot-config.jar --spring.config.location=F:/application.properties

小结

1、@ConfigurationProperties只需要写一次即可 ， @Value则需要每个字段都添加

2、松散绑定：这个什么意思呢? 比如我的yml中写的last-name，这个和lastName是一样的， - 后面跟着的字母默认是大写的。这就是松散绑定。可以测试一下

3、JSR303数据校验 ， 这个就是我们可以在字段是增加一层过滤器验证 ， 可以保证数据的合法性

4、复杂类型封装，yml中可以封装对象 ， 使用value就不支持

SpringBoot整合Mybatis

导入依赖

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

配置数据库连接

Application.yml

spring:
  datasource:
    username: root
    password: 123456
    #?serverTimezone=UTC解决时区的报错
    url: jdbc:MySQL://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mySQL.jdbc.Driver

pojo

(也可以使用lombok)

package com.zh1z3ven.hellospringboot.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", pwd='" + pwd + ''' +
                '}';
    }
}

UserMapper.java

创建Mapper接口

@Mapper //标记这是一个Mapper
@Repository
public interface UserMapper {
    // 获取所有用户
    List<User> getUser();
}

UserMapper.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.zh1z3ven.hellospringboot.mapper.UserMapper">
    <select id="getUser" resultType="com.zh1z3ven.hellospringboot.pojo.User">
       select * from user;
    </select>
</mapper>

Controller

@Controller
public class UserController {
    @Autowired
    private UserMapper userMapper;

    @GetMapping("/getUser")
    @ResponseBody
    public List<User> getUser() {
        return userMapper.getUser();
    }
}

写在最后

SM的整合相较于SSM明显简单了很多，少了很多繁杂的配置，且配置都可以写在一起放在Properties或者yml中。

简单做个学习记录，熟悉一下SM的整合，后续遇到SpringBoot至少可以上手审计一下。

脚本宝典总结

以上是脚本宝典为你收集整理的Java之初探SpringBoot全部内容，希望文章能够帮你解决Java之初探SpringBoot所遇到的问题。

如果觉得脚本宝典网站内容还不错，欢迎将脚本宝典推荐好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。