Spring+Spring MVC+MyBatis的整合

最新推荐文章于 2022-07-21 09:10:08 发布

老臣、

最新推荐文章于 2022-07-21 09:10:08 发布

阅读量2k

点赞数 1

分类专栏： Spring Java MyBatis Spring技术栈文章标签： SSM Spring

本文链接：https://blog.csdn.net/vae1314chuanchen/article/details/79560925

版权

Java 同时被 3 个专栏收录

35 篇文章 0 订阅

订阅专栏

Spring技术栈

19 篇文章 3 订阅

订阅专栏

Spring

11 篇文章 0 订阅

订阅专栏

一、概述

　　在WEB开发中我们往往会借助框架来简化自己的开发过程，本文介绍了SSM框架的整合，从而搭建一个简单的Web框架。
　　
　　环境参数：
　　操作系统：windows10 64位
　　jdk版本：jdk1.8 64位
　　Maven版本：3.50
　　MySql版本：mysql-server 5.7
　　Tomcat版本：apache-tomcat-7.
　　数据库管理和设计工具：navicat
　　开发工具及版本：IntelliJ IDEA 2017.2.5

二、SSM整合前的准备

　　一、使用IntelliJ IDEA创建一个基于Maven构建的web工程，工程名称暂时叫SSM。在创建好的工程中先创建几个包，如下所示：
这里写图片描述
　　二、新建一个数据库，命名为ssm。在ssm数据库中创建一张员工表命名为tbl_emp，一张部门表，命名为 tbl_dept。每个表的结构如下所示：

　　OK，项目与数据库都创建好之后，我们开始Spring+Spring MVC+MyBatis的整合。

三、配置pom文件

　　由于本项目是一个基于Maven构建的web工程，所以需要配置pom.xml文件来管理Spring、Spring MVC、MyBatis以及他们整合时所需的jar包。
　　Spring各个jar包作用如下：

Spring AOP：Spring的面向切面编程，提供AOP（面向切面编程）的实现。
Spring Aspects：Spring提供的对AspectJ框架的整合。
Spring Beans：Spring IOC的基础实现，包含访问配置文件、创建和管理bean等。
Spring Context：在基础IOC功能上提供扩展服务，此外还提供许多企业级服务的支持，有邮件服务、任务调度、JNDI定位，EJB集成、远程访问、缓存以及多种视图层框架的支持。
Spring Context Support：Spring context的扩展支持，用于MVC方面。
Spring Core：Spring的核心工具包。
Spring expression：Spring表达式语言。
Spring JDBC：对JDBC 的简单封装。
Spring JMS：为简化jms api的使用而做的简单封装。
Spring orm：整合第三方的orm实现，如hibernate，ibatis，jdo以及spring 的jpa实现。
Spring oxm：Spring对于object/xml映射的支持，可以让JAVA与XML之间来回切换。
Spring test：对JUnit等测试框架的简单封装。
Spring tx：为JDBC、Hibernate、JDO、JPA等提供的一致的声明式和编程式事务管理。
Spring web：包含Web应用开发时，用到Spring框架时所需的核心类，包括自动载入WebApplicationContext特性的类、Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。
Spring webmvc：包含Spring MVC框架相关的所有类。包含国际化、标签、Theme、视图展现的FreeMarker、JasperReports、 Tiles、Velocity、XSLT相关类。当然，如果你的应用使用了独立的MVC框架，则无需这个JAR文件里的任何类。
Spring websocket：提供 Socket通信， web端的推送功能

　　pom文件的示例代码如下：

