SpringBoot快速入门one

Spring Boot

SpringBoot
- 1.建立第一个SpringBoot项目
- - 模型快速构建
  - maven构建
- 2.配置文件
- 3.配置文件读取和绑定
- - 1.@value
  - 2.Environment
  - 3.@ConfigurationProperties+@Component
- 4.profile(多环境切换)
- - 1.配置文件切换
  - 2. 虚拟机参数切换
- 5. 内部配置文件的加载顺序
- 6. 外部配置加载顺序
- 7. 使用log4j打印相关日志
- 8. 开发工具
整合框架
- 1.整合Junit
- 2.整合Redis
- 3.整合Mybatis

SpringBoot

快速构建项目，简化配置
思想：SpringBoot提供了一种快速使用Spring的方式，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率
功能：

自动配置
Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。
起步依赖：starter。无需关注版本关系
起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
辅助功能
提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。
简化部署，直接使用maven插件，将项目打成jar包在目标服务器执行即可。

注意：Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式，快速构建项目。

1.建立第一个SpringBoot项目

模型快速构建

勾选依赖–方便：勾选的方式添加启动器场景。不用手写依赖项。

注意模板构建的测试模块类中@SpringBootTest注解默认和引导类包路径一致，故未添加classes属性(classes = AndMybatisApplication.class)

maven构建

创建maven项目
pom文件中导入Springboot起步依赖

继承父工程<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.1.8.RELEASE</version></parent><dependencies><!--web开发的起步依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>

定义一个简单的Controller

@RestController
@RequestMapping("/springboot")
public class HelloController {@RequestMapping("/hello")public String hello(){return " hello Spring Boot !";}
}

编写引导类–：注意引导类的包路径不能直接为java目录下且要在其他类的上一级目录
类中有main方法，可以直接启动项目，打包方式为jar类型

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

启动测试
运行引导类，启动成功后访问

SpringBoot起步依赖原理分析

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

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

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

2.配置文件

配置文件分类
SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。

默认配置文件名称：application

在同一级目录下优先级为：properties>yml > yaml
application.properties：
```
server.port=8080
```
yml：
```
server:port: 8080
```
yaml

yaml语法
大小写敏感
数据值前边必须有空格，作为分隔符
使用缩进表示层级关系
缩进时不许使用tab键(idea允许 )
#表示注释，范围为一行
```
server: port: 8080  address: 127.0.0.1
name: abc
```

yaml数据格式
对象(map)：键值对的集合
数组：一组按次序排列的值
纯量：单个的值。date、boolean、string、number、null
参数引用：

#日期类型
times: 2021/10/12 20:12:33
#对象map：键值对的集合
#1.
person:name: zhangsanage: 12
#2.行内写法
person1: {name: lisi,age: 17}#数组
#1.
address:- ningxia- shanghai
#2.
address1: [xian,shanghai]#纯量
name: haha#参数引用
person3:name: ${name} #引用上边定义的name值age: 18

3.配置文件读取和绑定

1.@value

适用于少量数据

//对象map@Value("${person.name}")private String name1;//数组@Value("${address[0]}")private String a;//纯量@Value("${name}")private String name;//参数引用@Value("${person3.name}")private String name3;//通过@Value来取值@RequestMapping("/hello2")public String hello2(){System.out.println(name1);System.out.println(name);System.out.println(a);System.out.println(name3);return " hello Spring Boot !";}

2.Environment

注入对象来调用方法获取yaml文件中的值

//通过Evironment对象取值@Autowiredprivate Environment env;@RequestMapping("/hello3")public String hello3(){//获取纯量System.out.println(env.getProperty("name"));//获取对象System.out.println(env.getProperty("person.age"));//获取数组System.out.println(env.getProperty("address[1]"));//参数引用System.out.println(env.getProperty("person3.name"));return " hello Spring Boot !";}

3.@ConfigurationProperties+@Component

或者在任意配置类(有@Configuration注解的类)中添加注解@EnableConfigurationProperties(实体类.class)。
用于对象的数据绑定
注意：prefix一定要写。代表是配置文件中的哪个前缀
实践：
方式一：

person实体类
@Component
@ConfigurationProperties(prefix = "person")
public class Person {private String name;private int age;public String getName() {return name;}

方式二：
去除实体类上的@Component注解，在启动类上添加注解@EnableConfigurationProperties(Person.class)即可，因为启动类也是一个配置类

//@ConfigurationProperties方式数据绑定@Autowiredprivate Person person;@RequestMapping("/hello4")public String hello4(){System.out.println(person);return " hello Spring Boot !";}

4.profile(多环境切换)

1.配置文件切换

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

application-dev.properties/yml 开发环境

application-test.properties/yml 测试环境

application-pro.properties/yml 生产环境

#开发环境
server.port=8081

yml多文档方式：
在yml中使用 — 分隔不同配置

#配置多环境生产环境
---
server:port: 8085
spring:profiles: dev
---
server:port: 8086
spring:profiles: pro
---
server:port: 8087
spring:profiles: test

激活方式
- 配置文件激活
  application.properties
  或者bootstrap.yml
  只要优先级比上述定义的文件高即可。
```
spring.profiles.active=dev
```
或者
application.yaml
```
spring:profiles:active: pro
```

2. 虚拟机参数切换

在VM options 指定
-Dspring.profiles.active=dev
打包后参数激活–
- 命令行激活
  项目打包后cmd中执行
  java –jar xxx.jar --spring.profiles.active=dev

5. 内部配置文件的加载顺序

加载顺序为上文的排列顺序，高优先级配置的属性会生效

file:./config/：当前项目下的/config目录下
file:./ ：当前项目的根目录
classpath:/config/：classpath的/config目录
classpath:/ ：classpath的根目录

6. 外部配置加载顺序

外部配置的作用：当项目打包完成后发现有些参数需要更改，则可以添加外部配置文件来及时更改

命令行

java -jar app.jar --name="Spring“ --server.port=9000

指定配置文件位置

 java -jar myproject.jar --spring.config.location=e://application.properties后跟本地配置文件的地址

外部不带profile的properties文件

    classpath:/config/application.propertiesclasspath:/application.properties

7. 使用log4j打印相关日志

在相应类上添加@Slf4j注解
直接使用log.日志级别进行打印即可。

@Slf4j
@RestController
@RequestMapping("/hello")
public class UserController {@Autowiredprivate UserService userService;@RequestMappingpublic String say(@RequestParam String res){log.info("日志记录：请求进来了");return userService.say();}}

如果需要将日志存储到文件则添加配置即可

logging:file: logs.log

原因：lombok依赖中有对log4j的支持

     <dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency>

8. 开发工具

查看SpringIOC容器自动装配Bean。配置后就会在控制台打印装配得Bean都有哪些。

#开启查看自动配置Bean的报告
debug: true

自定义的类和配置文件绑定一般没有提示。
添加该依赖后，在配置文件中编写绑定java对象的参数名称时候会有提示
然后在项目打包时排除该提示jar包

        <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-configuration-processor</artifactId><optional>true</optional></dependency><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.springframework.boot</groupId><artifactId>spring-boot-configuration-processor</artifactId></exclude></excludes></configuration></plugin></plugins></build>

检查代码变更：快速重启
当java文件有变化后重新编译就会重启项目。如果是静态资源的话则重新百编译就会生效，不会重启服务。
只需要引入依赖即可.

<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><optional>true</optional></dependency>
</dependencies>

注意：实际开发还是使用JRebel插件为主，该插件真正意义上的热部署
文章链接如下：
https://blog.csdn.net/weixin_45466462/article/details/117442528

整合框架

1.整合Junit

注意:当测试类和引导类不在命名相同的包路径或子目录下时注解需要配置@SpringBootTest(classes = SpringbootJunitApplication.class )

注意：当测试类包路径和启动类包路径一致或是其子类时，测试类注解中不用添加其字节码文件

搭建SpringBoot工程
引入starter-test起步依赖

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

编写测试类


/*** 测试类*/@SpringBootTest(classes = SpringbootJunitApplication.class )
public class UserServiceTest {@Testpublic void test(){System.out.println(111);}
}

测试

2.整合Redis

搭建SpringBoot工程
引入redis起步依赖

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

配置redis相关属性

spring:redis:host: 127.0.0.1 # redis的主机ipport: 6379

注入RedisTemplate模板
@Autowired
private RedisTemplate redisTemplate;
编写测试方法，测试

@SpringBootTest
public class SpringbootRedisApplicationTests {@Autowiredprivate RedisTemplate redisTemplate;@Testpublic void testSet() {//存入数据redisTemplate.boundValueOps("name").set("zhangsan");}@Testpublic void testGet() {//获取数据Object name = redisTemplate.boundValueOps("name").get();System.out.println(name);}}

3.整合Mybatis

搭建SpringBoot工程
模型创建时需要勾选
引入mybatis起步依赖，添加mysql驱动

<dependencies><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.0</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><!--<scope>runtime</scope>--></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies>

编写DataSource和MyBatis相关配置

application.yml

# datasource
spring:datasource:url: jdbc:mysql:///springboot?serverTimezone=UTCusername: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Driver# mybatis使用mapper文件开发时需要配置，纯注解开发不需要配置
mybatis:mapper-locations: classpath:mapper/*Mapper.xml # mapper映射文件路径type-aliases-package: org.yh.demo.domain# config-location:  # 指定mybatis的核心配置文件，需要分页插件时需要使用

定义表和实体类

public class User {private int id;private String username;private String password;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Overridepublic String toString() {return "User{" +"id=" + id +", username='" + username + '\'' +", password='" + password + '\'' +'}';}
}

编写dao和

纯注解开发

@Mapper
@Repository
public interface IUserDao {@Select("select * from user")//mapper开发时不需要此注解public List<User> findAll();
}

mapper文件开发
mapper.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="org.yh.demo.dao.IUserDao"><select id="findAll" resultType="org.yh.demo.domain.User">select * from user</select>
</mapper>

纯注解开发

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

测试

@SpringBootTest(classes = AndMybatisApplication.class)
class AndMybatisApplicationTests {@AutowiredIUserDao iUserDao;@Testvoid contextLoads() {List<User> all = iUserDao.findAll();System.out.println(all);}
}