mybatis.zzh

最新推荐文章于 2024-08-09 21:25:57 发布

apcnx22400

最新推荐文章于 2024-08-09 21:25:57 发布

阅读量119

点赞数

文章标签：数据库 java

原文链接：http://www.cnblogs.com/zzh1997/p/9601130.html

版权

Mybatis介绍：

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。

Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

JDBC的缺点

1、数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能。如果使用数据库连接池可解决此问题。

2、 Sql语句在代码中硬编码，造成代码不易维护，实际应用中sql变化的可能较大，sql变动需要改变java代码。

3、使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。

4、对结果集解析存在硬编码（查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析比较方便

Mybatis架构

1、 mybatis配置

SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。

mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。

2、通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂

3、由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。

4、 mybatis底层自定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。

5、 Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的id。

6、 Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。

7、 Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程

Mybatis环境搭建

1、创建Dynamic Web工程

2、导入mybatis核心包

3、导入lib文件夹下的mybatis依赖包

4、导入数据库驱动包

5、创建POJO

6、新建并书写sql映射文件SqlMapConfig.xml和加载映射文件Mapper.xml

SqlMapConfig的配置

<?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>
	<!-- 和spring整合后 environments配置将废除 -->
	<environments default="development">
		<environment id="development">
			<!-- 使用jdbc事务管理 -->
			<transactionManager type="JDBC" />
			<!-- 数据库连接池 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql:///mybatis?characterEncoding=utf-8" />
				<property name="username" value="root" />
				<property name="password" value="123" />
			</dataSource>
		</environment>
	</environments>
    <mappers>
		<!-- <mapper resource="com/zzh/mapper/User.xml"/> -->
        <!-- 建议使用package
            这种情况下，接口名需要与对应的mapper.xml文件名一致    
        -->
		<package name="com.zzh.dao"/>
	</mappers>
</configuration>

              
          
<?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>
    <!-- 和spring整合后 environments配置将废除 -->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理 -->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url"
                    value="jdbc:mysql:///mybatis?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="123" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!-- <mapper resource="com/zzh/mapper/User.xml"/> -->
        <!-- 建议使用package
            这种情况下，接口名需要与对应的mapper.xml文件名一致    
        -->
        <package name="com.zzh.dao"/>
    </mappers>
</configuration>

Mapper.xml映射文件的增删改查配置

其中需要注意的是可以添加selectKey标签使mysql自增主键返回

select LAST_INSERT_ID()

</selectKey>

<?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">
<!-- namespace：命名空间，用于隔离sql，还有一个很重要的作用，后面会讲 -->
<mapper namespace="test">

	<!-- id:statement的id 或者叫做sql的id-->
	<!-- parameterType:声明输入参数的类型 -->
	<!-- resultType:声明输出结果的类型，应该填写pojo的全路径 -->
	<!-- #{}：输入参数的占位符，相当于jdbc的？ -->
	<select id="queryUserById" parameterType="int" resultType="com.zzh.bean.User">
		SELECT * FROM `user` WHERE id  = #{id}
	</select>
	
	
	<!-- 根据用户名模糊查询用户列表
		 #{} SELECT * FROM `user` WHERE id  = ? 占位符 ? == '字符串'
		 ${} SELECT * FROM `user` WHERE username like  '%字符串%'
	 -->
	<select id="findUserByUsername" parameterType="String"
		resultType="com.zzh.bean.User">
		select * from user where username like "%"#{value}"%"
	</select>
	
	<insert id="insertUser" parameterType="com.zzh.bean.User">
		<selectKey keyProperty="id" resultType="Integer" order="AFTER">
			select LAST_INSERT_ID()
		</selectKey>
		insert into user (username,sex,birthday,address) values (#{username},#{sex},#{birthday},#{address})
	</insert>
	
	<update id="updateUserById" parameterType="com.zzh.bean.User" >
		update user 
		set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address}
		where id = #{id}
	</update>
	
	<delete id="deleteUserById" parameterType="Integer">
		delete from user where id=#{id}
	</delete>
	
</mapper>

 
          x 
         

              
          
