Java PathBuilder类代码示例

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
private Expression<?> buildOrderPropertyPathFrom(JoinerQuery<?, ?> joinerQuery, Sort.Order order) {
    PathBuilder<?> builder = new PathBuilder<Object>(joinerQuery.getFrom().getType(), joinerQuery.getFrom().toString());

    PropertyPath path = PropertyPath.from(order.getProperty(), builder.getType());
    Expression<?> sortPropertyExpression = builder;

    while (path != null) {

        if (!path.hasNext() && order.isIgnoreCase()) {
            // if order is ignore-case we have to treat the last path segment as a String.
            sortPropertyExpression = Expressions.stringPath((Path<?>) sortPropertyExpression, path.getSegment()).lower();
        } else {
            sortPropertyExpression = Expressions.path(path.getType(), (Path<?>) sortPropertyExpression, path.getSegment());
        }

        path = path.next();
    }

    return sortPropertyExpression;
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * Return an expression for {@code entityPath.fieldName} (for Booleans) with
 * the {@code operator} or "equal" by default.
 * <p/>
 * Expr: {@code entityPath.fieldName eq searchObj}
 * 
 * @param entityPath
 * @param fieldName
 * @param searchObj
 * @param operator
 * @return
 */
public static <T> BooleanExpression createBooleanExpression(
        PathBuilder<T> entityPath, String fieldName, Object searchObj,
        String operator) {
    Boolean value = BooleanUtils.toBooleanObject((String) searchObj);
    if (value != null) {
        if (StringUtils.equalsIgnoreCase(operator, OPERATOR_GOE)) {
            return entityPath.getBoolean(fieldName).goe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "gt")) {
            return entityPath.getBoolean(fieldName).gt(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, OPERATOR_LOE)) {
            return entityPath.getBoolean(fieldName).loe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "lt")) {
            return entityPath.getBoolean(fieldName).lt(value);
        }
    }
    return entityPath.get(fieldName).eq(searchObj);
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * Return an expression for {@code entityPath.fieldName} (for Strings) with
 * the {@code operator} or "equal" by default.
 * <p/>
 * Expr: {@code entityPath.fieldName eq searchObj}
 * 
 * @param entityPath
 * @param fieldName
 * @param searchObj
 * @param operator
 * @return
 */
