SSM框架搭建总结

Posted 2020-10-17

目录 

Spring MVC框架 1

Spring MVC与Struts2区别 1

Spring MVC运行原理 1

Spring MVC Web应用开发步骤 2

1.导入Spring MVC所需库文件（.jar文件） 2

2. 在Web.xml中配置 Spring MVC 核心Servlet 2

Spring容器监听 2

统一网站字符集编码 3

DispatcherServlet配置 3

修改Spring MVC 配置文件默认位置（在DispatcherServlet中配置，在加载顺序之前） 3

3.配置Spring MVC 配置文件 4

Sping命名空间 4

4.编写控制器 5

5.编写JSP页面 5

Spring MVC 高级特性 5

Restful风格 5

@PathVariable 5

一个简单的页面跳转 6

静态资源处理 6

Json处理 7

Json视图解析器 7

@ResponseBody注解 7

防止IE下载 8

文件上传功能 8

拦截器 8

异常处理器 9

XML配置Spring MVC 10

注解控制器的规则 10

参数类型 10

HttpServletRequest与HttpServletResponse以及HttpSession 10

@RequestParam注解 10

任意JavaBean对象 10

Model与ModelAndView或Map 11

返回类型 11

重定向及转发 11

ModelAndView类型 11

String类型 12

Model、ModelMap、Map与void 12

MyBatis ORM 框架 12

MyBatis框架：半自动化的ORM框架 12

框架Hibernate框架：全自动化的ORM框架 12

MyBatis系统架构 13

API接口层 13

数据处理层 13

基础支持层 13

MyBatis开发步骤 13

1. 导入MyBatis所需库文件（jar包） 13

2. 编写MyBatis配置文件 13

数据库连接资源文件 13

XML创建SqlSessionFactory 14

3. 声明实体类 14

4. 声明映射接口及映射配置 15

创建持久层文件：声明映射接口 15

创建映射文件：mapper文件 15

namespace 15

#{}与${} 15

Select 15

sql 16

insert 16

update 17

delete 17

resultMap 17

5.编写客户端访问代码 19

获取事务的方式 19

Spring MVC框架

Spring MVC 框架围绕DispatcherServlet这个核心展开，DispatcherServlt是Spring MVC的总导演，总策划，它负责截获请求并将其分派给相应的处理器。Spring MVC框架包含注解驱动控制器，请求及响应的信息处理、视图解析、本地化解析、上传文件解析、异常处理以及表单标签绑定等内容。

 

Spring MVC和Struts2两者皆用于控制层的开发

Spring MVC 属于Spring框架的后续产品，是Spring框架中的模块之一。

Spring MVC与Struts2区别

相比于Struts2框架的复杂臃肿，Spring MVC 更为精简

1.Spring MVC可以使用单例开发，建议使用单例开发

2.性能比Sturts2好，如果使用struts2框架，建议使用JSTL标签库

3.学习成本低，学起来非常简单，开发控制器就像是开发Service

4.和Spring是一家的，无需整合，可直接使用IOC,DI,AOP特征

Spring MVC运行原理

1.浏览器请求提交至DispatcherServlet前端控制器；

2.DispatcherServlet控制器调用DefaultAnnotationHandlerMapping，以查找与请求地址相对应的控制器；

3.DefaultAnnotationHandlerMapping找到对应的控制器及其方法，并将结果返回给DispatcherServlet；

4.DispatcherServlet将请求传递至AnnotationMethodHandlerAdapter组件，以适配调用控制器的方法；

5.AnnotationMethodHandlerAdapter适配调用控制器的方法，适配内容包括方法的参数列表和返回值；

6.控制器方法处理请求，并将结果返回至AnnotationMethodHandlerAdapter；

7.AnnotationMethodHandlerAdapter将返回结果封装到ModelAndView对象，进而返回给DispatcherServlet；

ModelAndView：包含了处理结果的视图和视图中要使用的数据

8.DispatcherServlet基于ModelAndView对象调用ViewResolver，以查找指定的视图；

