Spring笔记(2) - 生命周期/属性赋值/自动装配及部分源码解析

一.生命周期

  1. @Bean自定义初始化和销毁方法

    //====xml方式: init-method和destroy-method====
        <bean id="person" class="com.hrh.bean.Person" scope="singleton" init-method="" destroy-method="">
            <property name="name" value="张三"></property>
            <property name="age" value="20"></property>
        </bean>
    //====@Bean方式====
    /**
     *单实例:只调用initMethod一次,容器关闭时会调用destroyMethod
     *多实例: 每次调用Bean都调用initMethod,容器关闭不会调用destroyMethod,需要手动调用
     **/
        @Bean(initMethod = "",destroyMethod = "")
        public Person person() {
            System.out.println("注入容器。。。。。");
            return new Person("张三", 20);
        }
    //====实现接口方式====
    /**
     * InitializingBean:定义初始化逻辑,实现afterPropertiesSet()
     * DisposableBean:定义销毁逻辑,实现destroy()
     */
    @Component
    public class Person implements InitializingBean, DisposableBean {
        public Person(){
            System.out.println("Person 。。。 constructor");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("Person 。。。afterPropertiesSet");
        }
    
        @Override
        public void destroy() throws DestroyFailedException {
            System.out.println("Person 。。。destroy");
        }
    }
    @Configurable
    @ComponentScan(value = "com.hrh")
    public class BeanConfig {}
    
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
    context.close();
  2. @PostConstruct和@PreDestroy

    /**
     * JSR250:
     *  @PostConstruct: 在bean创建完成并且属性赋值完成后,来执行初始化方法
     *  @PreDestroy :在容器销毁bean之前通知进行清理工作
     */
    @Component
    public class Color {
        public Color() {
            System.out.println("Color 。。。 constructor");
        }
    
        @PostConstruct//对象创建并赋值之后调用
        public void init() throws Exception {
            System.out.println("Color 。。。init");
        }
    
        @PreDestroy//容器移除对象之前
        public void destroy() {
            System.out.println("Color 。。。destroy");
        }
    }
  3.  BeanPostProcessor:bean后置处理器,对bean初始化之前和之后的处理,上文的@PostConstruct和@PreDestroy就是使用了该类实现的

        @Component
        public class MyBeanPostProcessor implements BeanPostProcessor {
            /**
             *
             * @param bean 容器创建的实例
             * @param beanName 容器创建实例的名字
             * @return 创建的实例或进行包装后的实例
             * @throws BeansException
             */
            @Override
            public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
                System.out.println("postProcessBeforeInitialization====>【"+bean+"】:"+beanName);
                return bean;
            }
        
            @Override
            public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
                System.out.println("postProcessAfterInitialization====>【"+bean+"】:"+beanName);
                return bean;
            }
        }
        public static void main(String[] args) {
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
        }
    •  原理:从doCreateBean可以看到,在对bean进行属性赋值后,调用initializeBean初始化bean,在initializeBean中会在调用初始化方法前后会遍历所有的BeanPostProcessor实现的方法
          AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
          public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
              ....
              refresh();//刷新容器
          }
          public void refresh() throws BeansException, IllegalStateException {
              ...
              //初始化剩下所有的(非懒加载的)单实例对象
              finishBeanFactoryInitialization(beanFactory);
          }
          protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
              ...
              //初始化剩下所有的(非懒加载的)单实例对象
              beanFactory.preInstantiateSingletons();
          }
          public void preInstantiateSingletons() throws BeansException {
              ...
              getBean(beanName);
              ...
          }
          @Override
          public Object getBean(String name) throws BeansException {
              return doGetBean(name, null, null, false);
          }
          protected <T> T doGetBean(
                      final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
                      throws BeansException {
              ...
              //getSingleton获取实例
              sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                  @Override
                  public Object getObject() throws BeansException {
                      try {
                          return createBean(beanName, mbd, args);//创建实例
                      }
                      ...
                  }
              });
              ...
              return (T) bean;
          }
      
          protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
              ...
              Object beanInstance = doCreateBean(beanName, mbdToUse, args);//创建实例
              ...
              return beanInstance;
          }
          protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
              ...
              Object exposedObject = bean;
              try {
                  populateBean(beanName, mbd, instanceWrapper);//对属性赋值
                  if (exposedObject != null) {
                      exposedObject = initializeBean(beanName, exposedObject, mbd);//初始化对象,相当后置处理器的调用
                  }
              }
              ...
              return exposedObject;
          }
          //从下面可以看到,在执行初始化方法之前,执行applyBeanPostProcessorsBeforeInitialization,执行完初始化方法之后,执行applyBeanPostProcessorsAfterInitialization
          protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
              ...
              wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
              ...
              invokeInitMethods(beanName, wrappedBean, mbd);//执行初始化方法
              ...
              wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
              return wrappedBean;
          }
          @Override
          public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
                  throws BeansException {
              Object result = existingBean;
              //遍历执行实现了BeanPostProcessor接口的类,比如MyBeanPostProcessor,然后执行实现类的重写方法
              for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
                  result = beanProcessor.postProcessBeforeInitialization(result, beanName);
                  if (result == null) {
                      return result;
                  }
              }
              return result;
          }
    •  InitDestroyAnnotationBeanPostProcessor:处理@PostConstruct和@PreDestroy
          /**
           *  处理javax.annotation.PostConstruct注解
           */
          public void setInitAnnotationType(Class<? extends Annotation> initAnnotationType) {
              this.initAnnotationType = initAnnotationType;
          }
          /**
           *  处理javax.annotation.PreDestroy注解
           */
          public void setDestroyAnnotationType(Class<? extends Annotation> destroyAnnotationType) {
              this.destroyAnnotationType = destroyAnnotationType;
          }
          public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
              //找到了使用@PostConstruct和@PreDestroy的类的生命周期注解
              LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
              try {
                  //对每个注解上的方法进行反射执行
                  metadata.invokeInitMethods(bean, beanName);
              }
              catch (InvocationTargetException ex) {
                  throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
              }
              catch (Throwable ex) {
                  throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
              }
              return bean;
          }
          public void invokeInitMethods(Object target, String beanName) throws Throwable {
              Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
              Collection<LifecycleElement> initMethodsToIterate =
                      (checkedInitMethods != null ? checkedInitMethods : this.initMethods);
              if (!initMethodsToIterate.isEmpty()) {
                  for (LifecycleElement element : initMethodsToIterate) {
                      if (logger.isTraceEnabled()) {
                          logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
                      }
                      //element包含注解和注解上的方法 
                      element.invoke(target);//执行每个注解上的方法
                  }
              }
          } 