<?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">
<!-- namespace：命名空间，用于隔离sql，还有一个很重要的作用，后面会讲 -->
<mapper namespace="test">
    <!-- id:statement的id 或者叫做sql的id-->
    <!-- parameterType:声明输入参数的类型 -->
    <!-- resultType:声明输出结果的类型，应该填写pojo的全路径 -->
    <!-- #{}：输入参数的占位符，相当于jdbc的？ -->
    <select id="queryUserById" parameterType="int" resultType="com.zzh.bean.User">
        SELECT * FROM `user` WHERE id  = #{id}
    </select>
    
    
    <!-- 根据用户名模糊查询用户列表
         #{} SELECT * FROM `user` WHERE id  = ? 占位符 ? == '字符串'
         ${} SELECT * FROM `user` WHERE username like  '%字符串%'
     -->
    <select id="findUserByUsername" parameterType="String"
        resultType="com.zzh.bean.User">
        select * from user where username like "%"#{value}"%"
    </select>
    
    <insert id="insertUser" parameterType="com.zzh.bean.User">
        <selectKey keyProperty="id" resultType="Integer" order="AFTER">
            select LAST_INSERT_ID()
        </selectKey>
        insert into user (username,sex,birthday,address) values (#{username},#{sex},#{birthday},#{address})
    </insert>
    
    <update id="updateUserById" parameterType="com.zzh.bean.User" >
        update user 
        set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address}
        where id = #{id}
    </update>
    
    <delete id="deleteUserById" parameterType="Integer">
        delete from user where id=#{id}
    </delete>
    
</mapper>

可新建一个log4j.properties日志文件输出日志信息

在config下创建log4j.properties如下：
# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

mybatis默认使用log4j作为输出日志信息。

              
          
在config下创建log4j.properties如下：
# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
mybatis默认使用log4j作为输出日志信息。

小结

1、#{}表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换。#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

${}表示拼接sql串，通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是value。

2、parameterType和resultType

parameterType：指定输入参数类型，mybatis通过ognl从输入对象中获取参数值拼接在sql中。

resultType：指定输出结果类型，mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。如果有多条数据，则分别进行映射，并把对象放到容器List中

3、selectOne和selectList

selectOne查询一条记录，如果使用selectOne查询多条记录则抛出异常：

org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 3

at org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(DefaultSqlSession.java:70)

selectList可以查询一条或多条记录

Hibernate和Mybatis的区别

Mybatis和hibernate不同，它不完全是一个ORM框架，因为MyBatis需要程序员自己编写Sql语句。mybatis可以通过XML或注解方式灵活配置要运行的sql语句，并将java对象和sql语句映射生成最终执行的sql，最后将sql执行的结果再映射生成java对象。

Mybatis学习门槛低，简单易学，程序员直接编写原生态sql，可严格控制sql执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，例如互联网软件、企业运营类软件等，因为这类软件需求变化频繁，一但需求变化要求成果输出迅速。但是灵活的前提是mybatis无法做到数据库无关性，如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件，工作量大。

Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）如果用hibernate开发可以节省很多代码，提高效率。但是Hibernate的学习门槛高，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡，以及怎样用好Hibernate需要具有很强的经验和能力才行。

总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好

Dao开发方法

使用mybatis开发Dao，有使用原始dao开发方法和动态代理开发方法两种

1、SqlSession的适用范围

SqlSession的创建: S qlSessionFactoryBuilder→SqlSessionFactory→SqlSession

1.1、SqlSessionFactoryBuilder

通常将SqlSessionFactoryBuilder当成一个工具类使用，最佳使用范围是方法范围即方法体内局部变量

1.2、SqlSessionFactory

SqlSessionFactory是一个接口，接口中定义了openSession的不同重载方法，SqlSessionFactory的最佳使用范围是整个应用运行期间，一旦创建后可以重复使用，通常以单例模式管理SqlSessionFactory

1.3、SqlSession

SqlSession是一个面向用户的接口，sqlSession中定义了数据库操作方法

每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用，它也是线程不安全的。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态字段或实例字段中