9.ViewResolver查找并确定视图，并返回给DispatcherServlet；

10.DispatcherServlet调度视图，视图负责将结果显示到客户端。

Spring MVC Web应用开发步骤

1.导入Spring MVC所需库文件（.jar文件）

spring-web-x.x.x.RELEASE.jar

spring-webmvc-x.x.x.RELEASE.jar

spring-webmvc-portlet-x.x.x.RELEASE.jar

2.在Web.xml中配置 Spring MVC 核心Servlet

Spring容器监听

<!–  支持业务层，持久层的相关配置 -->

  <context-param>

   <param-name>contextConfigLocation</param-name>

   <param-value>classpath:applicationContext.xml</param-value>

  </context-param>

  <listener>

  <listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

  </listener>

统一网站字符集编码

 <!-- 统一网站字符编码 -->

  <filter>

    <filter-name>CharacterEncodingFilter</filter-name>

    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>    

    <init-param>

        <param-name>forceEncoding</param-name>

        <param-value>true</param-value>

</init-param>

    <init-param>

        <param-name>encoding</param-name>

        <param-value>UTF-8</param-value>

    </init-param>

  </filter>

  <filter-mapping>

    <filter-name>CharacterEncodingFilter</filter-name>

    <url-pattern>/*</url-pattern>

  </filter-mapping>

 DispatcherServlet配置

<!-- 配置Spring MVC 核心控制器DispatcherServlet -->

  <servlet>

    <servlet-name>DispatcherServlet</servlet-name>

    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!-- 如果值为大于0的整数，在Web容器启动时立即加载并实例化（设置启动加载级别:值越小加载级别越大） -->

    <load-on-startup>1</load-on-startup>

  </servlet>

  <!-- 缺省配置：不要写/* 注意：这样配置会拦截静态资源(html,css,js,img...)后边需要进行放行处理。 -->

  <servlet-mapping>

    <servlet-name>DispatcherServlet</servlet-name>

<url-pattern>/</url-pattern>

 </servlet-mapping>

修改Spring MVC 配置文件默认位置（在DispatcherServlet中配置，在加载顺序之前）

    <!-- 修改SpringMVC配置文件默认位置 -->

    <init-param>

        <param-name>contextConfigLocation</param-name>

        <param-value>classpath:SpringMVC配置文件名</param-value>

    </init-param>

 

3.配置Spring MVC 配置文件

缺省情况下，Spring MVC 配置文名称为 <核心Servlet名称>-servlet.xml,默认存放在WEB/INF下，可以通过init-param来指定位置和文件名

Sping命名空间

<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"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

       http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context-3.0.xsd

       http://www.springframework.org/schema/mvc

       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 

       http://www.springframework.org/schema/aop

       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

       http://www.springframework.org/schema/tx

       " >http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

</beans>

 

    <!-- 配置包扫描 -->

    <context:component-scan base-package="所需扫描包" use-default-filters="false">

      <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>

</context:component-scan>

    

    <!-- 指定Spring容器对Spring MVC相关组件的注解进行注册。相当于配置HandlerMapping和HandlerAdapter -->

    <mvc:annotation-driven/>

    

    <!-- 放行静态资源(img,css...),交给默认的tomcat去处理,如果前端控制器配置的是/，这个地方必须配置 -->

    <mvc:default-servlet-handler/>

    

    <!-- 定义视图解析器  此处ID可以不指定 -->

    <bean id="defaultViewResolver" class=‘org.springframework.web.servlet.view.InternalResourceViewResolver‘>

      <!-- 配置前缀和后缀：控制器返回的url会经过视图解析器解析最终的url是：前缀+url+后缀 -->

      <property name="prefix" value="/" />

      <property name="suffix" value=".jsp" />

</bean>

Spring是父容器，Spring MCV 是子容器

 4.编写控制器

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping;

 

@Controller

@Scope(value="prototype")

@RequestMapping("/springmvc")

public class SimpleController {

　　@RequestMapping("/test")

　　public String test(Model model) {

　　　　model.addAttribute("message", "Hello world！");

　　　　return "HelloWorld";

　　}

}

 5.编写JSP页面

可通过EL表达式获取model中的属性的对象值  

Spring MVC 高级特性

Restful风格

@PathVariable

Spring MVC 可以通过@RequestMapping 指定请求路径，同时也支持rest风格。例如

http://localhost:8080/springmvc/user/{id}    

{id} 为占位符。Java代码示例如下：

@RequestMapping(“/user/{id}”)

public  ModelAndView  queryUserById(

@PathVariable(“id”) Integer id) {

//此处省略

}

使用@PathVariable 这个注解进行标识，在请求的时候，会把请求中的{id}的值直接注入到 方法的参数id中，如果在类的上面使用占位符，同样可以进行注入。

一个简单的页面跳转

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

 

@Controller

@Scope("prototype")

@RequestMapping("/forward")

public class SimpleForwardController {

 
　　@RequestMapping("/{page}")

　　public String forwardPage(@PathVariable("page") String page) {

　　　　return page;

　　}

}

静态资源处理

使用Rest风格的URL不希望后缀名是.do,.htm等格式，优雅的格式为  http://localhost:8080/springmvc/test/java  ：java模块

http://localhost:8080/springmvc/test/user :  用户模块

早期的springmvc不能很好的处理静态资源，所以通常会以.do , .htm等形式结尾。如果在DispatcherServlet中配置url-pattern为“/” 那么spring默认为处理所有请求，包括静态资源的请求。Spring MVC会把它作为一个普通的请求，如果找不到，则会抛出异常。Spring  rest风格是3.0版本的重要特征，所以该团队在处理静态资源文件的时候，做出了非常的多的努力，最终通过两种实现方式来处理静态资源文件。

1、<mvc:default-servlet-handler />  

一般服务器包括tomcat, weblogic , jboss , jetty ,webshpare等默认servlet的名称为default ,如果你使用的服务器的默认值不是default，需要通过属性default-servlet-name指定你服务器的默认值

2、 <mvc:resources />

该标签允许静态资源放在服务器的任何位置，包括WEB-INF, classpath下等，甚至可以打包到jar中，通过location指定静态资源的位置。

<mvc:resources location="/js/" mapping="/**"/>

<mvc:resources location="/images/" mapping="/iamges/**"/>

<mvc:resources location="/css/" mapping="/css/**"/>

3、<mvc:annotation-driven />

如果仅仅使用上面两个标签，那么系统会找不到我们的资源。

Json处理

Spring MVC的MappingJascksonJsonView借助Jackson框架的ObjectMapper将模型数据转换为Json格式输出。

Json视图解析器

由于MappingJacksonJsonView 也是一个bean,可以通过BeanNameViewResolver进行解析，因此需要在springmvc配置文件中配置：

<!-- 默认情况会把模型中的所有都输出json,可以通过renderedAttributes指定输出的内容 -->

<bean id="jsonView" class="org.springframework.web.servlet.view.json.MappingJacksonJsonView">

    <property name=“renderedAttributes”   value=“userList“ />

</bean>

<!-- 需要使用bean视图解析器 -->

<bean class="org.springframework.web.servlet.view.BeanNameViewResolver" p:order="10" />

 

简单测试：

@RequestMapping("getJson")

public String getJson(ModelMap map){

User user = userService.getUserByUserId(1);

map.put("userList", userList);

map.put("jsonList1", "这是一个测试字符串");

return "jsonView" ;

}

@ResponseBody注解

该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。

使用时机：

返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用。

防止IE下载

<!-- 防止IE下载 -->

    <bean id="stringHttpMessageConverter" class="org.springframework.http.converter.StringHttpMessageConverter">

        <property name="supportedMediaTypes">

            <list>

                <value>text/html;charset=UTF-8</value>

            </list>

        </property>

    </bean>

    

    <bean id="mappingJackson2HttpMessageConverter" class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">

        <property name="supportedMediaTypes">

            <list>

                <value>text/html;charset=UTF-8</value>

            </list>

        </property>

    </bean>

    

    <util:list id="messageConverters">

        <ref bean="mappingJackson2HttpMessageConverter"/>

        <ref bean="stringHttpMessageConverter"/>

    </util:list>

文件上传功能

Spring MVC 提供了对文件的上传支持，这种支持是通过即插即用的MultipartResolver实现的。Spring通过Jakarta   Commons FileUpload 技术实现了一个MultipartResolver实现类：CommonsMultipartResolver。

Spring在上下文中默认是没有配置MultipartResolver的，因此默认情况下不能支持文件上传的工作，如果想要使用文件上传的工作，那么需要先配置MultipartResolver，配置如下：

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver" p:defaultEncoding="UTF-8" />

<!-- 上传临时路径 -->

<property name="uploadTempDir" value="upload/temp"></property>

拦截器

继承HandlerInterceptorAdapter类

实现HandlerInterceptor接口

boolean preHandler(request,response,handler) :

在请求到达handler之前，先执行这个前置处理方法，当该方法返回false,则直接返回，不会传递到下一个拦截器中，更不会调用处理器链末端的handler中，只有返回true是请求才向链中的下一个处理节点传递。

void postHandler(request,response,handler, mav)

在请求被Handler执行后，执行这个方法做后置处理

void afterCompletion(req, resp , handler , exception)

在相应已经被渲染后，执行该方法。

Springmvc配置文件如下：

<mvc:interceptors>

<mvc:interceptor>

<mvc:mapping path="/**/*"/>

