基于MyBatis3.0.6的基本操作介绍

标签：基于 blog BlogMapper SqlSession session MyBatis3.0 mybatis 基本操作 public

每一个 MyBatis 的应用程序都以一个 SqlSessionFactory 对象的实例为核心。SqlSessionFactory本身是由SqlSessionFactoryBuilder创建的，一般而言，在一个应用中，一个数据库只会对应一个SqlSessionFactory，所以一般我们都把SqlSessionFactory定义成单例模式，或通过Spring等进行注入。

SqlSessionFactoryBuilder创建SqlSessionFactory的方法有：

SqlSessionFactory build(InputStream inputStream)
SqlSessionFactory build(InputStream inputStream, String environment)
SqlSessionFactory build(InputStream inputStream, Properties properties)
SqlSessionFactory build(InputStream inputStream, String env, Properties props)
SqlSessionFactory build(Configuration config)

这些方法主要设计到的参数有InputStream，environment，properties，其中InputStream是从配置文件中获取的一个输入流；environment表示在配置文件里面配置的众多的environment中，当前要使用的是哪一个environment，包括数据源和事务，缺省则使用默认的environment；使用properties，MyBatis则会加载对应的属性或文件，它们可以在配置文件中使用。

从XML中构建SqlSessionFactory

1. private static SqlSessionFactory sqlSessionFactory = null; 
2. 
3. static
4. try
5. InputStream is = Resources.getResourceAsStream("config/mybatis_config.xml"); 
6. sqlSessionFactory = new
7. } catch
8. // TODO Auto-generated catch block 
9. e.printStackTrace(); 
10. } 
11. 
12. } 
13. 
14. public static
15. return
16. } 
 
