【开端】一个看的奇奇怪怪类的解析

一、绪论

Java中正常的类语法如下：

public class TmpMUser   implements Serializable{

@Data
public class TmpMUser   implements Serializable{
	/**
	 * 序列
	 */
	private static final long serialVersionUID = 1L;
	
 
    /**
     * 
     */
    private String rowId;
 
    /**
     * 
     */
    private String cellphone;
     
    /**
     * 
     */
    private String phone;
    
    /**
     * 
     */
    private String origPhone;
    
    /**
     * 
     */
    private String cellphoneSha;
    
    
     
 
}

看一下复杂的一个类

public class QueryWrapper<T> extends AbstractWrapper<T, String, QueryWrapper<T>>
    implements Query<QueryWrapper<T>, T, String> {

@SuppressWarnings("serial")
public class QueryWrapper<T> extends AbstractWrapper<T, String, QueryWrapper<T>>
    implements Query<QueryWrapper<T>, T, String> {

    /**
     * 查询字段
     */
    private final SharedString sqlSelect = new SharedString();

    public QueryWrapper() {
        this(null);
    }

    public QueryWrapper(T entity) {
        super.setEntity(entity);
        super.initNeed();
    }

    public QueryWrapper(T entity, String... columns) {
        super.setEntity(entity);
        super.initNeed();
        this.select(columns);
    }

    /**
     * 非对外公开的构造方法,只用于生产嵌套 sql
     *
     * @param entityClass 本不应该需要的
     */
    private QueryWrapper(T entity, Class<T> entityClass, AtomicInteger paramNameSeq,
                         Map<String, Object> paramNameValuePairs, MergeSegments mergeSegments, SharedString paramAlias,
                         SharedString lastSql, SharedString sqlComment, SharedString sqlFirst) {
        super.setEntity(entity);
        super.setEntityClass(entityClass);
        this.paramNameSeq = paramNameSeq;
        this.paramNameValuePairs = paramNameValuePairs;
        this.expression = mergeSegments;
        this.paramAlias = paramAlias;
        this.lastSql = lastSql;
        this.sqlComment = sqlComment;
        this.sqlFirst = sqlFirst;
    }

    @Override
    public QueryWrapper<T> select(String... columns) {
        if (ArrayUtils.isNotEmpty(columns)) {
            this.sqlSelect.setStringValue(String.join(StringPool.COMMA, columns));
        }
        return typedThis;
    }

    @Override
    public QueryWrapper<T> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) {
        super.setEntityClass(entityClass);
        this.sqlSelect.setStringValue(TableInfoHelper.getTableInfo(getEntityClass()).chooseSelect(predicate));
        return typedThis;
    }

    @Override
    public String getSqlSelect() {
        return sqlSelect.getStringValue();
    }

    @Override
    protected String columnSqlInjectFilter(String column) {
        return StringUtils.sqlInjectionReplaceBlank(column);
    }

    /**
     * 返回一个支持 lambda 函数写法的 wrapper
     */
    public LambdaQueryWrapper<T> lambda() {
        return new LambdaQueryWrapper<>(getEntity(), getEntityClass(), sqlSelect, paramNameSeq, paramNameValuePairs,
            expression, paramAlias, lastSql, sqlComment, sqlFirst);
    }

    /**
     * 用于生成嵌套 sql
     * <p>
     * 故 sqlSelect 不向下传递
     * </p>
     */
    @Override
    protected QueryWrapper<T> instance() {
        return new QueryWrapper<>(getEntity(), getEntityClass(), paramNameSeq, paramNameValuePairs, new MergeSegments(),
            paramAlias, SharedString.emptyString(), SharedString.emptyString(), SharedString.emptyString());
    }

    @Override
    public void clear() {
        super.clear();
        sqlSelect.toNull();
    }
}

二、一个看的奇奇怪怪类的解析

那么这个public class QueryWrapper<T> extends AbstractWrapper<T, String, QueryWrapper<T>>
    implements Query<QueryWrapper<T>, T, String> {

的每一个单词表示什么

看上去和我们平时写的类有点不同或者他看起来更加复杂一点。。

public： 权限修饰符，表示 这个类是可以被实现，可以被继承的，

class ：用来修饰这是一个类

QueryWrapper<T>： 类名本身，但是它多了一个<T>是什么意思呢

定义了一个公开的类QueryWrapper，它是一个泛型类，泛型参数为T。这里的T代表了你想要查询的实体类的类型，例如User、Product等。

extends：表示继承一个父类。

AbstractWrapper<T, String, QueryWrapper<T>> 这个也是个奇奇怪怪得到东西

• T：实体类类型，与QueryWrapper的泛型参数相同。
• String：表示数据库字段的类型。在这里，字段名被假定为String类型，因为大多数数据库中的列名都是字符串。
• QueryWrapper<T>：表示当前类自己，这是一个自引用的泛型参数，用于在父类中实现链式调用的支持。

implements：表示实现一个类

    implements Query<QueryWrapper<T>, T, String> 这又是一个起奇怪怪的东西，它有表示是什么

mplements Query<QueryWrapper<T>, T, String>：QueryWrapper类实现了Query接口，这是一个泛型接口，用于定义条件构造器的基本行为。这里的泛型参数分别为：

• QueryWrapper<T>：条件构造器自身的类型，用于链式调用。
• T：实体类类型。
• String：字段类型，同样假定为String。