[Spring Framework Core] 4.3. Language Reference (2)

 

public abstract class StringUtils {

    public static String reverseString(String input) {
        StringBuilder backwards = new StringBuilder(input.length());
        for (int i = 0; i < input.length(); i++) {
            backwards.append(input.charAt(input.length() - 1 - i));
        }
        return backwards.toString();
    }
}

https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions-operators

Core Technologies

틀린 내용이 있다면 알려주세요 😇

 

 

---

4.3.7. Operators ~ 4.3.12. Bean References

 

SpEL 에는 아래 4가지의 연산자를 지원한다

• Relational Operators
• Logical Operators
• Mathematical Operators
• The Assignment Operator

 

Relational Operators

(equal, not equal, less than, less than or equal, greater than, and greater than or equal)

Number type 이 아닌 Comparable 을 구현하는 다른 유형에서도 작동한다 

 

// evaluates to true
boolean trueValue = parser.parseExpression("2 == 2").getValue(Boolean.class);

// evaluates to false
boolean falseValue = parser.parseExpression("2 < -5.0").getValue(Boolean.class);

// evaluates to true
boolean trueValue = parser.parseExpression("'black' < 'block'").getValue(Boolean.class);

// uses CustomValue:::compareTo
boolean trueValue = parser.parseExpression("new CustomValue(1) < new CustomValue(2)").getValue(Boolean.class);

 

* null 은 아무것도 아닌 것으로 처리가 된다 ( 0 으로 보지 않는다 )

결과적으로 다른 값들은 항상 null 보다 크다 ( X > null ) == true

하지만 이런 비교는 안하는게..

 

 

SpEL supports the instanceof and regular expression-based matches operator.

또한 matches 정규표현식도 지원한다

 

// evaluates to false
boolean falseValue = parser.parseExpression(
        "'xyz' instanceof T(Integer)").getValue(Boolean.class);

// evaluates to true
boolean trueValue = parser.parseExpression(
        "'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);

// evaluates to false
boolean falseValue = parser.parseExpression(
        "'5.0067' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);

 

 

원시 type 은 wrapper type에 바로 평가된다

1 instanceof T(int) == false

instanceof T(Integer) == true

 

 

• lt( <)
• gt( >)
• le( <=)
• ge( >=)
• eq( ==)
• ne( !=)
• div( /)
• mod( %)
• not( !).

 

Logical Operators

SpEL supports the following logical operators:

• and (&&)
• or (||)
• not (!)

// -- AND --

// evaluates to false
boolean falseValue = parser.parseExpression("true and false").getValue(Boolean.class);

// evaluates to true
String expression = "isMember('Nikola Tesla') and isMember('Mihajlo Pupin')";
boolean trueValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class);

// -- OR --

// evaluates to true
boolean trueValue = parser.parseExpression("true or false").getValue(Boolean.class);

// evaluates to true
String expression = "isMember('Nikola Tesla') or isMember('Albert Einstein')";
boolean trueValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class);

// -- NOT --

// evaluates to false
boolean falseValue = parser.parseExpression("!true").getValue(Boolean.class);

// -- AND and NOT --
String expression = "isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')";
boolean falseValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class);

 

Mathematical Operators

// Addition
int two = parser.parseExpression("1 + 1").getValue(Integer.class);  // 2

String testString = parser.parseExpression(
        "'test' + ' ' + 'string'").getValue(String.class);  // 'test string'

// Subtraction
int four = parser.parseExpression("1 - -3").getValue(Integer.class);  // 4

double d = parser.parseExpression("1000.00 - 1e4").getValue(Double.class);  // -9000

// Multiplication
int six = parser.parseExpression("-2 * -3").getValue(Integer.class);  // 6

double twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(Double.class);  // 24.0

// Division
int minusTwo = parser.parseExpression("6 / -3").getValue(Integer.class);  // -2

double one = parser.parseExpression("8.0 / 4e0 / 2").getValue(Double.class);  // 1.0

// Modulus
int three = parser.parseExpression("7 % 4").getValue(Integer.class);  // 3

int one = parser.parseExpression("8 / 5 % 2").getValue(Integer.class);  // 1

