import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
	BeanWrapper bw = new BeanWrapperImpl(ThreadPoolTaskExecutor.class);
	determinePoolSizeRange(bw);
	if (this.queueCapacity != null) {
		bw.setPropertyValue("queueCapacity", this.queueCapacity);
	}
	if (this.keepAliveSeconds != null) {
		bw.setPropertyValue("keepAliveSeconds", this.keepAliveSeconds);
	}
	if (this.rejectedExecutionHandler != null) {
		bw.setPropertyValue("rejectedExecutionHandler", this.rejectedExecutionHandler);
	}
	if (this.beanName != null) {
		bw.setPropertyValue("threadNamePrefix", this.beanName + "-");
	}
	this.target = (TaskExecutor) bw.getWrappedInstance();
	if (this.target instanceof InitializingBean) {
		((InitializingBean) this.target).afterPropertiesSet();
	}
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
    if (executor instanceof InitializingBean) {
        InitializingBean bean = (InitializingBean) executor;
        bean.afterPropertiesSet();
    }
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
@Override
protected void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
	if (handlerExceptionResolvers == null) {
		return;
	}
	for (HandlerExceptionResolver resolver : handlerExceptionResolvers) {
		if (resolver instanceof ApplicationContextAware) {
			((ApplicationContextAware) resolver).setApplicationContext(getApplicationContext());
		}
		if (resolver instanceof InitializingBean) {
			try {
				((InitializingBean) resolver).afterPropertiesSet();
			}
			catch (Exception ex) {
				throw new IllegalStateException("Failure from afterPropertiesSet", ex);
			}
		}
		exceptionResolvers.add(resolver);
	}
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
/**
 * Create and start a new container using the specified factory.
 */
