<?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><?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>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 + "]";
}
}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();
}
}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();
}
}
}Mybatis 3.2.7 简单入门Demo,布布扣,bubuko.com
原文地址：http://blog.csdn.net/loveany121/article/details/26603577
