本文共 18457 字，大约阅读时间需要 61 分钟。

一、

1.1、

1.2、 1.3、 1.4.0 1.4.1 1.5、 1.6.0 1.6.1 1.6.2 1.6.3 1.6.4 1.6.5

2.1

2.2 2.3. 2.4

三.

3.0

3.1

四.

4.1

4.2 4.3 4.4 4.5 4.6

一 @Configuation加载Spring方法

1.0 @Configuration注解

@ Configuration用于定义配置类，

可替换xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法， 这些方法将会被AnnotationConfigApplicationContext 或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器

AnnotationConfigApplicationContext applicationContext =     new AnnotationConfigApplicationContext(MainConfig2.class);

注意：@Configuration注解的配置类有如下要求：

@Configuration不可以是final类型；@Configuration不可以是匿名类；嵌套的configuration必须是静态类。

1.1、@Configuration配置spring并启动spring容器

@Configuration标注在类上，相当于把该类作为spring的xml配置文件中的，作用为：配置spring容器(应用上下文)

不用@Configuration注解的spring容器加载方式，用xml配置文件加载：

ApplicationContext  Context=new ClassPathXmlApplicationContext("beans.xml");

@Configuration注解的spring容器加载方式:

AnnotationConfigApplicationContext applicationContext =     new AnnotationConfigApplicationContext(MainConfig2.class);

// @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext />

1.2@Bean注解

@Bean标注在方法上(返回某个实例的方法)，等价于spring的xml配置文件中的，作用为：注册bean对象

使用配置文件

< bean id="person" class="com.atguigu.bean.Person"  scope="prototype" >    		< property name="age" value="${}">    		< property name="name" value="zhangsan">    	< /bean>

使用@Bean注解

//配置类==配置文件    @Configuration  //告诉Spring这是一个配置类    public class MainConfig {
       	    	//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id    	@Bean("person")    	public Person person01(){
       		return new Person("lisi", 20);    	}        }

注：

(1)、@Bean注解在返回实例的方法上，如果未通过@Bean指定bean的名称，则默认与标注的方法名相同；

(2)、@Bean注解默认作用域为单例singleton作用域，可通过@Scope(“prototype”)设置为原型作用域；

(3)、既然@Bean的作用是注册bean对象，那么完全可以使用@Component、@Controller、@Service、@Ripository等注解注册bean，当然需要配置@ComponentScan注解进行自动扫描。

1.3 @ComponentScan注解

1、@Service用于标注业务层组件

2、@Controller用于标注控制层组件(如struts中的action) 3、@Repository用于标注数据访问组件，即DAO组件. 4、@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。 在xml文件中配置

使用注解@Configuration启动容器+@Component注册Bean

//配置类==配置文件    @Configuration  //告诉Spring这是一个配置类        @ComponentScans(    		value = {
       				@ComponentScan(value="com.atguigu",includeFilters = {
       /*						@Filter(type=FilterType.ANNOTATION,classes={Controller.class}),    						@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/    						@Filter(type=FilterType.CUSTOM,classes={
   MyTypeFilter.class})    				},useDefaultFilters = false)	    		}    		)    //@ComponentScan  value:指定要扫描的包    //excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件    //includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件    //FilterType.ANNOTATION：按照注解    //FilterType.ASSIGNABLE_TYPE：按照给定的类型；    //FilterType.ASPECTJ：使用ASPECTJ表达式    //FilterType.REGEX：使用正则指定    //FilterType.CUSTOM：使用自定义规则    public class MainConfig {
       	    	//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id    	@Bean("person")    	public Person person01(){
       		return new Person("lisi", 20);    	}        }

使用@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})自定义规则

public class MyTypeFilter implements TypeFilter {
   	/**	 * metadataReader：读取到的当前正在扫描的类的信息	 * metadataReaderFactory:可以获取到其他任何类信息的	 */	@Override	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)			throws IOException {
   		// TODO Auto-generated method stub		//获取当前类注解的信息		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();		//获取当前正在扫描的类的类信息		ClassMetadata classMetadata = metadataReader.getClassMetadata();		//获取当前类资源（类的路径）		Resource resource = metadataReader.getResource();				String className = classMetadata.getClassName();		System.out.println("--->"+className);		if(className.contains("er")){
   			return true;		}		return false;	}}