2、原始Dao开发

1、创建Dao接口，接口方法

2、创建Dao接口的实现类，书写接口方法

3、配置加载映射文件，映射文件中的sql标签中的id属性为Dao接口的对应方法名

原始Dao开发存在的问题

1、Dao方法体中存在着通过SqlSessionFactory创建SqlSession和调用SqlSession数据库的代码重复问题

2、调用sqlSession的数据库操作方法需要指定statement的id，这里存在硬编码，不得于开发维护

3、Mapper动态代理方式

3.1、开发规范

Mapper接口开发方法只需要程序员编写Mapper接口（相当于Dao接口），由Mybatis框架根据接口定义创建接口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法

3.2、开发步骤

1、创建UserMapper.xml（映射文件）

2、创建UserMapper接口

3、在SqlMapConfig.xml文件中加载UserMapper.xml文件

Mapper的动态代理方式的四大原则

//遵循四个原则

//1、接口方法名与Mapper.xml中的id名一致

//2、返回值类型与Mapper.xml文件中的返回值类型一致

//3、方法的入参与Mapper.xml文件中的入参类型一致

//4、命名空间绑定此接口

SqlMapConfig.xml配置文件

配置内容

typeAliases（类型别名）

1、mybatis默认别名

2、自定义别名

mappers（映射器）

Mapper配置有三种方法：

1、<mapper resource=" " /> 使用相对于类路径的资源

如: <mapper resource="UserMapper.xml" />

2、<mapper class=" " /> 使用mapper接口类路径

如: <mapper class="com.zzh.mapper.UserMapper"/>

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中

3、注册包下的所有mapper接口 <package name=""/>

如:<package name="com.zzh.mybatis.mapper"/>

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中

创建POJO包装类

实现Serializable接口的原因如下：

序列化，就是把对象转化为字节流，才能进行网络传输。把该字节序列保存起来(例如:保存在一个文件里),以后可以随时将该字节序列恢复为原来的对象。甚至可以将该字节序列放到其他计算机上或者通过网络传输到其他计算机上恢复，只要该计算机平台存在相应的类就可以正常恢复为原来的对象

package com.zzh.bean;

import java.io.Serializable;

public class QueryVo implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private User user;

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}
	
}

              
          
package com.zzh.bean;
import java.io.Serializable;
public class QueryVo implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    private User user;
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    
}

配置ResultMap

resultType可以指定将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。

当sql查询字段名和pojo的属性名不一致时，可以通过resultMap将字段名和属性名作一个对应关系，resultMap实质上还需要将查询结果映射到pojo对象中。

resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。

需要在对应的mapper.xml文件中创建<resultMap>标签，并在标签内配置<result>，标签属性column为数据库表中的列名，property属性指POJO中与数据库表列名不一致的属性名

	<resultMap type="Orders" id="order">
		<result column="user_id" property="userId"/>
	</resultMap>

              
          
    <resultMap type="Orders" id="order">
        <result column="user_id" property="userId"/>
    </resultMap>

动态Sql

1、if标签

	<if test="sex != null and sex != ''">
		AND sex = #{sex}
	</if>
	<if test="username != null and username != ''">
		AND username LIKE
		'%${username}%'
	</if>

              
          
    <if test="sex != null and sex != ''">
        AND sex = #{sex}
    </if>
    <if test="username != null and username != ''">
        AND username LIKE
        '%${username}%'
    </if>

2.where标签

    <!-- where标签可以自动添加where，同时处理sql语句中第一个and关键字 
        注意此时处理的第一个and是条件语句前的and
    -->
	<where>
		<if test="sex != null">
			AND sex = #{sex}
		</if>
		<if test="username != null and username != ''">
			AND username LIKE
			'%${username}%'
		</if>
	</where>

              
          
    <!-- where标签可以自动添加where，同时处理sql语句中第一个and关键字 
        注意此时处理的第一个and是条件语句前的and
    -->
    <where>
        <if test="sex != null">
            AND sex = #{sex}
        </if>
        <if test="username != null and username != ''">
            AND username LIKE
            '%${username}%'
        </if>
    </where>