<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">
  <modelVersion>4.0.0</modelVersion>
  <groupId>SSM</groupId>
  <artifactId>SSM</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>SSM Maven Webapp</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
    <!-- spring版本号 -->
    <org.springframework.version>4.3.12.RELEASE</org.springframework.version>
    <!-- mybatis版本号 -->
    <org.mybatis.version>3.4.4</org.mybatis.version>
    <!-- spring-mybatis版本号 -->
    <org.mybatis.spring.version>1.3.0</org.mybatis.spring.version>
  </properties>

  <dependencies>
    <!--JSR303数据校验支持；tomcat7及以上的服务器，
        tomcat7以下的服务器：el表达式。额外给服务器的lib包中替换新的标准的el
     -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>5.4.1.Final</version>
    </dependency>

    <!--j2ee相关包 servlet、jsp、jstl-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
    </dependency>

    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>


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

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

    <!--spring的事务管理-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>

    <!--spring的单元测试-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>

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

    <!--spring面向切面编程-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>

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

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

    <!--mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${org.mybatis.version}</version>
    </dependency>

    <!--mybatis-spring整合-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${org.mybatis.spring.version}</version>
    </dependency>

    <!--数据库连接池-->
    <!--c3p0-->
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>

    <!--或者dbcp-->
    <!--<dependency>-->
    <!--<groupId>commons-dbcp</groupId>-->
    <!--<artifactId>commons-dbcp</artifactId>-->
    <!--<version>1.4</version>-->
    <!--<scope>runtime</scope>-->
    <!--</dependency>-->

    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>


    <!--apache.commons-->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.5</version>
    </dependency>

    <dependency>
      <groupId>commons-collections</groupId>
      <artifactId>commons-collections</artifactId>
      <version>3.2.1</version>
    </dependency>

    <!--guava-->
    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>20.0</version>
    </dependency>


    <!--jackson-databind-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.1</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!-- MBG -->
    <dependency>
      <groupId>org.mybatis.generator</groupId>
      <artifactId>mybatis-generator-core</artifactId>
      <version>1.3.5</version>
    </dependency>

    <!--引入pagehelper分页插件-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.0.0</version>
    </dependency>


    <!-- ftpclient -->
    <dependency>
      <groupId>commons-net</groupId>
      <artifactId>commons-net</artifactId>
      <version>3.1</version>
    </dependency>

    <!-- file upload -->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.2</version>
    </dependency>

    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.0.1</version>
    </dependency>

    <!--JSON.simple » 1.1.1-->
    <dependency>
      <groupId>com.googlecode.json-simple</groupId>
      <artifactId>json-simple</artifactId>
      <version>1.1.1</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>SSM</finalName>

    <plugins>
      <!-- maven的核心插件之-complier插件默认只支持编译Java 1.4，
           因此需要加上支持高版本jre的配置，在pom.xml里面加上 增加编译插件 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
          <compilerArguments>
            <extdirs>${project.basedir}/src/main/webapp/WEB-INF/lib</extdirs>
          </compilerArguments>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

四、配置web.xml文件

　　配置web.xml文件，主要对Spring的配置，在Web项目初始化的时候，加载Spring的IOC容器。以及对SpringMVC配置，配置SpringMVC的前端控制器，并拦截所有请求。
　　
　　web.xml配置文件的代码及注释如下所示：

<?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_2_5.xsd"
         id="WebApp_ID" version="2.5">

  <display-name>Archetype Created Web Application</display-name>

  <!--web容器启动和关闭的监听器，只负责web容器启动和关闭的事件-->
  <listener>
    <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
  </listener>

  <!--1、Spring配置 -->
  <!--启动spring容器 ContextLoaderListener 将web容器和spring容器整合-->
  <!--在servlet初始化之前引导根web应用程序的上下文-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!--Spring配置文件，类路径下的applicationContext.xml-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>


  <!-- 2、SpringMVC配置 -->
  <!-- SpringMVC的前端控制器，拦截所有请求 -->
  <!-- 配置 DispatcherServlet -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置 DispatcherServlet 的一个初始化参数: 配置 SpringMVC 配置文件的位置和名称 -->
    <!--
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:springmvc.xml</param-value>
            </init-param>
    -->
    <!--
        实际上也可以不通过 contextConfigLocation 来配置 SpringMVC 的配置文件, 而使用默认的.
        默认的配置文件为: /WEB-INF/<servlet-name>-servlet.xml
        dispatcherServlet-servlet.xml
    -->

    <!--<load-on-startup>是dispatcherServlet在当前web应用被加载的时候就创建，
        而不是等第一次请求的时候被创建-->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <!--拦截所有请求-->
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- 3、字符编码过滤器，一定要放在所有过滤器之前 -->
  <filter>
    <filter-name>CharacterEncodingFilter</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>
    <init-param>
      <param-name>forceRequestEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
    <init-param>
      <param-name>forceResponseEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- 4、使用Rest风格的URI，将页面普通的post请求转为指定的delete或者put请求 -->
  <filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <filter>
    <filter-name>HttpPutFormContentFilter</filter-name>
    <filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>HttpPutFormContentFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

