ibatis使用2

1、配置SqlMapConfig.xml文件

<?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>
  
  <!-- IBatis设置信息
  useStatementNamespaces="true" 启用命名空间，访问SQL语句必须增加命名空间
  cacheModelsEnabled="true" 启用查询缓存，提高效率
   -->
  <settings useStatementNamespaces="true"
            cacheModelsEnabled="true" 
  />
  
  <!-- 
  transactionManager表示数据库操作时，事务采用什么方式处理.
  
   type属性表示事务的方式 
   
   		取值为jdbc , 使用JDBC的事务处理机制完成事务。
   		取值为JTA, 表示使用全局事务。
   -->
  <transactionManager type="JDBC">
    <!-- 
    Ibatis技术框架封装了大部分的数据库操作，包括数据库的连接，所以下面的配置信息为IBatis获取数据库连接的配置信息
    
    dataSource标签标示数据库连接池的配置操作
       
       type属性表示连接池的类型
       
       		取值为simple，表示IBatis内部实现了一个简易的连接池对象。
       		取值为dbcp，表示使用apache组织提供的专业的DBCP连接池组件。
       		取值为jndi, 可以通过JNDI服务访问连接池资源。
    
     -->
    <dataSource type="SIMPLE">
      <property name="JDBC.Driver" value="oracle.jdbc.driver.OracleDriver"/>
      <property name="JDBC.ConnectionURL" value="jdbc:oracle:thin:@127.0.0.1:1521:scott"/>
      <property name="JDBC.Username" value="cjf"/>
      <property name="JDBC.Password" value="cjf"/>
    </dataSource>
  </transactionManager>

  <!-- 
  SQL文的映射标签。可以关联SQL文映射文件。
  
     resource属性表示映射文件的路径，如果在包中，需要指定包名，并且使用斜杠代替点。
   -->
  <sqlMap resource="user.xml"/>
  <sqlMap resource="user-input.xml"/>
  <sqlMap resource="user-output.xml"/>
  <sqlMap resource="user-dynquery.xml"/>
  <sqlMap resource="user-pagequery.xml"/>
  <sqlMap resource="user-cud.xml"/>
  <sqlMap resource="emp.xml"/>
  <sqlMap resource="user-cache.xml"/>
</sqlMapConfig>

2、User.java

public class User {

	private Integer seqid;
	private String usercode;
	private String username;
	private String userpswd;
	private String orgtype;
	private String regdate;
...
}

3.1 、

public class IBatisFirst {

	// Ibatis核心对象，可以进行数据库操作
	private static SqlMapClient sqlMapper;
	
    static {
	    try {
	      // 读取IBatis的数据库连接配置文件
	      Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
	      // 创建Ibatis核心对象
	      sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
	      // 关闭文件输入流
	      reader.close(); 
	    } catch (IOException e) {
	      // Fail fast.
	      throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
	    }
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		// queryForObject();
		
		queryForList();

	}
	public static void queryForList() throws Exception {

		String sqlMapId = "selectUsers";

		// ibatis操作中，方法的调用应该和SQL语句对应
		//Object obj = sqlMapper.queryForObject(sqlMapId);
		
		List<User> userList = sqlMapper.queryForList(sqlMapId);
		
		for ( User u : userList ) {
			System.out.println( u.getUsercode() );
		}
		
		//User user = (User)obj;
		
		//System.out.println( user.getRegdate() );
	}
	public static void queryForObject() throws Exception {
		// 查询一条用户信息
		String sqlMapId = "selectUserByCode";
		// queryForObject可以查询数据库，第一个参数表示SQL文映射ID，和SQL配置文件中的ID必须保持一致，否则会出现错误。
		// 第二个参数表示SQL语句可能需要参数，所以参数表示向SQL语句中传递的参数值。
		Object obj = sqlMapper.queryForObject(sqlMapId, "zhangsan");
		
		User user = (User)obj;
		
		System.out.println( user.getRegdate() );
	}

}

3.1sql文件

