SpringBoot入门

1. SpringBoot概述

SpringBoot：是spring系列的一款全新框架

特点：

①：快速搭建项目，简化开发流程

②：解决样板化的配置（之前使用spring的时候需要手动配置xml文件，而xml文件都是一种模板文件，每次都需要拷贝和修改，springboot使用注解式编程，不再需要xml配置文件）

2. SpringBoot的初体验

spring的三大核心：AOC DI AOP

学习SpringBoot从AOC和DI入手，看看它为我们简化了哪些！

AOC ：控制反转，反转就是曾今需要使用new 的方式创建实例，而现在可以把创建实例交给spring管理，需要时从spring的容器中获取，并且如果实例拥有依赖关系，spring也会通过反射为我们注入！

使用spring的方式管理bean

导包

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

创建实体类

public class Mybean {}

配置xml，注入bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    <bean id="mybean" class="com.hanfengyi.xml_config.Mybean"></bean>
</beans>

测试

public class MybeanTest {
    @Test
    public void test(){
        ApplicationContext applicationContext = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Mybean bean = applicationContext.getBean(Mybean.class);
        System.out.println(bean);
    }
}

加载配置文件，从应用上下文applicationContext中获取实例

使用springboot的方式创建bean

使用springboot的时候，不会去配置xml文件，而是使用java配置类！

创建一个实体类
```
public class Mybean {}
```

创建一个配置类

@Configuration
public class ApplicationConfig {
    @Bean
    public Mybean mybean(){
        return new Mybean();
    }
}

测试

@Test
    public void test(){
        ApplicationContext context
                = new AnnotationConfigApplicationContext(ApplicationConfig.class);
        Mybean bean = context.getBean(Mybean.class);
        System.out.println(bean);
    }

<u>@Configuration:标识是一个配置类，spring会根据该注解加载配置类，去创建该配置类中的实例。</u>

<u>@Bean:标注在方法上，该方法返回的实例会交给spring管理</u>

ApplicationContext：使用spring的时候是用ClassPathXmlApplicationContext去读取配置文件，而使用springboot 的时候是用AnnotationConfigApplicationContext去加载配置类！

3. SpringBoot配置类

在xml配置文件中，对于一个实例，我们可以指定bean的名字、id、初始化方法、销毁方法、作用域、是否是懒加载...等，那么在配置类如何描述呢

Bean的详细信息

@Configuration
public class ApplicationConfig {
    @Bean(name = "teacher",initMethod = "init",destroyMethod = "destroy")
    @Scope
    @Lazy
    public Teacher teacher(){
        return new Teacher();
    }
}

@Bean注解中可以指定bean的名字，初始化方法名，销毁方法名

@Scope注解指定bean是单例还是多例，默认是单例，@Scope("prototype")表示是多例

@Lazy注解指定bean是否是懒加载，@Lazy（true）表示是懒加载

使用spring的测试

public class Teacher {
    public void init(){
        System.out.println("初始化...");
    }
    public void destroy(){
        System.out.println("销毁...");
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ApplicationConfig.class)
public class TeacherTest {
    @Autowired
    private ApplicationContext applicationContext;
    @Test
    public void test(){
        Teacher bean = applicationContext.getBean(Teacher.class);
        System.out.println(bean);
    }
}

与之前使用spring的测试不同的地方，@ContextConfiguration需要传递配置类的字节码文件，去加载该配置类，ApplicationContext可以自动注入，通过它可以拿到所需要的bean！

当然因为Teacher已经在加载配置类的时候放到了容器中了，所以可以直接拿到，不需要通过ApplicationContext，如下：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ApplicationConfig.class)
public class TeacherTest {
    @Autowired
    private Teacher teacher;
    @Test
    public void test(){
        System.out.println(teacher);
    }
}

4. SpringBoot的DI

SpringBoot的di依赖注入分为为普通字段注入值，为引用字段注入值！

public class Mybean {
    private String name;
    private OtherBean otherBean;

    public String getName() {
        return name;
    }

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

    public OtherBean getOtherBean() {
        return otherBean;
    }

