java项目从SSM向SrpingBoot迁移教程，吐血一步一步整理，第一次弄真的踩了好多坑

最新推荐文章于 2023-10-31 13:54:36 发布

IDEA_TEYU_1112

最新推荐文章于 2023-10-31 13:54:36 发布

阅读量1.1k

点赞数 1

分类专栏：项目实战文章标签： java

本文链接：https://blog.csdn.net/qq_41901915/article/details/105659453

版权

项目实战专栏收录该内容

16 篇文章 0 订阅

订阅专栏

七前端页面的迁移直接复制过来，再配置一下路径就好了

一下载spring tool suite

1.1下载spring tool suite，选择下面一个匹配的并下载，我这里用的是windows，下载地址https://spring.io/tools

1.2 下载完毕后，运行然后会生成一个文件夹

1.3 然后里面会有这个程序的快捷方式，运行这个快捷方式就会进入到这个构建工具当中

二项目的生成与初步测试

2.1 在spring的官网生成一个项目，你可以根据自己的需要选择相应的内容，,https://start.spring.io/

2.2 在打开项目之前，先进入.setting文件中修改一下版本，修改org.eclipse.wst.common.project.facet.core文件，修改为

<?xml version="1.0" encoding="UTF-8"?>
<faceted-project>
  <fixed facet="wst.jsdt.web"/>
  <installed facet="java" version="1.8"/>
  <installed facet="wst.jsdt.web" version="1.0"/>
  <installed facet="jst.web" version="3.1"/>
</faceted-project>

因为这个地方有一个BUG，如果直接去下面这个页面是修改不了的

这个配置文件修改的就是dynamic web module的版本

2.3 打开spring tool suite并导入在官网生成的项目，选择刚才的路径，并添加完成

2.4构建完成的目录结构

2.5 插入一个大坑，就是Source folder is not a Java project.，这是由于没有勾选dynamic web module，勾选，并重新启动软件，注意！！！这里不是update maven，而且你在已经打开项目的时候，去修改.setting里面的那个3.1版本配置，maven update它又会将这个3.1重新更新为4，所以最好重启一下软件。

2.6 插入一个大坑，看一下jre和jdk的版本是不是之前的，版本不一样的话也会发生错误，这里好好确认一下。

2.7 插入一个大坑，一定要配置好maven的这两个

配置过程，首先下载maven http://maven.apache.org/download.cgi

然后解压到相应的文件夹下，再进行配置相应的路径就可以了。

2.8 插入一个巨大大大大大大坑，spring tool suite这个软件是有内嵌的tomcat的，所以我们不需要额外配置相应的tomcat，只需要到下面这个类中，右键，run as ，java application就可以了（当时自己傻乎乎的像eclipse一样配置了一个额外的tomcat8，然后报错，网上说用tomcat8.5就好了，我就下载了tomcat8.5，然后还是报错，服务器不能运行，原来它有自己的内嵌tomcat啊，啊啊啊），当然，你像下面这样直接运行是不好用的，你需要再pom文件中将mybatis的依赖先注释掉，现在还有没配置相关的内容，spring一定会报错的。

2.9 初步测试，创建一个hello.java，如下，代码也给你写好了

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Hello {
	@RequestMapping(value = "/hello", method = RequestMethod.GET)
	public String hello() {
		//返回Hello SpringBoot!
		return "Hello SpringBoot!";
	}
}

2.10 像上面提到的那样，开启项目

2.10 在浏览器中测试，刚才我设置的映射是/hello

这样一个项目的初步创建就完成了，中间的时候真的踩了好多坑，浪费了好多时间，一定要有耐心，并且一定要仔细才行啊，好的开始是成功的一半，这里仅仅是初步创建，重头戏还在后面，那么整个项目是如何迁移的呢，不用担心，在后面我会写一些springboot的知识，以及注解，还有就是详细的图文迁移过程。后面的迁移主要包含dao的迁移，service的迁移，web的迁移，前端的迁移，验证码的迁移，拦截器的迁移等等，当然有时候你的项目里还有其他的一些内容可以去迁移。

三. pom.xml文件的迁移

3.1 将原来spring的相关依赖删去，springboot已经封装好了。下面是删掉的部分