<mvc:exclude-mapping path="/user/login"/>

<mvc:exclude-mapping path="/easyui/**"/>

<mvc:exclude-mapping path="/images/**"/>

<mvc:exclude-mapping path="/jquery/**"/>

<mvc:exclude-mapping path="/js/**"/>

<bean class=“com.r863.spring.interceptor.SessionInterceptor" />

</mvc:interceptor>

</mvc:interceptors>

异常处理器

Spring MVC对异常的处理提供了一个视图处理类：SimpleMappingExceptionResoler

    <!-- 定义一个异常视图处理器 -->

    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">

        <property name="exceptionMappings">

            <props>

                <!-- <prop key="异常全类名1">对应的视图1</prop> -->

                <prop key="com.r863.spring.exception.MyServiceException">error</prop>

                <prop key="java.lang.NullPointerException">error1</prop>

            </props>

        </property>

        

        <property name="statusCodes">

            <props>

                <prop key="error">500</prop>

                <prop key="error1">501</prop>

            </props>

        </property>

</bean>

XML配置Spring MVC

配置文件：

<bean id="xmlConfigController" class="com.r863.spring.controller.XmlConfigController" scope="prototype">

<property name="methodNameResolver" ref="methodNameResolver" />

</bean>

<bean id="methodNameResolver" class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">

