SSM框架搭建

前言

现在使用Java后端开发使用的技术栈基本上比较统一：Spring + SpringMVC + Mybatis，即大家常说的SSM。虽然现在流行的做法是使用SpringBoot来快速搭建、配置好SSM项目，但还是有必要知道如何不用SpringBoot来组合好这三者，因为SpringBoot也只是帮助我们做好了许多配置，并不是说舍弃掉了那些配置，所以知道原生的SSM如何整合可以更好帮助我们理解SSM也能更好的理解SpringBoot带来的好处！而且有的老项目就是没有用SpringBoot，如果你对原生SSM整合与配置一无所知那维护老项目起来会极其难受。

SSM整合相比起SpringBoot的快速搭建自然是繁琐无比，但是不用担心，本文会一步一步演示如何整合这三者，并且会讲解每个配置的含义。如果想自己做一个完整的SSM项目，直接用这套架子进行开发也是完全没问题的！

整合

项目搭建

创建项目

这里使用idea进行项目创建，maven来管理依赖包。首先我们在idea上新建一个project，选择Maven，然后选择web应用：

idea 搭建项目

点击下一步后输入GroupId和ArtifactId后点击下一步直到完成。项目创建完毕后整个项目结构如下：

配置web项目

现在还先别着急配置SSM，我们先得配置一下这个idea下的web项目才行。大家也可以看到，项目建立起来后这个web.xml文件里写的是2.3版本，这个版本太老了，不行。

我们按住catl + shift + alt + S打开idea的Project Structure，然后点击左侧的Modules，再点击Web，然后点击右边的删除按钮，确定，最后点击APPLY先将这个默认的删除：

此时我们会发现默认的web.xml文件已经被删除了。然后我们再点击右侧的添加按钮，点击web.xml进行添加：

这里我们选择3.1版本，选择好后点击弹出框的OK，再点击下方的OK即可创建完毕：

创建完毕后就会发现我们的web.xml内容已经变成了3.1了。

建立项目结构

此时还先不要着急去配置SSM，我们现在项目连个基本的结构都没有呢，你核心代码写在哪，你测试在哪些，你资源放哪这些都是我们要去建立的。

首先，我们在src路径下新建test文件夹，然后在src/main路径下新建java和resources文件夹。建立好文件夹后，右键点击文件夹，然后拖到下方，选择Mark Directory as，然后选择对应的目录结构。

java文件夹对应SourcesRoot，代表标记为项目源代码路径，代码就写在这里。

resources文件夹对应ResourcesRoot，代表标记为资源路径，所有资源比如配置文件就放在这。

test文件夹对应TestSourcesRoot，代表标记为测试路径，测试代码都会放在这里。

文件夹指定好后，我们就要在java文件夹下创建我们的代码包结构。包的话就分为最基本的controller、service、mapper、entity。包建好后目录结构如下：

导入必备依赖包