<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<!-- 2)这个jar 文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean 以及进行Inversion of Control 
		/ Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI 支持，引入spring-core.jar 
		及spring-beans.jar 文件就可以了。 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-beans</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<!-- 3)这个jar 文件为Spring 核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI 
		所需的全部类，instrumentation组件以及校验Validation 方面的相关类。 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<!-- 4) 这个jar 文件包含对Spring 对JDBC 数据访问进行封装的所有类。 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-jdbc</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<!-- 5) 为JDBC、Hibernate、JDO、JPA等提供的一致的声明式和编程式事务管理。 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-tx</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<!-- 6)Spring web 包含Web应用开发时，用到Spring框架时所需的核心类，包括自动载入WebApplicationContext特性的类、Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-web</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<!-- 7)包含SpringMVC框架相关的所有类。 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-webmvc</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<!-- 8)Spring test 对JUNIT等测试框架的简单封装 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>${spring.version}</version>
		<scope>test</scope>
	</dependency>

3.2 将junit依赖去掉，因为springboot已经有了相关测试类的东西，下面是删掉的部分

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

3.3 将mybatis的相关部分干掉，因为我在最开始的时候引入了mybatis依赖了，下面是删掉的部分

<!-- DAO: MyBatis -->
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.5.1</version>
	</dependency>
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis-spring</artifactId>
		<version>2.0.1</version>
	</dependency>

4.4 将剩余的依赖复制到新的项目的pom文件的依赖中，并把刚才的mybatis依赖的注释去掉，下面是springboot的整合好的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.2.6.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.imooc</groupId>
	<artifactId>o2o</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<name>o2o</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		
			<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>1.2.3</version>
		</dependency>
		<!-- Spring -->
		<!-- 1)包含Spring 框架基本的核心工具类。Spring 其它组件要都要使用到这个包里的类，是其它组件的基本核心 -->
		
		<!-- Servlet web -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>4.0.1</version>
		</dependency>
		<!-- json解析 -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.9.9</version>
		</dependency>
		<!-- Map工具类 对标准java Collection的扩展 spring-core.jar需commons-collections.jar -->
		<dependency>
			<groupId>commons-collections</groupId>
			<artifactId>commons-collections</artifactId>
			<version>3.2.2</version>
		</dependency>
		
		<!-- 数据库 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>8.0.16</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
		<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.5.4</version>
		</dependency>
	
		<!-- 图片处理 -->
		<!-- https://mvnrepository.com/artifact/net.coobird/thumbnailator -->
		<dependency>
			<groupId>net.coobird</groupId>
			<artifactId>thumbnailator</artifactId>
			<version>0.4.8</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.github.penggle/kaptcha -->
		<dependency>
			<groupId>com.github.penggle</groupId>
			<artifactId>kaptcha</artifactId>
			<version>2.3.2</version>
		</dependency>
		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>1.3.2</version>
		</dependency>
		<!-- redis客户端:Jedis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.1.2</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

如果粘贴过来之后，某些版本标记黄色了，可能是与springboot的里jar包的版本冲突，可以把版本信息去掉。

四 Dao层的迁移

主要包含两大部分，配置的迁移和普通类的迁移

4.1 application.properties感觉是一个变量库，像是一个key-value，然后我们在之后配置的时候通过@value进行调用，后面会提到。先来简单看一下这个application.properties

server.port=8080
#加入/o2o前缀
server.servlet.context-path=/o2o

#DataSource
#数据库驱动
jdbc.driver=com.mysql.cj.jdbc.Driver
#数据库链接
jdbc.url=jdbc:mysql://106.13.78.180:3306/o2o?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
#数据库用户名（已加密）
jdbc.username=WnplV/ietfQ=
#数据库密码（已加密）
jdbc.password=RxQNfAQRZdFbfLs72BFqeQ==

