黑马springcloud教程

SpringBoot学习-01

一、springboot基础知识

1. springBoot打包项目成jar

在pom.xml 文件中首先要指定打包文件类型：

<?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>org.example</groupId>
    <artifactId>boot-01-helloWorld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <!--副工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>


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

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

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

</project>

2. 之后在pom.xml 文件中配置一个插件，代码如上所示。
3. 在idea的右边点击maven->同时选择clean和package -> 点击maven下的绿色运行按钮
4. 使用springboot之后，很多的配置都可以直接在recourse 文件夹下只用application.properties就可以配置了。
5. 要做测试的话，直接使用main方法就可以完成，直接运行main方法即可。

二、了解自动配置的原理

1.SpringBoot的特点

①依赖管理

<!--依赖管理-->
	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>

<!--他的父项目管理-->
	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>
<!--父项目管理主要功能就是几乎声明了所有开发中常用的依赖的版本号，自动-->

springBoot 中的starter场景启动器

1. 见到很多 spring-boot-starter -* : *就是某种场景

2.要引入starter，这个场景的所有常规需要的依赖我们都要自动引入

3.SpringBoot 所有支持的场景：https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter

4.可以自定义创建starter，见到的 *-spring-boot-starter 都是第三方为我们提供的简化开发场景启动器

5.所有的场景启动器最低层的依赖：

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

注意：

1.引入依赖默认的都可以不写版本

2.引入的非版本仲裁的jar，都需要配置版本

②自动配置好了springmvc

1.引入SpringMVC全套功能

2.自动配置号SpringMVC常用组件

③自动配置好Web常见功能

如：字符编码问题

SpringBoot配置好了所有web开发的常见场景

④默认包结构

1.主程序所在的包及其下面的所有子包都会被扫描到

2.无需配置包扫描

当需要被扫描的类在主程序外层的时候，需要在注入主程序的是时候，指定一下扫描路径

例如：主程序的包结构为：com.jzy.boot; 主程序的名字为（MainApplication）

当需要被扫描的类在com.jzy下的时候，在注入MainApplication的时候，给 @SpringBootApplication加一个scanBasePackages属性来指定扫描路径。

例子：

package com.jzy.boot;

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

/**
 * 主程序类
 * @SpringBootApplication相当于告诉springboot这是一个springboot应用
 *
 */
@SpringBootApplication(scanBasePackages="com.jzy")
public class HelloWorld {
    public static void main(String[] args) {
        //1.返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(HelloWorld.class,args);
        //2.查看容器里面的组件
        /**String[] names= run.getBeanDefinitionNames();
        for(String name : names){
            System.out.println(name);
        }*/
    }
}

重点：还可以使用@ComponentScan来指定包扫描路径

但是需要加两个注解：@SpringBootConfiguration 和 @EnableAutoConfiguration

package com.jzy.boot;

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

/**
 * 主程序类
 * @SpringBootApplication相当于告诉springboot这是一个springboot应用
 *
 */
@SpringBootConfiguration 
@EnableAutoConfiguration
@ComponentScan("com.jzy")
public class HelloWorld {
    public static void main(String[] args) {
        //1.返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(HelloWorld.class,args);
    }
}

⑤各种配置都有默认值

例如：在文件上传的大小，但是一般的可以在application.peoperties配置文件中可以修改的文件上传时的最大值。

在application.properties中配置的值都会绑定到一个类上去，这个类会在容器中创建一个对象。

⑥按需要加载所有自动配置项

引入了那些场景，这个场景的配置项才会开启

SpringBoot所有的自动配置功能都在spring-boot-autoconfigure包中

三、容器功能

1.组件添加

1.1 @Configuration

1.作用是告诉SpringBoot这是一个配置类 == 配置文件

2.配置类本身也是一个组件

1.2 @Bean

作用是给容器中添加组件，以方法名字作为组件的Id。返回类型就是组件类型，返回的值就是在容器中的对象（实例）

例子：

public class User{
    private String name;
    private int age;
    public User(){}
    public User(String name,int age){
        this.name = name;
        this.age = age;
    }
    ……//各个属性的setter和getter方法
}

public class Pet{
    private String name;
    ……//构造方法（有参构造和无参构造）和 setter、getter方法
}

@Configuration//这是一个配置类，等同于spring中的配置文件
public class MyConfig{
    @Bean //给容器中添加组件，以方法名字作为组件的Id。返回类型就是组件类型，返回的值就是在容器中的实例
    public User user01(){
        return new User("张三",18);
    }
    
    /**
    	外部调用该方法，是从容器中获取到的单实例对象
    */
    @Bean("Tom") // 加上参数，也就自定义在容器中的名字
    public Pet catPet(){
        return new Pet("cat");
    }
}

package com.jzy.boot;

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

@SpringBootApplication
public class HelloWorld {
    public static void main(String[] args) {
        //1.返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(HelloWorld.class,args);
        //2.从容器中获取组件
        Pet Tom01 = run.getBean("Tom",Pet.class);
    }
}

重点：如果为 @Configuration设置一个参数，为proxyBeanMethods = true

如果proxyBeanMethods = true，那么User user = bean.user01();就是代理调用方法，SpringBoot总会检查这个组件是否在容器中存在，如果存在，就不创建，保证实例是单实例。如果的值为false，就不是一个代理方法。

2.@import

作用：给容器中导入组件

@Import({User.class,WeChatUser.class})//给容器中自动创建出这两个类型的组件，这种方式导入的话，默认组件的名字是全类名
@Configuration//这是一个配置类，等同于spring中的配置文件
public class MyConfig{
    @Bean //给容器中添加组件，以方法名字作为组件的Id。返回类型就是组件类型，返回的值就是在容器中的实例
    public User user01(){
        return new User("张三",18);
    }
    
