AbstractForever
- 浏览: 308546 次
- 性别:
- 来自: 成都
-
文章分类
- 全部博客 (118)
- VS2008 (2)
- JAVA (34)
- AJAX (1)
- C# (1)
- Flex (16)
- FMS (6)
- SQLSERVER (1)
- ORACLE (1)
- Quartz (1)
- struts2 (1)
- java数据结构 (1)
- java设计模式 (3)
- JSF (0)
- web (2)
- jbpm4 (4)
- J2EE (1)
- webservice (2)
- javascript (8)
- spring (3)
- lucene (0)
- linux (9)
- ibatis (1)
- JPA (2)
- 外挂 (0)
- VB (0)
- Hibernate (1)
- OSGI (8)
- EXT (4)
- Maven (1)
- SpringSecurity (0)
- activiti (0)
- 项目开发 (0)
- 项目管理 (7)
- android (0)
- FFMPEG (1)
- C (2)
- eclipse (1)
最新评论
-
默默得守候在你的身边：
给力
java与Delphi写的dll交互 -
默默得守候在你的身边：
java与Delphi写的dll交互 -
fuguitong：
[url][url][url][url][url][url][ ...
doc转swf -
baidu_25402161：
到结束的时候一直 Can't delete processIn ...
一个请假单流程的实现(struts2.1.8+spring2.5+hibernate3集成jbpm4.3) -
lohaoo1：
nice！
java面包屑导航制作
公司要用ibatis，所以学习学习，初学ibatis，版本号ibatis-2.3.4.726.jar，
所需jar包：
log4j-1.2.15.jar，ojdbc14.jar。
代码已上传，项目不包含ojdbc14.jar，自己加上哈。
使用数据库oracle10,首先对单个实体的各种操作进行测试：
脚本代码：
/*
Navicat Oracle Data Transfer
Oracle Client Version : 10.2.0.1.0
Source Server : chenjun
Source Server Version : 100200
Source Host : localhost:1521
Source Database :
Source Schema : SCOTT
Target Server Type : ORACLE
Target Server Version : 100200
File Encoding : 65001
Date: 2010-04-04 00:09:32
*/
-- ----------------------------
-- Table structure for "STUDENT_"
-- ----------------------------
DROP TABLE "STUDENT_";
CREATE TABLE "SCOTT"."STUDENT_"
( "ID_" NUMBER NOT NULL ENABLE,
"NAME_" VARCHAR2(50),
"SEX_" VARCHAR2(50),
"AGE_" VARCHAR2(50),
"GRADE_" VARCHAR2(50),
"CLASS_" VARCHAR2(50),
PRIMARY KEY ("ID_")
USING INDEX PCTFREE 10 INITRANS 2 MAXTRANS 255 COMPUTE STATISTICS
STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT)
TABLESPACE "USERS" ENABLE
) PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255 NOCOMPRESS LOGGING
STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT)
TABLESPACE "USERS"
;
-- ----------------------------
-- Records of STUDENT_
-- ----------------------------
INSERT INTO "STUDENT_" VALUES ('1', 'student1', '男', '11', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('2', 'student2', '男', '12', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('3', 'student3', '男', '13', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('4', 'student4', '女', '14', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('5', 'student5', '女', '15', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('6', 'student6', '男', '16', '二年级', '一班');
INSERT INTO "STUDENT_" VALUES ('7', 'student7', '男', '17', '二年级', '一班');
INSERT INTO "STUDENT_" VALUES ('8', 'student8', '女', '18', '一年级', '一班');
INSERT INTO "STUDENT_" VALUES ('9', 'story1', '男', '19', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('10', 'story2', '女', '11', '一年级', '一班');
INSERT INTO "STUDENT_" VALUES ('11', 'story3', '男', '12', '二年级', '一班');
INSERT INTO "STUDENT_" VALUES ('12', 'story4', '女', '13', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('13', 'story5', '男', '14', '一年级', '一班');
INSERT INTO "STUDENT_" VALUES ('14', 'story6', '男', '15', '一年级', '一班');
INSERT INTO "STUDENT_" VALUES ('15', 'story7', '女', '16', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('16', 'story8', '男', '17', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('17', 'story9', '男', '18', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('18', 'story8', '男', '15', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('19', 'story8', '男', '16', '一年级', '二班');
INSERT INTO "STUDENT_" VALUES ('20', 'story8', '保密', '16', '一年级', '二班');
-- ----------------------------
-- Checks structure for table "STUDENT_"
-- ----------------------------
ALTER TABLE "STUDENT_" ADD CHECK ("ID_" IS NOT NULL);
-- ----------------------------
-- Primary Key structure for table "STUDENT_"
-- ----------------------------
ALTER TABLE "STUDENT_" ADD PRIMARY KEY ("ID_");
实体类：
package org.forever.xxxx.domain;
import java.io.Serializable;
import org.forever.xxxx.pagination.PageInfo;
/**
* 学生类
*/
public class Student extends PageInfo implements Serializable {
private static final long serialVersionUID = -2786021709397070449L;
private int id;// 主键
private String name;// 姓名
private String sex;// 性别
private int age;// 年龄
private String grade;// 年级
private String clazz;// 班级
public Student() {
}
public Student(String name, String sex, Integer age, String grade,
String clazz) {
this.name = name;
this.sex = sex;
this.age = age;
this.grade = grade;
this.clazz = clazz;
}
public Student(int id, String name, String sex, int age, String grade,
String clazz) {
this.id = id;
this.name = name;
this.sex = sex;
this.age = age;
this.grade = grade;
this.clazz = clazz;
}
//get和set省略
public String toString() {
return new StringBuffer().append("学生编号："+this.id)
.append("\t学生姓名："+this.name)
.append("\t学生年龄："+this.age)
.append("\t学生性别："+this.sex)
.append("\t学生年级："+this.grade)
.append("\t学生班级："+this.clazz)
.toString();
}
}
实体的配置文件：
<?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="Student">
<typeAlias alias="Student" type="org.forever.xxxx.domain.Student" />
<!-- 可以配置多个结果映射信息描述 -->
<resultMap id="StudentResult" class="Student">
<result property="id" column="ID_" />
<result property="name" column="NAME_" />
<result property="sex" column="SEX_" />
<result property="age" column="AGE_" />
<result property="grade" column="GRADE_" />
<result property="clazz" column="CLASS_" />
</resultMap>
<!-- 将参数封装成map进行传递 -->
<select id="findByMap" parameterClass="java.util.Map" resultMap="StudentResult">
SELECT * FROM STUDENT_ WHERE STUDENT_.NAME_=#name#
</select>
<!-- 多条件查询 -->
<select id="find" parameterClass="java.util.Map" resultMap="StudentResult">
<!-- 这种写法的缺陷显而易见,不推荐-->
SELECT * FROM STUDENT_
WHERE STUDENT_.GRADE_=#grade#
AND
STUDENT_.CLASS_=#class#
AND STUDENT_.NAME_ LIKE '%$name$%'
AND
STUDENT_.AGE_ BETWEEN #start_age# AND #end_age#
AND STUDENT_.SEX_ IN
('男','女')
ORDER BY STUDENT_.NAME_ ASC,STUDENT_.AGE_ ASC
</select>
<!--
附上mysql的分页语句模板
照着语句模板套上就行了
@TABLE_NAME--表名
@CONDITIONS--条件
@ORDERS--排序
@FIRST_INDEX--起始索引
@PAGE_SIZE--每页大小
获取集合语句
SELECT * FROM @TABLE_NAME WHERE 1=1 @CONDITIONS @ORDERS LIMIT @FIRST_INDEX,@PAGE_SIZE
获取统计语句
SELECT COUNT(*) FROM @TABLE_NAME WHERE 1=1 @CONDITIONS
-->
<!-- 处理条件的模板sql语句 -->
<sql id="condition_sql">
<!-- 条件集合不为null时说明有附加条件 -->
<isNotNull property="conditions">
<!-- 迭代条件集合,还有其他条件的解析，自己补充吧 ,这种条件可以写成模板sql，让统计语句重复使用-->
<iterate property="conditions" prepend=" AND " conjunction=" AND ">
<!-- 等于条件解析 -->
<isEqual property="${conditions[].operation}" compareValue="EQ">
($conditions[].propertyName$ = #conditions[].propertyValue#)
</isEqual>
<!-- 模糊条件解析 -->
<isEqual property="${conditions[].operation}" compareValue="LIKE">
($conditions[].propertyName$ LIKE
'%'||#conditions[].propertyValue#||'%')
</isEqual>
<!-- 范围条件解析 -->
<isEqual property="${conditions[].operation}" compareValue="BETWEEN">
($conditions[].propertyName$ BETWEEN
#conditions[].propertyValue[0]# AND
#conditions[].propertyValue[1]#)
</isEqual>
<!-- in条件解析 -->
<isEqual property="${conditions[].operation}" compareValue="IN">
($conditions[].propertyName$ IN
<iterate open="(" close="))" conjunction=","
property="${conditions[].propertyValue}">
#conditions[].propertyValue[]#
</iterate>
</isEqual>
</iterate>
</isNotNull>
</sql>
<!-- 分页查询单个对象的信息2(推荐) -->
<select id="queryByStudent" parameterClass="Student" resultMap="StudentResult">
<![CDATA[
SELECT * FROM
(
SELECT ROWNUM NUM,STUDENT_.* FROM STUDENT_
WHERE 1=1 AND (ROWNUM<=#currentPage#*#pageSize#)
]]>
<include refid="condition_sql"/>
<!-- 排序条件处理 -->
$orderSql$
<![CDATA[
)
WHERE NUM >(#currentPage#-1)*#pageSize#
]]>
</select>
<!-- 分页统计查询2(推荐) -->
<select id="queryPageCount" parameterClass="Student"
resultClass="int">
SELECT COUNT(*) FROM STUDENT_ WHERE 1=1
<include refid="condition_sql"/>
</select>
<!-- 分页统计查询1(不推荐) -->
<select id="findPageCount" parameterClass="Student" resultClass="int">
SELECT COUNT(*) FROM STUDENT_ WHERE 1=1 $conditionSql$
</select>
<!-- 分页结果集查询1(不推荐) -->
<select id="findByStudent" parameterClass="Student" resultMap="StudentResult">
<![CDATA[
SELECT * FROM
(
SELECT ROWNUM NUM,STUDENT_.* FROM STUDENT_
WHERE 1=1 AND (ROWNUM<=#currentPage#*#pageSize#)
$conditionSql$ $orderSql$
)
WHERE NUM >(#currentPage#-1)*#pageSize#
]]>
</select>
<!-- 单个参数配置 -->
<select id="findByNameStudent" parameterClass="string"
resultMap="StudentResult">
SELECT * FROM STUDENT_ WHERE STUDENT_.NAME_=#name#
</select>
<!-- 根据学生id查询 -->
<select id="findByIdStudent" parameterClass="int" resultMap="StudentResult">
SELECT * FROM STUDENT_ WHERE STUDENT_.ID_=#id#
</select>
<!-- 更新一条记录 -->
<update id="updateStudent" parameterClass="Student">
UPDATE STUDENT_ SET
STUDENT_.AGE_=#age#,STUDENT_.NAME_=#name#,STUDENT_.CLASS_=#clazz#,STUDENT_.GRADE_=#grade#,STUDENT_.SEX_=#sex#
WHERE STUDENT_.ID_ = #id#
</update>
<!-- 删除一条记录 -->
<delete id="deleteStudent" parameterClass="int">
DELETE STUDENT_ WHERE
STUDENT_.ID_ = #id#
</delete>
<!-- 批量删除 -->
<delete id="batchDelete" parameterClass="java.util.List">
DELETE STUDENT_ WHERE STUDENT_.ID_ IN
<iterate conjunction="," open="(" close=")">
#value[]#
</iterate>
</delete>
<!-- 添加一条记录,参数类型为Student -->
<insert id="saveStudent" parameterClass="Student">
<!-- 获取序列的下一个值 keyProperty为实体的属性-->
<selectKey keyProperty="id" resultClass="int">
SELECT
SEQ_STUDENT_ID.NEXTVAL AS SID FROM DUAL
</selectKey>
<!-- #属性#字段 -->
<![CDATA[
INSERT INTO STUDENT_(
ID_,
NAME_,
SEX_,
AGE_,
GRADE_,
CLASS_
)
VALUES(
#id#,
#name#,
#sex#,
#age#,
#grade#,
#clazz#
)
]]>
</insert>
<!-- 查询所有信息 -->
<select id="findAllStudent" resultMap="StudentResult">
SELECT * FROM STUDENT_
</select>
</sqlMap>
实体的接口：
package org.forever.xxxx.dao;
import java.util.List;
import java.util.Map;
import org.forever.xxxx.domain.Student;
public interface StudentDao {
public List<?> find(Map<?,?> map);
/**
* 将查询参数封装成map进行查询
* @param map
* @return
*/
public Student findByMap(Map<?,?> map);
/**
* 根据名字进行查询
* @param name
* @return
*/
public Student findByNameStudent(String name);
/**
* 根据id查询
* @return
*/
public Student findByIdStudent(int id);
/**
* 更新一条数据库信息
* @param student
*/
public void updateStudent(Student student);
/**
* 批量删除
*/
public void batchDelete(List<Integer> ids);
/**
* 删除单条数据
* @param id
*/
public void deleteStudent(int id);
/**
* 查找所有的学生信息
* @return
*/
public List<?> findAllStudent();
/**
* 保存或者修改学生信息
* @param student
*/
public void saveStudent(Student student);
/**
* 分页组合查询
* @param student
*/
public List<?> findByStudent(Student student);
/**
* 升级版的分页组合查询，解析sql将在配置文件完成
* @param student
* @return
*/
public List<?> queryByStudent(Student student);
}
实体dao接口的实现：
package org.forever.xxxx.dao;
import java.io.IOException;
import java.io.Reader;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import org.forever.xxxx.domain.Student;
import org.forever.xxxx.pagination.Condition;
import org.forever.xxxx.pagination.Operation;
import org.forever.xxxx.pagination.Order;
import org.forever.xxxx.pagination.OrderType;
import org.forever.xxxx.pagination.PageInfo;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
public class StudentDaoImpl implements StudentDao {
private static SqlMapClient sqlMapper;
static {
try {
// 加载配置信息
Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
reader.close();
} catch (IOException e) {
throw new RuntimeException(
"Something bad happened while building the SqlMapClient instance."
+ e, e);
}
}
public void batchDelete(List<Integer> ids) {
try {
sqlMapper.delete("batchDelete", ids);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public void deleteStudent(int id) {
try {
sqlMapper.delete("deleteStudent", id);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public Student findByIdStudent(int id) {
try {
return (Student) sqlMapper.queryForObject("findByIdStudent", id);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public void updateStudent(Student student) {
try {
sqlMapper.update("updateStudent", student);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public List<?> find(Map<?, ?> map) {
try {
return sqlMapper.queryForList("find", map);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public Student findByNameStudent(String name) {
try {
return (Student) sqlMapper
.queryForObject("findByNameStudent", name);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public Student findByMap(Map<?, ?> map) {
try {
return (Student) sqlMapper.queryForObject("findByMap", map);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public List<?> findAllStudent() {
try {
return sqlMapper.queryForList("findAllStudent");
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public void saveStudent(Student student) {
try {
sqlMapper.insert("saveStudent", student);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
/**
* 不推荐(使用)
*/
public List<?> findByStudent(Student student) {
try {
processCondition(student);
processOrder(student);
int totalItems = Integer.parseInt(sqlMapper.queryForObject(
"findPageCount", student).toString());
// 设置总条数
student.setTotalItems(totalItems);
// 设置总页数
student
.setTotalPage(totalItems % student.getPageSize() == 0 ? totalItems
/ student.getPageSize()
: totalItems / student.getPageSize() + 1);
return sqlMapper.queryForList("findByStudent", student);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
/**
* 处理排序条件sql
*
* @param pageInfo
*/
public void processOrder(PageInfo pageInfo) {
StringBuffer order = new StringBuffer();
List<Order> orders = pageInfo.getOrders();
if (orders != null && orders.size() > 0) {
order.append(" ORDER BY ");
for (Order item : orders) {
String propertyName = item.getPropertyName();
switch (item.getOrderType()) {
case ASC:
order.append(propertyName + " ASC,");
break;
case DESC:
order.append(propertyName + " DESC,");
break;
default:
break;
}
}
order.replace(order.length() - 1, order.length(), "");
}
pageInfo.setOrderSql(order.toString());
}
/**
* 处理条件(拼接语句真烦，不安全，不推荐)
*/
public void processCondition(PageInfo pageInfo) {
StringBuffer condition = new StringBuffer();
List<Condition> conditions = pageInfo.getConditions();
if (conditions != null && conditions.size() > 0) {
for (Condition item : conditions) {
Object value = item.getPropertyValue();
String propertyName = item.getPropertyName();
switch (item.getOperation()) {
case EQ:
if (value instanceof String) {
condition.append(" AND (" + propertyName + " ='"
+ value + "') ");
} else {
condition.append(" AND (" + propertyName + " =" + value
+ ") ");
}
break;
case LIKE:
condition.append(" AND (" + propertyName + " LIKE '%"
+ value + "%') ");
break;
case IN:
Object[] obj = (Object[]) value;
if (obj[0] instanceof String) {
condition.append(" AND (" + propertyName + " IN (");
for (Object object : obj) {
condition.append("'" + object + "',");
}
condition.replace(condition.length() - 1, condition
.length(), "");
condition.append("))");
} else {
for (Object object : obj) {
condition.append(object + ",");
}
condition.replace(condition.length() - 1, condition
.length(), "");
condition.append("))");
}
break;
case BETWEEN:
condition.append(" AND ( " + propertyName + " BETWEEN "
+ ((Object[]) value)[0] + " AND "
+ ((Object[]) value)[1] + " )");
break;
default:
break;
}
}
}
pageInfo.setConditionSql(condition.toString());
}
/**
* 强烈推荐这种方式的写法
*/
public List<?> queryByStudent(Student student) {
try {
// //////////////////注意当使用ibatis的dao接口包时，这些dao接口的实现类就不会让我们自己手写
// /////////////////可以将以下代码提取出来就可以了
int totalItems = Integer.parseInt(sqlMapper.queryForObject(
"queryPageCount", student).toString());
// 设置总条数
student.setTotalItems(totalItems);
// 设置总页数
student
.setTotalPage(totalItems % student.getPageSize() == 0 ? totalItems
/ student.getPageSize()
: totalItems / student.getPageSize() + 1);
// //////////////////////
return sqlMapper.queryForList("queryByStudent", student);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
StudentDao studentDao = new StudentDaoImpl();
Student student = new Student();
student.setPageSize(4);
student.setCurrentPage(1);
/*
* 例子：
* 查询一年级二班，
* 名字中包含stor的，
* 年龄在14到18的，
* 性别是男和女的学生
* 并且按照姓名升序排序，
* 名字相同的按照年龄的降序排序。
*/
student.setConditions(Arrays.asList(new Condition("GRADE_", "一年级",
Operation.EQ), new Condition("CLASS_", "二班", Operation.EQ),
new Condition("NAME_", "stor", Operation.LIKE), new Condition(
"AGE_", new Object[] { 14, 18 }, Operation.BETWEEN),
new Condition("SEX_", new Object[] { "男", "女", "保密" },
Operation.IN)));
student.setOrders(
Arrays.asList(
new Order("NAME_", OrderType.ASC),
new Order("AGE_", OrderType.DESC)
)
);
List<?> list = studentDao.queryByStudent(student);
System.out.println("共有条数：" + student.getTotalItems());
System.out.println("共有页数：" + student.getTotalPage());
for (Object object : list) {
System.out.println(object);
}
}
}
分页实体：
package org.forever.xxxx.pagination;
import java.io.Serializable;
import java.util.List;
//分页信息
public class PageInfo implements Serializable {
private static final long serialVersionUID = -2013522911148457717L;
private int currentPage = 1;// 当前页
private int totalPage;// 总页数
private int totalItems;// 总条数
private int pageSize = 10;// 每页显示多少条
private List<Condition> conditions;// 条件集合
private List<Order> orders;// 排序集合
private String conditionSql="";// 条件的sql拼接语句(不推荐)
private String orderSql="";// 排序拼接语句
public PageInfo() {
}
public int getCurrentPage() {
return currentPage;
}
public void setCurrentPage(int currentPage) {
this.currentPage = currentPage;
}
public int getTotalPage() {
return totalPage;
}
public void setTotalPage(int totalPage) {
this.totalPage = totalPage;
}
public int getTotalItems() {
return totalItems;
}
public void setTotalItems(int totalItems) {
this.totalItems = totalItems;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public List<Condition> getConditions() {
return conditions;
}
public void setConditions(List<Condition> conditions) {
this.conditions = conditions;
}
public List<Order> getOrders() {
return orders;
}
public void setOrders(List<Order> orders) {
this.orders = orders;
//排序的处理放在任何一个地方处理都可以，暂时放在这里
//这里处理的话就必须这样赋予所有的排序条件,如下：
/* student.setOrders(
Arrays.asList(
new Order("NAME_", OrderType.ASC),
new Order("AGE_", OrderType.DESC)
)
);*/
StringBuffer order = new StringBuffer();
if (orders != null && orders.size() > 0) {
order.append(" ORDER BY ");
for (Order item : orders) {
String propertyName = item.getPropertyName();
switch (item.getOrderType()) {
case ASC:
order.append(propertyName + " ASC,");
break;
case DESC:
order.append(propertyName + " DESC,");
break;
default:
break;
}
}
//去掉多余的逗号
order.replace(order.length() - 1, order.length(), "");
}
setOrderSql(order.toString());
}
public String getConditionSql() {
return conditionSql;
}
public void setConditionSql(String conditionSql) {
this.conditionSql = conditionSql;
}
public String getOrderSql() {
return orderSql;
}
public void setOrderSql(String orderSql) {
this.orderSql = orderSql;
}
}
sqlmapconfig配置：
<?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>
<!-- 导入数据库链接配置 -->
<properties resource="database.properties"/>
<!-- 简单配置数据库链接信息 ,不提交事务-->
<transactionManager type="JDBC">
<dataSource type="SIMPLE">
<property name="JDBC.Driver" value="${driver}"/>
<property name="JDBC.ConnectionURL" value="${url}"/>
<property name="JDBC.Username" value="${username}"/>
<property name="JDBC.Password" value="${password}"/>
</dataSource>
</transactionManager>
<!-- 导入实体映射文件 -->
<!-- 学生配置文件 -->
<sqlMap resource="org/forever/xxxx/domain/Student.xml"/>
</sqlMapConfig>
省略了pageInfo的其他实体信息，完整代码提供下载。学习参考使用。
- ibatis02.rar (2.1 MB)
- 下载次数: 41
0
顶
顶
0
踩
踩
分享到：
发表评论
相关推荐
总之，Ibatis提供的SQL映射功能使得开发者可以灵活地处理各种数据库操作，包括删除指定ID的单个对象。在实际开发中，结合Spring等框架，我们可以构建出高效、稳定的业务系统。理解并熟练掌握Ibatis的这些基本操作，...
本教程聚焦于如何使用Ibatis查询指定ID的单个对象，这对于日常的数据检索工作尤为重要。 首先，理解Ibatis的基本架构。Ibatis不是一个完整的ORM（对象关系映射）框架，而是介于SQL和Java之间的桥梁，允许开发者编写...
- **查询操作**：`selectOne()`用于根据主键获取单个对象，`selectAll()`则返回所有记录。这些方法通常需要传入SQL映射文件中的ID和可能的参数对象。 - **插入操作**：`insert()`方法用于将一个对象插入到数据库中...
本教程主要聚焦于如何利用Ibatis查询指定ID的单个对象，这对于数据库操作来说是常见的需求，特别是在CRUD（创建、读取、更新、删除）操作中。下面我们将深入探讨Ibatis查询机制以及实现这一功能的步骤。 Ibatis的...
本教程主要聚焦于使用Ibatis删除指定ID的单个对象，这是一个常见的数据库操作任务，对于理解Ibatis的工作原理和实际应用具有重要意义。 Ibatis是一个基于Java的持久层框架，它简化了Java应用程序与数据库之间的交互...
本教程主要聚焦于如何利用Ibatis删除指定ID的单个对象，这是一个常见的数据库操作，对于理解Ibatis的工作原理和实际应用具有重要意义。 Ibatis，全称MyBatis，最初由Clinton Begin开发，它是一个基于Java的持久层...
本教程将围绕“03_ibatis教程_查询指定id的单个对象”这一主题展开，讲解如何利用Ibatis查询数据库中特定ID的对象。 首先，我们需要理解Ibatis的基本架构。Ibatis的核心组件包括SqlMapConfig.xml配置文件、SQL映射...
如果是查询，返回单个对象或对象集合。 五、基础知识点 1. SqlMapClient：它是iBATIS的主要接口，负责执行SQL映射和批处理操作。提供多种方法如queryForObject、queryForMap等，用于执行不同的查询或更新操作。 2. ...
Ibatis，全称为MyBatis，是一个优秀的Java持久层框架，它主要负责SQL映射，使得开发者能够将SQL语句与Java代码分离，从而更好地管理数据库操作。Ibatis的出现，解决了传统JDBC中手动编写SQL和结果集映射的繁琐工作，...
在 Java 代码中，调用 `selectOne` 或 `selectList` 方法获取单个对象或结果集。 - **更新（Update）**: 使用 `update` 标签定义更新语句，通过参数匹配要更新的记录。在 Java 代码中调用 `update` 方法执行更新...
在Java代码中，调用Mapper接口的查询方法，返回结果通常是一个List集合或单个对象。 4. **更新记录**：更新数据使用`<update>`标签，编写SQL更新语句，并在Java代码中调用Mapper接口的`update()`方法，传入需要更新...
5. **结果集映射**: 映射查询结果到对象，可以是单个对象或集合。 **四、Person实体类与映射文件** 在示例中，我们看到一个名为`Person`的文件，这可能是一个表示人员信息的类。通常，这个类会包含属性，如`Id`、`...
2. 细粒度优化：iBATIS允许对SQL进行更细致的优化，如直接指定更新单个字段的语句，或选择性地获取表的部分内容。 3. 可维护性：由于SQL保存在单独的文件中，iBATIS的可维护性优于Hibernate，后者有时会在Java代码中...
Ibatis提供了多种查询方式，如单个查询、多个查询、根据条件查询等。例如，查询用户： ```xml <!-- mapper.xml配置 --> SELECT * FROM users WHERE id = #{id} ``` ```java // Mapper接口 public ...
《深入剖析iBatis框架：一个CRUD操作的项目实例》 iBatis，一个轻量级的Java持久层框架，以其简洁、灵活的特点，在Java开发领域占据了一席之地。本篇文章将通过一个具体的CRUD操作项目实例，帮助读者深入理解iBatis...
CLOB是一种用于存储大量字符数据的数据类型，它可以容纳最大4GB的单个文本对象。在Oracle中，CLOB通常用于存储大段的文本，如文章、报告或者XML文档。 iBATIS是一个Java库，它允许开发者将SQL语句与Java代码分离，...
ParameterMap定义了参数和它们的映射关系，ParameterValuePair则是单个参数值对。 4. **ResultMap**：定义了结果集如何映射到Java对象，支持复杂的列名到Java属性的映射，如一对一、一对多、多对多的关系映射。 5....
iBatis提供了方便的方法，通过Mapper接口和@Select注解，可以直接调用SQL获取单个对象。同时，讲解了如何处理查询结果为null的情况，避免空指针异常。 4. **iBatis的优点**： - **简洁高效**：相比传统的JDBC，...
在“05_ibatis教程_删除指定id的单个对象.rar”中，我们学习了如何通过Ibatis删除数据库中的特定记录。删除操作通常涉及查询目标对象并执行DELETE语句。在Ibatis中，这可以通过配置XML映射文件或使用注解来实现，...