手把手实现Spring+SpringMVC+MyBatis框架整合

我们已经学习了Spring、SpringMVC和MyBatis框架，那么这三个框架如何结合在一块儿使用呢？首先，需要将者三个框架进行整合。那么，袁老师就给大家安排上。本节袁老师将给大家介绍SSM框架的整合流程，并带大家最终完成Web应用程序的开发。袁老师保证，只要你认真看完，肯定会有斩获哦。

一. 项目环境搭建

  1. 搭建项目结构
  2. 首先我们要选择【Java Enterprise】选项，将项⽬名称设置为ssm-integration。项⽬的GAV坐标中GroupId的值设置为com.cy.ssm，Artfact选项的值设置为controller，并将Project template选项的值设置成Web application，其他保持默认。
  3. 然后要将项⽬com.cy.controller包下⾃动⽣成的HelloServlet类删除，并将webapp⽂件夹下⾃动⽣成的index.jsp⽂件删除。
  4. 之后在项目的com.cy.ssm包下创建pojo、mapper、service、service.impl、controller的包结构。
  5. 最后就可以在webapp目录下创建css、img、js等文件夹，并在WEB-INF目录下创建pages文件夹了。
  6. 配置Tomcat
  7. 我们可以在IDEA窗口的右上角点击【Add Configurations】按钮，打开Run/Debug Configurations窗口。
  8. 接着在Run/Debug Configurations窗口中点击【+】号，选择Tomcat Server选项下的Local选项。点击右下角的【Fix】选项。
  9. 然后在Deployment选项下点击【+】号按钮，选择【Artifact】选项，在新打开的窗口中选择【ssm-integration:war expolded】选项。
  10. 最后启动Tomcat服务器，访问http://localhost:8080/ssm-integration_war_exploded/地址，进行初始化环境测试。
  11. 添加SSM依赖
  12. 修改pom.xml文件，首先将编译版本改为11版本（根据安装的JDK版本来确定配置的编译版本）。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.target>11</maven.compiler.target>
  <maven.compiler.source>11</maven.compiler.source>
  <junit.version>5.8.1</junit.version>
</properties>
在pom.xml文件中添加SSM框架所需的相关依赖配置。
<?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>
 
    <groupId>com.cy</groupId>
    <artifactId>controller</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>ssm-integration</name>
    <packaging>war</packaging>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.target>11</maven.compiler.target>
        <maven.compiler.source>11</maven.compiler.source>
        <junit.version>5.8.1</junit.version>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
 
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.22</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.22</version>
        </dependency>
        <!-- 引⼊FastJson依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>
        <!-- MyBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!-- Spring+MyBatis集成依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- Spring-JDBC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.22</version>
        </dependency>
        <!-- 数据库驱动：MySQL -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!-- 数据库连接池：Druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.9</version>
        </dependency>
        <!-- jsp -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- jstl -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- 日志相关 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.6</version>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.2</version>
            </plugin>
        </plugins>
    </build>
</project>　

二. Spring环境搭建

下面先跟袁老师来搭建Spring环境，主要是Spring配置以及Spring环境测试，最后我们再配置log4j日志。

1.Spring配置

1.1 加载Spring容器配置

在resources目录下，创建applicationContext.xml配置文件。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?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:aop="http://www.springframework.org/schema/aop"
       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/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
 
</beans>
在web.xml配置文件中添加在Web容器启动时就加载Spring的核心配置文件applicationContext.xml。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
 
    <!-- 启动Spring容器。在Web容器中引入Spring的核心配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <!-- 指定配置文件位置 -->
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!-- 在Web容器中使用监听器加载Spring的核心配置文件，在Web容器启动时就加载Spring的核心配置文件 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

1.2 Spring容器整合技巧

1.2.1 整合思路

此时项目中有两个工厂：

DispatcherServlet启动的SpringMVC工厂，负责生产Controller及SpringMVC自己的系统组件。ContextLoaderListener启动的Spring工厂，负责生产其他所有组件。SpringMVC的工厂会被设置为Spring工厂的子工厂，可以随意获取Spring工厂中的组件。整合过程，就是累加：代码+依赖+配置。然后将Service注入给Controller即可。

1.2.2 整合技巧实现

