Spring+Spring MVC+MyBatis的整合

Spring 同时被 3 个专栏收录
11 篇文章 0 订阅
35 篇文章 0 订阅
9 篇文章 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、视图解析器的prefixsuffixvalue值。
    其次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
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值