<?xml version="1.0"?>
<dataset>
  <users id="${id}" username="ElDuderino" first_name="Jeffrey" last_name="Lebowsky" />
</dataset>

String elText = "Dude, where is my ${car}?";
SomeSortOfContext context = new SomeSortOfContext();
context.bind( "car", "EL tutorial" );
String convertedText = doSomeMagic( context, elText );
// convertedText is "Dude, where is my EL tutorial?"

1. First, get the el-api.jar. Where? Another of life's obscure mysteries, but long story short, try https://maven-repository.dev.java.net/repository/javax.el/jars
2. Then you need to define SomeContext. The EL API defines an ELContext (javax.el.ELContext), but that is an abstract class - you need to extend it and implement the getELResolver(), getFunctionMapper(), and getVariableMapper() methods.
3. For getELResolver(), you can just return a new BeanELResolver() (that class is part of the EL api). Similarly, you are not interested on getFunctionMapper() (unless you need to support EL functions), so you can create an inner class implementation that does nothing (don't panic, I will show the whole code below).
4. Now comes the first real trick, implementing getVariableMapper(). For this dude, you also create your own implementation, which simply uses a Map to store the variables you want to bind. And as a courtesy to your fellow programmers, you add the bind() method shown in the above example.
5. Next step is to get a javax.el.ExpressionFactory implementation. If you guessed that el-api.jar does not provide any implementation, congratulations, you read my mind! But in this case you don't need to create your own, you can get an existing implementation, such as Tomcat's (again, the shorcut is to download jasper-el.jar from http://mirrors.ibiblio.org/pub/mirrors/maven2/org/apache/tomcat/jasper-e...)
6. That leave us with the final step, the doSomeMagic() method, which is simply return factory.createValueExpression(context, elText, Object.class ).getValue(context);!

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import javax.el.BeanELResolver;
import javax.el.ELContext;
import javax.el.ELResolver;
import javax.el.ExpressionFactory;
import javax.el.FunctionMapper;
import javax.el.ValueExpression;
import javax.el.VariableMapper;

import org.apache.el.ValueExpressionLiteral;
import static org.junit.Assert;
import org.junit.Test;

public class BlogTest {
  
  @Test
  public void doIt() {
    String elText = "Dude, where is my ${car}?";
    SomeContext context = new SomeContext();
    context.bind( "car", "EL tutorial" );
    Object convertedText = doSomeMagic( context, elText );
    assertEquals( "Dude, where is my EL tutorial?", convertedText );
  }

  private Object doSomeMagic(SomeContext context, String elText) {
    if ( factory == null ) {
      throw new RuntimeException( "could not get instance of factory class " + factoryClass );
    }
    ValueExpression converted = factory.createValueExpression(context, elText, Object.class );
    return converted.getValue(context);
  }
  
  private static final String factoryClass = "org.apache.el.ExpressionFactoryImpl";
  private static final ExpressionFactory factory;
  
  static {
    System.setProperty("javax.el.ExpressionFactory", factoryClass);
    ExpressionFactory tmpFactory = null;
    try {
      tmpFactory = ExpressionFactory.newInstance();    
    } catch ( RuntimeException e ) {
      System.err.println("D'OH!");
    }
    factory = tmpFactory;
  }
  
  public class SomeContext extends ELContext {

    private final BeanELResolver resolver = new BeanELResolver();
    private final FunctionMapper functionMapper = new NoopFunctionMapper();
    private final VariableMapper variableMapper = new VariableMapperImpl();
    private final Map variables =  new HashMap();

    @Override
    public ELResolver getELResolver() {
      return resolver;
    }

    @Override
    public FunctionMapper getFunctionMapper() {
      return functionMapper;
    }

    @Override
    public VariableMapper getVariableMapper() {
      return variableMapper;
    }
    
    public void bind( String variable, Object obj ) {
      variables.put( variable, new ValueExpressionLiteral(obj,Object.class) );
    }
    
    private class VariableMapperImpl extends VariableMapper {
      public ValueExpression resolveVariable(String s) {
        return variables.get(s);
      }
      public ValueExpression setVariable(String s, ValueExpression valueExpression) {
        return (variables.put(s, valueExpression));
      }
    }

    private class NoopFunctionMapper extends FunctionMapper {
      public Method resolveFunction(String s, String s1) {
        return null;
      }
    }

  }
  
}