3、sql片段

在Mapper.xml文件中有的sql语句中有重复的语句（例如select * from XXX）存在时，可以使用<sql>标签把重复内容提取出来，使用时只需添加<include>标签就可以使用<sql>标签内的内容了

	<sql id="selector">
		select * from user
	</sql>

    <select>
        <include refid="selector"></include>
    </select>

              
          
    <sql id="selector">
        select * from user
    </sql>
    <select>
        <include refid="selector"></include>
    </select>

4、foreach

需要在QueryVo中创建一个用于遍历数组或集合

注：当使用array或list直接传参时，collection属性必须对应地书写为array或list，因为参数传递本质是使用Map传递的

	<select id="queryUsersByIds" parameterType="QueryVo" resultType="User">
		<include refid="selector"></include>
		<where>
			<foreach collection="idsList" item="id" separator="," open="id in (" close=")">
				#{id}
			</foreach>
		</where>
	</select>

              
          
    <select id="queryUsersByIds" parameterType="QueryVo" resultType="User">
        <include refid="selector"></include>
        <where>
            <foreach collection="idsList" item="id" separator="," open="id in (" close=")">
                #{id}
            </foreach>
        </where>
    </select>

关联查询

示例

一对一查询

需求：查询所有订单信息，关联查询下单用户信息

分析：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单

sql语句：此时以用户表作为中心查询，用户表左外连接订单表

使用resultMap

1、改造pojo类

2、创建Mapper接口

3、配置Mapper.xml

	<!-- 一对一查询 -->
    <resultMap type="Orders" id="oneToOne">
		<result column="id" property="id"/>
		<result column="user_id" property="userId"/>
		<result column="number" property="number"/>
		<association property="user" javaType="user">
			<id column="id" property="id"/>
			<result column="username" property="username"/>
		</association>
	</resultMap>
	<select id="findOrders" resultMap="oneToOne">
		select 
		o.id,
		o.user_id,
		o.number,
		o.createtime,
		u.id,
		u.username 
		from orders o 
		left join user u
		on o.user_id = u.id
	</select>

              
          
    <!-- 一对一查询 -->
    <resultMap type="Orders" id="oneToOne">
        <result column="id" property="id"/>
        <result column="user_id" property="userId"/>
        <result column="number" property="number"/>
        <association property="user" javaType="user">
            <id column="id" property="id"/>
            <result column="username" property="username"/>
        </association>
    </resultMap>
    <select id="findOrders" resultMap="oneToOne">
        select 
        o.id,
        o.user_id,
        o.number,
        o.createtime,
        u.id,
        u.username 
        from orders o 
        left join user u
        on o.user_id = u.id
    </select>

1、此时以Orders作为中心进行一对一查询，因此sql语句中左表为orders

2、多表查询时返回类型resultType只能使用resultMap

3、自定义resultMap中：

主标签中各属性：

id:该resultMap的标志

type：返回值的类名，此例中返回Orders类

association元素，Association元素处理“has-one”（一对一）这种类型关系，其中的各属性含义：

property:映射数据库列的字段或属性

colum:数据库的列名或者列标签别名

javaTyp:完整java类名或别名

jdbcType:支持的JDBC类型列表列出的JDBC类型，这个属性只在insert,update或delete的时候针对允许空的列有用

一对多查询

需求及分析：查询所有用户信息及用户关联的订单信息，用户信息和订单信息为一对多关系

sql语句：此时以订单为中心进行查询，订单表左外连接订单表

1、改造pojo类，在User类中加入List<Order> orders属性

2、创建Mapper接口

