Spring簡介及基礎組件

一、Spring發展歷程

2003年2月Spring框架正式開源，Spring致力於J2EE應用的各種解決方案，而不僅僅專注於某一層解決方案。可以說Spring是企業應用開發的“一站式”選擇，Spring貫穿於表現層、業務層、持久層，然而Spring並不想取代那些已經有的框架，而是以高度的開放性，與這些已有的框架進行整合。

二、Spring的目標

1、讓現有的技術更容易使用，2、促進良好的編程習慣。Spring是一個全面的解決方案，它堅持一個原則：不從新造輪子。已經有較好解決方案的領域,Spring絕不重複性實現，比如：對象持久化和OR映射，Spring只對現有的JDBC，Hibernate等技術提供支持，使之更容易使用，而不做重複的實現。Spring框架有很多特性，這些特性由7個定義良好的模塊構成。

三、Spring體系結構

四、基礎組件使用

1. 配置文件 --> 配置類

（1）最原始的方式：配置文件

在src/main/resources下建立配置文件beans.xml(文件名可以任取)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="person" class="com.dapeng.study1.Person">
        <property name="name" value="dapeng"></property>
        <property name="age" value="25"></property>
    </bean>

</beans>

測試：

package com.dapeng.study1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 測試配置文件加載bean
 * Created by dapeng on 2019/12/30.
 */
public class MainTest1 {
    public static void main(String args[]) {
        //把beans.xml的類加載到容器
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        //從容器中獲取bean
        Person person = (Person) app.getBean("person");

        System.out.println(person);
    }
}

（2）使用@Configuration註解替代配置文件

package com.dapeng.study1;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * TODO
 * Created by dapeng on 2019/12/30.
 */
//告訴Spring這是一個配置類，等同於配置文件
@Configuration
public class MainConfig {
    //給容器中註冊一個bean，id默認爲方法名，也可以用@Bean("abc")類設置id，類型爲方法返回值類型
    @Bean
    public Person person() {
        Person person = new Person();
        person.setName("dapeng");
        person.setAge(25);
        return person;
    }
}

測試：

package com.dapeng.study1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 測試配置類加載bean
 * Created by dapeng on 2019/12/30.
 */
public class MainTest2 {
    public static void main(String args[]) {
        //把配置類中的信息加載到容器
        ApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
        //從容器中獲取bean
        Person person = (Person) app.getBean("person");

        System.out.println(person);
    }
}

2. @ComponentScan

一個項目中有許多類，要是全部像這樣配置一遍太費盡，那有什麼好辦法嗎？可以用掃描註解@ComponentScan

這個註解可以指定掃描範圍，讓spring啓動的時候掃描指定範圍的類，然後放進IOC容器中；還可以設置過濾器指定哪些類不用掃描，或者只掃描哪些類；還可以自定義過濾規則。

@Configuration
@ComponentScan(value = "com.dapeng.study2")
public class MainConfig {
    //給容器中註冊一個bean，id默認爲方法名，也可以用@Bean("abc")類設置id，類型爲方法返回值類型
    @Bean
    public Person person() {
        Person person = new Person();
        person.setName("dapeng");
        person.setAge(25);
        return person;
    }
}

測試：

    @Test
    public void test01() {
        //將配置類信息加載進IOC容器
        ApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
        //獲取容器中所有註冊的bean，打印
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }

測試結果：

假如現在只需要掃描被@Controller標記的類，該怎麼做呢？很簡單，只需要用includeFilters，這裏要注意把useDefaultFilters設置爲false

@ComponentScan(value = "com.dapeng.study2", includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})
}, useDefaultFilters = false)

測試結果：掃描註冊的bean只剩下orderController了

同樣的，也可以設置不讓掃描哪些類，使用excludeFilters

@ComponentScan(value = "com.dapeng.study2", excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})
})

測試結果：orderController不在容器中了

也可以自定義過濾器：

/**
 * 自定義掃描過濾器
 * Created by dapeng on 2019/12/30.
 */