private static SqlSessionFactory sqlSessionFactory = null;
  
  static {
    try {
      InputStream is = Resources.getResourceAsStream("config/mybatis_config.xml");
      sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    
  }
  
  public static SqlSessionFactory getSqlSessionFactory() {
    return sqlSessionFactory;
  }

下面讲讲配置文件的基本结构：

mybatis的配置文件一般包括如下几个部分：

properties：properties用于定义或导入属性，然后在后面的环境中使用

settings:settings用于设置一些mybatis在运行时的行为方式，具体的设置信息可以查看mybatis的文档

typeAliases:typeAliases是为系统中的Java类型指定一个较短的别名

environments:MyBatis 可以配置多种环境。这会帮助你将 SQL 映射应用于多种数据库之中。

1. 1. <environments default="development">
<environment id="development">
2. <transactionManager type="JDBC" />
3. <dataSource type="POOLED">
4. <property name="driver" value="${jdbc.driver}" />
5. <property name="url" value="${jdbc.url}" />
6. <property name="username" value="${jdbc.username}" />
7. <property name="password" value="${jdbc.password}" />
8. </dataSource> 
9. </environment> 
10. </environments>

由于MyBatis可以配置多个environment，所以可以在创建SqlSessionFactory的时候指定具体的环境来创建特定的环境下的SqlSessionFactory，不指定则使用默认的环境。

transactionManager

在 MyBatis 中有两种事务管理器类型(也就是 type=”[JDBC|MANAGED]”):

JDBC – 这个配置直接简单使用了 JDBC 的提交和回滚设置。它依赖于从数据源得到的连接来管理事务范围。
MANAGED – 这个配置几乎没做什么。它从来不提交或回滚一个连接。而它会让容器来管理事务的整个生命周期(比如 Spring 或 JEE 应用服务器的上下文) 默认情况下它会关闭连接。然而一些容器并不希望这样, 因此如果你需要从连接中停止它,将 closeConnection 属性设置为 false。

dataSource

dataSource 元素使用基本的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

许多 MyBatis 的应用程序将会按示例中的例子来配置数据源。然而它并不是必须的。要知道为了方便使用延迟加载,数据源才是必须的。

有三种内建的数据源类型(也就是 type=”???”):

UNPOOLED – 这个数据源的实现是每次被请求时简单打开和关闭连接。它有一点慢, 这是对简单应用程序的一个很好的选择, 因为它不需要及时的可用连接。不同的数据库对这个的表现也是不一样的, 所以对某些数据库来说配置数据源并不重要, 这个配置也是闲置的。 UNPOOLED 类型的数据源仅仅用来配置以下 5 种属性:

driver
url
username
password
defaultTransactionIsolationLevel

作为可选项,你可以传递数据库驱动的属性。要这样做,属性的前缀是以“driver.”开头的,例如:

driver.encoding=UTF8

这样就会传递以值 “ UTF8 ” 来传递属性 “ encoding ”, 它是通过 DriverManager.getConnection(url,driverProperties)方法传递给数据库驱动。

POOLED – 这是 JDBC 连接对象的数据源连接池的实现,用来避免创建新的连接实例时必要的初始连接和认证时间。这是一种当前 Web 应用程序用来快速响应请求很流行的方法。

除了上述(UNPOOLED)的属性之外,还有很多属性可以用来配置 POOLED 数据源:

poolMaximumActiveConnections
poolMaximumIdleConnections
poolMaximumCheckoutTime
poolTimeToWait
poolPingQuery
poolPingEnabled
poolPingConnectionsNotUsedFor

JNDI – 这个数据源的实现是为了使用如 Spring 或应用服务器这类的容器, 容器可以集中或在外部配置数据源,然后放置一个 JNDI 上下文的引用。这个数据源配置只需要两个属性:

initial_context
data_source

再之后就是Mapper了，Mapper就是映射SQL语句的，首先要告诉mybatis要到哪里去找这些SQL语句，即指定资源位置。

<mappers>
    <mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>
  </mappers>

下面是我在测试过程中的一个简单的配置文件：

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE configuration 
3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
4. "http://mybatis.org/dtd/mybatis-3-config.dtd">
5. <configuration> 
6. <properties resource="config/jdbc.properties"></properties> 
7. <typeAliases> 
8. <typeAlias alias="Blog" type="com.tiantian.mybatis.model.Blog"/>
9. </typeAliases> 
10. <environments default="development">
11. <environment id="development">
12. <transactionManager type="JDBC" />
13. <dataSource type="POOLED">
14. <property name="driver" value="${jdbc.driver}" />
15. <property name="url" value="${jdbc.url}" />
16. <property name="username" value="${jdbc.username}" />
17. <property name="password" value="${jdbc.password}" />
18. </dataSource> 
19. </environment> 
20. </environments> 
21. <mappers> 
22. <mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>
23. </mappers> 
24. </configuration>

在上面配置文件中导入了一个外部的属性文件，MyBatis配置文件中的属性引入可以是直接包含在properties元素中的，也可以是利用properties元素从外部引入的，还可以是在创建SqlSessionFactory的时候，作为一个参数properties传入。既然MyBatis配置文件中的属性可以从这么多地方引入，那就牵涉到一个优先级的问题，MyBatis将会按照下面的顺序来寻找它们：

先是配置文件中，properties元素体中的属性被读取
再是利用properties元素从外部引入的属性文件中的属性被读取，会覆盖前面读取的相同的属性
最后是创建SqlSessionFactory时传入的properties中的属性被读取，同样会覆盖前面相同的属性

在有了SqlSessionFactory之后就是获取特定的SqlSession了，在使用mybatis的过程中每一个操作都是离不开SqlSession的，所以获取SqlSession是相当重要的。此外，SqlSession是不能被共享、线程不安全的，所以在每次需要SqlSession的时候都应该打开一个，然后在用完了之后再把它关上。

SqlSession session = sqlSessionFactory.openSession();

SqlSessionFactory中湖区SqlSession的方法有：

SqlSession openSession()
SqlSession openSession(boolean autoCommit)
SqlSession openSession(Connection connection)
SqlSession openSession(TransactionIsolationLevel level)
SqlSession openSession(ExecutorType execType,TransactionIsolationLevel level)
SqlSession openSession(ExecutorType execType)
SqlSession openSession(ExecutorType execType, boolean autoCommit)
SqlSession openSession(ExecutorType execType, Connection connection)
Configuration getConfiguration();

它们的主要区别在于：

Transaction (事务): 你想为 session 使用事务或者使用自动提交
Connection (连接): 你想 MyBatis 获得来自配置的数据源的连接还是提供你自己
Execution (执行): 你想 MyBatis 复用预处理语句和/或批量更新语句(包括插入和删除)

默认的opensession方法没有参数，它会创建有如下特性的SqlSession：

会开启一个事务，也就是不自动提交
连接对象会从当前正在使用的environment中的数据源中得到
事务隔离级别将会使用驱动或数据源的默认值
预处理语句不会被复用，也不会批量更新语句

ExecutorType有三个值：

ExecutorType.SIMPLE 它会为每个语句的执行创建一个新的预处理语句
ExecutorType.REUSE 它会复用预处理语句
ExecutorType.BATCH 这个执行器会批量执行更新语句

mybatis的基本操作就是增、删、改、查，即insert、delete、update和select。在进行这些基本的操作的时候可以直接利用SqlSession访问Mapper配置文件里面的映射来进行，也可以利用与Mapper配置文件相对应的Mapper接口来进行操作，条件是Mapper接口中定义的方法的参数和返回值要与Mapper配置文件中定义的参数和返回值相同。此外，在使用Mapper接口的时候，对应的SQL语句是可以写在Mapper配置文件中的，也可以直接利用对应的注解在Mapper接口中对应的方法上进行标明，这将在下面的示例代码中看到。

下面是一系列的示例代码：

先贴一个用于获取SqlSessionFactory的工具类：

import java.io.IOException;
import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Util {
  
  private static SqlSessionFactory sqlSessionFactory = null;
  
  static {
    try {
      InputStream is = Resources.getResourceAsStream("config/mybatis_config.xml");
      sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    
  }
  
  public static SqlSessionFactory getSqlSessionFactory() {
    return sqlSessionFactory;
  }
  
}

mybatis的配置文件：

基于MyBatis3.0.6的基本操作介绍_bc

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE configuration 
3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
4. "http://mybatis.org/dtd/mybatis-3-config.dtd">
5. <configuration> 
6. <properties resource="config/jdbc.properties"></properties> 
7. <typeAliases> 
8. <typeAlias alias="Blog" type="com.tiantian.mybatis.model.Blog"/>
9. </typeAliases> 
10. <environments default="development">
11. <environment id="development">
12. <transactionManager type="JDBC" />
13. <dataSource type="POOLED">
14. <property name="driver" value="${jdbc.driver}" />
15. <property name="url" value="${jdbc.url}" />
16. <property name="username" value="${jdbc.username}" />
17. <property name="password" value="${jdbc.password}" />
18. </dataSource> 
19. </environment> 
20. </environments> 
21. <mappers> 
22. <mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>
23. </mappers> 
24. </configuration>

BlogMapper.xml


1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE mapper 
3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5. 
6. <mapper namespace="com.tiantian.mybatis.model.BlogMapper">
7. <!-- 新增记录 -->
8. <insert id="insertBlog" parameterType="Blog">
9. insert into t_blog(title,content,owner) values(#{title},#{content},#{owner}) 
10. </insert> 
11. <!-- 查询单条记录 -->
12. <select id="selectBlog" parameterType="int" resultType="Blog">
13. select * from t_blog where id
14. </select> 
15. <!-- 修改记录 -->
16. <update id="updateBlog" parameterType="Blog">
17. update t_blog set title = #{title},content = #{content},owner = #{owner} where id
18. </update> 
19. <!-- 查询所有记录，查询多条记录即返回结果是一个集合的时候，resultType不是集合类型，而是集合所包含的类型 -->
20. <select id="selectAll" resultType="Blog">
21. select * from t_blog 
22. </select> 
23. <!-- 模糊查询 -->
24. <select id="fuzzyQuery" resultType="Blog" parameterType="java.lang.String">
25. select * from t_blog where title like "%"#{title}"%" 
26. </select> 
27. <!-- 删除记录 -->
28. <delete id="deleteBlog" parameterType="int">
29. delete from t_blog where id
30. </delete> 
31. </mapper>

SQL映射语句中一些应该注意的问题：

resultType的值应该是返回类型的完全名或别名，当返回的结果是一个集合的时候，resultType应为集合中所包含的类型，而不是集合类型，如上面的Blog
resultType和resultMap都是表示指定返回结果的，但两者不能同时使用
对于Insert映射语句有一个useGeneratedKeys属性，该属性的默认值为false，当该属性的值为true时，在进行插入操作时，mybatis会取到当前正在插入的记录在数据库中的自动递增的主键值，并把它设置给指定的实体的属性，这就需要设置一个keyProperty属性，用于指定实体中表示主键的属性

Blog.java

package com.tiantian.mybatis.model;

public class Blog {

  private int id;

  private String title;

  private String content;

  private String owner;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getTitle() {
    return title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public String getContent() {
    return content;
  }

  public void setContent(String content) {
    this.content = content;
  }

  public String getOwner() {
    return owner;
  }

  public void setOwner(String owner) {
    this.owner = owner;
  }

  @Override
  public String toString() {
    return "id: " + id + ", title: " + title + ", content: " + content
        + ", owner: " + owner;
  }

}

BlogMapper.java

package com.tiantian.mybatis.model;

import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

/**
 * 以下的操作1都是把SQL写在配置文件里面的，而操作2都是直接用注解标明要执行的SQL语句
 * 因为该Mapper的全名跟BlogMapper.xml文件里面的namespace是一样的，所以不能在这里面
 * 用注解定义一个与BlogMapper.xml文件里面同名的映射
 * @author andy
 *
 */
public interface BlogMapper {

  public Blog selectBlog(int id);
  
  @Select("select * from t_blog where id = #{id}")
  public Blog selectBlog2(int id);
  
  public void insertBlog(Blog blog);
  
  @Insert("insert into t_blog(title,content,owner) values(#{title},#{content},#{owner})")
  public void insertBlog2(Blog blog);
  
  public void updateBlog(Blog blog);
  
  @Update("update t_blog set title=#{title},content=#{content},owner=#{owner} where id=#{id}")
  public void updateBlog2(Blog blog);
  
  public void deleteBlog(int id); 
  
  @Delete("delete from t_blog where id = #{id}")
  public void deleteBlog2(int id);
  
  public List<Blog> selectAll();
  
  @Select("select * from t_blog")
  public List<Blog> selectAll2();
  
  public List<Blog> fuzzyQuery(String title);
  
  @Select("select * from t_blog where title like \"%\"#{title}\"%\"")
  public List<Blog> fuzzyQuery2(String title);
  
}

Test1.java

package com.tiantian.mybatis.test;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.tiantian.mybatis.model.Blog;
import com.tiantian.mybatis.util.Util;

/**
 * 该系列操作是通过把SQL写在配置文件里面，
 * 然后利用SqlSession进行操作的
 * @author andy
 *
 */
public class Test1 {

  /**
   * 新增记录
   */
  @Test
  public void testInsertBlog() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    Blog blog = new Blog();
    blog.setTitle("中国人");
    blog.setContent("五千年的风和雨啊藏了多少梦");
    blog.setOwner("天天");
    session.insert("com.tiantian.mybatis.model.BlogMapper.insertBlog", blog);
    session.commit();
    session.close();
  }
  
  /**
   * 查询单条记录
   */
  @Test
  public void testSelectOne() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    Blog blog = (Blog)session.selectOne("com.tiantian.mybatis.model.BlogMapper.selectBlog", 8);
    System.out.println(blog);
    session.close();
  }
  
  /**
   * 修改记录
   */
  @Test
  public void testUpdateBlog() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    Blog blog = new Blog();
    blog.setId(7);//需要修改的Blog的id
    blog.setTitle("中国人2");//修改Title
    blog.setContent("黄色的脸，黑色的眼，不变是笑容");//修改Content
    blog.setOwner("天天2");//修改Owner
    session.update("com.tiantian.mybatis.model.BlogMapper.updateBlog", blog);
    session.commit();
    session.close();
  }
  
  /**
   * 查询所有的记录
   */
  @Test
  public void testSelectAll() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.selectAll");
    for (Blog blog:blogs)
      System.out.println(blog);
    session.close();
  }
  
  /**
   * 模糊查询
   */
  @Test
  public void testFuzzyQuery() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    String title = "中国";
    List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.fuzzyQuery", title);
    for (Blog blog:blogs)
      System.out.println(blog);
    session.close();
  }
  
  /**
   * 删除记录
   */
  @Test
  public void testDeleteBlog() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    session.delete("com.tiantian.mybatis.model.BlogMapper.deleteBlog", 8);
    session.commit();
    session.close();
  }
  
}