<?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="user">

  <!-- 
  select标签表示声明查询SQL语句
  
  id属性表示sql语句关联ID，当程序访问这个ID时，等同于访问这个SQL语句。
  resultClass属性表示当查询结果有了之后，将结果直接转换为指定类型的对象
   -->
  <!-- 
  SQL中的##表示SQL语句需要参数，可以代替？号
   -->
  <!-- 
  查询结果使用反射的方式将所有查询字段的值放置在对象的属性当中，如果查询字段不存在，那么属性值为null
  
  usercode -> setUsercode
  usercode  setUser_code
  
  user_code -> setUser_code
  
  如果表字段名称和对象属性名称不一致的场合，可以通过别名的方式保持一致，进行数据的封装。
   -->
  <select id="selectUserByCode" resultClass="com.cjf.ibatis.bean.User">
    select
      usercode as user_code,
      username,
      userpswd,
      orgtype
    from t_user
    where usercode = #usercode#
  </select>
  
  <!-- 
  resultClass属性表示查询的每一条数据转换成指定类型的对象
  如果结果为多条数据，转换后会自动封装为集合对象
   -->
   
  <select id="selectUsers" resultClass="com.cjf.ibatis.bean.User">
     select * from t_user
  </select>
  
  <select id="selectList" resultClass="com.cjf.ibatis.bean.User">
     select * from t_user
  </select>

</sqlMap>

----------------------------------
3.2 、

public class IBatisInput {

	// Ibatis核心对象，可以进行数据库操作
	private static SqlMapClient sqlMapper;
	
    static {
	    try {
	      // 读取IBatis的数据库连接配置文件
	      Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
	      // 创建Ibatis核心对象
	      sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
	      // 关闭文件输入流
	      reader.close(); 
	    } catch (IOException e) {
	      // Fail fast.
	      throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
	    }
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		// queryForObject();
		//queryForList();
		//queryForList1();
		//queryForList2();
		//queryForList3();
		//queryForList4();
		queryForList5();

	}
	public static void queryForList() throws Exception {

		String sqlMapId = "selectUserByCond";
		
		// SQL文可以使用#代替问号，然后传递数据时可以传递简单类型的数据(Integer, String)
		// 如果参数为简单类型，那么传递的参数就是设置的SQL参数值
		// 如果参数为简单类型，那么无论SQL文有多少个参数，取值相同。参数名称可以随便起，尽量符合JAVA语法
		List<User> userList = sqlMapper.queryForList(sqlMapId, "zhangsan");
		
		for ( User u : userList ) {
			System.out.println( u.getUsername() );
		}

	}
	public static void queryForList1() throws Exception {

		String sqlMapId = "selectUserByCond";
		
		// SQL文可以使用#代替问号，然后传递数据时可以传递对象
		// 如果参数为对象，那么SQL中的参数就是对象中的属性，##中的内容就是对象的属性名称。
		// 如果参数为对象类型，那么参数名称不能随便起名，名称必须和对象的属性名称保持一致
		//User user = new User();
		
		Emp emp = new Emp();
		
		emp.setUsercode("zhangsan");
		
		List<User> userList = sqlMapper.queryForList(sqlMapId, emp);
		
		for ( User u : userList ) {
			System.out.println( u.getUsername() );
		}

	}

