Wrapper (mybatis-plus 2.1.0 API)

java.lang.Object
- com.baomidou.mybatisplus.mapper.Wrapper<T>

所有已实现的接口:

Serializable

直接已知子类:

Condition, EntityWrapper
```
public abstract class Wrapper<T>
extends Object
implements Serializable
```
条件构造抽象类，定义T-SQL语法

作者:

hubin , yanghu , Dyang , Caratacus

另请参阅:
序列化表格

字段概要

字段
限定符和类型	字段和说明
`protected String`	`AND_OR` 拼接WHERE后应该是AND还是ORnull
`protected Boolean`	`isWhere` 自定义是否输出sql为 WHERE OR AND OR OR
`protected String`	`paramAlias`
`protected SqlPlus`	`sql` 实现了TSQL语法的SQL实体
`protected String`	`sqlSelect` SQL 查询字段内容，例如：id,name,age

构造器概要

构造器
构造器和说明

Wrapper()

构造器
构造器和说明
`Wrapper()`

方法概要

方法
限定符和类型	方法和说明
`Wrapper<T>`	`addFilter(String sqlWhere, Object... params)` 为了兼容之前的版本,可使用where()或and()替代
`Wrapper<T>`	`addFilterIfNeed(boolean need, String sqlWhere, Object... params)` 根据判断条件来添加条件语句部分使用 andIf() 替代 eg: ew.filterIfNeed(false,"name='zhangsan'").where("name='zhangsan'") .filterIfNeed(true,"id={0}",22) 输出: WHERE (name='zhangsan' AND id=22)
`Wrapper<T>`	`allEq(boolean condition, Map<String,Object> params)` 等同于SQL的"field=value"表达式
`Wrapper<T>`	`allEq(Map<String,Object> params)` 等同于SQL的"field=value"表达式
`Wrapper<T>`	`and()` 使用AND连接并换行
`Wrapper<T>`	`and(boolean condition, String sqlAnd, Object... params)` AND 连接后续条件
`Wrapper<T>`	`and(String sqlAnd, Object... params)` AND 连接后续条件
`Wrapper<T>`	`andNew()` 使用AND连接并换行 eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) AND (statu=1)
`Wrapper<T>`	`andNew(boolean condition, String sqlAnd, Object... params)` 使用AND连接并换行 eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) AND (statu=1)
`Wrapper<T>`	`andNew(String sqlAnd, Object... params)` 使用AND连接并换行 eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) AND (statu=1)
`Wrapper<T>`	`between(boolean condition, String column, Object val1, Object val2)` betwwee 条件语句
`Wrapper<T>`	`between(String column, Object val1, Object val2)` betwwee 条件语句
`Wrapper<T>`	`eq(boolean condition, String column, Object params)` 等同于SQL的"field=value"表达式
`Wrapper<T>`	`eq(String column, Object params)` 等同于SQL的"field=value"表达式
`Wrapper<T>`	`exists(boolean condition, String value)` EXISTS 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`exists(String value)` EXISTS 条件语句，目前适配mysql及oracle
`protected String`	`formatSql(String sqlStr, Object... params)` 格式化SQL
`protected String`	`formatSqlIfNeed(boolean need, String sqlStr, Object... params)` 根据需要格式化SQL Format SQL for methods: EntityWrapper.where/and/or...
`Wrapper<T>`	`ge(boolean condition, String column, Object params)` 等同于SQL的"field>=value"表达式
`Wrapper<T>`	`ge(String column, Object params)` 等同于SQL的"field>=value"表达式
`T`	`getEntity()` 兼容EntityWrapper
`String`	`getParamAlias()`
`Map<String,Object>`	`getParamNameValuePairs()` Fix issue 200.
`abstract String`	`getSqlSegment()` SQL 片段 (子类实现)
`String`	`getSqlSelect()`
`Wrapper<T>`	`groupBy(boolean condition, String columns)` SQL中groupBy关键字跟的条件语句 eg: ew.where("name='zhangsan'").groupBy("id,name")
`Wrapper<T>`	`groupBy(String columns)` SQL中groupBy关键字跟的条件语句 eg: ew.where("name='zhangsan'").groupBy("id,name")
`Wrapper<T>`	`gt(boolean condition, String column, Object params)` 等同于SQL的"field>value"表达式
`Wrapper<T>`	`gt(String column, Object params)` 等同于SQL的"field>value"表达式
`Wrapper<T>`	`having(boolean condition, String sqlHaving, Object... params)` SQL中having关键字跟的条件语句 eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null")
`Wrapper<T>`	`having(String sqlHaving, Object... params)` SQL中having关键字跟的条件语句 eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null")
`Wrapper<T>`	`in(boolean condition, String column, Collection<?> value)` IN 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`in(boolean condition, String column, Object[] value)` IN 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`in(boolean condition, String column, String value)` IN 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`in(String column, Collection<?> value)` IN 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`in(String column, Object[] value)` IN 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`in(String column, String value)` IN 条件语句，目前适配mysql及oracle
`boolean`	`isEmptyOfWhere()` 查看where构造是否为空
`boolean`	`isNotEmptyOfWhere()` 查看where构造是否不为空
`Wrapper<T>`	`isNotNull(boolean condition, String columns)` is not null 条件
`Wrapper<T>`	`isNotNull(String columns)` is not null 条件
`Wrapper<T>`	`isNull(boolean condition, String columns)` is not null 条件
`Wrapper<T>`	`isNull(String columns)` is not null 条件
`Wrapper<T>`	`isWhere(Boolean bool)` 自定义是否输出sql开头为 `WHERE` OR `AND` OR `OR`
`Wrapper<T>`	`last(String limit)` 手动把sql拼接到最后(有sql注入的风险,请谨慎使用)
`Wrapper<T>`	`le(boolean condition, String column, Object params)` 等同于SQL的"field<=value"表达式
`Wrapper<T>`	`le(String column, Object params)` 等同于SQL的"field<=value"表达式
`Wrapper<T>`	`like(boolean condition, String column, String value)` LIKE条件语句，value中无需前后%
`Wrapper<T>`	`like(boolean condition, String column, String value, SqlLike type)` LIKE条件语句，value中无需前后%
`Wrapper<T>`	`like(String column, String value)` LIKE条件语句，value中无需前后%
`Wrapper<T>`	`like(String column, String value, SqlLike type)` LIKE条件语句，value中无需前后%
`Wrapper<T>`	`lt(boolean condition, String column, Object params)` 等同于SQL的"field
`Wrapper<T>`	`lt(String column, Object params)` 等同于SQL的"field
`Wrapper<T>`	`ne(boolean condition, String column, Object params)` 等同于SQL的"field <> value"表达式
`Wrapper<T>`	`ne(String column, Object params)` 等同于SQL的"field <> value"表达式
`Wrapper<T>`	`notBetween(boolean condition, String column, Object val1, Object val2)` NOT betwwee 条件语句
`Wrapper<T>`	`notBetween(String column, Object val1, Object val2)` NOT betwwee 条件语句
`Wrapper<T>`	`notExists(boolean condition, String value)` NOT EXISTS条件语句
`Wrapper<T>`	`notExists(String value)` NOT EXISTS条件语句
`Wrapper<T>`	`notIn(boolean condition, String column, Collection<?> value)` NOT IN 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`notIn(boolean condition, String column, Object... value)` NOT IN 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`notIn(boolean condition, String column, String value)` NOT IN条件语句
`Wrapper<T>`	`notIn(String column, Collection<?> value)` NOT IN 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`notIn(String column, Object... value)` NOT IN 条件语句，目前适配mysql及oracle
`Wrapper<T>`	`notIn(String column, String value)` NOT IN条件语句
`Wrapper<T>`	`notLike(boolean condition, String column, String value)` NOT LIKE条件语句，value中无需前后%
`Wrapper<T>`	`notLike(boolean condition, String column, String value, SqlLike type)` NOT LIKE条件语句，value中无需前后%
`Wrapper<T>`	`notLike(String column, String value)` NOT LIKE条件语句，value中无需前后%
`Wrapper<T>`	`notLike(String column, String value, SqlLike type)` NOT LIKE条件语句，value中无需前后%
`Wrapper<T>`	`or()` 使用OR连接并换行
`Wrapper<T>`	`or(boolean condition, String sqlOr, Object... params)` 添加OR条件
`Wrapper<T>`	`or(String sqlOr, Object... params)` 添加OR条件
`Wrapper<T>`	`orderBy(boolean condition, String columns)` SQL中orderby关键字跟的条件语句 eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null" ).orderBy("id,name")
`Wrapper<T>`	`orderBy(boolean condition, String columns, boolean isAsc)` SQL中orderby关键字跟的条件语句，可根据变更动态排序
`Wrapper<T>`	`orderBy(String columns)` SQL中orderby关键字跟的条件语句 eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null" ).orderBy("id,name")
`Wrapper<T>`	`orderBy(String columns, boolean isAsc)` SQL中orderby关键字跟的条件语句，可根据变更动态排序
`String`	`originalSql()` 原生占位符sql
`Wrapper<T>`	`orNew()` 使用OR换行，并添加一个带()的新的条件 eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) OR (statu=1)
`Wrapper<T>`	`orNew(boolean condition, String sqlOr, Object... params)` 使用OR换行，并添加一个带()的新的条件 eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) OR (statu=1)
`Wrapper<T>`	`orNew(String sqlOr, Object... params)` 使用OR换行，并添加一个带()的新的条件 eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) OR (statu=1)
`Wrapper<T>`	`setParamAlias(String paramAlias)` 参数别名设置，初始化时优先设置该值、重复设置异常
`Wrapper<T>`	`setSqlSelect(Column... column)` 使用对象封装的setsqlselect
`Wrapper<T>`	`setSqlSelect(Columns columns)` 使用对象封装的setsqlselect
`Wrapper<T>`	`setSqlSelect(String... columns)` 使用字符串数组封装sqlSelect，便于在不需要指定 AS 的情况下通过实体类自动生成的列静态字段快速组装 sqlSelect，减少手动录入的错误率
`Wrapper<T>`	`setSqlSelect(String sqlSelect)`
`protected String`	`stripSqlInjection(String value)` SQL注入内容剥离
`String`	`toString()`
`Wrapper<T>`	`where(boolean condition, String sqlWhere, Object... params)` SQL中WHERE关键字跟的条件语句 eg: ew.where("name='zhangsan'").where(id!
`Wrapper<T>`	`where(String sqlWhere, Object... params)` SQL中WHERE关键字跟的条件语句 eg: ew.where("name='zhangsan'").where("id={0}","123"); 输出: WHERE (NAME='zhangsan' AND id=123)

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- 字段详细资料
  - sql
```
protected final SqlPlus sql
```
    实现了TSQL语法的SQL实体
  - paramAlias
```
protected String paramAlias
```
  - sqlSelect
```
protected String sqlSelect
```
    SQL 查询字段内容，例如：id,name,age
  - isWhere
```
protected Boolean isWhere
```
    自定义是否输出sql为 WHERE OR AND OR OR
  - AND_OR
```
protected String AND_OR
```
    拼接WHERE后应该是AND还是ORnull
- 构造器详细资料
  - Wrapper
```
public Wrapper()
```
- 方法详细资料
  - getEntity
```
public T getEntity()
```
    兼容EntityWrapper
    
    返回:
  - isEmptyOfWhere
```
public boolean isEmptyOfWhere()
```
    查看where构造是否为空
    
    返回:
  - isNotEmptyOfWhere
```
public boolean isNotEmptyOfWhere()
```
    查看where构造是否不为空
    
    返回:
  - getSqlSelect
```
public String getSqlSelect()
```
  - setSqlSelect
```
public Wrapper<T> setSqlSelect(String sqlSelect)
```
  - setSqlSelect
```
public Wrapper<T> setSqlSelect(String... columns)
```
    使用字符串数组封装sqlSelect，便于在不需要指定 AS 的情况下通过实体类自动生成的列静态字段快速组装 sqlSelect，
    减少手动录入的错误率
    
    参数:
    columns - 字段
    
    返回:
  - setSqlSelect
```
public Wrapper<T> setSqlSelect(Column... column)
```
    使用对象封装的setsqlselect
    
    参数:
    column - 字段
    
    返回:
  - setSqlSelect
```
public Wrapper<T> setSqlSelect(Columns columns)
```
    使用对象封装的setsqlselect
    
    参数:
    columns - 字段
    
    返回:
  - getSqlSegment
```
public abstract String getSqlSegment()
```
    SQL 片段 (子类实现)
  - toString
```
public String toString()
```
    覆盖:
    
    toString 在类中 Object
  - originalSql
```
public String originalSql()
```
    原生占位符sql
    
    返回:
  - where
```
public Wrapper<T> where(boolean condition,
               String sqlWhere,
               Object... params)
```
    SQL中WHERE关键字跟的条件语句
    
    eg: ew.where("name='zhangsan'").where(id!=null, "id={0}", id);
    输出:
    如果id=123: WHERE (NAME='zhangsan' AND id=123)
    如果id=null: WHERE (NAME='zhangsan')
    
    参数:
    condition - 拼接的前置条件
    sqlWhere - where语句
    params - 参数集
    
    返回:
    this
  - where
```
public Wrapper<T> where(String sqlWhere,
               Object... params)
```
    SQL中WHERE关键字跟的条件语句
    
    eg: ew.where("name='zhangsan'").where("id={0}","123");
    输出: WHERE (NAME='zhangsan' AND id=123)
    
    参数:
    sqlWhere - where语句
    params - 参数集
    
    返回:
    this
  - eq
```
public Wrapper<T> eq(boolean condition,
            String column,
            Object params)
```
    等同于SQL的"field=value"表达式
    
    参数:
    condition - 拼接的前置条件
    column -
    params -
    
    返回:
  - eq
```
public Wrapper<T> eq(String column,
            Object params)
```
    等同于SQL的"field=value"表达式
    
    参数:
    column -
    params -
    
    返回:
  - ne
```
public Wrapper<T> ne(boolean condition,
            String column,
            Object params)
```
    等同于SQL的"field <> value"表达式
    
    参数:
    condition - 拼接的前置条件
    column -
    params -
    
    返回:
  - ne
```
public Wrapper<T> ne(String column,
            Object params)
```
    等同于SQL的"field <> value"表达式
    
    参数:
    column -
    params -
    
    返回:
  - allEq
```
public Wrapper<T> allEq(boolean condition,
               Map<String,Object> params)
```
    等同于SQL的"field=value"表达式
    
    参数:
    condition - 拼接的前置条件
    params -
    
    返回:
  - allEq
```
public Wrapper<T> allEq(Map<String,Object> params)
```
    等同于SQL的"field=value"表达式
    
    参数:
    params -
    
    返回:
  - gt
```
public Wrapper<T> gt(boolean condition,
            String column,
            Object params)
```
    等同于SQL的"field>value"表达式
    
    参数:
    condition - 拼接的前置条件
    column -
    params -
    
    返回:
  - gt
```
public Wrapper<T> gt(String column,
            Object params)
```
    等同于SQL的"field>value"表达式
    
    参数:
    column -
    params -
    
    返回:
  - ge
```
public Wrapper<T> ge(boolean condition,
            String column,
            Object params)
```
    等同于SQL的"field>=value"表达式
    
    参数:
    condition - 拼接的前置条件
    column -
    params -
    
    返回:
  - ge
```
public Wrapper<T> ge(String column,
            Object params)
```
    等同于SQL的"field>=value"表达式
    
    参数:
    column -
    params -
    
    返回:
  - lt
```
public Wrapper<T> lt(boolean condition,
            String column,
            Object params)
```
    等同于SQL的"field
    
    参数:
    condition - 拼接的前置条件
    column -
    params -
    
    返回:
  - lt
```
public Wrapper<T> lt(String column,
            Object params)
```
    等同于SQL的"field
    
    参数:
    column -
    params -
    
    返回:
  - le
```
public Wrapper<T> le(boolean condition,
            String column,
            Object params)
```
    等同于SQL的"field<=value"表达式
    
    参数:
    condition - 拼接的前置条件
    column -
    params -
    
    返回:
  - le
```
public Wrapper<T> le(String column,
            Object params)
```
    等同于SQL的"field<=value"表达式
    
    参数:
    column -
    params -
    
    返回:
  - and
```
public Wrapper<T> and(boolean condition,
             String sqlAnd,
             Object... params)
```
    AND 连接后续条件
    
    参数:
    condition - 拼接的前置条件
    sqlAnd - and条件语句
    params - 参数集
    
    返回:
    this
  - and
```
public Wrapper<T> and(String sqlAnd,
             Object... params)
```
    AND 连接后续条件
    
    参数:
    sqlAnd - and条件语句
    params - 参数集
    
    返回:
    this
  - andNew
```
public Wrapper<T> andNew(boolean condition,
                String sqlAnd,
                Object... params)
```
    使用AND连接并换行
    
    eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) AND (statu=1)
    
    参数:
    condition - 拼接的前置条件
    sqlAnd - AND 条件语句
    params - 参数值
    
    返回:
    this
  - andNew
