Mybatis 3.2.7 简单入门Demo-CSDN博客

对最新版本 Mybatis 3.2.7 做了一个demo,做个记录

需要的基本jar：
mybatis-3.2.7.jar
mysql-connector-java-5.1.27.jar

首先配置xml文件

mybatis-config.xml

[java]view plaincopy 
   
 <?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>  
       
     <!-- 读取数据连接参数 -->  
     <properties resource="resources/config.properties" />  
   
   
     <settings>  
         <setting name="cacheEnabled" value="true" />  
         <setting name="lazyLoadingEnabled" value="true" />  
         <setting name="multipleResultSetsEnabled" value="true" />  
         <setting name="useColumnLabel" value="true" />  
         <setting name="useGeneratedKeys" value="false" />  
         <setting name="autoMappingBehavior" value="PARTIAL" />  
         <setting name="defaultExecutorType" value="SIMPLE" />  
         <setting name="defaultStatementTimeout" value="25" />  
         <setting name="safeRowBoundsEnabled" value="false" />  
         <setting name="mapUnderscoreToCamelCase" value="false" />  
         <setting name="localCacheScope" value="SESSION" />  
         <setting name="jdbcTypeForNull" value="OTHER" />  
         <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString" />  
     </settings>  
   
   
     <!-- 实体类别名设置 -->  
     <typeAliases>  
         <typeAlias type="model.Customer" alias="Customer" />  
     </typeAliases>  
   
   
     <!-- 数据库连接环境配置 -->  
     <environments default="development">  
         <environment id="development">  
             <!-- JDBC – 这个配置直接简单使用了 JDBC 的提交和回滚设置。 它依赖于从数据源得 到的连接来管理事务范围。 -->  
             <transactionManager type="JDBC" />  
             <!-- MANAGED – 这个配置几乎没做什么。它从来不提交或回滚一个连接。 而它会让 容器来管理事务的整个生命周期(比如 Spring   
                 或 JEE 应用服务器的上下文) 默认 情况下它会关闭连接。 然而一些容器并不希望这样, 因此如果你需要从连接中停止 它,将 closeConnection   
                 属性设置为 false。   
                 <transactionManager type="MANAGED"> <property name="closeConnection"   
                 value="false" />   
                 </transactionManager>   
             -->  
             <!-- UNPOOLED – 这个数据源的实现是每次被请求时简单打开和关闭连接。  
             POOLED – 这是 JDBC 连接对象的数据源连接池的实现,用来避免创建新的连接实例 时必要的初始连接和认证时间。这是一种当前 Web 应用程序用来快速响应请求很流行的方 法。  
             JNDI – 这个数据源的实现是为了使用如 Spring 或应用服务器这类的容器, 容器可以集 中或在外部配置数据源,然后放置一个 JNDI 上下文的引用。  
              -->  
             <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>  
       
     <!-- 多数据库配置 通过 databaseId 匹配 -->  
     <databaseIdProvider type="DB_VENDOR">  
         <property name="SQL Server" value="sqlserver" />  
         <property name="DB2" value="db2" />  
         <property name="Oracle" value="oracle" />  
         <property name="MySQL" value="mysql" />  
     </databaseIdProvider>  
       
     <!-- mapping 文件路径配置 -->  
     <mappers>  
         <mapper resource="mapper/CustomerMapper.xml" />  
     </mappers>  
 </configuration>  

CustomerMapper.xml

