groovy - 执行`/usr/bin/build-classpath`时出现`/usr/bin/groovy`消息

Question

# groovy --version
/usr/bin/build-classpath: Could not find /lib/jvm/java Java extension for this JVM
/usr/bin/build-classpath: error: Some specified jars were not found
Groovy Version: 1.8.9 JVM: 1.7.0_79 Vendor: Oracle Corporation OS: Linux

# java -version
java version "1.7.0_79"
OpenJDK Runtime Environment (fedora-2.5.5.0.fc20-x86_64 u79-b14)
OpenJDK 64-Bit Server VM (build 24.79-b02, mixed mode)

您希望我向您展示哪个“Java 扩展”？ “一些指定的 jar ”？我没有指定任何。我真的很喜欢这种毫无意义的信息。

更新 1:

两者:

# alternatives --config java
# alternatives --config javac

如 first link of blackdrag's answer 中所述没有帮助。

对于这两个有 1 个程序提供“java[c]”，它是 OpenJDK。

The second link也没有帮助。

更新 2:

我安装并设置为替代:

# java -version
java version "1.8.0_51"
Java(TM) SE Runtime Environment (build 1.8.0_51-b16)
Java HotSpot(TM) 64-Bit Server VM (build 25.51-b03, mixed mode)

没用。

更新 3:

第一条消息来自/usr/share/java-utils/java-functions:

# Functions library for Java applications.                           -*- sh -*-
#
# Copyright (c) 2012-2013, Red Hat, Inc
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the
#    distribution.
# 3. Neither the name of Red Hat nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Fedora Project <http://www.fedoraproject.org/>
#   Mikolaj Izdebski <mizdebsk@redhat.com>
#
# JPackage Project <http://www.jpackage.org/>
#   Guillaume Rousse <guillomovitch@sourceforge.net>
#   Ville Skyttä <scop at jpackage.org>
#   David Walluck <david@jpackage.org>
#   Nicolas Mailhot <Nicolas.Mailhot at laPoste.net>


_log()
{
    if [ -n "${JAVAPACKAGES_DEBUG}" ]; then
        echo "${0}: ${@}" >&2
    fi
}

_err()
{
    echo "${0}: ${@}" >&2
}

# Load a single Java configuration file.
_load_java_conf_file()
{
    local IFS
    local JAVA_LIBDIR
    local JNI_LIBDIR
    local JVM_ROOT

    if [ -f "${1}" ]; then
        _log "Loading config file: ${1}"
        . "${1}"

        _javadirs="${_javadirs}${_javadirs:+:}${JAVA_LIBDIR}:${JNI_LIBDIR}"
        _jvmdirs="${_jvmdirs}${_jvmdirs:+:}${JVM_ROOT}"
    else
        _log "Skipping config file ${1}: file does not exist"
    fi
}

# Load system and user Java configuration.
_load_java_conf()
{
    local IFS=:
    local java_home_save="${JAVA_HOME}"
    local java_opts_save="${JAVACMD_OPTS}"
    local javaconfdir
    local conf

    unset _javadirs
    unset _jvmdirs

    set -- ${JAVACONFDIRS:-/etc/java}

    _log "Java config directories are:"
    for javaconfdir; do
        _log "  * ${javaconfdir}"
    done

    for javaconfdir; do
        conf="${javaconfdir}/java.conf"
        if [ ! -f "${conf}" ]; then
            _err "Java configuration directory ${javaconfdir} was ignored because configuration file ${conf} does not exist"
        else
            _load_java_conf_file "${conf}"
        fi
    done

    _load_java_conf_file "${HOME}/.java/java.conf"

    _javadirs=${_javadirs:-/usr/share/java:/usr/lib/java}
    _jvmdirs=${_jvmdirs:-/usr/lib/jvm}

    if [ -d "${java_home_save}" ]; then
        JAVA_HOME="${java_home_save}"
    fi
    if [ -n "${java_opts_save}" ]; then
        JAVACMD_OPTS="${java_opts_save}"
    fi
}