```
public Wrapper<T> andNew()
```
    使用AND连接并换行
    
    eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) AND (statu=1)
    
    返回:
    this
  - andNew
```
public Wrapper<T> andNew(String sqlAnd,
                Object... params)
```
    使用AND连接并换行
    
    eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) AND (statu=1)
    
    参数:
    sqlAnd - AND 条件语句
    params - 参数值
    
    返回:
    this
  - and
```
public Wrapper<T> and()
```
    使用AND连接并换行
    
    返回:
    this
  - or
```
public Wrapper<T> or()
```
    使用OR连接并换行
    
    返回:
    this
  - or
```
public Wrapper<T> or(boolean condition,
            String sqlOr,
            Object... params)
```
    添加OR条件
    
    参数:
    condition - 拼接的前置条件
    sqlOr - or 条件语句
    params - 参数集
    
    返回:
    this
  - or
```
public Wrapper<T> or(String sqlOr,
            Object... params)
```
    添加OR条件
    
    参数:
    sqlOr - or 条件语句
    params - 参数集
    
    返回:
    this
  - orNew
```
public Wrapper<T> orNew()
```
    使用OR换行，并添加一个带()的新的条件
    
    eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) OR (statu=1)
    
    返回:
    this
  - orNew
```
public Wrapper<T> orNew(boolean condition,
               String sqlOr,
               Object... params)
```
    使用OR换行，并添加一个带()的新的条件
    
    eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) OR (statu=1)
    
    参数:
    condition - 拼接的前置条件
    sqlOr - AND 条件语句
    params - 参数值
    
    返回:
    this
  - orNew
