如何在EL中引用常量？

Question

如何在 JSP 页面上使用 EL 引用常量？

我有一个接口 Addresses ，其中包含一个名为 URL 的常量。我知道我可以通过以下方式使用 scriplet 引用它： <%=Addresses.URL%>，但是如何使用 EL 来执行此操作？

Answer 1

EL 3.0 或更高版本

如果您已经使用 Java EE 7 / EL 3.0，那么 @page import 还将导入 EL 范围内的类常量。

<%@ page import="com.example.YourConstants" %>

这将在幕后通过 ImportHandler#importClass() 并以 ${YourConstants.FOO} 形式提供。

请注意，所有 java.lang.* 类均已隐式导入并可用，如 ${Boolean.TRUE} 和 ${Integer.MAX_VALUE} >。这只需要更新的 Java EE 7 容器服务器，因为早期版本存在错误。例如，GlassFish 4.0 和 Tomcat 8.0.0-1x 失败，但 GlassFish 4.1+ 和 Tomcat 8.0.2x+ 可以工作。并且您需要绝对确保您的 web.xml 声明符合服务器支持的最新 servlet 版本。因此，对于声明为符合 Servlet 2.5 或更早版本的 web.xml，Servlet 3.0+ 功能都不起作用。

另请注意，此功能仅在 JSP 中可用，在 Facelets 中不可用。对于 JSF+Facelets，最好的选择是使用 OmniFaces 如下：

<o:importConstants type="com.example.YourConstants" />

或者添加一个调用 ImportHandler#importClass() 的 EL 上下文侦听器，如下所示：

@ManagedBean(eager=true)
@ApplicationScoped
public class Config {

    @PostConstruct
    public void init() {
        FacesContext.getCurrentInstance().getApplication().addELContextListener(new ELContextListener() {
            @Override
            public void contextCreated(ELContextEvent event) {
                event.getELContext().getImportHandler().importClass("com.example.YourConstants");
            }
        });
    }

}

---

EL 2.2 或更早版本

这是在 EL 2.2 及更早版本中不可能。有几种替代方案：

1. 将它们放入您放置在应用程序范围内的 Map 中。在 EL 中，可以通过 ${map.key} 或 ${map['key.with.dots']} 以通常的 Javabean 方式访问映射值。

2. 使用非标准标签库的（maven2存储库此处)：

   <%@ taglib uri="http://jakarta.apache.org/taglibs/unstandard-1.0" prefix="un" %>
   >
   

   这样就可以通过 ${constants.FOO} 以通常的 Javabean 方式访问它们。

3. 使用Javaranch的CCC 如 本文。

   <%@ taglib uri="http://bibeault.org/tld/ccc" prefix="ccc" %>;
   
   

   这样，它们也可以通过 ${constants.FOO} 以通常的 Javabean 方式访问。

4. 如果您使用的是 JSF2，则可以使用 OmniFaces的代码>。

   
   >
   

   这样，它们也可以通过 #{YourConstants.FOO} 以通常的 Javabean 方式访问。

5. 创建一个包装类，通过 Javabean 风格的 getter 方法返回它们。

6. 创建一个自定义 EL 解析器，它首先扫描常量是否存在，如果不存在，则委托给默认解析器，否则返回常量值。

Answer 2

以下内容通常不适用于 EL，而仅适用于 SpEL (Spring EL)（在 Tomcat 7 上使用 3.2.2.RELEASE 进行测试）。
我认为这里值得一提，以防有人搜索 JSP 和 EL（但使用 JSP 和 Spring）。

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<spring:eval var="constant" expression="T(com.example.Constants).CONSTANT"/>

Answer 3

您通常将这些类型的常量放置在 servlet 上下文中的 Configuration 对象（具有 getter 和 setter）中，并使用 ${applicationScope.config.url} 访问它们

Answer 4

你不能。它遵循 Java Bean 约定。所以你必须有一个吸气剂。

Answer 5

