SSM框架自学(五)——Maven构建SSM项目快速入门

前言：目前大部分的 Java 互联网项目，都是用 Spring MVC + Spring + MyBatis 搭建平台的。毫无疑问，SSM框架已经成了 Java 互联网技术主流框架组合，它们经受住了大数据量和大批量请求的考验，完全可以构建高性能的大型网站。这篇文章主要讲讲我在IDEA下利用Maven如何快速搭建一个整合SSM框架的Web项目，包括服务端和前端 。                                     

使用 Maven 构建 SSM 项目，如果对于 Maven 不熟悉的童鞋可以去我这篇博客简单学习一下 Maven 的使用：

 Maven项目管理工具快速入门教程

技术体系和开发环境说明：

SSM框架：Spring 4.3.5.RELEASE+Mybatis3.4.1

Mysql数据库:Mysql 5.7

Web应用服务器Tomcat：Tomcat 7.0.69

JSP+JSON格式传输

IntelliJ IDEA

Maven项目管理工具

Log4j日志系统工具

Junit4单元测试工具

Alibaba Java Coding Guidelines 代码规范检查工具

下面是我配置好Maven本地仓库和使用阿里云公共仓后 的 IDEA 环境下的构建过程：

第一步：创建 Maven webapp 项目

1.1 首先新建工程，选择 Maven 标签，然后勾选上【Create from archetype】选择maven-archetype-webapp　

一个最简单的Maven war项目模板，当需要快速创建一个Web应用的时候可以使用它

1.2 Next，填写项目坐标

1.3 这一步可以看到 Maven 配置中的参数，不需要做改动，直接Next就可以（图中的路径是我配置的本地 Maven 仓库的地址)

1.4 确认项目名称，点击【Finish】即可完成创建

1.5 创建完毕后如下, 下面就是 Maven 风格的 webapp 的默认目录结构

其中pom.xml为工程的项目对象模型，可以理解为工程的说明文件，主要描述工程信息、依赖对象、构建方式等等信息。

我们还可以看到新建完成的项目有src/main/webapp的文件夹，但是还少三个root文件夹，分别是：src/main/java 、 src/main/resources 和src/main/test文件夹。

第二步：SSM框架工程目录结构创建

接着我们将按下述步骤创建SSM框架的基本工程结构：

1、在main文件下创建java文件夹，并右键点击java文件夹，选择Mark Directory As选项为Sources Root

2、在java文件夹下依次创建dao、service、controller三个包，分别表示dao层、业务层、控制层

3、在dao包下创建entity包，存放实体类

4、在service包下创建impl包，存放业务实现类

5、在main文件下创建resources文件夹，并右键点击java文件夹，选择Mark Directory As选项为Resources Root

6、在resources文件夹下创建mappers文件夹，用于存放dao层的映射文件

7、在resources文件夹下创建jdbc.properties、log4j.properties、spring-mvc.xml、spring-mybatis.xml四个空文件

8、在main文件下创建test文件夹，并右键点击java文件夹，选择Mark Directory As选项为Test Sources Root

注意：因为新建好的src/main/java 和 src/main/resources 只是一个简单的文件夹，而通常这两个文件夹都是用来放我们的java文件和资源文件的，所以需要将他们标记为root,以便让IDEA 识别不同的目录作用。

遵循 Maven 的统一项目结构，我们搭建出项目的完整目录结构如下图：

第三步、配置SSM项目的文件内容

3.1、在【pom.xml】文件中声明SSM项目所有依赖的 jar 包

pom.xml为工程的项目对象模型，可以理解为工程的说明文件，主要描述工程信息、依赖对象、构建方式等等信息。

想用什么jar包，直接填写在pom.xml配置文件中，Maven就会自动帮我们下载jar依赖包到工程中，我们还能通过配置让jar包时刻保持最新版本。