1.4.0@Scope

//默认是单实例的

ConfigurableBeanFactory#SCOPE_PROTOTYPE * @see

ConfigurableBeanFactory#SCOPE_SINGLETON * @see

org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST

request * @see

org.springframework.web.context.WebApplicationContext#SCOPE_SESSION

sesssion * @return\ * @Scope:调整作用域 *

prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。 * 每次获取的时候才会调用方法创建对象； 每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的 getBean()方法）都会产生一个新的bean实例，相当与一个new的操作，

singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。 * 以后每次获取就是直接从容器（map.get()）中拿， 当把 一个bean定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都 将返回被缓存的对象实例 request：同一次请求创建一个实例 * session：同一个session创建一个实例

1.4.1@Lazy懒加载：

@Lazy注解用于标识bean是否需要延迟加载

* 		单实例bean：默认在容器启动的时候创建对象； * 		懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化； *

没加注解之前主要容器启动就会实例化bean，而加上@Lazy注解则必须在第一次调用的时候才会加载

1.5@Conditional注解

SpringBoot底层大量使用，它的作用是按照一定的条件进行判断，满足条件给容器注册bean，注解可以标注在类和方法上

/**	 * @Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean	 * 	 * 如果系统是windows，给容器中注册("bill")	 * 如果是linux系统，给容器中注册("linus")	 */	@Conditional(LinuxCondition.class)	@Bean("bill")	public Person person01(){
   		return new Person("Bill Gates",62);	}		@Conditional(LinuxCondition.class)	@Bean("linus")	public Person person02(){
   		return new Person("linus", 48);	}

需要实现Condition接口，并重写方法来自定义match规则，conditionContext提供了多种方法，方便获取各种信息，也是SpringBoot中 @ConditonalOnXX注解多样扩展的基础。

1.6.0给容器中注册组件；

* 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前面加一个& * 			&colorFactoryBean */

1.6.1@Import导入组件

@Import注解是:通过导入的方式实现把实例加入springIOC容器中

1）@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类

1.6.2使用ImportSelector接口

ImportSelector:返回需要导入的组件的全类名数组

假如现在要给容器注册Red对象，则进行如下操作： 修改配置类

1.6.3 ImportBeanDefinitionRegistrar手动注册bean到容器中

1.6.4使用Spring提供的 FactoryBean（工厂Bean）

Spring中有两种类型的Bean，一种是普通Bean，另一种是工厂Bean，即FactoryBean。工厂Bean跟普通Bean不同，其返回的对象不是指定类的一个实例，其返回的是该工厂Bean的getObject方法所返回的对象。

1、实现工厂bean接口

2、配置类配置工厂bean

3、测试

获取bean时，调用的工厂类中的getObject方法。

注：如何拿到工厂bean的本身？

测试类，工厂类id前添加&符号，&在工厂类接口中是定义好的，是一个常亮。

1.6.5@ImportResource和Import引入配置文件

1.在@configuration中引入spring的xml配置文件

2.在@configuration中引入其他配置文件

二.生命周期

2.1@Bean指定初始化和销毁方法

