SSM 框架整合

SSM 框架 (Spring+SpringMVC+MyBatis)

　　SSM 框架是 (Spring+SpringMVC+MyBatis)的缩写，这个框架是继 SSH（Spring+Struts+Hibernate）之后，目前比较主流的 Java EE 企业级框架，适合搭建各种中小型的企业级应用系统。由于之前也没有Java Web相关的工作经验以及后台系统开发经验，更别说应用框架来开发应用系统了。通过各方面的了解，SSM框架作为轻量级应用框架，速度快，效率高，最主要的还是学习成本更低。这样我们能更快地学习并应用到我们的项目当中！所以，追踪器的项目选择了 SSM这套框架作为我们的后台开发框架！以下，便详细的说明各个框架的优缺点以及 框架的具体搭建步骤。

1、基本概念以及优缺点
1.1、Spring

一、基本概念

　　Spring 是一个开源框架，于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来，用来简化企业系统应用开发。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

二、优点

  • 通过 Spring 的 IOC特性，将对象的依赖关系都交给了 Spring 来控制，方便解耦，简化了开发 Controller-->Service -->Dao
  • 让代码结构更良好
  • 面向接口编程
  • 高低原则：高内聚、低耦合
  • 开闭原则：对扩展开放、对修改关闭
  • 通过 Spring 的 AOP 特性，很容易实现事务、日志、权限的控制管理
  • 提供了许多技术支持
  • 提供了辅助类，如：JdbcTemplate、HibernateTemplate、StringUtils、CollectionUtils、StreamUtils等
  • 提供单例模式
  • 提供对主流开源框架的提供集成支持，如 mybatis,shiro，Struts, Hibernate等
1.2、SpringMVC

一、基本概念

　　SpringMVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring MVC分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让他们更容易进行定制。

　　model 数据模型

　　View 视图

　　Controller 控制器

　　MVC 是一种 Web 应用架构，是一种代码设计思想（将所有客户端的请求全部交由控制器，有控制器将其分发并将结果响应给客户端），实际开发中，一般都会使用 MVC框架，如 Structs1、Structs2以及 SpringMVC等

二、优点

  • 使用注解配置，代替 xml 配置，开发更简单
  • 效率高，单例的
  • 扩展性好，用户自定义
  • SpringMVC 和 Spring 无缝衔接
  • 灵活的数据验证，格式化，数据绑定机制。

三、SpringMVC 主要是由 DispatcherServlet、处理器映射、控制器、视图解析器、视图组成。其中它的核心主要是处理器映射 HandlerMappinig (选择使用哪个控制器来处理请求) 和 视图解析器 ViewResolver (选择处理结果应该如何渲染页面)，框架的结构图如下：

工作流程：

  • Http 请求：客户端请求提交到 DispatcherServlet。
  • 寻找处理器：由 DispatcherServlet 控制器查询一个或多个HandlerMapping，找到处理请求的 Controller。
  • 调用业务处理和返回结果：Controller 调用业务逻辑处理后，返回ModelAndView。
  • 处理视图映射并返回模型： DispatcherServlet 查询一个或多个ViewResoler视图解析器，找到 ModelAndView指定的视图。
  • Http响应：视图负责将结果显示到客户端

　　简单来说就是这样一个过程：从“Request（请求）”开始，依次进入“DispatcherServlet（核心分发器）” —> “HandlerMapping（处理器映射）” —> “Controller（控制器）” —> “ModelAndView（模型和视图）” —> “ViewResolver（视图解析器）” —> “View（视图）” —> “Response（响应）”结束。

1.3、MyBatis

一、基本概念

　　MyBatis 本是 apache 的一个开源项目 iBatis, 2010年这个项目由 apache software foundation 迁移到了 google code，并且改名为 MyBatis 。MyBatis是一个基于 Java 的持久层 (可以将业务数据存储到磁盘，且具备长期存储能力，只要磁盘不损坏，在断电或者其它情况下，重新开启系统任然可以读取到这些数据) 框架。iBATIS提供的持久层框架包括 SQL Maps 和 Data Access Objects（DAO）MyBatis 消除了几乎所有的 JDBC 代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的 POJOs（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录。可以这么理解：Mybatis 是一个用来帮你管理数据增删改查的框架。

二、Mybatis 的优缺点：