<?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.hs</groupId>
  <artifactId>SSMTest</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>SSMTest Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>

    <!-- 设置项目编码 -->
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- spring版本号 -->
    <spring.version>4.3.5.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.4.1</mybatis.version>
    <!-- mysql驱动版本号 -->
    <mysql-driver.version>5.1.33</mysql-driver.version>
    <!--slf4j-log4j12日志包版本号 -->
    <slf4j-log4j12.version>1.7.28</slf4j-log4j12.version>

  </properties>

  <dependencies>

    <!--pom.xml默认就会配置的Junit单元测试，这里我修改了版本-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <!-- 指定范围，在测试时才会加载 -->
      <scope>test</scope>
    </dependency>

    <!-- java ee -->
    <dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>7.0</version>
    </dependency>

    <!--不添加会报500访问jsp网页错误，找不到此类-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
      <scope>runtime</scope>
    </dependency>

   <!-- 添加日志jar包 ，建议通过slf4j设计日志系统，方便扩展：slf4j-log4j12这个包
  依赖了slf4j和log4j，所以使用slf4j+log4j的组合只要配置上面这一个依赖就够了-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j-log4j12.version}</version>
    </dependency>

    <!-- 添加jackson,用于SpringMVC默认就支持的json转换器MappingJackson2HttpMessageConverter(基于Jackson的JSON转换器，能够将对象转换成JSON格式的数据)-->
    <!--对于系统中默认包含的json转换器，只要我们在项目中加入转换器所依赖的JAR包，相关转换器就会被自动加载。-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.8.7</version>
    </dependency>

    <!-- 添加fastjson，效率更好并且适应场景更多，可以用来代替SpringMVC默认的jackson或Gson数据转换器-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.41</version>
    </dependency>

    <!-- 数据库 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql-driver.version}</version>
      <scope>runtime</scope>
    </dependency>

    <!-- 数据库连接池 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.2</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>1.3.1</version>
    </dependency>

    <!-- 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-context</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-tx</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-test</artifactId>
      <version>${spring.version}</version>
    </dependency>


    <!-- 以下是 SpringAOP所需要的包 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.9.1</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.1</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>

    <!--CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。-->
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.2.2</version>
    </dependency>
    <!-- 以上是 SpringAOP 所需要的包 -->

  </dependencies>

  <build>
    <finalName>SSMTest</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

</project>

3.2 添加SSM框架相关配置文件的内容

a、在【web.xml】中声明编码过滤器并配置 DispatcherServlet

<?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_3_1.xsd"
         version="3.1">

  <display-name>ssm-test</display-name>

  <!-- 1、让Web项目知道这些配置文件的存在并让它们起作用，web项目的所有部分都将共享的上下文 ServletContext 对象，会以键值对的形式保存<context-param> 信息-->
  <!--配置Spring IoC-->
  <!--ContextLoaderListener的作用就是启动Web容器时自动装配ApplicationContext的配置信息：默认Web容器会自动加载/WEB-INF/applicationContext.xml初始化ApplicationContext实例-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--如果需要指定配置文件位置，可通过context-param加以指定-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-mybatis.xml</param-value>
  </context-param>

  <!-- 配置LOG4J -->
  <context-param>
    <param-name>log4jConfigLocation</param-name>
    <param-value>classpath:log4j.properties</param-value>
  </context-param>

  <!-- 2、编码过滤器 -->
  <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>

  <!-- 3、配置DispatcherServlet -->
  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--配置SpringMVC需要加载的配置文件,spring-mvc.xml因为被配置在DispatcherServlet的初始化过程中，所以如果不初始化servlet，那么spring-servlet.xml是不会被发现的-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath: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>

  <!--总结：Spring框架在加载web.xml配置文件的时候。首先加载的是context-param配置的内容，而并不会去初始化servlet。
  只有进行了网站的跳转，经过了DispatcherServlet的导航的时候，才会初始化servlet，从而加载init-param中的内容。-->

</web-app>

b、在【spring-mvc.xml】中完成 Spring MVC 的相关配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

    <!-- 启用包自动扫描功能，找到使用注解@Controller相关的bean注入IOC容器管理-->
    <context:component-scan base-package="com.hs.controller"/>

    <!-- 开启SpringMVC注解模式 -->
    <mvc:annotation-driven/>

    <!-- 静态资源(js、image等)的访问,默认servlet配置 -->
    <mvc:default-servlet-handler/>

    <!--DispatcherServlet 将会使用视图解析器（ViewResolver）来将逻辑视图名匹配为一个特定的视图实现，它可能是也可能不是 JSP-->
    <!--【WEB-INF】是 Java Web 中默认的安全目录，是不允许用户直接访问的（也就是你说你通过 localhost/WEB-INF/ 这样的方式访问不到-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