Test2.java

package com.tiantian.mybatis.test;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.tiantian.mybatis.model.Blog;
import com.tiantian.mybatis.model.BlogMapper;
import com.tiantian.mybatis.util.Util;

/**
 * 该系列操作是将SQL语句写在配置文件里面，
 * 然后通过对应Mapper接口来进行操作的
 * @author andy
 *
 */
public class Test2 {

  /**
   * 新增记录
   */
  @Test
  public void testInsertBlog() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    Blog blog = new Blog();
    blog.setTitle("中国人");
    blog.setContent("五千年的风和雨啊藏了多少梦");
    blog.setOwner("天天");
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    blogMapper.insertBlog(blog);
    session.commit();
    session.close();
  }

  /**
   * 查询单条记录
   */
  @Test
  public void testSelectOne() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    Blog blog = blogMapper.selectBlog(7);
    System.out.println(blog);
    session.close();
  }

  /**
   * 修改记录
   */
  @Test
  public void testUpdateBlog() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    Blog blog = new Blog();
    blog.setId(9);// 需要修改的Blog的id
    blog.setTitle("中国人2");// 修改Title
    blog.setContent("黄色的脸，黑色的眼，不变是笑容");// 修改Content
    blog.setOwner("天天2");// 修改Owner
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    blogMapper.updateBlog(blog);
    session.commit();
    session.close();
  }

  /**
   * 查询所有记录
   */
  @Test
  public void testSelectAll() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    List<Blog> blogs = blogMapper.selectAll();
    for (Blog blog : blogs)
      System.out.println(blog);
    session.close();
  }

  /**
   * 模糊查询
   */
  @Test
  public void testFuzzyQuery() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    String title = "中国";
    List<Blog> blogs = blogMapper.fuzzyQuery(title);
    for (Blog blog : blogs)
      System.out.println(blog);
    session.close();
  }

  /**
   * 删除记录
   */
  @Test
  public void testDeleteBlog() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    blogMapper.deleteBlog(10);
    session.commit();
    session.close();
  }

}

