项目需要,需要用ibatis,我花了一天时间学习,一天时间整理,希望能和刚入门的ibatis朋友,一起分享.....
/**
* IbatisTest.java
* com.isoftstone.cry.ibatisTest
*
* Function: TODO
*
* ver date author
* ──────────────────────────────────
* Mar 10, 2011
*
* Copyright (c) 2011, All Rights Reserved.
*/
package com.isoftstone.cry.ibatis;
import java.io.IOException;
import java.io.Reader;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import com.isoftstone.cry.pojo.KeyBean;
import com.isoftstone.cry.pojo.LockBean;
/**
*
* ClassName:IbatisDemo
* Project:
* Company: isoftStone
*
* @author
* @version
* @since Ver 1.1
* @Date 2011 Mar 14
* @see
*/
public class IbatisDemo {
public static void main(String[] args) throws IOException,SQLException{
// 读取配置文件
Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);
// 单表的增删改查
// ①、查询表集合
/*List<LockBean> lockList = (List<LockBean>)sqlMap.queryForList("lockNameSpace.getLockList");
for(LockBean lb : lockList){
System.out.println(
lb.getId()+" "+lb.getLockName()+" "+lb.getLockFactory()
);
}*/
// ②、查询表对象 by id
/*LockBean lb = (LockBean)sqlMap.queryForObject("lockNameSpace.getLockObjectById",new Long(1));
System.out.println(
lb.getId()+" "+lb.getLockName()+" "+lb.getLockFactory()
);*/
// ③、查询表对象 by like
/*List<LockBean> lockList = (List<LockBean>)sqlMap.queryForList("lockNameSpace.getLockObjectByLike",new String("南京"));
for(LockBean lb : lockList){
System.out.println(
lb.getId()+" "+lb.getLockName()+" "+lb.getLockFactory()
);
}*/
// ④、查询表对象 动态组合查询
// test 前台http 获取属性值
/* LockBean lb = new LockBean();
lb.setLockFactory("南京");
lb.setLockType(new Integer(12));
List<LockBean> lockList = (List<LockBean>)sqlMap.queryForList
("lockNameSpace.getLockListByDynamic",lb);
for(LockBean lock : lockList){
System.out.println(
lock.getId()+" "+lock.getLockName()+" "+lock.getLockFactory()
);
}*/
// ⑤、多表查询 - 一对一 关联查询 ... (所谓“n+1”Select问题)
/*List<LockBean> lockList = (List<LockBean>)sqlMap.queryForList
("lockNameSpace.getLockList");
for(LockBean lock : lockList){
System.out.println(
lock.getId()+" "+lock.getLockName()+" "+lock.getLockInfo().getLockMoney()
);
}*/
// ⑥、多表查询 - 一对一 (解决所谓“n+1”Select问题)
/*List<LockBean> lockList = (List<LockBean>)sqlMap.queryForList
("lockNameSpace.getLockListOneToOne");
for(LockBean lock : lockList){
System.out.println(
lock.getId()+" "+lock.getLockName()+" "+lock.getLockInfo().getLockMoney()
);
}*/
// 7、 多表查询 一对多(基本解决,有个bug.....)
/*List<LockBean> lockList = (List<LockBean>)sqlMap.queryForList
("lockNameSpace.getLockList");
System.out.println("size = "+lockList.size());
for(int i=0;i<lockList.size();i++)
{
LockBean lb = lockList.get(i);
System.out.println(lb.getId()+" - ");
for(int j=0;j<lb.getKeyList().size();j++){
KeyBean kb = lb.getKeyList().get(j);
System.out.println(kb.getLockId()+" "+kb.getId()+" "+kb.getKeyName());
}
}*/
// 8、插入操作 insert
/*LockBean lb = new LockBean();
lb.setLockName("lockName");
lb.setLockFactory("lockFactory");
lb.setLockColor("lockColor");
lb.setLockType(new Integer(44));
sqlMap.insert("lockNameSpace.insertLock",lb);
System.out.println("insert success .... ");*/
// 9、批量插入操作 insert
/*List<LockBean> lbList = new ArrayList<LockBean>();
for(int i=0;i<5;i++){
LockBean lb = new LockBean();
lb.setLockName("lockName"+i);
lb.setLockFactory("lockFactory"+i);
lb.setLockColor("lockColor"+i);
lb.setLockType(new Integer(44)+i);
lbList.add(lb);
}*/
// 结合spring批量处理
/*SqlMapClientCallback callback = new SqlMapClientCallback() {
public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {
executor.startBatch();
for (T tObject : memberList) {
executor.insert(statement, tObject); // statement在*MapSql.xml一条语句的id
}
executor.executeBatch();
return null;
}
};*/
// ibatis 批量插入 - 删除跟新类似
/*sqlMap.startTransaction();
for(int i=0;i<lbList.size();i++){
sqlMap.insert("lockNameSpace.batchInsertLock",lbList.get(i));
}
sqlMap.executeBatch();
sqlMap.commitTransaction();
sqlMap.endTransaction();
System.out.println("批量插入完成................");*/
// 10、 删除操作 delete
/*sqlMap.delete("lockNameSpace.deleteLock",100);*/
// 11、批量删除
/*sqlMap.startTransaction();
for(int i=51;i<100;i++){
sqlMap.delete("lockNameSpace.deleteLock",i);
}
sqlMap.executeBatch();
sqlMap.commitTransaction();
sqlMap.endTransaction();
System.out.println("批量删除完成................");*/
// 12、更新操作 update ..
/*LockBean lb = new LockBean();
lb.setLockName("updatelockName");
lb.setLockColor("upColor");
lb.setId(50);
sqlMap.update("lockNameSpace.updateLock",lb);
System.out.println("更新完成。。。。。");*/
// 13、批量更新
/*List<LockBean> lbList = new ArrayList<LockBean>();
for(int i=50;i<60;i++){
LockBean lb = new LockBean();
lb.setLockName("lockName"+i);
lb.setLockFactory("lockFactory"+i);
lb.setLockColor("Color"+i);
lb.setLockType(new Integer(44)+i);
lb.setId(i);
lbList.add(lb);
}
sqlMap.startTransaction();
for(int i=0;i<lbList.size();i++){
sqlMap.update("lockNameSpace.updateLock",lbList.get(i));
}
sqlMap.executeBatch();
sqlMap.commitTransaction();
sqlMap.endTransaction();
System.out.println("批量更新完成................");*/
}
}
<?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="lockNameSpace">
<!-- ibatis add,delete,modify,query demo -->
<!-- 设计映射 -->
<typeAlias alias="lock" type="com.isoftstone.cry.pojo.LockBean"/>
<typeAlias alias="lockInformation" type="com.isoftstone.cry.pojo.LockInfoBean"/>
<typeAlias alias="lockKey" type="com.isoftstone.cry.pojo.KeyBean"/>
<resultMap id="lockResult" class="lock">
<result property="id" column="id"/>
<result property="lockName" column="lock_Name"/>
<result property="lockColor" column="lock_Color"/>
<result property="lockFactory" column="lock_Factory"/>
<result property="lockType" column="lock_Type"/>
<!-- 一对一设置 n+1 select 延时加载-->
<result property="lockInfo" column="id" select="lockNameSpace.getLockVsInfo"/>
<!-- 一对多 -->
<result property="keyList" column="id" select="lockNameSpace.getKeyList"/>
<!-- <result property="lockInfo" resultMap="resultLockInfo"/>-->
</resultMap>
<!-- 备注:resultMap 映射机制,resultClass 隐式映射(前提是javaBean属性和表字段column相同) -->
<!-- query object list -->
<!-- query all -->
<select id="getLockList" resultMap="lockResult">
<![CDATA[
SELECT * FROM LOCK_
]]>
</select>
<!-- query by id -->
<select id="getLockObjectById" resultMap="lockResult">
SELECT * FROM LOCK_ WHERE ID = #VALUE#
</select>
<!-- query by like -->
<select id="getLockObjectByLike" resultMap="lockResult">
SELECT * FROM LOCK_ WHERE LOCK_FACTORY LIKE '%$VALUE$%'
</select>
<!-- query dynamik -->
<select id="getLockListByDynamic" resultMap="lockResult">
SELECT * FROM LOCK_
<dynamic prepend="WHERE">
<isNotEmpty prepend="and" property="lockFactory">
(lock_factory like '%$lockFactory$%')
</isNotEmpty>
<isNotNull prepend="AND" property="lockType">
(lock_type = #lockType#)
</isNotNull>
</dynamic>
</select>
<!-- 多表查询 一对一 -->
<!-- 关联lockInfo表属性对应数据库字段 -->
<resultMap id="resultLockInfo" class="lockInformation">
<result property="id" column="id"/>
<result property="lockId" column="lock_Id"/>
<result property="lockWeight" column="lock_Weight"/>
<result property="lockMoney" column="lock_Money"/>
<result property="lockRemark" column="lock_Remark"/>
</resultMap>
<!-- 一对一查询 SQL -->
<!--
在lock_表POJO中增加了 lockInfo对象
result property="lockInfo" column="id" select="lockNameSpace.getLockVsInfo"
用2次SQL查询实现 一对一 关联
也就是所谓“n+1”Select问题(如果lock表有十几万数据,而lockinfo表就几条数据问题)
-->
<select id="getLockVsInfo" resultMap="resultLockInfo">
select * from lock_info where lock_id = #value#
</select>
<!--
解决一对一的 n+1 问题 (待解决...)
<select id="getLockListOneToOne" parameterClass="int" resultMap="lockResult">
<![CDATA[
SELECT l.*,i.* FROM lock_ l,lock_info i WHERE l.id=i.lock_id and l.id=#value#
]]>
</select>
-->
<!-- 一对多 (单向关联和双向关联)-->
<resultMap class="lockKey" id="keyResultMap">
<result property="id" column="id"/>
<result property="keyName" column="key_Name"/>
<result property="lockId" column="lock_Id"/>
</resultMap>
<select id="getKeyList" parameterClass="int" resultMap="keyResultMap">
select * from key_ where LOCK_ID = #id#
</select>
<!-- insert -->
<insert id="insertLock" parameterClass="lock">
<!-- 获取序列 -->
<selectKey keyProperty="id" resultClass="long">
SELECT pagetest_seq.nextval AS id FROM dual
</selectKey>
insert into lock_ (id,lock_Name,lock_Color,lock_Factory,lock_Type) values (#id#,#lockName#,#lockColor#,#lockFactory#,#lockType#)
</insert>
<!-- batch insert -->
<insert id="batchInsertLock" parameterClass="lock">
<!-- 获取序列 -->
<selectKey keyProperty="id" resultClass="long">
SELECT pagetest_seq.nextval AS id FROM dual
</selectKey>
insert into lock_ (id,lock_Name,lock_Color,lock_Factory,lock_Type) values (#id#,#lockName#,#lockColor#,#lockFactory#,#lockType#)
</insert>
<!-- delete -->
<delete id="deleteLock" parameterClass="int">
delete from lock_ where id =#id#
</delete>
<!-- update -->
<update id="updateLock" parameterClass="lock">
update lock_ set lock_name=#lockName# , lock_color=#lockColor# where id=#id#
</update>
<!-- page -->
<!-- batch -->
</sqlMap>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig
PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
<settings
cacheModelsEnabled="true"
enhancementEnabled="true"
lazyLoadingEnabled="true"
maxRequests="32"
maxSessions="10"
maxTransactions="5"
useStatementNamespaces="true" />
<transactionManager type="JDBC" commitRequired="false">
<dataSource type="SIMPLE">
<property name="JDBC.Driver" value="oracle.jdbc.OracleDriver"/>
<property name="JDBC.ConnectionURL"
value="jdbc:oracle:thin:@127.0.0.1:1521:ORCL"/>
<property name="JDBC.Username" value="SYSTEM"/>
<property name="JDBC.Password" value="suypower"/>
</dataSource>
</transactionManager>
<sqlMap resource="com/isoftstone/cry/pojo/lock.xml"/>
</sqlMapConfig>
public class KeyBean implements Serializable{
private long id ;
private String keyName ;
private long lockId ;
。。。。。。。get、set
----------------------------
public class LockBean implements Serializable{
private long id ; // 主键
private String lockName ; // 锁名称
private String lockColor ; // 锁颜色
private String lockFactory ; // 锁出厂公司
private Integer lockType ; // 锁类型 - 枚举字段 (用封装类型,允许null)
private LockInfoBean lockInfo ; // 一对一
private List<KeyBean> keyList = new ArrayList<KeyBean>(); // 一对多
get、set
-----------------------------
public class LockInfoBean implements Serializable{
private long id ;
private long lockId ;
private String lockWeight ;
private String lockMoney ;
private String lockRemark ;
分享到:
相关推荐
在本示例中,"ibatis实现增删改查功能demo"是一个具体的项目,旨在演示如何利用Ibatis进行数据库操作,包括插入(Insert)、删除(Delete)、更新(Update)和查询(Select)数据。以下将详细解析这个项目的重点内容...
在这个“增删改查(二)”的主题中,我们将继续上一部分的内容,详细介绍如何执行数据库的基本操作。 首先,我们需要理解Ibatis的核心概念,包括XML配置文件、映射器接口和SqlSession。XML配置文件是Ibatis的起点,...
本篇文章将详细探讨iBatis在增删改查(CRUD)操作以及一对一和一对多关系映射中的应用。 首先,让我们了解一下iBatis的CRUD操作: 1. **创建(Create)**:在iBatis中,创建数据通常通过`<insert>`标签实现。你需要...
总结,Ibatis以其简单易用、灵活高效的特性在Java开发中占据重要地位,其增删改查功能的实现让开发者能更加专注于业务逻辑,而不是繁琐的JDBC操作。对于初学者来说,深入理解Ibatis的CRUD操作及其相关配置,对提升...
在这个项目中,开发者利用了Spring 2.5、Struts 2.1和iBatis 2.3这三个组件来实现数据的增删改查功能,并且结合了存储过程来增强数据库操作的灵活性。同时,通过Junit进行单元测试,确保代码的正确性和稳定性。 ...
这个例子展示了如何将这三个框架集成在一起,实现对MySQL数据库的增删改查操作。接下来,我们将深入探讨这些技术及其在实际项目中的应用。 首先,Struts2 是一个基于MVC(Model-View-Controller)设计模式的Web应用...
Ibatis与MySQL的结合,使得开发者能够方便地执行SQL查询,实现数据的增删改查操作。 整合这五个技术的关键在于配置。在Maven的pom.xml文件中,需要定义所有依赖项,确保所有组件的版本兼容。在Spring的配置文件中,...
**Ibatis 框架详解:为初学者的增删改查指南** Ibatis 是一个优秀的持久层框架,它能够将SQL与Java代码分离,使得开发者可以更专注于SQL语句的编写,同时避免了JDBC的繁琐操作。本文将深入探讨Ibatis的基本概念、...
加快了开发速度,但是也有一些不足之处,比如由于三种框架的配置文件较多,也给我们带来了一些不便,特别是对于较小的应用来说更是如此,本文主要是对Strtus2、Spring、iBatis三个开源框架进行一个集成
本实例主要关注MyBatis如何实现增删改查(CRUD)操作,包括处理不同类型的表关系,如一对一、一对多、多对多的关系映射,以及常见的多参数传参方法。 首先,让我们深入理解MyBatis的核心概念。MyBatis允许开发者...
每个Action类中会有一个或多个业务方法,分别对应增删改查的动作。 接下来,使用Ibatis的配置文件(mybatis-config.xml)来配置数据源,以及SqlMapConfig.xml来定义SQL映射文件。在SQL映射文件中,编写具体的SQL语句...
在这个"ibate 的增删改查例子"中,我们将深入探讨如何使用Ibatis进行数据的插入(Insert)、查询(Select)、更新(Update)和删除(Delete)操作。 首先,Ibatis 的核心是SqlMapConfig.xml配置文件,它包含了数据...
这个"SSI 增删改查 范例"显然是一份针对初学者的教程,旨在通过实例演示如何在Java J2EE环境中使用SSI进行基本的数据操作,如添加、删除、修改和查询。这里我们将深入探讨SSI的基本概念,以及它与Java J2EE、iBatis...
以上就是使用 Struts、Spring 和 iBatis 实现增删改查操作的基本流程和关键点。理解这些概念并熟练掌握它们的整合,对于构建高效、可维护的 Java Web 应用至关重要。在实际开发中,还需要考虑安全性、性能优化、代码...
本篇将详细讲解Ibatis在实现模糊查询、关联查询以及增删改查操作时的关键知识点。 首先,模糊查询是数据库操作中常见的功能,Ibatis通过`<if>`标签或`<where>`标签配合`#{}`占位符来实现。例如,如果你有一个用户...
总之,SSI(在此场景下特指Spring、Struts和Ibatis的组合)增删改查功能的实现,是Java Web开发中的一个典型应用场景,涉及到模型设计、数据访问、业务逻辑处理以及前端交互等多个层面。通过本文档的介绍,相信读者...
-- 更多的增删改查操作 --> ``` 同时,需要创建对应的Mapper接口: ```java public interface UserMapper { void insertUser(User user); // 其他方法 } ``` 在Service层,我们可以使用SqlSession来执行SQL...
此外,Ibatis还支持结果映射、关联映射等功能,可以处理复杂的查询结果,如一对多、多对一、多对多关系。在处理这些关系时,Ibatis的 `<association>`、`<collection>` 和 `<resultMap>` 元素将发挥重要作用。 总的...
在这个“struts2+spring+ibatis增删查改翻页代码示例”中,我们将深入探讨这三个框架如何协同实现数据管理的基本操作,并集成MySQL数据库和Tomcat web服务器。 首先,Struts2作为MVC(模型-视图-控制器)框架,主要...