public class MyTypeFilter implements TypeFilter {
    /**
     * Created by dapeng on 2019/12/30.
     *
     * @param metadataReader        可以獲取到當前正在掃描的類信息
     * @param metadataReaderFactory 可以獲取到其他任何類信息
     */
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) {
        //當前掃描的類的註解信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //當前掃描的類的信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //當前掃描的類資源（類的路徑）
        Resource resource = metadataReader.getResource();

        String className = classMetadata.getClassName();
        if (className.contains("Dao")) {
            return true;//返回true則當前類的實例被註冊到IOC容器中
        }
        return false;//返回false則不會
    }
}

//告訴Spring這是一個配置類，等同於配置文件
@Configuration
@ComponentScan(value = "com.dapeng.study2", includeFilters = {
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})
}, useDefaultFilters = false)
public class MainConfig {
    //給容器中註冊一個bean，id默認爲方法名，也可以用@Bean("abc")類設置id，類型爲方法返回值類型
    @Bean
    public Person person() {
        Person person = new Person();
        person.setName("dapeng");
        person.setAge(25);
        return person;
    }
}

測試結果：只有類名包含Dao的類實例會被註冊到IOC容器中

給容器中註冊bean的方式總結：

1. @Bean 一般用來導入第三方的包或類。比如Person爲第三方的類，需要在我們的IOC容器中使用
2. 包掃描註解+標識註解（@ComponentScan + @Controller、@Service、@Responsitory、@Componet）,一般是針對我們自己寫的類，使用這個
3. @Import 快速給容器導入一個組件。注意：@Bean有點簡單 。（用的少）
4. 通過FactoryBean註冊到容器中。（用的少）

3. @Scope 單實例、多實例

prototype 多實例：IOC容器啓動的時候，並不會調用方法創建對象，而是每次獲取的時候纔會調用方法創建對象
singleton 單實例：IOC容器啓動的時候，會調用方法創建對象並放到IOC容器中，以後每次獲取的時候就是直接從容器中拿的是同一個bean

@Configuration
public class MainConfig {
    /**
     * prototype 多實例：IOC容器啓動的時候，並不會調用方法創建對象，而是每次獲取的時候纔會調用方法創建對象
     * singleton 單實例：IOC容器啓動的時候，會調用方法創建對象並放到IOC容器中，以後每次獲取的時候就是直接從容器中拿的是同一個bean
     */
    @Scope("prototype")
    @Bean
    public Person person() {
        Person person = new Person();
        person.setName("dapeng");
        person.setAge(25);
        return person;
    }
}

4. @Lazy 懶加載

懶加載：針對單實例bean，容器啓動的時候不創建對象，僅當第一次使用的時候才創建

@Configuration
public class MainConfig {
    /**
     * 懶加載：針對單實例bean，容器啓動的時候不創建對象，僅當第一次使用的時候才創建
     */
    @Lazy
    @Bean
    public Person person() {
        System.out.println("person實例創建。。");
        Person person = new Person();
        person.setName("dapeng");
        person.setAge(25);
        return person;
    }
}

測試：

public class Study4Test {
    @Test
    public void test01() {
        ApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
        System.out.println("容器加載完成。。");
        app.getBean("person");
    }
}

測試結果：

5. @Conditional

有條件地往IOC容器中添加實例。例如：操作系統不是Windows的時候，才把person2添加到容器中

@Configuration
public class MainConfig {

    @Bean
    public Person person1() {
        System.out.println("person1 實例創建。。。");
        return new Person();
    }

    @Conditional(WinCondition.class)
    @Bean
    public Person person2() {
        System.out.println("person2 實例創建。。。");
        return new Person();
    }
}

public class WinCondition implements Condition {

    /**
     * Created by dapeng on 2019/12/30.
     *
     * @param conditionContext      上下文環境
     * @param annotatedTypeMetadata 註解信息
     */
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //當前環境變量（包括操作系統信息）
        Environment environment = conditionContext.getEnvironment();
        String osName = environment.getProperty("os.name");
        if (!osName.contains("Windows")) {//如果不是windows平臺，添加到IOC容器中
            return true;//返回true，則當前類實例會被添加到IOC容器中
        }
        return false;
    }
}

 測試：

public class Study5Test {

    @Test
    public void test01() {
        ApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
        System.out.println("容器加載完成。。。");
    }
}

測試結果：因爲當前操作系統是Windows，所以person2沒有添加到容器中