3、配置Mapper.xml

	<!-- 一对多查询 -->
	<resultMap type="User" id="user">
		<id column="user_id" property="id"/>
		<result column="username" property="username"/>
		<collection property="orderList" ofType="Orders">
			<id column="id" property="id"/>
			<result column="number" property="number"/>
			<result column="user_id" property="userId"/>
			<result column="createtime" property="createtime"/>
		</collection>
	</resultMap>
	<select id="findUserList" resultMap="user">
		SELECT 
		o.id,
		o.user_id,
		o.number,
		o.createtime,
		u.username 
		FROM user u 
		LEFT JOIN orders o
		ON o.user_id = u.id
	</select>

              
          
    <!-- 一对多查询 -->
    <resultMap type="User" id="user">
        <id column="user_id" property="id"/>
        <result column="username" property="username"/>
        <collection property="orderList" ofType="Orders">
            <id column="id" property="id"/>
            <result column="number" property="number"/>
            <result column="user_id" property="userId"/>
            <result column="createtime" property="createtime"/>
        </collection>
    </resultMap>
    <select id="findUserList" resultMap="user">
        SELECT 
        o.id,
        o.user_id,
        o.number,
        o.createtime,
        u.username 
        FROM user u 
        LEFT JOIN orders o
        ON o.user_id = u.id
    </select>

collection元素，当需要映射一个嵌套结果集到一个列表时，应该使用collection元素

collection元素中有一个比较特别的属性ofType，这个元素是用来区别JavaBean属性（或者字段）类型和集合所包括的类型的

Spring整合mybatis

SqlMapConfig.xml配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	   xmlns:context="http://www.springframework.org/schema/context" 
	   xmlns:aop="http://www.springframework.org/schema/aop" 
	   xmlns:tx="http://www.springframework.org/schema/tx" 
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd 
	   					   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd 
	   					   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
	   					   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
	   <context:property-placeholder location="classpath:jdbc.properties"/>
	   <bean name="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
			<property name="driverClassName" value="${jdbc.driverClass}"></property>
			<property name="url" value="${jdbc.jdbcUrl}"></property>
			<property name="username" value="${jdbc.user}"></property>
			<property name="password" value="${jdbc.password}"></property>

	   </bean>
	   
	   <bean name="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	   		<property name="dataSource" ref="dataSource"></property>
	   		<!-- 核心配置文件位置 -->
	   		<property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
	   </bean>
	   
	   <!-- <bean name="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
	   		<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
	   		<property name="mapperInterface" value="com.zzh.mapper.UserMapper"></property>
	   </bean> -->	
	   
	   <!-- Mapper动态代理开发 扫描
	   		此时spring将自动扫描该配置文件下的sqlSessionFactory，不需手动配置property标签
	   		name="basePackgae"指定spring去对应的包中扫描mapper
	    -->
	   <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
	   		<property name="basePackage" value="com.zzh.mapper"></property>
	   </bean>				   
</beans>

              
          
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xmlns:tx="http://www.springframework.org/schema/tx" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd 
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd 
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
                           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
       <context:property-placeholder location="classpath:jdbc.properties"/>
       <bean name="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
            <property name="driverClassName" value="${jdbc.driverClass}"></property>
            <property name="url" value="${jdbc.jdbcUrl}"></property>
            <property name="username" value="${jdbc.user}"></property>
            <property name="password" value="${jdbc.password}"></property>
       </bean>
       
       <bean name="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"></property>
            <!-- 核心配置文件位置 -->
            <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
       </bean>
       
       <!-- <bean name="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
            <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
            <property name="mapperInterface" value="com.zzh.mapper.UserMapper"></property>
       </bean> -->  
       
       <!-- Mapper动态代理开发 扫描
            此时spring将自动扫描该配置文件下的sqlSessionFactory，不需手动配置property标签
            name="basePackgae"指定spring去对应的包中扫描mapper
        -->
       <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.zzh.mapper"></property>
       </bean>                 
</beans>

UserMap.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="com.zzh.mapper.UserMapper">
	<select id="findUserById" parameterType="Integer" resultType="User">
		select * from `user` where id  = #{id}
	</select>
</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="com.zzh.mapper.UserMapper">
    <select id="findUserById" parameterType="Integer" resultType="User">
        select * from `user` where id  = #{id}
    </select>
</mapper>

来自为知笔记(Wiz)

转载于:https://www.cnblogs.com/zzh1997/p/9601130.html

apcnx22400

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
mybatis.zzh

Mybatis介绍： MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去...
复制链接

扫一扫