c、在【spring-mybatis.xml】中完成 spring 和 mybatis 的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 自动扫描service.service包下所有使用注解的类型,base-package为需要扫描的包(含子包)。-->
    <context:component-scan base-package="com.hs.service"/>

    <!-- 加载一个properties文件 ，配置数据库相关参数properties的属性：${url} -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
        <!-- 这个必须写在minPoolSize和maxPoolSize之间，表示初始化时获取的连接数，这个值一般设警告置为minPoolSize，缺省时默认为3。不设置Logj4会发出[Warn]警告-->
        <property name="initialPoolSize" value="10"/>
        <property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
        <property name="autoCommitOnClose" value="${c3p0.autoCommitOnClose}"/>
        <property name="checkoutTimeout" value="${c3p0.checkoutTimeout}"/>
        <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
    </bean>

    <!-- mybatis和spring完美整合，不需要mybatis的配置映射文件 -->
    <!-- 配置SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 扫描entity包 使用别名 -->
        <property name="typeAliasesPackage" value="com.hs.dao.entity"/>
        <!-- 扫描sql配置文件:mapper需要的xml文件 -->
        <property name="mapperLocations" value="classpath:mappers/UserDapMapper.xml"/>
    </bean>

    <!--Mapper批量扫描器：会扫描Dao接口包，动态实现Dao接口，自动创建代理对象并注入到spring IOC容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描Dao接口包 -->
        <property name="basePackage" value="com.hs.dao"/>
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 配置基于注解的声明式事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

d、在【jdbc.properties】中配置 c3p0 数据库连接池

#配置 c3p0 数据库连接池：

jdbc.driver=com.mysql.jdbc.Driver
#数据库地址
jdbc.url=jdbc:mysql://localhost:3306/mengtu?useUnicode=true&characterEncoding=utf8
#用户名
jdbc.username=root
#密码
jdbc.password= your password
#最小连接数
c3p0.minPoolSize=10
#最大连接数
c3p0.maxPoolSize=30
#关闭连接后不自动commit
c3p0.autoCommitOnClose=false
#获取连接超时时间
c3p0.checkoutTimeout=10000
#当获取连接失败重试次数
c3p0.acquireRetryAttempts=2

f、在【log4j.properties】中配置logj日志系统

#Log4j日志系统框架在运行的时候会加载项目路径下的 log4j.properties 配置文件，可以提供方便的日志记录，我们通过查看日志文件可以方便项目的Bug调试。

#log4j.rootLogger = [level] , appenderName1 , appenderName2 , … 这里表示默认输出Info级别以上的日志到控制台和文件中
log4j.rootLogger=INFO,Console,File,D

#控制台日志：输出Info级别以上的日志信息到控制台
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=[%p][%t][%d{yyyy-MM-dd HH\:mm\:ss}][%C] - %m%n

#普通文件日志：输出Info级别以上的日志到src同级目录logs中的ssm.log文件中
log4j.appender.File=org.apache.log4j.RollingFileAppender
log4j.appender.File.File=logs/ssm.log
log4j.appender.File.MaxFileSize=10MB
#Threshold是个全局的过滤器，它将把低于当前所设置的level的信息过滤不显示出来，但是要注意Threshold指定的日志级别必须得比最上面rootLogger设置的level更高才有效
log4j.appender.File.Threshold=ALL
log4j.appender.File.layout=org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern=[%p][%t][%d{yyyy-MM-dd HH\:mm\:ss}][%C] - %m%n

### 输出error级别以上的日志到硬盘中 = D://Maven/error.log ###
log4j.appender.D= org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File =D://Maven/error.log 
log4j.appender.D.Append = true
log4j.appender.D.Threshold = ERROR 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n


#插件技巧提示：
# 1、配置IDEA控制台的多颜色log日志输出功能：由于idea不支持显示ascii颜色，grep-console插件能很好的解决这个问题。打开Setting，选中Plugins,输入框里搜索Grep-Console插件安装使用
# 2、配置log文件的多颜色日志查看功能：查看ssm.log日志文件idea会弹出下载Ideolog插件，这插件可以让我们更加直观的查看log日志,根据等级显示不同颜色

到这里第三步为止，创建Maven Web工程、SSM框架的工程目录结构的创建和SSM框架所需的基本配置文件都已经完成了。

第四步：编写代码，整合SSM 框架

经过前三步处理步骤，下面的第四步终于可以正式敲代码啦，感觉这些目录结构的创建和配置SSM的XML文件都是特别繁琐毫无意义的工作，希望过几天我学会约定大于配置的SpringBoot 可以摆脱这个困局。

4.1、首先准备好用来测试的Mysql数据库，就一张user表