使用XML方式配置Bean的时候，通过 元素的 init-method/destroy-method属性可以指定初始化之后 、销毁之前调用的操作方法。`

​ 不过在使用@Bean注解声明bean的时候，也可以做出上述XML配置相同的功能，基本实例如下：

声明一个Java配置类，在配置类中使用@Bean注解声明一个组件

@Configurationpublic class LifecycleConfig {
       @Bean(initMethod = "init",destroyMethod = "destory")    public Car car(){
           return new Car("audi");    }

只有单例的bean，在容器创建时才会实例化，并执行初始化方法，在容器关闭时执行销毁方法。对于多实例bean，只有在创建bean的时候才会实例化并初始化方法，如果要执行多实例bean的销毁方法，需要我们自己手动去调用。(只需将bean的@Scope设置为prototype,可以看出容器关闭的时候并没有调用销毁方法)。

2.2 InitializingBean 与 DisposableBean

可以让bean实现InitializingBean 接口 定义自身初始化逻辑，实现DisposableBean接口定义销毁逻辑。

public class Car implements InitializingBean,DisposableBean{
       private String name;            public Car(String name) {
               this.name = name;            System.out.println("Car...Constructor ");        }                public void destroy() throws Exception {
               System.out.println("car ...DisposableBean... destory");        }            public void afterPropertiesSet() throws Exception {
               System.out.println("car...InitializingBean...afterPropertiesSet");        }

2.3. @PostConstruct 与 @PreDestroy注解

SpringBean 的初始化流程

flowchat

st=>start: 开始 op1=>operation: Spring容器加载1 op2=>operation: 调用构造函数 op3=>operation: @PostConstruct方法调用 op4=>operation: init()调用 op5=>operation: 其他代码 op6=>operation: destroy()调用 op7=>operation: @PreDestroy方法调用 e=>end: 结束

默认情况下，Spring不会意识到@PostConstruct和@PreDestroy注解。要启用它，要么注册“CommonAnnotationBeanPostProcessor”，要么在bean配置文件的<context:annotation-config

/>‘ 指定

可以看出，@PostConstruct 与 @PreDestroy 这两个注解与上述两种方法功能基本相似，只是在他们同时起作用的时候，执行顺序还是有些规律的。 初始化之后执行： @PostConstruct > InitializingBean > init-method

销毁之前执行：@preDestroy > DisposableBean > destoryMethod

2.4 BeanPostProcessor后置处理器

初始化前调用这个方法：

* BeanPostProcessor.postProcessBeforeInitialization 初始化方法有：

• 1） 通过@Bean指定init-method和destroy-method；
• 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
  DisposableBean（定义销毁逻辑）;
• 3）、可以使用JSR250；
  @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
  @PreDestroy：在容器销毁bean之前通知我们进行清理工作
  对象创建完成，并赋值好，调用初始化方法。。。
  在初始化之后工作BeanPostProcessor.postProcessAfterInitialization
• 销毁：

• 单实例：容器关闭的时候

• 多实例：容器不会管理这个bean；容器不会调用销毁方法

• 

3.0 @Value注解

• @Value("#{configProperties[‘t1.msgname’]}")
  或者
• @Value("${t1.msgname}")；
  Spring 通过注解获取*.porperties文件的内容，除了xml配置外，还可以通过@value方式来获取。
  使用方式必须在当前类使用@Component，xml文件内配置的是通过pakage扫描方式,
  例如：<context:component-scan base-package=“pakage_name” />加粗样式
  

属性赋值

3.1 @Propertysource注解

通过@PropertySource注解将properties配置文件中的值存储到Spring的 Environment中，Environment接口提供方法去读取配置文件中的值，参数是properties文件中定义的key值。

用法1- @PropertySource和@Value

@Configuration@PropertySource("classpath:jdbc.properties")public class PropertiesWithJavaConfig {
      @Value(${
   jdbc.driver})   private String driver;   @Value(${
   jdbc.url})   private String url;   @Value(${
   jdbc.username})   private String username;   @Value(${
   jdbc.password})   private String password;   //要想使用@Value 用${}占位符注入属性，这个bean是必须的，这个就是占位bean,另一种方式是不用value直接用Envirment变量直接getProperty('key')     @Bean   public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
         return new PropertySourcesPlaceholderConfigurer();   }}

用法2- 等同于在xml中配置properties文件

?xml version="1.0" encoding="UTF-8"?>
         
    
   

用法3- 通过Environment设置

示例1：@PropertySource + Environment

package com.dxz.config;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.PropertySource;import org.springframework.core.env.Environment;@Configuration@ComponentScan(basePackages = "com.dxz.config")@PropertySource(value = "classpath:spring/config.properties")public class ServiceConfiguration {
        @Autowired     Environment environment;     public ServiceConfiguration() {
           System.out.println("ServiceConfiguration zheli");    }        //@Bean    public javax.sql.DataSource dataSource(){
            String user = this.environment.getProperty("ds.user");        System.out.println(user);        return null;    } }

@Configuration@PropertySource("classpath:jdbc.properties")public class PropertiesWithJavaConfig {
      @Autowired    private Environment env;}

在Spring 4中，Spring提供了一个新的注解——@PropertySources,从名字就可以猜测到它是为多配置文件而准备的。

@PropertySources({
           @PropertySource("classpath:config.properties"),        @PropertySource("classpath:db.properties")        })        public class AppConfig {
               //something        }

四.自动装配

4.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的名字     * 		BookService{
        * 			@Autowired     * 			BookDao  bookDao;     * 		}

@Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false。如果我们想使用按照名称（byName）来装配，可以结合@Qualifier注解一起使用。如下：

4.2@Qualifier注解

@Qualifier限定描述符除了能根据名字进行注入，更能进行更细粒度的控制如何选择候选者，具体使用方式如下： 解释得不够通俗易懂哈。

这个作用是：当一个接口有多个实现的时候，为了指名具体调用哪个类的实现。

@Autowired是根据类型进行自动装配的。如果当Spring上下文中存在不止一个UserDao类型的bean时，就会抛出BeanCreationException异常;如果Spring上下文中不存在UserDao类型的bean，也会抛出BeanCreationException异常。我们可以使用@Qualifier配合@Autowired来解决这些问题。如下：

①可能存在多个UserDao实例

@Autowired       @Qualifier("userServiceImpl")       public IUserService userService;

或者

@Autowired   public void setUserDao(@Qualifier("userDao") UserDao userDao) {
          this.userDao = userDao;   }

这样Spring会找到id为userServiceImpl和userDao的bean进行装配。

②可能不存在UserDao实例

@Autowired(required = false)   public IUserService userService

个人总结：

@Autowired//默认按type注入

@Qualifier(“cusInfoService”)//一般作为@Autowired()的修饰用

4.3@Resource注解

@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的，分是name和type，Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。

4.4@Resource注解与@Autowired区别：

使用区别

@Resource(name="loginService")     private LoginService loginService;     @Autowired(required=false)@Qualifier("loginService")     private LoginService loginService;

(1).@Autowired 与@Resource都可以用来装配bean. 都可以写在字段上,或写在setter方法上;

(2).@Autowired 默认按类型装配，默认情况下必须要求依赖对象必须存在，如果要允许null值，可以设 置它的required属性为false，如：@Autowired(required=false) .

如果我们想使用名称装配可以结合 @Qualifier注解进行使用;

(3).@Resource（这个注解属于J2EE的），默认安装名称进行装配，名称可以通过name属性进行指定，如果没

有指定name属性，当注解写在字段上时，默认取字段名进行安装名称查找，如果注解写在setter方法上默认取属 性名进行装配。当找不到与名称匹配的bean时才按照类型进行装 配。但是需要注意的是，如果name属性一旦指 定，就只会按照名称进行装配。

推荐使用@Resource注解在字段上，这样就不用写setter方法了.并且这个注解是属于J2EE的，减少了与Spring

的耦合,这样代码看起就比较优雅 。

另外，通过实践，还总结出一条规律：

如果将@requied或者@autowired写了set方法之上，则程序会走到set方法内部。

但如果写在了field之上，则不会进入set方法当中。

4.5 spring之Aware接口的相关实现

详细链接：https://blog.csdn.net/boling_cavalry/article/details/81611426

Spring Aware 作用：你的bean将会和spring框架耦合 目的：是为了让bean获取spring容器的服务： 了解spring容器的IOC（依赖注入）的同学应该知道，我们的所有的bean对于spring容器是无意识的，啥叫无意识呢，就是你完全可以把spring容器替换成其他的容器而不需要改变你的代码，并且bean之间也是没有耦合的，既然这样，那问题就来，假如现在我们需要对spring有意识，换句话说就是现在我们的业务可能需要用到spring底层的一些功能那么我们该怎么实现？这个其实优秀的spring框架早就帮我们想到了，那就是spring提供了一系列的xxxAware接口供我们自己来实现使用

public class MyAware implements BeanNameAware,ResourceLoaderAware,ApplicationContextAware,BeanFactoryAware{
       private String beanName;    private ResourceLoader loader;    private ApplicationContext applicationContext;    private BeanFactory beanFactory;    // BeanFactoryAware中的方法    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
           this.beanFactory = beanFactory;    }    // ApplicationContextAware中的方法    public void setApplicationContext(ApplicationContext applicationContext)            throws BeansException {
           this.applicationContext = applicationContext;    }    // ResourceLoaderAware中的方法    public void setResourceLoader(ResourceLoader resourceLoader) {
           this.loader = resourceLoader;    }    public void printResult() throws IOException {
           System.out.println("BeanNameAware Bean的名称是:" + beanName);        Resource resource = loader.getResource("classpath:test.txt");        System.out.println("----------------------------------------" );        System.out.print("ResourceLoaderAware ResourceLoader加载的内容是:");        String line = null;        BufferedReader reader = new BufferedReader(new InputStreamReader(                resource.getInputStream()));        while ((line = reader.readLine()) != null) {
               System.out.println(line);        }        reader.close();        Environment environment = applicationContext.getEnvironment();        System.out.println("----------------------------------------" );        System.out.println("ApplicationContextAware 系统是:" + environment.getProperty("os.name"));        boolean flow = beanFactory.isSingleton(beanName);        System.out.println("----------------------------------------" );        System.out.println("BeanFactoryAware bean【" + beanName+" 】是单例嘛:"+flow);    }    // BeanNameAware中的方法    public void setBeanName(String name) {
           this.beanName = name;    }}

4.6@@Profile注解

@profile注解是spring提供的一个用来标明当前运行环境的注解。我们正常开发的过程中经常遇到的问题是，开发环境是一套环境，qa测试是一套环境，线上部署又是一套环境。这样从开发到测试再到部署，会对程序中的配置修改多次，尤其是从qa到上线这个环节，让qa的也不敢保证改了哪个配置之后能不能在线上运行。

为了解决上面的问题，我们一般会使用一种方法，就是配置文件，然后通过不同的环境读取不同的配置文件，从而在不同的场景中跑我们的程序。 那么，spring中的@profile注解的作用就体现在这里。 @Profile注解用于实现通过修改运行时参数，切换不同的开发环境

@Profile注解可以加在类上，也可以加载注入bean的方法上

使用方法：

/** * Profile： * 		Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能； *  * 开发环境、测试环境、生产环境； * 数据源：(/A)(/B)(/C)； *  *  * @Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件 *  * 1）、加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境 * 2）、写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效 * 3）、没有标注环境标识的bean在，任何环境下都是加载的； */@PropertySource("classpath:/dbconfig.properties")@Configurationpublic class MainConfigOfProfile implements EmbeddedValueResolverAware{
   		@Value("${db.user}")	private String user;		private StringValueResolver valueResolver;		private String  driverClass;			@Bean	public Yellow yellow(){
   		return new Yellow();	}		@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/test");		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/ssm_crud");		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/scw_0515");				dataSource.setDriverClass(driverClass);		return dataSource;	}	@Override	public void setEmbeddedValueResolver(StringValueResolver resolver) {
   		// TODO Auto-generated method stub		this.valueResolver = resolver;		driverClass = valueResolver.resolveStringValue("${db.driverClass}");	}

public class IOCTest_Profile {
   		 //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);		}				Yellow bean = applicationContext.getBean(Yellow.class);		System.out.println(bean);		applicationContext.close();	}

记:spring的内容还是要多参照文档学习