二.属性赋值

  1.  @Value

    public class Person {
        /**
         * @Value :基本数值,SpEL表达式 #{}, ${}获取配置文件的值
         */
        @Value("张三")
        private String name;
        @Value("#{20-1}")
        private Integer age;
    }
  2. @PropertySource:读取外部配置文件中k/v的数据

    public class Person{
        /**
         * @Value :基本数值,SpEL表达式 #{}, ${}获取配置文件的值
         */
        @Value("张三")
        private String name;
        @Value("#{20-1}")
        private Integer age;
        @Value("${sex}")
        private String sex;
    }
    @PropertySource(value = "classpath:/global.properties")
    @Configurable
    public class BeanConfig {}
    
    global.properties
    sex=男

三.自动装配

  1. @Autowired&@Qualifier&@Primary:Spring定义

    @Service
    public class UserService {
        /**
         * @Autowired :自动注入
         * 1)默认优先按照类型去容器中对应的组件:context.getBean(UserDao.class);
         * 2)如果有多少相同类型的组件,需要将属性的名称作为id去容器查找:(UserDao) context.getBean("userDao1")
         * 3)@Qualifier("userDao1"):指定需要装配的组件id,而不是使用默认属性;优先级比@Primary高
         * 4)如果UserDao没有注入容器(@Repository和 @Bean):启用@Autowired会报空指针异常,需要required = false,表示从容器中找到就自动装配,找不到就设为null
         * 5)@Primary表示Spring自动装配时,默认使用首选的bean
         */
        @Qualifier("userDao")
        @Autowired
        private UserDao userDao;
    
        public void printf() {
            System.out.println(userDao);
        }
    }
    @Repository
    public class UserDao {
        private String id ="1";
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        @Override
        public String toString() {
            return "UserDao{" +
                    "id='" + id + '\'' +
                    '}';
        }
    }
    @Configurable
    @ComponentScan(value = "com.hrh")
    public class BeanConfig {
        @Primary
        @Bean("userDao1")
        public UserDao userDao() {
            UserDao userDao = new UserDao();
            userDao.setId("2");
            return userDao;
        }
    }
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
    UserService person = context.getBean(UserService.class);
    person.printf();
    //UserDao userDao = context.getBean(UserDao.class);
    UserDao userDao =(UserDao) context.getBean("userDao1");
    System.out.println(userDao);  
  2. @Resource&@Inject:Java规范

    1. @Resource:只按照属性名称进行装配,可以使用@Resource(name = "")装配指定id;不支持@Primary的使用,即使用该注解是无效的;
    2. @Inject:支持自动装配,和@Autowired功能一样,支持@Primary的使用;没有required = false属性;
  3. Aware注入Spring底层组件&原理

    • 自定义组件使用Spring容器底层的一些组件(ApplicationContext、BeanFactory...),实现xxxAware
      public class Color  implements ApplicationContextAware {
          private ApplicationContext applicationContext;
          //获取容器并赋值给当前类
          @Override
          public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
              this.applicationContext = applicationContext;
          }
      }
    • xxxAware使用对应的xxxAwareProcessor进行处理:利用后置处理器在类初始化时注入组件
          //bean:获得实现了ApplicationContextAware接口的类,即Color
          public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
              //类型判断
              if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                      bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                      bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
                  return bean;
              }
      
              AccessControlContext acc = null;
      
              if (System.getSecurityManager() != null) {
                  acc = this.applicationContext.getBeanFactory().getAccessControlContext();
              }
      
              if (acc != null) {
                  //权限检查
                  AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                      invokeAwareInterfaces(bean);
                      return null;
                  }, acc);
              }
              else {
                  invokeAwareInterfaces(bean);//转换并注入组件
              }
      
              return bean;
          }
      
          private void invokeAwareInterfaces(Object bean) {
              if (bean instanceof EnvironmentAware) {
                  ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
              }
              if (bean instanceof EmbeddedValueResolverAware) {
                  ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
              }
              if (bean instanceof ResourceLoaderAware) {
                  ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
              }
              if (bean instanceof ApplicationEventPublisherAware) {
                  ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
              }
              if (bean instanceof MessageSourceAware) {
                  ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
              }
              if (bean instanceof ApplicationContextAware) {
                  //给当前类注入ApplicationContext
                  ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
              }
          }
  4. @Profile:指定组件在哪个环境的情况下才能被注册到容器中

    • 加了环境标识的bean,只有在指定环境才能被注册到容器中,默认是default环境
    • 写在配置类上,只有是指定环境整个配置类里面的所有配置才能生效
    • 没有环境标识的bean在任何环境下都会被注册到容器中
      @PropertySource("classpaht:/db.properties")
      @Configuration
      public class BeanProfileConfig {
          @Value("${db.user}")
          private String user;
          @Value("${db.driverClass}")
          private String driverClass;
      
          @Profile("test")
          @Bean
          public DataSource TestDateSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
              ComboPooledDataSource dataSource = new ComboPooledDataSource();
              dataSource.setUser(user);
              dataSource.setPassword(pwd);
              dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
              dataSource.setDriverClass(driverClass);
              return dataSource;
          }
      
          @Profile("dev")
          @Bean
          public DataSource DevDateSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
              ComboPooledDataSource dataSource = new ComboPooledDataSource();
              dataSource.setUser(user);
              dataSource.setPassword(pwd);
              dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/dev");
              dataSource.setDriverClass(driverClass);
              return dataSource;
          }
      
          @Profile("pro")
          @Bean
          public DataSource ProDateSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
              ComboPooledDataSource dataSource = new ComboPooledDataSource();
              dataSource.setUser(user);
              dataSource.setPassword(pwd);
              dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/pro");
              dataSource.setDriverClass(driverClass);
              return dataSource;
          }
      }
      /**
       * 1.使用命令行动态参数:在虚拟机参数位置加载 -Dspring.profiles.active=test
       * 2.代码方式:创建无参容器,设置激活环境
       */
      //创建容器
      AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
      //设置需要激活的环境
      context.getEnvironment().setActiveProfiles("test");
      //注册主配置类
      context.register(BeanProfileConfig.class);
      //启动刷新容器
      context.refresh(); 
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值