# Test default JRE/JVM roots if nothing is defined yet
_set_java_home()
{
    local IFS=:
    local jvmdir
    local subdir
    local subdirs

    if [ -n "${JAVA_HOME}" ]; then
        if [ -z "${JVM_ROOT}" ]; then
            JVM_ROOT=$(readlink -f "${JAVA_HOME}"/.. || :)
        fi
        return
    fi

    case "${_prefer_jre}" in
        1|[Yy][Ee][Ss]|[Tt][Rr][Uu][Ee])
            subdirs=jre:java
            ;;
        *)
            subdirs=java:jre
            ;;
    esac

    for subdir in $subdirs; do
        for jvmdir in $_jvmdirs; do
            JVM_ROOT="${jvmdir}"
            JAVA_HOME="${jvmdir}/${subdir}"
            if [ -d "${JVM_ROOT}" -a -d "${JAVA_HOME}" ]; then
                _log "Using configured JVM_ROOT: ${JVM_ROOT}"
                _log "Using configured JAVA_HOME: ${JAVA_HOME}"
                return
            fi
        done
    done

    unset JVM_ROOT
    unset JAVA_HOME
}

# Set the java virtual machine
set_jvm()
{
    local IFS=:
    local cmd
    local cmds

    _set_java_home

    # use $JAVA_HOME if defined
    if [ -n "${JAVA_HOME}" ]; then
        return
    fi

    # try to find it from java command

    # try javac first, or we might get the location of the jre instead - djw
    # if JRE is prefered then don't try javac - mizdebsk
    case "${_prefer_jre}" in
        1|[Yy][Ee][Ss]|[Tt][Rr][Uu][Ee])
            cmds=java
            ;;
        *)
            cmds=javac:java
            ;;
    esac

    for cmd in $cmds; do
        cmd=$(which "${cmd}" 2>/dev/null || :)

        if [ -n "${cmd}" ]; then
            cmd=$(readlink -f "${cmd}")
            export JAVA_HOME=$(readlink -f "${cmd%/*}"/.. || :)
            return
        fi
    done

    echo "Can't find Java virtual machine, aborting."
    exit 1
}

# Set the classpath
set_classpath()
{
    local IFS

    _set_java_home

    # get local classpath first
    set -- ${@} ${ADDITIONAL_JARS}
    LOCAL_CLASSPATH=$("/usr/bin/build-classpath" ${@})

    # append original classpath if defined
    CLASSPATH=${LOCAL_CLASSPATH}${CLASSPATH:+:}${CLASSPATH}
}

set_javacmd()
{
    local IFS
    local cmd

    if [ -x "${JAVACMD}" ]; then
        return
    fi

    set_jvm

    # Add all sorts of jvm layouts here
    for cmd in jre/sh/java bin/java; do
        JAVACMD="${JAVA_HOME}/${cmd}"
        if [ -x "${JAVACMD}" ]; then
            _log "Using configured JAVACMD: $JAVACMD"
            JAVACMD="${JAVACMD}${JAVACMD_OPTS:+ }${JAVACMD_OPTS}"
            return 0
        fi
    done

    JAVACMD=$(which java 2>/dev/null || :)
    if [ -x "${JAVACMD}" ]; then
        _log "Using JAVACMD from PATH: $JAVACMD"
        JAVACMD="${JAVACMD}${JAVACMD_OPTS:+ }${JAVACMD_OPTS}"
        return 0
    fi

    _err "Failed to set JAVACMD"
    return 1
}

# Set flags
set_flags()
{
    FLAGS="${@}${ADDITIONAL_FLAGS:+ }${ADDITIONAL_FLAGS}"
}

# Set options
set_options()
{
    OPTIONS="${@}${ADDITIONAL_OPTIONS:+ }${ADDITIONAL_OPTIONS}"
}

# Run application
run()
{
    set_javacmd

    if [ -n "${VERBOSE}" ]; then
        echo "Java virtual machine used: ${JAVACMD}"
        echo "classpath used: ${CLASSPATH}"
        echo "main class used: ${MAIN_CLASS}"
        echo "flags used: ${FLAGS}"
        echo "options used: ${OPTIONS}"
        echo "arguments used: ${@}"
    fi

    # let's start
    exec "${JAVACMD}" ${FLAGS} -classpath "${CLASSPATH}" \
        ${OPTIONS} "${MAIN_CLASS}" "${@}"
}

