Spring application without web.xml log4j configuration

jerseylog4jlog4j2spring

I have a Spring + Jersey web application that I'm migrating from a web.xml to annotation base configuration. I'm implementing WebApplicationInitializer and everything works except log4j, because I have a custom file name.

In the web.xml I had

<context-param>
    <param-name>log4jConfiguration</param-name>
    <param-value>/WEB-INF/custom-name-log4j.xml</param-value>
</context-param>

This worked.

Now, I tried to do the same in Java:

container.setInitParameter("log4jConfiguration", "/WEB-INF/custom-name-log4j.xml");

This doesn't work… I get the following errors in Tomcat 7.0.62:

ERROR StatusLogger No Log4j context configuration provided. This is very unusual.
ERROR StatusLogger No log4j2 configuration file found. Using default configuration: logging only errors to the console.

My WAR file contains the xml in the WEB-INF/ folder.

Do I have to do more than specifying that log4jConfiguration parameter?

Later Edit:
WebApplicationInitializer

    @Override
    public void onStartup(ServletContext container) {
        AnnotationConfigWebApplicationContext rootContext =
                new AnnotationConfigWebApplicationContext();
        rootContext.register(MyApplicationConfiguration.class);

        container.setInitParameter("log4jConfiguration", "/WEB-INF/custom-name-log4j.xml");

        rootContext.setConfigLocation("my.package.spring");

        final FilterRegistration.Dynamic characterEncodingFilter = container.addFilter("characterEncodingFilter", new CharacterEncodingFilter());
        characterEncodingFilter.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");
        characterEncodingFilter.setInitParameter("encoding", "UTF-8");
        characterEncodingFilter.setInitParameter("forceEncoding", "true");

        container.setInitParameter("spring.profiles.default", "prod");

        rootContext.register(SecurityContextFilter.class);

        container.addListener(new ContextLoaderListener(rootContext));
        container.addListener(new RequestContextListener());

        container.setInitParameter("contextConfigLocation", "");

        final ServletContainer servlet = new ServletContainer();
        final ServletRegistration.Dynamic appServlet = container.addServlet("appServlet", servlet);
        appServlet.setInitParameter("jersey.config.server.provider.packages", "my.package");
        appServlet.setLoadOnStartup(1);

        final Set<String> mappingConflicts = appServlet.addMapping("/rest/*");

    }

Best Answer

You also need to register a Listener : Log4jConfigListener (you can find it in org.springframework.web.util)

servletContext.addListener(Log4jConfigListener.class);

By the way, you can note that it is deprecated since spring 4.2.1

EDIT

Sorry I didn't realized that you were using log4j2, everything stated above is false, and here is the solution for you :

log4j2 (thanks to log4j-web artifact) & spring are both relying on ServletContainerInitializer from servlet 3.0 API to setup the ServletContext. The problem is that the order they are executed depends on the order they are scanned on the classpath and you can't really rely on it (in your case the Log4jServletContainerInitializer startup methods is called before the one from SpringServletContainerInitializer).

To correct this you can declare your own ServletContainerInitializer implementation which we'll be taken into account before others (before scanning the classpath) and here is a sample :

public class Log4j2ConfigServletContainerInitializer implements ServletContainerInitializer {

    @Override
    public void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException {
        ctx.setInitParameter("log4jConfiguration", "/WEB-INF/custom-name-log4j.xml");
    }
}

Then you have to create a file : /META-INF/services/javax.servlet.ServletContainerInitializer

and put into it :

example.initializer.Log4j2ConfigServletContainerInitializer (change to suit your needs)

and the configuration you provided to set a custom log4j config file location will be set before triggering the Log4jServletContainerInitializer and everything is going to be fine.

see :

https://docs.oracle.com/javaee/6/api/javax/servlet/ServletContainerInitializer.html

http://www.eclipse.org/jetty/documentation/current/using-annotations.html#servlet-container-initializers

http://logging.apache.org/log4j/2.x/manual/webapp.html

EDIT

POC @ http://www.filedropper.com/32713596_1 just run mvn jetty:run