#Mybatis
mybatis_config_file=mybatis-config.xml
mapper_path=/mapper/**.xml
type_alias_package=com.imooc.entity

4.2 springboot是尽量去除XML代码，然后以代码的形式进行配置，所以最后会有若干个对应的class文件，用以代替XML配置文件

4.3 首先来看一下之前的dao配置文件都有什么，然后再看看一个一个改成什么。既然是项目迁移，我想大家应该都有原来的文件，我就不在这里献丑了，直接说了。

第一个，jdbc.properties文件，主要配置与mysql的连接，然后里面的内容会在datasource中得到调用，以${jdbc.driver}的形式，这一部分直接迁移到application.properties文件当中

第二个，datasource，这一部分会创建类来进行配置，如下：

这里面一共有四个标签值得注意

@Configuration这个标签表示它是一个配置，这个配置也会自动写入到spring容器当中

@MapperScan("com.imooc.o2o.dao")这个标签扫描的是dao相关的包

@Value("${jdbc.driver}")这个标签刚才提到了，是从application.properties属性文件中获取相应的内容

@Bean(name = "dataSource")这个注明这个dataSource也是一个bean生成之后也要写入到spring容器当中

然后其他的操作就是配置相应的dataSource的属性了

package com.imooc.o2o.config.dao;

import java.beans.PropertyVetoException;

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 com.imooc.o2o.util.DESUtil;
import com.mchange.v2.c3p0.ComboPooledDataSource;

/**
 * 配置datasource到ioc容器里面
 * 
 * @author xiangze
 *
 */
@Configuration
// 配置mybatis mapper的扫描路径
@MapperScan("com.imooc.o2o.dao")
public class DataSourceConfiguration {
	@Value("${jdbc.driver}")
	private String jdbcDriver;
	@Value("${jdbc.url}")
	private String jdbcUrl;
	@Value("${jdbc.username}")
	private String jdbcUsername;
	@Value("${jdbc.password}")
	private String jdbcPassword;

	/**
	 * 生成与spring-dao.xml对应的bean dataSource
	 * 
	 * @return
	 * @throws PropertyVetoException
	 */
	@Bean(name = "dataSource")
	public ComboPooledDataSource createDataSource() throws PropertyVetoException {
		// 生成datasource实例
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		// 跟配置文件一样设置以下信息
		// 驱动
		dataSource.setDriverClass(jdbcDriver);
		// 数据库连接URL
		dataSource.setJdbcUrl(jdbcUrl);
		// 设置用户名
		dataSource.setUser(DESUtil.getDecryptString(jdbcUsername));
		// 设置用户密码
		dataSource.setPassword(DESUtil.getDecryptString(jdbcPassword));
		// 配置c3p0连接池的私有属性
		// 连接池最大线程数
		dataSource.setMaxPoolSize(30);
		// 连接池最小线程数
		dataSource.setMinPoolSize(10);
		dataSource.setInitialPoolSize(10);
		// 关闭连接后不自动commit
		dataSource.setAutoCommitOnClose(false);
		// 连接超时时间
		dataSource.setCheckoutTimeout(10000);
		// 连接失败重试次数
		dataSource.setAcquireRetryAttempts(2);
		return dataSource;
	}

}

第三个，sqlSessionFactory，这个也会以类的形式进行配置，如下：

同样的，这里面首先有一个configuration，然后通过@value进行调用参数，这些参数在总配置文件当中

mybatis_config_file=mybatis-config.xml
mapper_path=/mapper/**.xml
type_alias_package=com.imooc.entity

其实也就是扫描相应的依赖的mybatis-config.xml配置文件

扫描相应的dao层开发mapper文件

还有相应的实体类bean，也就是什么商店，人，区域，类别这种与数据库对应的实体类

package com.imooc.o2o.config.dao;

import java.io.IOException;

import javax.sql.DataSource;

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;

@Configuration
public class SessionFactoryConfiguration {
	// mybatis-config.xml配置文件的路径
	private static String mybatisConfigFile;

	@Value("${mybatis_config_file}")
	public void setMybatisConfigFile(String mybatisConfigFile) {
		SessionFactoryConfiguration.mybatisConfigFile = mybatisConfigFile;
	}

	// mybatis mapper文件所在路径
	private static String mapperPath;

	@Value("${mapper_path}")
	public void setMapperPath(String mapperPath) {
		SessionFactoryConfiguration.mapperPath = mapperPath;
	}

	// 实体类所在的package
	@Value("${type_alias_package}")
	private String typeAliasPackage;

	@Autowired
	private DataSource dataSource;

	/**
	 * 创建sqlSessionFactoryBean 实例 并且设置configtion 设置mapper 映射路径 设置datasource数据源
	 * 
	 * @return
	 * @throws IOException
	 */
	@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;
	}

}