# Set JVM-related directories
set_jvm_dirs()
{
    local IFS
    local re
    local option
    local version

    _set_java_home

    # Jar repository provided by the JVM
    JVM_LIBDIR=${JVM_ROOT}-exports/$(echo "${JAVA_HOME}" |\
        sed -n "s+${JVM_ROOT}/\([-_[:alnum:].]*\)\(.*\)+\1+p")

    # Java standard version of the JVM.  -fullversion seems to be lot faster
    # to invoke than -version.  Some examples:
    #   java full version "1.4.2_04-b05"
    #   java full version "J2RE 1.4.1 IBM build cxia321411-20030930"
    #   java full version "Blackdown-1.4.1-01"
    #   java version "1.5.0"

    re='\([[:digit:]]\{1,\}\.[[:digit:]]\{1,\}\(\.[[:digit:]]\{1,\}\)*\)'
    for option in -fullversion -version; do
        # Yuck, "grep -o" would be cleaner, but requires GNU grep >= 2.5.
        # This could be improved/simplified if sed had non-greedy matching.
        version=$(${JAVACMD} $option 2>&1 | sed -n \
            -e '/\(openjdk\|java\) \(full \)*version "/s/'$re'/<<<\1>>>/' \
            -e '/\(openjdk\|java\) \(full \)*version "/s/.*<<<\([^>]\{1,\}\)>>>.*/\1/p')
        if [ -n "${version}" ]; then
            _log "Determined Java version to be ${version}"
            break
        fi
    done

    if [ -z "${version}" ]; then
        echo "$0: Unable to determine Java version"
        return 1
    fi

    # Jar repository for this Java standard
    IFS=:
    _javaverdirs=
    for dir in ${_javadirs}; do
        _javaverdirs="${_javaverdirs}${_javaverdirs:+:}${dir}-${version}"
   done

    return 0
}


# Links a jar repository
link_jar_repository() {

   unset repository
   unset extension_list

   unset _LINK_CMD
   unset _PRESERVE_NAMING

   while [ $# -gt 0 ] ; do
      case "$1" in
         -h|--hard)
            _LINK_CMD="ln -f"
            ;;
         -s|--soft|--symbolic)
            _LINK_CMD="ln -fs"
            ;;
         -c|--copy)
            _LINK_CMD="cp -f"
            ;;
         -p|--preserve-naming)
            _PRESERVE_NAMING="true"
            [ -z "$_LINK_CMD" ] && _LINK_CMD="cp -f"
            ;;
         --|-)
            break
            ;;
         *)
            if [ -z "$repository" ] ; then
               repository=$1
               if ! [ -d "$repository" -a -w "$repository" ] ; then
                  _err "$1 must be a writable directory"
                  exit 1
               fi
            else
               extension_list="$extension_list $1"
            fi
            ;;
      esac
      shift
   done

   [ -z "$_LINK_CMD" ] && _LINK_CMD="ln -fs"
   extension_list="$extension_list $@"

   pushd $repository > /dev/null
      _ALLFOUND=0
      for extension in $extension_list ; do
         extension=$(echo $extension | sed 's+/$++g' | sed 's+\.jar$++g')
         found_extension=$(find_jar $extension)
         found=$?
         [ -z "$_PRESERVE_NAMING" ] \
            && extension=[$(echo $extension | sed 's+/+][+g')] \
            || extension=$(echo $extension | sed 's+/+_+g')
         if [ $found -eq 0 ] ; then
            if [ -d "$found_extension" ] ; then
               for jar in $(find "$found_extension" -follow -name "*.jar") ; do
                  rm -fr "$extension$(basename $jar)"
                  $_LINK_CMD $jar "$extension$(basename $jar)"
               done
            else
               rm -fr $extension.jar
               $_LINK_CMD $found_extension $extension.jar
            fi
         else
            # Defer failure to get list of all errors in one shot
            # Do create a symlink so we can recover with another jvm
            rm -fr $extension.jar
            ln -fs /could/not/find/extension/for/this/jvm $extension.jar
            _ALLFOUND=1
         fi
      done
   popd $repository > /dev/null
   return $_ALLFOUND
}