Related Solutions

Java – What’s the difference between @Component, @Repository & @Service annotations in Spring

From Spring Documentation:

The @Repository annotation is a marker for any class that fulfils the role or stereotype of a repository (also known as Data Access Object or DAO). Among the uses of this marker is the automatic translation of exceptions, as described in Exception Translation.

Spring provides further stereotype annotations: @Component, @Service, and @Controller. @Component is a generic stereotype for any Spring-managed component. @Repository, @Service, and @Controller are specializations of @Component for more specific use cases (in the persistence, service, and presentation layers, respectively). Therefore, you can annotate your component classes with @Component, but, by annotating them with @Repository, @Service, or @Controller instead, your classes are more properly suited for processing by tools or associating with aspects.

For example, these stereotype annotations make ideal targets for pointcuts. @Repository, @Service, and @Controller can also carry additional semantics in future releases of the Spring Framework. Thus, if you are choosing between using @Component or @Service for your service layer, @Service is clearly the better choice. Similarly, as stated earlier, @Repository is already supported as a marker for automatic exception translation in your persistence layer.

Annotation	Meaning
`@Component`	generic stereotype for any Spring-managed component
`@Repository`	stereotype for persistence layer
`@Service`	stereotype for service layer
`@Controller`	stereotype for presentation layer (spring-mvc)

Spring – Best configuration for spring 3.2.3

You can change your web.xml context param to:

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:META-INF/spring/applicationContext*.xml</param-value>
</context-param>

And create any count of context files without importing it to root context

enter image description here

Also it is very useful when you have multimodule project and put configuration files to each module, name it applicationContext-.xml and it will be automatically scanned.

It is good practice to declare mvc components in mvc-dispatcher-servlet.xml: interceptors (locale, theme interceptors and your own), view resolvers, resources, exception-handlers, templating-engine configuration and other components that relates with view.

Also it is useful to declare component-scan only for controllers in servlet configuration:

mvc-dispatcher-servlet.xml:

<context:component-scan base-package="by.company.app" use-default-filters="false">
    <context:include-filter expression="org.springframework.stereotype.Controller" type="annotation"/>
</context:component-scan>

When in applicationContext exclude @Controller scan:

applicationContext.xml:

<context:component-scan base-package="by.company.app">
    <context:exclude-filter expression="org.springframework.stereotype.Controller" type="annotation"/>
</context:component-scan>

That helps to avoid duplicated bean definitions

Example of separate applicationContexts (namespaces declaration omitted):

applicationContext.xml:

<beans>    
    <context:property-placeholder location="classpath*:META-INF/spring/a-*.properties" />

    <task:annotation-driven/>

    <context:spring-configured/>

    <context:component-scan base-package="by.company.app">
        <context:exclude-filter expression="org.springframework.stereotype.Controller" type="annotation"/>
    </context:component-scan>
</beans>

applicationContext-db.xml

<beans>
    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="url" value="jdbc:mysql://${database.host}:${database.port}/${database.db-path}" />
        <property name="driverClassName" value="${database.driverClassName}" />
        <property name="username" value="${database.username}" />
        <property name="password" value="${database.password}" /> 
    </bean>

    <bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <tx:annotation-driven mode="aspectj" transaction-manager="transactionManager"/>

    <bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory">
        <property name="persistenceUnitName" value="persistenceUnit"/>
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
        </property>
        <property name="jpaProperties"> 
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.max_fetch_depth">3</prop> 
                <prop key="hibernate.jdbc.fetch_size">50</prop> 
                <prop key="hibernate.jdbc.batch_size">10</prop> 
                <prop key="hibernate.show_sql">false</prop>
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <prop key="hibernate.connection.charSet">UTF-8</prop>
                <!-- <prop key="hibernate.hbm2ddl.auto">update</prop> -->
            </props> 
        </property>
    </bean>

    <jpa:repositories base-package="by.company.app" />

</beans>

Best Answer

Related Solutions

Java – What’s the difference between @Component, @Repository & @Service annotations in Spring

Spring – Best configuration for spring 3.2.3

Related Topic