SSM和Spring Boot常用配置比较

一.Dao层相关

　　1.Mysql相关：

　　　　1.1配置DataSource连接池:

　　　　　　（1）SSM配置：

 <!-- 加密后配置自己写的解析文件 -->

     <bean class="com.swpu.o2o.util.EncryptPropertyPlaceholderConfigurer">

         <property name="locations">

             <list>

                 <!-- 需要解密的文件 -->

                 <value>classpath:jdbc.properties</value>

                 <value>classpath:redis.properties</value>

             </list>

         </property>

         <!-- 设置编码为UTF-8 -->

         <property name="fileEncoding" value="UTF-8"></property>

     </bean>

     <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">

         <!-- 配置连接池属性 -->

         <property name="driverClass" value="${jdbc.driver}" />

         <property name="jdbcUrl" value="${jdbc.url}" />

         <property name="user" value="${jdbc.username}" />

         <property name="password" value="${jdbc.password}" />

         <!-- c3p0连接池的私有属性 -->

         <property name="maxPoolSize" value="30" />

         <property name="minPoolSize" value="10" />

         <!-- 关闭连接后不自动commit -->

         <property name="autoCommitOnClose" value="false" />

         <!-- 获取连接超时时间 -->

         <property name="checkoutTimeout" value="10000" />

         <!-- 当获取连接失败重试次数 -->

         <property name="acquireRetryAttempts" value="2" />

     </bean>

　　　　　 （2）Spring Boot配置（写入Bean）

 package com.swpu.o2o.config.dao;

 import com.mchange.v2.c3p0.ComboPooledDataSource;

 import com.swpu.o2o.util.DESUtils;

 import org.mybatis.spring.annotation.MapperScan;

 import org.springframework.beans.factory.annotation.Value;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import java.beans.PropertyVetoException;

 /**

  * 配置dataSource到ioc容器里

  */

 @Configuration

 //配置mybatis mapper扫描路径

 @MapperScan("com.swpu.o2o.dao")

 public class DataSourceConfiguration {

     //通过@Value标签获取application.properties中的配置信息

     @Value("${jdbc.driver}")

     private String jdbcDriver;

     @Value("${jdbc.url}")

     private String jdbcUrl;

     @Value("${jdbc.username}")

     private String jdbcUser;

     @Value("${jdbc.password}")

     private String jdbcPassword;

     /**

      * 生成与与spring-dao.xml对应的bean dataSource

      */

     @Bean(name="dataSource")

     public ComboPooledDataSource createDataSource() throws PropertyVetoException {

         //生成dataSource实例

         ComboPooledDataSource dataSource=new ComboPooledDataSource();

         //配置相关信息（和配置文件一样）

         //驱动(强制异常处理，抛出去)

         dataSource.setDriverClass(jdbcDriver);

         //数据库连接url

         dataSource.setJdbcUrl(jdbcUrl);

         //用户名(解密)

         dataSource.setUser(DESUtils.getDecryptString(jdbcUser));

         //密码

         dataSource.setPassword(DESUtils.getDecryptString(jdbcPassword));

         return dataSource;

     }

 }

　　　　1.2创建SqlSessionFactoryBean实例（设置设置mybatis configuration扫描路径,mapper映射路径，配置扫描Dao接口包等）

　　　　　　（1）SSM配置:

 <!-- 3.配置SqlSessionFactory对象 -->

     <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">

         <!-- 注入数据库连接池 -->

         <property name="dataSource" ref="dataSource" />

         <!-- 配置MyBaties全局配置文件:mybatis-config.xml -->

         <property name="configLocation" value="classpath:mybatis-config.xml" />

         <!-- 扫描entity包 使用别名 -->

         <property name="typeAliasesPackage" value="com.swpu.o2o.entity" />

         <!-- 扫描sql配置文件:mapper需要的xml文件 -->

         <property name="mapperLocations" value="classpath:mapper/*.xml" />

     </bean>

     <!-- 4.配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->

     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

         <!-- 注入sqlSessionFactory -->

         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />

         <!-- 给出需要扫描Dao接口包 -->

         <property name="basePackage" value="com.swpu.o2o.dao" />

     </bean>

