Maven的多模块 Spring MVC + Spring + Mybatis 项目的搭建

我想大多数做java开发的同学对SSM框架的搭建已经都轻车熟路了,但是大家搭建的大多数是单模块的,网上也有非常多的例子,但是如何用maven去构建多module的ssm项目呢?下面来手把手的,利用IntelliJ IDEA搭建一次多module的ssm项目,给大家一个参考。

为什么要搭建多模块的maven项目?

首先抛出这么一个问题,我们为什么要搭建多模块的maven项目呢?以多模块的方式组织项目,其实也是maven一直倡导的。做开发的同学都知道的一个概念就是“低耦合,高内聚”,将项目划分多模块,可以极大的增大代码的重用性,防止随着项目的增大,pom文件越来越臃肿。

对于一般的java项目我们一般是这么分层的:

  • dao层负责数据库的交互。
  • service层主要处理业务逻辑。
  • web层负责与客户端交互。
  • pojo层存放的是实体类。
  • common层存放我们常用的一些公用的工具类等。

对应的,在一个项目中,我们会看到一些包名:

  • com.leeyom.ssm.dao
  • com.leeyom.ssm.service
  • com.leeyom.ssm.web
  • com.leeyom.ssm.common
  • com.leeyom.ssm.pojo

这样整个项目的框架就清晰了,但随着项目的进行,你可能会遇到如下问题:

  1. 这个应用可能需要有一个前台和一个后台管理端,你发现大部分dao,一些service,和大部分util是在两个应用中均可用。
  2. pom.xml中的依赖列表越来越长以重用的,但是,由于目前只有一个项目(WAR),你不得不新建一个项目依赖这个WAR,这变得非常的恶心,因为在Maven中配置对WAR的依赖远不如依赖JAR那样简单明了,而且你根本不需要com.leeyom.ssm.web。有人修改了dao,提交到svn并且不小心导致build失败了,你在编写service的代码,发现编译不过,只能等那人把dao修复了,你才能继续进行,很多人都在修改,到后来你根本就不清楚哪个依赖是谁需要的,渐渐的,很多不必要的依赖被引入。甚至出现了一个依赖有多个版本存在。
  3. build整个项目的时间越来越长,尽管你只是一直在web层工作,但你不得不build整个项目。
  4. 某个模块,比如util,你只想让一些经验丰富的人来维护,可是,现在这种情况,每个开发者都能修改,这导致关键模块的代码质量不能达到你的要求。

我们会发现,其实这里实际上没有遵守一个设计模式原则:“高内聚,低耦合”。虽然我们通过包名划分了层次,并且你还会说,这些包的依赖都是单向的,没有包的环依赖。这很好,但还不够,因为就构建层次来说,所有东西都被耦合在一起了。因此我们需要使用Maven划分模块。

以上的讲解是参考:Maven最佳实践:划分模块

项目结构

项目整体目录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ssm-demo
├── ssm-common -- 公共模块,主要存放一些工具类
| ├── src
| ├── pom.xml -- 打包方式:jar
├── ssm-dao -- 存放mybatis相关的mapper接口
| ├── src
| ├── pom.xml -- 打包方式:jar
├── ssm-pojo -- 存放实体类
| ├── src
| ├── pom.xml -- 打包方式:jar
├── ssm-service -- 存放业务逻辑类
| ├── src
| ├── pom.xml -- 打包方式:jar
├── ssm-web -- 存放前台页面,客户端交互相关的handler
| ├── src
| ├── pom.xml -- 打包方式:war
├── pom.xml --打包方式为pom,一些公用的依赖

各模块的依赖关系

