configuration_configurationproperties - CSDN
精华内容
参与话题
  • @Configuration的使用 和作用

    千次阅读 2019-07-20 22:01:08
    https://blog.csdn.net/u014199143/article/details/80692685 ...

    https://blog.csdn.net/u014199143/article/details/80692685

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

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

    1. @Configuration不可以是final类型;
    2. @Configuration不可以是匿名类;
    3. 嵌套的configuration必须是静态类。

    一、用@Configuration加载spring
    1.1、@Configuration配置spring并启动spring容器
    1.2、@Configuration启动容器+@Bean注册Bean
    1.3、@Configuration启动容器+@Component注册Bean
    1.4、使用 AnnotationConfigApplicationContext 注册 AppContext 类的两种方法
    1.5、配置Web应用程序(web.xml中配置AnnotationConfigApplicationContext)

    二、组合多个配置类
    2.1、在@configuration中引入spring的xml配置文件
    2.2、在@configuration中引入其它注解配置
    2.3、@configuration嵌套(嵌套的Configuration必须是静态类)
    三、@EnableXXX注解
    四、@Profile逻辑组配置
    五、使用外部变量

    一、@Configuation加载Spring方法

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

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

    复制代码
    package com.dxz.demo.configuration;
    

    import org.springframework.context.annotation.Configuration;

    @Configuration
    public class TestConfiguration {
    public TestConfiguration() {
    System.out.println(
    “TestConfiguration容器启动初始化。。。”);
    }
    }

    复制代码

    相当于:

    复制代码
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
        xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
            http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
            http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd" default-lazy-init="false">
    

    </beans>

    复制代码

    主方法进行测试:

    复制代码
    package com.dxz.demo.configuration;
    

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;

    public class TestMain {
    public static void main(String[] args) {

        </span><span>//</span><span> @Configuration注解的spring容器加载方式,用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext</span>
        ApplicationContext context = <span>new</span> AnnotationConfigApplicationContext(TestConfiguration.<span>class</span><span>);
    
        </span><span>//</span><span> 如果加载spring-context.xml文件:
        </span><span>//</span><span> ApplicationContext context = new
        </span><span>//</span><span> ClassPathXmlApplicationContext("spring-context.xml");</span>
    

    }
    }

    复制代码

    从运行主方法结果可以看出,spring容器已经启动了:

    1.2、@Configuration启动容器+@Bean注册Bean,@Bean下管理bean的生命周期

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

    bean类:

    复制代码
    package com.dxz.demo.configuration;
    

    public class TestBean {

    </span><span>private</span><span> String username;
    </span><span>private</span><span> String url;
    </span><span>private</span><span> String password;
    
    </span><span>public</span> <span>void</span><span> sayHello() {
        System.out.println(</span>"TestBean sayHello..."<span>);
    }
    
    </span><span>public</span><span> String toString() {
        </span><span>return</span> "username:" + <span>this</span>.username + ",url:" + <span>this</span>.url + ",password:" + <span>this</span><span>.password;
    }
    
    </span><span>public</span> <span>void</span><span> start() {
        System.out.println(</span>"TestBean 初始化。。。"<span>);
    }
    
    </span><span>public</span> <span>void</span><span> cleanUp() {
        System.out.println(</span>"TestBean 销毁。。。"<span>);
    }
    

    }

    复制代码

    配置类:

    复制代码
    package com.dxz.demo.configuration;
    

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

    @Configuration
    public class TestConfiguration {
    public TestConfiguration() {
    System.out.println(
    “TestConfiguration容器启动初始化。。。”);
    }

    </span><span>//</span><span> @Bean注解注册bean,同时可以指定初始化和销毁方法
    </span><span>//</span><span> @Bean(name="testBean",initMethod="start",destroyMethod="cleanUp")</span>
    

    @Bean
    @Scope(
    “prototype”)
    public TestBean testBean() {
    return new TestBean();
    }
    }

    复制代码

    主方法测试类:

    复制代码
    package com.dxz.demo.configuration;
    

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;

    public class TestMain {
    public static void main(String[] args) {

        </span><span>//</span><span> @Configuration注解的spring容器加载方式,用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext</span>
        ApplicationContext context = <span>new</span> AnnotationConfigApplicationContext(TestConfiguration.<span>class</span><span>);
    
        </span><span>//</span><span> 如果加载spring-context.xml文件:
        </span><span>//</span><span> ApplicationContext context = new
        </span><span>//</span><span> ClassPathXmlApplicationContext("spring-context.xml");
    
         </span><span>//</span><span>获取bean</span>
        TestBean tb = (TestBean) context.getBean("testBean"<span>);
        tb.sayHello();
    }
    

    }

    复制代码

    结果:

    注: 
    (1)、@Bean注解在返回实例的方法上,如果未通过@Bean指定bean的名称,则默认与标注的方法名相同; 
    (2)、@Bean注解默认作用域为单例singleton作用域,可通过@Scope(“prototype”)设置为原型作用域; 
    (3)、既然@Bean的作用是注册bean对象,那么完全可以使用@Component、@Controller、@Service、@Ripository等注解注册bean,当然需要配置@ComponentScan注解进行自动扫描。

     

    @Bean下管理bean的生命周期

    可以使用基于 Java 的配置来管理 bean 的生命周期。@Bean 支持两种属性,即 initMethod 和destroyMethod,这些属性可用于定义生命周期方法。在实例化 bean 或即将销毁它时,容器便可调用生命周期方法。生命周期方法也称为回调方法,因为它将由容器调用。使用 @Bean 注释注册的 bean 也支持 JSR-250 规定的标准 @PostConstruct 和 @PreDestroy 注释。如果您正在使用 XML 方法来定义 bean,那么就应该使用 bean 元素来定义生命周期回调方法。以下代码显示了在 XML 配置中通常使用 bean 元素定义回调的方法。

    复制代码
    @Configuration
    @ComponentScan(basePackages = "com.dxz.demo.configuration")
    public class TestConfiguration {
        public TestConfiguration() {
            System.out.println("TestConfiguration容器启动初始化。。。");
        }
    
    </span><span>//</span><span>@Bean注解注册bean,同时可以指定初始化和销毁方法</span>
    <span>@Bean(name="testBean",initMethod="start",destroyMethod="cleanUp")
    @Scope("prototype")
    </span><span>public</span><span> TestBean testBean() {
        </span><span>return</span> <span>new</span><span> TestBean();
    }
    

    }

    复制代码

    启动类:

    复制代码
    public class TestMain {
        public static void main(String[] args) {
    
        ApplicationContext context </span>= <span>new</span> AnnotationConfigApplicationContext(TestConfiguration.<span>class</span><span>);
    
        TestBean tb </span>= (TestBean) context.getBean("testBean"<span>);
        tb.sayHello();
        System.out.println(tb);
    
        TestBean tb2 </span>= (TestBean) context.getBean("testBean"<span>);
        tb2.sayHello();
        System.out.println(tb2);
    }
    

    }

    复制代码

    结果:

    分析:

    结果中的1:表明initMethod生效

    结果中的2:表明@Scope(“prototype”)生效

     

     

     

    1.3、@Configuration启动容器+@Component注册Bean

    bean类:

    复制代码
    package com.dxz.demo.configuration;
    

    import org.springframework.stereotype.Component;

    //添加注册bean的注解
    @Component
    public class TestBean {

    </span><span>private</span><span> String username;
    </span><span>private</span><span> String url;
    </span><span>private</span><span> String password;
    
    </span><span>public</span> <span>void</span><span> sayHello() {
        System.out.println(</span>"TestBean sayHello..."<span>);
    }
    
    </span><span>public</span><span> String toString() {
        </span><span>return</span> "username:" + <span>this</span>.username + ",url:" + <span>this</span>.url + ",password:" + <span>this</span><span>.password;
    }
    
    </span><span>public</span> <span>void</span><span> start() {
        System.out.println(</span>"TestBean 初始化。。。"<span>);
    }
    
    </span><span>public</span> <span>void</span><span> cleanUp() {
        System.out.println(</span>"TestBean 销毁。。。"<span>);
    }
    

    }

    复制代码

    配置类:

    复制代码
    package com.dxz.demo.configuration;
    

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

    @Configuration
    //添加自动扫描注解,basePackages为TestBean包路径
    @ComponentScan(basePackages = “com.dxz.demo.configuration”)
    public class TestConfiguration {
    public TestConfiguration() {
    System.out.println(
    “TestConfiguration容器启动初始化。。。”);
    }

    </span><span>/*</span><span>// @Bean注解注册bean,同时可以指定初始化和销毁方法
    // @Bean(name="testNean",initMethod="start",destroyMethod="cleanUp")
    @Bean
    @Scope("prototype")
    public TestBean testBean() {
        return new TestBean();
    }</span><span>*/</span><span>
    

    }

    复制代码

    主方法测试获取bean对象:

    复制代码
    package com.dxz.demo.configuration;
    

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;

    public class TestMain {
    public static void main(String[] args) {

        </span><span>//</span><span> @Configuration注解的spring容器加载方式,用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext</span>
        ApplicationContext context = <span>new</span> AnnotationConfigApplicationContext(TestConfiguration.<span>class</span><span>);
    
        </span><span>//</span><span> 如果加载spring-context.xml文件:
        </span><span>//</span><span> ApplicationContext context = new
        </span><span>//</span><span> ClassPathXmlApplicationContext("spring-context.xml");
    
         </span><span>//</span><span>获取bean</span>
        TestBean tb = (TestBean) context.getBean("testBean"<span>);
        tb.sayHello();
    }
    

    }

    复制代码

    sayHello()方法都被正常调用。

    1.4、使用 AnnotationConfigApplicationContext 注册 AppContext 类的两种方法

    1.4.1、 配置类的注册方式是将其传递给 AnnotationConfigApplicationContext 构造函数

    复制代码
    public static void main(String[] args) {
    
        </span><span>//</span><span> @Configuration注解的spring容器加载方式,用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext</span>
        <span>ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
    

    //获取bean
    TestBean tb = (TestBean) context.getBean(“testBean”);
    tb.sayHello();
    }

    复制代码

    1.4.2、 AnnotationConfigApplicationContext 的register 方法传入配置类来注册配置类

    public static void main(String[] args) {
      ApplicationContext ctx = new AnnotationConfigApplicationContext();
      ctx.register(AppContext.class)
    }

    1.5、配置Web应用程序(web.xml中配置AnnotationConfigApplicationContext)

    过去,您通常要利用 XmlWebApplicationContext 上下文来配置 Spring Web 应用程序,即在 Web 部署描述符文件 web.xml 中指定外部 XML 上下文文件的路径。XMLWebApplicationContext 是 Web 应用程序使用的默认上下文类。以下代码描述了 web.xml 中指向将由 ContextLoaderListener 监听器类载入的外部 XML 上下文文件的元素。

    复制代码
    <web-app>
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/applicationContext.xml</param-value>
        </context-param>
        <listener>
            <listener-class>
                org.springframework.web.context.ContextLoaderListener
            </listener-class>
        </listener>
        <servlet>
        <servlet-name>sampleServlet</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        </servlet>
    


    </web-app>

    复制代码

    现在,您要将 web.xml 中的上述代码更改为使用 AnnotationConfigApplicationContext 类。切记,XmlWebApplicationContext 是 Spring 为 Web 应用程序使用的默认上下文实现,因此您永远不必在您的web.xml 文件中显式指定这个上下文类。现在,您将使用基于 Java 的配置,因此在配置 Web 应用程序时,需要在web.xml 文件中指定 AnnotationConfigApplicationContext 类。上述代码将修改如下:

    复制代码
    <web-app>
        <context-param>
            <param-name>contextClass</param-name>
            <param-value>
                org.springframework.web.context.
                support.AnnotationConfigWebApplicationContext
            </param-value>
        </context-param>
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                demo.AppContext
            </param-value>
        </context-param>
        <listener>
            <listener-class>
                org.springframework.web.context.ContextLoaderListener
            </listener-class>
        </listener>
        <servlet>
        <servlet-name>sampleServlet</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>
                org.springframework.web.context.
                support.AnnotationConfigWebApplicationContext
            </param-value>
        </init-param>
        </servlet>
    


    </web-app>

    复制代码

    以上修改后的 web.xml 现在定义了 AnnotationConfigWebApplicationContext 上下文类,并将其作为上下文参数和 servlet 元素的一部分。上下文配置位置现在指向 AppContext 配置类。这非常简单。下一节将演示 bean 的生命周期回调和范围的实现。

    1.6、@Configuation总结

     @Configuation等价于<Beans></Beans>

     @Bean等价于<Bean></Bean>

     @ComponentScan等价于<context:component-scan base-package=”com.dxz.demo”/>

     

    二、组合多个配置类

    2.1、在@configuration中引入spring的xml配置文件

    复制代码
    package com.dxz.demo.configuration2;
    

    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.ImportResource;

    @Configuration
    @ImportResource(“classpath:applicationContext-configuration.xml”)
    public class WebConfig {
    }

    复制代码

    bean类:

    复制代码
    package com.dxz.demo.configuration2;
    

    public class TestBean2 {
    private String username;
    private String url;
    private String password;

    </span><span>public</span> <span>void</span><span> sayHello() {
        System.out.println(</span>"TestBean2 sayHello..."<span>);
    }
    
    </span><span>public</span><span> String toString() {
        </span><span>return</span> "TestBean2 username:" + <span>this</span>.username + ",url:" + <span>this</span>.url + ",password:" + <span>this</span><span>.password;
    }
    
    </span><span>public</span> <span>void</span><span> start() {
        System.out.println(</span>"TestBean2 初始化。。。"<span>);
    }
    
    </span><span>public</span> <span>void</span><span> cleanUp() {
        System.out.println(</span>"TestBean2 销毁。。。"<span>);
    }
    

    }

    复制代码

    测试类:

    复制代码
    package com.dxz.demo.configuration2;
    

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;

    public class TestMain2 {
    public static void main(String[] args) {

        </span><span>//</span><span> @Configuration注解的spring容器加载方式,用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext</span>
        ApplicationContext context = <span>new</span> AnnotationConfigApplicationContext(WebConfig.<span>class</span><span>);
    
        </span><span>//</span><span> 如果加载spring-context.xml文件:
        </span><span>//</span><span> ApplicationContext context = new
        </span><span>//</span><span> ClassPathXmlApplicationContext("spring-context.xml");
    
        </span><span>//</span><span> 获取bean</span>
        TestBean2 tb = (TestBean2) context.getBean("testBean2"<span>);
        tb.sayHello();
    }
    

    }

    复制代码

    结果:

     2.2、在@configuration中引入其它注解配置

    复制代码
    package com.dxz.demo.configuration2;
    

    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Import;
    import org.springframework.context.annotation.ImportResource;

    import com.dxz.demo.configuration.TestConfiguration;

    @Configuration
    @ImportResource(“classpath:applicationContext-configuration.xml”)
    @Import(TestConfiguration.
    class)
    public class WebConfig {
    }

    复制代码

    测试类:

    复制代码
    package com.dxz.demo.configuration2;
    

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;

    import com.dxz.demo.configuration.TestBean;

    public class TestMain2 {
    public static void main(String[] args) {

        </span><span>//</span><span> @Configuration注解的spring容器加载方式,用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext</span>
        ApplicationContext context = <span>new</span> AnnotationConfigApplicationContext(WebConfig.<span>class</span><span>);
    
        </span><span>//</span><span> 如果加载spring-context.xml文件:
        </span><span>//</span><span> ApplicationContext context = new
        </span><span>//</span><span> ClassPathXmlApplicationContext("spring-context.xml");
    
        </span><span>//</span><span> 获取bean</span>
        TestBean2 tb2 = (TestBean2) context.getBean("testBean2"<span>);
        tb2.sayHello();
    
        <span>TestBean tb </span></span><span>= (TestBean) context.getBean("testBean"</span><span><span>);
        tb.sayHello();</span>
    }
    

    }

    复制代码

    结果:

    2.3、@configuration嵌套(嵌套的Configuration必须是静态类)

    通过配置类嵌套的配置类,达到组合多个配置类的目的。但注意内部类必须是静态类

    上代码:

    复制代码
    package com.dxz.demo.configuration3;
    

    import org.springframework.stereotype.Component;

    @Component
    public class TestBean {

    </span><span>private</span><span> String username;
    </span><span>private</span><span> String url;
    </span><span>private</span><span> String password;
    
    </span><span>public</span> <span>void</span><span> sayHello() {
        System.out.println(</span>"TestBean sayHello..."<span>);
    }
    
    </span><span>public</span><span> String toString() {
        </span><span>return</span> "username:" + <span>this</span>.username + ",url:" + <span>this</span>.url + ",password:" + <span>this</span><span>.password;
    }
    
    </span><span>public</span> <span>void</span><span> start() {
        System.out.println(</span>"TestBean start"<span>);
    }
    
    </span><span>public</span> <span>void</span><span> cleanUp() {
        System.out.println(</span>"TestBean destory"<span>);
    }
    

    }

    复制代码
    复制代码
    package com.dxz.demo.configuration3;
    

    public class DataSource {

    </span><span>private</span><span> String dbUser;
    </span><span>private</span><span> String dbPass;
    </span><span>public</span><span> String getDbUser() {
        </span><span>return</span><span> dbUser;
    }
    </span><span>public</span> <span>void</span><span> setDbUser(String dbUser) {
        </span><span>this</span>.dbUser =<span> dbUser;
    }
    </span><span>public</span><span> String getDbPass() {
        </span><span>return</span><span> dbPass;
    }
    </span><span>public</span> <span>void</span><span> setDbPass(String dbPass) {
        </span><span>this</span>.dbPass =<span> dbPass;
    }
    @Override
    </span><span>public</span><span> String toString() {
        </span><span>return</span> "DataSource [dbUser=" + dbUser + ", dbPass=" + dbPass + "]"<span>;
    }
    

    }

    复制代码

    配置类:

    复制代码
    package com.dxz.demo.configuration3;
    

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

    @Configuration
    @ComponentScan(basePackages = “com.dxz.demo.configuration3”)
    public class TestConfiguration {
    public TestConfiguration() {
    System.out.println(
    “TestConfiguration容器启动初始化。。。”);
    }

    @Configuration
    static class DatabaseConfig {
    @Bean
    DataSource dataSource() {
    return new
    DataSource();
    }
    }

    }

    复制代码

    启动类:

    复制代码
    package com.dxz.demo.configuration3;
    

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;

    public class TestMain {
    public static void main(String[] args) {

        </span><span>//</span><span> @Configuration注解的spring容器加载方式,用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContexts</span>
        ApplicationContext context = <span>new</span> AnnotationConfigApplicationContext(TestConfiguration.<span>class</span><span>);
    
         </span><span>//</span><span>bean</span>
        TestBean tb = (TestBean) context.getBean("testBean"<span>);
        tb.sayHello();
    
        DataSource ds </span>= (DataSource) context.getBean("dataSource"<span>);
        System.out.println(ds);
    }
    

    }

    复制代码

    结果:

    TestConfiguration容器启动初始化。。。
    TestBean sayHello...
    DataSource [dbUser=null, dbPass=null]

    3、@EnableXXX注解

    配合@Configuration使用,包括 @EnableAsync, @EnableScheduling, @EnableTransactionManagement, @EnableAspectJAutoProxy, @EnableWebMvc。

    @EnableAspectJAutoProxy—《spring AOP 之:@Aspect注解

    @EnableScheduling–《Spring 3.1新特性之二:@Enable*注解的源码,spring源码分析之定时任务Scheduled注解

     

    4、@Profile逻辑组配置

    见《Spring的@PropertySource + Environment,@PropertySource(PropertySourcesPlaceholderConfigurer)+@Value配合使用

    5、使用外部变量

    1、@PropertySource + Environment,通过@PropertySource注解将properties配置文件中的值存储到Spring的 Environment中,Environment接口提供方法去读取配置文件中的值,参数是properties文件中定义的key值。
    2、@PropertySource(PropertySourcesPlaceholderConfigurer)+@Value

    见《Spring的@PropertySource + Environment,@PropertySource(PropertySourcesPlaceholderConfigurer)+@Value配合使用

     

    展开全文
  • Spring中Configuration的理解

    万次阅读 2017-03-26 16:35:31
    基本用途从Spring3.0,@Configuration用于定义配置类,可替换xml配置文件,被注解的类内部包含有一个或多个被@Bean注解的方法,这些方法将会被AnnotationConfigApplicationContext或...例如:@Configuration

    基本用途

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

    @Configuration
    public class AppConfig {
    
        @Bean
        public MyBean myBean() {
            // instantiate, configure and return bean ...
        }
    }
    
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.register(AppConfig.class);//加载配置类
    ctx.refresh();//刷新并创建容器
    MyBean myBean = ctx.getBean(MyBean.class);
    // use myBean ...

    注意

    1. @Configuration不可以是final类型;
    2. @Configuration不可以是匿名类;
    3. 嵌套的configuration必须是静态类。

    加载配置类方法

    • 硬编码,例如ctx.register(AppConfig.class);
    • 使用xml配置
    <beans>
            //这个注解用于启用ConfigurationClassPostProcessor等后置处理器,以加载以下类到容器。
         <context:annotation-config/>
         <bean class="com.acme.AppConfig"/>
    </beans>
    XmlWebApplicationContext xmlWebApplicationContext = new XmlWebApplicationContext();
