Spring Boot配置类编写

编写Spring Boot配置类

解释

多个配置类的编写（一主多从）

启动类为：Application
主配置类为：SpringConfiguration
从配置类为：SpringWebMvcConfigurer

1.启动类导入主配置类

@SpringBootApplication                                    
@Import(SpringConfiguration.class)
public class Application {
    ...
}

2.主配置类导入从配置类

@Configurable
@Import(SpringWebMvcConfigurer.class)
public class SpringConfiguration {
    ...
}

3.编写从配置类

@Configuration
public class SpringWebMvcConfigurer {
    ...
}

确定包扫描路径

指定扫描组件的包路径，可以减少扫描的时间。在主配置类上使用@ComponentScan注解。

@ComponentScan({ "team.sevendwarfs.persistence", "team.sevendwarfs.web.controller" })
public class SpringConfiguration {
    ...
}

例子中只扫描 Controller和持久层中Entity, Repository, Server 组件

指定属性文件名

默认情况下，资源文件名为application.properties，也可以自定义，不过需要显式指定

@PropertySource({"classpath:application-dev.properties"})
public class SpringConfiguration {
    ...
}

编写多个属性文件

将属性文件分为 开发环境属性文件 和 生产环境属性文件。结构为：一主多从
application.properties 主配置文件
application-dev.properties
application-prod.properties

// fileName:application.properties
spring.profiles.active=dev

// fileName:application-dev.properties
server.port=8082
...

// fileName:application-prod.properties
server.port=80
...

配置类默认读取application.properties，而application.properties中指定了当前激活的属性文件为application-dev.properties，那么就导入了application-dev.properties的属性

示例

启动类

// FileName: Application
@SpringBootApplication
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class,
                                    HibernateJpaAutoConfiguration.class})
@Import(SpringConfiguration.class)
public class Application {

  /**
   * @Description 整个web应用的入口点.
   */
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

主配置类

// fileName: SpringConfiguration
@Configurable
@ComponentScan({ "team.sevendwarfs.persistence", "team.sevendwarfs.web" +
        ".controller" })
@PropertySource({"classpath:application.properties"})
@Import(SpringWebMvcConfigurer.class)
public class SpringConfiguration {
    private static final String HIBERNATEDIALECT = "hibernate.dialect";
    private static final String HIBERNATESHOWSQL = "hibernate.show_sql";
    private static final String HIBERNATEDDLAUTO = "hibernate.hbm2ddl.auto";
    private static final String HIBERNATEPACKAGESCAN = "hibernate.packagesToScan";
    private static final String HIBERNATEFORMATSQL = "hibernate.format_sql";

    @Value("${spring.datasource.jdbcUrl}")
    private String url;
    @Value("${spring.datasource.username}")
    private String username;
    @Value("${spring.datasource.password}")
    private String password;
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.minPoolSize}")
    private Integer minPoolSize;
    @Value("${spring.datasource.maxPoolSize}")
    private Integer maxPoolSize;
    @Value("${spring.datasource.maxIdleTime}")
    private Integer maxIdleTime;
    @Value("${spring.datasource.acquireIncrement}")
    private Integer acquireIncrement;
    @Value("${spring.datasource.maxStatements}")
    private Integer maxStatements;
    @Value("${spring.datasource.initialPoolSize}")
    private Integer initialPoolSize;
    @Value("${spring.datasource.idleConnectionTestPeriod}")
    private Integer idleConnectionTestPeriod;

    @Autowired
    private Environment env;

    @Bean(name = "dataSource")
    @Primary
    public DataSource dataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        dataSource.setDriverClass(driverClassName);
        dataSource.setMinPoolSize(minPoolSize);
        dataSource.setMaxPoolSize(maxPoolSize);
        dataSource.setMaxIdleTime(maxIdleTime);
        dataSource.setAcquireIncrement(acquireIncrement);
        dataSource.setMaxStatements(maxStatements);
        dataSource.setInitialPoolSize(initialPoolSize);
        dataSource.setIdleConnectionTestPeriod(idleConnectionTestPeriod);
        return dataSource;
    }

    @Bean("localSessionFactoryBean")
    public LocalSessionFactoryBean localSessionFactoryBean(DataSource dataSource) throws
            PropertyVetoException, IOException {
        LocalSessionFactoryBean sessionFactoryBean = new LocalSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        sessionFactoryBean.setPackagesToScan(env.getRequiredProperty(HIBERNATEPACKAGESCAN));
        // 设置完属性之后需要调用 afterPropertiesSet方法使配置生效
        sessionFactoryBean.setHibernateProperties(hibProperties());
        sessionFactoryBean.afterPropertiesSet();
        return sessionFactoryBean;
    }

    @Bean("sessionFactory")
    @Primary
    public SessionFactory sessionFactory(LocalSessionFactoryBean localSessionFactoryBean) throws
            PropertyVetoException, IOException {
        SessionFactory sessionFactory = localSessionFactoryBean.getObject();
        return sessionFactory;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory
            (DataSource dataSource) {
        final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource);
        final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        em.setJpaVendorAdapter(vendorAdapter);
        em.setPackagesToScan(env.getRequiredProperty(HIBERNATEPACKAGESCAN));
        // 设置完属性之后需要调用 afterPropertiesSet方法使配置生效
        em.setJpaProperties(hibProperties());
        em.afterPropertiesSet();
        return em;
    }

    @Bean
    public PlatformTransactionManager transactionManager(final EntityManagerFactory emf) {
        final JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(emf);
        return transactionManager;
    }

    @Bean
    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
        return new PersistenceExceptionTranslationPostProcessor();
    }

    @Bean
    public FilterRegistrationBean registerOpenEntityManagerInViewFilterBean() {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        OpenEntityManagerInViewFilter filter = new OpenEntityManagerInViewFilter();
        registrationBean.setFilter(filter);
        registrationBean.addUrlPatterns("/*");
        registrationBean.setOrder(5);
        return registrationBean;
    }


    private Properties hibProperties() {
        Properties properties = new Properties();
        properties.put(HIBERNATEDIALECT, env.getRequiredProperty(HIBERNATEDIALECT));
        properties.put(HIBERNATESHOWSQL, env.getRequiredProperty(HIBERNATESHOWSQL));
        properties.put(HIBERNATEDDLAUTO, env.getRequiredProperty(HIBERNATEDDLAUTO));
        properties.put(HIBERNATEFORMATSQL, env.getRequiredProperty(HIBERNATEFORMATSQL));
        return properties;
    }
}

MVC从配置类

// FileName: SpringWebMvcConfigurer
@Configuration
public class SpringWebMvcConfigurer extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 添加拦截规则
        // 只有用户登录过后才能访问 user/目录下资源
        registry.addInterceptor(new UserInterceptor()).addPathPatterns
                ("/api/user/**");

        /**
         * 只有登录管理员账号后才能访问管理员目录
         * 例外：管理员登录路径 /api/admin/login
         */
        registry.addInterceptor(new AdminInterceptor()).addPathPatterns
              ("/api/admin/**").excludePathPatterns("/api/admin/login");
        super.addInterceptors(registry);
    }
}