Spring – Lenguaje de expresión (SpEL)

SpEL es un lenguaje de secuencias de comandos que le permite consultar y manipular un gráfico de objetos en tiempo real. JSP EL, OGNL, MVEL y JBoss EL son solo algunos de los lenguajes de expresión disponibles. La invocación de métodos y la creación de plantillas de strings son dos de las funcionalidades adicionales proporcionadas por SpEL.

API para SpEL: muchas interfaces y clases están disponibles en la API de SpEL. Los siguientes son los detalles:

1. Interfaz de expresión
2. Clase SpelExpression
3. interfaz ExpressionParser
4. Clase SpelExpressionParser
5. Interfaz EvaluationContext
6. Clase de contexto de evaluación estándar

Dependencias: Agregue las siguientes dependencias:

• núcleo de resorte
• contexto de primavera
• frijoles de primavera

Implementación: la estructura del proyecto se ve como se muestra en los siguientes medios de la siguiente manera: 

A. Archivo: pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.geeksforgeeks.spring</groupId>
    <artifactId>springListExample</artifactId>
    <version>0.0.1-SNAPSHOT</version>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
 
    <properties>
        <spring.version>3.2.3.RELEASE</spring.version>
    </properties>
</project>

Compatibilidad con expresiones XML de Spring Context

Para facilitar la configuración, podemos emplear expresiones de primavera dentro del contexto XML. Comenzaremos con nuestro ejemplo y luego pasaremos a las clases POJO.

Aquí hay un ejemplo, estamos teniendo un programa de capacitación construido alrededor de una lección que cubre una variedad de temas técnicos. El curso se centrará en un tema específico.

B. Archivo: Tema.java

// Java Program to Illustrate Topic Class
 
package com.geeksforgeeks.spring;
 
// Class
public class Topic {
 
    // Class data members
    private String name;
 
    // Constructor: Default
    public Topic() {}
 
    // Constructor: Parametrized
    public Topic(String name) { this.name = name; }
 
    // Getters and setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String toString() { return name; }
}

C. Archivo: Tutorial.java

// Java Program to Illustrate Tutorial Class
 
package com.geeksforgeeks.spring;
 
// Importing required classes
import java.util.ArrayList;
import java.util.List;
 
// Class
public class Tutorial {
 
    // Class data members
    private String name;
 
    private List<?> topicsList = new ArrayList<>();
 
    // Getter
    public String getName() { return name; }
 
    // Setter
    public void setName(String name) { this.name = name; }
 
    // Method
    public List<?> getTopicsList() { return topicsList; }
 
    // Setter
    public void setTopicsList(List<?> topicsList)
    {
        this.topicsList = topicsList;
    }
 
    // Method
    // Overloading toString() method
    public String toString() { return name + topicsList; }
}

D. Archivo: Entrenamiento.java

// Java Program to Illustrate Training Class
 
package com.geeksforgeeks.spring;
 
// Class
public class Training {
 
    // Class data member
    private Topic topic;
 
    // Getter
    public Topic getTopic() { return topic; }
 
    // Setter
    public void setTopic(Topic topic)
    {
        this.topic = topic;
    }
}

Definiremos un par de temas técnicos, java core y ScalaBasics, así como una lección y capacitación, en el contexto de XML. Al definir los beans, las expresiones SpEL se pueden combinar con XML. #expression string> es la sintaxis.

#tutorial.topicsList[1] se usa para establecer el tema de nuestro bean de entrenamiento. Establece la propiedad subject en el segundo tema de la lista de temas del bean instructivo.

E. Archivo: applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
 
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
     <context:component-scan base-package="com.geeksforgeeks.spring" />
 
    <bean id="tutorial" class="com.geeksforgeeks.spring.Tutorial">
        <property name="topicsList">
           <ref local="javaCore" />
           <ref local="scalaBasics" />
        </property>
    </bean>
         
    <bean id="javaCore" class="com.geeksforgeeks.spring.Topic">
        <property name="name" value="JavaCore" />
    </bean>
     
    <bean id="scalaBasics" class="com.geeksforgeeks.spring.Topic">
        <property name="name" value="ScalaBasics" />
    </bean>   
     
    <bean id="training" class="com.geeksforgeeks.spring.Training">
        <property name="topic" value="#{tutorial.topicsList[1]}"/>
    </bean>
     
</beans>

F. ARCHIVO: SpringExpressionXmlContextExample.java

// Java Program to Illustrate Application Class
 
package com.geeksforgeeks.spring;
 
// Importing required classes
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
// Main Class
public class SpringExpressionXmlContextExample {
 
    // Main driver method
    public static void main(String[] args)
    {
        ClassPathXmlApplicationContext context
            = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
 
        // Try block to check for exceptions
        try {
            Training training
                = (Training)context.getBean("training");
            System.out.println(training.getTopic());
 
            System.out.println(training.getDefaultTopic());
        }
 
        // finally block that will execute for sure
        finally {
 
            // Closing the connections
            // using close() method
            context.close();
        }
    }
}

Producción:

ScalaBasics

Anotación en Spring Expressions

Las expresiones SpEL también se pueden usar para definir beans usando metadatos de configuración basados ​​en anotaciones. Para definir un valor predeterminado, utilice la anotación @Value en campos, métodos y argumentos de método/constructor.

Hemos agregado un tema predeterminado de miembro nuevo a nuestro bean de capacitación para mostrar el ejemplo. Para establecer el tema predeterminado, utilizamos una expresión de primavera.

Archivo: Entrenamiento.java

package com.geeksforgeeks.spring;
  
import org.springframework.beans.factory.annotation.Value;
  
public class Training
{
    private Topic topic;
      
    @Value("#{tutorial.topicsList[0]}")
    private Topic defaultTopic;
  