// Operator precedence
int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Integer.class);  // -21

 

 

The Assignment Operator

Inventor inventor = new Inventor();
EvaluationContext context = SimpleEvaluationContext.forReadWriteDataBinding().build();

parser.parseExpression("name").setValue(context, inventor, "Aleksandar Seovic");

// alternatively
String aleks = parser.parseExpression(
        "name = 'Aleksandar Seovic'").getValue(context, inventor, String.class);

= , setValue, getValue

 

 

4.3.8. Types

특수한 T 연산자를 사용하여 java.lang.Class(유형)의 인스턴스를 지정할 수 있다.

static method도 이 를 사용하여 호출된다.

StandardEvaluationContext는 TypeLocator를 사용하여 type을 찾고

StandardTypeLocator(대체 가능한 경우)는 java.lang 패키지를 이해하여 빌드된다

즉, java.lang 패키지 내의 유형에 대한 T() 참조는 정규화될 필요가 없지만 다른 모든 유형 참조는 정규화되어야 한다.

 

Class dateClass = parser.parseExpression("T(java.util.Date)").getValue(Class.class);

Class stringClass = parser.parseExpression("T(String)").getValue(Class.class);

boolean trueValue = parser.parseExpression(
        "T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR")
        .getValue(Boolean.class);

 

 

4.3.9. Constructors

 new를 사용하여 생성자를 호출한다.

java.lang 패키지에 있는 type(Integer, Float, String 등)을 제외한 모든 유형에 대해 완전한 클래스 이름을 사용해야 한다. 

 

Inventor einstein = p.parseExpression(
        "new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
        .getValue(Inventor.class);

// create new Inventor instance within the add() method of List
p.parseExpression(
        "Members.add(new org.spring.samples.spel.inventor.Inventor(
            'Albert Einstein', 'German'))").getValue(societyContext);

 

 

4.3.10. Variables

#valiableName 구문으로 식에서 변수 참조가 가능하다

valiables 는 EvaluationContext implementation에서 setVariable method를 사용하여 구현된다

 

Valid variable names must be composed of one or more of the following supported characters.

• letters: A to Z and a to z
• digits: 0 to 9
• underscore: _
• dollar sign: $

 

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");

EvaluationContext context = SimpleEvaluationContext.forReadWriteDataBinding().build();
context.setVariable("newName", "Mike Tesla");

parser.parseExpression("name = #newName").getValue(context, tesla);
System.out.println(tesla.getName())  // "Mike Tesla"

 

 

The #this and #root Variables

this 변수는 항상 정의되어 현재 평가하는 object를 참조한다 (비한정 참조)

식의 구성 요소가 어떻게 표현되느냐에 따라 달라질 수 있다.

 

root 변수는 항상 정의되어 context object를 참조하며, 항상 root를 참조한다

 

// create an array of integers
List<Integer> primes = new ArrayList<Integer>();
primes.addAll(Arrays.asList(2,3,5,7,11,13,17));

// create parser and set variable 'primes' as the array of integers
ExpressionParser parser = new SpelExpressionParser();
EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataAccess();
context.setVariable("primes", primes);

// all prime numbers > 10 from the list (using selection ?{...})
// evaluates to [11, 13, 17]
List<Integer> primesGreaterThanTen = (List<Integer>) parser.parseExpression(
        "#primes.?[#this>10]").getValue(context);

 

 

4.3.11. Functions

EvaluationContext 에 등록하여 사용자 정의 함수를 만들 수 있다

Method method = ...;

EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
context.setVariable("myFunction", method);

 

public abstract class StringUtils {

    public static String reverseString(String input) {
        StringBuilder backwards = new StringBuilder(input.length());
        for (int i = 0; i < input.length(); i++) {
            backwards.append(input.charAt(input.length() - 1 - i));
        }
        return backwards.toString();
    }
}

이렇게 만들어서 사용

 

ExpressionParser parser = new SpelExpressionParser();

EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
context.setVariable("reverseString",
        StringUtils.class.getDeclaredMethod("reverseString", String.class));

String helloWorldReversed = parser.parseExpression(
        "#reverseString('hello')").getValue(context, String.class);