　　　　　　（2）Spring Boot配置:

 package com.swpu.o2o.config.dao;

 import org.mybatis.spring.SqlSessionFactoryBean;

 import org.springframework.beans.factory.annotation.Autowired;

 import org.springframework.beans.factory.annotation.Value;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.core.io.ClassPathResource;

 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

 import org.springframework.core.io.support.ResourcePatternResolver;

 import javax.sql.DataSource;

 import java.io.IOException;

 @Configuration

 public class SessionFactoryConfiguration {

     //mybatis-config.xml配置文件路径

     //注意:静态(static)的变量不能直接通过@Value获取，可以通过set方法

     private static String mybatisConfigFile;

     //mybatis mapper文件所在路径

     private static String mapperPath;

     @Value("${mybatis_config_file}")

     public void setMybatisConfigFile(String mybatisConfigFile) {

         SessionFactoryConfiguration.mybatisConfigFile = mybatisConfigFile;

     }

     @Value("${mapper_path}")

     public void setMapperPath(String mapperPath) {

         SessionFactoryConfiguration.mapperPath = mapperPath;

     }

     //实体类所在package

     @Value("${type_alias_package}")

     private String typeAliasPackage;

     @Autowired

     private DataSource dataSource;

     /**

      * 创建SqlSessionFactoryBean实例，并且设置mapper映射路径

      * 设置dataSource数据源

      */

     @Bean(name = "sqlSessionFactory")

     public SqlSessionFactoryBean createSqlSessionFactoryBean() throws IOException {

         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();

         //设置mybatis configuration扫描路径

         sqlSessionFactoryBean.setConfigLocation(new ClassPathResource(mybatisConfigFile));

         //设置mapper 扫描路径

         PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver();

         String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + mapperPath;

         sqlSessionFactoryBean.setMapperLocations(pathMatchingResourcePatternResolver.getResources(packageSearchPath));

         //设置dataSource

         sqlSessionFactoryBean.setDataSource(dataSource);

         //设置typeAlias包扫描路径

         sqlSessionFactoryBean.setTypeAliasesPackage(typeAliasPackage);

         return sqlSessionFactoryBean;

     }

 }

　　　　　　（3）Mybatis配置文件：

 <?xml version="1.0" encoding="UTF-8"?>

 <!DOCTYPE configuration

  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

  "http://mybatis.org/dtd/mybatis-3-config.dtd">

 <configuration>

     <!-- 配置全局属性 -->

     <settings>

         <!-- 使用jdbc的getGeneratedKeys获取数据库自增主键值 -->

         <setting value="true" name="useGeneratedKeys" />

         <!-- 使用列别名替换列名 默认:true -->

         <setting value="true" name="useColumnLabel" />

         <!-- 开启驼峰命名转换:Table{create_time} -> Entity{createTime} -->

         <setting value="true" name="mapUnderscoreToCamelCase" />

         <!-- 打印查询语句 -->

     </settings>

 </configuration>

　　2.Redis:

　　　　(1)SSM配置：

 <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"

     xsi:schemaLocation="http://www.springframework.org/schema/beans

         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

         http://www.springframework.org/schema/context

         http://www.springframework.org/schema/context/spring-context-3.2.xsd">

     <!-- Redis连接池配置 -->

     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">

         <!-- 控制一个pool能分配多少个jedis实例 -->

         <property name="maxTotal" value="${redis.pool.maxActive}" />

         <!-- 连接池中最多空闲多少个maxIdle个连接，这里为20，表示即使没有数据库连接时依然可以保持20空闲的连接，而不被清除，处于待命状态，随时连接 -->

         <property name="maxIdle" value="${redis.pool.maxIdle}" />

         <!-- 最大等待时间，当没有可用连接时，连接池等待连接被归还的最大时间（以毫秒计数），超过时间即抛出异常 -->

         <property name="maxWaitMillis" value="${redis.pool.maxWait}" />

         <!-- 在获取连接时，检查有效性 -->

         <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />

     </bean>

     <!-- 创建Redis连接池，并做相关配置 -->

     <bean id="jedisWritePool" class="com.swpu.o2o.cache.JedisPoolWriper"

         depends-on="jedisPoolConfig">

         <constructor-arg index="0" ref="jedisPoolConfig" />

         <constructor-arg index="1" value="${redis.hostname}" />

         <constructor-arg index="2" value="${redis.port}" type="int" />

     </bean>

     <!-- 创建Redis工具类，封装好Redis的连接以进行相关操作 -->

     <bean id="jedisUtil" class="com.swpu.o2o.cache.JedisUtil"

         scope="singleton">

         <property name="jedisPool">

             <ref bean="jedisWritePool" />

         </property>

     </bean>

     <bean id="jedisKeys" class="com.swpu.o2o.cache.JedisUtil$Keys"

         scope="singleton">

         <constructor-arg ref="jedisUtil"></constructor-arg>

     </bean>

     <bean id="jedisStrings" class="com.swpu.o2o.cache.JedisUtil$Strings"

         scope="singleton">

         <constructor-arg ref="jedisUtil"></constructor-arg>

     </bean>

     <bean id="jedisLists" class="com.swpu.o2o.cache.JedisUtil$Lists"

         scope="singleton">

         <constructor-arg ref="jedisUtil"></constructor-arg>

     </bean>

     <bean id="jedisSets" class="com.swpu.o2o.cache.JedisUtil$Sets"

         scope="singleton">

         <constructor-arg ref="jedisUtil"></constructor-arg>

     </bean>

     <bean id="jedisHash" class="com.swpu.o2o.cache.JedisUtil$Hash"

         scope="singleton">

         <constructor-arg ref="jedisUtil"></constructor-arg>

     </bean>

 </beans>

