Mybatis 笔记

最新推荐文章于 2021-12-18 08:52:20 发布

Neo爱吃海苔

最新推荐文章于 2021-12-18 08:52:20 发布

阅读量340

点赞数 1

分类专栏： Java JavaWeb 文章标签： Java Web框架 Spring ssm

本文链接：https://blog.csdn.net/qq_28666193/article/details/89212897

版权

Java 同时被 2 个专栏收录

18 篇文章 0 订阅

订阅专栏

JavaWeb

10 篇文章 0 订阅

订阅专栏

Mybatis note

概念

持久层框架，和DBUtils/Hibernate等类似。一个ORM的持久层框架。

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对象并返回。

差别

Hibernate 易上手而难精通；Hibernate难在如何设计O/R映射关系，在性能与对象模型间难以平衡；缓存与数据加载复杂、SQL优化复杂；尤其当表非常多的时候，维护有难度。

Hibernate有自己的HQL查询，较少使用SQL语句；Mybatis则相反。

JDBC回顾

导入数据库驱动，如mysql

1、	加载数据库驱动
2、	创建并获取数据库链接
3、	创建jdbc statement对象
4、	设置sql语句
5、	设置sql语句中的参数(使用preparedStatement)
6、	通过statement执行sql并获取结果
7、	对sql执行结果进行解析处理
8、	释放资源(resultSet、preparedstatement、connection)

Demo