protected MessageListenerContainer createListenerContainer(JmsListenerEndpoint endpoint,
		JmsListenerContainerFactory<?> factory) {

	MessageListenerContainer listenerContainer = factory.createListenerContainer(endpoint);

	if (listenerContainer instanceof InitializingBean) {
		try {
			((InitializingBean) listenerContainer).afterPropertiesSet();
		}
		catch (Exception ex) {
			throw new BeanInitializationException("Failed to initialize message listener container", ex);
		}
	}

	int containerPhase = listenerContainer.getPhase();
	if (containerPhase < Integer.MAX_VALUE) {  // a custom phase value
		if (this.phase < Integer.MAX_VALUE && this.phase != containerPhase) {
			throw new IllegalStateException("Encountered phase mismatch between container factory definitions: " +
					this.phase + " vs " + containerPhase);
		}
		this.phase = listenerContainer.getPhase();
	}

	return listenerContainer;
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
public static <T> T parseTag(Class<T> clazz, Spec spec) {
    T object = Reflect.on(clazz).create().get();

    if (object instanceof SpecAppliable)
        ((SpecAppliable) object).applySpec(spec);

    if (object instanceof InitializingBean) {
        try {
            ((InitializingBean) object).afterPropertiesSet();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    return object;
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
public static <T> T createBean(Class<T> clazz, Settings settings, ApplicationContext applicationContext) throws Exception {
	if (clazz == null || clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) {
		return null;
	}

	T bean = clazz.newInstance();

	if (bean instanceof SettingsAware) {
		((SettingsAware) bean).setSettings(settings);
	}

	if (bean instanceof ApplicationContextAware) {
		((ApplicationContextAware) bean).setApplicationContext(applicationContext);
	}

	if (bean instanceof InitializingBean) {
		((InitializingBean) bean).afterPropertiesSet();
	}

	return bean;
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
@Bean
InitializingBean init(
        final IdentityService identityService) {
    return new InitializingBean() {
        @Override
        public void afterPropertiesSet() throws Exception {

            // install groups & users
            Group userGroup = group("user");
            Group adminGroup = group("admin");

            User joram = user("jbarrez", "Joram", "Barrez");
            identityService.createMembership(joram.getId(), userGroup.getId());
            identityService.createMembership(joram.getId(), adminGroup.getId());

            User josh = user("jlong", "Josh", "Long");
            identityService.createMembership(josh.getId(), userGroup.getId());
        }
    };
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
@Override
protected FunctionExclusionGroups createFunctionExclusionGroups() {
  // TODO: The exclusion groups could be exposed over the network (sending the function identifier) and cached
  final String exclusionGroups = getCommandLine().getOptionValue(EXCLUSION_GROUPS_OPTION);
  if (exclusionGroups != null) {
    try {
      final Class<?> exclusionGroupsClass = ClassUtils.loadClass(exclusionGroups);
      Object groupsObject = exclusionGroupsClass.newInstance();
      if (groupsObject instanceof InitializingBean) {
        ((InitializingBean) groupsObject).afterPropertiesSet();
      }
      if (groupsObject instanceof FactoryBean) {
        groupsObject = ((FactoryBean<?>) groupsObject).getObject();
      }
      if (groupsObject instanceof FunctionExclusionGroups) {
        return (FunctionExclusionGroups) groupsObject;
      }
      throw new IllegalArgumentException("Couldn't set exclusion groups to " + exclusionGroups + " (got " + groupsObject + ")");
    } catch (Exception e) {
      throw new OpenGammaRuntimeException("Error loading exclusion groups", e);
    }
  }
  return null;
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
protected <T> Map<String, T> getCurrencyInfo(final Function<CurrencyInfo, T> filter) {
  final Map<String, T> result = new HashMap<String, T>();
  for (final Map.Entry<String, CurrencyInfo> e : getPerCurrencyInfo().entrySet()) {
    final T entry = filter.apply(e.getValue());
    if (entry instanceof InitializingBean) {
      try {
        ((InitializingBean) entry).afterPropertiesSet();
      } catch (final Exception ex) {
        s_logger.debug("Skipping {}", e.getKey());
        s_logger.trace("Caught exception", e);
        continue;
      }
    }
    if (entry != null) {
      result.put(e.getKey(), entry);
    }
  }
  return result;
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
protected <T> Map<Pair<String, String>, T> getCurrencyPairInfo(final Function<CurrencyPairInfo, T> filter) {
  final Map<Pair<String, String>, T> result = new HashMap<Pair<String, String>, T>();
  for (final Map.Entry<Pair<String, String>, CurrencyPairInfo> e : getPerCurrencyPairInfo().entrySet()) {
    final T entry = filter.apply(e.getValue());
    if (entry instanceof InitializingBean) {
      try {
        ((InitializingBean) entry).afterPropertiesSet();
      } catch (final Exception ex) {
        s_logger.debug("Skipping {}", e.getKey());
        s_logger.trace("Caught exception", e);
        continue;
      }
    }
    if (entry != null) {
      result.put(e.getKey(), entry);
    }
  }
  return result;
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
@Bean
public InitializingBean clientsCorrelationInitializer(final RequestCorrelationProperties properties) {

    return new InitializingBean() {
        @Override
        public void afterPropertiesSet() throws Exception {

            if(clients != null) {
                for(InterceptingHttpAccessor client : clients) {
                    final List<ClientHttpRequestInterceptor> interceptors = new ArrayList<>(client.getInterceptors());
                    interceptors.add(new ClientHttpRequestCorrelationInterceptor(properties));
                    client.setInterceptors(interceptors);
                }
            }
        }
    };
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
private TimestampPair createAdapter(String ip, int port, String user, String password) {
    CobarAdapter adapter = null;
    try {
        DataSource ds = dsFactory.createDataSource(ip, port, user, password);
        adapter = new CobarAdapter();
        adapter.setDataSource(ds);
        ((InitializingBean) adapter).afterPropertiesSet();
        return new TimestampPair(adapter);
    } catch (Exception exception) {
        logger.error("ip=" + ip + ", port=" + port, exception);
        try {
            adapter.destroy();
        } catch (Exception e) {
        }
        throw new RuntimeException(exception);
    }
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
private void autowireAndInitialize(ServletRequest req, Map<String, Object> contexts) {
    ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(req.getServletContext());
    AutowireCapableBeanFactory autowirer = appContext.getAutowireCapableBeanFactory();
    for (Map.Entry<String,Object> entry : contexts.entrySet()) {
        Object context = entry.getValue();
        autowirer.autowireBean(context);
        try {
            if (context instanceof InitializingBean) {
                ((InitializingBean) context).afterPropertiesSet();
            }
        } catch (Exception e) {
            logger.warn("Invocation of init method failed of context: " + entry.getKey(), e);
        }

    }
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
@Bean
InitializingBean populateData(final UserService userService) {
    return () -> {
        userService.deleteAll();
        userService.persist(User.builder().login("malysz").name("adam").salary(new BigDecimal(306)).build());
        log.info(" {}", userService.persist(User.builder().login("borowiec").name("przodownik").salary(new BigDecimal(100)).build()));
        log.info(" {}", userService.persist(User.builder().login("borowiec").name("aga").salary(new BigDecimal(10)).build()));
        log.info(" {}", userService.persist(User.builder().login("borowiec").name("kalina").salary(new BigDecimal(30)).build()));
        log.info(" {}", userService.persist(User.builder().login("tyson").name("iron mike").salary(new BigDecimal(3234)).build()));
        log.info(" {}", userService.persist(User.builder().login("rossi").name("the doctor").salary(new BigDecimal(2000)).build()));

        log.info(" {}", userService.persist(new User("kazimierczak", "juz", new BigDecimal(100))));
        log.info(" {}", userService.persist(new User("aleksandrowicz", "dawid", new BigDecimal(10))));
        log.info(" {}", userService.persist(new User("barszcz", "mariusz", new BigDecimal(30))));
        log.info(" {}", userService.persist(new User("bogadanski", "pawel", new BigDecimal(3000))));
        log.info(" {}", userService.persist(new User("chudzikowska", "sylwia", new BigDecimal(2000))));

        log.info(" {}", userService.persist(new User("swietojanski", "przemyslaw", new BigDecimal(100))));
        log.info(" {}", userService.persist(new User("zurek", "marcin", new BigDecimal(10))));
        log.info(" {}", userService.persist(new User("grabowski", "michal", new BigDecimal(30))));
        log.info(" {}", userService.persist(new User("gilewski", "piotr", new BigDecimal(3000))));
        log.info(" {}", userService.persist(new User("ostroski", "krzych", new BigDecimal(2000))));
    };
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
public void afterPropertiesSet() throws Exception {
	Class<?> executorClass = (shouldUseBackport() ?
			ClassUtils.forName("org.springframework.scheduling.backportconcurrent.ThreadPoolTaskExecutor", getClass().getClassLoader()) :
			ThreadPoolTaskExecutor.class);
	BeanWrapper bw = new BeanWrapperImpl(executorClass);
	determinePoolSizeRange(bw);
	if (this.queueCapacity != null) {
		bw.setPropertyValue("queueCapacity", this.queueCapacity);
	}
	if (this.keepAliveSeconds != null) {
		bw.setPropertyValue("keepAliveSeconds", this.keepAliveSeconds);
	}
	if (this.rejectedExecutionHandler != null) {
		bw.setPropertyValue("rejectedExecutionHandler", this.rejectedExecutionHandler);
	}
	if (this.beanName != null) {
		bw.setPropertyValue("threadNamePrefix", this.beanName + "-");
	}
	this.target = (TaskExecutor) bw.getWrappedInstance();
	if (this.target instanceof InitializingBean) {
		((InitializingBean) this.target).afterPropertiesSet();
	}
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
protected View createView() {
    Assert.state(viewClass != null, "View class to instantiate is not set");
    Object o = BeanUtils.instantiateClass(viewClass);
    Assert.isTrue((o instanceof View), "View class '" + viewClass
            + "' was instantiated, but instance is not a View!");
    View view = (View) o;
    view.setDescriptor(this);
    if (viewProperties != null) {
        BeanWrapper wrapper = new BeanWrapperImpl(view);
        wrapper.setPropertyValues(viewProperties);
    }

    if (view instanceof InitializingBean) {
        try {
            ((InitializingBean) view).afterPropertiesSet();
        } catch (Exception e) {
            throw new BeanInitializationException("Problem running on " + view, e);
        }
    }
    return view;
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
private Editor createEditor(){
	Object o = BeanUtils.instantiateClass(editorClass);
	Assert.isTrue((o instanceof Editor), "Editor class '"+
		editorClass + "' was instantiated but is not an Editor");
	Editor editor = (Editor)o;
	editor.setDescriptor(this);
	ApplicationEventMulticaster multicaster = getApplicationEventMulticaster();
	if(editor instanceof ApplicationListener &&  multicaster != null){
		multicaster.addApplicationListener((ApplicationListener)editor);
	}
	if(editorProperties != null){
		BeanWrapper wrapper = new BeanWrapperImpl(editor);
		wrapper.setPropertyValues(editorProperties);
	}
	if(editor instanceof InitializingBean){
		 try {
			 ((InitializingBean)editor).afterPropertiesSet();
         }
         catch (Exception e) {
             throw new BeanInitializationException("Problem running on " + editor, e);
         }
	}
	return editor;
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
@Bean
public InitializingBean demo(DemoService demoService) {
    return new InitializingBean() {
        @Override
        @Transactional
        public void afterPropertiesSet() throws Exception {
            if (demoProperties.isEnabled()) {
                demoService.createDemoDataFromProperties(demoProperties);
            }
        }
    };
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
@Bean
public InitializingBean issuerInitializer(IssuerRepository issuerRepository) {
    return new InitializingBean() {
        @Override
        @Transactional
        public void afterPropertiesSet() throws Exception {
            initializeIssuerFromPropertiesIfNecessary(issuerRepository, issuer());
        }
    };
}
 

import org.springframework.beans.factory.InitializingBean; //导入依赖的package包/类
public void testProxy() throws Exception {
	// publish service
	bundleContext.registerService(new String[] { DataSource.class.getName(), Comparator.class.getName(),
		InitializingBean.class.getName(), Constants.class.getName() }, new Service(), new Hashtable());

	ConfigurableApplicationContext ctx = getNestedContext();
	assertNotNull(ctx);
	Object proxy = ctx.getBean("service");
	assertNotNull(proxy);
	assertTrue(proxy instanceof DataSource);
	assertTrue(proxy instanceof Comparator);
	assertTrue(proxy instanceof Constants);
	assertTrue(proxy instanceof InitializingBean);
	ctx.close();
}