两个工厂不能有彼此侵入，即生产的组件不能有重合。在applicationContext.xml文件中添加开启组件扫描的配置。

?
1
2
3
4
<!-- 告知Spring唯独不扫描@Controller注解的类 -->
<context:component-scan base-package="com.cy.ssm" use-default-filters="true">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
  • Spring环境测试
  • 在src/test/java包下创建com.cy.ssm包，并在该包下创建SpringTests测试类，测试Spring的环境是否正常。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.cy.ssm;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class SpringTests {
    @Test
    public void testSpring() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // ClassPathXmlApplicationContext
        System.out.println(context.getClass().getSimpleName());
    }
}
  • log4j配置
  • 在运行上述testSpring()单元测试时，控制台会提示log4j:WARN的警告信息。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/Library/Java/JavaVirtualMachines/jdk-11.0.12.jdk/Contents/Home/bin/java ...
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
在项目的resources文件夹下创建log4j.properties文件，并在log4j.properties文件中添加log4j日志的配置信息，这一步的前提是需要导入log4j的依赖。
log4j.rootLogger=DEBUG, Console
# Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

三. Spring整合MyBatis

1.MyBatis配置

1.1 MyBatis核心配置文件

在src/main/resources目录下，创建MyBatis的核心配置文件mybatis-config.xml。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?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>
     
</configuration>
在mybatis-config.xml配置文件中开启驼峰映射和二级缓存。
<settings>
  <!-- 开启驼峰映射 -->
  <setting name="mapUnderscoreToCamelCase" value="true"/>
  <!-- 开启二级缓存 -->
  <setting name="cacheEnabled" value="true"/>
  <!-- 后台的日志输出：针对开发者 -->
  <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

1.2 MyBatis数据源文件

在src/main/resources目录下创建mappers文件夹，将来用于存放MyBatis的映射文件。在src/main/resources目录下创建jdbc.properties数据源文件。

# 基础配置
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_sys?useUnicode=true&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=123456
# 配置初始化大小、最小、最大
jdbc.initialSize=5
jdbc.minIdle=1
jdbc.maxActive=10
# 配置获取连接等待超时的时间
jdbc.maxWait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
jdbc.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
jdbc.minEvictableIdleTimeMillis=300000
注意：在jdbc.properties配置文件中数据库的连接名不能使用username的属性名，否则会报错。因此在数据源文件中添加固定前缀以区分。

2.Spring整合MyBatis实现

2.1 Druid连接池配置

在applicationContext.xml配置文件中添加MyBatis框架的整合以及配置事务控制。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<!-- 导入jdbc.properties配置文件 -->
<context:property-placeholder location="classpath:/jdbc.properties"/>
 
<!-- 与DruidDataSource集成(二选一) -->
<!-- 注册数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <!-- 基本配置 -->
    <property name="driverClassName" value="${jdbc.driverClassName}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    <!-- 配置初始化大小、最小、最大 -->
    <property name="initialSize" value="${jdbc.initialSize}"/>
    <property name="minIdle" value="${jdbc.minIdle}"/>
    <property name="maxActive" value="${jdbc.maxActive}"/>
    <!-- 配置获取连接等待超时的时间 -->
    <property name="maxWait" value="${jdbc.maxWait}"/>
    <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
    <property name="timeBetweenEvictionRunsMillis" value="${jdbc.timeBetweenEvictionRunsMillis}"/>
    <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
    <property name="minEvictableIdleTimeMillis" value="${jdbc.minEvictableIdleTimeMillis}"/>
</bean>
 
<!-- 与PooledDataSource集成(二选一) -->
<!--
<bean id="dataSource" class="org.apache.ibatis.datasource.pooled.PooledDataSource">
    <property name="driver" value="${jdbc.driverClassName}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>
-->

2.2 Druid监控中心配置

在项目的web.xml文件中添加Druid的StatViewServlet组件的配置。

?
1
2
3
4
5
6
7
8
<servlet>
    <servlet-name>DruidStatView</servlet-name>
    <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>DruidStatView</servlet-name>
    <url-pattern>/druid/*</url-pattern>
</servlet-mapping>
测试Druid监控中心。访问http://localhost:8080/ssm_integration_war_exploded/druid/index.html地址进行测试。
Druid访问的语法url格式：http://ip:port/project/druid/index.html。

 2.3 整合MyBatis

1.导入依赖

在pom.xml文件中导入spring-jdbc和mybatis-spring依赖。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<!-- MyBatis -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.4.5</version>
</dependency>
<!-- Spring+MyBatis集成依赖 -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.1</version>
</dependency>
<!-- Spring-JDBC -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>5.2.1.RELEASE</version>
</dependency>
<!-- 数据库驱动：MySQL -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.6</version>
</dependency>
<!-- 数据库连接池：Druid -->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.2.9</version>
</dependency>
<!-- 事务 -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>5.2.1.RELEASE</version>
</dependency>

2.配置SqlSessionFactoryBean 在applicationContext.xml文件中配置SqlSessionFactoryBean工厂。

?
1
2
3
4
5
6
7
8
9
10
11
12
<!-- 整合MyBatis框架，SqlSessionFactoryBean可以根据配置文件得到SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <!-- 注入数据库连接池 -->
  <property name="dataSource" ref="dataSource"/>
  <!-- 配置MyBatis全局配置文件SqlMapConfig.xml -->
  <property name="configLocation" value="classpath:mybatis-config.xml"/>
  <!-- xml映射文件路径 -->
  <property name="mapperLocations" value="classpath:mappers/*.xml"/>
  <!-- 为XxxMapper.xml文件中的实体定义缺省包路径。
       如：<select id="queryAll" resultType="User">中User类可以不定义包。 -->
  <property name="typeAliasesPackage" value="com.cy.ssm.pojo"></property>
</bean>

3.配置MapperScannerConfigurer 在applicationContext.xml文件中添加Mapper扫描器MapperScannerConfigurer的配置。作用是：管理Mapper实现类的创建，并创建Mapper对象，存入工厂管理。

扫描所有Mapper接口，去构建Mapper实现。将Mapper实现存入工厂管理。Mapper实现对象在工厂中的id是：“首字母小写的接口的类名”。
?
1
2
3
4
5
6
7
<!--自动扫描，将Mapper接口生成代理注入到Spring容器中。 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <!-- 扫描Mapper包。如果有多个包，可以用逗号或分号分隔。 -->
  <property name="basePackage" value="com.cy.ssm.mapper"/>
  <!-- 如果工厂中只有一个SqlSessionFactory的bean，此配置可省略。 -->
  <!-- <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/> -->
</bean>
说明：MapperScannerConfigurer类是Spring框架和MyBatis框架整合时mybatis-spring依赖提供的一个类。其作用是自动扫描，将Mapper接口生成代理注入到Spring容器中。

4.配置DataSourceTransactionManager

在applicationContext.xml文件中配置事务管理器。事务管理器其中持有DataSource对象，可以控制事务功能（commit和rollback等）。

?
1
2
3
4
5
<!-- 配置事务控制 -->
<!-- 配置事务管理器。其中依赖DataSource对象，借此以获得连接，进而控制事务逻辑。 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>
注意：DataSourceTransactionManager和SqlSessionFactoryBean要注入同一个DataSource的Bean，否则事务控制失败。

5.配置事务通知

基于事务管理器进一步定制，生成一个额外功能Advice。此Advice可以切入任何需要事务的方法，通过事务管理器为方法控制事务。我们可以在applicationContext.xml文件中配置事务规则和AOP切面。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!--配置事务规则 -->
<tx:advice id="advice" transaction-manager="transactionManager">
  <!-- 配置事务属性 -->
  <tx:attributes>
    <!-- 任何方法发生异常就回滚。rollback-for：触发指定异常时回滚 -->
    <tx:method name="*" rollback-for="java.lang.Exception"/>
    <!-- find开头的方法设置只读可优化性能 -->
    <tx:method name="find*" read-only="true"/>
  </tx:attributes>
</tx:advice>
<!-- 配置AOP -->
<aop:config>
  <aop:pointcut id="pc" expression="execution(* com.cy.ssm.service.*.*(..))"/>
  <aop:advisor advice-ref="advice" pointcut-ref="pc"/>
</aop:config>
 
<!-- <tx:annotation-driven transaction-manager="transactionManager"/> -->

2.4 MyBatis环境测试

在src/test/java下的com.cy.ssm包下创建MyBatisTests测试类，测试MyBatis的环境是否正常。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.cy.ssm;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class MyBatisTests {
    @Test
    public void testMyBatis() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        SqlSessionFactory sqlSessionFactory = (SqlSessionFactory) context.getBean("sqlSessionFactory");
        // org.apache.ibatis.session.defaults.DefaultSqlSessionFactory@304bb45b
        System.out.println(sqlSessionFactory);
    }
}
注意：获取的org.mybatis.spring.SqlSessionFactoryBean类型的对象需要使用SqlSessionFactory类型来接收。否则会抛出类型转化异常，具体见下：
类org.apache.ibatis.session.defaults.DefaultSqlSessionFactory不能转换为类org.mybatis.spring.SqlSessionFactoryBean。

四. SpringMVC整合

1.SpringMVC配置

2.在resources目录下创建springmvc-servlet.xml配置文件，并在文件中添加SpringMVC的相关配置。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
<?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.xsd">
 
    <!-- 告知SpringMVC哪些包中存在被注解的类。
       use-default-filters=true：凡是被@Controller、@Service、@Repository注解的类都会被扫描
       use-default-filters=false：默认不扫描包内的任何类
       include-filter：只扫描include-filter中expression属性指定的类(只扫描被@Controller注解的类) -->
    <context:component-scan base-package="com.cy.ssm" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
 
    <!-- 开启SpringMVC注解驱动 -->
    <mvc:annotation-driven>
        <!-- 设置不使⽤默认的消息转换器 -->
        <mvc:message-converters register-defaults="false">
            <!-- 配置FastJson中实现HttpMessageConverter接⼝的转换器 -->
            <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
                <!-- 声明⽀持的返回的类型 -->
                <property name="supportedMediaTypes">
                    <list>
                        <value>application/json</value>
                    </list>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
 
    <!-- 忽略静态资源 -->
    <mvc:resources mapping="/img/" location="/img/"/>
    <mvc:resources mapping="/js/" location="/js/"/>
    <mvc:resources mapping="/css/**" location="/css/"/>
 
    <!-- 注册视图解析器 -->
    <!--
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    -->
</beans>
在web.xml文件中添加SpringMVC框架的前端控制器的配置，以及字符编码过滤器的配置和服务器启动页的配置。
<!-- 配置SpringMVC前端控制器 -->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 读取spring-servlet.xml -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc-servlet.xml</param-value>
    </init-param>
    <!-- 启动后加载 -->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <!-- /*：匹配所有资源；/：匹配除jsp之外的所有资源 -->
    <url-pattern>/</url-pattern>
</servlet-mapping>
 
<!-- 配置字符编码过滤器 -->
<filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>　　

1.SpringMVC环境测试

2.在controller包下创建TestController类，并添加处理test请求的处理方法。

?
1
2
3
4
5
6
7
8
9
10
11
12
package com.cy.ssm.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@RequestMapping("/mvc")
public class TestController {
    @RequestMapping("/test")
    public String test() {
        return "{status: 200}";
    }
}

启动Tomcat服务器，访问http://localhost:8080/ssm_integration_war_exploded/mvc/test进行测试。

"{status: 200}"

五. SSM架构总结

通过以上关于SSM框架的介绍，相信通过对SSM框架的整合流程有了很深入的了解。在Spring + SpringMVC + MyBatis架构下，框架之间的职责分工见下图：

通过上图的分析，是不是对SSM框架负责的模块理解的更加深刻了。这篇文章我们主要介绍了Spring环境的大家，以及如何使用Spring整合MyBatis框架和SpringMVC框架的整合。通过以上内容的学习，相信各位小伙伴一定可以自行搭建起SSM框架的架构环境。好了，关于SSM框架的搭建内容就给大家介绍到这里。

 

posted @   可爱的小锋  阅读(1508)  评论(0)  编辑  收藏  举报
相关博文：
·  Java 框架面试题-Spring Boot自定义配置与自动配置共存
·  Spring整合Junit框架
·  SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）
·  SSM框架整合 详细步骤
·  Spring和MyBatis整合
阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 零经验选手，Compose 一天开发一款小游戏！
· 通过 API 将Deepseek响应流式内容输出到前端
点击右上角即可分享
微信分享提示