public static void main(String[] args) {
	Connection connection = null;
	PreparedStatement preparedStatement = null;
	ResultSet resultSet = null;
	try {
		// 加载数据库驱动
		Class.forName("com.mysql.jdbc.Driver");
		// 通过驱动管理类获取数据库链接
		connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "123456");
		// 定义sql语句 ?表示占位符
		String sql = "select * from user where username = ?";
		// 获取预处理statement
		preparedStatement = connection.prepareStatement(sql);
		// 设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
		preparedStatement.setString(1, "王五");
		// 向数据库发出sql执行查询，查询出结果集
		resultSet = preparedStatement.executeQuery();
		// 遍历查询结果集
		while (resultSet.next()) {
			System.out.println(resultSet.getString("id") + "  " + resultSet.getString("username"));
		}
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		// 释放资源
		if (resultSet != null) {
			try {
				resultSet.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if (preparedStatement != null) {
			try {
				preparedStatement.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if (connection != null) {
			try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

问题
1. 数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能。使用数据库连接池可解决此问题。
2. Sql语句在代码中硬编码，造成代码不易维护，实际应用中sql变化的可能较大，sql变动需改变java代码。使用配置文件？
3. 使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护；
4. 对结果集解析存在硬编码（查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析比较方便

使用

Demo V3.2.7版本，构建过程

导入Jar包-核心包1，依赖包数个
核心配置文件SqlMapConfig.xml、log4j.properties
POJO文件
SQL映射文件
加载配置文件使用

配置文件

一般使用SqlMapConfig.xml配置，使用DTD模式的限定格式；configuration下可以有多个environment配置，如开发环境、生产、测试等。

<environments default="development">
    <environment id="development">
        <!-- 使用jdbc事务管理 -->
        <transactionManager type="JDBC" />
        <!-- 数据库连接池 -->
        <dataSource type="POOLED">
            <property name="driver" value="${jdbc.driver}" />
            <property name="url"           value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
            <property name="username" value="root" />
            <property name="password" value="root" />
        </dataSource>
    </environment>
    <!-- 加载配置文件 -->
	<mappers>
		<mapper resource="mybatis/User.xml"/>
	</mappers>
</environments>

Mybatis的日志和SQL输出依赖log4j.properties来配置。

接着，类似于Hibernate根据不同的Bean对象配置XML配置文件，用来解析类到数据库的映射。对象的配置文件中有命名空间namespace，用来控制当前配置的作用范围——用于隔离SQL语句。

<?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">
<!-- 写Sql语句   -->
<mapper namespace="user">	

</mapper>

Demo ：查询

使用Mybatis来实现对DAO的访问，需要实现三个步骤；编写SQL语句、配置Bean的映射文件、加载配置文件测试

SQL语句、配置XML

<mapper namespace="user">	
	<!-- id:statement的id 或者叫做sql的id-->
	<!-- parameterType:声明输入参数的类型 -->
	<!-- resultType:声明输出结果的类型，应该填写pojo的全路径 -->
	<!-- #{}：输入参数的占位符，相当于jdbc的？ -->
	<select id="queryUserById" parameterType="int" resultType="com.leehao.mybatis.pojo.User">
		SELECT * FROM `user` WHERE id  = #{id}
	</select>
</mapper>

测试——一个标准访问流程

private SqlSessionFactory sqlSessionFactory = null;
@Before
public void init() throws Exception {
    // 1. 创建SqlSessionFactoryBuilder对象
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    // 2. 加载SqlMapConfig.xml配置文件
    InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
    // 3. 创建SqlSessionFactory对象
    this.sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
}

@Test
public void testQueryUserById() throws Exception {
    // 4. 创建SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    // 5. 执行SqlSession对象执行查询，获取结果User
    // 第一个参数是User.xml的statement的id，第二个参数是执行sql需要的参数；
    Object user = sqlSession.selectOne("user.queryUserById", 1);
    // 6. 打印结果
    System.out.println(user);
    // 7. 释放资源
    sqlSession.close();
}

将SqlSessionFactory抽离出工具类；

public class SqlSessionFactoryUtils {
	private static SqlSessionFactory sqlSessionFactory = null;
	static {
		try {
			// 1. 创建SqlSessionFactoryBuilder对象
			SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
			// 2. 加载SqlMapConfig.xml配置文件
			InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
			// 3. 创建SqlSessionFactory对象
			sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
		} catch (Exception e) {
		}
	}
	public static SqlSessionFactory getSqlSessionFactory() {
		return sqlSessionFactory;
	}
}

一个模糊匹配的案例

@Test
public void demo2(){
    //模糊查询
    System.out.println("2333");
    SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtils.getSqlSessionFactory();
    SqlSession sqlSession = sqlSessionFactory.openSession();
    List<User> list = sqlSession.selectList("user.queryUserByName", "%张%");
    for (User user : list) {
        System.out.println(user);
    }
}

配置小结

#{}和${}

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

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

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

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

selectOne查询一条记录，如果使用selectOne查询多条记录则抛出异常；selectList可以查询一条或多条记录
其他：
- Mybatis默认事务是不提交的，若发生写操作需要使用sqlsession.commit手动提交。
- 或者使用SqlSessionFactory.opensession(true)设置自动提交事务。

插入Demo

插入操作的一个示例：

<insert id="saveUser" parameterType="com.leehao.mybatis.pojo.User">
    INSERT INTO `user`
    (username,birthday,sex,address) VALUES
    (#{username},#{birthday},#{sex},#{address})
</insert>

插入用户，当需要返回插入的ID时：

<!-- 保存用户 -->
<insert id="saveUser" parameterType="cn.itcast.mybatis.pojo.User">
	<!-- selectKey 标签实现主键返回 -->
	<!-- keyColumn:主键对应的表中的哪一列 -->
	<!-- keyProperty：主键对应的pojo中的哪一个属性 -->
	<!-- order：设置在执行insert语句前执行查询id的sql，或之后执行查询id的sql -->
	<!-- resultType：设置返回的id的类型 -->
	<selectKey keyColumn="id" keyProperty="id" order="AFTER"
		resultType="int">
		SELECT LAST_INSERT_ID()     //mysql的内置函数
	</selectKey>
	INSERT INTO `user`
	(username,birthday,sex,address) VALUES
	(#{username},#{birthday},#{sex},#{address})
</insert>
//或者使用insert标签中的值简写
<insert id="saveUser" parameterType="cn.itcast.mybatis.pojo.User" useGeneratedKeys="true" keyProperty="id">

更新Demo

<!-- 更新用户 -->
<update id="updateUserById" parameterType="com.leehao.mybatis.pojo.User">
	UPDATE `user` SET
	username = #{username} WHERE id = #{id}
</update>

删除Demo

<!-- 删除用户 -->
<delete id="deleteUserById" parameterType="int">
    delete from user where
    id=#{id}
</delete>

Mybatis 体系结构

体系结构
- mybatis配置：SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。
- 通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂
- 由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。
- mybatis底层自定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。
- Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的id。
- Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。
- Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

Mybatis解决jdbc编程的问题

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

解决：在SqlMapConfig.xml中配置数据连接池，使用连接池管理数据库链接。
Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。
向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。

解决：Mybatis自动将java对象映射至sql语句，通过statement中的parameterType定义输入参数的类型。
对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。

解决：Mybatis自动将sql执行结果映射至java对象，通过statement中的resultType定义输出结果的类型。

Dao开发

Mybatis与Hibernate：

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

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

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

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

Mybatis的Dao

原始Dao开发方法和Mapper动态代理开发方法。

SqlSession中封装了对数据库的操作，如：查询、插入、更新、删除等。SqlSession通过SqlSessionFactory创建。SqlSessionFactory是通过SqlSessionFactoryBuilder进行创建

SqlSessionFactoryBuilder

用于创建SqlSessionFacoty，SqlSessionFacoty一旦创建完成就不需要SqlSessionFactoryBuilder了，因为SqlSession是通过SqlSessionFactory创建的。所以可以将SqlSessionFactoryBuilder当成一个工具类使用，最佳使用范围是方法范围即方法体内局部变量
SqlSessionFactory

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

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

每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用，它也是线程不安全的。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态字段或实例字段中。打开一个 SqlSession使用完毕就要关闭它。通常把这个关闭操作放到 finally 块中以确保每次都能执行关闭
```
SqlSession session = sqlSessionFactory.openSession();
try {
	 // do work
} finally {
	session.close();
}
```

传统DAO开发

原始Dao开发方法需要程序员编写Dao接口和Dao实现类。原始Dao开发中存在以下问题：Dao方法体存在重复代码：通过SqlSessionFactory创建SqlSession，调用SqlSession的数据库操作方法。调用sqlSession的数据库操作方法需要指定statement的id，这里存在硬编码，不得于开发维护。

Mapper动态代理

开发规范：

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

Mapper接口开发需要遵循以下规范：

Mapper.xml文件中的namespace与mapper接口的类路径相同。
Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同
Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

@Test
public void testQueryById(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //从sqlSession中获取Mapper接口的代理对象
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    //执行
    User user = userMapper.queryById(28);
    System.out.println(user);
    sqlSession.close();
}

小结

selectOne和selectList：动态代理对象调用sqlSession.selectOne()和sqlSession.selectList()是根据mapper接口方法的返回值决定，如果返回list则调用selectList方法，如果返回单个对象则调用selectOne方法。

namespace：mybatis官方推荐使用mapper代理方法开发mapper接口，程序员不用编写mapper接口实现类，使用mapper代理方法时，输入参数可以使用pojo包装对象或map对象，保证dao的通用性。

全局配置

SqlMapConfig.xml配置内容

SqlMapConfig.xml中配置的内容和顺序如下：

properties（属性）:xml中会覆盖properties的字段
settings（全局配置参数）
typeAliases（类型别名）:别名大小写不敏感
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境集合属性对象）
environment（环境子属性对象）
transactionManager（事务管理）
dataSource（数据源）
mappers（映射器）

输入输出映射

Mapper.xml映射文件中定义了操作数据库的sql，每个sql是一个statement，映射文件是mybatis的核心；

单个输入输出

parameterType/resultType是一对值，可以在mapper映射中配置输入输出；

传递简单类型：#{}占位符，${value}—sql拼接
pojo对象属性类型：#{属性名} ${属性名}
pojo包装对象类型：Pojo类中的一个属性是另外一个pojo

ResultMap

resultType可以指定将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系，resultMap实质上还需要将查询结果映射到pojo对象中。 resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。

<mapper namespace="com.leehao.mybatis.mapper.OrdersMapper">
	<!-- 查询ID -->
	<!-- type是查询到的结果类型 -->
	<resultMap type="orders" id="ordersResultMap">
		<!-- id是查询结果的主键 ，多列则多个-->
		<id property="id" column="id"/>
		<result property="userId" column="user_id"/>
		<result property="number" column="number" />
		<result property="createtime" column="createtime" />
		<result property="note" column="note" />
	</resultMap>
	
	<!-- id需要和mapper接口方法名一致、参数类型和返回值类型也是 -->
	<select id="queryOrderAll" resultMap="ordersResultMap">
		select id, user_id, number,	createtime, note FROM `orders`
	</select>
</mapper>

动态SQL

通过mybatis提供的各种标签方法实现动态拼接sql.

where

<!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
	SELECT id, username, birthday, sex, address FROM `user`
<!-- where标签可以自动添加where，同时处理sql语句中第一个and关键字 -->
	<where>
		<if test="sex != null">
			AND sex = #{sex}
		</if>
		<if test="username != null and username != ''">
			AND username LIKE
			'%${username}%'
		</if>
	</where>
</select>

sql片段：include通用判断
foreach：

关联查询

一对一

使用resultType，改造pojo类，把相关关联属性放入待查询的类中；一起映射

<!-- 查询订单，同时包含用户数据 -->
<select id="queryOrderUser" resultType="orderUser">
	SELECT
	o.id, o.user_id
	userId,
	o.number, 	o.createtime, o.note, u.username, u.address
	FROM
	`order` o LEFT JOIN `user` u ON o.user_id = u.id
</select>

使用resultMap，改造pojo类，使用pojo引用对象的包装；再映射

<resultMap type="order" id="orderUserResultMap">
	<id property="id" column="id" />
	<result property="userId" column="user_id" />
	<result property="number" column="number" />
	<result property="createtime" column="createtime" />
	<result property="note" column="note" />

	<!-- association ：配置一对一属性 -->
	<!-- property:order里面的User属性名 -->
	<!-- javaType:属性类型 -->
	<association property="user" javaType="user">
		<!-- id:声明主键，表示user_id是关联查询对象的唯一标识-->
		<id property="id" column="user_id" />
		<result property="username" column="username" />
		<result property="address" column="address" />
	</association>
</resultMap>

<!-- 一对一关联，查询订单，订单内部包含用户属性 -->
<select id="queryOrderUserResultMap" resultMap="orderUserResultMap">
	SELECT
	o.id,o.user_id,o.number,o.createtime,o.note,
	u.username,u.address
	FROM
	`order` o LEFT JOIN `user` u ON o.user_id = u.id
</select>

一对多

<resultMap type="user" id="userOrderResultMap">
	<id property="id" column="id" />
	<result property="username" column="username" />
	<result property="birthday" column="birthday" />
	<result property="sex" column="sex" />
	<result property="address" column="address" />

	<!-- 配置一对多的关系 -->
	<collection property="orders" javaType="list" ofType="order">
		<!-- 配置主键，是关联Order的唯一标识 -->
		<id property="id" column="oid" />
		<result property="number" column="number" />
		<result property="createtime" column="createtime" />
		<result property="note" column="note" />
	</collection>
</resultMap>

<!-- 一对多关联，查询订单同时查询该用户下的订单 -->
<select id="queryUserOrder" resultMap="userOrderResultMap">
	SELECT
	u.id, u.username, u.birthday, u.sex, u.address,
	o.id oid, o.number, o.createtime, o.note
	FROM
	`user` u LEFT JOIN `order` o ON u.id = o.user_id
</select>

整合Spring

思路

1、SqlSessionFactory对象应该放到spring容器中作为单例存在。

2、传统dao的开发方式中，应该从spring容器中获得sqlsession对象。

3、Mapper代理形式中，应该从spring容器中直接获得mapper的代理对象。

4、数据库的连接以及数据库连接池事务管理都交给spring容器来完成。

包管理

1、spring的jar包

2、Mybatis的jar包

3、Spring+mybatis的整合包。

4、Mysql的数据库驱动jar包。

5、数据库连接池的jar包。

步骤

配置文件
使用SqlSessionFactoryBean完成SqlSessionFactory的创建

开发：传统Dao接口+实现类时，使用SqlSessionDaoSupport支持（类似HibernateDaoSupport);使用Mapper方式，则使用：

<!-- Mapper代理的方式开发方式一，配置Mapper代理对象 -->
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
	<!-- 配置Mapper接口 -->
	<property name="mapperInterface" value="cn.itcast.mybatis.mapper.UserMapper" />
	<!-- 配置sqlSessionFactory -->
	<property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

<!-- Mapper代理的方式开发方式二，扫描包方式配置代理 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
	<!-- 配置Mapper接口 -->
	<property name="basePackage" value="cn.itcast.mybatis.mapper" />
</bean>
每个mapper代理对象的id就是类名，首字母小写

逆向工程(不常用)

\1. 逆向工程生成的代码只能做单表查询

\2. 不能在生成的代码上进行扩展，因为如果数据库变更，需要重新使用逆向工程生成代码，原来编写的代码就被覆盖了。

\3. 一张表会生成4个文件

Neo爱吃海苔

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis 笔记

Mybatis note 概念持久层框架，和DBUtils/Hibernate等类似。一个ORM的持久层框架。MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。MyBatis是一个优秀的持久层框架...
复制链接

扫一扫

专栏目录