4.2、接下来编写Dao层代码、Service层和Controller层代码

a、Dao层

在【com.hs.dao.entity】包下创建好对应的实体类 User ：

package com.hs.dao.entity;

/**
*   用户实体类
 */

public class UserEntity {

    //属性名必须与数据库表的字段名一致，以便Mybatis直接把实体类映射成数据库记录
    private Integer uid; //用户id
    private String username;//用户名
    private String password;//用户密码

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

在【com.hs.dao】包下创建好Dao接口：

package com.hs.dao;

import com.hs.dao.entity.UserEntity;

/**
 * 用户Dao类:从数据库存取数据的逻辑会放置在 DAO 层（Date Access Object，数据访问对象），接口中的方法与Mapper映射文件中的SQL语句的ID一一对应
 */
public interface UserDao
{
    /**
     * 根据用户id查找用户
     *
     * @param uid
     * @return
     */
    UserEntity selectById(Integer uid);

    /**
     * 更新用户记录
     *
     * @param userEntity
     * @return
     */
    Integer update(UserEntity userEntity);

    /**
     * 删除用户记录
     *
     * @param uid
     * @return
     */
    Integer delete(Integer uid);

    /**
     * 插入用户记录
     *
     * @param userEntity
     * @return
     */
    Integer insert(UserEntity userEntity);
}

在【resources/mappers】下编写 UserDao.xml 映射文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--Mapper动态代理方式：直接设置命名空间为UserDao接口的方法提供sql语句映射 (不需要使用@Mapper注解)，mybatis可以自动生成dao(本来是mapper)接口实现类代理对象。
在代码中可以直接使用DAO接口而不需要再编写实现类，面向接口编程-->
<mapper namespace="com.hs.dao.UserDao">

    <select id="selectById"  parameterType="java.lang.Integer" resultType="com.hs.dao.entity.UserEntity">
        SELECT *
        FROM user
        WHERE uid=#{uid};
    </select>

    <update id="update" parameterType="com.hs.dao.entity.UserEntity">
        UPDATE user
        SET uid=#{uid},username=#{username},password=#{password}
        WHERE uid=#{uid}
    </update>

    <delete id="delete" parameterType="java.lang.Integer">
        DELETE FROM user
        WHERE uid=#{uid}
    </delete>