Maven多模块项目创建

  1. 先创建一个空的maven项目(ssm-demo)作为父级项目,创建成功后,删除掉src目录!

  2. 右击我们刚刚创建的父级项目ssm-demo,选择 new --> Module,创建ssm-common模块。填写Artifactld点击Finish,就可以建好ssm-common模块。
    打开ssm-common下面的pom.xml文件,添加该模块的打包方式为jar:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
        <?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
    <artifactId>ssm</artifactId>
    <groupId>com.leeyom.ssm</groupId>
    <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>ssm-common</artifactId>
    <packaging>jar</packaging>
    <properties>
    <!--编译级别-->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>
    </project>
  3. 同理,跟创建ssm-common模块一样,继续创建ssm-pojossm-servicessm-daossm-web等相应的模块。但是我们需要注意的一点是:在我们的依赖模块关系图里,我们知道ssm-web模块的打包方式是war包,那我们需要将他的打包方式设置为war包,而不是jar了,为什么要设置成war呢?因为我们的war包最终是要放到tomcat web容器中跑的,你打包成jar怎么放web容器里面跑,是不是?同时ssm-web依赖ssm-servicessm-common两个模块,我在这里就拿ssm-web模块的pom文件讲解下:

    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
    <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 http://maven.apache.org/maven-v4_0_0.xsd">
    <parent>
    <artifactId>ssm</artifactId>
    <groupId>com.leeyom.ssm</groupId>
    <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>ssm-web</artifactId>
    <packaging>war</packaging>
    <name>ssm-web</name>
    <url>http://maven.apache.org</url>

    <properties>
    <!--编译级别-->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>

    <dependencies>
    <!--junit单元测试,因为父级的pom中junit的scope为test,所以在其他的module要用junit使用单元测试要单独添加junit依赖-->
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.9</version>
    <scope>test</scope>
    </dependency>

    <!--添加 ssm-service module依赖,需要调用业务层处理业务-->
    <dependency>
    <groupId>com.leeyom.ssm</groupId>
    <artifactId>ssm-service</artifactId>
    <version>1.0-SNAPSHOT</version>
    </dependency>
    </dependencies>

    <build>
    <finalName>ssm</finalName>
    <plugins>
    <!--编译插件-->
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
    <!--设置source和target版本,解决IDEA自动重置Language Level和JavaCompiler版本的问题-->
    <source>1.8</source>
    <target>1.8</target>
    <encoding>UTF-8</encoding>
    <showWarnings>true</showWarnings>
    <!--如果lib目录下面有jar包,将lib目录已有的jar包打包进war-->
    <compilerArguments>
    <extdirs>src\main\webapp\WEB-INF\lib</extdirs>
    </compilerArguments>
    </configuration>
    </plugin>

    <!--tomcat7插件-->
    <plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.2</version>
    <configuration>
    <!--项目访问路径,如果你设置为根路径,那么访问地址为: http://localhost:8080/ -->
    <!--如果你改为ssm,那么访问路径变为: http://localhost:8080/ssm/-->
    <path>/ssm-demo</path>
    <!--tomcat访问端口-->
    <port>8080</port>
    <uriEncoding>UTF-8</uriEncoding>
    <!--tomcat管理界面路径,固定-->
    <url>http://localhost:8080/manager/html</url>
    <server>tomcat7</server>
    <username>admin</username>
    <password>admin</password>
    </configuration>
    </plugin>
    </plugins>
    </build>
    </project>

    知道ssm-web模块的pom文件的处理方式,那剩下的ssm-pojossm-daossm-service自然就很清楚了吧!具体的话可以看我上传到github的项目代码。

  4. 重点分析父级 pom.xml 文件,下面贴出父级的完整的pom.xml文件,分析都写在pom文件中。

    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
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    <?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.leeyom.ssm</groupId>
    <artifactId>ssm</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <!--聚合的子module,父级的pom聚合他下面的所有的子模块,而子模块可以继承父级pom里面的依赖,这就是maven的聚合与继承-->
    <modules>
    <module>ssm-web</module>
    <module>ssm-service</module>
    <module>ssm-common</module>
    <module>ssm-dao</module>
    <module>ssm-pojo</module>
    </modules>

    <properties>
    <!--jar包版本控制-->
    <spring.version>4.1.7.RELEASE</spring.version>
    <mybatis.version>3.3.0</mybatis.version>
    <mybatis-spring.version>1.2.3</mybatis-spring.version>
    <pagehelper.version>4.1.4</pagehelper.version>
    <junit.version>4.9</junit.version>
    <mysql-connector.version>5.1.37</mysql-connector.version>
    <druid.version>1.1.2</druid.version>
    <slf4j.version>1.7.7</slf4j.version>
    <log4j.version>1.2.17</log4j.version>
    <javaee-api.version>7.0</javaee-api.version>
    <jstl.version>1.2</jstl.version>
    <jsp-api.version>2.3.1</jsp-api.version>
    <servlet-api.version>3.1.0</servlet-api.version>
    <commons-fileupload.version>1.3.1</commons-fileupload.version>
    <commons-io.version>2.4</commons-io.version>
    <commons-codec.version>1.9</commons-codec.version>
    <commons-lang3.version>3.3.2</commons-lang3.version>
    <json-lib.version>2.4</json-lib.version>
    <fastjson.version>1.2.35</fastjson.version>
    <gson.version>2.2.4</gson.version>

    <!--编译级别,如果不设置编译级别,IDEA 老是将 language level 重置-->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>

    <!--父级 pom 主要管理公共依赖-->
    <dependencies>
    <!--spring核心包-->
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-oxm</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>${spring.version}</version>
    </dependency>

    <!-- mybatis核心包 -->
    <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>${mybatis.version}</version>
    </dependency>
    <!-- mybatis集成spring包 -->
    <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>${mybatis-spring.version}</version>
    </dependency>

    <!-- Mysql数据库链接jar包 -->
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql-connector.version}</version>
    <scope>runtime</scope>
    </dependency>

    <!-- mybatis分页插件 -->
    <dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>${pagehelper.version}</version>
    </dependency>

    <!--阿里巴巴德鲁伊数据库连接池-->
    <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>${druid.version}</version>
    </dependency>

    <!-- JSTL标签类 -->
    <dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>${jstl.version}</version>
    </dependency>

    <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>${servlet-api.version}</version>
    <scope>provided</scope>
    </dependency>

    <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>${jsp-api.version}</version>
    <scope>provided</scope>
    </dependency>

    <!-- java ee jar 包 -->
    <dependency>
    <groupId>javax</groupId>
    <artifactId>javaee-api</artifactId>
    <version>${javaee-api.version}</version>
    <scope>provided</scope>
    </dependency>

    <!--单元测试-->
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
    </dependency>

    <!--日志管理-->
    <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>${log4j.version}</version>
    </dependency>

    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>${slf4j.version}</version>
    </dependency>

    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>${slf4j.version}</version>
    </dependency>

    <!-- json格式化组件 -->
    <dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>${gson.version}</version>
    </dependency>
    <dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>${json-lib.version}</version>
    <classifier>jdk15</classifier>
    </dependency>

    <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>${fastjson.version}</version>
    </dependency>

    <!-- 上传组件包 -->
    <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>${commons-fileupload.version}</version>
    </dependency>
    <dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>${commons-io.version}</version>
    </dependency>
    <dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>${commons-codec.version}</version>
    </dependency>

    <!--apache工具包-->
    <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>${commons-lang3.version}</version>
    </dependency>
    </dependencies>
    </project>