    /**
    	外部调用该方法，是从容器中获取到的单实例对象
    */
    @Bean("Tom") // 加上参数，也就自定义在容器中的名字
    public Pet catPet(){
        return new Pet("cat");
    }
}

3.@Conditional

条件装配：满足Conditional指定的条件，则进行组件的注入

@Import({User.class,WeChatUser.class})
@Configuration(proxyBeanMethods = false)
public class MyConfig{
    
    @ConditionalOnBean(name = "tom")//当容器中有Tom组件的时候才注入user01
    //@ConditionalOnMissingBean(name = "tom") // 当容器中没有的时候，才注入
    @Bean
    public User user01(){
        return new User("张三",18);
    }
    
    //这里暂时不进行注册
    public Pet catPet(){
        return new Pet("cat");
    }
}

4.原生配置文件引入

@ImportResource

当某个团队使用的是bean.xml的方式对实例进行注入的时候，可以使用@ImportResource进行导入，进行重新解析使用。 但是要保证bean.xml 的路径正确。

@Import({User.class,WeChatUser.class})
@Configuration(proxyBeanMethods = false)
@ImportResource("classpath:bean.xml")
public class MyConfig{
    
    @ConditionalOnBean(name = "tom")//当容器中有Tom组件的时候才注入user01
    //@ConditionalOnMissingBean(name = "tom") // 当容器中没有的时候，才注入
    @Bean
    public User user01(){
        return new User("张三",18);
    }
    
    //这里暂时不进行注册
    public Pet catPet(){
        return new Pet("cat");
    }
}

5.配置绑定

把properties（yaml）文件中的值绑定到实体类中

如何使用java读取到properties文件中内容，并且把它封装到JavaBean中，一便于随时使用。

使用注解：@ConfigurationProperties(prefix=" ") //只有在容器中的组件，才会拥有SpringBoot提供的强大功能

所以还需要使用 @Component 注解

server.port=8888 //给服务器修改默认端口,当然，这里的注解不能再properties文件中出现

mycar.name=BYD
mycar.price=100000

package com.jzy.boot.bean;

@Component //必须使用，不然ConfigurationProperties无效
@ConfigurationProperties(prefix="mycar")
public class Car {
    private String name;
    private int price;

    public Car(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public Car(){}
    
    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

@RestController
public class HelloController {
    //这里能用，是因为在Car类中使用了@Component注解，把该类加载到容器中了.这里的Autowired相当于拿出来使用
    @Autowired
    Car car;
    
    @RequestMapper("/lp")
    public Car getCar(){
        return car;
    }
}

第二种方式就是在配置类中进行配置

使用开启属性配置功能注解： @EnableConfigurationProperties(Car.class) + @ConfigurationProperties注解

有了自动配置类，免去了我们手动编写配置注入功能组件等功能。

四、使用Spring Initializer 快速创建Spring Boot项目

IDE都支持使用Spring的项目创建向导快速创建一个SpringBoot项目。

选择我们需要的模块；向导会联网创建Spring Boot项目；

默认生成的Spring Boot项目；

1.主程序已经生成好了，我们只需要编写我们自己的逻辑

2.resources 文件夹中目录结构

static：保存所有的静态资源

templates：保存所有的模板页面； Spring Boot默认的jar包使用嵌入式的Tomcat，默认不支持JSP页面的）

但是可以使用模板引擎（freemarker、thymeleaf）

appliaction.properties: 是SpringBoot的应用的配置文件

五、Spring Boot 的配置

1.使用一个全局的配置文件

1.application.properties

2.application.yml

配置文件的作用：修改SpringBoot自动配置的默认值

YAML：以数据为中心，比json、xml等更适合做配置文件

application.properties

server.port = 8090

YAML

server:
	port: 8090

2.YAML的基本语法

1.基本语法

K : (空格)V 表示一对键值对（空格必须存在）

以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的

server:
    port: 8090
    path: /hello

属性和值也是大小写敏感的

2.值的写法

字面量：普通的值（数字、字符串、布尔）

对象：（属性和值）、map、数组（List、Set）

数组：（第一个是List 的，第二个是数组类型的）

在properties中的编写：

数据校验的例子

@Component
@ConfigurationProperties(prefix = "person")
@Validated  //表示该类要进行数据校验
public class Person {
    
    @Value("$person.firstName")
    private String firstName;
    private String lastName;
    @Value("18")
    private Integer age;
    @Value("true")
    private boolean boss;
    
    @Email
    private String email;
    private Date birth;
    private List<String> lists;
    private Dog dog;
    
    ……
}

3.@PropertySource & @ImportResource

@PropertySource : 加载指定的配置文件；

如果需要绑定的属性不在application中的时候，在person.properties文件中，这个时候再使用之前的@ConfigurationProperties注解就不会再生效。

这个时候要使用@PropertySource注解来指定路径。

例如：

@PropertySource(value = {"classpath:person.properties"})
@Component
public class Person {
    ……
}

@ImportResource : 导入Spring的配置文件，让配置文件里面的内容生效

作用与上面的@Import的一样，@Import注解是SpringBoot 2中的

用法：

4.配置文件的占位符

4.1 随机数

${random.value} 、${random.int} 、${random.long} 、${random.int(10)} 、${random.int(1024,65535)}

4.2 占位符获取之前配置的值，如果没有可以用：指定默认值

person.dog.name=${person.hello:hello}_dog