Java PropertyAccessException.getMessage方法代码示例

import com.espertech.esper.client.PropertyAccessException; //导入方法依赖的package包/类
public DataFlowOpInitializeResult initialize(DataFlowOpInitializateContext context) throws Exception {
    EventType outputEventType = context.getOutputPorts().get(0) != null ? context.getOutputPorts().get(0).getOptionalDeclaredType().getEventType() : null;
    if (outputEventType == null) {
        throw new IllegalArgumentException("No event type provided for output, please provide an event type name");
    }
    if ((outputEventType.getPropertyNames().length != 1 || outputEventType.getPropertyDescriptors()[0].getPropertyType() != String.class) &&
            propertyNameLine == null) {
        throw new IllegalArgumentException("Expecting an output event type that has a single property that is of type string, or alternatively specify the 'propertyNameLine' parameter");
    }

    if (outputEventType instanceof ObjectArrayEventType && outputEventType.getPropertyDescriptors().length == 1) {
        lineProcessor = new LineProcessorObjectArray();
    } else {
        String propertyNameLineToUse = propertyNameLine;
        if (propertyNameLineToUse == null) {
            propertyNameLineToUse = outputEventType.getPropertyDescriptors()[0].getPropertyName();
        }
        if (!outputEventType.isProperty(propertyNameLineToUse)) {
            throw new EPException("Failed to find property name '" + propertyNameLineToUse + "' in type '" + outputEventType.getName() + "'");
        }

        Class propertyType;
        try {
            propertyType = outputEventType.getPropertyType(propertyNameLineToUse);
        } catch (PropertyAccessException ex) {
            throw new EPException("Invalid property name '" + propertyNameLineToUse + "': " + ex.getMessage(), ex);
        }
        if (propertyType != String.class) {
            throw new EPException("Invalid property type for property '" + propertyNameLineToUse + "', expected a property of type String");
        }

        Set<WriteablePropertyDescriptor> writeables = context.getStatementContext().getEventAdapterService().getWriteableProperties(outputEventType, false);
        List<WriteablePropertyDescriptor> writeableList = new ArrayList<WriteablePropertyDescriptor>();

        WriteablePropertyDescriptor writeableLine = EventTypeUtility.findWritable(propertyNameLineToUse, writeables);
        if (writeableLine == null) {
            throw new EPException("Failed to find writable property property '" + propertyNameLineToUse + "', is the property read-only?");
        }
        writeableList.add(writeableLine);

        if (propertyNameFile != null) {
            WriteablePropertyDescriptor writeableFile = EventTypeUtility.findWritable(propertyNameFile, writeables);
            if (writeableFile == null || writeableFile.getType() != String.class) {
                throw new EPException("Failed to find writable String-type property '" + propertyNameFile + "', is the property read-only?");
            }
            writeableList.add(writeableFile);
        }

        EventBeanManufacturer manufacturer;
        try {
            WriteablePropertyDescriptor[] writables = writeableList.toArray(new WriteablePropertyDescriptor[writeableList.size()]);
            manufacturer = context.getStatementContext().getEventAdapterService().getManufacturer(outputEventType, writables, context.getStatementContext().getEngineImportService(), false);
        } catch (EventBeanManufactureException e) {
            throw new EPException("Event type '" + outputEventType.getName() + "' cannot be written to: " + e.getMessage(), e);
        }

        lineProcessor = new LineProcessorGeneralPurpose(manufacturer);
    }

    if (context.getOutputPorts().size() == 2) {
        eofProcessor = getBeginEndProcessor(context, 1);
    } else if (context.getOutputPorts().size() == 3) {
        bofProcessor = getBeginEndProcessor(context, 1);
        eofProcessor = getBeginEndProcessor(context, 2);
    } else if (context.getOutputPorts().size() > 3) {
        throw new EPException("Operator only allows up to 3 output ports");
    }

    return null;
}
 

import com.espertech.esper.client.PropertyAccessException; //导入方法依赖的package包/类
public ExprNode validate(ExprValidationContext validationContext) throws ExprValidationException {
    // rewrite expression into a table-access expression
    if (validationContext.getStreamTypeService().hasTableTypes()) {
        ExprTableIdentNode tableIdentNode = validationContext.getTableService().getTableIdentNode(validationContext.getStreamTypeService(), unresolvedPropertyName, streamOrPropertyName);
        if (tableIdentNode != null) {
            return tableIdentNode;
        }
    }

    String unescapedPropertyName = PropertyParser.unescapeBacktickForProperty(unresolvedPropertyName);
    Pair<PropertyResolutionDescriptor, String> propertyInfoPair = ExprIdentNodeUtil.getTypeFromStream(validationContext.getStreamTypeService(), unescapedPropertyName, streamOrPropertyName, false);
    resolvedStreamName = propertyInfoPair.getSecond();
    int streamNum = propertyInfoPair.getFirst().getStreamNum();
    Class propertyType = JavaClassHelper.getBoxedType(propertyInfoPair.getFirst().getPropertyType());
    resolvedPropertyName = propertyInfoPair.getFirst().getPropertyName();
    EventType eventType = propertyInfoPair.getFirst().getStreamEventType();
    EventPropertyGetterSPI propertyGetter;
    try {
        propertyGetter = ((EventTypeSPI) eventType).getGetterSPI(resolvedPropertyName);
    } catch (PropertyAccessException ex) {
        throw new ExprValidationException("Property '" + unresolvedPropertyName + "' is not valid: " + ex.getMessage(), ex);
    }

    if (propertyGetter == null) {
        throw new ExprValidationException("Property getter returned was invalid for property '" + unresolvedPropertyName + "'");
    }

    Audit audit = AuditEnum.PROPERTY.getAudit(validationContext.getAnnotations());
    if (audit != null) {
        evaluator = new ExprIdentNodeEvaluatorLogging(streamNum, propertyGetter, propertyType, this, eventType, validationContext.getStreamTypeService().isOptionalStreams(), resolvedPropertyName, validationContext.getStatementName(), validationContext.getStreamTypeService().getEngineURIQualifier());
    } else {
        evaluator = new ExprIdentNodeEvaluatorImpl(streamNum, propertyGetter, propertyType, this, eventType, validationContext.getStreamTypeService().isOptionalStreams());
    }

    // if running in a context, take the property value from context
    if (validationContext.getContextDescriptor() != null && !validationContext.isFilterExpression()) {
        EventType fromType = validationContext.getStreamTypeService().getEventTypes()[streamNum];
        String contextPropertyName = validationContext.getContextDescriptor().getContextPropertyRegistry().getPartitionContextPropertyName(fromType, resolvedPropertyName);
        if (contextPropertyName != null) {
            EventTypeSPI contextType = (EventTypeSPI) validationContext.getContextDescriptor().getContextPropertyRegistry().getContextEventType();
            Class type = JavaClassHelper.getBoxedType(contextType.getPropertyType(contextPropertyName));
            evaluator = new ExprIdentNodeEvaluatorContext(streamNum, type, contextType.getGetterSPI(contextPropertyName));
        }
    }
    return null;
}