一、组件添加
1、@Configuration&@Bean
@Configuration:标注在类上,告诉Spring这是一个配置类(配置类==配置文件)
@Bean:标注在方法上,给容器中注册一个Bean,类型为返回值的类型id,默认是用方法名作为id,也可以通过value属性指定id
@Configuration
public class MainConfig {
@Bean("person")
public Person person01() {
return new Person("lisi", 20);
}
}
@Test
public void test01() {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
Person bean = applicationContext.getBean(Person.class);
System.out.println(bean);// Person [name=lisi, age=20]
String[] beanNamesForType = applicationContext.getBeanNamesForType(Person.class);
for (String name : beanNamesForType) {
System.out.println(name);// person
}
}
2、@ComponentScan
在配置类上添加@ComponentScan注解,value属性值为需要扫描的包名
@ComponentScan(value = "com.hand")
excludeFilters属性指定扫描的时候按照什么规则排除哪些组件
//排除标注了@Controller和@Service注解的类
@ComponentScan(value = "com.hand", excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})})
includeFilters属性指定扫描的时候只包含哪些组件,需要使用将useDefaultFilters属性值置为false来禁用默认的规则
//只保留标注了@Controller注解的类
@ComponentScan(value = "com.hand", includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})},
useDefaultFilters = false)
@ComponentScans指定多个扫描规则
@ComponentScans(value = {
@ComponentScan(value = "com.hand", includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})},
useDefaultFilters = false)
})
3、自定义TypeFilter指定过滤规则
FilterType.ANNOTATION:按照注解
FilterType.ASSIGNABLE_TYPE:按照给定的类型
FilterType.ASPECTJ:使用ASPECTJ表达式
FilterType.REGEX:使用正则表达式
//只保留BookService这种类型的类
@ComponentScans(value = {
@ComponentScan(value = "com.hand", includeFilters = {
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {BookService.class})},
useDefaultFilters = false)
})
FilterType.CUSTOM:自定义过滤规则
@ComponentScan(value = "com.hand", includeFilters = {
@ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})},
useDefaultFilters = false
)
public class MyTypeFilter implements TypeFilter {
//metadataReader:读取到的当前正在扫描的类的信息
//metadataReaderFactory:可以获取到其他任何类信息的
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
//获取当前类注解信息
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
//获取当前正在扫描的类的类型信息
ClassMetadata classMetadata = metadataReader.getClassMetadata();
String className = classMetadata.getClassName();
System.out.println("className:" + className);
//获取当前类资源信息(类的路径)
Resource resource = metadataReader.getResource();
if (className.contains("Service")) {
//扫描到的类名只要包含Service,就添加到IOC容器中(即使类上没有标注@Service等注解也会被添加进IOC容器中)
return true;
}
return false;
}
}
4、@Scope设置组件作用域
/*
* ConfigurableBeanFactory#SCOPE_PROTOTYPE:多实例的,IOC容器启动并不会去调用方法创建对象放在容器中,每次获取的时候才会调用方法创建对象
* ConfigurableBeanFactory#SCOPE_SINGLETON:单实例的(默认值),IOC容器启动会调用方法创建对象放到ioc容器中,以后每次获取就是直接从容器中拿
* org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST:同一次请求创建一个实例
* org.springframework.web.context.WebApplicationContext#SCOPE_SESSION:同一个session创建一个实例
*/
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Bean
public Person person() {
return new Person("张三", 25);
}
5、@Lazy-bean懒加载
/*
* 单实例bean:默认在容器启动的时候创建对象
* 懒加载:容器启动不创建对象。第一次使用(获取)Bean创建对象,并初始化
*/
@Lazy
@Bean
public Person person() {
System.out.println("初始化person对象");
return new Person("张三", 25);
}
6、@Conditional按照条件注册Bean
标注在方法上:
/*
* @Conditional({Condition}) : 按照一定的条件进行判断,满足条件给容器中注册bean
* 如果是linux系统,给容器中注册("linus")
*/
@Conditional(LinuxCondition.class)
@Bean("linus")
public Person person2() {
return new Person("Linus", 48);
}
//判断是否linux系统
public class LinuxCondition implements Condition {
/**
* ConditionContext:判断条件能使用的上下文(环境)
* AnnotatedTypeMetadata:注释信息
*/
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//1、能获取到IOC使用的beanfactory
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
//2、获取类加载器
ClassLoader classLoader = context.getClassLoader();
//3、获取当前环境信息
Environment environment = context.getEnvironment();
//4、获取到bean定义的注册类
BeanDefinitionRegistry registry = context.getRegistry();
String property = environment.getProperty("os.name");
//可以判断容器中的bean注册情况,也可以给容器中注册bean
boolean definition = registry.containsBeanDefinition("person");
if (property.contains("linux")) {
return true;
}
return false;
}
}
标注在类上:
//类中组件统一设置。满足当前条件,这个类中配置的所有bean注册才能生效;
@Conditional({WindowsCondition.class})
@Configuration
public class MainConfig2 {
7、@Import给容器中快速导入一个组件
@Configuration
//@Import导入组件,id默认是组件的全类名
@Import(value = {Color.class, Red.class})
public class MainConfig2 {
8、ImportSelector
@Configuration
//@Import导入组件,id默认是组件的全类名
@Import(value = {Color.class, Red.class, MyImportSelector.class})
public class MainConfig2 {
//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
//返回值,就是导入到容器中的组件全类名
//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.hand.bean.Blue", "com.hand.bean.Yellow"};
}
}
9、ImportBeanDefinitionRegistrar
@Import(value = {Color.class, Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
/*
* AnnotationMetadata:当前类的注解信息
* BeanDefinitionRegistry:BeanDefinition注册类,把所有需要添加到容器中的bean,调用BeanDefinitionRegistry.registerBeanDefinition手工注册
*/
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
boolean flag1 = registry.containsBeanDefinition("com.hand.bean.Red");
boolean flag2 = registry.containsBeanDefinition("com.hand.bean.Blue");
if (flag1 && flag2) {
//指定Bean定义信息
RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
//注册一个Bean,指定bean名
registry.registerBeanDefinition("rainBow", beanDefinition);
}
}
}
10、使用FactoryBean注册组件
@Bean
public ColorFactoryBean colorFactoryBean(){
//注册实际上是Color对象
return new ColorFactoryBean();
}
//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {
//返回一个Color对象,这个对象会添加到容器中
public Color getObject() throws Exception {
return new Color();
}
public Class<?> getObjectType() {
return Color.class;
}
//是否单例
public boolean isSingleton() {
return true;
}
}
@Test
public void test06() {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
Object bean1 = applicationContext.getBean("colorFactoryBean");
System.out.println("bean1的类型:"+bean1.getClass());//bean1的类型:class com.hand.bean.Color
Object bean2 = applicationContext.getBean("&colorFactoryBean");
System.out.println("bean2的类型:"+bean2.getClass());//bean2的类型:class com.hand.bean.ColorFactoryBean
}
11、给容器中添加Bean的几种方式
给容器中注册组件:
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前面加一个&
二、Bean生命周期
1、@Bean指定初始化和销毁方法
/*
* Bean的生命周期:bean创建-->初始化-->销毁的过程
* 容器管理bean的生命周期
*
* 构造(对象创建)
* 单实例:在容器启动的时候创建对象
* 多实例:在每次获取的时候创建对象
*
* 初始化:对象创建完成,并赋值好,调用初始化方法
* 销毁:
* 单实例:容器关闭的时候
* 多实例:容器不会管理这个bean,容器不会调用销毁方法
*
* 可以自定义初始化和销毁方法,容器在bean进行到当前生命周期的时候来调用自定义的初始化和销毁方法
* 指定初始化和销毁方法;通过@Bean指定init-method和destroy-method
*/
@Configuration
public class MainConfigOfLifeCycle {
@Bean(initMethod = "init", destroyMethod = "destroy")
public Car car() {
return new Car();
}
}
public class Car {
public Car(){
System.out.println("car constructor...");
}
public void init(){
System.out.println("car init...");
}
public void destroy(){
System.out.println("car destroy...");
}
}
2、InitializingBean和DisposableBean
通过让Bean实现InitializingBean(定义初始化逻辑),DisposableBean(定义销毁逻辑)
@Component
public class Cat implements InitializingBean, DisposableBean {
public Cat(){
System.out.println("cat constructor...");
}
public void destroy() throws Exception {
System.out.println("cat destroy...");
}
public void afterPropertiesSet() throws Exception {
System.out.println("cat afterPropertiesSet...");
}
}
3、@PostConstruct&@PreDestroy
可以使用JSR250:
@PostConstruct:在bean创建完成并且属性赋值完成,来执行初始化方法
@PreDestroy:在容器销毁bean之前通知我们进行清理工作
@Component
public class Dog {
public Dog(){
System.out.println("dog constructor...");
}
//对象创建并赋值之后调用
@PostConstruct
public void init(){
System.out.println("dog @PostConstruct...");
}
//在容器移除对象之前
@PreDestroy
public void destroy(){
System.out.println("dog @PreDestroy...");
}
}
4、BeanPostProcessor后置处理器
BeanPostProcessor【interface】:bean的后置处理器
在bean初始化前后进行一些处理工作
postProcessBeforeInitialization:在初始化之前工作
postProcessAfterInitialization:在初始化之后工作
/*
* 后置处理器:初始化前后进行处理工作
* 将后置处理器加入到容器中
*/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println(beanName + " postProcessBeforeInitialization...");
return bean;
}
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println(beanName + " postProcessAfterInitialization...");
return bean;
}
}
5、小结
Bean的生命周期:bean创建-->初始化-->销毁的过程
容器管理bean的生命周期
构造(对象创建)
单实例:在容器启动的时候创建对象
多实例:在每次获取的时候创建对象
初始化:对象创建完成,并赋值好,调用初始化方法
销毁:
单实例:容器关闭的时候
多实例:容器不会管理这个bean,容器不会调用销毁方法
可以自定义初始化和销毁方法,容器在bean进行到当前生命周期的时候来调用自定义的初始化和销毁方法
1)、指定初始化和销毁方法;通过@Bean指定init-method和destroy-method
2)、通过让Bean实现InitializingBean(定义初始化逻辑),DisposableBean(定义销毁逻辑)
3)、可以使用JSR250:
@PostConstruct:在bean创建完成并且属性赋值完成,来执行初始化方法
@PreDestroy:在容器销毁bean之前通知我们进行清理工作
4)、BeanPostProcessor【interface】:bean的后置处理器
在bean初始化前后进行一些处理工作
postProcessBeforeInitialization:在初始化之前工作
postProcessAfterInitialization:在初始化之后工作
三、组件赋值
1、@Value赋值
public class Person {
//使用@Value赋值
//1、基本数值
//2、可以写SpEL:#{}
@Value("张三")
private String name;
@Value("#{20-2}")
private Integer age;
2、@PropertySource加载外部配置文件
配置文件person.properties:
person.nickName=张三123
@Configuration
//使用@PropertySource读取外部配置文件中的属性
@PropertySource(value = {"classpath:/person.properties"})
public class MainConfigOfPropertyValues {
@Bean
public Person person(){
return new Person();
}
}
public class Person {
//使用@Value赋值
//1、基本数值
//2、可以写SpEL:#{}
//3、可以写${},取出配置文件中的值(在运行环境变量里面的值)
@Value("张三")
private String name;
@Value("#{20-2}")
private Integer age;
@Value("${person.nickName}")
private String nickName;
@Test
public void test02() {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfPropertyValues.class);
ConfigurableEnvironment environment = applicationContext.getEnvironment();
String property = environment.getProperty("person.nickName");
System.out.println(property);
}
2、自动装配
自动装配:Spring利用依赖注入(DI)完成对IOC容器中各个组件的依赖关系赋值
1)、@Autowired:自动注入
1)默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值
2)如果找到多个相同类型的组件,再将属性的名称作为组件的id去容器中查找applicationContext.getBean("bookDao")
3)@Qualifier("bookDao"):使用@Qualifier指定需要装配的组件的id,而不是使用属性名
4)自动装配默认一定要将属性赋值好,没有就会报错
可以使用@Autowired(required=false)
5)@Primary:让Spring进行自动装配的时候,默认使用首选的bean
也可以继续使用@Qualifier指定需要装配的bean的名字
2)、Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[Java规范的注解]
@Resource:
可以和@Autowired一样实现自动装配功能;默认是按照组件名称进行装配的
没有能支持@Primary功能没有支持@Autowired(reqiured=false)
@Inject:
需要导入javax.inject的包,和Autowired的功能一样。没有required=false的功能
@Autowired:Spring定义的; @Resource、@Inject都是Java规范
3)、 @Autowired:构造器,参数,方法,属性;都是从容器中获取参数组件的值
1)[标注在方法位置]:@Bean+方法参数;参数从容器中获取;默认不写@Autowired效果是一样的;都能自动装配
2)[标在构造器上]:如果组件只有一个有参构造器,这个有参构造器的@Autowired可以省略,参数位置的组件还是可以自动从容器中获取
3)放在参数位置
3、@Profile
配置文件dbconfig.properties:
db.user=root
db.password=123456
db.driverClass=com.mysql.jdbc.Driver
/*
* Profile:
* Spring为我们提供的可以根据当前环境,动态的激活和切换一系列组件的功能
* 开发环境、测试环境、生产环境
* 数据源:(/A)(/B)(/C)
*
* @Profile:指定组件在哪个环境的情况下才能被注册到容器中,不指定,任何环境下都能注册这个组件
* 1)、加了环境标识的bean,只有这个环境被激活的时候才能注册到容器中。默认是default环境
* 2)、写在配置类上,只有是指定的环境的时候,整个配置类里面的所有配置才能开始生效
* 3)、没有标注环境标识的bean在,任何环境下都是加载的
*/
@PropertySource("classpath:/dbconfig.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware {
@Value("${db.user}")
private String user;
private StringValueResolver valueResolver;
private String driverClass;
@Profile("test")
@Bean("testDataSource")
public DataSource dataSourceTest(@Value("${db.password}") String pwd) throws Exception {
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/cms");
dataSource.setDriverClass(driverClass);
return dataSource;
}
@Profile("dev")
@Bean("devDataSource")
public DataSource dataSourceDev(@Value("${db.password}") String pwd) throws Exception {
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/web_shop");
dataSource.setDriverClass(driverClass);
return dataSource;
}
@Profile("prod")
@Bean("prodDataSource")
public DataSource dataSourceProd(@Value("${db.password}") String pwd) throws Exception {
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/imooc-demo");
dataSource.setDriverClass(driverClass);
return dataSource;
}
public void setEmbeddedValueResolver(StringValueResolver resolver) {
this.valueResolver = resolver;
driverClass = valueResolver.resolveStringValue("${db.driverClass}");
}
}
//1、使用命令行动态参数: 在虚拟机参数位置加载 -Dspring.profiles.active=test
//2、代码的方式激活某种环境
@Test
public void test01(){
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext();
//1、创建一个applicationContext
//2、设置需要激活的环境
applicationContext.getEnvironment().setActiveProfiles("dev");
//3、注册主配置类
applicationContext.register(MainConfigOfProfile.class);
//4、启动刷新容器
applicationContext.refresh();
String[] namesForType = applicationContext.getBeanNamesForType(DataSource.class);
for (String string : namesForType) {
System.out.println(string);
}
applicationContext.close();
}