<property name="paramName" value="action" />

</bean>

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

<property name="mappings">

<props>

<prop key="/xmlConfig">xmlConfigController</prop>

</props>

</property>

</bean>

--  XmlConfigController  需要继承 MultiActionController  

访问地址为：http://localhost:8080/springmvc/xmlConfig?action=login

 login为 XmlConfigController 中的一个方法名

注解控制器的规则

参数类型

在处理HTTP请求时，AnnotationMethodHandlerAdapter组件负责调用指定的请求处理方法。它可以根据方法的参数列表不同，生成对应类型的参数，进而调用请求处理方法。

对于控制器中方法，Spring支持以下参数类型：

HttpServletRequest与HttpServletResponse以及HttpSession

@RequestParam注解

任意JavaBean对象

Model与ModelAndView或Map  

返回类型

返回值被交由ViewResolver组件进行解析，将其解析为最终转发的JSP页面URL

 

重定向及转发

return "forward:xxxURL";

return "redirect:xxxURL";

注意：如果使用转发或重定向的话，返回路径不会经过视图解析器的解析，需要手动添加。

ModelAndView类型

Spring MVC 内置类，包含Model和View两个对象，分别用于封装数据和转发视图。

addObject(name,value);//向request作用域中设置数据

setViewName(url);  //设置响应的视图URL

