iBatis2学习笔记：单表映射

最新推荐文章于 2021-01-19 02:15:14 发布
最新推荐文章于 2021-01-19 02:15:14 发布
阅读量90 收藏
点赞数
文章标签： 数据库 java 开发工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34310785/article/details/85203728
版权
iBatis2学习笔记：单表映射
 
环境：
MySQL5.51b
iBatis 2.3
Spring 2.5.4
 
 
一、SQL
/*==============================================================*/
/* Table: foo                                                   */
/*==============================================================*/
create table foo
(
   id                   bigint,
   name                 varchar(20),
   type                 varchar(20),
   remark               varchar(600)
);

alter table foo comment '单表';
 
二、POJO
public class Foo {  
     private Long id;  
     private String name;  
     private String type;  
     private String remark;  
 
三、SqlMap
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd" >

<sqlMap namespace="foo">
    <typeAlias alias="foo" type="com.lavasoft.ssi.domain.Foo"/>

    <! -- 映射结果集 -->
    <resultMap id="result_base" class="foo">
        <result property="id" column="id"/>
        <result property=" name" column=" name"/>
    </resultMap>
    <! -- 继承映射结果集 -->
    <resultMap id="result" class="foo" extends="result_base">
        <result property="type" column="type"/>
        <result property="remark" column="remark"/>
    </resultMap>
    <resultMap id="result_map" class="foo">
        <result property="id" column="fid"/>
        <result property=" name" column="fname"/>
        <result property="remark" column="fremark"/>
    </resultMap>