```
public Wrapper<T> orNew(String sqlOr,
               Object... params)
```
    使用OR换行，并添加一个带()的新的条件
    
    eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 输出： WHERE (name='zhangsan' AND id=11) OR (statu=1)
    
    参数:
    sqlOr - AND 条件语句
    params - 参数值
    
    返回:
    this
  - groupBy
```
public Wrapper<T> groupBy(boolean condition,
                 String columns)
```
    SQL中groupBy关键字跟的条件语句
    
    eg: ew.where("name='zhangsan'").groupBy("id,name")
    
    参数:
    condition - 拼接的前置条件
    columns - SQL 中的 Group by 语句，无需输入 Group By 关键字
    
    返回:
    this
  - groupBy
```
public Wrapper<T> groupBy(String columns)
```
    SQL中groupBy关键字跟的条件语句
    
    eg: ew.where("name='zhangsan'").groupBy("id,name")
    
    参数:
    columns - SQL 中的 Group by 语句，无需输入 Group By 关键字
    
    返回:
    this
  - having
```
public Wrapper<T> having(boolean condition,
                String sqlHaving,
                Object... params)
```
    SQL中having关键字跟的条件语句
    
    eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null")
    
    参数:
    condition - 拼接的前置条件
    sqlHaving - having关键字后面跟随的语句
    params - 参数集
    
    返回:
    EntityWrapper
  - having
```
public Wrapper<T> having(String sqlHaving,
                Object... params)
```
    SQL中having关键字跟的条件语句
    
    eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null")
    
    参数:
    sqlHaving - having关键字后面跟随的语句
    params - 参数集
    
    返回:
    EntityWrapper
  - orderBy
```
public Wrapper<T> orderBy(boolean condition,
                 String columns)
```
    SQL中orderby关键字跟的条件语句
    
    eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null" ).orderBy("id,name")
    
    参数:
    condition - 拼接的前置条件
    columns - SQL 中的 order by 语句，无需输入 Order By 关键字
    
    返回:
    this
  - orderBy
```
public Wrapper<T> orderBy(String columns)
```
    SQL中orderby关键字跟的条件语句
    
    eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null" ).orderBy("id,name")
    
    参数:
    columns - SQL 中的 order by 语句，无需输入 Order By 关键字
    
    返回:
    this
  - orderBy
```
public Wrapper<T> orderBy(boolean condition,
                 String columns,
                 boolean isAsc)
```
    SQL中orderby关键字跟的条件语句，可根据变更动态排序
    
    参数:
    condition - 拼接的前置条件
    columns - SQL 中的 order by 语句，无需输入 Order By 关键字
    isAsc - 是否为升序
    
    返回:
    this
  - orderBy