我在一开始就在 jsp 中定义了一个常量：

<%final String URI = "http://www.example.com/";%>

我在 JSP 中包含了核心 taglib：

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

然后，我通过以下语句使该常量可用于 EL：

<c:set var="URI" value="<%=URI%>"></c:set>

现在，我可以稍后使用它。下面是一个示例，其中该值只是写为 HTML 注释以进行调试：

<!-- ${URI} -->

---

使用常量类，您只需导入类并将常量分配给局部变量即可。我知道我的答案是一种快速破解，但是当人们想要直接在 JSP 中定义常量时，问题也会出现。

Answer 6

我实现如下：

public interface Constants{
    Integer PAGE_SIZE = 20;
}

-

public class JspConstants extends HashMap<String, String> {

        public JspConstants() {
            Class c = Constants.class;
            Field[] fields = c.getDeclaredFields();
            for(Field field : fields) {
                int modifier = field.getModifiers();
                if(Modifier.isPublic(modifier) && Modifier.isStatic(modifier) && Modifier.isFinal(modifier)) {
                    try {
                        Object o = field.get(null);
                        put(field.getName(), o != null ? o.toString() : null);
                    } catch(IllegalAccessException ignored) {
                    }
                }
            }
        }

        @Override
        public String get(Object key) {
            String result = super.get(key);
            if(StringUtils.isEmpty(result)) {
                throw new IllegalArgumentException("Check key! The key is wrong, no such constant!");
            }
            return result;
        }
    }

下一步将此类的实例放入 servlerContext

public class ApplicationInitializer implements ServletContextListener {


    @Override
    public void contextInitialized(ServletContextEvent sce) {
        sce.getServletContext().setAttribute("Constants", new JspConstants());
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
    }
}

添加监听器到

<listener>
    <listener-class>com.example.ApplicationInitializer</listener-class>
</listener>

jsp 中的 web.xml 访问

${Constants.PAGE_SIZE}

Answer 7

静态属性在 EL 中不可访问。我使用的解决方法是创建一个非静态变量，将其自身分配给静态值。

public final static String MANAGER_ROLE = 'manager';
public String manager_role = MANAGER_ROLE;

我使用 lombok 生成 getter 和 setter，这样就很好了。您的 EL 如下所示：

${bean.manager_role}

完整代码位于 https://rogerkeays .com/access-java-static-methods-and-constants-from-el

Answer 8

是的，你可以。您需要一个自定义标签（如果您在其他地方找不到它）。我已经这样做了：

package something;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Map;
import java.util.TreeMap;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.TagSupport;

import org.apache.taglibs.standard.tag.el.core.ExpressionUtil;

/**
 * Get all class constants (statics) and place into Map so they can be accessed
 * from EL.
 * @author Tim.sabin
 */
public class ConstMapTag extends TagSupport {
    public static final long serialVersionUID = 0x2ed23c0f306L;

    private String path = "";
    private String var = "";

    public void setPath (String path) throws JspException {
        this.path = (String)ExpressionUtil.evalNotNull ("constMap", "path",
          path, String.class, this, pageContext);
    }

    public void setVar (String var) throws JspException {
        this.var = (String)ExpressionUtil.evalNotNull ("constMap", "var",
          var, String.class, this, pageContext);
    }