public static <T> BooleanExpression createStringExpression(
        PathBuilder<T> entityPath, String fieldName, Object searchObj,
        String operator) {
    if (StringUtils.equalsIgnoreCase(operator, OPERATOR_GOE)) {
        return entityPath.getString(fieldName).goe((String) searchObj);
    }
    else if (StringUtils.equalsIgnoreCase(operator, "gt")) {
        return entityPath.getString(fieldName).gt((String) searchObj);
    }
    else if (StringUtils.equalsIgnoreCase(operator, OPERATOR_LOE)) {
        return entityPath.getString(fieldName).loe((String) searchObj);
    }
    else if (StringUtils.equalsIgnoreCase(operator, "lt")) {
        return entityPath.getString(fieldName).lt((String) searchObj);
    }
    else if (StringUtils.equalsIgnoreCase(operator, "like")) {
        return entityPath.getString(fieldName).like((String) searchObj);
    }
    return entityPath.get(fieldName).eq(searchObj);
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * Obtains the class type of the property named as {@code fieldName} of the
 * entity.
 * 
 * @param fieldName the field name.
 * @param entity the entity with a property named as {@code fieldName}
 * @return the class type
 */
public static <T> Class<?> getFieldType1(String fieldName,
        PathBuilder<T> entity) {
    Class<?> entityType = entity.getType();
    String fieldNameToFindType = fieldName;

    // Makes the array of classes to find fieldName agains them
    Class<?>[] classArray = ArrayUtils.<Class<?>> toArray(entityType);
    if (fieldName.contains(SEPARATOR_FIELDS)) {
        String[] fieldNameSplitted = StringUtils.split(fieldName,
                SEPARATOR_FIELDS);
        for (int i = 0; i < fieldNameSplitted.length - 1; i++) {
            Class<?> fieldType = BeanUtils.findPropertyType(
                    fieldNameSplitted[i],
                    ArrayUtils.<Class<?>> toArray(entityType));
            classArray = ArrayUtils.add(classArray, fieldType);
            entityType = fieldType;
        }
        fieldNameToFindType = fieldNameSplitted[fieldNameSplitted.length - 1];
    }

    return BeanUtils.findPropertyType(fieldNameToFindType, classArray);
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * Obtains the descriptor of the filtered field
 * 
 * @param fieldName
 * @param entity
 * @return
 */
public static <T> TypeDescriptor getTypeDescriptor(String fieldName,
        PathBuilder<T> entity) {
    Class<?> entityType = entity.getType();
    if (entityType == Object.class) {
        // Remove from path the root "entity" alias
        String fromRootPath = entity.toString().replaceFirst("^[^.]+[.]",
                "");
        TypeDescriptor fromRoot = getTypeDescriptor(fromRootPath, entity
                .getRoot().getType());
        if (fromRoot == null) {
            return null;
        }
        entityType = fromRoot.getType();
    }
    return getTypeDescriptor(fieldName, entityType);
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public <T> BooleanExpression createBooleanExpression(
        PathBuilder<T> entityPath, String fieldName, Object searchObj,
        String operator) {
    Boolean value = BooleanUtils.toBooleanObject((String) searchObj);
    if (value != null) {
        if (StringUtils.equalsIgnoreCase(operator, OPERATOR_GOE)) {
            return entityPath.getBoolean(fieldName).goe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "gt")) {
            return entityPath.getBoolean(fieldName).gt(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, OPERATOR_LOE)) {
            return entityPath.getBoolean(fieldName).loe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "lt")) {
            return entityPath.getBoolean(fieldName).lt(value);
        }
    }
    return entityPath.get(fieldName).eq(searchObj);
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public <T> BooleanExpression createStringExpression(
        PathBuilder<T> entityPath, String fieldName, Object searchObj,
        String operator) {
    if (StringUtils.equalsIgnoreCase(operator, OPERATOR_GOE)) {
        return entityPath.getString(fieldName).goe((String) searchObj);
    }
    else if (StringUtils.equalsIgnoreCase(operator, "gt")) {
        return entityPath.getString(fieldName).gt((String) searchObj);
    }
    else if (StringUtils.equalsIgnoreCase(operator, OPERATOR_LOE)) {
        return entityPath.getString(fieldName).loe((String) searchObj);
    }
    else if (StringUtils.equalsIgnoreCase(operator, "lt")) {
        return entityPath.getString(fieldName).lt((String) searchObj);
    }
    else if (StringUtils.equalsIgnoreCase(operator, "like")) {
        return entityPath.getString(fieldName).like((String) searchObj);
    }
    return entityPath.get(fieldName).eq(searchObj);
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public <T, E extends Comparable<?>> OrderSpecifier<?> createOrderSpecifier(
        PathBuilder<T> entityPath, String fieldName, Class<E> fieldType,
        Order order) {
    OrderSpecifier<?> orderBy = null;

    // Get the OrderSpecifier
    if (order == Order.ASC) {
        orderBy = entityPath.getComparable(fieldName, fieldType).asc();
    }
    else if (order == Order.DESC) {
        orderBy = entityPath.getComparable(fieldName, fieldType).desc();
    }
    return orderBy;
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public <T> TypeDescriptor getTypeDescriptor(String fieldName,
        PathBuilder<T> entity) {
    Class<?> entityType = entity.getType();
    if (entityType == Object.class) {
        // Remove from path the root "entity" alias
        String fromRootPath = entity.toString().replaceFirst("^[^.]+[.]",
                "");
        TypeDescriptor fromRoot = getTypeDescriptor(fromRootPath, entity
                .getRoot().getType());
        if (fromRoot == null) {
            return null;
        }
        entityType = fromRoot.getType();
    }
    return getTypeDescriptor(fieldName, entityType);
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public <T, E extends Comparable<?>> SearchResults<T> findByCriteria(
        Class<T> entityClass,
        Map<String, List<String>> filterByAssociations,
        Map<String, List<String>> orderByAssociations,
        DatatablesCriterias datatablesCriterias,
        BooleanBuilder basePredicate, boolean distinct)
        throws IllegalArgumentException {

    Assert.notNull(entityClass);

    // Query DSL builder
    PathBuilder<T> entity = new PathBuilder<T>(entityClass, "entity");

    return findByCriteria(entity, filterByAssociations,
            orderByAssociations, datatablesCriterias, basePredicate,
            distinct, null);
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
public CustomQuerydslMongoRepositoryImpl(MongoEntityInformation<T, ID> entityInformation, MongoOperations mongoOperations, EntityPathResolver resolver) {
    super(entityInformation, mongoOperations, resolver);
    this.path = resolver.createPath(entityInformation.getJavaType());
    this.pathBuilder = new PathBuilder<T>(path.getType(), path.getMetadata());
    this.mongoOperations = mongoOperations;
    this.entityInformation = entityInformation;
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * Method to create Bounding box intersects expression
 * 
 * @param entityPath
 * @param boundingBox
 * @param fieldName
 * @return
 */
public static <T> Predicate createIntersectsExpression(
        PathBuilder<T> entityPath, String fieldName, Geometry boundingBox) {
    JTSPolygonPath<Polygon> polygonPath = new JTSPolygonPath<Polygon>(
            entityPath, fieldName);
    BooleanExpression intersectsExpression = polygonPath
            .intersects(boundingBox);
    return intersectsExpression;
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * Creates a WHERE clause by the intersection of the given search-arguments
 * 
 * @param entity Entity {@link PathBuilder}. It represents the entity for
 *        class generation and alias-usage for path generation.
 *        <p/>
 *        Example: To retrieve a {@code Customer} with the first name 'Bob'
 *        entity must be a {@link PathBuilder} created for {@code Customer}
 *        class and searchArgs must contain the entry
 *        {@code 'firstName':'Bob'}
 * @param searchArgs Search arguments to be used to create the WHERE clause.
 *        It can contain {@code _operator_} entries for each field that want
 *        to use its own operator. By default {@code EQUALS} operator is
 *        used.
 *        <p/>
 *        Operator entry example: {@code _operator_weight = LT} the
 *        expression for {@code weight} field will do a less-than value
 *        comparison
 * @param conversionService required to transform values
 * @return the WHERE clause
 */
public static <T> BooleanBuilder createPredicateByAnd(
        PathBuilder<T> entity, Map<String, Object> searchArgs,
        ConversionService conversionService) {

    // Using BooleanBuilder, a cascading builder for
    // Predicate expressions
    BooleanBuilder predicate = new BooleanBuilder();
    if (searchArgs == null || searchArgs.isEmpty()) {
        return predicate;
    }

    // Build the predicate
    for (Entry<String, Object> entry : searchArgs.entrySet()) {
        String key = entry.getKey();
        // can
        // contain "_operator_"
        // entries for each
        // field
        Object valueToSearch = entry.getValue();
        String operator = (String) searchArgs.get(OPERATOR_PREFIX
                .concat(key));

        // If value to search is a collection, creates a predicate for
        // each object of the collection
        if (valueToSearch instanceof Collection) {
            @SuppressWarnings("unchecked")
            Collection<Object> valueColl = (Collection<Object>) valueToSearch;
            for (Object valueObj : valueColl) {
                predicate.and(createObjectExpression(entity, key, valueObj,
                        operator, conversionService));
            }
        }
        else {
            predicate.and(createObjectExpression(entity, key,
                    valueToSearch, operator, conversionService));
        }
    }
    return predicate;
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * Utility for constructing where clause expressions.
 * 
 * @param entityPath Full path to entity and associations. For example:
 *        {@code Pet} , {@code Pet.owner}
 * @param fieldName Property name in the given entity path. For example:
 *        {@code name} in {@code Pet} entity, {@code firstName} in
 *        {@code Pet.owner} entity.
 * @param fieldType Property value {@code Class}
 * @param searchStr the value to find, may be null
 * @return Predicate
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public static <T> Predicate createExpression(PathBuilder<T> entityPath,
        String fieldName, String searchStr,
        ConversionService conversionService) {

    TypeDescriptor descriptor = getTypeDescriptor(fieldName, entityPath);
    if (descriptor == null) {
        throw new IllegalArgumentException(String.format(
                "Can't found field '%s' on entity '%s'", fieldName,
                entityPath.getType()));
    }
    Class<?> fieldType = descriptor.getType();

    // Check for field type in order to delegate in custom-by-type
    // create expression method
    if (String.class == fieldType) {
        return createStringLikeExpression(entityPath, fieldName, searchStr);
    }
    else if (Boolean.class == fieldType || boolean.class == fieldType) {
        return createBooleanExpression(entityPath, fieldName, searchStr);
    }
    else if (Number.class.isAssignableFrom(fieldType)
            || NUMBER_PRIMITIVES.contains(fieldType)) {
        return createNumberExpressionGenerics(entityPath, fieldName,
                fieldType, descriptor, searchStr, conversionService);
    }
    else if (Date.class.isAssignableFrom(fieldType)
            || Calendar.class.isAssignableFrom(fieldType)) {
        BooleanExpression expression = createDateExpression(entityPath,
                fieldName, (Class<Date>) fieldType, searchStr);
        return expression;
    }

    else if (fieldType.isEnum()) {
        return createEnumExpression(entityPath, fieldName, searchStr,
                (Class<? extends Enum>) fieldType);
    }
    return null;
}
 

import com.mysema.query.types.path.PathBuilder; //导入依赖的package包/类
/**
 * Return an expression for {@code entityPath.fieldName} (for Dates) with
 * the {@code operator} or "equal" by default.
 * <p/>
 * Expr: {@code entityPath.fieldName eq searchObj}
 * 
 * @param entityPath
 * @param fieldName
 * @param searchObj
 * @param operator
 * @param fieldType
 * @return
 */
@SuppressWarnings("unchecked")
public static <T> BooleanExpression createDateExpression(
        PathBuilder<T> entityPath, String fieldName, Object searchObj,
        String operator, Class<?> fieldType) {
    DatePath<Date> dateExpression = entityPath.getDate(fieldName,
            (Class<Date>) fieldType);
    try {
        Date value = DateUtils.parseDateStrictly((String) searchObj,
                FULL_DATE_PATTERNS);
        if (StringUtils.equalsIgnoreCase(operator, OPERATOR_GOE)) {
            return dateExpression.goe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "gt")
                || StringUtils.equalsIgnoreCase(operator, "after")) {
            return dateExpression.gt(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, OPERATOR_LOE)) {
            return dateExpression.loe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "lt")
                || StringUtils.equalsIgnoreCase(operator, "before")) {
            return dateExpression.lt(value);
        }
    }
    catch (ParseException e) {
        return entityPath.get(fieldName).eq(searchObj);
    }
    return entityPath.get(fieldName).eq(searchObj);
}