优点：

  • sql 语句写在 XML 文件中，便于统一管理和优化，解除了 sql 和程序代码的耦合
  • 提供映射标签，支持对象和数据库 orm 字段关系的映射，支持对象的关系映射标签，支持对象关系的组建
  • 提供 XML 标签，支持编写动态 sql
  • 相对传统的 JDBC ,建立连接（Connection）、操作（Statment）、拿到数据 ResultSet ，处理相关异常等，这些都可以交给 Mybatis 去帮处理

缺点：

  • 工作量较大，特别是在表的字段多，关联表多的情况下 Mybatis中的逆向工程可以实现半自动化
  • sql 语句的编写依赖于数据库，可移植性差
  • 不支持级联删除，级联更新，需要自己对表进行删除
2、开发环境的要求

环境准备

  1. JDK 7或 8版本，本项目中用jdk1.8的版本
  2. IDEA、Eclipse、MyEclipse都可以，看使用习惯，推荐使用 IDEA工具
  3. Tomcat 8.5 版本
  4. MySql 数据库，版本：5.723
  5. Maven工具，版本 3.5
3、SSM 框架整合步骤
1.1、认识 Maven

一、简单介绍 Maven Apache Maven 是一个软件项目管理和构建工具，可以帮助我们创建和管理项目，基于项目对象模型 POM（Project Object Model）的概念，帮助开发者构造一个项目的完整生命周期。POM是 Maven对一个项目的描述，一个 POM就是一个 XML 文件。

二、为什么使用 Maven

  • 项目的管理工具 项目开发很多情况一定会将项目进行拆分，将一个项目拆分成多个模块，每个模块对应一个工程，多个工程之间存储依赖关系，此时可以使用 maven 的依赖管理机制，帮助我们与项目之间建立依赖关系
  • jar 包的管理工具 通过仓库管理 jar包，避免繁琐的导包；自动下载 jar 包；解决 jar 包之间的依赖等
  • 自动化构建工具 构建过程：编译主代码 --> 编译测试代码 --> 执行测试单元 -->生成测试报告 -->打包 --> 部署
1.2、使用 Maven 构建 SSM 项目

　　第一步：创建 Maven webapp 项目

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

　　点击下一步，填写上【GroupId】和【ArtifactId】：

    • GroupId：项目组织唯一的标识符，实际对应 JAVA 的包的结构，也就是 main 目录下 java 的目录结构（包）
    • AritifactId：项目的唯一标识符，实际对应项目的名称，就是项目根目录的名称
    • Version: 表示版本信息，这个默认就可以。

　　确认项目路径，这一步你可以看到 Maven 配置中的参数，不需要做改动，直接下一步就可以（图中的路径是我配置的本地 Maven 仓库的地址）：

确认项目 module 名称，点击【Finish】即可：

　　等待一会儿，控制台就会有创建成功的提示信息，我们把【Enable Auto-Import】点上，这个提示会在每次 pom.xml 有改动时出现，自动导入，省掉麻烦：

　　第二步：搭建项目目录结构

　　下面就是 Maven 风格的 webapp 的默认目录结构：

  • 注意： webapp 是默认没有 java 源文件也没有 test 目录的，图中的test目录是自己创建的。
  • 提示：我们可以在 IDEA 中右键目录然后选择【Make Directory as】，让 IDEA 识别不同的目录作用

　　第三步：pom.xml 文件中添加相关依赖 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.xiaomo.demo</groupId>
  <artifactId>ssm-study</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

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

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
      <junit.version>4.12</junit.version>
      <javax.servlet-api.version>3.1.0</javax.servlet-api.version>
      <jsp-api.version>2.2</jsp-api.version>
      <jstl.version>1.2</jstl.version>
      <spring-core.version>4.3.19.RELEASE</spring-core.version>
      <mybatis.version>3.4.5</mybatis.version>
      <mybatis-spring.version>1.3.1</mybatis-spring.version>
      <pagehelper.version>5.1.2</pagehelper.version>
      <mysql-connector-java.version>5.1.38</mysql-connector-java.version>
      <druid.version>1.1.6</druid.version>
      <fastjson.version>1.2.47</fastjson.version>
      <tomcat7-maven-plugin.version>2.2</tomcat7-maven-plugin.version>
      <mybatis-generator-maven-plugin.version>1.3.5</mybatis-generator-maven-plugin.version>
</properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
      <!-- java ee -->
      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>${javax.servlet-api.version}</version>
          <scope>provided</scope>
      </dependency>
      <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>${jsp-api.version}</version>
          <scope>provided</scope>
      </dependency>
      <dependency>
          <groupId>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>${jstl.version}</version>
      </dependency>

      <!-- spring -->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <version>${spring-core.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>${spring-core.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-beans</artifactId>
          <version>${spring-core.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>${spring-core.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-expression</artifactId>
          <version>${spring-core.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aop</artifactId>
          <version>${spring-core.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aspects</artifactId>
          <version>${spring-core.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>${spring-core.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-tx</artifactId>
          <version>${spring-core.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>${spring-core.version}</version>
      </dependency>

      <!-- mybatis -->
      <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>${mybatis.version}</version>
      </dependency>
      <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis-spring</artifactId>
          <version>${mybatis-spring.version}</version>
      </dependency>
      <!-- mysql -->
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>${mysql-connector-java.version}</version>
      </dependency>
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>${druid.version}</version>
      </dependency>

      <!--json工具-->
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>${fastjson.version}</version>
      </dependency>

      <!--日志-->
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-api</artifactId>
          <version>1.7.25</version>
      </dependency>
      <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>1.2.17</version>
      </dependency>
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-log4j12</artifactId>
          <version>1.7.21</version>
      </dependency>

  </dependencies>

  <build>
    <finalName>demo</finalName>
      <resources>
          <resource>
              <directory>src/main/java</directory>
              <includes>
                  <include>**/*.xml</include>
                  <include>**/*.properties</include>
              </includes>
          </resource>
          <resource>
              <directory>src/main/resources</directory>
              <includes>
                  <include>**/*.xml</include>
                  <include>**/*.properties</include>
              </includes>
          </resource>
      </resources>
    <plugins>
        <!--配置mybatis反向生成插件-->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>${mybatis-generator-maven-plugin.version}</version>
            <configuration>
                <verbose>true</verbose>
                <overwrite>true</overwrite>
            </configuration>
        </plugin>
    </plugins>

  </build>
</project>
  • 备注：记得配置相关资源打包，避免资源文件打包的时候漏掉！
<resources>
            <resource>
              <directory>src/main/java</directory>
              <includes>
                <include>**/*.xml</include>
                <include>**/*.properties</include>
              </includes>
            </resource>
            <resource>
              <directory>src/main/resources</directory>
              <includes>
                <include>**/*.xml</include>
                <include>**/*.properties</include>
              </includes>
            </resource>
          </resources>
  • 在pom.xml 文件中，你还可以配置 tomcat 插件：
<plugins>
          <!--配置mybatis反向生成插件-->
          <plugin>
          	<groupId>org.mybatis.generator</groupId>
              <artifactId>mybatis-generator-maven-plugin</artifactId>
              <version>1.3.5</version>
              <configuration>
                  <verbose>true</verbose>
                  <overwrite>true</overwrite>
              </configuration>
          </plugin>
          <plugin>
          <!--配置tomcat-->
       	   <groupId>org.apache.tomcat.maven</groupId>
             <artifactId>tomcat7-maven-plugin</artifactId>
             <configuration>
               <path>/</path>
               <port>8888</port>
               </configuration>
              </plugin>
</plugins>
4、编写配置文件
1.1、Mybatis整合Spring的配置文件，Spring-dao.xml。如下：
<?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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--读取属性文件-->
    <context:property-placeholder location="classpath:dataSource.properties"/>

    <!--创建数据源-->
    <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="maxActive" value="${jdbc.maxActive}"/>
        <property name="minIdle" value="${jdbc.minIdle}"/>
    </bean>

    <!-- mybatis与Spring整合 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mapperLocations" value="classpath:com/xiaomo/study/dao/mapper/*.xml"/>
        <!--mybatis 别名（实体类对象）包扫描-->
        <property name="typeAliasesPackage" value="com.xiaomo.study.entity"/>
    </bean>

    <!-- mybatis的Mapper接口扫描 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--mapper 接口扫描包-->
        <property name="basePackage" value="com.xiaomo.study.dao"/>
    </bean>

</beans>
1.2、 配置（数据库连接的）属性文件，dataSource.properties。如下：
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/demo_db?useSSL=false
jdbc.username=
jdbc.password=
jdbc.initialSize=5
jdbc.maxActive=100
jdbc.minIdle=20
  • 备注：这里面属性最好是加上前缀，如 jdbc.*，目的是为了避免，获取username 的时候，如果不加前缀则会获取电脑用户的名字！！
1.3、 配置 Spring 文件，主要配置 Spring 的 IOC 以及事务管理，Spring-service.xml。如下：
<?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">
    <!-- 开启IOC注解 -->
    <context:component-scan base-package="com.xiaomo.study.service.impl"/>
    <!--spring 事务配置-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--开启事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
1.4、配置Spring 整合SpringMVC的文件，Spring-mvc.xml。如下：
<?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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置注解驱动以及fastjson-->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
                 <property name="supportedMediaTypes" value="application/json;charset=utf-8"/>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
    <!--扫描 controller 包-->
    <context:component-scan base-package="com.xiaomo.study.controller"/>
    <!--配置视图解析-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/views/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>
1.5、 配置 web.xml 文件，通过 web 程序启动，来加载所有配置以及资源文件， 这是整个框架的入口。如下：
<?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">

    <!--Spring +spring mvc，可以只配置 DispatcherServlet,启动spring mvc-->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!--配置读取spring mvc 配置文件-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring*.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--配置过滤器，解决乱码问题-->
    <filter>
        <filter-name>encodingFileter</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>encodingFileter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>
1.6、 编写日志文件 log4j.properties
### 设置###
    log4j.rootLogger = info,stdout,D,E
    ### 输出信息到控制抬 ###
    log4j.appender.stdout = org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target = System.out
    log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
    ### 输出DEBUG 级别以上的日志到=E://logs/debug.log 包括 error debug info###
    log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
    log4j.appender.D.File = E://logs/log.log
    log4j.appender.D.Append = true
    log4j.appender.D.Threshold = DEBUG 
    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
    ### 输出ERROR 级别以上的日志到=E://logs/error.log ###
    log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
    log4j.appender.E.File =E://logs/error.log 
    log4j.appender.E.Append = true
    log4j.appender.E.Threshold = ERROR 
    log4j.appender.E.layout = org.apache.log4j.PatternLayout
    log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
5、编写测试类
  • 步骤3中， 1.1 到 1.6 步骤配置文件的完成，SSM框架也就基本搭好了！接下来，我们可以写一个测试类进行验证，如下：
1.1、编写一个简单的前端客户信息录入页面（input.jsp）：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>用户录入界面</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/user/login" method="post">
        用户姓名：<input type="text" name="name"><br>
        用户年龄：<input type="text" name="age"><br>
        用户性别：<input type="text" name="gender"><br>
        <input type="submit" value="保存">
    </form>
</body>
</html>
1.2、客户信息录入成功页面（success.jsp）：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>提示页面</title>
</head>
<body>
    <p>success!</p>
</body>
</html>
1.3、客户信息录入失败页面（fail.jsp）：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>提示页面</title>
</head>
<body>
    <p>fail!</p>
</body>
</html>
1.4、编写一个测试 UserController类，客户信息录入界面，点击保存按钮，返回数据给前端页面：
package com.xiaomo.study.controller;

import com.xiaomo.study.entity.User;
import com.xiaomo.study.service.UserDaoService;
import com.xiaomo.study.utils.ResultJsonData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * Author: 小莫
 * Date: 2018-12-05 16:18
 * Description:<描述>
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserDaoService userDaoService;

    @RequestMapping("input")
    public String input(){
        return "input";
    }

    @RequestMapping("login")
    @ResponseBody
    public ResultJsonData userLogin(User user){
        if (userDaoService.addUser(user)) {
            return ResultJsonData.success("success",user);
        }else{
            return ResultJsonData.fail("fail",user);
        }
    }
}
6、验证结果
  • 打开浏览器，在地址栏输入：http://localhost:8080/user/input

　　点击保存按钮，结果如下：

　　表明客户信息成功录入，此时查看数据库中数据：

　　至此，SSM 框架便成功完成整合！

posted on 2019-07-25 14:15  农夫三拳有點疼  阅读(45)  评论(0)  编辑  收藏  举报

导航