	public static void queryForList2() throws Exception {

		String sqlMapId = "selectUserByCond";
		
		Map map = new HashMap();
		
		map.put("usercode", "zhangsan");
		map.put("userpswd", "123");
		
		// SQL参数可以传递集合对象
		// 参数名称可以和Map中的key相同。
		// 参数名称可以任意使用，但是数据可能取不到。
		List<User> userList = sqlMapper.queryForList(sqlMapId, map);
		
		for ( User u : userList ) {
			System.out.println( u.getUsername() );
		}

	}
	public static void queryForList3() throws Exception {

		String sqlMapId = "selectUserByCond1";
		
		User user = new User();
		
		user.setUsercode("zhangsan");
		user.setUserpswd("123123");
		
		// 如果sql语句参数使用$符号，表示使用拼串的方式进行查询， 参数一定要考虑数据类型，如果是字符串，外部必须包含单引号。
		List<User> userList = sqlMapper.queryForList(sqlMapId, user);
		
		for ( User u : userList ) {
			System.out.println( u.getUsername() );
		}

	}
	public static void queryForList4() throws Exception {

		String sqlMapId = "selectUserByLike";
		
		User user = new User();
		
		// 模糊查询
		user.setUsername("z");
		
		// 如果sql语句参数使用$符号，表示使用拼串的方式进行查询， 参数一定要考虑数据类型，如果是字符串，外部必须包含单引号。
		List<User> userList = sqlMapper.queryForList(sqlMapId, user);
		
		for ( User u : userList ) {
			System.out.println( u.getUsername() );
		}

	}
	public static void queryForList5() throws Exception {

		String sqlMapId = "selectUserByLike1";
		
		User user = new User();
		
		// 模糊查询
		user.setUsername("z");
		
		// 如果sql语句参数使用$符号，表示使用拼串的方式进行查询， 参数一定要考虑数据类型，如果是字符串，外部必须包含单引号。
		List<User> userList = sqlMapper.queryForList(sqlMapId, user);
		
		for ( User u : userList ) {
			System.out.println( u.getUsername() );
		}

	}
}

3.2 sql文件

<?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 >

  <!-- 
  如果sql文有参数，那么ibatis在底层处理时，会对传递的参数对象进行类型判断，比较麻烦，可以通过类型限定，提高效率。
  
  parameterClass属性用于限定参数的类型。如果限定的类型和传递的参数类型不一致，会出现错误。
  
  如果限定的类型和传递的参数存在父子关系，不会出现错误。
   -->
  <select id="selectUserByCond" parameterClass="com.cjf.ibatis.bean.User"  resultClass="com.cjf.ibatis.bean.User" >
     select * from t_user where usercode = #usercode# and userpswd = #userpswd#
  </select>
  <select id="selectUserByCond1" parameterClass="com.cjf.ibatis.bean.User"  resultClass="com.cjf.ibatis.bean.User">
     select * from t_user where usercode = '$usercode$' and userpswd = '$userpswd$'
  </select>
  <select id="selectUserByLike" parameterClass="com.cjf.ibatis.bean.User"  resultClass="com.cjf.ibatis.bean.User">
     select * from t_user where username like '%$username$%'
  </select>
  <!-- Oracle数据库的模糊查询操作 -->
  <select id="selectUserByLike1" parameterClass="com.cjf.ibatis.bean.User"  resultClass="com.cjf.ibatis.bean.User">
     select * from t_user where username like '%'||#username#||'%'
  </select>
</sqlMap>

--------------------

3.3

public class IBatisOutput {

	// Ibatis核心对象，可以进行数据库操作
	private static SqlMapClient sqlMapper;
	
    static {
	    try {
	      // 读取IBatis的数据库连接配置文件
	      Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
	      // 创建Ibatis核心对象
	      sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
	      // 关闭文件输入流
	      reader.close(); 
	    } catch (IOException e) {
	      // Fail fast.
	      throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
	    }
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		//queryForList();
		//queryForList1();
		//queryForList2();
		//queryForList3();
		queryForList4();
	}
	public static void queryForList() throws Exception {

		String sqlMapId = "selectUserToUser";

		// 将查询结果转换指定类型的对象集合
		List<User> userList = sqlMapper.queryForList(sqlMapId);
		
		for ( User u : userList ) {
			System.out.println( u.getUsername() );
		}

	}
	public static void queryForList1() throws Exception {

		String sqlMapId = "selectUserToMap";

		// 将查询结果转换Map集合
		// 将每一个查询的数据封装为Map集合, 查询字段名称为key，数据库的数值为value
		List userList = sqlMapper.queryForList(sqlMapId);
		
		for ( Object obj : userList ) {
			System.out.println( obj );
		}

	}
	public static void queryForList2() throws Exception {

		//String sqlMapId = "selectUserToString";
		String sqlMapId = "selectUserToInteger";

		// 将查询结果转换String类型
		// 转换时，会将查询结果只保留第一个字段，将结果转换为字符串类型。
		List userList = sqlMapper.queryForList(sqlMapId);
		
		for ( Object obj : userList ) {
			System.out.println( obj );
		}

	}
	public static void queryForList3() throws Exception {

		String sqlMapId = "selectUserToXML";

		// 将查询结果转换String类型
		// 转换时，会将查询结果只保留第一个字段，将结果转换为字符串类型。
		List userList = sqlMapper.queryForList(sqlMapId);
		
		for ( Object obj : userList ) {
			System.out.println( obj );
		}

	}
	public static void queryForList4() throws Exception {

		String sqlMapId = "selectUserToNull";

		List userList = sqlMapper.queryForList(sqlMapId);
		
		for ( Object obj : userList ) {
			System.out.println( obj );
		}

	}
}