[java]view plaincopy 
   
 <?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="model.Customer">  
   
   
     <resultMap id="customerResultMap" type="model.Customer">  
         <id property="id" column="id" />  
         <result property="name" column="username" />  
         <result property="age" column="age" />  
         <result property="des" column="des" />  
     </resultMap>  
   
   
   
   
   
   
     <!-- 用来定义可重用的 SQL 代码段,可以包含在其他语句中。 -->  
     <sql id="customerColumns"> name,age,des </sql>  
     <select id="selectCustomerAll3" resultType="Customer">  
         select  
         <include refid="customerColumns" />  
         from customers  
     </select>  
   
   
     <!-- useGeneratedKey ( 仅 对 insert, update 有 用 ) 这 会 告 诉 MyBatis 使 用 JDBC   
         的 getGeneratedKeys 方法来取出由数据 (比如:像 MySQL 和 SQL Server 这样的数据库管理系统的自动递增字段)内部生成的主键。   
         默认值:false。 <selectKey keyProperty="id" resultType="int" order="BEFORE"> select   
         CAST(RANDOM()*1000000 as INTEGER) a from SYSIBM.SYSDUMMY1 </selectKey> #{property,javaType=int,jdbcType=NUMERIC}   
         ORDER BY ${columnName} 这里 MyBatis 不会修改或转义字符串。 -->  
     <insert id="saveCustomer" parameterType="model.Customer"  
         useGeneratedKeys="true" keyProperty="id" flushCache="true">  
         insert into  
         customers(name,age,des) values (#{name}, #{age}, #{des})  
     </insert>  
   
   
     <select id="selectCustomerAll" resultType="Customer" flushCache="false" useCache="true">  
         select id,name,age,des  
         from customers  
     </select>  
       
     <!--     
         数组 ：  
         <foreach item="item" index="index" collection="array" open="(" separator="," close=")">    
             #{item}    
         </foreach>   
     -->  
     <select id="selectCustomer3" resultType="Customer">  
         SELECT id,name,age,des  
         FROM customers  
         WHERE id in  
         <foreach item="item" index="index" collection="list" open="(" separator="," close=")">  
             #{id}  
         </foreach>  
     </select>  
   
   
     <select id="selectCustomerByBind" parameterType="Customer" resultType="Customer">  
         <!-- <bind name="pattern" value="'%' + ${name} + '%'" />  此未测试成功 -->  
         <bind name="pattern" value="'%' + _parameter.getName() + '%'" />  
         SELECT id,name,age,des  
         FROM customers  
         WHERE name like #{pattern}  
     </select>  
   
   
     <!-- resultType="hashmap" 返回一个 HashMap 类型的对象,其中的键是列名,值是列对应的值。 -->  
     <select id="selectCustomerAll2" resultType="hashmap">  
         select  
         id,name,age,des  
         from customers  
     </select>  
   
   
     <!-- 可用的收回策略有:   
             LRU – 最近最少使用的:移除最长时间不被使用的对象。   
             FIFO – 先进先出:按对象进入缓存的顺序来移除它们。   
             SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。   
             WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。   
             默认的是 LRU。  
         flushInterval(刷新间隔)可以被设置为任意的正整数,而且它们代表一个合理的毫秒 形式的时间段。默认情况是不设置,也就是没有刷新间隔,缓存仅仅调用语句时刷新。  
         size(引用数目)可以被设置为任意正整数,要记住你缓存的对象数目和你运行环境的 可用内存资源数目。默认值是 1024。  
         readOnly(只读)属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓 存对象的相同实例。因此这些对象不能被修改。  
             这提供了很重要的性能优势。可读写的缓存 会返回缓存对象的拷贝(通过序列化) 。这会慢一些,但是安全,因此默认是 false。  
     -->  
       
     <!-- <cache type="com.domain.something.MyCustomCache"/> 自定义缓存 -->  
     <!-- <cache-ref namespace="com.someone.application.data.SomeMapper"/> 共享相同的缓存-->  
       
     <!-- 创建了一个 FIFO 缓存,并每隔 60 秒刷新,存数结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此在不同线程中的调用者之间修改它们会 导致冲突。 -->  
     <cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true" />  
   
   
   
   
 </mapper>  

Customer.java

[java]view plaincopy 
   
 package model;  
   
   
 public class Customer {  
       
     public int id;  
     public String name;  
     public int age;  
     public String des;  
   
   
     public Customer() {  
     }  
   
   
     public Customer(int id, String name, int age, String des) {  
         this.id = id;  
         this.name = name;  
         this.age = age;  
         this.des = des;  
     }  
       
     public Customer(String name, int age, String des) {  
         this.name = name;  
         this.age = age;  
         this.des = des;  
     }  
       
     public int getId() {  
         return id;  
     }  
     public void setId(int id) {  
         this.id = id;  
     }  
     public String getName() {  
         return name;  
     }  
     public void setName(String name) {  
         this.name = name;  
     }  
   
   
     public int getAge() {  
         return age;  
     }  
   
   
     public void setAge(int age) {  
         this.age = age;  
     }  
   
   
     public String getDes() {  
         return des;  
     }  
     public void setDes(String des) {  
         this.des = des;  
     }  
     @Override  
     public String toString() {  
         return "Customer [id=" + id + ", name=" + name + ", age=" + age  
                 + ", des=" + des + "]";  
     }  
       
 }  

SessionFactoryUtil.java

[java]view plaincopy 
   
 package dao;  
   
   
 import java.io.IOException;  
 import java.io.InputStream;  
   
   
 import org.apache.ibatis.io.Resources;  
 import org.apache.ibatis.session.SqlSession;  
 import org.apache.ibatis.session.SqlSessionFactory;  
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
   
   
 public class SessionFactoryUtil {  
       
     private static final String MYBATIS_CONFIG_PATH = "resources/mybatis-config.xml";  
       
     private static InputStream is = null;  
       
     private static SqlSessionFactory sqlSessionFactory = null;  
       
     static {  
         try {  
             is = Resources.getResourceAsStream(MYBATIS_CONFIG_PATH);  
             //SqlSessionFactoryBuilder这个类可以被实例化,使用和丢弃。一旦创建了 SqlSessionFactory 后,这个类就不需 要存在了。   
             //因此 SqlSessionFactoryBuilder 实例的最佳范围是方法范围 (也就是本地方法变量)。  
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);   
         } catch (IOException e) {  
             e.printStackTrace();  
         }  
           
     }  
     /** 
      * 私有构造器 
      */  
     private SessionFactoryUtil(){};  
       
     /** 
      *  SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次 
      *  最简单的就是使用单例模式或者静态单例模式。 
      * @return SqlSessionFactory 
      */  
     public static SqlSessionFactory getSqlSessionFactoryIntance(){  
           
         return sqlSessionFactory;  
           
     }  
       
     /** 
      * 每个线程都应该有它自己的 SqlSession 实例。 
      * SqlSession 的实例不能被共享,也是线程 不安全的。 
      * 因此最佳的范围是请求或方法范围。 
      * 绝对不能将 SqlSession 实例的引用放在一个 类的静态字段甚至是实例字段中。 
      * @return SqlSession 
      */  
     public static SqlSession getSqlSessionIntance() {  
   
   
         return sqlSessionFactory.openSession();  
           
     }  
       
 }  

