<bean id="dataSource" destroy-method="close" class="org.apache.commons.dbcp.BasicDataSource">

    <property name="url" value="${jdbc.url}"/>

</bean>

@Configuration

@ImportResource("classpath:/com/acme/properties-config.xml")

public class AppConfig {

    @Value("${jdbc.url}")

    private String url;

}

user: ${db.user}

environment.resolvePlaceholders("${db.user}")

package org.mybatis.spring.mapper;

import static org.springframework.util.Assert.notNull;

import java.lang.annotation.Annotation;

import java.util.Map;

import org.apache.ibatis.session.SqlSessionFactory;

import org.mybatis.spring.SqlSessionTemplate;

import org.springframework.beans.PropertyValue;

import org.springframework.beans.PropertyValues;

import org.springframework.beans.factory.BeanNameAware;

import org.springframework.beans.factory.InitializingBean;

import org.springframework.beans.factory.config.BeanDefinition;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

import org.springframework.beans.factory.config.PropertyResourceConfigurer;

import org.springframework.beans.factory.config.TypedStringValue;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;

import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;

import org.springframework.beans.factory.support.BeanNameGenerator;

import org.springframework.beans.factory.support.DefaultListableBeanFactory;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.util.StringUtils;

/**

 * BeanDefinitionRegistryPostProcessor that searches recursively starting from a base package for

 * interfaces and registers them as {@code MapperFactoryBean}. Note that only interfaces with at

 * least one method will be registered; concrete classes will be ignored.

 * <p>

 * This class was a {code BeanFactoryPostProcessor} until 1.0.1 version. It changed to

 * {@code BeanDefinitionRegistryPostProcessor} in 1.0.2. See https://jira.springsource.org/browse/SPR-8269

 * for the details.

 * <p>

 * The {@code basePackage} property can contain more than one package name, separated by either

 * commas or semicolons.

 * <p>

 * This class supports filtering the mappers created by either specifying a marker interface or an

 * annotation. The {@code annotationClass} property specifies an annotation to search for. The

 * {@code markerInterface} property specifies a parent interface to search for. If both properties

 * are specified, mappers are added for interfaces that match <em>either</em> criteria. By default,

 * these two properties are null, so all interfaces in the given {@code basePackage} are added as

 * mappers.

 * <p>

 * This configurer enables autowire for all the beans that it creates so that they are

 * automatically autowired with the proper {@code SqlSessionFactory} or {@code SqlSessionTemplate}.

 * If there is more than one {@code SqlSessionFactory} in the application, however, autowiring

 * cannot be used. In this case you must explicitly specify either an {@code SqlSessionFactory} or

 * an {@code SqlSessionTemplate} to use via the <em>bean name</em> properties. Bean names are used

 * rather than actual objects because Spring does not initialize property placeholders until after

 * this class is processed.

 * <p>

 * Passing in an actual object which may require placeholders (i.e. DB user password) will fail.

 * Using bean names defers actual object creation until later in the startup

 * process, after all placeholder substituation is completed. However, note that this configurer

 * does support property placeholders of its <em>own</em> properties. The <code>basePackage</code>

 * and bean name properties all support <code>${property}</code> style substitution.

 * <p>

 * Configuration sample:

 * <p>

 *

 * <pre class="code">

 * {@code

 *   <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

 *       <property name="basePackage" value="org.mybatis.spring.sample.mapper" />

 *       <!-- optional unless there are multiple session factories defined -->

 *       <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />

 *   </bean>

 * }

 * </pre>

 *

 * @author Hunter Presnall

 * @author Eduardo Macarron

 *

 * @see MapperFactoryBean

 * @see ClassPathMapperScanner

 */

public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {

  private String basePackage;

  private boolean addToConfig = true;

  private SqlSessionFactory sqlSessionFactory;

  private SqlSessionTemplate sqlSessionTemplate;

  private String sqlSessionFactoryBeanName;

  private String sqlSessionTemplateBeanName;

  private Class<? extends Annotation> annotationClass;

  private Class<?> markerInterface;

  private ApplicationContext applicationContext;

  private String beanName;

  private boolean processPropertyPlaceHolders;

  private BeanNameGenerator nameGenerator;

@Target({ ElementType.TYPE, ElementType.METHOD })

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Conditional(OnBeanCondition.class)

public @interface ConditionalOnBean {

    /**

     * The annotation type decorating a bean that should be checked. The condition matches

     * when any of the annotations specified is defined on a bean in the

     * {@link ApplicationContext}.

     * @return the class-level annotation types to check

     */

    Class<? extends Annotation>[] annotation() default {};

@Target({ ElementType.TYPE })

@Retention(RetentionPolicy.RUNTIME)

public @interface MyAnnotation {

}

@Configuration

public class MyAutoConfiguration {

    @Bean

    // if comment this line, it will be fine.

    @ConditionalOnBean(annotation = { MyAnnotation.class })

    public String abc() {

        return "abc";

    }

}

<bean id="sysProps" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">

  <property name="targetClass" value="java.lang.System" />

  <property name="targetMethod" value="getProperties" />

</bean>

<bean id="javaVersion" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">

  <property name="targetObject" ref="sysProps" />

  <property name="targetMethod" value="getProperty" />

  <property name="arguments" value="${java.version.key}" />

</bean>

@SpringBootApplication

@ImportResource("classpath:/demo.xml")

public class DemoApplication {

    public static void main(String[] args) {

        ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args);

        System.err.println(context.getBean("javaVersion"));

    }

}

@ConfigurationProperties(prefix = "spring.my")

public class MyProperties {

    String key;

}

public static MyProperties buildMyProperties(ConfigurableEnvironment environment) {

  MyProperties myProperties = new MyProperties();

  if (environment != null) {

    MutablePropertySources propertySources = environment.getPropertySources();

    new RelaxedDataBinder(myProperties, "spring.my").bind(new PropertySourcesPropertyValues(propertySources));

  }

  return myProperties;

}