</web-app>

注：在web.xml文件编写完成之后，需要创建两个配置文件，即Spring的配置文件applicationContext.xml和Spring MVC的配置文件dispatcherServlet-servlet.xml。

五、编写Spring MVC的配置文件

　　由于本例中没有通过 contextConfigLocation 来配置 SpringMVC 的配置文件的位置, 所以使用的是默认的配置文件。默认的配置文件为: /WEB-INF/<servlet-name>-servlet.xml。下面我们需要在WEB-INF路径下创建一个名为dispatcherServlet-servlet.xml的文件，编写SpringMVC的配置文件即对dispatcherServlet-servlet.xml文件的编写。
　这里写图片描述
　　对dispatcherServlet-servlet.xml文件的编写，主要是：
　　1、配置自动扫描的包，需要交给Spring MVC管理的类。
　　2、配置视图解析器，方便页面返回（看情况）。
　　3、两个标准配置，如下：
　　

<mvc:default-servlet-handler/>
<mvc:annotation-driven/>

　　4、 Spring MVC的文件上传（可选）
　　

    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760"/> <!-- 10m -->
        <property name="maxInMemorySize" value="4096" />
        <property name="defaultEncoding" value="UTF-8"></property>
    </bean>

　　dispatcherServlet-servlet.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: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的配置文件，包含网站跳转逻辑的控制，配置  -->

    <!-- 1、配置自动扫描的包 只扫描Controller-->
    <context:component-scan base-package="com.ssm.controller" use-default-filters="false">
        <!--只扫描控制器,即带Controller注解的类 -->
        <context:include-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>


    <!-- 2、配置视图解析器，方便页面返回  -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!-- 3、两个标准配置  -->
    <!-- 将spring MVC 不能处理的请求交给tomcat -->
    <mvc:default-servlet-handler/>
    <!--
      default-servlet-handler 将在 Spring MVC 上下文中定义一个 DefaultServletHttpRequestHandler,
      它会对进入 DispatcherServlet 的请求进行筛查, 
      如果发现是没有经过映射的请求,就将该请求交由 WEB 应用服务器默认的Servlet 处理. 
      如果不是静态资源的请求，才由 DispatcherServlet 继续处理

      一般 WEB 应用服务器默认的 Servlet 的名称都是 default.
      若所使用的 WEB 服务器的默认 Servlet 名称不是 default，
      则需要通过 default-servlet-name 属性显式指定
    -->

    <!-- 在实际开发中通常都需配置 mvc:annotation-driven 标签 -->
    <!-- 能支持spring MVC更高级的一些功能，JSR303校验，快捷的ajax...映射动态请求 -->
    <mvc:annotation-driven/>


    <!-- Spring MVC的文件上传 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760"/> <!-- 10m -->
        <property name="maxInMemorySize" value="4096" />
        <property name="defaultEncoding" value="UTF-8"></property>
    </bean>

</beans>

注：此配置文件不能照抄，需要根据实际的项目做相应的修改：
　　　　1、base-package所对应包的具体位置。
　　　　2、视图解析器的prefix和suffix的value值。
　　　　其次Spring MVC文件上传的配置本例没有用到。

六、编写Spring的配置文件

　　在web.xml中配置的Spring的配置文件为类路径下的applicationContext.xml，所以需要在类路径下创建一个applicationContext.xml文件，并完成对其的编写。