测试：

[java]view plaincopy 
   
 package dao;  
   
   
 import java.util.ArrayList;  
 import java.util.List;  
 import java.util.Map;  
   
   
 import model.Customer;  
   
   
 import org.apache.ibatis.session.SqlSession;  
 import org.junit.Test;  
   
   
 public class CustomerDao {  
   
   
     public CustomerDao() {  
     }  
   
   
     @Test  
     public void findCustomer() {  
   
   
         //SqlSessionFactory ssf = null;  
         SqlSession sqlSession = null;  
         try {  
             //ssf = SessionFactoryUtil.getSqlSessionFactoryIntance();  
             sqlSession = SessionFactoryUtil.getSqlSessionIntance();  
             System.out.println(sqlSession); //每次都是新建一个SqlSession实例org.apache.ibatis.session.defaults.DefaultSqlSession@dc57db  
               
             //sqlSession = SessionFactoryUtil.getSqlSessionIntance();  
             //System.out.println(sqlSession); //每次都是新建一个SqlSession实例org.apache.ibatis.session.defaults.DefaultSqlSession@c24c0  
               
             //resultType="hashmap"  返回类型为 Map<id,Map<列名，值>>  
             Map<Object, Object> customerMap = (Map<Object, Object>) sqlSession.selectMap("selectCustomerAll2", "id");  
             System.out.println("customerMap : " + customerMap);  
             for(Map.Entry<Object, Object> customerSingle : customerMap.entrySet()) {  
                 System.out.println("customerMap : " + customerSingle);  
                 System.out.println("customerMap_Key : " + customerSingle.getKey());  
                 System.out.println("customerMap_Value : " + customerSingle.getValue());  
                 @SuppressWarnings("unchecked")  
                 Map<Object, Object> map = (Map<Object, Object>) customerSingle.getValue();  
                 System.out.println("Name : " + map.get("name"));  
             }  
               
             //resultType="Customer" 自动封装成 list  
             //如果没有查到数据，返回长度为0的list  
             //List<Customer> customerList = sqlSession.selectList("selectCustomerAll");  
               
             //测试 bind 用于  like 查询  
             Customer customerBind = new Customer("Man",110,"service");  
             List<Customer> customerList = sqlSession.selectList("selectCustomerByBind", customerBind);  
   
             System.out.println("customerList : " + customerList);  
             System.out.println("customerList : " + customerList.size());  
               
             List<Customer> customerList1 = new ArrayList<Customer>();  
             System.out.println("customerList1 : " + customerList1);  
             System.out.println("customerList1 : " + customerList1.size());  
               
             for (Customer customer : customerList) {  
                 System.out.println(customer);  
             }  
               
         } catch (Exception e) {  
             e.printStackTrace();  
         } finally {  
             if(sqlSession != null) {  
                 sqlSession.close();  
             }  
         }  
   
   
     }  
   
   
     @Test  
     public void saveCustomer() {  
           
         SqlSession sqlSession = null;  
         try {  
             sqlSession = SessionFactoryUtil.getSqlSessionIntance();  
               
             Customer customer = new Customer("herry",110,"service");  
             int id = sqlSession.insert("saveCustomer", customer); //返回影响的行数  
             System.out.println(id);  
             System.out.println(customer.getId()); //id 已经被set为 自增长的 key  
               
             sqlSession.commit();  
         } catch (Exception e) {  
             e.printStackTrace();  
             sqlSession.rollback();  
         }finally {  
             sqlSession.close();  
         }  
     } 