3.3 sql文件

<?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 >
  <!-- 将指定的类型使用别名代替，在其他的地方可以使用别名，比较方便。 -->
  <typeAlias alias="user" type="com.cjf.ibatis.bean.User"/>

  <!-- 将查询结果直接转换为指定类型的对象 -->
  <select id="selectUserToUser" resultClass="user" >
     select * from t_user
  </select>
  <!-- 将查询结果转换为Map集合 -->
  <select id="selectUserToMap" resultClass="java.util.HashMap" >
     select * from t_user
  </select>
  <!-- 将查询结果转换为字符串类型 -->
  <select id="selectUserToString" resultClass="java.lang.String" >
     select * from t_user
  </select>
  <!-- 将查询结果转换为整数类型 -->
  <select id="selectUserToInteger" resultClass="java.lang.Integer" >
     select count(*) from t_user
  </select>
  <!-- 将查询结果转换为XML格式的字符串
  如果转换的类型名称太长，不方便使用，可以采用别名的方式解决。
   -->
  <select id="selectUserToXML" resultClass="xml" xmlResultName="user" >
     select * from t_user
  </select>
  <!-- 
   查询结果转换时没有指定  resultClass转换的类型。
   获取的结果就为空，即使sql语句执行有结果，但是程序获取不到。
   -->
  <select id="selectUserToNull">
     select * from t_user
  </select>
</sqlMap>

---------------------

3.4

public class IBatisCUD {

	// Ibatis核心对象，可以进行数据库操作
	private static SqlMapClient sqlMapper;
	
    static {
	    try {
	      // 读取IBatis的数据库连接配置文件
	      Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
	      // 创建Ibatis核心对象
	      sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
	      // 关闭文件输入流
	      reader.close(); 
	    } catch (IOException e) {
	      // Fail fast.
	      throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
	    }
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		//insertUser();
		//insertUser1();
		//updateUser();
		//deleteUser();
		//deleteUser1();
		doBatch();
	}
	public static void deleteUser1() throws Exception {
		String sqlMapId = "deleteUser";
		
		User user = new User();
		
//		user.setUsercode("cccc");
//		user.setRegdate("2012-01-01");
//		user.setUsername("ibm123");
//		user.setOrgtype("0");
//		user.setUserpswd("123123");

		// 删除数据
		sqlMapper.delete(sqlMapId, user);
	}
	public static void doBatch() throws Exception {

		String sqlMapId = "insertUser";
		
		User user = new User();
		
		user.setUsercode("ibm");
		user.setRegdate("2012-01-01");
		user.setUsername("ibm");
		user.setOrgtype("0");
		user.setUserpswd("123123");

		// 执行批处理，将多条数据库操作当成一个整体同时发送到数据库，提高效率
		sqlMapper.startBatch();
		
		sqlMapper.insert(sqlMapId, user);
		
		sqlMapId = "deleteUser";
		sqlMapper.delete(sqlMapId, user);
		
		sqlMapper.executeBatch();
	}
	public static void deleteUser() throws Exception {
		String sqlMapId = "deleteUser";
		
		User user = new User();
		
		user.setUsercode("ibm");
		user.setRegdate("2012-01-01");
		user.setUsername("ibm123");
		user.setOrgtype("0");
		user.setUserpswd("123123");

		// 删除数据
		// 方法的返回值和JDBC操作是一致的。
		sqlMapper.delete(sqlMapId, user);
	}
	