    public void setOtherBean(OtherBean otherBean) {
        this.otherBean = otherBean;
    }

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

public class OtherBean {}

为普通字段设置值，很简单，直接在方法中调用set方法，并返回

@Configuration
public class ApplicationConfig {
    @Bean
    public Mybean mybean(){
        Mybean mybean =  new Mybean();
        mybean.setName("hello");
        return mybean;
    }

为引用字段设置值的方法很多，但是必须先交给spring管理

①：调用方法的方式

@Configuration
public class ApplicationConfig {
    @Bean
    public Mybean mybean(){
        Mybean mybean =  new Mybean();
        mybean.setName("hello");
        mybean.setOtherBean(otherBean());
        return mybean;
    }
    @Bean
    public OtherBean otherBean(){
        return new OtherBean();
    }
}

因为otherbean已经在spring容器中，调用方法的时候，会先从容器中去获取！

②：方法传参的方式

@Configuration
public class ApplicationConfig {
    @Bean
    public Mybean mybean(OtherBean otherBean){
        Mybean mybean =  new Mybean();
        mybean.setName("hello");
        mybean.setOtherBean(otherBean);
        return mybean;
    }
    @Bean
    public OtherBean otherBean(){
        return new OtherBean();
    }
}

③：使用@Autowired自动注入的方式

@Configuration
public class ApplicationConfig {
    @Autowired
    private OtherBean otherBean;
    @Bean
    public Mybean mybean(){
        Mybean mybean =  new Mybean();
        mybean.setName("hello");
        mybean.setOtherBean(otherBean);
        return mybean;
    }
    @Bean
    public OtherBean otherBean(){
        return new OtherBean();
    }
}

5. SpringBoot的注解

springboot为我们提供注解式编程，把传统的xml文件中的标签替换为注解！

5.1 自动扫描 @ComponentScan

实体类上使用@Component

@Component
public class Students {}

配置类上使用@ComponentScan开启扫描，相当于是xml中的<context:component-scan> 会去扫描使用了@Component注解的类，交给spring管理

@Configuration
@ComponentScan
public class ApplicationConfig {}

5.2 Condition条件注解

@Condition在bean上使用，标识该bean需要满足条件才被定义

这里以一个案例来说明使用方法，比如需要系统环境是windows 10才定义bean，否则不定义！

首先需要创建一个类实现Condition接口，来自定义条件！

然后在使用了@Bean注解的方法上添加 @Conditional注解，他需要我们提供自定义条件类的class对象

@Configuration
public class ApplicationConfig {
    @Bean
    @Conditional(value = MyCondition.class)
    public People people(){
        return new People();
    }
}

public class MyCondition implements Condition {
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        System.out.println(environment);
        String property = environment.getProperty("os.name");
        System.out.println(property);
        if(property.equals("Windows 10")){
            return true;
        }
        return false;
    }
}

5.3 Import导入注解

import注解

①：@Import可以导入一个配置类

例如我需要在Mybean的配置类中去获取OtherBean对象

先把OtherBean交给spring管理,然后在Mybean的配置类中导入OtherBean的配置类

@Configuration
public class OtherBeanConfig {
    @Bean
    public OtherBean otherBean(){
        return new OtherBean();
    }
}

@Configuration
@Import(OtherBeanConfig.class)
public class MybeanConfig {
    @Bean
    public Mybean mybean(){
        return new Mybean();
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = MybeanConfig.class)
public class ImportConfigTest {
    @Autowired
    private ApplicationContext applicationContext;
    @Test
    public void test(){
        Mybean myBean = applicationContext.getBean(Mybean.class);
        OtherBean otherBean = applicationContext.getBean(OtherBean.class);
        System.out.println(myBean);
        System.out.println(otherBean);
    }
}

在测试的时候只需要加载Mybean的配置类即可，同样可以获取到OtherBean！

②：@Import可以导入一个普通类，它也会交给spring管理

比如OtherBean就不用写它的配置类，当作一个普通类，直接使用@Import(OtherBean.class)引入

@Configuration
@Import(OtherBean.class)
public class MybeanConfig {
    @Bean
    public Mybean mybean(){
        return new Mybean();
    }
}

ImportSelector导入选择器

有时候我们定义的bean太多，此时可以使用ImportSelector来导入所需要的bean

①：创建一个自定义类实现ImportSelector接口，重写方法，需要我们返回一个字符串数组，该数组中包含了我们需要定义bean的全限定名

public class MyImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.hanfengyi.importselector_config.OtherBean",
                "com.hanfengyi.importselector_config.Mybean"};
    }
}

②：在配置类中使用@Import传递我们自定义选择器的class对象,他会根据这些类的全限定名加载该类交给spring管理

@Configuration
@Import(MyImportSelector.class)
public class ApplicationConfig {}

ImportBeanDefinitionRegistrar bean定义注册器

spring默认的创建bean的方式，spring启动时通过该注册器，去创建我们所需要的bean

①：创建一个自定义类实现ImportBeanDefinitionRegistrar接口，重写方法

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 
                                        BeanDefinitionRegistry registry) {
        BeanDefinition mybeanDefinition = new RootBeanDefinition(Mybean.class);
        registry.registerBeanDefinition("myBean", mybeanDefinition);
        BeanDefinition otherBeanDefinition = new RootBeanDefinition(OtherBean.class);
        registry.registerBeanDefinition("otherBean", otherBeanDefinition);
    }
}

RootBeanDefinition:对bean进行封装注册

②：在配置类中使用@Import传递我们自定义注册器的class对象

@Configuration
@Import(MyImportBeanDefinitionRegistrar.class)
public class ApplicationConfig {}