String类型

Model、ModelMap、Map与void

其中Model和ModelMap均为Spring MVC 内置类。

注意：返回视图名称与请求URL相同

MyBatis ORM 框架

Mybatis是世界上流行最广泛的SQL映射框架，由Clinton Begin在2002年创建，后捐献给Apache基金会，成立了iBatis项目，该项目是O/R Mapping解决方案。2010年5月，将代码库迁至Google Code,并更名为MyBatis。

MyBatis是一个可以自定义SQL、存储过程和高级映射的持久层框架。MyBatis摒除了大部分的JDBC代码，手工设置参数和结果集重获。MyBatis只使用简单的XML和注解来配置和映射基本数据类型，接口和POJO到数据库记录

MyBatis框架：半自动化的ORM框架

优点：

1、需要编写sql语句，对sql优化和维护比较方便

2、学习成本低，学起来非常简单

 

缺点：

    1、开发效率不如hibernate，数据库移植性差

    2、缓存机制不是很好，需要使用第三方日志统计：log4j

 

适用于：需求量变化比较频繁的项目  例：互联网项目...

框架Hibernate框架：全自动化的ORM框架

优点：

1、不需要编写SQL语句，自动生成sql

2、开发效率非常快

3、数据库移植性好，提供了HQL语句

4、缓存机制比较好，自带日志统计

缺点：

1、相比于mybatis，维护性比较差，修改sql语句比较麻烦

2、性能没有Mybatis好，学习成本高，入门门槛高

       

       适用于：需求量变化不大的项目(中小型项目) 例：后台管理系统，OA...

MyBatis系统架构

API接口层

提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。

接口层接收到调用请求后，会调用数据处理层来完成具体的数据处理。

数据处理层

负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。

其主要目的是根据调用请求完成一次数据库操作。

基础支持层

负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理。

为其上的数据处理层提供最基础的支撑。

 

MyBatis开发步骤

1.导入MyBatis所需库文件（jar包）

commons-logging-x.x.x.jar

mybatis-x.x.x.jar处理mybatis的核心jar

jar包可以从 http://www.mvnrepository.com网站获取

2.编写MyBatis配置文件

在MyBatis应用程序中，需要提供以下配置文件：

数据库连接属性文件，例如database.properties(以mysql数据库为例)

Mybatis主配置文件（XML格式），例如config.xml

数据库连接资源文件

dirver=com.mysql.jdbc.Driver

url=jdbc:mysql://localhost:3036/数据库名

username=root

password=1234

XML创建SqlSessionFactory

<?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> 

    <!-- 配置别名 -->

    <typeAliases>

        <typeAlias alias="别名" type="类的完全限定名"/>

    </typeAliases>

    <!-- 环境集 -->

    <environments default="development">

        <!-- 环境，数据库的连接 -->

        <environment id="development">

        <!-- 事务管理器 -->

            <transactionManager type="JDBC"/>

            <!-- 数据源 -->

            <dataSource type="POOLED">

                <property name="driver" value="${driver}"/>

                <property name="url" value="${url}"/>

                <property name="username" value="${username}"/>

                <property name="password" value="${password}"/>

            </dataSource>

        </environment>

    </environments>

    <mappers> 

        <!-- 加载映射语句配置文件：XXXMapper.xml -->

        <mapper resource="com/mybatis/dao/XXXMapper.xml"/> 

    </mappers> 

</configuration>

3.声明实体类

MyBatis实体类与普通JavaBean无任何区别。需注意：类中属性名应与数据库字段名相对应。

4.声明映射接口及映射配置

创建持久层文件：声明映射接口

MyBatis映射接口相当于DAO，用于提供将对象映射为数据库关系的操作方法。

当程序运行时，MyBatis可基于该接口自动生成实现类，而无须手动编写。但须提供与之接口对应的XML映射配置文件。

创建映射文件：mapper文件

映射配置文件通常与接口名称一致：XXXMapper.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="XXXMapper关联接口完全限定名">

</mapper>

namespace

指定映射文件所对应的映射接口

#{}与${}

#{}MyBatis会对属性自动解析

${}不可变字符串

Select

最基本写法：

    <select id="接口中对应的方法" parameterType="参数类型" resultType="返回类型">

        select语句

    </select>

省略参数类型：

<select id="接口中对应的方法" resultType="返回值类型">

        select语句

</select>

sql

定义重用的sql语句：

<sql id="xxx_column"> 字段名,字段名 </sql>

<select id="接口中对应的方法" resultType="返回值类型">

select <include refid="xxx_column"/> from xxx;

</select>

分页查询：

Mysql分页：

<select id="接口中对应的方法" resultType="返回值类型">

select <include refid="xxx_column"/> from xxx limit #{0},#{1} ;

</select>

Oracle分页：

<select id="接口中对应方法" parameterType="参数类型" resultType="返回值类型">
     <include refid="common.header"></include>
         select语句
     <include refid="common.footer"></include>
</select>

创建base.xml的Mapper共同文件，需要另外加载映射。

<?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="common">

    <sql id="header">

       select * from ( select a.* , rownum r from (

    </sql>

    <sql id="footer">

          ) a

        ) b where b.r > #{start} and b.r <= #{end}

    </sql>

</mapper>

insert

