MVEL 2.0: A Powerful Expression Language for Java Applications

What is MVEL?

MVFLEX Expression Language?(MVEL) is a hybrid dynamic/statically typed, embeddable?Expression Language?and?runtime?for the?Java Platform. Originally started as a utility language for an application framework, the project is now developed completely independently.

MVEL is typically used for exposing basic logic to end-users and programmers through configuration such as?XML?files or?annotations. It may also be used to parse simple?JavaBean?expressions. It is designed to be highly efficient and flexible, making it ideal for scenarios requiring dynamic behavior such as rule engines, templating, and configuration scripting. In this article, we will explore the features of MVEL 2.0 and demonstrate how to use it in a Java application.

MVEL expressions may consist of:

Property expressions:

String name = (String) MVEL.eval("person.name", context);

In this example, person.name is a property expression used to access the name field of the person object.

Boolean expressions:

booleanisAdult = (Boolean) MVEL.eval("age >= 18", context);

Boolean expressions are used to evaluate conditions and implement logic within MVEL scripts. They form the basis for decision-making in MVEL.

Method invocations:

String upperCaseName = (String) MVEL.eval("person.getName().toUpperCase()", context);

MVEL allows invoking methods on objects within expressions. This enables the execution of business logic and manipulation of data through method calls.

Variable assignments:

MVEL.eval("int x = 5; x = x + 10;", context);

MVEL supports variable assignments within expressions, enabling the creation and modification of variables dynamically.

Function definitions:

String script = "def greet(name) { return 'Hello, ' + name; }; greet('John');";

String greeting = (String) MVEL.eval(script, context);

MVEL allows defining custom functions within expressions, enabling developers to encapsulate and reuse logic.

?

Key Features of MVEL 2.0:

• Dynamic Expression Evaluation: MVEL can evaluate expressions at runtime, allowing for dynamic decision-making and scripting within Java applications.
• Lightweight and Fast: MVEL is optimized for performance, with a lightweight footprint and fast execution of expressions.
• Integration with Java: MVEL integrates seamlessly with Java, allowing for the invocation of Java methods and manipulation of Java objects.
• Advanced Scripting Capabilities: MVEL supports advanced scripting features, such as looping, conditionals, and lambda expressions, making it suitable for complex logic.
• Support for Collections and Maps: MVEL provides native support for collections and maps, allowing for easy manipulation of data structures.

Getting Started with MVEL 2.0:

To start using MVEL in your Java application, you need to add the MVEL library to your project. If you are using Maven, you can include the following dependency in your pom.xml:

<dependency>

<groupId>org.mvel</groupId>

<artifactId>mvel2</artifactId>

<version>2.4.12.Final</version>

</dependency>        

For a Gradle project, add this line to your build.gradle:

implementation 'org.mvel:mvel2:2.4.12.Final'        

?Example: Using MVEL in a Java Application

Let’s walk through a simple example of how to use MVEL in a Java application. In this example, we will create a simple rule engine that evaluates discount rules for a shopping cart.

Step 1: Define the Data Model

public class Product {
    private String name;
    private double price;
    private int quantity;
 // Constructors, getters, and setters
    public Product(String name, double price, int quantity) {
        this.name = name;
this.price = price;
this.quantity = quantity;
}
public String getName() {
        return name;
    }
public double getPrice() {
        return price;
    }
public intgetQuantity() {
        return quantity;
    }
public double getTotalPrice() {
        return price * quantity;
    }
}public class ShoppingCart {
    private List<Product> products = new ArrayList<>();

    public void addProduct(Product product) {
products.add(product);
    }
public List<Product>getProducts() {
        return products;
    } public double getTotalPrice() {
        return products.stream().mapToDouble(Product::getTotalPrice).sum();
    }
}        

Step 2: Define the Discount Rule

Next, we define a discount rule using an MVEL expression. The rule grants a 10% discount if the total price exceeds $100:

public class DiscountRuleEngine {
    private static final String DISCOUNT_RULE =
        "cart.totalPrice> 100 ? cart.totalPrice * 0.1 : 0";
public double calculateDiscount(ShoppingCart cart) {
        Map<String, Object> variables = new HashMap<>();
variables.put("cart", cart);
// Evaluate the MVEL expression
        return (Double) MVEL.eval(DISCOUNT_RULE, variables);
    }
}        

Step 3: Execute the Rule

Finally, we create a shopping cart, add products, and use the rule engine to calculate the discount:

public class Main {
    public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();
cart.addProduct(new Product("Laptop", 80.0, 1));
cart.addProduct(new Product("Headphones", 30.0, 2));
DiscountRuleEngine engine = new DiscountRuleEngine();
        double discount = engine.calculateDiscount(cart);
System.out.println("Total Price: $" + cart.getTotalPrice());
System.out.println("Discount: $" + discount);
System.out.println("Final Price: $" + (cart.getTotalPrice() - discount)) 
}
}        

Explanation

• Data Model: We define Product and ShoppingCart classes to represent the items in the cart and the cart itself.
• Discount Rule: We define a simple MVEL expression to calculate the discount. The expression uses a ternary operator to check if the total price exceeds $100 and calculates a 10% discount if true.
• MVEL Evaluation: We create an instance of DiscountRuleEngine and use MVEL.eval() to evaluate the discount rule, passing in the ShoppingCart object as a variable.
• Output: The application prints the total price, calculated discount, and final price after applying the discount.

?

Additional Benefits of MVEL 2.0

Extensibility

• Custom Functions and Operators: MVEL allows defining custom functions and operators, enabling you to tailor the language to specific domain requirements.
• Plugin Architecture: Supports integrating third-party libraries through a plugin architecture, extending functionality without altering the core library.

Ease of Use

• Concise Syntax: MVEL's intuitive syntax is accessible to both developers and non-developers, facilitating collaboration across teams.
• Interactive Debugging: Provides tools for testing and debugging expressions quickly, enhancing productivity and speeding up development.

Community and Support

• Active Community: MVEL has a vibrant developer community that contributes and provides support, ensuring the language stays current with advancements.
• Comprehensive Documentation: Offers extensive documentation and examples, helping developers quickly learn and leverage MVEL's advanced features.

?

Conclusion:

MVEL 2.0 is a powerful tool for Java developers looking to add dynamic expression evaluation to their applications. Its seamless integration with Java and support for complex expressions make it ideal for use cases like rule engines, configuration scripting, and templating. By following the example outlined above, you can get started with MVEL and harness its capabilities to build more flexible and dynamic Java applications.