springBoot工程入门

springBoot是快速构建spring的技术

基本知识

spring缺点：1. 配置繁琐 2. 依赖繁琐（导包的版本怎么确定）

SpringBoot功能

1. 自动配置
2. 起步依赖，简化依赖的配置
3. 辅助功能 eg.嵌入式服务器、安全、指标

springBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式

官网文档地址：Spring Boot Reference Documentation

在创建项目时候，使用jar的方式打包
引导类是项目入口，运行main方法就可以启动项目
使用springboot和spring构建的项目，业务代码编写方式完全一样

快速搭建springBoot工程

搭建springBoot工程，定义HelloController.hello()方法，返回“Hello SpringBoot”

步骤① 创建Maven项目
步骤② 导入springBoot起步依赖
springboot工程需要继承的父工程：Inheriting the Starter Parent POM

    <!-- springboot工程需要继承的父工程 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.1</version>
    </parent>

    <dependencies>
        <dependency>
            <!--web开发的起步依赖-->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

步骤③定义Controller

步骤④编写引导类

步骤⑤启动测试
运行后，显示在8080端口

浏览器访问http://localhost:8080/hello

或者使用idea的快速构建即可代替上面的配置。

起步依赖·原理分析

spring-boot-starter-parent

spring-boot-starter-parent 中定义了各种技术的版本信息，组合了一套最优搭配的技术版本。

在各种starter中，定义了完成该功能需要的坐标集合，其中大部分版本信息来自于父工程。

我们的工程继承parent、引入starter后，通过依赖传递，就可以简单方便获得需要的jar包，并不会存在版本冲突等问题。

一直查看父工程的配置文件，最终可以看到<properties>下面定义了很多版本信息
<dependencyManagement>中的依赖都根据<properties>来确定包的版本，这就是版本锁定

spring-boot-starter-web

查看配置文件，发现这个包已经自动将一些其他的包导入进来了

配置

默认配置文件明：application

2种配置文件明：properties和yml/yaml

springBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml(application.yaml)配置

• properties
  
• yaml
  
  如果存在多个配置，根据优先级读取：application.properties > application.yml > application.yaml

yaml

拓展名可以使用.yml或.yaml

比较简洁，以数据为中心，
相较于xml，可以少写尾标签
相较于profile，可以看出来同一类的属性

# profile
server.port: 8081

# yaml
server:
  port: 8082

# xml
<server>
	<port>8083</port>
</server>

基本语法

• 大小写敏感
• 数据值前面必须有空格作为分隔符
• 用缩进表示层级关系
  • 缩进不允许使用Tab键，只能用空格，不同系统Tab键的空格数不同
  • 缩进的空格数目不重要，只要相同层级的元素左对齐就行
• # 表示行注释，从这个字符到行尾，都会被解析器忽略

数据格式

• 对象（map）：键值对的集合

person:
  name: soon
  
person: {name: soon} # 行内写法

• 数组：一组按次序排列的值，使用‘-’ 表示数组的每个元素

city:
  - beijing
  - shanghai
 
city: [beijing,shanghai] # 行内写法 

• 纯量：单个值，不可再分

msg1: 'hello1 \n beijing' # 单引号 忽略转义字符
msg2: "hello2 \n shanghai" # 双引号 识别转义字符

• 参数引用：${key}

读取配置

1. @Value获取单个值比较方便，值多了就不方便
2. Environment
3. @ConfigurationProperties配置和对象相护传递

@Value

Environment.getProperty

import org.springframework.core.env.Environment;

@RestController
public class HelloController {
    @Autowired
    private Environment env;

    @RequestMapping("/getName")
    public String hello(){
        System.out.println(env.getProperty("person.name"));
        System.out.println(env.getProperty("city[0]"));
        return env.getProperty("name");
    }
}

@ConfigurationProperties
添加注解处理器的依赖

profile

我们在开发Spring Boot应用时,通常同一套程序会被安装到不同环境,比如:开发、测试生产等。其中数据库地址、服务器端口等等配置都不同，如果每次打包时，都要修改配置文件,那么非常麻烦。
profile功能就是来进行动态配置切换的。

profile配置方式

