如何搭建一个基于Java Config零配置的SSM框架(无配置文件)

偏执的太偏执、 2022-06-06 12:59 113阅读 0赞

基于Java形式的项目配置，相比于基于配置文件的形式更直接，更简洁，更简单。使用配置文件，比如xml,json,properties等形式，都是用代码去解析配置文件内的信息，然后根据其信息设置相应配置类的属性。而Java形式的配置是跳过配置文件，直接将配置信息赋值到相应的配置类里。

以文件形式配置，一般相应的解析类和配置类都不容易找到，感觉这里面是一个黑箱，只知道应该这样配置，但是不清楚为什么这样配置，配置是如何发生作用的等等。而以Java形式配置，我们直接和配置类打交道，中间省去了配置文件和解析类，能很明了的看到我们的配置的作用流程，出现问题能更方面的定位及解决。

在常见的Java web项目中，我们通常将项目的启动信息配置在web.xml内，比如日志文件定位，日志使用类，Spring启动类，Spring配置文件，Filter，SpringMVC配置文件，MVC根路径等等。当我们配置好了之后，就能启动项目了。那么有没有能替代web.xml的一个Java类，我们把配置信息都配置在这类里面。或者换条路，原先web.xml的配置信息最终都配置到了哪个或者哪些类，我们能不能直接使用那些配置类，用以配置项目。其实是有的。

原先我们将配置信息放在web.xml内，以tomcat为例，在启动时会加载web.xml，解析内部的dom元素，得到我们配置的信息，然后根据信息比如Spring启动类，配置文件地址来启动Spring容器。而在Servlet3.0之后，有了一个替代web.xml的java类出现了，叫ServletContainerInitializer，tomcat在启动后会搜索项目ServletContainerInitializer接口的指定实现类， 调用他们的onStartup方法，而且将Servlet上下文当做参数传进去。Spring在3.1版本之后新增了一个SpringServletContainerInitializer，实现了ServletContainerInitializer接口，里面含有启动整个Spring及SpringMVC的配置选项。Sring在某处配置了这个类的全限定名，tomcat在启动后会加载此类，在加载的过程中调用其onStartup方法，启动Spring。

推荐Spring版本至少为4，因为Spring4之后新增了很多基于注解形式的配置，用注解加类配置，实在是太好用了。

@HandlesTypes(WebApplicationInitializer.class)
    public class SpringServletContainerInitializer implements ServletContainerInitializer { 
        ......
        public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
                throws ServletException {
            ......
        }
    }

SpringServletContainerInitializer 类上有一个@HandlesTypes，值是WebApplicationInitializer.class，tomcat在启动时，搜索org.springframework.web.SpringServletContainerInitializer这个类，解析器上的@HandlesTypes注解的value，按类型获取项目内所有的实现类，然后将这些实现类和Servlet上下文单做参数传入onStartup（）方法，然后执行此方法。

![这里写图片描述][SouthEast]

这个类结构图使用了模板方法模式，留下了很多可以重写的方法，可以通过重写这些方法，返回我们的项目配置信息。通过继承AbstractAnnotationConfigDispatcherServletInitializer，重写里面的方法来自定义配置。下面就讲讲能重写哪些方法，每个方法返回的配置的意义。

当我们定义了一个类去继承AbstractAnnotationConfigDispatcherServletInitializer，看如下代码:

public class WebContextInitializer extends AbstractAnnotationConfigDispatcherServletInitializer { 
    
        @Override
        protected Class<?>[] getRootConfigClasses() {
            return new Class<?>[] {RootContextConfig.class};
        }
    
        @Override
        protected Class<?>[] getServletConfigClasses() {
            return new Class<?>[] {MvcContextConfig.class};
        }
    
        @Override
        protected ApplicationContextInitializer<?>[] getRootApplicationContextInitializers() {
            return new ApplicationContextInitializer<?>[] {
       new RootContextInitializer()};
        }
    
        @Override
        protected ApplicationContextInitializer<?>[] getServletApplicationContextInitializers() {
            return new ApplicationContextInitializer<?>[] {
       new ServletContextInitializer()};
        }
    
        @Override
        protected String[] getServletMappings() {
            return new String[] {
       "/"};
        }
    
        @Override
        protected Filter[] getServletFilters() {
            CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
            characterEncodingFilter.setEncoding("UTF-8");
            characterEncodingFilter.setForceEncoding(true);
            return new Filter[] {characterEncodingFilter};
        }
    
    }