Test3.java

package com.tiantian.mybatis.test;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.tiantian.mybatis.model.Blog;
import com.tiantian.mybatis.model.BlogMapper;
import com.tiantian.mybatis.util.Util;

/**
 * 该系列操作是利用Mapper接口来进行的
 * ，然而其相应的SQL语句是通过对应的
 * 注解Annotation在Mapper中对应的方法上定义的
 * @author andy
 *
 */
public class Test3 {

  /**
   * 新增记录
   */
  @Test
  public void testInsert() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    Blog blog = new Blog();
    blog.setTitle("title2");
    blog.setContent("content2");
    blog.setOwner("owner2");
    blogMapper.insertBlog2(blog);
    session.commit();
    session.close();
  }
  
  /**
   * 查找单条记录
   */
  @Test
  public void testSelectOne() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    Blog blog = blogMapper.selectBlog2(1);
    System.out.println(blog);
    session.close();
  }
  
  /**
   * 查找多条记录，返回结果为一集合
   */
  @Test
  public void testSelectAll() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    List<Blog> blogs = blogMapper.selectAll2();
    for (Blog blog:blogs)
      System.out.println(blog);
    session.close();
  }
  
  /**
   * 修改某条记录
   */
  @Test
  public void testUpdate() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    Blog blog = new Blog();
    blog.setId(3);
    blog.setTitle("title3");
    blog.setContent("content3");
    blog.setOwner("owner3");
    blogMapper.updateBlog2(blog);
    session.commit();
    session.close();
  }
  
  /**
   * 删除记录
   */
  @Test
  public void testDelete() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    blogMapper.deleteBlog2(5);
    session.commit();
    session.close();
  }
  
  @Test
  public void testFuzzyQuery() {
    SqlSession session = Util.getSqlSessionFactory().openSession();
    BlogMapper blogMapper = session.getMapper(BlogMapper.class);
    List<Blog> blogs = blogMapper.fuzzyQuery2("中国");
    for (Blog blog:blogs)
      System.out.println(blog);
    session.close();
  }
  
}

对应的建表语句：

1. CREATE TABLE `t_blog` ( 
2. `id` int(11) NOT NULL AUTO_INCREMENT, 
3. `title` varchar(255) DEFAULT NULL, 
4. `content` varchar(255) DEFAULT NULL, 
5. `owner` varchar(50) DEFAULT NULL, 
6. PRIMARY KEY (`id`) 
7. )

标签：基于,blog,BlogMapper,SqlSession,session,MyBatis3.0,mybatis,基本操作,public
From： https://blog.51cto.com/u_4172728/6046887

基于MyBatis3.0.6的基本操作介绍

相关文章

赞助商

阅读排行