Mysql插入：

    <insert id="接口中对应的方法" parameterType="参数类型" useGeneratedKeys="true"

    keyProperty="id名">

        insert into xxx(字段,字段)

        values(#{属性},#{属性})

    </insert>

Oracle插入：

    <insert id="接口中对应的方法" parameterType="参数类型">

        insert into xxx(字段,字段)

        values(#{属性},#{属性})

        <selectKey keyColumn="id" keyProperty="id名" order="BEFORE" resultType="int">

            select 序列.nextval from dual

        </selectKey>

    </insert>

update

<update id="接口中对应的方法" parameterType="参数类型">

        update xxx set

        字段=#{属性},

        字段=#{属性},

        字段=#{属性}

        where id=#{属性};

或采用占位符

        update xxx set

        字段=#{1},

        字段=#{2},

        字段=#{3}

        where id=#{0};

    </update>  

parameterType可省略

delete

    <delete id="接口中对应的方法" parameterType="参数类型">

        delete from xxx where lid=#{属性};

    </delete>

parameterType可省略

resultMap

解决列名不匹配问题：

   <!-- 定义ResultMap:解决列名不匹配的一种方式 -->

    <resultMap type="xxx" id="xxxMap">

        <!-- property:属性名   column：列名 -->

        <result property="year" column="lyear"/>

    </resultMap>

    <select id="接口中对应方法" resultMap="xxxMap">

        select语句

    </select>

一对多关系映射：

<resultMap type="grade" id="gradeResultMap">

<id column="id" property="id"/>

<result column="className" javaType="string" property="className" />

<!– 通过collection配置集合属性，ofType指定集合中元素的类型，id标签配置外键 -->

<collection property="users" ofType="user">

<id column="u_id" property="id"/>

<result column="username" property="username"/>

</collection>

</resultMap>

<select id="getGradeById" resultMap="gradeResultMap">

select g.id , g.className , u.id as u_id ,

u.username from t_grade g left join t_user u

on g.id = u.g_id

where g.id = #{id}

</select>

多对一关系映射：

<resultMap type="user" id="userResultMap">

<id column="id" property="id"/>

<result column="username" property="username"/>

<result column="password" property="password"/>

<!– 通过association配置集合属性， javaType指定元素的类型-->

<association property="grade" javaType="grade">

<id column="g_id" property="id"/>

<result column="className" property="className"/>

</association>

</resultMap>

<select id="getUserGradeByUserId" resultMap="userResultMap">

select u.id , u.username , u.password ,

g.id as g_id , g.className from t_user u

left join t_grade g on u.g_id = g.id

where u.id = #{id}

</select>

5.编写客户端访问代码

从SqlSessionFactoryBuilder中build 创建SqlSessionFactory之后create获取SqlSession回话。

public class SqlSessionFactoryUtil {

private static SqlSessionFactory sqlSessionFactory;

 

static {

String resource = "config.xml";

// InputStream in = SqlSessionFactoryUtil.class.getResourceAsStream(resource);

try {

InputStream in = Resources.getResourceAsStream(resource);

sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);

} catch (IOException e) {

e.printStackTrace();

}

}

 

public static SqlSession getSession(boolean autoCommit)  {

return sqlSessionFactory.openSession(autoCommit);

}

 

public static void main(String[] args) {

SqlSession session = SqlSessionFactoryUtil.getSession(true);

LeagueMapper mapper = session.getMapper(LeagueMapper.class);

}

}

获取事务的方式

可在调用增删改操作后调用session.commit()进行事务的提交；

也可在获取SqlSession的时候，通过sqlSessionFactory.openSession(true)。

MyBatis动态SQL

if语句

<select id="selectUsers" parameterType="java.util.HashMap“ resultType="user">

 

select ID , USERNAME , PASSWORD

 FROM USERW WHERE 1=1

<if test="username!=null and username!=‘‘">

and USERNAME = #{username}

</if>

 

<if test="password!=null and password!=‘‘">

and PASSWORD = #{password}

</if>

</select>

 

choose when other 语句

<select id="selectUsers" parameterType="java.util.HashMap" resultType="user">

 

select ID , USERNAME , PASSWORD FROM USERW WHERE 1=1

<choose>

<when test="username!=null and username!=‘‘">

and USERNAME = #{username}

</when>

<when test="username==null or username==‘‘">

and USERNAME is null

</when>

<otherwise>

and 1!=1

</otherwise>

</choose>

</select>

trim, where,set语句

<select id="selectUsers" parameterType="java.util.HashMap" resultType="user">

select ID , USERNAME , PASSWORD FROM USERW

<where>

<if test="username!=null">

USERNAME = #{username}

</if>

</where>

</select>

<update id="updateUser" parameterType="java.util.HashMap">

update USERW

<set>

<if test="username!=null">

USERNAME = #{username},

</if>

<if test="password!=null">

PASSWORD = #{password},

</if>

</set>

where ID = #{id}

</update>

foreach语句

<select id="selectUsers" parameterType="java.util.HashMap" resultType="user">

 

select ID , USERNAME , PASSWORD FROM USERW WHERE 1=1

<choose>

<when test="username!=null and username!=‘‘">

and USERNAME = #{username}

</when>

<when test="username==null or username==‘‘">

and USERNAME is null

</when>

<otherwise>

and 1!=1

</otherwise>

</choose>

</select>

Spring+MyBatis整合

Spring整合ORM框架的优势

简化编程：整合后的编程，在配置文件、API调用，以及异常处理等方面的程序有很大的简化

简化事务配置：整合后可使用Spring AOP事务实现对事务的控制，程序中不必再编写事务控制的代码。

Spring-MyBatis整合结构

将MyBatis整合到Spring的优势

在MyBatis-Spring中，使用SqlSessionFactoryBean来代替SqlSessionFactoryBuilder，它直接声明在Spring配置文件中。

Mapper实例不在需要手动编码获取，直接在Spring配置文件中声明即可。

原有的数据源配置信息，被整合到Spring提供的DataSource中。

MapperFactoryBean

用于生成MyBatis Mapper子类实例的工厂类，该类内部使用了工厂方法模式。服务组件通过通过该Bean获取Mapper实例。

MapperScannerConfigurer

用于扫描指定路径中的映射配置文件来获取映射信息。

SqlSessionFactoryBean

用于生产MyBatis中SqlSession的工厂类，该类内部使用了工厂方法模式。

DataSource

用于连接数据库的通用组件，可使用Web容器提供的数据源，也可以使用第三方数据源。