Spring简介及基础组件

一、Spring发展历程

2003年2月Spring框架正式开源,Spring致力于J2EE应用的各种解决方案,而不仅仅专注于某一层解决方案。可以说Spring是企业应用开发的“一站式”选择,Spring贯穿于表现层、业务层、持久层,然而Spring并不想取代那些已经有的框架,而是以高度的开放性,与这些已有的框架进行整合。

二、Spring的目标

1、让现有的技术更容易使用,2、促进良好的编程习惯。Spring是一个全面的解决方案,它坚持一个原则:不从新造轮子。已经有较好解决方案的领域,Spring绝不重复性实现,比如:对象持久化和OR映射,Spring只对现有的JDBC,Hibernate等技术提供支持,使之更容易使用,而不做重复的实现。Spring框架有很多特性,这些特性由7个定义良好的模块构成。

三、Spring体系结构

Spring简介及基础组件_第1张图片

四、基础组件使用

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

(1)最原始的方式:配置文件

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




    
        
        
    

测试:

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);
        }
    }

测试结果:

Spring简介及基础组件_第2张图片

假如现在只需要扫描被@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不在容器中了

Spring简介及基础组件_第3张图片

也可以自定义过滤器:

/**
 * 自定义扫描过滤器
 * 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没有添加到容器中

你可能感兴趣的:(一步一步学Spring,spring,注解)