SSM框架的整合

通过上面搭建maven好的maven多模块项目的骨架,现在就可以开始ssm项目的整合了,我的开发环境和所用的三大框架的版本如下:

  • 开发环境是:
    • IntelliJ IDEA 2017.1
    • JDK 1.8.0_45
    • Tomcat 7
    • Maven 3.3.9
    • MySQL 5.7.16
  • 三大框架版本:
    • Spring 4.1.7.RELEASE
    • Spring MVC 4.1.7.RELEASE
    • MyBatis 3.3.0
  • 核心配置文件:
文件名 所属目录 描述
mybatis-config.xml ssm-web/src/main/resources/spring mybatis分页插件pagehelper配置文件
spring-mvc.xml ssm-web/src/main/resources/spring 配置spring mvc,比如配置视图解析器、文件上传、spring mvc 注解等等。
spring-mybatis.xml ssm-web/src/main/resources/spring spring与mybatis的整合文件,数据源、自动扫描、事务管理等都是在这里配置。
xxxMapper.xml ssm-web/src/main/resources/mapper 这个就是通过mybatis-generator自动生成的mapper数据库映射文件。
jdbc.properties ssm-web/src/main/resources/ 这个不多说,配置数据库连接信息
log4j.properties ssm-web/src/main/resources/ 日志配置文件,方便调试bug,打印日志,需要配置此项