  //getters and setters
    public Topic getTopic()
    {
        return topic;
    }
  
    public void setTopic(Topic topic)
    {
        this.topic = topic;
    }
      
    public Topic getDefaultTopic()
    {
        return defaultTopic;
    }
}

Las anotaciones se escanean y evalúan agregando el contexto: el elemento de escaneo de componentes al XML de contexto.

Archivo: applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
 
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
     <context:component-scan base-package="com.geeksforgeeks.spring" />
 
    <bean id="tutorial" class="com.geeksforgeeks.spring.Tutorial">
        <property name="topicsList">
          <ref local="javaCore" />
          <ref local="scalaBasics" />
        </property>
    </bean>
         
    <bean id="javaCore" class="com.geeksforgeeks.spring.Topic">
        <property name="name" value="JavaCore" />
    </bean>
     
    <bean id="scalaBasics" class="com.geeksforgeeks.spring.Topic">
        <property name="name" value="ScalaBasics" />
    </bean>   
     
    <bean id="training" class="com.geeksforgeeks.spring.Training">
        <property name="topic" value="#{tutorial.topicsList[1]}"/>
    </bean>
     
</beans>

Veamos si defaultTopic está habilitado.

Archivo: SpringExpressionXmlContextExample.java

package com.geeksforgeeks.spring;
 
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class SpringExpressionXmlContextExample {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        try {
            Training training = (Training) context.getBean("training");
            System.out.println(training.getTopic()); 
             
            System.out.println(training.getDefaultTopic());
        } finally {
            context.close();
        }
    }
}

Producción:

ScalaBasics
JavaCore

Ejemplo de analizador de lenguaje de expresión Spring

Usando el analizador de expresiones, el SpEL también se puede utilizar como un componente independiente.

org.springframework.expression.spel.standard.SpelExpressionParser.

Archivo: SpringExpressionParserExample.java

package com.geeksforgeeks.spring;
 
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
 
public class SpringExpressionParserExample {
    public static void main(String[] args) {
        SpelExpressionParser parser = new SpelExpressionParser();
        Expression exp = parser.parseExpression("'Just a string value'");
        String message = (String) exp.getValue();
        System.out.println(message);
         
        System.out.println(parser.parseExpression("'Just a string value'.substring(5)").getValue());
         
        System.out.println(parser.parseExpression("'Just a string value'.length()").getValue());
         
        System.out.println(parser.parseExpression("'Just a string value'.substring('Just '.length())").getValue());
         
        System.out.println(parser.parseExpression("'Just a string value'.class").getValue());
         
        System.out.println(parser.parseExpression("'Just a string value'.bytes").getValue());
         
        System.out.println(parser.parseExpression("new com.geeksforgeeks.spring.Topic('Java')").getValue(Topic.class).getClass());      
    }
}

Producción:

Echemos un vistazo a un par de instancias más: usar Spring ExpressionParser para llamar a un método donde, en este ejemplo, llamamos substring(), length() de String.

Archivo: SpringExpressionParserExample.java

package com.geeksforgeeks.spring;
 
import java.util.Arrays;
 
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
  
public class SpringExpressionParserExample {
    public static void main(String[] args) {
        SpelExpressionParser parser = new SpelExpressionParser();
        Expression exp = parser.parseExpression("'Just a string value'");
        String message = (String) exp.getValue();
        System.out.println(message);
          
        System.out.println(parser.parseExpression("'Just a string value'.substring(5)").getValue());
          
        System.out.println(parser.parseExpression("'Just a string value'.length()").getValue());
          
        System.out.println(parser.parseExpression("'Just a string value'.substring('Just '.length())").getValue());       
    }
}

Producción:

Acceda a las propiedades de JavaBean usando Spring ExpressionParser

Accedamos a un par de clases de propiedades JavaBean y bytes de los objetos String.

Archivo: SpringExpressionParserExample.java

// Java Program to Illustrate Spring Expression Parser
 
package com.geeksforgeeks.spring;
 
// Importing required classes
import java.util.Arrays;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
 
// Class
public class SpringExpressionParserExample {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        SpelExpressionParser parser
            = new SpelExpressionParser();
        Expression exp = parser.parseExpression(
            "'Just a string value'");
        String message = (String)exp.getValue();
 
        // Print commands
        System.out.println(message);
 
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.substring(5)")
                .getValue());
 
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.length()")
                .getValue());
 
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.substring('Just '.length())")
                .getValue());
 
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.class")
                .getValue());
 
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.bytes")
                .getValue());
    }
}

Producción:
 

Llamando a Constructor usando Spring ExpressionParser

Podemos crear un objeto llamando al constructor de la clase en la expresión de primavera. Por ejemplo:

'new com.geeksforgeeks.spring.Topic('Java')'

Archivo: SpringExpressionParserExample.java

// Java Program to Illustrate Spring Expression Parser
 
package com.geeksforgeeks.spring;
 
// Importing required classes
import java.util.Arrays;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
 
// Class
public class SpringExpressionParserExample {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        SpelExpressionParser parser
            = new SpelExpressionParser();
        Expression exp = parser.parseExpression(
            "'Just a string value'");
        String message = (String)exp.getValue();
        System.out.println(message);
 
        // Print commands
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.substring(5)")
                .getValue());
 
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.length()")
                .getValue());
 
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.substring('Just '.length())")
                .getValue());
 
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.class")
                .getValue());
 
        System.out.println(
            parser
                .parseExpression(
                    "'Just a string value'.bytes")
                .getValue());
 
        System.out.println(
            parser
                .parseExpression(
                    "new com.geeksforgeeks.spring.Topic('Java')")
                .getValue(Topic.class)
                .getClass());
    }
}

Producción: