MyBatis总结

Mybatis

大纲

1. 介绍mybatis
2. 基于mybatis的开发过程
3. 查询的条件不在实体类中时
4. 几个优化的地方
5. 使用接口结合xml文件
6. 解决字段与属性不匹配
7. 关联查询
8. $和#的区别
9. 添加对象时如何把生成的id返回
10. 动态sql语句
11. 逆向工程(generator)
12. 分页助手(pagehelper)

1. 介绍mybatis

 mybatis支持普通sql语句查询、存储过程和高级映射的持久层框架。

持久化：即把Java对象保存到数据库中

特点：

消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的封装

使用xml文件进行配置和映射

 

2. 基于mybatis的开发过程

1) 新建Java工程

2) 导入mybatis的jar包以及数据库驱动（放入工程目录下的lib文件夹中，需要Build Path）

3) 创建数据库和表格

4) 添加实体类和构造函数

5) 添加mybatis的配置文件conf.xml(加载数据库驱动、连接到数据库、数据库的用户名和密码)

*在resource文件夹下添加

*conf.xml中是配置数据源的信息：即数据库的信息

<?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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url"
                    value="jdbc:mysql://localhost:3306/mybatis" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
</configuration>

6) 定义操作user表的sql映射文件userMapper.xml(以user表为例，映射文件即在实体类、表、sql语句之间映射关系)

*在src目录下新建mapper的包，再在该包下新建userMapper.xml文件

*id：标识该标签

*parameterType：参数的数据类型

*resultType：返回值的数据类型

*mapper：即映射

*namespace:表示命名空间，现在的目的是区分id的

*mybatis中的占位符用#{ }

#{id}:类似于EL表达式解析id

<?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="com.zhiyou.clg.mapper.UserMapper">
    <select id="selectUser" parameterType="int"
        resultType="com.zhiyou.clg.bean.User">
        select * from user where id=#{id}
    </select>
</mapper>

7) 在conf.xml文件中注册user Mapper.xml文件(即把映射文件引入到配置文件中)

*在mappers标签中使用mapper标签（属性：resource）

        <mappers>
        <mapper resource="com/zhiyou/clg/mapper/UserMapper.xml"/>
    </mappers>    

　　8) 进行单元测试

//解析配置文件conf.xml

Reader reader = Resources.getResourceAsReader(“conf.xml”);

//获取SessionFactory对象

SqlSessionFactory  sessionFactory = new  SqlSessionFactoryBuilder().build(reader);

//获取Session对象。这里表示jdbc中Connection.是操作数据库的

SqlSession session = sessionFactory.openSession();

User user = session.selectOne("com.zhiyou.clg.mapper.userMapper.getUser", 1);

*进行增删改的时候需要进行手动提交任务,即将数据提交到数据库中

session.commit();

手动提交可实现     事物管理：事物是由一系列动作组成，这些动作要么都执行，要么都不执行

package com.zhiyou.clg.mapper;

import static org.junit.jupiter.api.Assertions.*;

import java.io.IOException;
import java.io.Reader;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

import com.zhiyou.clg.bean.User;

class UserTest {
    private static SqlSession session = null;
    final static String str="com.zhiyou.clg.mapper.UserMapper";
    @BeforeAll//测试前会执行
    static void setUpBeforeClass() throws Exception {
                //解析配置文件
                Reader reader = Resources.getResourceAsReader("conf.xml");
                //获取SessionFactory对象
                SqlSessionFactory SessionFactory = new SqlSessionFactoryBuilder().build(reader);
                //获取Session对象
                session = SessionFactory.openSession();
    }

    @AfterAll//测试后执行
    static void tearDownAfterClass() throws Exception {
        session.commit();
    }

    @Test
    void test() throws IOException {
        User user=session.selectOne(str+".selectUser", 1);
        System.out.println(user);
    }

}

3. 查询的条件不在实体类中时

way1：参数类型封装到map中#{参数}--->map的键（此时参数类型为java.util.Map或map）

*若xml文件中出现了特殊字符

way1：使用转义字符

way2：使用<![CDATA[ ]]>

*映射文件UserMapper.xml：

<select id="selectway1" parameterType="map"
        resultType="com.zhiyou.clg.bean.User">
        <![CDATA[select * from user where age>=#{min} and age<=#{max}]]>
        <!-- select *from user where age between #{min} and #{max} -->
    </select>

　　*单元测试：

@Test
    void testselectway1() throws IOException {
        Map<String, Integer> map=new HashMap<String, Integer>();
        map.put("min", 18);
        map.put("max", 19);
        
        List<User> list=session.selectList(str+".selectway1",map);
        System.out.println(list);
    }

　　*若xml文件中出现了特殊字符

way1：使用转义字符

way2：使用<![CDATA[ ]]>

way2：封装一个实体类

4. 几个优化的地方

1)习惯把数据源信息放到一个属性文件中。后缀为properties

*  # 在properties中表示注释

*在resource目录下新建该文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=root

　　*在配置文件conf.xml中引入属性文件<properties  resource=”文件名”/>

<?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="db.properties"/>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}" />
                <property name="url" value="${jdbc.url}" />
                <property name="username" value="${jdbc.username}" />
                <property name="password" value="${jdbc.password}" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/zhiyou/clg/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

　　2)在conf.xml文件中为实体类起别名----不建议使用别名，建议还是在映射文件中使用全类名

<typeAliases>

<typeAlias type=”实体类路径” alias=”别名”/>//为某个实体类起别名

<package  name=”实体类包名” />//将包下所有的实体类的别名起为对应的实体类名，故可以直接使用

<typeAliases/>

3)添加日志

*在lib目录下导入日志jar包

*在resource目录下新建log4j.properties或者. log4j.xml文件（固定内容复制）

log4j.properties,
log4j.rootLogger=DEBUG, Console
#Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

5. 使用接口结合xml文件

　　1)创建dao包，在包下创建接口，该接口要和映射文件匹配

package com.zhiyou.clg.dao;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.zhiyou.clg.bean.User;
public interface UserDao {
    List<User> selectUser2(int id);
}

　　2)映射文件中的namespace一定要和接口所在的包以及接口的名字一样

　　3)标签中的id一定和接口中方法的名字对照

<?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="com.zhiyou.clg.dao.UserDao">
    <select id="selectUser2" parameterType="int"
        resultType="com.zhiyou.clg.bean.User">
        select * from user where id=#{id}
    </select>
</mapper>

　　4)测试时：

@Test
    void testselectUser2() {
        UserDao userDao = session.getMapper(UserDao.class);
        List<User> list = userDao.selectUser2(1);
        System.out.println(list);
    }

6. 解决字段与属性不匹配

　　way1：sql语句中为字段起别名，别名与实体类名一致

<select id="getOrder2" parameterType="int" resultType="com.zhiyou.clg.bean.Order">
          select order_id id,order_no no,order_price price from Orders where order_id=#{id}   
</select>

　　way2：使用resultMap标签(属性：type、id)来定义实体类与字段之间的对应关系，其标签内包含标签id（主键）、标签result（普通字段，属性：column、property）

       <select id="getOrder" resultMap="myMap">
          select * from Orders where Order_id=#{id}   
    </select>
    <resultMap type="com.zhiyou.clg.bean.Order" id="myMap">
        <id column="order_id" property="id"/>
        <result column="order_no" property="no"/>
        <result column="order_price" property="price"/>
    </resultMap>    

7. 关联查询

7.1比如根据班级id查询班级信息（带老师的信息）一对一或多对一

　　　　way1：SQL语句中使用联表查询

*实体类中需要添加属性（数据类型为实体类名）

*映射文件中使用association标签（属性：property（实体类中添加的属性名）、javaType(添加的属性所在的实体类的全类名)）

<select id="getClazz" resultMap="myMap">
          select * from class c,teacher t where c.teacher_id=t.t_id and c_id=#{cid}   
    </select>
    <resultMap type="com.zhiyou.clg.bean.Clazz" id="myMap">
        <id column="c_id" property="id"/>
        <result column="c_name" property="name"/>
        <result column="teacher_id" property="teacherid"/>
        <association property="teacher" javaType="com.zhiyou.clg.bean.Teacher">
            <id column="t_id" property="id"/>
            <result column="t_name" property="name"/>
        </association>
    </resultMap> 

way2：嵌套查询（查询的结果为其他查询的条件）

*实体类中需要添加属性（数据类型为实体类名）

*映射文件中使用association标签（属性：property、javaType（查询到的结果，此时作为查询条件）、 column、select（另一映射的语句的id，即另一select标签的id））

     <select id="getClazz" resultMap="myMap2">
          select * from class where c_id=#{cid}   
    </select>
    <select id="getTeacher" parameterType="int" resultType="com.zhiyou.clg.bean.Teacher">
           select t_id id,t_name name from teacher where t_id=#{tid}   
    </select>
    <resultMap type="com.zhiyou.clg.bean.Clazz" id="myMap2">
        <id column="c_id" property="id"/>
        <result column="c_name" property="name"/>
        <result column="teacher_id" property="teacherid"/>
        <association property="teacher"   javaType="com.zhiyou.clg.bean.Teacher" 
                    column="teacher_id" select="getTeacher">
            <id column="t_id" property="id"/>
            <result column="t_name" property="name"/>
        </association>
    </resultMap>      

7.2比如根据班级id查询班级信息（带班里学生的信息）一对多

way1：SQL语句中使用联表查询

*实体类中添加属性（数据类型为集合，泛型为实体类名）

*映射文件中使用collection标签(属性：property（添加的属性名）、ofType（集合泛型的实体 类的全类名）)

　　 <select id="getClazz" resultMap="myMap3">
select *from class c,teacher t,student s where c.c_id=s.class_id and c.teacher_id=t.t_id and c.c_id=#{cid}  
    </select>
    <resultMap type="com.zhiyou.clg.bean.Clazz" id="myMap3">
        <id column="c_id" property="id"/>
        <result column="c_name" property="name"/>
        <result column="teacher_id" property="teacherid"/>
        <association property="teacher" javaType="com.zhiyou.clg.bean.Teacher">
            <id column="t_id" property="id"/>
            <result column="t_name" property="name"/>
        </association>
        <collection property="students" ofType="com.zhiyou.clg.bean.Student">
            <id column="s_id" property="id"/>
            <result column="s_name" property="name"/>
            <result column="class_id" property="cid"/>
        </collection>
    </resultMap> -->

way2：嵌套查询（查询的结果为其他查询的条件）

*实体类中添加属性（数据类型为集合，泛型为实体类名）

*映射文件中使用collection标签(属性：property、ofType、column、select)

<select id="getClazz" resultMap="myMap4">
          select * from class where c_id=#{cid}   
    </select>
    <select id="getTeacher" parameterType="int" resultType="com.zhiyou.clg.bean.Teacher">
           select t_id id,t_name name from teacher where t_id=#{tid}   
    </select>
    <select id="getStudent" parameterType="int" resultType="com.zhiyou.clg.bean.Student">
            select s_id id,s_name name,class_id cid from student where class_id=#{cid}
    </select>
    <resultMap type="com.zhiyou.clg.bean.Clazz" id="myMap4">
        <id column="c_id" property="id"/>
        <result column="c_name" property="name"/>
        <result column="teacher_id" property="teacherid"/>
        <association property="teacher"   javaType="com.zhiyou.clg.bean.Teacher" 
                    column="teacher_id" select="getTeacher">
            <id column="t_id" property="id"/>
            <result column="t_name" property="name"/>
        </association>
        <collection property="students" ofType="com.zhiyou.clg.bean.Student"
                     column="c_id" select="getStudent">
            <id column="s_id" property="id"/>
            <result column="s_name" property="name"/>
            <result column="class_id" property="cid"/>
        </collection>
    </resultMap> 

8. $和#的区别

$: 解析时不会为内容添加”” 他是sql语句的拼接,存在sql注入的缺陷。

当传入的为表结构时使用，当传入的为列名或表名时可以使用

order by  group by 时用$

$:一般用于传入数据库对象，例如列名或表名

#: 解析时会为内容添加””,它的sql时采用占位符，防止sql注入。

能用#不要用$

#:一般传入的是值

9. 添加对象时如何把生成的id返回

    <insert id="adduser" parameterType="com.zhiyou.clg.bean.User" useGeneratedKeys="true" keyProperty="id">
        insert into user(name,age) values(#{name},#{age});
    </insert>

　　useGeneratedKeys="true"  ：表示使用自动生成的id

keyProperty="id"   ：把生成的id赋值给对应的实体类属性

以上两者联合使用

*测试时可通过get方法获取id值

@Test
    void testadd() throws IOException {
        User user=new User();
        user.setName("小天");
        user.setAge(10);
        userDao.adduser(user);
        System.out.println(user.getId());

    }

　　一般可用于添加单号（自动生成）后即刻便加入商品

10. 动态sql语句(即sql语句的拼接)

　　10.1  if标签（属性：test（判断条件））

　　缺点：如果仅仅是第二个条件满足导致sql语句出错（故使用if+where）

　　<select id="select1" resultType="com.zhiyou.clg.bean.User">
        select *from user
        <if test="name!=null">
            where name=#{name}
        </if>
        <if test="age!=null and age!=''">
            and age=#{age}
        </if>
    </select>

　　10.2  if+where ( where标签会知道如果它包含的标签中有返回值的话，就会插入where 若其以and或or开头会将and或or剔除)

    <select id="select2" resultType="com.zhiyou.clg.bean.User">
        select *from user
        <where>
            <if test="name!=null">
                and name=#{name}
            </if>
            <if test="sex!=null">
                and sex=#{sex}
            </if>
            <if test="age!=null and age!=''">
                and age=#{age}
            </if>
        </where>
    </select>

　　10.3 if+set( set标签会知道如果它包含的标签中有返回值的话，就会插入set并且剔除最后一个满足条件的逗号“，”)

<update id="update1" parameterType="com.zhiyou.clg.bean.User">
        update user
        <set>
            <if test="name!=null">
                name=#{name},
            </if>
            <if test="sex!=null">
                sex=#{sex},
            </if>
            <if test="age!=null and age!=''">
                age=#{age},
            </if>
        </set>
        <where>
            <if test="id!=null">
                id=#{id}
            </if>
        </where>
    </update

 　　10.4 choose(标签when+标签otherwise)----类似于switch语句，有且仅有一个条件会满足

　　　<sql id="usercolumn" >
         id,name,age,sex
     </sql>
    <select id="select3" resultType="com.zhiyou.clg.bean.User">
        select 
            <include refid="usercolumn"></include>
         from user
        <where>
            <choose>
                <when test="name!=null">
                    and name=#{name}
                </when>
                <when test="age!=null and age!=''">
                    and age=#{age}
                </when>
                <otherwise>
                    and sex=#{sex}
                </otherwise>
            </choose>
        </where>
    </select>

10.5 trim（trim标记是一个格式化的标记，可以完成set或者是where标记的功能；）

属性：prefix：前缀　　　　　　

　　  prefixoverrides：去掉前缀

　　  suffix：后缀　　　　　　

　　  suffixoverrides：去掉后缀

    <update id="update2" parameterType="com.zhiyou.clg.bean.User">
        update user
            <trim prefix="set" suffixOverrides=",">
                <if test="name!=null">
                    name=#{name},
                </if>
                <if test="sex!=null">
                    sex=#{sex},
                </if>
                <if test="age!=null and age!=''">
                    age=#{age},
                </if>
            </trim>
        <where>
            <if test="id!=null">
                id=#{id}
            </if>
        </where>
    </update>

 　　10.6 sql片段------使用sql标签定义（属性：id）;引用片段时用include标签（属性：refid）

10.7 foreach

属性：  collection:指定输入对象中的集合属性

            item:每次遍历生成的对象

            open:开始遍历时的拼接字符串

            close:结束时拼接的字符串

            separator:遍历对象之间需要拼接的字符串

    <sql id="namecolumn" >
         name
     </sql>
    <select id="select4" resultType="com.zhiyou.clg.bean.User">
        select 
            <include refid="namecolumn"></include>
        from user where id in 
            <foreach collection="ids" open="(" close=")" separator="," item="id">
                #{id}
            </foreach>
    </select>

 　　10.8模糊查询-----like后使用concat函数拼接（‘%’,#{name},’%’）

     　　 name  like  concat（‘%’,#{name},’%’）

11. 逆向工程(generator)----->由表帮我们来生成dao、bean、xml

　　1)引入mybatis-generator的jar包