Spring 与 mybatis 的整合

所有的ssm整合配置项都是在ssm-web这个子模块下面进行配置,先来看一下ssm-web模块的目录结构:

  1. 建立jdbc.properties数据库属性文件

    1
    2
    3
    jdbc.url=jdbc:mysql://localhost:3306/ssm-demo?useUnicode=true&characterEncoding=utf8
    jdbc.username=root
    jdbc.password=root

    因为我们这边用的是阿里巴巴的德鲁伊数据库连接池,并不需要配置jdbc.driver,如果你用的是c3p0或者dbcp数据库连接池,是要配置jdbc.driver。

  2. 创建spring-mybatis.xml核心配置文件

    该配置文件也是spring整合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
    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
    <?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.1.xsd">
    <!-- 自动扫描 -->
    <context:component-scan base-package="com.leeyom"/>
    <!-- 引入配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:jdbc.properties"/>
    </bean>
    <!--使用阿里巴巴的德鲁伊数据源,这里使用官方给出的参考,德鲁伊官方配置参考:https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_DruidDataSource%E5%8F%82%E8%80%83%E9%85%8D%E7%BD%AE-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
    <!-- 基本属性 url、user、password -->
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    <!-- 配置初始化大小、最小、最大 -->
    <property name="initialSize" value="1"/>
    <property name="minIdle" value="1"/>
    <property name="maxActive" value="20"/>
    <!-- 配置获取连接等待超时的时间 -->
    <property name="maxWait" value="60000"/>
    <!-- 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒 -->
    <property name="timeBetweenEvictionRunsMillis" value="60000"/>
    <!-- 配置一个连接在池中最小生存的时间,单位是毫秒 -->
    <property name="minEvictableIdleTimeMillis" value="300000"/>
    <property name="validationQuery" value="SELECT 'x'"/>
    <property name="testWhileIdle" value="true"/>
    <property name="testOnBorrow" value="false"/>
    <property name="testOnReturn" value="false"/>
    <!-- 打开PSCache,并且指定每个连接上PSCache的大小 -->
    <property name="poolPreparedStatements" value="true"/>
    <property name="maxPoolPreparedStatementPerConnectionSize" value="20"/>
    <!-- 配置监控统计拦截的filters -->
    <property name="filters" value="stat"/>
    </bean>
    <!-- spring和MyBatis整合 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--mybatis分页插件-->
    <property name="configLocation" value="classpath:spring/mybatis-config.xml"></property>
    <!-- 自动扫描mapping.xml文件 -->
    <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
    </bean>
    <!-- DAO接口所在包名,Spring会自动查找其下的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.leeyom.dao"/>
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>
    <!-- 事务管理 -->
    <bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
    </bean>
    <tx:annotation-driven />
    </beans>
  3. 创建mybatis-config.xml分页插件配置文件

    mybatis分页插件PaheHelper是一个非常好用的分页插件,也可以通过配置文件的形式整合到mybatis中,具体怎么使用可以参考我以前写的文章:mybatis 分页插件PageHelper使用及总结。具体的配置如下:

    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>
    <settings>
    <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>
    <!-- 配置分页插件 -->
    <plugins>
    <plugin interceptor="com.github.pagehelper.PageHelper">
    <!-- 指定数据库方言 -->
    <property name="dialect" value="mysql" />
    </plugin>
    </plugins>
    </configuration>
  4. 创建Log4j日志配
    为了方便查看控制台打印的日志,需要配置log4j日志配置文件:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #定义LOG输出级别
    log4j.rootLogger=INFO,Console,File
    #定义日志输出目的地为控制台
    log4j.appender.Console=org.apache.log4j.ConsoleAppender
    log4j.appender.Console.Target=System.out
    #可以灵活地指定日志输出格式,下面一行是指定具体的格式
    log4j.appender.Console.layout=org.apache.log4j.PatternLayout
    log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n
    #文件大小到达指定尺寸的时候产生一个新的文件
    log4j.appender.File=org.apache.log4j.RollingFileAppender
    #指定输出目录
    log4j.appender.File.File=logs/ssm-demo.log
    #定义文件最大大小
    log4j.appender.File.MaxFileSize=10MB
    #输出所以日志,如果换成DEBUG表示输出DEBUG以上级别日志
    log4j.appender.File.Threshold=ALL
    log4j.appender.File.layout=org.apache.log4j.PatternLayout
    log4j.appender.File.layout.ConversionPattern=[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n
  5. 测试spring与mybatis的整合情况

    创建测试表t_user,表结构如下:

    1
    2
    3
    4
    5
    6
    7
    8
     DROP TABLE IF EXISTS `t_user`;
    CREATE TABLE `t_user` (
    `u_id` int(100) NOT NULL AUTO_INCREMENT,
    `u_name` varchar(100) DEFAULT NULL,
    `u_password` varchar(100) DEFAULT NULL,
    PRIMARY KEY (`u_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
    SET FOREIGN_KEY_CHECKS = 1;

    再往该表中随便插入两条条数据:

    1
    INSERT INTO `t_user` VALUES ('1', 'leeyom', 'root'), ('2', '小明', 'admin');

    利用mybatis-generator生成UserMapper.javaUser.javaUserMapper.xml等相关的文件。文件是生成了,但是得放到对的位置,UserMapper.java放到ssm-dao模块下面,因为该层主要跟数据库进行交互,所以,dao层的接口文件就是放在该模块下面。User.java放到ssm-pojo模块下面,该模块主要存放实体类的bean,而UserMapper.xml文件
    则放在ssm-web模块的resources资源目录下面的mapper文件夹下面,放在此模块下面的原因是,该映射文件将打包一起部署到web服务器上面,如果放到ssm-dao模块,ssm-dao的打包方式是jar,到时候会出现引用到不该数据库映射文件。最后我们还需要在ssm-service模块创建接口类UserService.java

    1
    2
    3
    4
    5
    package com.leeyom.service.user;
    import com.leeyom.pojo.User;
    public interface UserService {
    public User getUserById(Integer userId);
    }

    接口的实现类UserServiceImpl.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package com.leeyom.service.user.impl;
    import com.leeyom.dao.user.UserMapper;
    import com.leeyom.pojo.User;
    import com.leeyom.service.user.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    @Service("userService")
    public class UserServiceImpl implements UserService {
    @Autowired
    UserMapper userMapper;
    @Override
    public User getUserById(Integer userId) {
    return userMapper.selectByPrimaryKey(userId);
    }
    }

    整个的目录如下:

    下面进行测试,在ssm-web模块的的test/java目录下面,新建测试类TestMybatis.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    import com.leeyom.pojo.User;
    import com.leeyom.service.user.UserService;
    import org.junit.Before;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class TestMybatis {
    private ApplicationContext ac = null;
    private UserService userService = null;
    @Before
    public void before() {
    ac = new ClassPathXmlApplicationContext("classpath:spring/spring-mybatis.xml");
    userService = (UserService) ac.getBean("userService");
    }
    @Test
    public void testMybtis() {
    User user = userService.getUserById(1);
    System.out.println(user.getuName() + "------>" + user.getuPassword());
    }
    }

如果打印信息如下,说明是spring与mybatis整合成功

那其实现在就有个问题,为什么ssm-service模块可以调用到ssm-dao模块呢?这就是我们之前说的,模块之间的依赖的关系,因为ssm-service的pom文件中有依赖到ssm-daossm-common两个模块,所以在ssm-service模块可以调用到ssm-dao中的类,这也就验证了我们之前的各模块的依赖关系图。

整合Spring mvc

spring 与 mybatis已经整合完毕,接下来Spring mvc的整合。

  1. 创建spring-mvc.xml配置文件

    该配置文件的存放路径依旧是ssm-web模块的资源文件夹resources/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
    37
    38
     <?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">

    <!-- 自动装配 -->
    <context:component-scan base-package="com.leeyom.controller" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
    </context:component-scan>

    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"></property>
    </bean>

    <!-- 文件上传 -->
    <bean id="multipartResolver"
    class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 默认编码 -->
    <property name="defaultEncoding" value="utf-8"/>
    <!-- 文件大小最大值 -->
    <property name="maxUploadSize" value="10485760000"/>
    <!-- 内存中的最大值 -->
    <property name="maxInMemorySize" value="40960"/>
    </bean>

    <!--启用该标签代表 spring mvc 不拦截css、js、jpg等相关的静态资源-->
    <mvc:default-servlet-handler/>

    <!-- 启用spring mvc 注解 -->
    <mvc:annotation-driven></mvc:annotation-driven>
    </beans>
  2. 配置ssm-web模块下面的web.xml文件
    千万别忘记配置web.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
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
     <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">
    <display-name>Archetype Created Web Application</display-name>
    <!-- Spring和mybatis的配置文件 -->
    <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring/spring-mybatis.xml</param-value>
    </context-param>
    <!-- 编码过滤器 -->
    <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <async-supported>true</async-supported>
    <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>

    <!-- Spring监听器 -->
    <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 防止Spring内存溢出监听器 -->
    <listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
    </listener>

    <!-- Spring MVC -->
    <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring/spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
    </servlet-mapping>
    <welcome-file-list>
    <welcome-file>/index.jsp</welcome-file>
    </welcome-file-list>
    </web-app>
  1. 在ssm-web模块的java文件夹下面创建UserHandler.java测试handler类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    @Controller
    public class UserHandler {
    @Autowired
    UserService userService;
    /**
    * description: 测试 spring mvc
    * author: leeyom
    * date: 2017-07-31 10:47
    * Copyright © 2017 by leeyom
    */
    @RequestMapping(value = "/getUserById", method = {RequestMethod.POST, RequestMethod.GET})
    public String getUserById(HttpServletRequest request, Model model) {
    //参数
    Integer userId = StringUtils.notNull(request.getParameter("userId")) ? Integer.parseInt(request.getParameter("userId")) : 1;
    User user = userService.getUserById(userId);
    model.addAttribute("user", user);
    return "test";
    }
    }
  2. 在ssm-web模块的WEB-INF文件夹下面创建test.jsp页面

    1
    2
    3
    4
    5
    6
    7
    8
    9
     <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
    <title>测试spring mvc</title>
    </head>
    <body>
    <h1> hello world! </h1> ${user.uName}
    </body>
    </html>
  3. 经过以上的准备,我们现在就可以编译整个项目,编译的结果如下,就说明编译成功,否则就是编译失败。


  4. 通过整个项目的编译,ssm-commonssm-pojossm-daossm-service分别被达成jar,ssm-web被打包成war,最后我们就是要把war通过tomcat容器跑起来。

  5. 访问localhost:8089/ssm-demo/getUserById?userId=1,如果页面出现如下的熟悉界面,恭喜你,三大框架整合成功!!!

总结

到此为止我们Maven的多模块 Spring MVC + Spring + Mybatis 项目的搭建就已经完成,后期就可以在此基础上添加更多的功能。写这篇文章的目的是看到很多的单模块的ssm项目的搭建,却很少看到多模块的ssm项目搭建,所以就在此抛砖迎玉,重新搭建了一番,中间如果有什么不懂的,或者我写的不对的,大家都可以讨论。如果你觉得有用,就帮忙点个star吧!
源码地址:https://github.com/wangleeyom/ssm-demo

文章目录
  1. 1. 为什么要搭建多模块的maven项目?
  2. 2. 项目结构
    1. 2.1. 项目整体目录
    2. 2.2. 各模块的依赖关系
  3. 3. Maven多模块项目创建
  4. 4. SSM框架的整合
    1. 4.1. Spring 与 mybatis 的整合
    2. 4.2. 整合Spring mvc
  5. 5. 总结
,
粤ICP备17147440号