基本的项目结构整理好后，接下来我们就要开始对SSM进行整合了。首先肯定要做的就是在pom.xml文件中导入必备的依赖包，直接复制粘贴就好了，各个地方都做了注释说明：

  1 <properties>
  2     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  3     <maven.compiler.source>1.8</maven.compiler.source>
  4     <maven.compiler.target>1.8</maven.compiler.target>
  5 
  6     <!--统一配置jar包的版本-->
  7     <mysql.version>5.1.48</mysql.version>
  8     <spring.version>5.2.0.RELEASE</spring.version>
  9     <jackson.version>2.10.0</jackson.version>
 10 </properties>
 11 
 12 <dependencies>
 13     <!--单元测试，注意哦要4.12版本以上。scope为test代表只用来做测试，并不随版本打包发布此依赖包-->
 14     <dependency>
 15         <groupId>junit</groupId>
 16         <artifactId>junit</artifactId>
 17         <version>4.12</version>
 18         <scope>test</scope>
 19     </dependency>
 20 
 21     <!--日志我们使用logback-->
 22     <dependency>
 23       <groupId>ch.qos.logback</groupId>
 24       <artifactId>logback-classic</artifactId>
 25       <version>1.2.3</version>
 26     </dependency>
 27 
 28     <!-- 简化Getter、Setter的工具lombok。非必需
 29     注意：使用lombok还要在idea上下载对应的插件-->
 30     <dependency>
 31         <groupId>org.projectlombok</groupId>
 32         <artifactId>lombok</artifactId>
 33         <version>1.18.10</version>
 34         <scope>provided</scope>
 35     </dependency>
 36 
 37 
 38     <!-- ***************数据库相关配置****************** -->
 39     <!-- mysql驱动依赖包，连接mysql必备-->
 40     <dependency>
 41         <groupId>mysql</groupId>
 42         <artifactId>mysql-connector-java</artifactId>
 43         <version>${mysql.version}</version>
 44     </dependency>
 45 
 46     <!-- 数据源依赖包，能大幅提升性和便利性。这里我们用阿里的德鲁伊数据源-->
 47     <dependency>
 48         <groupId>com.alibaba</groupId>
 49         <artifactId>druid</artifactId>
 50         <version>1.1.12</version>
 51     </dependency>
 52 
 53     <!-- Mybatis必备依赖包 -->
 54     <dependency>
 55         <groupId>org.mybatis</groupId>
 56         <artifactId>mybatis</artifactId>
 57         <version>3.4.6</version>
 58     </dependency>
 59 
 60     <!-- ***************web相关配置****************** -->
 61     <!--配置JavaEE依赖包，包含了Servlet、Validation等功能-->
 62     <dependency>
 63         <groupId>javax</groupId>
 64         <artifactId>javaee-api</artifactId>
 65         <version>8.0</version>
 66         <scope>provided</scope>
 67     </dependency>
 68 
 69     <!-- JSTL依赖包，如果用将jstl标签用在jsp中就要此依赖包。非必需的 -->
 70     <dependency>
 71         <groupId>javax.servlet</groupId>
 72         <artifactId>jstl</artifactId>
 73         <version>1.2</version>
 74     </dependency>
 75 
 76     <!-- jackson依赖包,用来将java对象转换JSON格式，SpringMVC要用的 -->
 77     <dependency>
 78         <groupId>com.fasterxml.jackson.core</groupId>
 79         <artifactId>jackson-core</artifactId>
 80         <version>${jackson.version}</version>
 81     </dependency>
 82     <dependency>
 83         <groupId>com.fasterxml.jackson.core</groupId>
 84         <artifactId>jackson-databind</artifactId>
 85         <version>${jackson.version}</version>
 86     </dependency>
 87     <dependency>
 88         <groupId>com.fasterxml.jackson.core</groupId>
 89         <artifactId>jackson-annotations</artifactId>
 90         <version>${jackson.version}</version>
 91     </dependency>
 92 
 93     <!-- ***************Spring相关配置****************** -->
 94     <!--配置Spring JDBC容器所需的jar包-->
 95     <dependency>
 96         <groupId>org.springframework</groupId>
 97         <artifactId>spring-jdbc</artifactId>
 98         <version>${spring.version}</version>
 99     </dependency>
100 
101     <!--配置Spring IOC容器所需的jar包-->
102     <dependency>
103         <groupId>org.springframework</groupId>
104         <artifactId>spring-context</artifactId>
105         <version>${spring.version}</version>
106     </dependency>
107 
108     <!--Spring mvc-->
109     <dependency>
110         <groupId>org.springframework</groupId>
111         <artifactId>spring-webmvc</artifactId>
112         <version>${spring.version}</version>
113     </dependency>
114 
115     <!-- AspectJ所需的jar包-->
116     <dependency>
117         <groupId>org.aspectj</groupId>
118         <artifactId>aspectjweaver</artifactId>
119         <version>1.9.4</version>
120     </dependency>
121 
122     <!--Spring测试依赖-->
123     <dependency>
124         <groupId>org.springframework</groupId>
125         <artifactId>spring-test</artifactId>
126         <version>${spring.version}</version>
127         <scope>test</scope>
128     </dependency>
129 
130     <!--配置Spring整合mybatis的jar包-->
131     <dependency>
132         <groupId>org.mybatis</groupId>
133         <artifactId>mybatis-spring</artifactId>
134         <version>1.3.2</version>
135     </dependency>
136 </dependencies>

