springboot入门一

1.微服务简介

微服务是一种架构风格,本质上还是spring,只不过简化了配置,真正讲究“约定大于配置”。
说白了就是以前MVC三层架构中的Service拆分成不同的模块,将每个模块部署在一台服务器上,每台服务器只提供相关的接口。

2.第一个springboot程序

https://spring.io/projects/spring-boot#learn
jar包,官网导入。也可以直接用IDEA创建（本质还是从官网上的Spring Initalizr导入）。

controller类:

package com.mao.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String sayHello(){
        return "helloworld!";
    }
}

因为约定大于配置,所以这里可以直接使用springMVC的Restful风格注解了。

启动类:

package com.mao.demo;

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

@SpringBootApplication
public class  DemoApplication {

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

}

通过看SpringBootApplication的源码我们知道它是一个Configuration,也就是一个Compoment,也就是说就是一个Spring的bean,将组件化做到了极致。

maven依赖

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--   web依赖: tomcat dispatcherServlet xml等     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

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

</project>

输出结果:

banner.txt改趣味启动日志

可以去https://www.bootschool.net/ascii-art/search下载有意思的图片,然后在banner.txt中改一下就可以生成趣味日志了:

3.springboot自动装配原理

pom.xml中的spring-boot-dependencies的核心依赖在父工程中,我们在写或者引入一些springboot依赖的时候,不需要制定版本,就因为有这些版本仓库

启动器:

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

• 说白了就是springboot的应用场景
• 假如要使用spring-boot-starter-web,它就会帮我们自动导入所有web相关的依赖。
• springboot会将所有的功能场景,变成一个个的启动器。
• 我们需要使用什么功能,只需要找到对应的启动器（starter）就可以了

springboot自动装配的原理就是springboot的所有自动配置都在启动类中被扫描并加载,所有的自动配置类都在:spring.factories,要判断是否导入了对应了starter,只有导入后才能让自动配置生效。具体流程如下:

1. springboot在启动的时候,从类路径下/META-INF/spring.factories获取指定的值。
2. 将这些自动配置的类导入容器,自动配置就会生效,帮我们自动配置
3. 以前需要我们配置的东西,springboot帮我们做的
4. 整合JavaEE,解决方案和自动配置的东西都在spring-boot-autoconfigure-2.2.0.RELEASE这个包下
5. 它会把所有需要的组件,以类名的方式返回,这些组件就会被注入到容器.
6. 容器中也会存在xxxAutoConfiguration的文件,这些类就是给容器中导入了这个场景需要的所有组件并自动配置,。

谈谈你对springboot的理解:

1. springboot启动会加载大量的自动配置类
2. 我们可以看我们需要的功能有没有在springboot默认写好的配置类中
3. 我们再来看这个自动配置类中到底配置了哪些组件;(只要我们想要的组件在其中,就无需自己去配置了)
4. 给容器中自动配置类添加组件的时候,会从properties中读取某些属性,我们只需要在配置文件中指定这些属性即可
   xxxAutoConfiguration:自动配置类,给容器中添加组件
   xxxProperties:封装配置文件中的相关属性

4.yaml语法入门

yaml不是一种标记语言,以key : value（中间必须要有空格）的形式来展现配置,比xml轻巧灵便,用缩进来表示子属性,有点类似js,实例：

#普通的key - value
name: wuwei

#对象
student1:
  name: jianglong
  age: 3

#对象的另一种写法（行内写法）
student2: {name: xianggou,age: 3}


#数组
pets:
  - cat
  - dog
  - pig

pets2: [cat,dog,pig]

ymal是可以给实体类赋值的。
举例:
实体类:

package com.mao.demo.pojo;


import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;
@Component
@ConfigurationProperties(prefix="person")
public class Person {

    private String name;
    private int age;
    private boolean happy;
    private Date birth;
    private Map  maps;
    private List<Object> list;
    private Dog dog;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isHappy() {
        return happy;
    }

    public void setHappy(boolean happy) {
        this.happy = happy;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public Map getMaps() {
        return maps;
    }

    public void setMaps(Map maps) {
        this.maps = maps;
    }

    public List<Object> getList() {
        return list;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }
}

配置提示

写好实体类因为用了@ConfigurationProperties(prefix=“person”)注解,所以需要点进去引入一个包,这样yml中就会有提示了。
报的提示:

引入的包:

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

然后去配置yaml文件:
applicaiton.yml

person:
  name: 项狗
  age: 24
  happy: false
  birth: 2019/1/1
  map: {wife: anqi, father: me}
  list:
    - feilong
    - jiaming
    - xiaoling
  dog:
    name: xiaoxiang
    age: 4

做测试:

package com.mao.demo.controller;


import com.mao.demo.DemoApplication;
import com.mao.demo.pojo.Person;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest(classes = DemoApplication.class)
@RunWith(SpringRunner.class)
public class HelloControllerTest {

    @Autowired
    private Person person;

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

结果:
Person{name=‘项狗’, age=24, happy=false, birth=Tue Jan 01 00:00:00 CST 2019, maps={wife=anqi, father=me}, list=[feilong, jiaming, xiaoling], dog=Dog{name=‘xiaoxiang’, age=4}}

@Value

用@Value在实体类中可以为单个参数赋值。

松散绑定

在yml中的last-name和实体类中的lastName是可以对应的。-后面跟着的默认是大写字母

5.数据校验

@validated

该注解用于数据校验,在其下面可以使用@Email(String message),完成对电子邮箱的校验;