• 多profile文件方式：提供多个配置文件，每个代表一种环境

  • application-dev.properties/yml开发环境
  • application-test.properties/yml测试环境
  • application-pro.properties/yml生产环境

• yml多文档方式

  • 在yml中使用---分隔不同配置

多profile文件方式

多了三个不同环境的配置：dev pro test，切换环境的时候，只用在application.properties中指定spring.profiles.active
运行之后发现端口就是8081

yml多文档方式

--- # 分割成不同部分
server:
  port: 8081
spring:
  config:
    on-profile: dev
---
server:
  port: 8082
spring:
  config:
    on-profile:  test
---
server:
  port: 8083
spring:
  config:
    on-profile: pro
---
spring:
  profiles:
    active: dev # 使用这个环境

profile激活方式

• 配置文件:在配置文件中配置: spring.profiles.active=dev ，详见多profile文件方式
• 虚拟机参数:在VM options指定: -Dspring.profiles.active=dev
• 命令行参数: java -jar xxjar --spring.profiles.active=dev

虚拟机参数

命令行参数

D:\Java\code\IdeaProjects\springboot-profiles\target> java -j .\springboot-profile-0.0.1-SNAPSHOT.jar --spring.profiles.active=pro

--spring.config.location=配置文件路径 使用外部配置文件
--server.port=8088 端口号改为8088
--server.servlet.context-path=/hello 修改项目的访问路径，默认为/

内部配置加载顺序

Springboot程序启动时，会从以下位置加载配置文件:

1. file:./config/: 当前项目下的/config目录下
2. file:./ :当前项目的根目录
3. classpath:/config/: classpath的/config目录
4. classpath:/ : classpath的根目录

优先级由高到低

打包后，java和resources路径下的内容都会放到classpath路径下

外部配置加载顺序

通过官网查看外部属性加载顺序，后面的属性源可以覆盖前面的属性源中定义的值。

整合其他框架

Junit

SpringBoot整合Junit，步骤：
①搭建SpringBoot工程
②引入starter-test起步依赖

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

③编写测试类

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public void add(int a) {
        System.out.println("添加" + a);
    }
}

④添加测试相关注解

• @RunWith(SpringRunner.class)
• @SpringBootTest(classes =启动类.class)，如果这个测试类和启动了是同一个包，则可以写成@SpringBootTest

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootJunitApplication.class) //main中的引导类
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testAdd(){
        userService.add(1);
    }
}

⑤编写测试方法

redis

SpringBoot整合redis，步骤：
①搭建SpringBoot工程

②引入redis起步依赖

③配置redis相关属性
如果不配置，就是用本机的；可以在配置文件中配置

spring:
  data:
    redis:
      host: 127.0.0.1 # redis的主机ip
      port: 6379

④在测试类中注入RedisTemplate模板

    @Autowired
    private RedisTemplate redisTemplate;

⑤编写测试方法，测试

mybatis

SpringBoot整合mybatis，步骤：
①搭建SpringBoot工程

②引入mybatis起步依赖,添加mysq|驱动

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

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

③编写DataSource和MyBatis相关配置

spring:
  datasource:
    url: jdbc:mysql:///springboot
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

④定义表和实体类

create table t_user
(
    id       int auto_increment
        primary key,
    username varchar(32) collate utf8mb4_unicode_ci null,
    password varchar(32) collate utf8mb4_unicode_ci null
);

public class User {
    Integer id;
    String name;
    String password;
    //生产toString get set 方法
}

⑤编写sql

@Mapper
public interface UserMapper {
    @Select("select * from t_user")
    public List<User> findAll();
}

⑥测试

@RunWith(SpringRunner.class)
@SpringBootTest
class MybatisApplicationTests {
    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        List<User> all = userMapper.findAll();
        for (User user : all) {
            System.out.println(user);
        }
    }

}

也可用xml写sql语句

spring:
  datasource:
    url: jdbc:mysql:///springboot
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

# mybatis
mybatis:
  mapper-locations: classpath:Mapper/*Mapper.xml # mapper映射文件路径
  type-aliases-package: com.example.mybatis.domain # 实体类所在的包，这样resultType就可以不写包名，直接写类名就行