	public static void updateUser() throws Exception {
		String sqlMapId = "updateUser";
		
		User user = new User();
		
		user.setUsercode("ibm");
		user.setRegdate("2012-01-01");
		user.setUsername("ibm123");
		user.setOrgtype("0");
		user.setUserpswd("123123");

		// 修改数据
		// 方法的返回值和JDBC操作是一致的。
		sqlMapper.update(sqlMapId, user);
	}
	
	public static void insertUser1() throws Exception {

		String sqlMapId = "insertUserBySeq";
		
		User user = new User();
		
		user.setUsercode("ibm");
		user.setRegdate("2012-01-01");
		user.setUsername("ibm");
		user.setOrgtype("0");
		user.setUserpswd("123123");
		
		// 保存数据
		// insert方法和JDBC操作的结果不太一致，表示自动生成的主键或序列生成的序号。
	    // 如果主键不是自动生成或seq序号，那么获取的结果为null
		Object obj = sqlMapper.insert(sqlMapId, user);
		
		System.out.println( "pk = " + obj );
		
		sqlMapId = "deleteUser";
		sqlMapper.delete(sqlMapId, user);
	}
	public static void insertUser() throws Exception {

		String sqlMapId = "insertUser";
		
		User user = new User();
		
		user.setUsercode("ibm");
		user.setRegdate("2012-01-01");
		user.setUsername("ibm");
		user.setOrgtype("0");
		user.setUserpswd("123123");
		
		// 保存数据
		Object obj = sqlMapper.insert(sqlMapId, user);
		
		System.out.println( "pk = " + obj );

	}


}

3.4 sql文件