```
public Wrapper<T> orderBy(String columns,
                 boolean isAsc)
```
    SQL中orderby关键字跟的条件语句，可根据变更动态排序
    
    参数:
    columns - SQL 中的 order by 语句，无需输入 Order By 关键字
    isAsc - 是否为升序
    
    返回:
    this
  - like
```
public Wrapper<T> like(boolean condition,
              String column,
              String value)
```
    LIKE条件语句，value中无需前后%
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 匹配值
    
    返回:
    this
  - like
```
public Wrapper<T> like(String column,
              String value)
```
    LIKE条件语句，value中无需前后%
    
    参数:
    column - 字段名称
    value - 匹配值
    
    返回:
    this
  - notLike
```
public Wrapper<T> notLike(boolean condition,
                 String column,
                 String value)
```
    NOT LIKE条件语句，value中无需前后%
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 匹配值
    
    返回:
    this
  - notLike
```
public Wrapper<T> notLike(String column,
                 String value)
```
    NOT LIKE条件语句，value中无需前后%
    
    参数:
    column - 字段名称
    value - 匹配值
    
    返回:
    this
  - like
```
public Wrapper<T> like(boolean condition,
              String column,
              String value,
              SqlLike type)
```
    LIKE条件语句，value中无需前后%
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 匹配值
    type -
    
    返回:
    this
  - like
```
public Wrapper<T> like(String column,
              String value,
              SqlLike type)
```
    LIKE条件语句，value中无需前后%
    
    参数:
    column - 字段名称
    value - 匹配值
    type -
    
    返回:
    this
  - notLike
```
public Wrapper<T> notLike(boolean condition,
                 String column,
                 String value,
                 SqlLike type)
```
    NOT LIKE条件语句，value中无需前后%
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 匹配值
    type -
    
    返回:
    this
  - notLike
```
public Wrapper<T> notLike(String column,
                 String value,
                 SqlLike type)
```
    NOT LIKE条件语句，value中无需前后%
    
    参数:
    column - 字段名称
    value - 匹配值
    type -
    
    返回:
    this
  - isNotNull
```
public Wrapper<T> isNotNull(boolean condition,
                   String columns)
```
    is not null 条件
    
    参数:
    condition - 拼接的前置条件
    columns - 字段名称。多个字段以逗号分隔。
    
    返回:
    this
  - isNotNull
```
public Wrapper<T> isNotNull(String columns)
```
    is not null 条件
    
    参数:
    columns - 字段名称。多个字段以逗号分隔。
    
    返回:
    this
  - isNull
```
public Wrapper<T> isNull(boolean condition,
                String columns)
```
    is not null 条件
    
    参数:
    condition - 拼接的前置条件
    columns - 字段名称。多个字段以逗号分隔。
    
    返回:
    this
  - isNull
```
public Wrapper<T> isNull(String columns)
```
    is not null 条件
    
    参数:
    columns - 字段名称。多个字段以逗号分隔。
    
    返回:
    this
  - exists
```
public Wrapper<T> exists(boolean condition,
                String value)
```
    EXISTS 条件语句，目前适配mysql及oracle
    
    参数:
    condition - 拼接的前置条件
    value - 匹配值
    
    返回:
    this
  - exists
```
public Wrapper<T> exists(String value)
```
    EXISTS 条件语句，目前适配mysql及oracle
    
    参数:
    value - 匹配值
    
    返回:
    this
  - notExists
```
public Wrapper<T> notExists(boolean condition,
                   String value)
```
    NOT EXISTS条件语句
    
    参数:
    condition - 拼接的前置条件
    value - 匹配值
    
    返回:
    this
  - notExists
```
public Wrapper<T> notExists(String value)
```
    NOT EXISTS条件语句
    
    参数:
    value - 匹配值
    
    返回:
    this
  - in
```
public Wrapper<T> in(boolean condition,
            String column,
            String value)
```
    IN 条件语句，目前适配mysql及oracle
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 逗号拼接的字符串
    
    返回:
    this
  - in
```
public Wrapper<T> in(String column,
            String value)
```
    IN 条件语句，目前适配mysql及oracle
    
    参数:
    column - 字段名称
    value - 逗号拼接的字符串
    
    返回:
    this
  - notIn
```
public Wrapper<T> notIn(boolean condition,
               String column,
               String value)
```
    NOT IN条件语句
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 逗号拼接的字符串
    
    返回:
    this
  - notIn
```
public Wrapper<T> notIn(String column,
               String value)
```
    NOT IN条件语句
    
    参数:
    column - 字段名称
    value - 逗号拼接的字符串
    
    返回:
    this
  - in
```
public Wrapper<T> in(boolean condition,
            String column,
            Collection<?> value)
```
    IN 条件语句，目前适配mysql及oracle
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 匹配值 List集合
    
    返回:
    this
  - in
```
public Wrapper<T> in(String column,
            Collection<?> value)
```
    IN 条件语句，目前适配mysql及oracle
    
    参数:
    column - 字段名称
    value - 匹配值 List集合
    
    返回:
    this
  - notIn
```
public Wrapper<T> notIn(boolean condition,
               String column,
               Collection<?> value)
```
    NOT IN 条件语句，目前适配mysql及oracle
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 匹配值 List集合
    
    返回:
    this
  - notIn
```
public Wrapper<T> notIn(String column,
               Collection<?> value)
```
    NOT IN 条件语句，目前适配mysql及oracle
    
    参数:
    column - 字段名称
    value - 匹配值 List集合
    
    返回:
    this
  - in
```
public Wrapper<T> in(boolean condition,
            String column,
            Object[] value)
```
    IN 条件语句，目前适配mysql及oracle
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 匹配值 object数组
    
    返回:
    this
  - in
```
public Wrapper<T> in(String column,
            Object[] value)
```
    IN 条件语句，目前适配mysql及oracle
    
    参数:
    column - 字段名称
    value - 匹配值 object数组
    
    返回:
    this
  - notIn
```
public Wrapper<T> notIn(boolean condition,
               String column,
               Object... value)
```
    NOT IN 条件语句，目前适配mysql及oracle
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    value - 匹配值 object数组
    
    返回:
    this
  - notIn
```
public Wrapper<T> notIn(String column,
               Object... value)
```
    NOT IN 条件语句，目前适配mysql及oracle
    
    参数:
    column - 字段名称
    value - 匹配值 object数组
    
    返回:
    this
  - between
```
public Wrapper<T> between(boolean condition,
                 String column,
                 Object val1,
                 Object val2)
```
    betwwee 条件语句
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    val1 -
    val2 -
    
    返回:
    this
  - between
```
public Wrapper<T> between(String column,
                 Object val1,
                 Object val2)
```
    betwwee 条件语句
    
    参数:
    column - 字段名称
    val1 -
    val2 -
    
    返回:
    this
  - notBetween