　　2)在工程目录下新建generator.xml文件（复制官网内容）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!-- 数据库驱动jar包所在的位置 -->
  <classPathEntry location="D:\mybatis\generator830\lib\mysql-connector-java-5.1.47.jar" />
  <context id="DB2Tables" targetRuntime="MyBatis3">
 <!--  去除注释 -->
      <commentGenerator>
      <property name="suppressAllComments" value="true" />
        </commentGenerator>
   <!--  数据源信息 -->
    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
        connectionURL="jdbc:mysql://localhost:3306/mybatis"
        userId="root"
        password="root">
    </jdbcConnection>
    <javaTypeResolver >
      <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>
    <!-- 生成的实体类所在的位置 -->
    <javaModelGenerator targetPackage="com.zhiyou.clg.bean" targetProject="./src">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    </javaModelGenerator>
    <!-- 生成的映射文件所在的位置 -->
    <sqlMapGenerator targetPackage="com.zhiyou.clg.mapper"  targetProject="./resource">
      <property name="enableSubPackages" value="true" />
    </sqlMapGenerator>
    <!-- 生成的dao所在的位置 -->
    <javaClientGenerator type="XMLMAPPER" targetPackage="com.zhiyou.clg.dao"  targetProject="./src">
      <property name="enableSubPackages" value="true" />
    </javaClientGenerator>
    <!-- 表和实体类的对象关系
        schema：该表所在的数据库
        tableName：表名
        domainObjectName：实体类名
     -->
    <table schema="DB2ADMIN" tableName="user" domainObjectName="User"  
     enableCountByExample="false" enableDeleteByExample="false" enableSelectByExample="false" enableUpdateByExample="false" >
      <property name="useActualColumnNames" value="true"/>
      <generatedKey column="ID" sqlStatement="DB2" identity="true" />
      <columnOverride column="DATE_FIELD" property="startDate" />
      <ignoreColumn column="FRED" />
      <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" />
    </table>

  </context>
</generatorConfiguration>

 　　3)在src目录下新建test包，再新建Test类，在main下复制官网内容，导包后运行

package com.zhiyou.clg.test;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;

public class TestGenerator {
    public static void main(String[] args) throws Exception{
        List<String> warnings = new ArrayList<String>();
           boolean overwrite = true;
           File configFile = new File("generator.xml");
           ConfigurationParser cp = new ConfigurationParser(warnings);
           Configuration config = cp.parseConfiguration(configFile);
           DefaultShellCallback callback = new DefaultShellCallback(overwrite);
           MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
           myBatisGenerator.generate(null);
    }
}

12. 分页助手(pagehelper)

　　1)引入jar包 jsqlparser-2.0.jar和pagehelper-5.1.10.jar(两jar包需匹配使用)

　　2)在配置文件中添加，拦截器插件（复制官网），注意顺序

<!--

    plugins在配置文件中的位置必须符合要求，否则会报错，顺序如下:

    properties?, settings?,

    typeAliases?, typeHandlers?,

    objectFactory?,objectWrapperFactory?,

    plugins?,

    environments?, databaseIdProvider?, mappers?

-->

<plugins>
        <!-- com.github.pagehelper为PageHelper类所在包名 -->
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!-- 使用下面的方式配置参数，后面会有所有的参数介绍 -->
           <!--  <property name="param1" value="value1"/> -->
        </plugin>
    </plugins>

　　*测试时：（参考官网）

@Test
void testselectall() {
        //1.使用PageHelper类设置起始页和每页显示的条数
        int pageNum=5;//当前页码   从网页中可以获取
        int pageSize=3;//pageSize：自定义
        PageHelper.startPage(pageNum,pageSize);
        //2调用查询所有的方法
        List<User> list=userMapper.selectall();
        for (User user : list) {
            System.out.println(user);
        }
        //3.把查询的结果封装到Pageinfo中
        PageInfo<User> pageinfo=new PageInfo<>(list,4);
        System.out.println("上一页:"+pageinfo.getPrePage());
        System.out.println("当前页:"+pageinfo.getPageNum());
        System.out.println("下一页:"+pageinfo.getNextPage());
        System.out.println("总页数:"+pageinfo.getPages());
        int[] navigatepageNums = pageinfo.getNavigatepageNums();
        for (int i : navigatepageNums) {
            System.out.print(i+"	");
        }
    }

　　*直接输出pageinfo查询到的结果

PageInfo{
pageNum=1, //当前页
pageSize=2,//每页显示的条数
 size=2,//该页条数
 startRow=1,//从第几条开始
 endRow=2, //到第几条结束
total=5, //总共有多少条
pages=3,//总共的页数
 list=Page{count=true, pageNum=1, pageSize=2, startRow=0, endRow=2, total=5, pages=3, reasonable=false, pageSizeZero=false}
[com.zhiyou.clg.bean.User@52bf72b5, com.zhiyou.clg.bean.User@37afeb11], //当前页的数据
prePage=0, //上一页
nextPage=2, //下一页
isFirstPage=true,//是否为第一页
 isLastPage=false, hasPreviousPage=false, hasNextPage=true, 
navigatePages=8,//每页显示的页码个数
 navigateFirstPage=1,
 navigateLastPage=3, 
navigatepageNums=[1, 2, 3]//页码的个数
}