    <insert id="insert" parameterType="com.hs.dao.entity.UserEntity">
        <selectKey keyProperty="id" resultType="java.lang.Integer"
                   order="AFTER">
            SELECT
            LAST_INSERT_ID()
        </selectKey>
        INSERT INTO
        user(uid,username,password)
        VALUES(#{uid},#{username},#{password});
    </insert>

</mapper>

在编写好每一个 Dao 的时候，我们都需要对它进行单元测试：

不熟悉Junit4单元测试可以看我这篇文章：Junit单元测试工具使用总结

package com.hs.dao;

import com.hs.dao.entity.UserEntity;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import static org.junit.Assert.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring-mybatis.xml"})
public class UserDaoTest {

    @Autowired
    UserDao userDao;

    @Test
    public void selectById() {

        UserEntity user = userDao.selectById(1);
        System.out.println(user.getId()+":"+user.getPassword()+":"+user.getUsername());
    }

    @Test
    public void update() {
    }

    @Test
    public void delete() {
    }

    @Test
    public void insert() {
    }
}

b、Service层

在【com.hs.service】包下编写好对应的 UserService 接口

package com.hs.service;

import com.hs.dao.entity.UserEntity;

/**
 * 用户服务类
 *
 */
public interface UserService {
    /**
     * 创建用户
     *
     * @param userEntity
     * @return
     */
    Integer createUser(UserEntity userEntity);

    /**
     * 更新用户
     *
     * @param userEntity
     * @return
     */
    Integer updateUser(UserEntity userEntity);

    /**
     * 删除用户
     *
     * @param uid
     * @return
     */
    Integer deleteUser(Integer uid);

    /**
     * 根据用户id查询用户
     *
     * @param uid
     * @return
     */
    UserEntity getUserById(Integer uid);
}

在【com.hs.service.impl】包下编写好对应的 UserService 接口对应的实现类UserServiceImpl

package com.hs.service.impl;

import com.hs.dao.UserDao;
import com.hs.dao.entity.UserEntity;
import com.hs.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * 用户服务实现类
 *
 */
@Service
public class UserServiceImpl implements UserService
{
    @Resource//@Resource的作用相当于@Autowired,都可以用来自动装配bean
    private UserDao userDao;

    @Override
    public Integer createUser(UserEntity userEntity) {
        return userDao.insert(userEntity);
    }

    @Override
    public Integer updateUser(UserEntity userEntity) {
        return userDao.update(userEntity);
    }

    @Override
    public Integer deleteUser(Integer uid) {
        return userDao.delete(uid);
    }

    @Override
    public UserEntity getUserById(Integer uid) {
        return userDao.selectById(uid);
    }
}

c、Controller层

在【com.hs.controller】下创建【UserController】控制类

package com.hs.controller;

import com.alibaba.fastjson.JSON;
import com.hs.dao.entity.UserEntity;
import com.hs.service.UserService;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import javax.annotation.Resource;

/**
*采用@Contoller注解的方式，将@Controller标记在某个类上，配合@RequestMapping注解，可以在一个类中定义多个接口(URL请求和Controller方法之间的映射)，这样的Controller
* 就能被外界访问到,@RequestMapping标记的方法会被分发处理器扫描识别，将不同的请求分发到对应的接口上。
* 相比自定义Controller类实现Controller接口并在Spring MVC的映射配置文件将某个接口与自定义Controller类做映射这种只能处理一个单一请求的方式来说更灵活方便。
 */

@Controller
public class UserController {

    private static Logger logger = Logger.getLogger(UserController.class);//Logj4日志系统工具
    @Resource
    private UserService userService;

    /**
    *1、使用 Spring MVC 所提供的 ModelAndView 对象来绑定数据和视图的形式
     */
    @RequestMapping(value = "/user")
    public ModelAndView user ()
    {
        logger.info("user()方法被调用");
        logger.error("666666666666只是测试用");//记录error级别的信息
        ModelAndView mv = new ModelAndView();//Spring MVC 通过 ModelAndView 对象把模型和视图结合在一起,即它里面包含了Model和View的对象

        //通过SpringMVC和Mybatis
        UserEntity userEntity = userService.getUserById(1);
        mv.addObject("user",userEntity);
        String str = JSON.toJSONString(userEntity);
        logger.info(str);

        mv.addObject("message", "测试能不能通过Controller层返回jsp!");
        mv.setViewName("user");//也可以在new ModelAndView("user")构造函数中的参数指出试图逻辑名
        return mv;
    }

    /*
    //2、使用 Model 对象来绑定数据的形式
    @RequestMapping("/user")
    public String user (Model model)
    {
        System.out.println("user()方法被调用");
        model.addAttribute("message","999999999999");
        return "user";
    }
     */
}

Controller层用到了Logj4日志系统，这里的View层我使用了返回JSP网页的方式。

不熟悉Logj4日志系统工具的用法，还有SpringMVC如何返回JSON格式的数据的同学可以看看我的另外两篇博客:

Log4j日志系统工具快速入门

SpringMVC如何返回JSON格式的数据

d、View层

最后在【WEB-INF/views】下创建 user.jsp 用于接收并显示数据

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<html>
<body>
<h1>${message}</h1>
<h2>${user.uid}：  ${user.username}   ${user.password}</h2>
</body>
</html>

第五步：配置好 Tomcat 服务器，部署SSM项目运行即可

5.1、在IDEA中选择EAdd Configurationsn，然后左上角点击 +号，找到Tomcat Server选择local进入本地Tomcat配置界面

5.2、设置好Tomcat后，IDEA右上角点击运行SSM项目，并在浏览器中输入：localhost/SSM_war/user

就这么简单的五个步骤，我们就实现了Maven构建SSM项目！！！

SSM 框架架构图

为了更加能理解 SSM 处理用户请求的整个过程，下面给出一张 SSM 系统架构图：

 SSM学习总结：

通过这个简单的Demo，我学会了Spring+SpringMVC+Mybatis三大框架，学会了使用Maven项目管理工具、Loj4日志系统和Junit4单元测试，后面两个工具真的是用着用着就会了，我会在下面博客会系统地写出来的。对了，还有SSM如何返回JSON格式的数据我也会单独提出来讲一讲。

此篇博客我已经把代码和配置文件注释得很详细了，希望大家能快速入门！

最后的最后，对下面两位博主致以敬意，谢谢你们写的如此仔细认真，谢谢你们的分享！

参考资料：

IDEA 整合 SSM 框架学习

学习SSM框架那些事儿