<?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="userCUD" >

  <typeAlias alias="user" type="com.cjf.ibatis.bean.User"/>

  <!-- 增加数据 -->
  <insert id="insertUser" parameterClass="user">
      insert into t_user values ( #usercode#, #username#, #orgtype#, #userpswd#, #regdate# )
  </insert>
  
  <insert id="insertUserBySeq" parameterClass="user">
      insert into t_user values ( seqinv.nextval, #username#, #orgtype#, #userpswd#, #regdate# )
      <selectKey keyProperty="seqid" resultClass="java.lang.Integer">
      select seqinv.currval from dual
      </selectKey>
  </insert>
  
  <!-- 修改数据 -->
  <update id="updateUser" parameterClass="user">
      update t_user set username = #username# where usercode = #usercode#
  </update>
  
  <!-- 删除数据 -->
  <delete id="deleteUser" parameterClass="user">
      delete from t_user
      <dynamic prepend="where">
          <isEmpty property="seqid">
	          <isNotEmpty property="usercode" prepend="and">
	          usercode = #usercode#
	          </isNotEmpty>
          </isEmpty>
          <isNotEmpty prepend="and" property="seqid">
          usercode = #seqid#
          </isNotEmpty>
      </dynamic>
  </delete>
  
</sqlMap>

------------------------

3.5

public class IBatisDynamicQuery {

	// Ibatis核心对象，可以进行数据库操作
	private static SqlMapClient sqlMapper;
	
    static {
	    try {
	      // 读取IBatis的数据库连接配置文件
	      Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
	      // 创建Ibatis核心对象
	      sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
	      // 关闭文件输入流
	      reader.close(); 
	    } catch (IOException e) {
	      // Fail fast.
	      throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
	    }
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		queryForList();
	}
	public static void queryForList() throws Exception {

		String sqlMapId = "selectUserByParam";

		User user = new User();
		
		user.setUsercode("zhangsan");
		user.setUserpswd("123123");
		user.setRegdate("2012-01-01");
		
		List<User> userList = sqlMapper.queryForList(sqlMapId, user);
		
		for ( User u : userList ) {
			System.out.println( u.getUsername() );
		}

	}

}

3.5 sql文件

<?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 >
  <!-- 将指定的类型使用别名代替，在其他的地方可以使用别名，比较方便。 -->
  <typeAlias alias="user" type="com.cjf.ibatis.bean.User"/>
  
  <select id="selectUserByParam" parameterClass="user" resultClass="user">
      select * from t_user
      <!-- 动态参数查询
      dynamic标签表示标签体的内容如果至少有一个条件成立，那么会输出prepend属性的取值
       -->
      <dynamic prepend="where">
          <!-- 当参数对象的属性不为空时，条件成立，将条件sql语句直接输出到最终的sql语句中，如果有多个条件，要指定连接条件的关键字
           -->
          <isNotEmpty property="userpswd" prepend="and">
           userpswd = #userpswd#
          </isNotEmpty>
          <!-- 对象指定的属性取值是否不为空。 -->
          <isNotEmpty property="usercode" prepend="and">
           usercode = #usercode#
          </isNotEmpty>
          <!-- 判断是否不可以访问对象指定的属性。 -->
          <isNotPropertyAvailable property="orgtype123" prepend="and">
          orgtype = '0'
          </isNotPropertyAvailable>
          <isNotEmpty property="regdate" prepend="and">
          <![CDATA[
             regdate <= #regdate#  
          ]]>
          </isNotEmpty>
      </dynamic>
  </select>
</sqlMap>

----------------------

3.6

public class IBatisPageQuery {

	// Ibatis核心对象，可以进行数据库操作
	private static SqlMapClient sqlMapper;
	
    static {
	    try {
	      // 读取IBatis的数据库连接配置文件
	      Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
	      // 创建Ibatis核心对象
	      sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
	      // 关闭文件输入流
	      reader.close(); 
	    } catch (IOException e) {
	      // Fail fast.
	      throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
	    }
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		//queryForList();
		queryForList1();
	}
	public static void queryForList1() throws Exception {
		// 分页查询 - 逻辑分页
		// ibatis在进行逻辑分页时，将所有的数据放置内存中，使用ResultSet绝对定位的方式找到2页的数据保存到内存中。
		// 但是只显示第一页的数据,翻页时，会再次查询数据库取得第三页的数据,所以效率比较慢，不推荐使用。
		String sqlMapId = "selectUserListForLogic";

		//List<User> userList = sqlMapper.queryForList(sqlMapId);
		int pageSize = 2;
		// 逻辑分页
		System.out.println( "******************第一页 数据***********************" );
		PaginatedList userList = sqlMapper.queryForPaginatedList(sqlMapId, pageSize);
		
		for ( Object obj : userList ) {
			User u = (User)obj;
			System.out.println( "name = " + u.getUsername() );
		}
		System.out.println( "******************第二页 数据***********************" );
		userList.nextPage();
		for ( Object obj : userList ) {
			User u = (User)obj;
			System.out.println( "name = " + u.getUsername() );
		}
	}
	public static void queryForList() throws Exception {

		// 分页查询 - 物理分页
		String sqlMapId = "selectUserListForPage";
		
		Map map = new HashMap();
		
		int pageno = 1;
		int pagesize = 2;
		
		int startIndex = ((pageno-1) * pagesize);
		int endIndex = (pageno * pagesize);
		
		map.put("startIndex", startIndex);
		map.put("endIndex", endIndex);

		List<User> userList = sqlMapper.queryForList(sqlMapId, map);
		
		for ( User u : userList ) {
			System.out.println( "name = " + u.getUsername() );
		}
	}

}

3.6 sql文件

<?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 >
  <!-- 将指定的类型使用别名代替，在其他的地方可以使用别名，比较方便。 -->
  <typeAlias alias="user" type="com.cjf.ibatis.bean.User"/>
  
  <!-- SQL逻辑分页, 将数据库的数据全部查询出来，在内存中进行分页 -->
  <select id="selectUserListForLogic" resultClass="user">
      select * from t_user
  </select>
  
  <!-- SQL物理分页，采用数据库本身的分页查询机制进行分页，效率比较高，但是移植性差 -->
  <select id="selectUserListForPage" resultClass="user">
      <![CDATA[
		select *
		from 
		(
		 select rownum r, t.* 
		 from 
		  (
		   select * from t_user
		  )    t
		  where rownum <= #endIndex#
		)where r>  #startIndex#

      ]]>
  </select>
</sqlMap>

---------------------