Spring Java Config file question

[Mike Tabak]

I have some Spring Java config files I'm looking at. The main configuration file is

import javax.servlet.MultipartConfigElement;
import javax.servlet.ServletRegistration.Dynamic;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import spittr.web.WebConfig;

public class SpitterWebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
  
  // Configs backend beans - corresponds to root-config.xml
  @Override
  protected Class<?>[] getRootConfigClasses() {
    return new Class<?>[] { RootConfig.class };
  }

  @Override
  protected Class<?>[] getServletConfigClasses() {
    return new Class<?>[] { WebConfig.class };
  }

  @Override
  protected String[] getServletMappings() {
    return new String[] { "/" };
  }

  @Override
  protected void customizeRegistration(Dynamic registration) {
    registration.setMultipartConfig(
        new MultipartConfigElement("/tmp/spittr/uploads", 2097152, 4194304, 0));
  }
 
}

The WebConfig.java file is:

import java.io.IOException;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.support.StandardServletMultipartResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.thymeleaf.spring3.SpringTemplateEngine;
import org.thymeleaf.spring3.view.ThymeleafViewResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;
import org.thymeleaf.templateresolver.TemplateResolver;

@Configuration  // This is a configuration file, picked up by scanning turned on in RootConfig.java
@EnableWebMvc  // Turn on Springs MVC model
@ComponentScan("spittr.web")  // Where to scan for controllers - @Controller
public class WebConfig extends WebMvcConfigurerAdapter {
  
  @Bean
  public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
    ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
    viewResolver.setTemplateEngine(templateEngine);
    return viewResolver;
  }
  @Bean
  public SpringTemplateEngine templateEngine(TemplateResolver templateResolver) {
    SpringTemplateEngine templateEngine = new SpringTemplateEngine();
    templateEngine.setTemplateResolver(templateResolver);
    return templateEngine;
  }

  @Bean
  public TemplateResolver templateResolver() {
    TemplateResolver templateResolver = new ServletContextTemplateResolver();
    templateResolver.setPrefix("/WEB-INF/views/");
    templateResolver.setSuffix(".html");
    templateResolver.setTemplateMode("HTML5");
    return templateResolver;
  }
    
  @Override
  public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
    configurer.enable();
  }
  
  @Bean
  public MultipartResolver multipartResolver() throws IOException {
    return new StandardServletMultipartResolver();
  }
  
}

The DataConfig.java file is:

import javax.sql.DataSource;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcOperations;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;

@Configuration
public class DataConfig {

  @Bean
  public DataSource dataSource() {
    return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .addScript("schema.sql")
            .build();
  }
  
  @Bean
  public JdbcOperations jdbcTemplate(DataSource dataSource) {
    return new JdbcTemplate(dataSource);
  }
  
}

and the RootConfig.java file is:

import java.util.regex.Pattern;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.context.annotation.Import;
import org.springframework.core.type.filter.RegexPatternTypeFilter;

import spittr.config.RootConfig.WebPackage;

@Configuration
@Import(DataConfig.class)
@ComponentScan(basePackages={"spittr"}, 
    excludeFilters={
        @Filter(type=FilterType.CUSTOM, value=WebPackage.class)
    })
public class RootConfig {
  public static class WebPackage extends RegexPatternTypeFilter {
    public WebPackage() {
      super(Pattern.compile("spittr\\.web"));
    }    
  }
}

Could someone explain the RootConfig.java file to me, specifically what the static class WebPackage is doing. I know RegexPatternTypeFilter is used to set up a simple filter for matching on a regex expression, but what is happening here when this class is just created and it's .match(...) method is not being obviously called anywhwere? Thanks in advance.

[John Cruz]

Hi Mike,

If the code is from a book (like Spring In Action), I think you should quote that it is so, to be fair to the book owners.

Anyway, the @ComponentScan have the excludeFilters, and excludeFilters uses that WebPackage.class.

WebPackage is a custom filter.

Basically anything that matches below, is excluded from the component scanning.

"spittr\\.web"

[Mike Tabak]

John Cruz wrote:Hi Mike,

If the code is from a book (like Spring In Action), I think you should quote that it is so, to be fair to the book owners.

Anyway, the @ComponentScan have the excludeFilters, and excludeFilters uses that WebPackage.class.

WebPackage is a custom filter.

Basically anything that matches below, is excluded from the component scanning.

"spittr\\.web"

Hi John,

Yes, this is from Spring In Action Volume 4. What you say makes sense. The version I quoted is from the downloadable source code. The version of this file printed in the text does the same thing, only without the WebPackage class definition, it just uses an excludeFilter definition based on annotation and class. When I substituted that file for the one in the download, things still worked fine. I guess when you component scan for the root config you have to be sure not to include any definitions in the DispatcherServlet config. Thanks much John.

[John Cruz]

Hi Mike,

The root config thing is shared by all lower configs. I mean, the root application context created from it, is inherited by all application contexts in the application.

There is only 1 root application context in the application. You usually put there only stuff that is used in entire application.

The web stuff is not used in entire application but by the web stuff only (like web layer, controllers; but not used for example by JMS layer services). That is why the coder of that sample code, excluded it from the root context, which is inherited by all lower contexts.

In the WebConfig in the sample code, that spitter.web is component-scanned in it, and therefore beans in the spitter.web are registered in the web application context.

All this magic starts at below:

  
  @Override
  protected Class<?>[] getRootConfigClasses() {
    return new Class<?>[] { RootConfig.class };
  }
 
  @Override
  protected Class<?>[] getServletConfigClasses() {
    return new Class<?>[] { WebConfig.class };
  }