Spring笔记-Bean基础及使用

发布于 2020-01-31  215 次阅读


Spring是什么?

Spring是一种开源轻量级框架,是为了解决企业应用程序开发复杂性而创建的,Spring致力于各层解决方案,而不仅仅于某一层的方案。Spring贯穿于表现层,业务层,持久层,Spring并不想取代那些已有的框架,而是与这些已有的进行整合。比如持久化和ORM映射,Spring只对现有的JDBC,Hibernate等技术提供支持,使之更容易使用,而不做重复的实现。

Spring的模块

  • Spring Core: 基础,可以说 Spring 其他所有的功能都需要依赖于该类库。主要提供 IoC 依赖注入功能。
  • Spring Aspects : 该模块为与AspectJ的集成提供支持。
  • Spring AOP :提供了面向切面的编程实现。
  • Spring JDBC : Java数据库连接。
  • Spring JMS :Java消息服务。
  • Spring ORM : 用于支持Hibernate等ORM工具。
  • Spring Web : 为创建Web应用程序提供支持。
  • Spring Test : 提供了对 JUnit 和 TestNG 测试的支持。

Spring Bean的使用

基于xml使用

首先,新建一个Person类,注意,这个类要是一个JavaBean,有无参的默认构造函数,有私有属性及对应的getter/setter

public class Person implements Serializable {
    public Person() {
    }
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

然后在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.lk.cap1.Person">
        <property name="age" value="1"></property>
        <property name="name" value="test"></property>
    </bean>
</beans>

main方法中,调用bean

public class TestBean {
    public static void main(String[] args) {
        //把beans.xml中的类加载到容器中
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        //根据bean标签的id,从容器中去获取bean实例
        Person person = (Person) app.getBean("person");
        System.out.println(person);
    }
}
//输出如下
Person{name='test', age=1}

其实配置文件中还有很多参数可以配置,比如作用域singleton,配置这个bean对象是单例,还有prototype,request,session三个作用域,配置文件已经不用了,现在都基于注解,所以不多记录。

基于注解使用

Person类和上面一样,不过是多了一个两个参数的构造函数,新建MainConfig类

@Configuration用于定义配置类,可替换xml配置文件,被注解的类内部包含有一个或多个被@Bean注解的方法,这些方法将会被AnnotationConfigApplicationContextAnnotationConfigWebApplicationContext类进行扫描,并用于构建bean定义,初始化Spring容器。

@Bean表示声明该方法返回的实例是受Spring管理的Bean,其有以下几个参数可供设置

  • value或name: 含义相同,为 bean 起一个名字,如果默认没有写该属性,那么就使用方法的名称为该 bean 的名称
  • autowire: 装配方式,Autowire.NO (默认设置) , Autowire.BY_NAME (根据名称), Autowire.BY_TYPE(根据类型)
  • initMethod: bean的初始化方法, 直接指定方法名称即可,不用带括号
  • destroyMethod: bean的销毁方法,在调用 IoC 容器的 close() 方法时,会执行到该属性指定的方法。不过,只是单实例的 bean 才会调用该方法,如果是多实例的情况下,不会调用该方法
@Configuration
public class MainConfig {
    @Bean
    public Person person() {
        return new Person("Test", 1);
    }
}

然后在main方法中,通过AnnotationConfigApplicationContext获取到bean容器

public static void main(String[] args) {
        ApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
        Person person = (Person) app.getBean("person");
        System.out.println(person);
}
//输出如下
Person{name='Test', age=1}

要知道IOC容器相当于一个大的map,而app.getBean("person")中的person就相当于key,这个key默认是config中的方法名,当然你也可以指定,如下

@Bean("CustomPerson") //如不指定,默认是方法名
public Person person() {
        return new Person("Test", 1);
}

//调用
Person person = (Person) app.getBean("CustomPerson");

bean初始化时我们可以执行指定的方法,通过initMethod参数去指定初始化方法,如下

@Bean(value = "CustomPerson",initMethod = "init")
public Person person() {
      return new Person("Test", 1);
}

然后Person类中也要加上对应的init方法

public class Person implements Serializable {
    public void init(){
        System.out.println("init person");
    } 
    //.....省略
}

再执行main方法,输出如下,可以看到在输出bean对象信息前,先执行了init方法

init person
Person{name='Test', age=1}

@ComponentScan扫描规则

我们实际项目开发中,一般都要分三层,service层、dao层、controller层,每一层都有一个对应的注解,注解于类上

  • Service层: @Service
  • Dao层: @Repository
  • Controller层: @Controller

前面我们是新建了一个MainConfig,在其中返回我们需要的方法,而这三层必然对应多个类,我们总不能一一写在MainConfig中返回,这样代码也太丑了。

ComponentScan做的事情就是告诉Spring从哪里找到bean,由你来定义哪些包需要被扫描。一旦你指定了,Spring将会将在被指定的包及其下级的包(sub packages)中寻找bean,这样的话不用你一一去定义了,只需要在MainConfig中配置好扫描规则即可。

开始使用

ComponentScan下面这部分转自 https://www.jianshu.com/p/64aac6461d5b ,不花时间再写了,和我准备写的流程完全一样,我最后补充自定义过滤器

1.创建一个配置类,在配置类上添加 @ComponentScan 注解。该注解默认会扫描该类所在的包下所有的配置类,相当于在beans.xml中的 <context:component-scan>

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan
public class BeanConfig {

}

2.使用 ApplicationContextgetBeanDefinitionNames() 方法获取已经注册到容器中的 bean 的名称。

import io.mieux.config.BeanConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App02 {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(BeanConfig.class);

        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanName : beanDefinitionNames) {
            System.out.println("beanName: " + beanName);
        }
    }
}

运行效果:

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig

除了 spring 本身注册的一些 bean 之外,可以看到最后一行,已经将 BeanConfig 这个类注册进容器中了。

3.指定要扫描的包(使用@ComponentScan 的 valule 属性来配置),创建一个controller 包,并在该包下新建一个 AppController 类。

package io.mieux.controller;

import org.springframework.stereotype.Controller;

@Controller
public class AppController {
}

在类上加了@Controller注解,说明该类是一个 Component。在 BeanConfig 类中修改:

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan(value = "io.mieux.controller")
public class BeanConfig {

}

在 @ComponentScan 注解中指定了要扫描的包。

运行效果:

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig
beanName: appController

AppController 已经被注册进容器了。

4.excludeFilters 和 includeFilters 的使用

使用 excludeFilters 来按照规则排除某些包的扫描。

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

@ComponentScan(value = "io.mieux",
        excludeFilters = {@Filter(type = FilterType.ANNOTATION,
        value = {Controller.class})})
public class BeanConfig {

}

excludeFilters 的参数是一个 Filter[] 数组,然后指定 FilterType 的类型为 ANNOTATION,也就是通过注解来过滤,最后的 value 则是Controller 注解类。配置之后,在 spring 扫描的时候,就会跳过 io.mieux 包下,所有被 @Controller 注解标注的类。

使用 includeFilters 来按照规则只包含某些包的扫描。

再创建一个 service 的包,并创建一个 AppService 类,再加上一个 @Service 注解。

package io.mieux.service;

import org.springframework.stereotype.Service;

@Service
public class AppService {
}

修改 BeanConfig 类:

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

@ComponentScan(value = "io.mieux", includeFilters = {@Filter(type = FilterType.ANNOTATION, classes = {Controller.class})})
public class BeanConfig {

}

运行效果:

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig
beanName: appController
beanName: appService

配置里面,应该是只包含 @Controller 注解的类才会被注册到容器中,为什么 @Service 注解的类也被注册了呢?这里涉及到 @ComponentScan 的一个 useDefaultFilters 属性的用法,该属性默认值为 true,也就是说 spring 默认会自动发现被 @Component、@Repository、@Service 和 @Controller 标注的类,并注册进容器中。要达到只包含某些包的扫描效果,就必须将这个默认行为给禁用掉(在 @ComponentScan 中将 useDefaultFilters 设为 false 即可)。

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

@ComponentScan(value = "io.mieux", 
        includeFilters = {@Filter(type = FilterType.ANNOTATION, classes = {Controller.class})},
        useDefaultFilters = false)
public class BeanConfig {

}

运行效果:

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig
beanName: appController

5.添加多种扫描规则

1、如果使用的 jdk8,则可以直接添加多个 @ComponentScan 来添加多个扫描规则,但是在配置类中要加上 @Configuration 注解,否则无效。

package io.mieux.config;

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

@ComponentScan(value = "io.mieux.controller")
@ComponentScan(value = "io.mieux.service")
@Configuration
public class BeanConfig {

}

2、也可以使用 @ComponentScans 来添加多个 @ComponentScan,从而实现添加多个扫描规则。同样,也需要加上 @Configuration 注解,否则无效。

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;
import org.springframework.context.annotation.Configuration;

@ComponentScans(value = 
        {@ComponentScan(value = "io.mieux.controller"),
        @ComponentScan(value = "io.mieux.service")})
@Configuration
public class BeanConfig {

}

6.添加自定义过滤规则

在前面使用过 @Filter 注解,里面的 type 属性是一个 FilterType 的枚举类型:

public enum FilterType {
    ANNOTATION,
    ASSIGNABLE_TYPE,
    ASPECTJ,
    REGEX,
    CUSTOM
}

使用 CUSTOM 类型,就可以实现自定义过滤规则。

1、 首先创建一个实现 TypeFilter 接口的 CustomTypeFilter 类,并实现其 match 方法。

package io.mieux.config;

import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

import java.io.IOException;

public class CustomTypeFilter implements TypeFilter {
    @Override
    public boolean match(MetadataReader metadataReader,
                         MetadataReaderFactory metadataReaderFactory) throws IOException {

        // 获取当前扫描到的类的注解元数据
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        // 获取当前扫描到的类的元数据
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        // 获取当前扫描到的类的资源信息
        Resource resource = metadataReader.getResource();

        if (classMetadata.getClassName().contains("Co")) {
            return true;
        }

        return false;
    }
}

这里简单对扫描到的类名进行判断,如果类名包含"Service"的就符合条件,也就会注入到容器中。

2、对 BeanConfig 进行修改,指定过滤类型为 Custom 类型,并指定 value 为 CustomTypeFilter.class

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.FilterType;

@ComponentScan(value = "io.mieux",
        includeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM, value = {CustomTypeFilter.class})},
        useDefaultFilters = false)
public class BeanConfig {

}
public class CustomTypeFilter implements TypeFilter {    
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        //获取当前类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //获取当前正在扫描的类的信息
        ClassMetadata classMetaData = metadataReader.getClassMetadata();
        //获取当前类资源(类的路径)
        Resource resource = metadataReader.getResource();
        String className = classMetaData.getClassName();
        //过滤规则,类名包含service,根据自己需求调整
        if (className.contains("service")) {
            return true;
        }
        return false;
    }
}

运行效果:

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig
beanName: appService

@Scope作用域

  • singleton:单例模式,全局有且仅有一个实例
  • prototype:原型模式,每次获取Bean的时候会有一个新的实例
  • request:request表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP request内有效
  • session:session作用域表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP session内有效
  • globalsession:global session作用域类似于标准的HTTP Session作用域,不过它仅仅在基于portlet的web应用中才有意义

@Scope默认值为singleton,其实常用的就singleton,单例的话要注意,如果实例中有非静态变量,那么可能会导致线程安全问题,共享资源的竞争。prototype的话,可能会频繁创建bean实例,性能差,也影响GC回收。

@Configuration
public class MainConfig {
    @Scope("singleton") //直接填写作用域,不填写直接用@Scope,默认为singleton
    @Bean(value = "CustomPerson",initMethod = "init")
    public Person person() {
        return new Person("Test", 1);
    }
}

@Lazy懒加载

如果不是懒加载的话,IOC容器启动时就会加载所有对象,而懒加载时,只有当你第一次去使用这个对象时,才会去加载,加快IOC容器启动速度,如果出现循环依赖,也可以通过@Lazy调整。

@Configuration
public class MainConfig {
    @Lazy
    @Bean
    public Person person() {
        return new Person("Test", 1);
    }
}

@Condition条件注册

有时候根据业务需求不同,可能会条件性的注册一些bean,比如根据操作系统是win/linux,这个时候可以在条件里判断当前是什么操作系统。

比如我们要根据操作系统是win还是linux注册指定bean,新建一个类WinCondition,实现spring里的Condition接口的matches方法

public class WinCondition implements Condition {
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //获取IOC容器正在使用的BeanFactory
        //BeanFactory:用于从容器中获取bean
        //FactoryBean:用于注册bean到容器
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        //获取当前环境变量,比如当前的操作系统信息
        Environment environment = conditionContext.getEnvironment();
        //获取操作系统名称
        String osName = environment.getProperty("os.name");
        if (osName.toLowerCase().contains("windows")) {
            return true;
        }
        return false;
    }
}

然后给需要条件的bean添加@Condition注解即可,就只有在windows操作系统下,才会注册这个bean,也可以在MainConfig上面添加@Condition注解

@Configuration
public class MainConfig {
    //在方法上加条件
    @Conditional(WinCondition.class)
    @Bean
    public Person person() {
        return new Person("Test", 1);
    }
}
//在类上加条件,对所有方法进行过滤
@Conditional(WinCondition.class)
@Configuration
public class MainConfig {
    @Bean
    public Person person() {
        return new Person("Test", 1);
    }
}

@Import导入

@Import表示要导入一个或多个@Configuration类,允许从另一个配置类加载@Bean定义,也可以直接导入一个组件

第一种,直接导入一个类,但是这样没办法注入参数,使用的是导入的类的默认构造函数

@Configuration
public class Dog {
    @Bean
    public Person personA() {
        return new Person("Test", 1);
    }
}
//导入一个
@Import(Dog.class)
@Configuration
public class MainConfig {
}
//导入多个
@Import(value = {Dog.class, Cat.class})
@Configuration
public class MainConfig {
}

第二种,使用ImportBeanDefinitionRegistrar将类注入到IOC容器中,特别灵活,在registerBeanDefinitions方法里想注入哪些就注入哪些

public class DogBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        BeanDefinitionBuilder dogBean = BeanDefinitionBuilder.rootBeanDefinition(Dog.class);
        //可以通过containsBeanDefinition判断IOC容器中是否存在某个类,看自己需求
        boolean dogExist = beanDefinitionRegistry.containsBeanDefinition(Dog.class.getName());
        if(dogExist) {
          //.....
        }
        //通过BeanDefinitionRegistry注入到容器
        beanDefinitionRegistry.registerBeanDefinition("Dog", dogBean.getBeanDefinition());
    }
}
@Import(DogBeanDefinitionRegistrar.class)
@Configuration
public class MainConfig {
}

第三种,使用ImportSelector注入,只需要返回一个String[]数组,里面的内容是类名即可

public class DogImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{
                Dog.class.getName()
        };
    }
}

@Import(DogImportSelector.class)
@Configuration
public class MainConfig {
}

第四种,其实还是ImportSelector,不过是多创建了一个注解,在这个注解中@Import,然后在Config中再加上这个注解,更加灵活,Spring中的各种Starter包,都是通过EnableXXXX 注解进行开启使用,就是这个

public class DogImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{
                Dog.class.getName() //如果不使用getName,那么必须使用全路径类名"com.xxx.xx.Dog"
        };
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target(ElementType.TYPE)
@Import(DogImportSelector.class)
public @interface EnableDog {
}

@EnableDog
@Configuration
public class MainConfig {
}

LoneKing