@Override public boolean evaluate(InvocationContext context) { Object left = ((AbstractExpression) jjtGetChild(0)).value(context); Object right = ((AbstractExpression) jjtGetChild(1)).value(context); if (left instanceof Number && right instanceof Number) { return MathUtils.compare((Number) left, (Number) right) != 0; } // 都不为null,一个是另一个的子类,则使用equals操作 if (left != null && right != null && (left.getClass().isAssignableFrom(right.getClass()) || right.getClass().isAssignableFrom(left.getClass()))) { return !left.equals(right); } if (left == null && right == null) { // 都为null return false; } else if (left == null || right == null) { // 一个为null,一个不为null return true; } else { // 都不为null left = left.toString(); right = right.toString(); return !left.equals(right); } }
/** * Calculates the value of the logical expression * * <p>arg1 == arg2 * * <p>All class types are supported. Uses equals() to determine equivalence. This should work as * we represent with the types we already support, and anything else that implements equals() to * mean more than identical references. * * @param context internal context used to evaluate the LHS and RHS * @return true if equivalent, false if not equivalent, false if not compatible arguments, or * false if either LHS or RHS is null * @throws MethodInvocationException */ public boolean evaluate(InternalContextAdapter context) throws MethodInvocationException { Object left = jjtGetChild(0).value(context); Object right = jjtGetChild(1).value(context); /* * convert to Number if applicable */ if (left instanceof TemplateNumber) { left = ((TemplateNumber) left).getAsNumber(); } if (right instanceof TemplateNumber) { right = ((TemplateNumber) right).getAsNumber(); } /* * If comparing Numbers we do not care about the Class. */ if (left instanceof Number && right instanceof Number) { return MathUtils.compare((Number) left, (Number) right) == 0; } /** * if both are not null, then assume that if one class is a subclass of the other that we should * use the equals operator */ if (left != null && right != null && (left.getClass().isAssignableFrom(right.getClass()) || right.getClass().isAssignableFrom(left.getClass()))) { return left.equals(right); } /* * Ok, time to compare string values */ left = (left == null) ? null : left.toString(); right = (right == null) ? null : right.toString(); if (left == null && right == null) { if (log.isDebugEnabled()) { log.debug( "Both right (" + getLiteral(false) + " and left " + getLiteral(true) + " sides of '==' operation returned null." + "If references, they may not be in the context." + getLocation(context)); } return true; } else if (left == null || right == null) { if (log.isDebugEnabled()) { log.debug( (left == null ? "Left" : "Right") + " side (" + getLiteral(left == null) + ") of '==' operation has null value. If it is a " + "reference, it may not be in the context or its " + "toString() returned null. " + getLocation(context)); } return false; } else { return left.equals(right); } }