此时，有3个方法是必须实现的，一个返回Spring容器配置类，一个返回SpringMVC容器的配置类，一个返回Servlet根路径，也就是接受Http请求的根路径。有很多配置是有默认值的，比如Servlet名称，是否支持异步等，我们也可以通过重写相应方法来自定义配置，感兴趣的可以自行查看这几个类的内部逻辑。当这几个类的最顶层的AbstractContextLoaderInitializer的onStartup方法执行时，我们的所有配置均能发生作用，注册了Spring容器和SpringMVC容器，当然还未初始化。

**当onStartup方法执行后，我们向ServletContext内注册了一个Listener，ContextLoaderListener，将Spring容器配置类设置到了Listener的属性中，tomcat过后会启动整个Listener，执行其contextInitialized方法，方法内初始化Spring容器；向ServletContext内注册了一个Servlet，FrameworkServlet，将SpringMVC容器的配置类设置到其属性中，在ServletContext执行完Listener的contextInitialized方法后执行Servlet的init方法，在此方法中初始化SpringMVC容器**。

当然以上只是配置ssm整合框架的启动类，如何配置Spring，SpringMVC，Mybatis是我们接下来要讲的。

**第一部分：配置Spring**

我们先看Spring容器的配置文件:

// @ImportResource(locations = {"classpath:com/bob/config/servlet-config.xml"})
    // @PropertySource(value = "classpath:com/bob/config/log/log4j.properties", ignoreResourceNotFound =true)
    /*@ComponentScan(basePackages = { "com.bob.config.root" }, excludeFilters = { @Filter(type = FilterType.ANNOTATION, classes = { UserEnv.class }), @Filter(type = FilterType.REGEX, pattern = { "com.bob.config.root" }) })*/
    @Configuration
    @EnableAsync
    @ComponentScan(basePackages = "com.bob.config.root")
    @Import({ DataAccessContextConfig.class, RedisCacheContextConfig.class })
    @ImportedBeanRegistry(value = "lanboal", telephone = "18758107760")
    public class RootContextConfig { 
    
        @Bean
        public ConversionService conversionService() {
            GenericConversionService conversionService = new GenericConversionService();
            conversionService.addConverter(new String2DateConverter());
            return conversionService;
        }
    
        /* 配置线程池 * * {@linkplain ThreadPoolExecutor#execute(Runnable)} * * @return */
        @Bean
        public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(10); // 线程池维护线程的最少数量
            executor.setMaxPoolSize(20); // 线程池维护线程的最大数量
            executor.setKeepAliveSeconds(300); // 空闲线程的最长保留时间,超过此时间空闲线程会被回收
            executor.setQueueCapacity(30); // 线程池所使用的缓冲队列
            executor.setThreadNamePrefix("Spring-ThreadPool#");
            // rejection-policy：当线程池线程已达到最大值且任务队列也满了的情况下，如何处理新任务
            // CALLER_RUNS：这个策略重试添加当前的任务，他会自动重复调用 execute() 方法，直到成功
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            return executor;
        }
    
        // @Bean,仅仅是为了演示方法可带参数，Spring解析是会按照@Autowired的形式将合适的Bean注入此参数，然后执行此方法
        public MethodInvokingJobDetailFactoryBean taskInfo(QuartzTaskExample quartzTaskExample) {
            MethodInvokingJobDetailFactoryBean taskInfo = new MethodInvokingJobDetailFactoryBean();
            taskInfo.setTargetObject(quartzTaskExample);
            taskInfo.setTargetMethod("execute");
            return taskInfo;
        }
    
    }

在Spring容器配置类上，最好标识一个@Configuration注解，来指明这是一个配置类，不标也不会有太多问题。最重要的是@ComponentScan，要扫描Spring容器内的相关Bean，但是**最好不要扫描到和Http请求相关的Bean**，比如Controller等，那些最好放在SpringMVC容器中，同时在Spring容器内的这些Bean，不要饮用到那些属于SpringMVC容器中的Bean，否则会报错，因为此时SpringMVC容器还未初始化，那些Bean还不存在。可以用@ImportResource来引入容器配置文件，可以用@PropertySource来引入properties文件，可以用@Bean标识方法的形式来定义Bean，方法的返回值就是Bean的类型，方法名称就是Bean的名称，和通过扫描得到的Bean同样效果。还可以通过@Import来引入Bean，我们的Mybatis就是通过此形式引入的。

**第二部分：配置Mybatis**

我们在Spring容器配置类上通过@Import的形式引入了Mybatis的配置类，也就是说Mybatis的相关Bean最终存放在Spring容器中。

@Configuration
    @MapperScan("com.bob.mvc.mapper")
    @EnableTransactionManagement(proxyTargetClass = true)
    public class DataAccessContextConfig { 
    
        private static final String driverClassName = "com.mysql.jdbc.Driver";
        private static final String username = "root";
        private static final String password = "lanboal";
        // MySQL的JDBC URL编写方式：jdbc:mysql://主机名称：连接端口/数据库的名称?参数=值
        // 避免中文乱码要指定useUnicode和characterEncoding
        // 执行数据库操作之前要在数据库管理系统上创建一个数据库，名字自己定，
        // 下面语句之前就要先创建project数据库
        private static final String url = "jdbc:mysql://localhost:3306/project?useUnicode=true&characterEncoding=UTF8&useSSL=false";
    
        @Bean(destroyMethod = "close")
        public DataSource dataSource() {
            BasicDataSource dataSource = new BasicDataSource();
            dataSource.setDriverClassName(driverClassName);
            dataSource.addConnectionProperty("useInformationSchema","true"); //针对mysql获取字段注释
            //dataSource.addConnectionProperty("remarksReporting","true"); 针对oracle获取字段注释
            dataSource.setUrl(url);
            dataSource.setUsername(username);
            dataSource.setPassword(password);
            dataSource.setMaxTotal(50);
            dataSource.setMinIdle(5);
            dataSource.setMaxIdle(10);
            return dataSource;
        }
    
        @Bean
        public DataSourceTransactionManager txManager(DataSource dataSource) {
            return new DataSourceTransactionManager(dataSource);
        }
    
        @Bean
        public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSource);
            // 配置MapperConfig
            org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
    
            //当数据库集群时,配置多个数据源,通过设置不同的DatebaseId来区分数据源,同时sql语句中通过DatabaseId来指定匹配哪个数据源
            //configuration.setDatabaseId("Mysql-1");
    
            //设置Mybatis的SQL执行器的使用方式: 执行器重用
            //configuration.setDefaultExecutorType(ExecutorType.REUSE);
    
            // 这个配置使全局的映射器启用或禁用缓存
            configuration.setCacheEnabled(true);
            // 允许 JDBC 支持生成的键，需要适合的驱动（如MySQL，SQL Server，Sybase ASE）。
            // 如果设置为 true 则这个设置强制生成的键被使用，尽管一些驱动拒绝兼容但仍然有效（比如 Derby）。
            // 但是在 Oracle 中一般不需要它，而且容易带来其它问题，比如对创建同义词DBLINK表插入时发生以下错误：
            // "ORA-22816: unsupported feature with RETURNING clause" 在 Oracle
            // 中应明确使用 selectKey 方法
            configuration.setUseGeneratedKeys(false);
            // 配置默认的执行器。SIMPLE 执行器没有什么特别之处；REUSE 执行器重用预处理语句；BATCH 执行器重用语句和批量更新
            configuration.setDefaultExecutorType(ExecutorType.REUSE);
            // 全局启用或禁用延迟加载，禁用时所有关联对象都会即时加载
            configuration.setLazyLoadingEnabled(false);
            // 设置SQL语句执行超时时间缺省值，具体SQL语句仍可以单独设置
            configuration.setDefaultStatementTimeout(5000);
            sqlSessionFactoryBean.setConfiguration(configuration);
            // 匹配多个 MapperConfig.xml, 使用mappingLocation属性
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath*:com/bob/**/*Mapper.xml"));
            return sqlSessionFactoryBean.getObject();
        }
    }

通过@MapperScan指明要扫描的Mapper接口；通过@EnableTransactionManagement的形式声明支持事务；通过@Bean的形式定义数据源，事务管理和sqlSessionFactory。在sqlSessionFactory指定需要加载的sql xml文件。mybatis配置文件加载时就会针对那些mapper接口使用cglib生成代理实现类。

**第三部分：配置SpringMVC**

配置SpringMVC框架有一个很重要的注解，@EnableWebMvc，他的作用类似配置文件形式的

<mvc：annotation-griven />

帮我们配置了SpringMVC内很多重要的组件。@EnableWebMvc注解上有@Import注解，引入了DelegatingWebMvcConfiguration，其父类是WebMvcConfigurationSupport，在这类里有很多@Bean标识的方法， 在解析时会生成很多MVC框架内的组件，省了我们很多的功夫。

同时有一个很重要的配置类WebMvcConfigurerAdapter，我们继承这个类，重写那些想要配置的方法。

@Configuration
    @EnableAsync
    @EnableWebMvc
    @ComponentScan(basePackages = {
       "com.bob.mvc"}, basePackageClasses = {MvcContextConfig.class}, excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = {MvcContextScanExcludeFilter.class})})
    @EnableAspectJAutoProxy(proxyTargetClass = true)
    @Import({AppUserContextConfig.class, TimerContextConfig.class, KafkaContextConfig.class})
    public class MvcContextConfig extends WebMvcConfigurerAdapter { 
    
        final static Logger LOGGER = LoggerFactory.getLogger(MvcContextConfig.class);
    
        @Autowired
        private ThreadPoolTaskExecutor threadPoolTaskExecutor;
    
        @Bean
        public ViewResolver viewResolver() {
            InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
            viewResolver.setViewClass(JstlView.class);
            viewResolver.setSuffix(".jsp");
            return viewResolver;
        }
    
        /** * 定义文件上传的处理器 * * @return */
        @Bean("multipartResolver")
        public CommonsMultipartResolver commonsMultipartResolver() {
            CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
            multipartResolver.setMaxUploadSize(10 * 1024 * 1024);
            return multipartResolver;
        }
    
        @Override
        public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
            StringHttpMessageConverter stringConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
            stringConverter.setWriteAcceptCharset(false);
            converters.add(stringConverter);
            converters.add(new ByteArrayHttpMessageConverter());
            converters.add(new ResourceHttpMessageConverter());
            converters.add(new MappingJackson2HttpMessageConverter());
            converters.add(new MappingJackson2XmlHttpMessageConverter());
        }
    
        @Override
        public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
            configurer.useJaf(false).favorPathExtension(false).favorParameter(true).parameterName("mediaType")
                .ignoreAcceptHeader(true).defaultContentType(MediaType.APPLICATION_JSON);
        }
    
        @Override
        public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
            configurer.enable();
        }
    
        @Override
        public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/**").allowedOrigins("*").allowCredentials(true).allowedMethods("GET", "POST", "DELETE", "PUT").maxAge(3600);
    
        }
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            LoginInterceptor intcep = new LoginInterceptor();
            registry.addInterceptor(new MappedInterceptor(intcep.getIncludePatterns(), intcep.getExcludePatterns(), intcep));
        }
    
        @Override
        public Validator getValidator() {
            LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
            validator.setProviderClass(HibernateValidator.class);
            ReloadableResourceBundleMessageSource messageResource = new ReloadableResourceBundleMessageSource();
            messageResource.setBasenames("classpath:com/bob/validation/ValidationMessages");
            validator.setValidationMessageSource(messageResource);
            return validator;
        }
    
        @Override
        public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
            exceptionResolvers.add(new CustomizedExceptionResolver());
        }
    
        @Override
        public void addFormatters(FormatterRegistry registry) {
            registry.addFormatter(new StudentFormatter());
        }
    
        @Override
        public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
            configurer.setDefaultTimeout(5 * 1000);
            configurer.setTaskExecutor(threadPoolTaskExecutor);
            configurer.registerCallableInterceptors(new AsyncCallableInterceptor());
            configurer.registerDeferredResultInterceptors(new AsyncDeferredResultInterceptor());
        }
    
    }

我们通过重写WebMvcConfigurerAdapter 的方法做的配置，在WebMvcConfigurationSupport的@Bean的方法执行时会用上，感兴趣可以自行查看@Bean方法的执行逻辑。

**Spring容器在初始化后，会被设置为SpringMVC容器的父容器**，也就是说SpringMVC内可以获取Spring容器的Bean，Spring容器不能获取SpringMVC容器内的Bean。

当然WebMvcConfigurerAdapter 还有很多可以重写的方法， 可以做很多其他的配置，感兴趣的可以自行查看其代码。每个配置的含义可以百度，都很好理解的。

经过以上步骤，java形式的ssm框架整合就已经完成了，很多其他的框架也可以使用java形式来配置，比如kafka，可以使用@EnableKafka的形式来引入，schedule可以使用@EnableScheduling引入等等。使用java形式来配置是一个大势，希望这篇博客能对你有所启发。

[SouthEast]: /images/20220606/b7b1232af35c4391a59119cc4ca0db86.png