4.4 将相关的dao，mapper，实体类的包迁移过来

五 service的迁移

5.1 还是上面的套路，先看看service层原来有什么，然后再看看把它改成什么。

第一个，扫描相应的service包，这个在O2oApplication.java主类中有@SpringBootApplication注解，这个注解就是进行全体扫描，所以原来的扫描service包那个部分就可以不要了。

第二个，事务的管理，transactionManager，这里采用类的方式进行配置，如下：

@EnableTransactionManagement开启事务支持后在Service方法上添加注解 @Transactional 便可，这个事务配置还是比较简单的。

package com.imooc.o2o.config.service;

import javax.sql.DataSource;

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;

/**
 * 对标spring-service里面的transactionManager
 * 继承TransactionManagementConfigurer是因为开启annotation-driven
 * 
 * @author xiangze
 *
 */
@Configuration
// 首先使用注解 @EnableTransactionManagement 开启事务支持后
// 在Service方法上添加注解 @Transactional 便可
@EnableTransactionManagement
public class TransactionManagementConfiguration implements TransactionManagementConfigurer {

	@Autowired
	// 注入DataSourceConfiguration里边的dataSource,通过createDataSource()获取
	private DataSource dataSource;

	@Override
	/**
	 * 关于事务管理，需要返回PlatformTransactionManager的实现
	 */
	public PlatformTransactionManager annotationDrivenTransactionManager() {
		return new DataSourceTransactionManager(dataSource);
	}

}

第三个，redis，如果你的项目中存在redis的话，这个地方也需要redis的迁移，因为redis是在service层进行应用的，这个地方本文就先不说了，可以参考别的文章。

5.2 将相应的service，util等相关的包，全部复制过去就可以了。

5.3 这里面插入一条内容，在SSM的时候，利用junit进行测试，@Test标签，再加入相应的包的支持就可以进行单元测试了。在springboot里变得更加简单，只要用两个标签标记一下就好了，一个是@RunWith，另一个是@SpringBootTest

六 web层的迁移

6.1 还是先看看原来有什么，然后改为什么，web层的配置主要通过一个类文件来迁移。

第一个，原来有springmvc注解，现在用@EnableWebMvc等价于<mvc:annotation-driven/>
第二个，静态资源的配置，文件上传解析器的配置，视图解析器的配置，拦截器的配置，验证码的配置都通过下面的文件的相应方法进行了配置。

package com.imooc.o2o.config.web;

import javax.servlet.ServletException;

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.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

import com.google.code.kaptcha.servlet.KaptchaServlet;
import com.imooc.o2o.interceptor.shopadmin.ShopLoginInterceptor;
import com.imooc.o2o.interceptor.shopadmin.ShopPermissionInterceptor;
import com.imooc.o2o.interceptor.superadmin.SuperAdminLoginInterceptor;

/**
 * 开启Mvc,自动注入spring容器。 WebMvcConfigurerAdapter：配置视图解析器
 * 当一个类实现了这个接口（ApplicationContextAware）之后，这个类就可以方便获得ApplicationContext中的所有bean
 * 
 * @author xiangze
 *
 */