```
public Wrapper<T> notBetween(boolean condition,
                    String column,
                    Object val1,
                    Object val2)
```
    NOT betwwee 条件语句
    
    参数:
    condition - 拼接的前置条件
    column - 字段名称
    val1 -
    val2 -
    
    返回:
    this
  - notBetween
```
public Wrapper<T> notBetween(String column,
                    Object val1,
                    Object val2)
```
    NOT betwwee 条件语句
    
    参数:
    column - 字段名称
    val1 -
    val2 -
    
    返回:
    this
  - addFilter
```
public Wrapper<T> addFilter(String sqlWhere,
                   Object... params)
```
    为了兼容之前的版本,可使用where()或and()替代
    
    参数:
    sqlWhere - where sql部分
    params - 参数集
    
    返回:
    this
  - addFilterIfNeed
```
public Wrapper<T> addFilterIfNeed(boolean need,
                         String sqlWhere,
                         Object... params)
```
    根据判断条件来添加条件语句部分使用 andIf() 替代
    
    eg: ew.filterIfNeed(false,"name='zhangsan'").where("name='zhangsan'") .filterIfNeed(true,"id={0}",22)
    输出: WHERE (name='zhangsan' AND id=22)
    
    参数:
    need - 是否需要添加该条件
    sqlWhere - 条件语句
    params - 参数集
    
    返回:
    this
  - stripSqlInjection
```
protected String stripSqlInjection(String value)
```
    SQL注入内容剥离
    
    参数:
    value - 待处理内容
    
    返回:
    this
  - formatSql
```
protected String formatSql(String sqlStr,
               Object... params)
```
    格式化SQL
    
    参数:
    sqlStr - SQL语句部分
    params - 参数集
    
    返回:
    this
  - formatSqlIfNeed
```
protected String formatSqlIfNeed(boolean need,
                     String sqlStr,
                     Object... params)
```
    根据需要格式化SQL
    
    Format SQL for methods: EntityWrapper.where/and/or...("name={0}", value); ALL the {i} will be replaced with #{MPGENVALi}
    
    ew.where("sample_name={0}", "haha").and("sample_age >{0} and sample_age<{1}", 18, 30) TO sample_name=#{MPGENVAL1} and sample_age>#{MPGENVAL2} and sample_age<#{MPGENVAL3}
    
    参数:
    need - 是否需要格式化
    sqlStr - SQL语句部分
    params - 参数集
    
    返回:
    this
  - isWhere
```
public Wrapper<T> isWhere(Boolean bool)
```
    自定义是否输出sql开头为 `WHERE` OR `AND` OR `OR`
    
    参数:
    bool -
    
    返回:
    this
  - last
```
public Wrapper<T> last(String limit)
```
    手动把sql拼接到最后(有sql注入的风险,请谨慎使用)
    
    参数:
    limit -
    
    返回:
    this
  - getParamNameValuePairs
```
public Map<String,Object> getParamNameValuePairs()
```
    Fix issue 200.
    
    返回:
    从以下版本开始:
    
    2.0.3
  - getParamAlias
```
public String getParamAlias()
```
  - setParamAlias
```
public Wrapper<T> setParamAlias(String paramAlias)
```
    参数别名设置，初始化时优先设置该值、重复设置异常
    
    参数:
    paramAlias - 参数别名
    
    返回:

类 Wrapper<T>

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

sql

paramAlias

sqlSelect

isWhere

AND_OR

构造器详细资料

Wrapper

方法详细资料

getEntity

isEmptyOfWhere

isNotEmptyOfWhere

getSqlSelect

setSqlSelect

setSqlSelect

setSqlSelect

setSqlSelect

getSqlSegment

toString

originalSql

where

where

eq

eq

ne

ne

allEq

allEq

gt

gt

ge

ge

lt

lt

le

le

and

and

andNew

andNew

andNew

and

or

or

or

orNew

orNew

orNew

groupBy

groupBy

having

having

orderBy

orderBy

orderBy

orderBy

like

like

notLike

notLike

like

like

notLike

notLike

isNotNull

isNotNull

isNull

isNull

exists

exists

notExists

notExists

in

in

notIn