xmlWebApplicationContext.setConfigLocation("abc.xml");
    • 组件扫描。@Configuration本身是继承自@Component,因此也可以和正常被@Component一样被扫描到,或使用autowired。
    package com.acme.app.services
    
    @Configuration
    public class AppConfig {
        private final SomeBean someBean;
    
          //这里可以通过Spring注入someBean
        public AppConfig(SomeBean someBean) {
            this.someBean = someBean;
        }
    
        // @Bean definition using "SomeBean"
    
    }

    要想AppConfig被扫描到,可以

    @Configuration
    @ComponentScan("com.acme.app.services")
    public class RootConfig {
           // various @Bean definitions ...
    }

    使用外部变量

    • 注入Environment属性(可用于获取系统、JVM等环境变量),并配合@PropertySources注解,加载配置文件,使用@Value加载配置项。
    @Configuration
    @PropertySource("classpath:/com/acme/app.properties")
    public class AppConfig {
    
        @Inject Environment env;
    
        //PropertySourcesPlaceholderConfigurer,usually enabled via XML with <context:property-placeholder/>
        @Value("${bean.name}") String beanName;
    
        @Bean
        public MyBean myBean() {
            return new MyBean(env.getProperty("bean.name"));
        }
    }

    组合多个配置类

    类似于xml的\标签,可以使用@Import组合多个配置类,例如:

    @Configuration
    public class DatabaseConfig {
    
        @Bean
        public DataSource dataSource() {
            // instantiate, configure and return DataSource
        }
    }
    
    @Configuration
    @Import(DatabaseConfig.class)
    public class AppConfig {
    
        private final DatabaseConfig dataConfig;
    
        public AppConfig(DatabaseConfig dataConfig) {
            this.dataConfig = dataConfig;
        }
    
        @Bean
        public MyBean myBean() {
            // reference the dataSource() bean method
            return new MyBean(dataConfig.dataSource());
        }
    }
    
    //最后只需要导入一个即可
    new AnnotationConfigApplicationContext(AppConfig.class);

    @Configuration导入xml配置

    @Configuration
    @ImportResource("classpath:/com/acme/database-config.xml")
    public class AppConfig {
    
        @Inject DataSource dataSource; // from XML
    
        @Bean
        public MyBean myBean() {
            // inject the XML-defined dataSource bean
            return new MyBean(this.dataSource);
        }
    }

    内部类注解

    @Configuration
    public class AppConfig {
    
        @Inject DataSource dataSource;
    
        @Bean
        public MyBean myBean() {
            return new MyBean(dataSource);
        }
    
        @Configuration
        static class DatabaseConfig {
            @Bean
            DataSource dataSource() {
                return new EmbeddedDatabaseBuilder().build();
            }
        }
    }

    @Lazy懒加载

    可以与@Configuration和@Bean配合使用。Spring默认不是懒加载。

    @EnableXXX注解

    配合@Configuration使用,包括 @EnableAsync, @EnableScheduling, @EnableTransactionManagement, @EnableAspectJAutoProxy, @EnableWebMvc。

    • @EnableWebMvc

    常见使用方式如下所示:

       @Configuration
       @EnableWebMvc
       @ComponentScan(basePackageClasses = { MyConfiguration.class })
       public class MyWebConfiguration {
    
       }

    一旦使用了该注解,则会默认加载WebMvcConfigurationSupport配置,包括:

    1. HandlerMappings
       1. RequestMappingHandlerMapping 用于处理url到注解controller的method映射,序号是0
       2. HandlerMapping 用于处理url到view的映射,序号是1
       3. BeanNameUrlHandlerMapping 用于处理url到controller的beanname映射,序号是2
       4. HandlerMapping 用于处理静态资源,序号是Integer.MAX_VALUE-1
       5. HandlerMapping 用于forward到default servlet,序号是Integer.MAX_VALUE
    
    2. HandlerAdapters
       1. RequestMappingHandlerAdapter 用于处理带有注解Controller的响应处理方法
       2. HttpRequestHandlerAdapter 用于处理实现 HttpRequestHandler 的响应处理器
       3. SimpleControllerHandlerAdapter 用于处理实现Controller接口的响应处理器
    
    3. HandlerExceptionResolverComposite
       1. ExceptionHandlerExceptionResolver 用于处理@ExceptionHandler注解
       2. ResponseStatusExceptionResolver 用于处理@ResponseStatus注解
       3. DefaultHandlerExceptionResolver 用于处理已知的Spring异常
    
    4. AntPathMatcher 和 UrlPathHelper 

    你也可以不使用该注解,而是配置类继承WebMvcConfigurationSupport类或DelegatingWebMvcConfiguration,。或者使用@EnableWebMvc,并实现 WebMvcConfigurer接口,或 WebMvcConfigurerAdapter 适配器,例如:

       @Configuration
       @EnableWebMvc
       @ComponentScan(basePackageClasses = { MyConfiguration.class })
       public class MyConfiguration extends WebMvcConfigurerAdapter {
    
           @Override
           public void addFormatters(FormatterRegistry formatterRegistry) {
               formatterRegistry.addConverter(new MyConverter());
           }
    
           @Override
           public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
               converters.add(new MyHttpMessageConverter());
           }
    
           // More overridden methods ...
       }

    参考:

    http://www.cnblogs.com/xd502djj/archive/2012/09/24/2700490.html spring mvc 异常统一处理方式
    http://www.cnblogs.com/hupengcool/p/4586910.html SpringMVC 异常处理
    http://www.jianshu.com/p/cbcf78360308 Java Web技术经验总结(九)

    @Profile逻辑组配置

    用于指定配置类加载的逻辑组(a named logical grouping),只有在组内的配置类才会被加载。该注解类似于在xml的配置,例如\。@Profile可以在配置类上,也可以在配置类的方法上。如果不配置该注解,默认是无论如何都会加载。

    可以通过以下方式设置:

    1. 在JVM参数、系统环境参数或web.xml的initParam spring.profiles.active、spring.profiles.default(来自org.springframework.core.env.AbstractEnvironment) 。如果当spring.profiles.active属性被设置时,那么Spring会优先使用该属性对应值来激活Profile。当spring.profiles.active没有被设置时,那么Spring会根据spring.profiles.default属性的对应值来进行Profile进行激活。如果上面的两个属性都没有被设置,那么就不会有任务Profile被激活,只有定义在Profile之外的Bean才会被创建。
    2. 或者使用ConfigurableEnvironment.setActiveProfiles 指定需要激活的逻辑组名。
    3. 在测试类中,使用@ActiveProfiles注解指定。
    @Profile("embedded", "!abc")//表示当embedded激活,abc不激活时加载本配置类
    @Configuration
    public class EmbeddedDatabaseConfig {
    
        @Bean
        public DataSource dataSource() {
            // instantiate, configure and return embedded DataSource
        }
    }
    
    @Profile("production")
    @Configuration
    public class ProductionDatabaseConfig {
    
        @Bean
        public DataSource dataSource() {
            // instantiate, configure and return production DataSource
        }
    }

    等同于

    <beans profile="development">
            <!-- 只扫描开发环境下使用的类 -->
            <context:component-scan base-package="" />
            <!-- 加载开发使用的配置文件 -->
            <util:properties id="config" location="classpath:dev/config.properties"/>
        </beans>
    

    我们甚至可以自定义Profile注解

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Profile("dev")
    pubilc @interface Dev {
    }

    参考:

    http://www.jianshu.com/p/948c303b2253 详解Spring中的Profile
    http://zilongsky-gmail-com.iteye.com/blog/2032001 Maven 整合 spring profile实现多环境自动切换
    http://spring.io/blog/2011/02/14/spring-3-1-m1-introducing-profile/ Spring 3.1 M1: Introducing @Profile

    ConfigurableEnvironment

    用于在没有配置项的时候,用硬编码方式指定激活逻辑组、设置默认逻辑组,或增加新的逻辑组等。

    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.getEnvironment().setActiveProfiles("dev");
    ctx.register(TransferServiceConfig.class, StandaloneDataConfig.class, JndiDataConfig.class);
    ctx.refresh();

    配置信息

    最主要需要搞懂三个类PropertySource、PropertyResolver、Environment,PropertySource用于定于基本的配置数据来源,PropertyResolver用于对PropertySource进行解析,包括EL表达式(占位符替换),或进行类型转换(String->Integer等),Environment继承自PropertyResolver,这也是为何使用Environment.getProperty可以用el表达式的原因。

    Created with Raphaël 2.1.0propertySourcepropertySourcepropertyResolverpropertyResolverEnvironmentEnvironment被使用继承

    PropertySource

    加载各种配置信息。其中ComposePropertySource提供了组合PropertySource的功能,查找顺序就是注册顺序。默认提供了一个MutablePropertySources实现,我们可以调用addFirst添加到列表的开头,addLast添加到末尾,另外可以通过addBefore(propertySourceName, propertySource)或addAfter(propertySourceName, propertySource)添加到某个propertySource前面/后面;最后大家可以通过iterator迭代它,然后按照顺序获取属性。

    Map<String, Object> map = new HashMap<>();  
    map.put("encoding", "gbk");  
    PropertySource propertySource1 = new MapPropertySource("map", map);  
    System.out.println(propertySource1.getProperty("encoding"));  
    
    ResourcePropertySource propertySource2 = new ResourcePropertySource("resource", "classpath:resources.properties"); //name, location  
    System.out.println(propertySource2.getProperty("encoding"));

    这里写图片描述

    参考:

    http://sishuok.com/forum/blogPost/list/7936.html Spring3.1新属性管理API:PropertySource、Environment、Profile

    PropertyResolver 与 Environment

    Environment环境,比如JDK环境,Servlet环境,Spring环境等等;每个环境都有自己的配置数据,如System.getProperties()、System.getenv()等可以拿到JDK环境数据;ServletContext.getInitParameter()可以拿到Servlet环境配置数据等等;也就是说Spring抽象了一个Environment来表示环境配置。也可以获取或设置Profile。

    这里写图片描述

    1. MockEnvironment:模拟的环境,用于测试时使用;
    2. StandardEnvironment:标准环境,普通Java应用时使用,会自动注册System.getProperties() 和 System.getenv()到环境;
    3. StandardServletEnvironment:标准Servlet环境,其继承了StandardEnvironment,Web应用时使用,除了StandardEnvironment外,会自动注册ServletConfig(DispatcherServlet)、ServletContext及JNDI实例到环境;
    展开全文
  • 2、Configuration详解

    千次阅读 2017-06-16 23:47:13
    ConfigurationConfiguration类的位置org.apache.ibatis.session.Configuration Configuration类保存了所有Mybatis的配置信息。 。一般情况下Mybatis在运行过程中只会创建一个Configration对象,并且配置信息不...

    Configuration类

    Configuration类的位置org.apache.ibatis.session.Configuration
    Configuration类保存了所有Mybatis的配置信息。
    。一般情况下Mybatis在运行过程中只会创建一个Configration对象,并且配置信息不能再被修改。

    Configuration的属性

    configuration的属性主要分为两大部分:
    1. 从mybatis-config.xml中读取的配置
    2. 从mapper配置文件或Mapper注解读取的配置

    从mybatis-config.xml文件中对应的属性

    protected boolean safeRowBoundsEnabled = false;  
    protected boolean safeResultHandlerEnabled = true;  
    protected boolean mapUnderscoreToCamelCase = false;  
    protected boolean aggressiveLazyLoading = true;  
    protected boolean multipleResultSetsEnabled = true;  
    protected boolean useGeneratedKeys = false;  
    protected boolean useColumnLabel = true;  
    protected boolean cacheEnabled = true;  
    protected boolean callSettersOnNulls = false;  
    protected String logPrefix;  
    protected Class <? extends Log> logImpl;  
    protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;  
    protected JdbcType jdbcTypeForNull = JdbcType.OTHER;  
    protected Set<String> lazyLoadTriggerMethods = new HashSet<String>(Arrays.asList(new String[] { "equals", "clone", "hashCode", "toString" }));  
    protected Integer defaultStatementTimeout;  
    protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;  
    protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;  
    
    protected Properties variables = new Properties();  
    protected ObjectFactory objectFactory = new DefaultObjectFactory();  
    protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();  
    protected MapperRegistry mapperRegistry = new MapperRegistry(this);  
    
    protected boolean lazyLoadingEnabled = false;  
    protected ProxyFactory proxyFactory;  
    
    protected final InterceptorChain interceptorChain = new InterceptorChain();  
    protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();  
    protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();  
    protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry(); 

    从Mapper配置文件中读取的属性

    protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");  
    protected final Map<String, Cache> caches = new StrictMap<Cache>("Caches collection");  
    protected final Map<String, ResultMap> resultMaps = new StrictMap<ResultMap>("Result Maps collection");  
    protected final Map<String, ParameterMap> parameterMaps = new StrictMap<ParameterMap>("Parameter Maps collection");  
    protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<KeyGenerator>("Key Generators collection");  
    1. mappedStatements属性,保存了所有Mapper配置文件中的select/update/insert/delete节点信息。属性类型为一个Map,key为sql对应的ID,MappedSatement为一个java对象,保存了一个select/update/insert/delete的节点信息。
    2. resultMaps属性,保存了所有Mapper配置文件中的resultMap节点。
      Mapper配置文件也主要是配置select/update/insert/delete/resultMap这几个节点。

    Configuration加载过程

    1. XMLConfigBuilder解析mybatis-config.xml的配置到Configuration中
    2. XMLMapperBuilder解析Mapper配置文件的配置到Configuration中

    Configuration的创建

    Configuration创建的过程会对属性进行初始化
    下面的属性都是不可变的,意味着只能使用,mybatis默认提供的实现,或者类

    
        protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
        protected final InterceptorChain interceptorChain = new InterceptorChain();
        protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();
        protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
        protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");
        protected final Map<String, Cache> caches = new StrictMap<Cache>("Caches collection");
        protected final Map<String, ResultMap> resultMaps = new StrictMap<ResultMap>("Result Maps collection");
        protected final Map<String, ParameterMap> parameterMaps = new StrictMap<ParameterMap>("Parameter Maps collection");
        protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<KeyGenerator>("Key Generators collection");
        protected final Set<String> loadedResources = new HashSet<String>();
        protected final Map<String, XNode> sqlFragments = new StrictMap<XNode>("XML fragments parsed from previous mappers");
        protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<XMLStatementBuilder>();
        protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<CacheRefResolver>();
        protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<ResultMapResolver>();
        protected final Collection<MethodResolver> incompleteMethods = new LinkedList<MethodResolver>();
        /*
         * A map holds cache-ref relationship. The key is the namespace that
         * references a cache bound to another namespace and the value is the
         * namespace which the actual cache is bound to.
         */
        protected final Map<String, String> cacheRefMap = new HashMap<String, String>();

    Configuration的无参的构造方法,默认注册了很多类型别名

    public Configuration() {
            typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
            typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
    
            typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
            typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
            typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
    
            typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
            typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
            typeAliasRegistry.registerAlias("LRU", LruCache.class);
            typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
            typeAliasRegistry.registerAlias("WEAK", WeakCache.class);
    
            typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);
    
            typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
            typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);
    
            typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
            typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
            typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
            typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
            typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
            typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
            typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);
    
            typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
            typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);
    
            languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
            languageRegistry.register(RawLanguageDriver.class);
        }

    另外还有其他的构造器,具体参考`Configuration

    展开全文
  • @Configuration的作用

    千次阅读 2019-09-04 12:58:44
    在我们的项目当中,通常都会配置一个或者多个加了@Configuration注解的配置类,那么@Configuration这个注解到底有神马作用勒? @ComponentScan("com") public class AppConfig { @Bean public TestDao testDao() {...

    一、问题描述

    在项目中,通常都会配置一个或者多个加了@Configuration注解的配置类,那么@Configuration这个注解到底有神马作用勒?

    @ComponentScan("com")
    public class AppConfig {
    	@Bean
    	public TestDao testDao() {
    		return new TestDao();
    	}
    }
    
    public class Test {
    	public static void main(String[] args) {
    		AnnotationConfigApplicationContext acc = new AnnotationConfigApplicationContext(AppConfig.class);
    	}
    }
    
    public class TestDao {
    	public TestDao(){
    		System.out.println("testDao");
    	}
    
    }
    

    执行上面的代码,我们会发现当我们不加@Configuration这个注解的时候我们的TestDao 这个类还是还是会被实例化,也会打印testDao。我们的spring环境也可以正常运行。
    在这里插入图片描述
    那么我们的@Configuration注解是来解决什么问题的勒?我们来看一下下面这段代码。当我们在AppConfig中有2个方法,而且第二个方法调用了第一个方法。

    @ComponentScan("com")
    public class AppConfig {
    
    	@Bean
    	public TestDao testDao() {
    		return new TestDao();
    	}
    
    	@Bean
    	public TestDao1 testDao1() {
    		testDao();
    		return new TestDao1();
    	}
    }
    
    public class TestDao1 {
    	public TestDao1(){
    		System.out.println("testDao1");
    	}
    }
    

    不加@Configuration的打印结果
    在这里插入图片描述
    加上@Configuration的打印结果
    在这里插入图片描述

    二、分析

    从表面来看,当我们不加@Configuration注解的时候,我们的TestDao会被实例化两次,这违背了我们spring默认单例的设计原则,当加上我们的@Configuration注解的时候,TestDao只被实例化了一次。那么其底层到底做了什么,让我们来深追一下spring源码吧。
    当我们解析beanAppcofig的时候,会给它的一个属性标识为Full,表明它是一个全注解类。
    在这里插入图片描述
    在这里插入图片描述
    然后在我们调用ConfigurationClassPostProcessor.postProcessBeanFactory()方法的时候会去判断我们的bean工厂当中是否有bean需要进行cglib代理。
    在这里插入图片描述
    在这里插入图片描述
    然后遍历configBeanDefs这个map
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    cglib代理主要是对我们的方法进行拦截增强;当我们执行AppConfig中的方法的时候会去执行cglib代理类中的代理方法,主要就是callBacks中的方法。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    isCurrentlyInvokedFactoryMethod(beanMethod)) 会判断我们的执行方法和我们的调用方法是否是同一个;如果是同一个就调用父类的方法进行new;如果不是就调用$$beanFactory.getBean()获取。
    在这里插入图片描述

    三、总结

    加上@Configuration注解主要是给我们的类加上了cglib代理。在执行我们的配置类的方法时,会执行cglib代理类中的方法,其中有一个非常重要的判断,当我们的执行方法和我们的调用方法是同一个方法时,会执行父类的方法new(cglib代理基于继承);当执行方法和调用方法不是同一个方法时会调用beanFactory.getBean获取。
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 打开app.config编辑 使用时,要先添加引用 1.。。。 ... using System.Configuration;...public static string connectionString = ConfigurationManager.AppSettings["connString"];...
  • Configuration类详解

    千次阅读 2017-08-04 01:39:36
    ...1.configuration类简介 ... Hadoop没有使用Java.util.Properties管理配置文件,也没有使用Apache ... Jakarta Commons Configuration管理配置文件,而是使用了一套独有的配置文件管理系
  • @Configuration

    千次阅读 2018-07-03 09:04:52
    作用  声明当前类是一个配置类,相当于一个Spring的XML... Instead of using the XML files, we can use plain Java classes to annotate the configurations by using the @Configuration annotation. If you an...
  • Pycharm- Edit Congirations呈现灰色解决

    千次阅读 2018-04-08 19:51:08
    今天打开pycharm时,发现.py文件运行不了,我记得时调Edit configurations的选项的发现该选项是灰的,就比较尬尬的,想改也改不了后来我的解决方法是,回到pycharm的主界面,如果上次是打开,直接关的话,会直接进入...
  • @ConfigurationProperties 注解使用姿势,这一篇就够了

    万次阅读 多人点赞 2019-07-29 08:41:21
    @ConfigurationProperties 注解使用姿势,这一篇就够了
  • 配置类为什么要添加@Configuration注解?

    千次阅读 多人点赞 2020-06-07 17:12:37
    本系列文章将会带你一行行的将Spring的源码吃透,做到彻底精通Spring
  • 搭建完spring boot的demo后自然要实现自动注入来体现spring ioc的便利了,但是我在实施过程中出现了这么一个问题,见下面,这里找到解决办法记录下来,供遇到同样的问题的同僚参考  Description:Field ...
  • Logback configuration error detected的终极解决方案

    万次阅读 多人点赞 2018-09-21 14:54:02
    今天在springboot项目中替换log4j2日志的时候...Logging system failed to initialize using configuration from 'classpath:log4j2-dev.xml' java.lang.IllegalStateException: Logback configuration error dete...
  • Spring @Configuration 和 @Component 区别

    万次阅读 多人点赞 2017-09-24 08:44:02
    Spring @Configuration 和 @Component 区别 一句话概括就是 @Configuration 中所有带 @Bean 注解的方法都会被动态代理,因此调用该方法返回的都是同一个实例。 下面看看实现的细节。@Configuration 注解:@Target...
  • Spring @Configuration注解

    万次阅读 多人点赞 2018-04-03 12:15:36
    从Spring3.0,@Configuration用于定义配置类,可替换xml配置文件,被注解的类内部包含有一个或多个被@Bean注解的方法,这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类...
  • Spring容器启动时,即执行refresh方法时,主要是通过执行ConfigurationClassPostProcessor这个BeanFactoryPostProcessor,来开启整个@Configuration注解的系列类的加载的,即开启基于@Configuration的类配置代替...
  • Configuration(Android 6.0)

    千次阅读 2017-11-10 13:41:12
    说到Configuration,大家最熟悉的想必是android:configChanges=[“mcc”, “mnc”, “locale”,”touchscreen”, “keyboard”, “keyboardHidden”,”navigation”,”screenLayout”, “fontScale”, “uiMode”,”...
  • Keil(MDK-ARM)系列教程(五)_Configuration(Ⅰ)

    万次阅读 多人点赞 2019-03-08 11:38:25
    推荐 分享一个大神的人工智能教程。零基础!通俗易懂!风趣幽默!还带黄段子!希望你也加入到人工智能的队伍中来!http://www.captainbed.net/strongerhuang 我的网站:https://www.strongerhuang.com ...本...
  • IntelliJ Spring Configuration Check

    万次阅读 多人点赞 2019-01-29 17:46:00
    用IntelliJ 导入现有工程时,如果原来的工程中有spring,每次打开工程就会提示:Spring Configuration Check 开始不知道怎么回事,但工程不影响。 首先到工程设置界面 工程设置(Project Structure)点击...
  • @Component和@Configuration作为配置类的差别

    万次阅读 多人点赞 2018-06-08 18:48:00
    随着spingboot的大火,注解式配置受到了大家的热烈欢迎,而@Component和@Configuration都可以作为配置类,之前一直都没觉得这两个用起来有什么差别,可能有时程序跑的和自己想的有所区别也没注意到。 直到看到这篇...
  • Hadoop Configuration设置自定义类变量

    千次阅读 2015-03-14 17:23:13
    有时在编写Hadoop的MR的时候,会想到如果在Configuration里面可以设置一个类变量多好呀。查看Configuration的api可以看到,一般set方法都是set一般数据类型,比如int,string或者double之类的。那有没有一个方法设置...
1 2 3 4 5 ... 20
收藏数 1,307,722
精华内容 523,088
关键字:

configuration