# Finds a specific extention (jar or directory)
find_jar()
{
    local IFS=:
    local artifact="${1}"
    local m2home="${M2_HOME:-/usr/share/xmvn}"

    # If artifact contains semicolon then assume it specifies Maven
    # artifact coordinates.
    set -- ${artifact}
    if [ ${#} -gt 1 ]; then
        _log "Using XMvn location: ${m2home}"
        if ! [ -x "${m2home}/bin/xmvn-resolve" ]; then
            echo "${0}: Unable to execute xmvn-resolve." >&2
            echo "${0}: Make sure that XMvn is installed and M2_HOME is set correctly." >&2
            return 1
        fi

        "${m2home}/bin/xmvn-resolve" -c "${artifact}"
        return ${?}
    fi

    set -- ${JVM_LIBDIR} ${_javaverdirs} ${_javadirs}

    _log "JAR search path is:"
    for dir; do
        _log "  * ${dir}"
    done

    for artifact in ${artifact%.jar} ${artifact%-*} ${artifact%/*}; do
        for dir; do
            _log "Trying file ${dir}/${artifact}.jar"
            if [ -r "${dir}/${artifact}.jar" ]; then
                echo "${dir}/${artifact}.jar"
                return 0
            fi
            _log "Trying dir  ${dir}/${artifact}/"
            if [ -d "${dir}/${artifact}" ]; then
                echo "${dir}/${artifact}"
                return 0
            fi
        done
    done

    _err "Could not find ${artifact} Java extension for this JVM"
    return 1
}


## Checks java environment
check_java_env()
{
    # This is usually set by set_jvm
    if [ -z "${JAVA_HOME}" ]; then
        _err "JAVA_HOME must be set"
        return 1
    fi

    if [ -z "${JAVACMD}" ]; then
        _err "JAVACMD must be set"
        return 2
    fi

    return 0
}


_load_java_conf

第二条消息直接来自/usr/bin/build-classpath:

#!/bin/sh
#
# Small script to build a classpath depending on the JVM used
#
# JPackage Project <http://www.jpackage.org/>
#
# $Id: build-classpath,v 1.2 2005/09/17 07:06:19 david Exp $

# Import java functions
[ -r "/usr/share/java-utils/java-functions" ] \
 &&  . "/usr/share/java-utils/java-functions" || exit 1

# Prints help message
usage() {
cat >&2 << EOF_USAGE
Usage: $0 <jar1> [<jar2> .. <jarn>]
jarX: name of a jar
      Example: jndi
EOF_USAGE
exit 2
}

[ "$#" -eq "0" ] && usage

set_javacmd || exit 3

check_java_env || exit 4

set_jvm_dirs || exit 5

_ALLFOUND="true"

for extension in "$@" ; do
    unset _JARS
    extension=$(find_jar $extension)
    if [ "$?" = 0 ] ; then
        if [ -d "$extension" ] ; then
            # Brute-force approach. If we can't specify a single jar, we can as
            # well take everything in the directory
            # This may create duplicates if symlinks point back inside the
            # directory structure, but who cares
            _JARS=$(find "$extension" -follow -name "*.jar" -type f -printf %p: 2>/dev/null)
        else
            _JARS=$extension:
        fi
        _CLASSPATH=$_CLASSPATH$_JARS
    else
        # Defer failure to get list of all errors in one shot
        _ALLFOUND="false"
    fi
done

# Cleanup trailing :
_CLASSPATH="$(echo $_CLASSPATH | sed 's+:$++g')"

# Echo classpath whether it's complete or not
# Apps that do not care about a full classpath can redirect errors to /dev/null
echo "$_CLASSPATH"

if [ "$_ALLFOUND" = "true" ] ; then
    exit 0
else
    echo "$0: error: Some specified jars were not found" >&2
    exit 6
fi

Answer 1

看起来您的 Java 安装有问题。 This text from Redhat here建议使用替代工具进行配置以仅选择 OpenJDK。在此 stackoverflow 问题 "What is wrong with my ant configuration?" 中记录了进一步修复此问题的尝试.但是好像归结为没有安装oracle JDK。

编辑: 根据评论，我将此解决方法添加到我的答案中，以防这些链接不起作用:那就是从 groovy-lang.org/download.html 下载 zip。解压它，将 JAVA_HOME 设置为正确的 JDK 目录并使用其中的 shell 脚本。该页面上还有 GVM 的说明，与纯 zip 相比，使用它安装 Groovy 更舒服一些。这仍然会绕过 Fedora 上的正确安装，因此应该仅在没有其他工作时使用它，或者如果您只想进行本地安装。