首页 > 其他分享> 文章详细

Spring注解驱动开发(二)-----生命周期、属性赋值

2019-06-28 23:00:59 阅读：134 来源： 互联网

标签：... 生命周期 Spring springframework bean org import public 赋值

bean的生命周期

bean的生命周期：
bean创建---初始化----销毁的过程
容器管理bean的生命周期；
我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法-----一共四种方式

构造（对象创建）

单实例：在容器启动的时候创建对象
多实例：在每次获取的时候创建对象

初始化：

对象创建完成，并赋值好，调用初始化方法。。。

销毁：

单实例：容器关闭的时候
多实例：容器不会管理这个bean；容器不会调用销毁方法；

指定方式

1、指定初始化和销毁方法；

通过@Bean指定init-method和destroy-method；

MainConfigOfLifeCycle：

package com.atguigu.config;

import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import com.atguigu.bean.Car;

@Configuration
public class MainConfigOfLifeCycle {
    
    @Bean(initMethod="init",destroyMethod="detory")
    public Car car(){
        return new Car();
    }

}

car：

package com.atguigu.bean;

import org.springframework.stereotype.Component;

@Component
public class Car {
    
    public Car(){
        System.out.println("car constructor...");
    }
    
    public void init(){
        System.out.println("car ... init...");
    }
    
    public void detory(){
        System.out.println("car ... detory...");
    }

}

2、通过让Bean实现InitializingBean（定义初始化逻辑），DisposableBean（定义销毁逻辑）;

Cat：

package com.atguigu.bean;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class Cat implements InitializingBean,DisposableBean {
    
    public Cat(){
        System.out.println("cat constructor...");
    }

    @Override
    public void destroy() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("cat...destroy...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("cat...afterPropertiesSet...");
    }

}

MainConfigOfLifeCycle

@ComponentScan("com.atguigu.bean")
@Configuration
public class MainConfigOfLifeCycle {

}

3、可以使用JSR250；

@PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
@PreDestroy：在容器销毁bean之前通知我们进行清理工作

Dog：

package com.atguigu.bean;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class Dog {
    
    public Dog(){
        System.out.println("dog constructor...");
    }
    
    //对象创建并赋值之后调用
    @PostConstruct
    public void init(){
        System.out.println("Dog....@PostConstruct...");
    }
    
    //容器移除对象之前
    @PreDestroy
    public void detory(){
        System.out.println("Dog....@PreDestroy...");
    }
}

MainConfigOfLifeCycle：

@ComponentScan("com.atguigu.bean")
@Configuration
public class MainConfigOfLifeCycle {

}

4、BeanPostProcessor【interface】：bean的后置处理器；

在bean初始化前后进行一些处理工作；
postProcessBeforeInitialization:在初始化之前工作
postProcessAfterInitialization:在初始化之后工作

MyBeanPostProcessor：

package com.atguigu.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * 后置处理器：初始化前后进行处理工作
 * 将后置处理器加入到容器中
 * @author lfy
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
        return bean;
    }

}

在bean初始化(调用构造方法)之后----->调用postProcessBeforeInitialization()----->init()方法----->postProcessAfterInitialization()

BeanPostProcessor原理

执行顺序

-----BeanPostProcessor.postProcessBeforeInitialization
|-----初始化：对象创建完成，并赋值好，调用初始化方法。。。
-----BeanPostProcessor.postProcessAfterInitialization

执行流程(BeanPostProcessor原理)

1、populateBean(beanName, mbd, instanceWrapper);-----给bean进行属性赋值

2、initializeBean
{
　　　　applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
　　　　invokeInitMethods(beanName, wrappedBean, mbd);-----执行自定义初始化
　　　　applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

注：遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization

spring底层对BeanPostProcessor的使用

1、ApplicationContextAware-----实现ApplicationContextAware接口后，就可以将ApplicationContext对象通过setApplicationContext()注入。

package com.atguigu.bean;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class Dog implements ApplicationContextAware {
    
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

属性赋值

@Value赋值

1、MainConfigOfPropertyValues

package com.atguigu.config;

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

import com.atguigu.bean.Person;

//使用@PropertySource读取外部配置文件中的k/v保存到运行的环境变量中;加载完外部的配置文件以后使用${}取出配置文件的值
@PropertySource(value={"classpath:/person.properties"})
@Configuration
public class MainConfigOfPropertyValues {
    
    @Bean
    public Person person(){
        return new Person();
    }

}

2、Person

package com.atguigu.bean;

import org.springframework.beans.factory.annotation.Value;

public class Person {
    
    //使用@Value赋值；
    //1、基本数值
    //2、可以写SpEL； #{}
    //3、可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值）
    
    @Value("张三")
    private String name;
    @Value("#{20-2}")
    private Integer age;
    
    @Value("${person.nickName}")
    private String nickName;
        
    public String getNickName() {
        return nickName;
    }
    public void setNickName(String nickName) {
        this.nickName = nickName;
    }
    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;
    }
    
    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", nickName=" + nickName + "]";
    }
}

3、person.properties

person.nickName=李四

注：对于在classpath路径下的配置文件，也可以通过如下方式获取属性。配置文件的值都会加载到environment环境变量中，可以直接从环境变量中取值。

标签：...,生命周期,Spring,springframework,bean,org,import,public,赋值
来源： https://www.cnblogs.com/alimayun/p/11105154.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9