Spring与Mybatis整合

数据库配置

在进行整合之前我们来准备一下数据库，好接下来进行一个完整的演示。我这里用的是MySQL 5.7.25，咱们建立一个名为ssm_demo的数据库，执行语句新建一张user表并插入两条测试数据：

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `name` varchar(255) COLLATE utf8mb4_bin NOT NULL COMMENT '账户名',
  `password` varchar(255) COLLATE utf8mb4_bin NOT NULL COMMENT '账户密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

INSERT INTO `user` VALUES (1, 'admin', '123456');
INSERT INTO `user` VALUES (2, 'rudecrab', '654321');

然后我们在entity包下建立和数据库表对应的实体类User：

1 @Data // lombok注解，自动生成Getter、Setter、toString方法
2 public class User implements Serializable {
3     private Long id;
4 
5     private String name;
6 
7     private String password;
8 }

然后我们在resources文件夹下建立database.properties文件来配置数据库连接的相关信息（这里根据自己的数据库信息配置哦），等下整合Mybatis要用到的：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/ssm_demo?characterEncoding=utf-8&useSSL=false&autoReconnect=true&rewriteBatchedStatements=true&serverTimezone=UTC
jdbc.username=root
jdbc.password=root

logback日志配置

真实项目中一般是要观察日志输出的，我们再配置一下日志。在resources目录下新建logback.xml文件。注意啊，在尾部需要指定某个包，这个根据自己项目结构包名来设置：

 1 <?xml version="1.0" encoding="utf-8" ?>
 2 <configuration>
 3     <!--定义日志文件输出地址-->
 4     <property name="LOG_ERROR_HOME" value="error"/>
 5     <property name="LOG_INFO_HOME" value="info"/>
 6 
 7     <!--通过appender标签指定日志的收集策略，我们会定义三个收集策略：控制台输出、普通信息文件输出、错误信息文件输出-->
 8     <!--name属性指定appender命名-->
 9     <!--class属性指定输出策略，通常有两种，控制台输出和文件输出，文件输出就是将日志进行一个持久化-->