    <! -- 插入操作：以域对象foo做参数 -->
    < insert id=" insert" parameterClass="foo">
         insert into foo( name,type,remark) values(# name#,#type#,#remark#)
        <selectKey keyProperty="id" resultClass="long">
             select LAST_INSERT_ID()
        </selectKey>
    </ insert>
    <! -- 更新操作：以域对象foo做参数 -->
    < update id=" update" parameterClass="foo">
         update foo set name = # name#, type = #type#, remark = #remark# where id = #id#
    </ update>
    <! -- 多个参数情况下，用Map或者域对象做参数均可以，但域对象通常有更好的性能 -->
    <! -- 更新操作：以Map做参数 -->
    < update id="updateSomeByMap" parameterClass="map">
         update foo set name = # name#, remark = #remark# where id = #id#
    </ update>
    <! -- 更新操作：以域对象做参数 -->
    < update id="updateSomeByObject" parameterClass="foo">
         update foo set name = # name#, remark = #remark# where id = #id#
    </ update>
    <! -- where条件的三种写法“id = #value#，id = #id# id = #?#”均正确，查询结果相同  -->
    <! -- 结果集应该优先使用域对象 -->
    <! -- resultClass表示结果封装为foo类型，parameterClass表示参数类型，resultMap指定查询结果要填充的字段和对应关系 -->
    < select id="getById" resultClass="foo" parameterClass="long" resultMap="result">
         select * from foo where id = #value#
    </ select>
    <! -- 查询多条记录：结果封装为List<Foo> -->
    < select id="foo.getAll" resultClass="foo" resultMap="result">
        <![CDATA[
         select id, name,type,remark from foo where id > 0 and id < 8
        ]]>
    </ select>
    <! -- 查询多条记录：结果封装在List<HashMap>中 -->
    < select id="getAll2" resultMap="result_map" resultClass="map">
        <![CDATA[
         select id as fid, name as fname, remark as fremark from foo where id > 0 and id < 8
        ]]>
    </ select>
    < select id="getAll3">
        <![CDATA[
         select id as xid, name as xname from foo
        ]]>
    </ select>
    < select id="getAll4">
        <![CDATA[
         select id,type as name from foo   where id > 0 and id < 8
        ]]>
    </ select>
    < delete id="deleteById" parameterClass="long">
         delete from foo where id = #value#
    </ delete>
    < delete id="deleteAll">
         delete from foo
    </ delete>
    < select id="getCount" resultClass=" int">
         select count(id) from foo
    </ select>
    < select id="getByDynamic" resultMap="result" parameterClass="foo">
         select * from foo
        <dynamic prepend=" where">
            <isNotNull prepend=" and" property=" name">
                ( name like # name#)
            </isNotNull>
            <isNotEmpty prepend=" and">
                (type like '%'|| #type# || '%')
            </isNotEmpty>
        </dynamic>
        <isGreaterThan prepend=" where" property="id" compareValue="10">
            remark is not null
        </isGreaterThan>
    </ select>
</sqlMap>        
  
 
三、DAO即测试代码
 
public interface FooDAO {
     public Long insert(Foo foo);
     public int getCount();
     public int update(Foo foo);
     public int updateSomeByMap(Long id,String name,String remark);
     public int updateSomeByObject(Long id,String name,String remark);
     public Foo getById(Long id);
     public List getAll();
     public Object getAll2();
     public List getAll3();
     public List getAll4();
     public List getByDynamic(Foo foo);
     public int deleteById(Long id);
     public int deteteAll();
}
 
public class FooDAOImpl extends SqlMapClientDaoSupport implements FooDAO {

     public Long insert(Foo foo) {
       return  (Long)getSqlMapClientTemplate().insert( "foo.insert", foo);
    }

     public int getCount() {
         return (Integer)getSqlMapClientTemplate().queryForObject( "foo.getCount");
    }

     public int update(Foo foo) {
         return getSqlMapClientTemplate().update( "foo.update", foo);
    }

     public int updateSomeByMap(Long id, String name, String remark) {
        Map pm = new HashMap();
        pm.put( "id", id);
        pm.put( "name", name);
        pm.put( "remark", remark);
         return getSqlMapClientTemplate().update( "foo.updateSomeByMap", pm);
    }

     public int updateSomeByObject(Long id,String name,String remark) {
        Foo foo = new Foo();
        foo.setId(id);
        foo.setName(name);
        foo.setRemark(remark);
         return getSqlMapClientTemplate().update( "foo.updateSomeByObject", foo);
    }

     public Foo getById(Long id) {
         return (Foo) getSqlMapClientTemplate().queryForObject( "foo.getById",id);
    }

     public List getAll() {
         return getSqlMapClientTemplate().queryForList( "foo.getAll");
    }

     public Object getAll2() {
//        return getSqlMapClientTemplate().queryForList();
        List<String> ls = new ArrayList<String>();


         return getSqlMapClientTemplate().queryForMap( "foo.getAll2", null, "id");
    }

     public List getAll3() {
        Object obj =getSqlMapClientTemplate().queryForObject( "foo.getAll3");
         return getSqlMapClientTemplate().queryForList( "foo.getAll3");
    }

     public List getAll4() {
         return getSqlMapClientTemplate().queryForList( "foo.getAll4");
    }

     public List getByDynamic(Foo foo) {
         return getSqlMapClientTemplate().queryForList( "foo.getByDynamic",foo);
    }

     public int deleteById(Long id) {
         return getSqlMapClientTemplate().delete( "foo.deleteById",id);
    }

     public int deteteAll() {
         return getSqlMapClientTemplate().delete( "foo.deleteAll");
    }
}
 
package com.lavasoft.ssi.test;

import com.lavasoft.ssi.dao.FooDAO;
import com.lavasoft.ssi.common.utils.ApplicationContextUtils;
import com.lavasoft.ssi.domain.Foo;

import java.util.Random;
import java.util.List;
import java.util.Map;
import java.util.Iterator;

/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-6-15 9:29:26<br>
* <b>Note</b>: FooDAO的测试
*/
public class FooDAOTest {
     private FooDAO fooDAO = (FooDAO) ApplicationContextUtils.getApplicationContext().getBean( "fooDAO");

     public void testInsert() {
        System.out.println( "--------insert(Foo foo)--------");
        Foo foo = new Foo( "变态", "ttt", "插入数据测试！");
         for ( int i = 0; i < 15; i++) {
            Long pk = fooDAO.insert(foo);
            System.out.println( "所插入数据的ID=" + pk);
        }
    }

     public void testGetCount() {
        System.out.println( "--------testGetCount()--------");
         int count = fooDAO.getCount();
        System.out.println( "记录总数=" + count);

    }

     public void testUpdate() {
        System.out.println( "--------update(Foo foo)--------");
        String upRemark = "已更新" + new Random( new Random().nextLong()).nextInt();
        Long pk = 1L;

        Foo foo = fooDAO.getById(pk);
        System.out.println( "更新前" + foo);

        foo.setRemark(upRemark);
        fooDAO.update(foo);
        Foo foo1 = fooDAO.getById(pk);
        System.out.println( "更新后" + foo1);
    }

     public void testUpdateSomeByMap() {
        System.out.println( "------updateSomeByMap(Long id,String name,String remark)------");
        String upRemark = "已更新" + new Random( new Random().nextLong()).nextInt();
        Long pk = 2L;
        String name = null;

        Foo foo = fooDAO.getById(pk);
        System.out.println( "更新前" + foo);

        fooDAO.updateSomeByMap(pk, name, upRemark);

        Foo foo1 = fooDAO.getById(pk);
        System.out.println( "更新后" + foo1);
    }

     public void testUpdateSomeByObject() {
        System.out.println( "------updateSomeByObject(Long id,String name,String remark)------");
        String upRemark = "已更新" + new Random( new Random().nextLong()).nextInt();
        Long pk = 3L;
        String name = null;

        Foo foo = fooDAO.getById(pk);
        System.out.println( "更新前" + foo);

        fooDAO.updateSomeByObject(pk, name, upRemark);

        Foo foo1 = fooDAO.getById(pk);
        System.out.println( "更新后" + foo1);
    }

     public void testGetById() {
        System.out.println( "------getById(Long id)------");
        Long pk = 4L;
        Foo foo = fooDAO.getById(pk);
        System.out.println( "结果集" + foo);
    }

     public void testGetAll() {
        System.out.println( "------getAll()------");
        List<Foo> list = fooDAO.getAll();
         for (Foo foo : list) {
            System.out.println( "getAll结果集>>>" + foo);
        }
    }

     public void testGetAll2() {
        System.out.println( "------getAll2()------");
        Object rs = fooDAO.getAll2();
         if (rs instanceof List) {
            System.out.println( "结果集为List");
             for (Object obj : (List) rs) {
                 if (obj instanceof Map) {
                    System.out.println( "结果集Map的元素");                    
                    Map objMap = (Map) obj;
                     for (Iterator<Map.Entry> it = objMap.entrySet().iterator(); it.hasNext();) {
                        Map.Entry me = it.next();
                        System.out.println( "\t" + me.getKey() + "\t" + me.getValue());
                    }
                } else if(obj instanceof Foo){
                    System.out.println( "结果集为Foo类型:"+obj);
                }
            }
        }

    }

     public void testGetAll3() {
        System.out.println( "------getAll3()------");
        List<Foo> list = fooDAO.getAll3();
         for (Foo foo : list) {
            System.out.println( "getAll3结果集>>>" + foo);
        }
    }

     public void testGetAll4() {
        System.out.println( "------getAll4()------");
        List<Foo> list = fooDAO.getAll4();
         for (Foo foo : list) {
            System.out.println( "getAll4结果集>>>" + foo);
        }
    }

     public void testGetByDynamic() {
        System.out.println( "------getByDynamic(Foo foo)------");
        Foo foo = new Foo();
        foo.setName( "变态");
        foo.setType( "t");

        List<Foo> list = fooDAO.getByDynamic(foo);
         for (Foo f : list) {
            System.out.println( "getByDynamic结果集>>>" + f);
        }
    }

     public void testDeleteById() {
        System.out.println( "------deleteById(Long id)------");
        Long pk = 10L;
         int ef = fooDAO.deleteById(pk);
        System.out.println( "删除记录数 = " + ef);
    }

     public void testDeleteAll() {
        System.out.println( "------deteteAll()------");
         int ef = fooDAO.deteteAll();
        System.out.println( "删除记录数 = " + ef);
    }

     public static void main(String args[]) {
        System.out.println( "正在测试FooDAO");
        FooDAOTest fooDAOTest = new FooDAOTest();
        fooDAOTest.testInsert();
        fooDAOTest.testGetCount();
        fooDAOTest.testUpdate();
        fooDAOTest.testUpdateSomeByMap();
        fooDAOTest.testUpdateSomeByObject();
        fooDAOTest.testGetById();
        fooDAOTest.testGetAll();
        fooDAOTest.testGetAll2();
        fooDAOTest.testGetAll3();
        fooDAOTest.testGetAll4();
        fooDAOTest.testGetByDynamic();
//        fooDAOTest.testDeleteById();
//        fooDAOTest.testDeleteAll();
    }
}
 
 
三、其他的资源文件
 
Spring2 的 application.xml
<? xml version ="1.0" encoding ="UTF-8" ?>

< beans default-autowire ="byType"
       xmlns ="http://www.springframework.org/schema/beans"
       xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation ="http://www.springframework.org/schema/beans [url]http://www.springframework.org/schema/beans/spring-beans-2.0.xsd[/url]" >

     < bean id ="propertyConfig" class ="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >
         < property name ="locations" >
             < list >
                 < value >classpath:jdbc.properties </ value >
             </ list >
         </ property >
     </ bean >
    <!-- 配置系统的数据源 -->
     < bean id ="dataSource" class ="org.apache.commons.dbcp.BasicDataSource" destroy-method ="close" >
         < property name ="driverClassName" >
             < value >${jdbc.driver} </ value >
         </ property >
         < property name ="url" >
             < value >${jdbc.url} </ value >
         </ property >
         < property name ="username" >
             < value >${jdbc.username} </ value >
         </ property >
         < property name ="password" >
             < value >${jdbc.password} </ value >
         </ property >
     </ bean >


     < bean id ="transactionManager"
           class ="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
         < property name ="dataSource" ref ="dataSource" />
     </ bean >

    <!-- 根据dataSource和configLocation创建一个SqlMapClient-->
     < bean id ="sqlMapClient"
           class ="org.springframework.orm.ibatis.SqlMapClientFactoryBean" >
         < property name ="configLocation" value ="sqlMapConfig.xml" />
         < property name ="dataSource" ref ="dataSource" />
     </ bean >

     < bean id ="fooDAO" class ="com.lavasoft.ssi.dao.ibatis.FooDAOImpl" >
         < property name ="sqlMapClient" ref ="sqlMapClient" />
     </ bean >
     < bean id ="customerDAO" class ="com.lavasoft.ssi.dao.ibatis.CustomerDAOImpl" >
         < property name ="sqlMapClient" ref ="sqlMapClient" />
     </ bean >
     < bean id ="ordersDAO" class ="com.lavasoft.ssi.dao.ibatis.OrdersDAOImpl" >
         < property name ="sqlMapClient" ref ="sqlMapClient" />
     </ bean >
     < bean id ="userDAO" class ="com.lavasoft.ssi.dao.ibatis.UserDAOImpl" >
         < property name ="sqlMapClient" ref ="sqlMapClient" />
     </ bean >
     < bean id ="roleDAO" class ="com.lavasoft.ssi.dao.ibatis.RoleDAOImpl" >
         < property name ="sqlMapClient" ref ="sqlMapClient" />
     </ bean >
     < bean id ="tlinkDAO" class ="com.lavasoft.ssi.dao.ibatis.TlinkDAOImpl" >
         < property name ="sqlMapClient" ref ="sqlMapClient" />
     </ bean >

</ beans >
 
jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssitest
jdbc.username=root
jdbc.password=leizhimin
 
sqlMapConfig.xml
<? xml version ="1.0" encoding ="GBK" ?>
<!DOCTYPE sqlMapConfig
        PUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN"
        "http://www.ibatis.com/dtd/sql-map-config-2.dtd">

< sqlMapConfig >
     < settings
     cacheModelsEnabled ="true"
     errorTracingEnabled ="true"
     enhancementEnabled ="true"
     lazyLoadingEnabled ="true"
     maxRequests ="32"
     maxSessions ="10"
     maxTransactions ="5"
     useStatementNamespaces ="true" />

    <!-- 单表映射 -->
     < sqlMap resource ="com/lavasoft/ssi/domain/sqlmap/Foo.xml" />

    <!-- 一对多映射 -->
    <!-- <sqlMap resource="com/lavasoft/ssi/domain/sqlmap/Customer.xml"/>-->
    <!-- <sqlMap resource="com/lavasoft/ssi/domain/sqlmap/Orders.xml"/>-->

    <!-- 多对多映射 -->
    <!-- <sqlMap resource="com/lavasoft/ssi/domain/sqlmap/User.xml"/>-->
    <!-- <sqlMap resource="com/lavasoft/ssi/domain/sqlmap/Role.xml"/>-->
    <!-- <sqlMap resource="com/lavasoft/ssi/domain/sqlmap/Tlink.xml"/>-->
</ sqlMapConfig >
 
四、测试结果：
正在测试FooDAO
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
--------insert(Foo foo)--------
所插入数据的ID=1
所插入数据的ID=2
所插入数据的ID=3
所插入数据的ID=4
所插入数据的ID=5
所插入数据的ID=6
所插入数据的ID=7
所插入数据的ID=8
所插入数据的ID=9
所插入数据的ID=10
所插入数据的ID=11
所插入数据的ID=12
所插入数据的ID=13
所插入数据的ID=14
所插入数据的ID=15
--------testGetCount()--------
记录总数=15
--------update(Foo foo)--------
更新前Foo{id=1, name='变态', type='ttt', remark='插入数据测试！'}
更新后Foo{id=1, name='变态', type='ttt', remark='已更新-1425040370'}
------updateSomeByMap(Long id,String name,String remark)------
更新前Foo{id=2, name='变态', type='ttt', remark='插入数据测试！'}
更新后Foo{id=2, name='null', type='ttt', remark='已更新1143492135'}
------updateSomeByObject(Long id,String name,String remark)------
更新前Foo{id=3, name='变态', type='ttt', remark='插入数据测试！'}
更新后Foo{id=3, name='null', type='ttt', remark='已更新1570858341'}
------getById(Long id)------
结果集Foo{id=4, name='变态', type='ttt', remark='插入数据测试！'}
------getAll()------
getAll结果集>>>Foo{id=1, name='变态', type='ttt', remark='已更新-1425040370'}
getAll结果集>>>Foo{id=2, name='null', type='ttt', remark='已更新1143492135'}
getAll结果集>>>Foo{id=3, name='null', type='ttt', remark='已更新1570858341'}
getAll结果集>>>Foo{id=4, name='变态', type='ttt', remark='插入数据测试！'}
getAll结果集>>>Foo{id=5, name='变态', type='ttt', remark='插入数据测试！'}
getAll结果集>>>Foo{id=6, name='变态', type='ttt', remark='插入数据测试！'}
getAll结果集>>>Foo{id=7, name='变态', type='ttt', remark='插入数据测试！'}
------getAll2()------
------getAll3()------
------getAll4()------
------getByDynamic(Foo foo)------
getByDynamic结果集>>>Foo{id=1, name='变态', type='ttt', remark='已更新-1425040370'}
getByDynamic结果集>>>Foo{id=4, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=5, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=6, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=7, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=8, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=9, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=10, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=11, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=12, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=13, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=14, name='变态', type='ttt', remark='插入数据测试！'}
getByDynamic结果集>>>Foo{id=15, name='变态', type='ttt', remark='插入数据测试！'}

Process finished with exit code 0
 
 
weixin_34310785
关注
ibatis2-dao-2.1.6.589.jar
04-06
ibatis2-dao-2.1.6.589.jar文件，ibatis实现控制层
在spring中使用SqlMapClientTemplate操作数据库
热门推荐
天外来客的博客
01-21 3万+
SqlMapClientTemplate是SqlMapClient的封装类。 SqlMapClient是ibatis的。但SpringFramework，也很好的将其进行了集成，我们要做的就是继承SpringFramework中提供的SqlMapClientDaoSupport类即可。 在springFramework的org.springframework.orm.ibatis组件中。 S
iBaits中SqlMapClientTemplate的使用及方法
shixiaoguo90的专栏
11-20 2972
 Apache iBatis是当前IT项目中使用很广泛的一个半自动ORM框架，区别于Hibernate之类的全自动框架，iBatis对数据库的操作拥有更加灵活的控制，对于那些经常需要调用本地数据库函数自定义SQL语句，或是喜欢自己优化SQL执行效率的开发者来说，iBatis是一个非常不错的选择。而得到广泛应用的开源企业架构SpringFramework，也很好的将其进行了集成，使得iBati
ibatis2 解决 n+1 方法
gjp014的专栏
11-14 135
  方法一.延迟加载 &lt;settings lazyLoadingEnabled="true" useStatementNamespaces="true"/&gt; 方法二public class Account {   private long id;  private String firstName;  private String lastName;  private Str...
iBatis2学习笔记
02-08
3.iBatis2学习笔记：单表映射 .doc 4.iBatis2学习笔记：SqlMap的配置总结（18条）.doc 5.iBatis2学习笔记：入参和返回值的问题.doc 6.iBatis2学习笔记：一对多映射（双向）.doc 7.iBatis2学习笔记：多对多映射(双向)...
iBatis学习笔记
04-05
iBatis的主要功能是实现对象关系映射（Object/Relational Mapping，简称O/R Mapping），这是一种将程序中的对象与数据库中的记录进行匹配的技术，使得开发人员可以更方便地操作数据库，减少对SQL语句的手动编写。...
ibatis学习笔记
07-30
本篇文章将围绕iBatis的学习笔记，深入探讨其核心概念、工作原理以及实际应用，帮助读者构建全面的iBatis知识体系。 首先，我们需要了解iBatis的基本概念。iBatis，源自于“Interface-Based SQL Maps”的缩写，它将...
ibatis 学习笔记
05-28
本学习笔记将深入探讨 Ibatis 的核心概念、配置、映射文件以及实际应用。 一、Ibatis 概述 Ibatis 是由 Apache 软件基金会维护的开源项目，其设计目标是简化 SQL 与 Java 代码的绑定，避免手动操作 JDBC。Ibatis ...
ibatIS批量Update
Only the heart peace will be prosperity
10-25 255
一、我的应用 /*批量更新*/ public boolean batchAllUpdateComm(final List&lt;TCommission&gt; commList, final List&lt;Double&gt; ratioList,final String employeeId){ try{ this.getSqlMapClientTemplate().exe...
ibatis学习（一）--ibatis介绍以及用例
咖啡妆
12-07 126
  介绍 iBATIS是以SQL为中心的持久化层框架。能支持懒加载、关联查询、继承等特性。 iBATIS不同于一般的OR映射框架(eg:hibernate)。OR映射框架，将数据库表、字段等映射到类、属性，那是一种元数据(meta-data)映射。iBATIS则是将SQL查询的参数和结果集映射到类。因此可以说，iBATIS做的是SQL Mapping的工作。它把SQL语句看成输入以及输出，结果集就...
iBatis 2.1.0 Released,but...
青之六号
05-24 1500
这次小小的升级，在配置上加了一个新特性： discriminator,方便一张表对应一个继承体系的映射关系。经过实践，发现一个怪现象，在sql-map-config.xml中，多个配置文件的次序必须是有 discriminator 的放在后面，晕。只要相反，就会报错:Translating SQLException with SQLState 07009阿弥托佛，最近忙得一塌糊涂，日志N久未更
iBaits中SqlMapClientTemplate的使用
奋斗、
06-09 5810
Apache iBatis（现已迁至Google Code下发展，更名为MyBatis）是当前IT项目中使用很广泛的一个半自动ORM框架，区别于Hibernate之类的全自动框架，iBatis对数据库的操作拥有更加灵活的控制，对于那些经常需要调用本地数据库函数自定义SQL语句，或是喜欢自己优化SQL执行效率的开发者来说，iBatis是一个非常不错的选择。而得到广泛应用的开源企业架构SpringFr
getSqlMapClientTemplate().insert()方法的返回值问题
weixin_30289831的博客
11-21 855
insert方法的返回值 今天碰到一个问题，就是关于ibatis的insert方法的返回值的问题。在网上找了很多例子，自己也亲自试了一下。最后得出结论：insert方法返回的是在表中插入记录的主键值对象，如果没有主键，则返回一个null。xml中的配置如下： <insert id="insert" parameterClass="uRole"><selectKey ...
SqlMapClientTemplate
cpf2016的专栏
05-11 3623
1.引入与作用          （1）引入                     Spring对第三方开元orm的支持一贯做法是使用模板模式封装一个Template类，如iBatis的SqlMapClient封装为SQLMapClientTemplate，hibernate的HibernateTemplate。              （2）作用                  
ibatis(2)ibatis是什么
PacosonSWJTU的博客
06-17 775
【0】README 1）本文部分内容转自 “ibatis in action”，旨在 review “ibatis是什么” 的相关知识； 2）intro to ibatis： ibatis 就是数据映射器，Martin Fowler在《企业应用架构模式》中，对 data mapper模式是这样描述的： 所谓映射器层，是用于在对象和数据库之间搬运数据，同时保证对象，数据库以及映射器本身都相互独立
ibatis blob mysql_使用ibatis2.1从mysql数据库中读取blob数据展现在网页中
weixin_32382335的博客
01-19 159
为了要实现一个在网页上显示出图像的需求，而这些图像又是可以从后台来CRUD的，所以我打算采用数据库存图片的解决方案，数据库使用mysql。mysql存二进制数据一共有四种类型：TinyBlob, Blob, MediumBlob, LongBlob。这些类型主要的区别在于他们的容量，依次可以存储255B,65K, 16M, 4G。所以对于这个需求，我选择了MediumBlob，16M对于一副图片来...
iBATIS 2.3.4学习笔记：从入门到高级
iBATIS学习笔记是一份详细的指南，针对iBATIS 2.3.4版本进行讲解，旨在帮助读者深入理解和掌握这个流行的持久层框架。作者懒洋洋(QQ:125392310)在2010年6月26日整理了这份笔记，涵盖了iBATIS的核心概念、安装配置、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值