@Configuration
// 等价于<mvc:annotation-driven/>
@EnableWebMvc
public class MvcConfiguration implements WebMvcConfigurer, ApplicationContextAware {
	// Spring容器
	private ApplicationContext applicationContext;

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		this.applicationContext = applicationContext;
	}

	/**
	 * 静态资源配置
	 * 
	 * @param registry
	 */
	@Override
	public void addResourceHandlers(ResourceHandlerRegistry registry) {
		// registry.addResourceHandler("/resources/**").addResourceLocations("classpath:/resources/");
		registry.addResourceHandler("/upload/**").addResourceLocations("file:/Users/baidu/work/image/upload/");
	}

	/**
	 * 定义默认的请求处理器
	 */
	@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 createMultipartResolver() {
		CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
		multipartResolver.setDefaultEncoding("utf-8");
		// 1024 * 1024 * 20 = 20M
		multipartResolver.setMaxUploadSize(20971520);
		multipartResolver.setMaxInMemorySize(20971520);
		return multipartResolver;
	}

	@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
	 */
	@Bean
	public ServletRegistrationBean<KaptchaServlet> servletRegistrationBean() throws ServletException {
		ServletRegistrationBean<KaptchaServlet> servlet = new ServletRegistrationBean<KaptchaServlet>(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;
	}

	/**
	 * 添加拦截器配置
	 */
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		/** 店家管理系统拦截部分 **/
		String interceptPath = "/shopadmin/**";
		// 注册拦截器
		InterceptorRegistration loginIR = registry.addInterceptor(new ShopLoginInterceptor());
		// 配置拦截的路径
		loginIR.addPathPatterns(interceptPath);
		/** shopauthmanagement page **/
		loginIR.excludePathPatterns("/shopadmin/addshopauthmap");
		/** scan **/
		loginIR.excludePathPatterns("/shopadmin/adduserproductmap");
		loginIR.excludePathPatterns("/shopadmin/exchangeaward");
		// 还可以注册其它的拦截器
		InterceptorRegistration permissionIR = registry.addInterceptor(new ShopPermissionInterceptor());
		// 配置拦截的路径
		permissionIR.addPathPatterns(interceptPath);
		// 配置不拦截的路径
		/** shoplist page **/
		permissionIR.excludePathPatterns("/shopadmin/shoplist");
		permissionIR.excludePathPatterns("/shopadmin/getshoplist");
		/** shopregister page **/
		permissionIR.excludePathPatterns("/shopadmin/getshopinitinfo");
		permissionIR.excludePathPatterns("/shopadmin/registershop");
		permissionIR.excludePathPatterns("/shopadmin/shopoperation");
		/** shopmanage page **/
		permissionIR.excludePathPatterns("/shopadmin/shopmanagement");
		permissionIR.excludePathPatterns("/shopadmin/getshopmanagementinfo");
		/** shopauthmanagement page **/
		permissionIR.excludePathPatterns("/shopadmin/addshopauthmap");
		/** scan **/
		permissionIR.excludePathPatterns("/shopadmin/adduserproductmap");
		permissionIR.excludePathPatterns("/shopadmin/exchangeaward");
		/** 超级管理员系统拦截部分 **/
		interceptPath = "/superadmin/**";
		// 注册拦截器
		InterceptorRegistration superadminloginIR = registry.addInterceptor(new SuperAdminLoginInterceptor());
		// 配置拦截的路径
		superadminloginIR.addPathPatterns(interceptPath);
		superadminloginIR.excludePathPatterns("/superadmin/login");
		superadminloginIR.excludePathPatterns("/superadmin/logincheck");
		superadminloginIR.excludePathPatterns("/superadmin/main");
		superadminloginIR.excludePathPatterns("/superadmin/top");
		superadminloginIR.excludePathPatterns("/superadmin/clearcache4area");
		superadminloginIR.excludePathPatterns("/superadmin/clearcache4headline");
		superadminloginIR.excludePathPatterns("/superadmin/clearcache4shopcategory");
	}

}

七前端页面的迁移直接复制过来，再配置一下路径就好了

总结，不同的项目应用的技术不同，迁移的难度就不同，本文仅仅介绍了简单的迁移过程，具体的还得针对自己的项目去体会。

关注微信公众号，获取更多java软件开发学习资源，覆盖java基础，android，网络编程，并发编程，mysql，linux，算法，以及C++和python书籍资源。

IDEA_TEYU_1112

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
java项目从SSM向SrpingBoot迁移教程，吐血一步一步整理，第一次弄真的踩了好多坑

一下载spring tool suite1.1下载spring tool suite，选择下面一个匹配的并下载，我这里用的是windows，下载地址https://spring.io/tools1.2 下载完毕后，运行然后会生成一个文件夹1.3 然后里面会有这个程序的快捷方式，运行这个快捷方式就会进入到这个构建工具当中二项目的生成与初步测试2.1 在spring...
复制链接

扫一扫