这里写图片描述
　　编写Spring的配置文件，主要配置和业务逻辑有关的。
　　1、配置自动扫描的包，需要交给Spring管理的类。
　　2、数据源。
　　3、事务控制。
　　4、与mybatis的整合。
　　
　applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://mybatis.org/schema/mybatis-spring
        http://mybatis.org/schema/mybatis-spring.xsd">

    <!--spring的配置文件，这里主要配置和业务逻辑有关的-->
    <!-- Spring配置文件的核心点（数据源、与mybatis的整合，事务控制） -->

    <!-- 配置自动扫描的包 不包括Controller-->
    <context:component-scan base-package="com.ssm">
        <context:exclude-filter
                type="annotation"
                expression="org.springframework.stereotype.Controller" />
    </context:component-scan>

    <!-- 引入数据库的配置文件 -->
    <context:property-placeholder location="classpath:db.properties" />

    <!-- Spring用来控制业务逻辑。数据源、事务控制、aop -->
    <!--dbcp:org.apache.commons.dbcp.BasicDataSource-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!--使AspectJ的注解起作用-->
    <aop:aspectj-autoproxy/>

    <!-- spring事务管理 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--控制住数据源  -->
        <property name="dataSource" ref="dataSource"></property>
        <!--当提交事物失败的时候是否回滚-->
        <property name="rollbackOnCommitFailure" value="true"/>
    </bean>

    <!-- 开启基于注解的事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!--使用xml配置形式的事务（必要主要的都是使用配置式）-->
    <aop:config>
        <!-- 切入点表达式 -->
        <aop:pointcut expression="execution(* com.ssm.service..*(..))" id="txPoint"/>
        <!-- 配置事务增强 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
    </aop:config>

    <!--配置事务增强，事务如何切入  -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 所有方法都是事务方法 -->
            <tx:method name="*"/>
            <!--以get开始的所有方法  -->
            <tx:method name="get*" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!--
    配置和MyBatis的整合
        目的：1、spring管理所有组件。使用spring管理mapper的实现类。
                在service层调用Dao层的时候，使用Spring提供的@Autowired注解自动注入mapper；
             2、使用spring来管理事务，spring声明式事务
    -->
    <!--创建出SqlSessionFactory对象  -->
    <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!-- configLocation指定全局配置文件的位置 -->
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <!--mapperLocations: 指定mapper文件的位置-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
    </bean>

    <!--配置一个可以进行批量执行的sqlSession  -->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactoryBean"></constructor-arg>
        <constructor-arg name="executorType" value="BATCH"></constructor-arg>
    </bean>

    <!-- 扫描所有的mapper接口的实现,让这些mapper能够自动注入;
         base-package: 指定mapper接口的包名 -->
    <mybatis-spring:scan base-package="com.ssm.dao"/>

</beans>

　　在Spring的配置文件里面，使用<context:property-placeholder location="classpath:db.properties" /> 引用了外部数据库的配置文件，类路径下的db.properties代码如下：
　　

jdbc.jdbcUrl=jdbc:mysql://localhost:3306/ssm
jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.user=root
jdbc.password=1234

　　在创建SqlSessionFactory对象的时候，使用configLocation属性指定了全局配置文件（mybatis-config.xml）的位置，使用mapperLocations:属性指定了mapper文件的位置。mybatis-config.xml文件配置了一些MyBaits的全局属性与基本设置，示例代码如下：
　　

<?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"/>
        <setting name="jdbcTypeForNull" value="NULL"/>
        <!--开启SQL日志-->
        <setting name="logImpl" value="STDOUT_LOGGING" />
        <!-- 开启二级缓存 -->
        <setting name="cacheEnabled" value="true"/>
    </settings>

    <!--mybatis分页插件-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!-- 使用下面的方式配置参数，后面会有所有的参数介绍 -->
            <!--<property name="param1" value="value1"/>-->
        </plugin>
    </plugins>

    <databaseIdProvider type="DB_VENDOR">
        <property name="MySQL" value="mysql"/>
        <property name="Oracle" value="oracle"/>
    </databaseIdProvider>

</configuration>

注1：此配置文件不能照抄，需要根据实际的项目做相应的修改：
　　　　1、base-package所对应包的具体位置。
　　　　2、创建SqlSessionFactory对象的时候，mapperLocations 所指定mapper文件的具体位置。
　　　　3、扫描所有的mapper接口的实现，使用base-package:指定mapper接口的包名。
　　　　
注2： 在配置扫描器，将mybatis接口的实现加入到ioc容器中的时候，除了上面的写法，如下：

    <!-- 扫描所有的mapper接口的实现,让这些mapper能够自动注入;
         base-package: 指定mapper接口的包名 -->
    <mybatis-spring:scan base-package="com.ssm.dao"/>

也可以这样写，一些老的项目会有这样写的，如下：

    <!-- 配置扫描器，将mybatis接口的实现加入到ioc容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--扫描所有dao接口的实现，加入到ioc容器中 -->
        <property name="basePackage" value="com.ssm.dao"></property>
    </bean>

注3： 在Spring的配置文件中，我们还配置了Spring的事物管理，以及开启了基于AspectJ注解的方式来配置AOP。如果需要了解Spring的事物管理，传送门：
　　Spring框架（三）——AOP
　　Spring框架（四）——Spring中的事务管理

　　到此，SSM框架的基本整合就差不多了，接下来我们来编写测试代码。

七、测试

　　在编写好了一系列的配置文件之后，我们来编写测试的代码。
　　需求：
　　1）编写一个接口，用来获取数据库中部门id为2的员工。入参为dId,通过json将查询的结果返回。
　　2）编写一个接口，用来获取数据库中部门id为2的员工。入参为dId,返回jsp页面。
　　项目的代码结构如下所示：

这里写图片描述

一、根据数据库中的属性编写Employee的实体类

public class Employee {
    private Integer empId;
    private String empName;
    private String email;
    private String gender;
    private Integer dId;

    public Employee() {
    }

    public Employee(Integer empId, String empName, String email, String gender, Integer dId) {
        this.empId = empId;
        this.empName = empName;
        this.email = email;
        this.gender = gender;
        this.dId = dId;
    }

    public Integer getEmpId() {
        return empId;
    }

    public void setEmpId(Integer empId) {
        this.empId = empId;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Integer getdId() {
        return dId;
    }

    public void setdId(Integer dId) {
        this.dId = dId;
    }
}

二、DAO层代码的编写
　　DAO层主要是做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此，DAO层的设计首先是设计DAO的接口，然后在Spring的配置文件中定义此接口的实现类（本例是配置mapper文件），然后就可在模块中调用此接口来进行数据业务的处理，而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，DAO层的数据源配置，以及有关数据库连接的参数都在Spring的配置文件中进行配置。
　　DAO层代码的编写主要是对EmployeeMapper接口类与EmployeeMapper.xml配置文件的编写。
　　
　　EmployeeMapper接口类的示例代码如下：
　　

public interface EmployeeMapper {
    List<Employee> getEmpList(@Param("dId") Integer dId);
}

　　mapper/EmployeeMapper.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 namespace="com.ssm.dao.EmployeeMapper">

  <select id="getEmpList" parameterType="Integer" resultType="com.ssm.pojo.Employee" >
    SELECT *
    FROM tbl_emp
    WHERE d_id = #{dId}
  </select>
</mapper>

三、Service层代码的编写
　　Service层主要负责业务模块的逻辑应用设计。同样是首先设计接口，再设计其实现的类，接着再Spring的配置文件中配置其实现的关联。这样我们就可以在应用中调用Service接口来进行业务处理。Service层的业务实现，具体要调用到已定义的Dao层的接口，封装Service层的业务逻辑有利于通用的业务逻辑的独立性和重复利用性，程序显得非常简洁。
　　Service层是建立在DAO层之上的，建立了DAO层后才可以建立Service层，而Service层又是在Controller层之下的，因而Service层应该既调用DAO层的接口，又要提供接口给Controller层的类来进行调用，它刚好处于一个中间层的位置。每个模型都有一个Service接口，每个接口分别封装各自的业务处理方法。
　
　　Service层部分示例代码如下：
　　

public interface IEmployeeService {
    List<Employee> getEmpList(int dId);
}

@Service("iEmployeeService")
public class EmployeeServiceImpl implements IEmployeeService {

    @Autowired
    private EmployeeMapper employeeMapper;
    @Override
    public List<Employee> getEmpList(int dId) {
        List<Employee> empList = employeeMapper.getEmpList(dId);
        return empList;
    }
}

四、Controller层代码的编写
　　Controller层负责具体的业务模块流程的控制，在此层里面要调用Service层的接口来控制业务流程，控制的配置也同样是在Spring的配置文件里面进行，针对具体的业务流程，会有不同的控制器，我们具体的设计过程中可以将流程进行抽象归纳，设计出可以重复利用的子单元流程模块，这样不仅使程序结构变得清晰，也大大减少了代码量。
　　
　　Controller层部分示例代码如下：

@Controller
@RequestMapping("emp")
public class EmployeeController {

    @Autowired
    private IEmployeeService iEmployeeService;

    /**
     * 获取数据库中部门id为dId的员工。
     * 入参为`dId`,通过json将查询的结果返回。
     * @param dId
     * @return
     */
    @RequestMapping("list")
    @ResponseBody
    public Map<String,Object> getEmpList(@RequestParam("dId") Integer dId){
        Map<String,Object> empMap = new HashMap<>();
        List<Employee> empList = iEmployeeService.getEmpList(dId);
        empMap.put("empList", empList);
        empMap.put("code", "200");
        empMap.put("message", "查询成功");
        return empMap;
    }

    /**
     * 获取数据库中部门id为dId的员工。
     * 入参为`dId`,返回jsp页面。
     * @param dId
     * @param map
     * @return
     */
    @RequestMapping("view")
    public String getEmpView(@RequestParam("dId") Integer dId,Map<String,Object> map){

        List<Employee> empList = iEmployeeService.getEmpList(dId);
        map.put("allEmps", empList);
        return "emp";
    }
}

五、View层代码的编写

　　View层：此层与控制层结合比较紧密，需要二者结合起来协同工发。View层主要负责前台jsp页面的显示。

　　View层部分示例代码如下：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>EMPLOYEE LIST</title>
    <table>
        <tr>
            <td>empId</td>
            <td>empName</td>
            <td>email</td>
            <td>gender</td>
        </tr>
        <c:forEach items="${allEmps}" var="emp">
            <tr>
                <td>${emp.empId}</td>
                <td>${emp.empName}</td>
                <td>${emp.email}</td>
                <td>${emp.gender}</td>
            </tr>
        </c:forEach>

    </table>
</head>
<body>

</body>
</html>

　　OK，测试代码终于编写完成。接下来配置Tomcat服务器，将项目发布到Tomcat服务器上。查看控制台Tomcat是否正常启动后，在浏览器输入以下地址http://localhost:8080/emp/view?dId=2可以看到服务器返回的jsp页面。
这里写图片描述

　　在浏览器输入http://localhost:8080/emp/list?dId=2可以得到服务器返回的json数据。
这里写图片描述

　　OK，Spring+Spring MVC+MyBatis的整合结束，一个简单的Web框架搭建完成。

老臣、

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring+Spring MVC+MyBatis的整合

一、概述　　在WEB开发中我们往往会借助框架来简化自己的开发过程，本文介绍了SSM框架的整合，从而搭建一个简单的Web框架。　　　　环境参数：　　操作系统：windows10 64位　　jdk版本：jdk1.8 64位　　Maven版本：3.50 　　MySql版本：mysql-server 5.7 　　Tomcat版本：apache-tomcat-7. 　　...
复制链接

扫一扫

专栏目录