　　　（2）Spring Boot配置：

 package com.swpu.o2o.config.redis;

 import com.swpu.o2o.cache.JedisPoolWriper;

 import com.swpu.o2o.cache.JedisUtil;

 import org.springframework.beans.factory.annotation.Autowired;

 import org.springframework.beans.factory.annotation.Value;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import redis.clients.jedis.JedisPoolConfig;

 /**

  * 对应spring-redis.xml里的配置

  */

 @Configuration

 public class RedisConfiguration {

     @Value("${redis.hostname}")

     private String hostName;

     @Value("${redis.port}")

     private int port;

     @Value("${redis.pool.maxActive}")

     private int maxTotal;

     @Value("${redis.pool.maxIdle}")

     private int maxIdle;

     @Value("${redis.pool.maxWait}")

     private long maxWaitMillis;

     @Value("${redis.pool.testOnBorrow}")

     private boolean testOnBrrow;

     @Autowired

     private JedisPoolConfig jedisPoolConfig;

     @Autowired

     private JedisPoolWriper jedisWritePool;

     @Autowired

     private JedisUtil jedisUtil;

     /**

      * 创建redis连接池设置

      */

     @Bean(name = "jedisPoolConfig")

     public JedisPoolConfig createJedisPoolConfig() {

         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

         //控制一个pool可分配给多个jedis实例

         jedisPoolConfig.setMaxTotal(maxTotal);

         //连接池中最多空闲maxIdle个连接，这里取值20

         //表示即使没有数据库连接时依然可以保持20空闲的连接，而不清除，随时处于待命的状态

         jedisPoolConfig.setMaxIdle(maxIdle);

         //最大等待时间：当没有可用连接时

         //连接池等待连接被归还的最大时间（以毫秒计数），超过时间则抛出异常

         jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);

         //在获取连接的时候检查有效性

         jedisPoolConfig.setTestOnBorrow(testOnBrrow);

         return jedisPoolConfig;

     }

     /**

      * 创建Redis连接池，并做相关配置

      */

     @Bean(name = "jedisWritePool")

     public JedisPoolWriper createJedisPoolWripper() {

         JedisPoolWriper jedisWritePool = new JedisPoolWriper(jedisPoolConfig, hostName, port);

         return jedisWritePool;

     }

     /**

      * 创建Redis工具类，封装好Redis的连接以进行相关的操作

      */

     @Bean(name = "jedisUtil")

     public JedisUtil createJedisUtil() {

         JedisUtil jedisUtil = new JedisUtil();

         jedisUtil.setJedisPool(jedisWritePool);

         return jedisUtil;

     }

     /**

      * Redis的key操作

      */

     @Bean(name = "jedisKeys")

     public JedisUtil.Keys createJedisKeys() {

         //实例化内部类

         JedisUtil.Keys jedisKeys = jedisUtil.new Keys();

         return jedisKeys;

     }

     /**

      * Redis的String操作

      */

     @Bean(name = "jedisStrings")

     public JedisUtil.Strings createJedisStrings() {

         //实例化内部类

         JedisUtil.Strings jedisStrings = jedisUtil.new Strings();

         return jedisStrings;

     }

     /**

      * Redis的List操作

      */

     @Bean(name = "jedisLists")

     public JedisUtil.Lists createJedisLists() {

         //实例化内部类

         JedisUtil.Lists jedisLists = jedisUtil.new Lists();

         return jedisLists;

     }

     /**

      * Redis的Hash操作

      */

     @Bean(name = "jedisHash")

     public JedisUtil.Hash createJedisHash() {

         //实例化内部类

         JedisUtil.Hash jedisHash = jedisUtil.new Hash();

         return jedisHash;

     }

     /**

      * Redis的sets操作

      */

     @Bean(name = "jedisSets")

     public JedisUtil.Sets createJedisSets() {

         //实例化内部类

         JedisUtil.Sets jedisSets = jedisUtil.new Sets();

         return jedisSets;

     }

 }

　　　　　　JedisPool类:

 package com.swpu.o2o.cache;

 import redis.clients.jedis.JedisPool;

 import redis.clients.jedis.JedisPoolConfig;

 /**

  * 强指定redis的JedisPool接口构造函数，这样才能在centos成功创建jedispool

  *

  * @author xiangze

  *

  */

 public class JedisPoolWriper {

     //连接池对象

     private JedisPool jedisPool;

     public JedisPoolWriper(final JedisPoolConfig poolConfig, final String host,

             final int port) {

         try {

             //通过连接池配置信息，IP，端口构造连接池对象

             jedisPool = new JedisPool(poolConfig, host, port);

         } catch (Exception e) {

             e.printStackTrace();

         }

     }

     //获取redis连接池对象

     public JedisPool getJedisPool() {

         return jedisPool;

     }

     //注入redis连接池对象

     public void setJedisPool(JedisPool jedisPool) {

         this.jedisPool = jedisPool;

     }

 }

二.Service层相关（配置事务管理器，声明式事务）

　　(1)SSM配置：

 <?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:tx="http://www.springframework.org/schema/tx"

     xsi:schemaLocation="http://www.springframework.org/schema/beans

     http://www.springframework.org/schema/beans/spring-beans.xsd

     http://www.springframework.org/schema/context

     http://www.springframework.org/schema/context/spring-context.xsd

     http://www.springframework.org/schema/tx

     http://www.springframework.org/schema/tx/spring-tx.xsd">

     <!-- 扫描service包下所有使用注解的类型 -->

     <context:component-scan base-package="com.swpu.o2o.service" />

     <!-- 配置事务管理器 -->

     <bean id="transactionManager"

         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

         <!-- 注入数据库连接池 -->

         <property name="dataSource" ref="dataSource" />

     </bean>

     <!-- 配置基于注解的声明式事务 -->

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

 </beans>

　　(2)Spring Boot配置：

 package com.swpu.o2o.config.service;

 import org.springframework.beans.factory.annotation.Autowired;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.jdbc.datasource.DataSourceTransactionManager;

 import org.springframework.transaction.PlatformTransactionManager;

 import org.springframework.transaction.annotation.EnableTransactionManagement;

 import org.springframework.transaction.annotation.TransactionManagementConfigurer;

 import javax.sql.DataSource;

 /**

  * 对应spring-service.xml里面的transactionManager

  * 继承transactionManagementConfigurer：不能直接加入Bean，因为开启了annotation-driven

  */

 @Configuration

 //首先使用注解@EnableTransactionManagement开启事务后

 //在Service方法上添加注解@Transactional

 @EnableTransactionManagement

 public class TransactionManageConfiguration implements TransactionManagementConfigurer {

     @Autowired

     //注入DataSourceConfiguration里面的dataSource，通过createDataSource()获取

     private DataSource dataSource;

     @Override

     /**

      * 关于事务处理，需要返回PlatformTransactionManager的实现

      */

     public PlatformTransactionManager annotationDrivenTransactionManager() {

         return new DataSourceTransactionManager(dataSource);

     }

 }

三.Controller层相关

　　配置SpringMVC：

　　　　1.开启SpringMVC注解模式；2.静态资源默认servlet配置；3.定义视图解析器；4.扫描web相关的bean；5.权限拦截器

　　（1）SSM配置：

 <?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:mvc="http://www.springframework.org/schema/mvc"

     xsi:schemaLocation="http://www.springframework.org/schema/beans

     http://www.springframework.org/schema/beans/spring-beans.xsd

     http://www.springframework.org/schema/context

     http://www.springframework.org/schema/context/spring-context.xsd

     http://www.springframework.org/schema/mvc

     http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">

     <!-- 配置SpringMVC -->

     <!-- 1.开启SpringMVC注解模式 -->

     <!-- 简化配置： (1)自动注册DefaultAnootationHandlerMapping,AnotationMethodHandlerAdapter

         (2)提供一些列：数据绑定，数字和日期的format @NumberFormat, @DateTimeFormat, xml,json默认读写支持 -->

     <mvc:annotation-driven />

     <!-- 2.静态资源默认servlet配置 (1)加入对静态资源的处理：js,gif,png (2)允许使用"/"做整体映射 -->

     <mvc:resources mapping="/resources/**" location="/resources/" />

     <mvc:default-servlet-handler />

     <!-- 3.定义视图解析器 -->

     <!-- 定制请求加头加尾 -->

     <bean id="viewResolver"

         class="org.springframework.web.servlet.view.InternalResourceViewResolver">

         <property name="prefix" value="/WEB-INF/html/"></property>

         <property name="suffix" value=".html"></property>

     </bean>

     <bean id="multipartResolver"

         class="org.springframework.web.multipart.commons.CommonsMultipartResolver">

         <!-- 默认编码 -->

         <property name="defaultEncoding" value="utf-8"></property>

         <!-- 上传文件的最大 尺寸（单位是字节） -->

         <!-- 1024*1024*20=20971520 -->

         <property name="maxUploadSize" value="20971520"></property>

         <!-- 允许写在内存中的最大值 -->

         <property name="maxInMemorySize" value="20971520"></property>

     </bean>

     <!-- 4.扫描web相关的bean -->

     <context:component-scan base-package="com.swpu.o2o.web" />

     <!-- 5.权限拦截器 -->

     <mvc:interceptors>

         <!-- 校验是否登录了该管理系统的拦截器 -->

         <mvc:interceptor>

             <!-- 定义拦截的路由，shopadmin包下的所有Controller -->

             <mvc:mapping path="/shopadmin/**" />

             <!-- 拦截方法 -->

             <bean class="com.swpu.o2o.interceptor.shopadmin.ShopLoginInterceptor"

                 id="ShopInterceptor" />

         </mvc:interceptor>

         <!-- 校验是否对该店铺有操作权限的拦截器 -->

         <mvc:interceptor>

             <!-- 需要拦截的接口 -->

             <mvc:mapping path="/shopadmin/**" />

             <!-- shoplist page -->

             <!-- 排除该包下的某些接口不拦截 -->

             <mvc:exclude-mapping path="/shopadmin/shoplist" />

             <mvc:exclude-mapping path="/shopadmin/getshoplist" />

             <!-- shopmanage page -->

             <mvc:exclude-mapping path="/shopadmin/shopmanagement" />

             <mvc:exclude-mapping path="/shopadmin/getshopmanagementinfo" />

             <!-- shopregister page -->

             <mvc:exclude-mapping path="/shopadmin/getshopinitinfo" />

             <mvc:exclude-mapping path="/shopadmin/shopoperation" />

             <mvc:exclude-mapping path="/shop/registershop" />

             <bean class="com.swpu.o2o.interceptor.shopadmin.ShopPermissionInterceptor"

                 id="ShopPermissionInterceptor" />

         </mvc:interceptor>

     </mvc:interceptors>

 </beans>

　　（2）Spring Boot配置：

 package com.swpu.o2o.config.web;

 import com.google.code.kaptcha.servlet.KaptchaServlet;

 import com.swpu.o2o.interceptor.ShopLoginInterceptor;

 import com.swpu.o2o.interceptor.ShopPermissionInterceptor;

 import org.springframework.beans.BeansException;

 import org.springframework.beans.factory.annotation.Value;

 import org.springframework.boot.web.servlet.ServletRegistrationBean;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.ApplicationContextAware;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.web.multipart.commons.CommonsMultipartResolver;

 import org.springframework.web.servlet.ViewResolver;

 import org.springframework.web.servlet.config.annotation.*;

 import org.springframework.web.servlet.view.InternalResourceViewResolver;

 import javax.servlet.ServletException;

 /**

  * 开启Mvc，自动注入spring容器中

  * WebMvcConfigurer：配置视图解析器

  * 当一个类实现了接口WebMvcConfigurer，这个类就能方便的获取里面所有的bean

  */

 @Configuration

 //等价于<mvc:annotation-driven/>,使用Java 注解快捷配置Spring Webmvc

 @EnableWebMvc

 //实现ApplicationContextAware该接口获取Spring容器

 // extends WebMvcConfigurationSupport implements ApplicationContextAware

 public class MvcConfiguration extends WebMvcConfigurerAdapter implements ApplicationContextAware {

     //Spring容器

     private ApplicationContext applicationContext;

     @Override

     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

         this.applicationContext = applicationContext;

     }

     /**

      * 静态资源配置(docBase)

      *

      *

      *  @param registry

      */

     @Override

     public void addResourceHandlers(ResourceHandlerRegistry registry) {

         //拦截/resources下的请求解析到目标路径classpath:/resources

         //classpath表示在项目工程中找，file表示在服务器中找

         registry.addResourceHandler("/upload/**").addResourceLocations("file:D:/Project/image/upload/");

     }

     /**

      * 定义默认的请求处理器

      *

      * @param configurer

      */

     @Override

     public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {

         configurer.enable();

     }

     /**

      * 创建viewResolver

      * @return

      */

     @Bean(name = "viewResolver")

     public ViewResolver createViewResolver() {

         InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();

         //设置spring容器

         //viewResolver.setApplicationContext(this.applicationContext);

         //取消缓存

         viewResolver.setCache(false);

         //设置解析的前缀

         viewResolver.setPrefix("/WEB-INF/html/");

         //设置视图解析的后缀

         viewResolver.setSuffix(".html");

         return viewResolver;

     }

     /**

      * 文件上传解析器

      *

      * @return

      */

     @Bean(name = "multipartResolver")

     public CommonsMultipartResolver commonsMultipartResolver() {

         CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();

         multipartResolver.setDefaultEncoding("utf-8");

         //文件大小1024*1024*20

         multipartResolver.setMaxUploadSize(20971520);

         multipartResolver.setMaxInMemorySize(20971520);

         return multipartResolver;

     }

     //引入验证码kaptcha相关信息

     @Value("${kaptcha.border}")

     private String border;

     @Value("${kaptcha.textproducer.font.color}")

     private String fcolor;

     @Value("${kaptcha.image.width}")

     private String width;

     @Value("${kaptcha.textProducer.char.string}")

     private String cString;

     @Value("${kaptcha.image.height}")

     private String height;

     @Value("${kaptcha.textproducer.font.size}")

     private String fsize;

     @Value("${kaptcha.noise.color}")

     private String nColor;

     @Value("${kaptcha.textproducer.char.length}")

     private String clength;

     @Value("${kaptcha.textproducer.font.names}")

     private String fnames;

     /**

      * web.xml不生效了，在这里配置Kaptcha验证码Servlet

      * @return

      */

     @Bean

     public ServletRegistrationBean servletRegistrationBean() throws ServletException {

         ServletRegistrationBean servlet=new ServletRegistrationBean(new KaptchaServlet(),"/Kaptcha");

         servlet.addInitParameter("kaptcha.border",border);//无边框

         servlet.addInitParameter("kaptcha.textproducer.font.color",fcolor);//字体颜色

         servlet.addInitParameter("kaptcha.image.width",width);//图片宽度

         servlet.addInitParameter("kaptcha.textProducer.char.string",cString);//使用哪些字体

         servlet.addInitParameter("kaptcha.image.height",height);//图片高度

         servlet.addInitParameter("kaptcha.textproducer.font.size",fsize);//字体大小

         servlet.addInitParameter("kaptcha.noise.color",nColor);//干扰线颜色

         servlet.addInitParameter("kaptcha.textproducer.char.length",clength);//字符个数

         servlet.addInitParameter("kaptcha.textproducer.font.names",fnames);//字体

         return servlet;

     }

     /**

      * 拦截器

      * @param registry

      */

     @Override

     public void addInterceptors(InterceptorRegistry registry) {

         String interceptPath="/shopadmin/**";

         //注册拦截器（验证是否登录）

         InterceptorRegistration loginIR=registry.addInterceptor(new ShopLoginInterceptor());

         //配置拦截器路径

         loginIR.addPathPatterns(interceptPath);

         //注册拦截器（验证是否具有权限）

         InterceptorRegistration permissionIR=registry.addInterceptor(new ShopPermissionInterceptor());

         //配置拦截器路径

         permissionIR.addPathPatterns(interceptPath);

         //配置不拦截的路径

         permissionIR.excludePathPatterns("/shopadmin/shoplist");

         permissionIR.excludePathPatterns("/shopadmin/getshoplist");

         permissionIR.excludePathPatterns("/shopadmin/registershop");

         permissionIR.excludePathPatterns("/shopadmin/shopoperation");

         permissionIR.excludePathPatterns("/shopadmin/shopmanagement");

         permissionIR.excludePathPatterns("/shopadmin/getshopmanagementinfo");

     }

 }

　　　注：WebMvcConfigurerAdapter在Spring Boot2.0就已经过时，不推荐使用，可以继承WebMvcConfigurationSupport。该类包含了WebMvcConfigurerAdapter的所有方法。

巴特西

SSM和Spring Boot常用配置比较

一.Dao层相关

1.Mysql相关：

1.1配置DataSource连接池:

1.2创建SqlSessionFactoryBean实例（设置设置mybatis configuration扫描路径,mapper映射路径，配置扫描Dao接口包等）

2.Redis:

(1)SSM配置：

（2）Spring Boot配置：

JedisPool类:

二.Service层相关（配置事务管理器，声明式事务）

(1)SSM配置：

(2)Spring Boot配置：

三.Controller层相关

配置SpringMVC：

（1）SSM配置：

（2）Spring Boot配置：

最新文章

热门文章