    public int doStartTag () throws JspException {
        // Use Reflection to look up the desired field.
        try {
            Class<?> clazz = null;
            try {
                clazz = Class.forName (path);
            } catch (ClassNotFoundException ex) {
                throw new JspException ("Class " + path + " not found.");
            }
            Field [] flds = clazz.getDeclaredFields ();
            // Go through all the fields, and put static ones in a Map.
            Map<String, Object> constMap = new TreeMap<String, Object> ();
            for (int i = 0; i < flds.length; i++) {
                // Check to see if this is public static final. If not, it's not a constant.
                int mods = flds [i].getModifiers ();
                if (!Modifier.isFinal (mods) || !Modifier.isStatic (mods) ||
                  !Modifier.isPublic (mods)) {
                    continue;
                }
                Object val = null;
                try {
                    val = flds [i].get (null);    // null for static fields.
                } catch (Exception ex) {
                    System.out.println ("Problem getting value of " + flds [i].getName ());
                    continue;
                }
                // flds [i].get () automatically wraps primitives.
                // Place the constant into the Map.
                constMap.put (flds [i].getName (), val);
            }
            // Export the Map as a Page variable.
            pageContext.setAttribute (var, constMap);
        } catch (Exception ex) {
            if (!(ex instanceof JspException)) {
                throw new JspException ("Could not process constants from class " + path);
            } else {
                throw (JspException)ex;
            }
        }
        return SKIP_BODY;
    }
}

并且标记被称为：

<yourLib:constMap path="path.to.your.constantClass" var="consts" />

所有公共静态最终变量都将放入按其 Java 名称索引的 Map 中，因此如果

public static final int MY_FIFTEEN = 15;

标记将其包装在 Integer 中，您可以在 JSP 中引用它

<c:if test="${consts['MY_FIFTEEN'] eq 15}">

：你不必编写吸气剂！

Answer 9

你可以。按照以下方式尝试

 #{T(com.example.Addresses).URL}

在 TomCat 7 和 java6 上测试

Answer 10

即使知道它有点晚了，甚至知道这是一个小黑客 - 我使用以下解决方案来达到预期的结果。如果您是 Java 命名约定的爱好者，我的建议是停止阅读这里...

拥有一个这样的类，定义常量，按空类分组以创建某种层次结构：

public class PERMISSION{
    public static class PAGE{
       public static final Long SEE = 1L; 
       public static final Long EDIT = 2L; 
       public static final Long DELETE = 4L; 
       ...
    }
}

可以在 java 中使用 < code>PERMISSION.PAGE.SEE 检索值 1L

为了从 EL 表达式中实现类似的访问可能性，我这样做了：
（如果有编码大神 - 希望他会原谅我 :D ）

@Named(value="PERMISSION")
public class PERMISSION{
    public static class PAGE{
       public static final Long SEE = 1L; 
       public static final Long EDIT = 2L; 
       public static final Long DELETE = 4L; 
       ...

       //EL Wrapper
       public Long getSEE(){
           return PAGE.SEE;
       }

       public Long getEDIT(){
           return PAGE.EDIT;
       }

       public Long getDELETE(){
           return PAGE.DELETE;
       }
    }

    //EL-Wrapper
    public PAGE getPAGE() {
        return new PAGE();
    }
}

最后，访问相同 Long 的 EL 表达式变为： #{PERMISSION.PAGE.SEE}< /code> - Java 和 EL-Access 相等。我知道这不符合任何惯例，但它工作得很好。

Answer 11

@Bozho 已经提供了一个很好的答案

您通常将这些类型的常量放置在 servlet 上下文中的 Configuration 对象（具有 getter 和 setter）中，并使用 ${applicationScope.config.url} 访问它们

但是，我觉得需要一个示例，这样它会更加清晰并节省某人的时间

@Component
public Configuration implements ServletContextAware {
    private String addressURL = Addresses.URL;

    // Declare other properties if you need as also add corresponding
    // getters and setters

    public String getAddressURL() {
        return addressURL;
    }

    public void setServletContext(ServletContext servletContext) {
        servletContext.setAttribute("config", this);
    }
}

Answer 12

有一种解决方法并不完全是您想要的，但可以让您以非常简单的方式通过触摸 scriptlet 进行几乎相同的活动。您可以使用 scriptlet 将值放入 JSTL 变量中，并稍后在页面中使用干净的 JSTL 代码。

<%@ taglib prefix="c"       uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="com.whichever.namespace.Addresses" %>
<c:set var="ourUrl" value="<%=Addresses.URL%>"/>
<c:if test='${"http://www.google.com" eq ourUrl}'>
   Google is our URL!
</c:if>