01-Springboot-day01.md

**

01-今日内容

  • Spring概述、快速入门
  • SpringBoot配置
  • SpringBoot整合

02-SpringBoot概述

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

SpringBoot功能

1） 自动配置

Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。

2） 起步依赖

起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。

简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

3） 辅助功能

提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。

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

03-SpringBoot快速入门

需求：搭建SpringBoot工程，定义HelloController.hello()方法，返回”Hello SpringBoot!”。

实现步骤：

①创建Maven项目

②导入SpringBoot起步依赖

  1. <!--springboot工程需要继承的父工程-->
  2.     <parent>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-parent</artifactId>
  5.         <version>2.1.8.RELEASE</version>
  6.     </parent>
  8.     <dependencies>
  9.         <!--web开发的起步依赖-->
  10.         <dependency>
  11.             <groupId>org.springframework.boot</groupId>
  12.             <artifactId>spring-boot-starter-web</artifactId>
  13.         </dependency>
  14.     </dependencies>

③定义Controller

  1. @RestController
  2. public class HelloController {
  4.     @RequestMapping("/hello")
  5.     public String hello(){
  6.         return " hello Spring Boot !";
  7.     }
  8. }

④编写引导类

  1. /**
  2.  * 引导类。 SpringBoot项目的入口
  3.  */
  4. @SpringBootApplication
  5. public class HelloApplication {
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(HelloApplication.class,args);
  9.     }
  10. }

⑤启动测试

04-快速构建SpringBoot工程

springboot day01 - 图1

springboot day01 - 图2

springboot day01 - 图3

05-SpringBoot起步依赖原理分析

  • 在spring-boot-starter-parent中定义了各种技术的版本信息，组合了一套最优搭配的技术版本。
  • 在各种starter中，定义了完成该功能需要的坐标合集，其中大部分版本信息来自于父工程。
  • 我们的工程继承parent，引入starter后，通过依赖传递，就可以简单方便获得需要的jar包，并且不会存在版本冲突等问题。

06-SpringBoot配置-配置文件分类

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

  1. 默认配置文件名称：application
  2. 在同一级目录下优先级为：properties>yml > yaml

例如：配置内置Tomcat的端口

properties：

  1. server.port=8080

yml:

  1. server: port: 8080

07-SpringBoot配置-yaml基本语法

  • 大小写敏感
  • 数据值前边必须有空格，作为分隔符
  • 使用缩进表示层级关系
  • 缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的 空格数目可能不同，导致层次混乱）。
  • 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
  • ‘’#” 表示注释，从这个字符一直到行尾，都会被解析器忽略。
  1. server: 
  2.     port: 8080  
  3.     address: 127.0.0.1
  4. name: abc

08-SpringBoot配置-yaml数据格式

对象(map)：键值对的集合。

  1. person:  
  2.    name: zhangsan
  3. # 行内写法
  4. person: {name: zhangsan}

数组：一组按次序排列的值

  1. address:
  2.   - beijing
  3.   - shanghai
  4. # 行内写法
  5. address: [beijing,shanghai]

emList数组中的横杠代表一个数组中的对象,再点属性;

纯量：单个的、不可再分的值

  1. msg1: 'hello \n world'  # 单引忽略转义字符msg2: "hello \n world"  # 双引识别转义字符

参数引用

  1. name: lisi person:  name: ${name} # 引用上边定义的name值

09-SpringBoot配置-获取数据_1

@Value

  1.    #获取普通配置   @Value("${name}")    private String name;    #获取对象属性    @Value("${person.name}")    private String name2;       #获取数组    @Value("${address[0]}")    private String address1;      #获取纯量    @Value("${msg1}")    private String msg1;

Evironment

  1. @Autowired private Environment env;System.out.println(env.getProperty("person.name")); System.out.println(env.getProperty("address[0]"));

10-SpringBoot配置-获取数据_2

@ConfigurationProperties

注意：prefix一定要写

  1. @Component
  2. @ConfigurationProperties(prefix = "person")
  3. public class Person {
  5.     private String name;
  6.     private int age;
  7.     private String[] address;
  9.     public String getName() {
  10.         return name;
  11.     }
  13.     public void setName(String name) {
  14.         this.name = name;
  15.     }
  17.     public int getAge() {
  18.         return age;
  19.     }
  21.     public void setAge(int age) {
  22.         this.age = age;
  23.     }
  25.     public String[] getAddress() {
  26.         return address;
  27.     }
  29.     public void setAddress(String[] address) {
  30.         this.address = address;
  31.     }
  33.     @Override
  34.     public String toString() {
  35.         return "Person{" +
  36.                 "name='" + name + '\'' +
  37.                 ", age=" + age +
  38.                 '}';
  39.     }
  40. }

11-SpringBoot配置-profile

  1. profile是用来完成不同环境下，配置动态切换功能的。

  2. profile配置方式
    多profile文件方式：提供多个配置文件，每个代表一种环境。
    application-dev.properties/yml 开发环境
    application-test.properties/yml 测试环境
    application-pro.properties/yml 生产环境
    yml多文档方式：

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

  3. profile激活方式

  • 配置文件： 再配置文件中配置：spring.profiles.active=dev
  • 虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev
  • 命令行参数：java –jar xxx.jar —spring.profiles.active=dev

12-SpringBoot配置-项目内部配置文件加载顺序

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

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

13-SpringBoot配置-项目外部配置加载顺序

外部配置文件的使用是为了对能不文件的配合

1.命令行

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

2.指定配置文件位置

  1.  java -jar myproject.jar --spring.config.location=e://application.properties

3.外部不带profile的properties文件

  1.     classpath:/config/application.properties
  2.     classpath:/application.properties

https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config

springboot day01 - 图4

14-SpringBoot整合Junit

  1. 搭建SpringBoot工程
  2. 引入starter-test起步依赖
  1.  <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter</artifactId>
  5.         </dependency>
  7.         <dependency>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-test</artifactId>
  10.             <scope>test</scope>
  11.         </dependency>
  12.     </dependencies>
  1. 编写测试类
  1. /**
  2.  * 测试类
  3.  */
  5. @RunWith(SpringRunner.class)
  6. @SpringBootTest(classes = SpringbootJunitApplication.class )
  7. public class UserServiceTest {
  9.   @Autowired
  10.     private UserService userService;
  12.     @Test
  13.     public void test(){
  14.         System.out.println(111);
  15.     }
  16. }

注意:private UserService userService;这句报红是因为userServer是接口,不能创建对象,是springboot,动态代理创建接口实现类后又创建对象.

4.测试

如果测试类时启动类的包的子包或者和启动类同级别,那么@SpringBootTest(classes = SpringbootJunitApplication.class )里的classes后面的东西和括号都不用写,如下
**

15-SpringBoot整合mybatis

①搭建SpringBoot工程

②引入mybatis起步依赖，添加mysql驱动

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.mybatis.spring.boot</groupId>
  4.             <artifactId>mybatis-spring-boot-starter</artifactId>
  5.             <version>2.1.0</version>
  6.         </dependency>
  8.         <dependency>
  9.             <groupId>mysql</groupId>
  10.             <artifactId>mysql-connector-java</artifactId>
  11.             <!--<scope>runtime</scope>-->
  12.         </dependency>
  13.         <dependency>
  14.             <groupId>org.springframework.boot</groupId>
  15.             <artifactId>spring-boot-starter-test</artifactId>
  16.             <scope>test</scope>
  17.         </dependency>
  18.     </dependencies>

③编写DataSource和MyBatis相关配置

application.yml

  1. # datasource
  2. spring:
  3.   datasource:
  4.     url: jdbc:mysql:///springboot?serverTimezone=UTC
  5.     username: root
  6.     password: root
  7.     driver-class-name: com.mysql.cj.jdbc.Driver
  10. # mybatis
  11. mybatis:
  12.   mapper-locations: classpath:mapper/*Mapper.xml # mapper映射文件路径
  13.   type-aliases-package: com.itheima.springbootmybatis.domain
  15.   # config-location:  # 指定mybatis的核心配置文件

④定义表和实体类

  1. public class User {
  2.     private int id;
  3.     private String username;
  4.     private String password;
  7.     public int getId() {
  8.         return id;
  9.     }
  11.     public void setId(int id) {
  12.         this.id = id;
  13.     }
  15.     public String getUsername() {
  16.         return username;
  17.     }
  19.     public void setUsername(String username) {
  20.         this.username = username;
  21.     }
  23.     public String getPassword() {
  24.         return password;
  25.     }
  27.     public void setPassword(String password) {
  28.         this.password = password;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "User{" +
  34.                 "id=" + id +
  35.                 ", username='" + username + '\'' +
  36.                 ", password='" + password + '\'' +
  37.                 '}';
  38.     }
  39. }

⑤编写dao和mapper文件/纯注解开发

编写dao

  1. @Mapper
  2. @Repository
  3. public interface UserXmlMapper {
  5.     public List<User> findAll();
  6. }

mapper.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.itheima.springbootmybatis.mapper.UserXmlMapper">
  4.     <select id="findAll" resultType="user">
  5.         select * from t_user
  6.     </select>
  7. </mapper>

纯注解开发

  1. @Mapper
  2. @Repository
  3. public interface UserMapper {
  5.     @Select("select * from t_user")
  6.     public List<User> findAll();
  7. }

⑥测试

16-SpringBoot整合redis

①搭建SpringBoot工程

②引入redis起步依赖

  1.   <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-data-redis</artifactId>
  5.         </dependency>
  7.         <dependency>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-test</artifactId>
  10.             <scope>test</scope>
  11.         </dependency>
  12.     </dependencies>

③配置redis相关属性

  1. spring:
  2.   redis:
  3.     host: 127.0.0.1 # redis的主机ip
  4.     port: 6379

④注入RedisTemplate模板

⑤编写测试方法，测试

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class SpringbootRedisApplicationTests {
  5.     @Autowired
  6.     private RedisTemplate redisTemplate;
  8.     @Test
  9.     public void testSet() {
  10.         //存入数据
  11.         redisTemplate.boundValueOps("name").set("zhangsan");
  12.     }
  14.     @Test
  15.     public void testGet() {
  16.         //获取数据
  17.         Object name = redisTemplate.boundValueOps("name").get();
  18.         System.out.println(name);
  19.     }
  21. }