SSM和Spring Boot常用配置比较

<!-- 加密后配置自己写的解析文件 -->
<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>

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;
}
}

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

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;
}
}

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

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

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;
} }

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;
} }

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

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);
}
}

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

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");
}
}