10 
11     <!--控制台输出-->
12     <appender name="CONSOLE_LOG" class="ch.qos.logback.core.ConsoleAppender">
13         <!--使用该标签下的标签指定日志输出格式-->
14         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
15             <!--
16             %p:输出优先级，即DEBUG,INFO,WARN,ERROR,FATAL
17             %r:输出自应用启动到输出该日志讯息所耗费的毫秒数
18             %t:输出产生该日志事件的线程名
19             %f:输出日志讯息所属的类别的类别名
20             %c:输出日志讯息所属的类的全名
21             %d:输出日志时间点的日期或时间，指定格式的方式： %d{yyyy-MM-dd HH:mm:ss}
22             %l:输出日志事件的发生位置，即输出日志讯息的语句在他所在类别的第几行。
23             %m:输出代码中指定的讯息，如log(message)中的message
24             %n:输出一个换行符号
25             -->
26             <pattern>%red(%d{yyyy-MM-dd HH:mm:ss.SSS}) %yellow([%-5p]) %highlight([%t]) %boldMagenta([%C]) %green([%L]) %m%n</pattern>
27         </encoder>
28     </appender>
29 
30     <!--普通信息文件输出-->
31     <appender name="INFO_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
32         <!--通过使用该标签指定过滤策略-->
33         <filter class="ch.qos.logback.classic.filter.LevelFilter">
34             <!--标签指定过滤的类型-->
35             <level>ERROR</level>
36             <onMatch>DENY</onMatch>
37             <onMismatch>ACCEPT</onMismatch>
38         </filter>
39 
40         <encoder>
41             <!--标签指定日志输出格式-->
42             <pattern>[%d{yyyy-MM-dd' 'HH:mm:ss.SSS}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
43         </encoder>
44 
45         <!--标签指定收集策略，比如基于时间进行收集-->
46         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
47             <!--标签指定生成日志保存地址，通过这样配置已经实现了分类分天收集日志的目标了-->
48             <fileNamePattern>${LOG_INFO_HOME}//%d.log</fileNamePattern>
49             <maxHistory>30</maxHistory>
50         </rollingPolicy>
51     </appender>
52 
53     <!--错误信息文件输出-->
54     <appender name="ERROR_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
55         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
56             <level>ERROR</level>
57         </filter>
58         <encoder>
59             <pattern>[%d{yyyy-MM-dd' 'HH:mm:ss.SSS}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
60         </encoder>
61         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
62             <fileNamePattern>${LOG_ERROR_HOME}//%d.log</fileNamePattern>
63             <maxHistory>30</maxHistory>
64         </rollingPolicy>
65     </appender>
66 
67     <!--用来设置某一个包或具体的某一个类的日志打印级别-->
68     <logger name="com.rudecrab.ssm.mapper" level="DEBUG"/>
69 
70     <!--必填标签，用来指定最基础的日志输出级别-->
71     <root level="info">
72         <!--添加append-->
73         <appender-ref ref="CONSOLE_LOG"/>
74         <appender-ref ref="INFO_LOG"/>
75         <appender-ref ref="ERROR_LOG"/>
76     </root>
77 </configuration>

Mybatis全局设置

现在我们开始终于可以进行Spring和Mybatis的整合了。我们先在resources文件夹下新建mybatis-config.xml文件来对Mybatis进行全局配置，这里我习惯配置这些，根据自己的需求来就好：

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 3         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 4 <configuration>
 5     <!--配置全局设置-->
 6     <settings>
 7         <!--启用日志，并指定日志实现方式-->
 8         <setting name="logImpl" value="SLF4J"/>
 9 
10         <!--启用主键生成策略-->
11         <setting name="useGeneratedKeys" value="true"/>
12 
13         <!--配置启用下划线转驼峰的映射-->
14         <setting name="mapUnderscoreToCamelCase" value="true"/>
15 
16         <!--启用二级缓存-->
17         <setting name="cacheEnabled" value="true"/>
18     </settings>
19 </configuration>

Spring-Myabtis整合配置

再来新建spring-mybatis.xml文件，这个文件就是用来做整合的！注意啊，其中很多设置需要指定某个包，这个根据自己项目结构包名来设置，注释写的很清楚了：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:tx="http://www.springframework.org/schema/tx"
 6        xsi:schemaLocation="http://www.springframework.org/schema/beans
 7        http://www.springframework.org/schema/beans/spring-beans.xsd
 8        http://www.springframework.org/schema/context
 9        https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
10 
11     <!--属性文件的读取，这里读取刚才我们的数据库连接相关配置-->
12     <context:property-placeholder location="classpath:database.properties" file-encoding="UTF-8"/>
13 
14     <!--配置自动扫描，如果不配置这个那么就无法使用@Autowired加载bean-->
15     <context:component-scan base-package="com.rudecrab.ssm" use-default-filters="true">
16         <!--这里要排除掉Controller的注解，Controller专门交给MVC去扫描，这样会就不会冲突-->
17         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
18     </context:component-scan>
19 
20     <!--配置数据源-->
21     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
22         <!--配置JDBC基础属性，即数据库连接相关配置-->
23         <property name="driverClassName" value="${jdbc.driver}"/>
24         <property name="url" value="${jdbc.url}"/>
25         <property name="username" value="${jdbc.username}"/>
26         <property name="password" value="${jdbc.password}"/>
27 
28         <!--配置连接池的设置,这个是要根据真实项目情况来配置的，随着项目的发展会不断修改-->
29         <property name="initialSize" value="10"/>
30         <property name="maxActive" value="100"/>
31     </bean>
32 
33     <!--
34     重点来了，这里配置是MyBatis的SqlSessionFactory，就是这一块配置将Spring和Mybatis整合到了一起
35     如果不配置这里，你的mapper接口只能通过SqlSession来获取，十分麻烦。这里配置好后就可以通过Spring IoC来获取mapper接口了
36     -->
37     <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
38         <!--指定数据源-->
39         <property name="dataSource" ref="dataSource"/>
40         <!--加载mybatis全局设置，classpath即我们的资源路径resources-->
41         <property name="configLocation" value="classpath:mybatis-config.xml"/>
42         <!--配置Mybatis的映射xml文件路径-->
43         <property name="mapperLocations" value="classpath:mapper/*.xml"/>
44     </bean>
45 
46     <!--指定Mybatis的mapper接口扫描包-->
47     <!--注意！！！如果用的是tk.mybatis自动生成的mapper接口，一定要将org.mybatis.改成tk.mybatis-->
48     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
49         <!--指定刚才我们配置好的sqlSessionFactory-->
50         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
51         <!--指定mapper接口扫描包-->
52         <property name="basePackage" value="com.rudecrab.ssm.mapper"/>
53     </bean>
54 
55     <!--配置事务管理器，如果不配置这个，不启动事务扫描的话，那么发生了异常也不会触发回滚-->
56     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
57         <!--还得指定数据源-->
58         <property name="dataSource" ref="dataSource"/>
59     </bean>
60     <!--启动事务的扫描-->
61     <tx:annotation-driven/>
62 </beans>

JUnit测试

至此Spring和Myabtis已经整合配置好了，口说无凭，咱们还是得测试一下看下效果。在测试之前我们得先建立好mapper接口文件、myabtis映射xml文件、service接口和实现类：

UserMapper接口专门用来声明各种数据库操作方法，@Repository注解将其定义为Spring所管理的Bean：

1 @Repository
2 public interface UserMapper {
3     /**
4      * 从数据库中查询出所有的User对象
5      * @return User对象集合
6      */
7     List<User> selectAll();
8 }

UserMapper.xml映射文件用来写方法对应要执行的SQL语句：

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 3 <mapper namespace="com.rudecrab.ssm.mapper.UserMapper">
 4     <!--开启缓存-->
 5     <cache/>
 6 
 7     <!--从数据库中查询出所有的User对象-->
 8     <select id="selectAll" resultType="com.rudecrab.ssm.entity.User">
 9         select * from user
10     </select>
11 
12 </mapper>

UserService接口用来声明关于User的业务方法：

1 public interface UserService {
2     /**
3      * 从数据库中查询出所有的User对象
4      * @return User对象集合
5      */
6     List<User> getAll();
7 }

UserServiceImpl实体类用来实现关于User的业务逻辑，@Service注解和@Repository注解用处一样，将其定义为Bean。@Transactional注解为声明式事务，如果该业务层的方法有异常抛出则会触发事务回滚。然后使用@Autowired注解在私有属性上，自动加载Bean，无需我们手动创建UserMapper了：

 1 @Service
 2 @Transactional(rollbackFor = Exception.class)
 3 public class UserServiceImpl implements UserService {
 4     @Autowired
 5     private UserMapper userMapper;
 6 
 7     @Override
 8     public List<User> getAll() {
 9         return userMapper.selectAll();
10     }
11 }

相关类和文件都建好了，现在我们在test文件夹下建立一个测试类UserServiceTest，一定要在测试类上加上那两个注解，否则无法正常使用Spring相关功能：

 1 @RunWith(SpringJUnit4ClassRunner.class)
 2 @ContextConfiguration(locations = {"classpath:spring-mybatis.xml"})
 3 public class UserServiceTest {
 4     @Autowired
 5     private UserService userService;
 6 
 7     @Test
 8     public void getAll() {
 9         System.out.println(userService.getAll());
10         System.out.println(userService.getAll());
11     }
12 }

运行后我们就可以看到运行结果了：

可以看到结果正常显示，并且日志也打印在了控制台上。这代表我们已经完成了Spring和Mybatis的整合！

思路

SpringMVC

spring-mvc.xml

我们接下来配置SpringMVC，在resources目录下新建spring-mvc.xml文件进行配置。注意啊，其中设置需要指定某个包，这个根据自己项目结构包名来设置：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:mvc="http://www.springframework.org/schema/mvc"
 6        xsi:schemaLocation="http://www.springframework.org/schema/beans
 7        http://www.springframework.org/schema/beans/spring-beans.xsd
 8        http://www.springframework.org/schema/context
 9        https://www.springframework.org/schema/context/spring-context.xsd
10        http://www.springframework.org/schema/mvc
11        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
12 
13     <!--配置视图解析器，这样控制器里就直接返回文件名就好了-->
14     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
15         <!--前缀-->
16         <property name="prefix" value="/WEB-INF/views/"/>
17         <!--后缀-->
18         <property name="suffix" value=".jsp"/>
19     </bean>
20 
21     <!--配置静态资源过滤，不然静态资源比如css是访问不到的-->
22     <mvc:default-servlet-handler/>
23 
24     <!--配置扫描的包-->
25     <context:component-scan base-package="com.rudecrab.ssm.controller" use-default-filters="false">
26         <!--只扫描controller,实际开发中最好用这种方式来写，这边MVC就只扫描controller，就不会IOC那边冲突，否则事务会被覆盖，IOC那边就要排除这个controller-->
27         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
28     </context:component-scan>
29 
30     <!--启用MVC的注解-->
31     <mvc:annotation-driven/>
32 </beans>

web.xml

最后一个配置自然就是在web.xml里进行整合了，主要配置三点：

  1. 配置Spring IOC容器，为了mybatis做准备

  2. 配置SpringMVC的前端控制器

  3. 配置字符编码过滤器

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
 5          version="3.1">
 6 
 7     <!--1.配置Spring IOC容器的创建，如果不配置这个，Mybatis就在web应用里无法使用-->
 8     <context-param>
 9         <param-name>contextConfigLocation</param-name>
10         <!--spring和mybatis整合配置文件路径-->
11         <param-value>classpath:spring-mybatis.xml</param-value>
12     </context-param>
13     <listener>
14         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
15     </listener>
16 
17     <!--2.配置SpringMVC的前端控制器-->
18     <servlet>
19         <servlet-name>SpringMVC</servlet-name>
20         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
21         <init-param>
22             <param-name>contextConfigLocation</param-name>
23             <!--SpringMVC整合配置文件路径-->
24             <param-value>classpath:spring-mvc.xml</param-value>
25         </init-param>
26         <load-on-startup>1</load-on-startup>
27     </servlet>
28     <servlet-mapping>
29         <servlet-name>SpringMVC</servlet-name>
30         <url-pattern>/</url-pattern>
31     </servlet-mapping>
32 
33     <!--3.配置字符编码过滤器-->
34     <filter>
35         <filter-name>encodingFilter</filter-name>
36         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
37         <init-param>
38             <param-name>encoding</param-name>
39             <param-value>UTF-8</param-value>
40         </init-param>
41         <init-param>
42             <param-name>forceEncoding</param-name>
43             <param-value>true</param-value>
44         </init-param>
45     </filter>
46     <filter-mapping>
47         <filter-name>encodingFilter</filter-name>
48         <url-pattern>/*</url-pattern>
49     </filter-mapping>
50 </web-app>

最终测试

以上，所有的配置都弄好了，那么接下来咱们就跑一个最简单的web项目来看看是否整合成功！还记得我们在在spring-mvc.xml文件中配置的视图解析前缀嘛，我们在/WEB-INF/views/文件夹下新建一个index.jsp文件：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页-RudeCrab</title>
</head>
<body>
<%--循环提取userList中的元素--%>
<c:forEach var="user" items="${userList}">
    <ul>
        <li>${user}</li>
    </ul>
</c:forEach>
</body>
</html>

接下来再在controller包下新建一个控制器类来定义访问接口：

 1 @Controller
 2 @RequestMapping(value = "user")
 3 public class UserController {
 4     @Autowired
 5     private UserService userService;
 6 
 7     @GetMapping("/getList")
 8     public String getList(Model model) {
 9         // 将数据存到model对象里，这样jsp就能访问数据
10         model.addAttribute("userList", userService.getAll());
11         // 返回jsp文件名
12         return "index";
13     }
14 
15     @GetMapping("/getJson")
16     @ResponseBody
17     public List<User> getList() {
18         // 如果想做前后端分离的话可以加上@ResponseBody注解，直接返回数据对象，这样前端就可以通过获取json来渲染数据了
19         return userService.getAll();
20     }
21 }

然后我们启动Tomcat，在浏览器中访问接口：

可以看到我们成功的访问到了数据，至此SSM完全整合完毕！

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/liucs/p/12764409.html