7. Spring Expression Language ( SpEL )

 

Spring Expression Language ( SpEL )


- Spring Expression Language (SpEL) is a powerful and flexible expression language that is widely used in the Spring Framework for defining and evaluating expressions at runtime. 

- SpEL provides a standardized way to work with expressions in various parts of the Spring ecosystem, such as annotations, XML configuration, and programmatic configuration.

- Supports Parsing and executing expression with the help of @Value annotation.

- We can categorize elements in code, such as classes, variables, methods, constructors, objects, symbols, characters, numerics, operators, keywords, and special symbols, each serving a distinct purpose. These entities collectively contribute to the code's functionality by returning specific values.


Syntax :

- @Value("#{Expression}")



Here are some key features and concepts of Spring Expression Language:

1. Basic Syntax:

   SpEL expressions are enclosed in #{...} or ${...} syntax. The choice between #{} and ${} depends on the context in which the expression is used.


   Example:

   

   <bean id="myBean" class="com.example.MyBean">

       <property name="name" value="#{systemProperties['user.name']}"/>

   </bean>

   

2. Variables:

   SpEL supports the use of variables, which can be resolved at runtime. These variables can be provided through a `StandardEvaluationContext`.


   Example:

   

   StandardEvaluationContext context = new StandardEvaluationContext();

   context.setVariable("greeting", "Hello");

   

   ExpressionParser parser = new SpelExpressionParser();

   String result = parser.parseExpression("#greeting + ' World'").getValue(context, String.class);

   

3. Operators:

   SpEL supports a variety of operators, including arithmetic, relational, logical, and other specialized operators.


   Example:

   

   int result = parser.parseExpression("10 * 5 + 2").getValue(Integer.class); // Result: 52

   


4. Functions:

   SpEL provides a set of predefined functions that can be used in expressions. These functions cover a wide range of operations, including string manipulation, collection handling, and more.


   Example:

   

   String result = parser.parseExpression("toUpperCase('hello')").getValue(String.class); // Result: "HELLO"

   


5. Types and Type Conversion:

   SpEL can perform type conversion automatically. It also supports querying the type of an object and checking for its assignability.


   Example:

   

   Integer result = parser.parseExpression("'5' + '5'").getValue(Integer.class); // Result: 55

   


6. Conditional Operators:

   SpEL supports the ternary conditional operator (`condition ? trueValue : falseValue`) for concise conditional expressions.


   Example:

   String result = parser.parseExpression("score > 60 ? 'pass' : 'fail'").getValue(context, String.class);


7. Collection Projection and Selection:

   SpEL allows you to work with collections using projection and selection operations. This is particularly useful when dealing with collections of objects.


   Example:

   

   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

   List<Integer> squares = parser.parseExpression("#numbers.![#this * #this]").getValue(context, List.class);

   // Result: [1, 4, 9, 16, 25]

   

8. Bean References:

   SpEL can reference beans by their names or by using the `@beanName` syntax.


   Example:

   

   @Component("myBean")

   public class MyBean {

       // ...

   }

   

   MyBean bean = parser.parseExpression("@myBean").getValue(MyBean.class);

   

These are just some of the key features of Spring Expression Language. 

SpEL is extensively used in Spring applications for configuration, data binding, and dynamic query generation, among other purposes. Its flexibility and rich set of features make it a valuable tool in the Spring ecosystem.


Explore More :https://www.tutorialspoint.com/spring_expression_language/index.htm 


Comments

Post a Comment

Popular posts from this blog

1. Spring Overview

Image
  Spring Framework  - The Spring Framework is a comprehensive framework for enterprise Java development.  - It provides a wide range of features and functionalities that simplify the development of Java applications, particularly in the domain of enterprise and web applications.  - The framework is known for its modularity, scalability, and ease of integration. What is Spring  - It was developed by Rod Johnson in 2003. - Spring is a lightweight framework. - Spring is a Dependency injection framework to make java application loosely couple. - Spring framework makes the easy developement of javaEE (enterprise ) application. Why to Learn Spring? - Spring is the most popular application development framework for enterprise Java. Millions of developers around the world use Spring Framework to create high performing, easily testable, and reusable code. - Spring is a tool that helps make it easier to build software, like apps or websites. -  Learning Spring is val...
Read more

2. Spring Framework Module (Architecture)

Image
  Spring Framework Architecture The Spring Framework is a comprehensive framework for enterprise Java development. It provides a modular and organized way to build enterprise-level applications. The framework is divided into several modules, each addressing specific concerns.  Types  1. The Core Container: 2. Data Access / Integration 3. The Web   4. Miscellaneous (AOP)   1. Spring Core Container:    CORE: This module provides the fundamental parts of the framework,  its including the IoC (Inversion of Control) container and Dependency Injection features.   BEAN : It deals with the creation and management of Java objects (beans) and their dependencies.A sophisticated implementation of factory pattern called BeanFactory, is provided by, Bean module. CONTEXT : This module builds on the core and beans modules, providing a way to access application objects and services in a consistent manner. It has access rights for any objects that de...
Read more

10. Spring - MVC Framework

Image
  Introduction to Spring MVC Framework - Spring MVC is used to develop the web applications that uses MVC design pattern. By using Spring MVC we can build flexible and loosely coupled web applications. - The MVC design pattern helps in seperating the business logic, presentation logic and controller logic. - Models are responsible for encapsulating the application data.  - The Views render response to the user with the help of the model object .  - Controllers are responsible for receiving the request from the user and calling the back-end services. Spring MVC will make application development faster, cost effective and flexible. Advantage of Spring MVC Framework - Clear separation of responsibilities because it implements MVC design pattern. - Loose coupling among Model, View and Controller. - Inbuilt front controller. - Simplified Validation implementation. - Simplified Exception Handling. - Internationalization logic is simplified compared to other frameworks. - Spring...
Read more