Spring的容器类
- xmlBean配置容器类：
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
- 注解Bean配置容器类()：
ApplicationContext applicationContext = new AnnotationConfigApplicationContext("com.i9577.config");
ApplicationContext applicationContext2 = new AnnotationConfigApplicationContext(MainConfig.class);
- 每种容器类都有多种构造器供选择，常用的方法如下：
Person person = (Person) applicationContext.getBean("person");//获取对应id的bean的实体类
String[] beanNamesForType = applicationContext.getBeanNamesForType(Person.class);//获取当前传入类型的所有容器中bean的名称
String[] beanDefinitionNames1 = applicationContext.getBeanDefinitionNames();//获取当前容器内所有注册bean的名称
Environment environment = applicationContext.getEnvironment();//获取当前运行环境的系统参数
1.组件的注册
/**
* 给容器中注册组件；
* 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
* 2）、@Bean[导入的第三方包里面的组件]
* 3）、@Import[快速给容器中导入一个组件]
* 1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
* 2）、ImportSelector:返回需要导入的组件的全类名数组；
* 3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中
* 4）、使用Spring提供的 FactoryBean（工厂Bean）;
* 1）、默认获取到的是工厂bean调用getObject创建的对象
* 2）、要获取工厂Bean本身，我们需要给id前面加一个&
* &colorFactoryBean
*/
@Configuration-指定配置类
配置类==配置文件
@Configuration //告诉Spring这是一个配置类
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
...
}
@Target(ElementType.TYPE)可知该类只适用于注解在类或接口上；
@Retention(RetentionPolicy.RUNTIME) 指定生命周期为运行时，才能通过反射获取
@ComponentScan-自动扫描组件到IOC容器
相当于原xml配置中的
<context:component-scan base-package="com.i9577"></context:component-scan>
@ComponentScans(
value = {
@ComponentScan(value="com.i9577",includeFilters = {
/* @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/
@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
},useDefaultFilters = false)
}
)
//@ComponentScan value:指定要扫描的包
//excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
//includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件
//FilterType.ANNOTATION：按照注解
//FilterType.ASSIGNABLE_TYPE：按照给定的类型；
//FilterType.ASPECTJ：使用ASPECTJ表达式
//FilterType.REGEX：使用正则指定
//FilterType.CUSTOM：使用自定义规则
自定义过滤规则实现TypeFilter 接口，实现match方法
import java.io.IOException;
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;
public class MyTypeFilter implements TypeFilter {
/**
* metadataReader：读取到的当前正在扫描的类的信息
* metadataReaderFactory:可以获取到其他任何类信息的
*/
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
throws IOException {
// TODO Auto-generated method stub
//获取当前类注解的信息
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
//获取当前正在扫描的类的类信息
ClassMetadata classMetadata = metadataReader.getClassMetadata();
//获取当前类资源（类的路径）
Resource resource = metadataReader.getResource();
String className = classMetadata.getClassName();
System.out.println("--->"+className);
if(className.contains("er")){
return true;
}
return false;
}
}
@Bean-注册实体类到IOC容器
一般写在配置类中：
@Bean //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
public Person person() {
return new Person("008", "二傻");
}
相当于原先xml如下配置：
<bean id="person" class="com.i9577.bean.Person" scope="prototype">
<property name="id" value="007"></property>
<property name="name" value="詹姆斯邦德"></property>
</bean>
@Scope-设置组件的作用域
组件在IOC容器中默认注册都是单例(singleton),可通过@Scope调整为多实例和其他作用域。
//默认是单实例的
/**
* ConfigurableBeanFactory#SCOPE_PROTOTYPE
* @see ConfigurableBeanFactory#SCOPE_SINGLETON
* @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST request
* @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION sesssion
* @return\
* @Scope:调整作用域
* prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
* 每次获取的时候才会调用方法创建对象；
* singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
* 以后每次获取就是直接从容器（map.get()）中拿，
* request：同一次请求创建一个实例
* session：同一个session创建一个实例
*
*/
@Scope("prototype")
@Bean("person")
public Person person(){
return new Person();
}
@Lazy-组件在IOC容器内实现懒加载
/* 懒加载：
* 单实例bean：默认在容器启动的时候创建对象；
* 懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；
* /
@Conditional-按照条件注册Bean
可作用在配置类上，也可作用在配置方法上
/**
* @Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean
*
* 如果系统是windows，给容器中注册("bill")
* 如果是linux系统，给容器中注册("linus")
*/
@Conditional(WindowsCondition.class)
@Bean("bill")
public Person person01(){
return new Person("Bill Gates",62);
}
@Conditional(LinuxCondition.class)
@Bean("linus")
public Person person02(){
return new Person("linus", 48);
}
需要创建自定义类实现Condition接口，并实现matches方法
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;
//判断是否windows系统
public class WindowsCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
Environment environment = context.getEnvironment();
String property = environment.getProperty("os.name");
if(property.contains("Windows")){
return true;
}
return false;
}
}
@Import-给容器中快速导入一个组件
- 直接导入一个或多个类
@Import({Color.class,Red.class})
- 实现ImportSelector接口的selectImports方法，并返回需要导入的组件的全类名数组；
@Import({MyImportSelector .class})
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;
//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
//返回值，就是到导入到容器中的组件全类名
//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
// TODO Auto-generated method stub
//importingClassMetadata
//方法不要返回null值
return new String[]{"com.i9577.bean.Person","com.i9577.bean.Blue"};
}
}
- 实现ImportBeanDefinitionRegistrar的registerBeanDefinitions方法手动注册bean到容器
@Import({MyImportBeanDefinitionRegistrar .class})
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
import com.i9577.bean.RainBow;
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
/**
* AnnotationMetadata：当前类的注解信息
* BeanDefinitionRegistry:BeanDefinition注册类；
* 把所有需要添加到容器中的bean；调用
* BeanDefinitionRegistry.registerBeanDefinition手工注册进来
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
boolean definition = registry.containsBeanDefinition("com.i9577.bean.Red");
boolean definition2 = registry.containsBeanDefinition("com.i9577.bean.Blue");
if(definition && definition2){
//指定Bean定义信息；（Bean的类型，Bean。。。）
RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
//注册一个Bean，指定bean名
registry.registerBeanDefinition("rainBow", beanDefinition);
}
}
}
FactoryBean-Spring提供的 FactoryBean（工厂Bean）
1）、默认获取到的是工厂bean调用getObject创建的对象
2）、要获取工厂Bean本身，我们需要给id前面加一个&
如：&colorFactoryBean
@Bean
public ColorFactoryBean colorFactoryBean(){
return new ColorFactoryBean();
}
import org.springframework.beans.factory.FactoryBean;
//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {
//返回一个Color对象，这个对象会添加到容器中
@Override
public Color getObject() throws Exception {
// TODO Auto-generated method stub
System.out.println("ColorFactoryBean...getObject...");
return new Color();
}
@Override
public Class<?> getObjectType() {
// TODO Auto-generated method stub
return Color.class;
}
//是单例？
//true：这个bean是单实例，在容器中保存一份
//false：多实例，每次获取都会创建一个新的bean；
@Override
public boolean isSingleton() {
// TODO Auto-generated method stub
return false;
}
}
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
