Java 程序在 eclipse 中运行但不在命令提示符中-6ren

Java 程序在 eclipse 中运行但不在命令提示符中

转载作者：行者123 更新时间：2023-11-30 10:53:06

我有一个自己构建的小项目，它是使用 Hibernate 5、Hibernate Search 5.5、Log4j2 用 Java 编写的，并访问 PostgreSQL 的 3 个数据库(其中 2 个验证它们的元数据，另一个创建内容)。

问题在于这是一种非常奇怪的行为，我正试图向大家解释一下。

当我在 Eclipse 中启动 Main 类时，程序按预期运行良好。当我生成 JAR 并使用命令 shell 执行它时，问题就来了……这是堆栈 trace .

Exception in thread "main" java.lang.ExceptionInInitializerError
Caused by: org.hibernate.service.UnknownServiceException: Unknown service requested [org.hibernate.search.hcore.impl.SearchFactoryReference]
        at org.hibernate.service.internal.AbstractServiceRegistryImpl.getService(AbstractServiceRegistryImpl.java:184)
        at org.hibernate.search.hcore.impl.HibernateSearchSessionFactoryObserver.sessionFactoryCreated(HibernateSearchSessionFactoryObserver.java:86)
        at org.hibernate.internal.SessionFactoryObserverChain.sessionFactoryCreated(SessionFactoryObserverChain.java:35)
        at org.hibernate.internal.SessionFactoryImpl.<init>(SessionFactoryImpl.java:541)
        at org.hibernate.boot.internal.SessionFactoryBuilderImpl.build(SessionFactoryBuilderImpl.java:444)
        at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:708)
        at dao.paradasws.ServiceDaoParadasWs.getSessionFactory(ServiceDaoParadasWs.java:89)
        at dao.AbstractDao.<init>(AbstractDao.java:27)
        at dao.paradasws.ServiceDaoParadasWs.<init>(ServiceDaoParadasWs.java:36)
        at tasks.Main.<clinit>(Main.java:49)

我获取异常的方法如下:

@Override
protected SessionFactory getSessionFactory() throws HibernateException {

    if(getFactory() == null){
        // Configuramos hibernate:
        Configuration cfg = new Configuration();
        // Dialecto PostgreSQL:
        //cfg.setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQL9Dialect");
        // Dialecto Postgis:
        cfg.setProperty("hibernate.dialect", "org.hibernate.spatial.dialect.postgis.PostgisDialect");
        cfg.setProperty("hibernate.connection.driver_class", "org.postgresql.Driver");

        // Linux Server
        cfg.setProperty("hibernate.connection.url", "jdbc:postgresql://localhost:5432/database");
        cfg.setProperty("hibernate.connection.username", "postgres");
        cfg.setProperty("hibernate.connection.password", "postgres");

        cfg.setProperty("hibernate.hbm2ddl.auto", "validate");
        cfg.setProperty("show_sql", "true");
        cfg.setProperty("hibernate.connection.pool_size", "5000");

        // C3p0 connection pool
//      cfg.setProperty("connection.provider_class", "org.hibernate.connection.C3P0ConnectionProvider");
//      cfg.setProperty("c3p0.min_size", "7");
//      cfg.setProperty("c3p0.max_size", "1000");
//      cfg.setProperty("c3p0.timeout", "1000");
//      cfg.setProperty("c3p0.idle_test_period", "2000");
//      cfg.setProperty("c3p0.preferredTestQuery", "select 1;");
//      cfg.setProperty("hibernate.connection.release_mode", "after_transaction");

        // Hibernate search:
        cfg.setProperty("hibernate.search.default.directory_provider", "filesystem");
        cfg.setProperty("hibernate.search.default.indexBase", "indexLucene");

        cfg.setProperty("hibernate.current_session_context_class", "thread");

        cfg.addAnnotatedClass(OperadorWS.class);
        cfg.addAnnotatedClass(ParadaWS.class);

        StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder();
        builder.applySettings(cfg.getProperties());
        StandardServiceRegistry serviceRegistry = builder.build();
        setFactory(cfg.buildSessionFactory(serviceRegistry));

        setStats(getFactory().getStatistics());
        getStats().setStatisticsEnabled(true);

    }

    return super.getFactory();

}

为了以防万一，我发布了我的 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.mycompany</groupId>
    <artifactId>autom</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <build>
        <plugins>
            <plugin>
                <!-- NOTE: We don't need a groupId specification because the group is
                     org.apache.maven.plugins ...which is assumed by default.
                 -->
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                            <classpathMavenRepositoryLayout>true</classpathMavenRepositoryLayout>
                            <mainClass>tasks.Main</mainClass>
                            <addExtensions>true</addExtensions>
                            <classpathLayoutType>repository</classpathLayoutType>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id> <!-- this is used for inheritance merges -->
                        <phase>package</phase> <!-- bind to the packaging phase -->
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.6</version>

                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                            <classpathMavenRepositoryLayout>true</classpathMavenRepositoryLayout>
                            <mainClass>tasks.Main</mainClass>
                            <addExtensions>true</addExtensions>
                            <classpathLayoutType>repository</classpathLayoutType>
                        </manifest>
                    </archive>
                </configuration>

            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <!-- or whatever version you use -->
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>

        <commons-lang.version>3.4</commons-lang.version>    
        <commons-csv.version>1.2</commons-csv.version>
        <log4j.version>2.4.1</log4j.version>
        <postgresql-jdbc.version>9.1-901.jdbc4</postgresql-jdbc.version>
        <hibernate.version>5.0.5.Final</hibernate.version>
        <hibernate-validator.version>5.2.2.Final</hibernate-validator.version>
        <javax-el-api.version>2.2.4</javax-el-api.version>
        <hibernate-search.version>5.5.1.Final</hibernate-search.version>
        <simmetrics.version>4.0.1</simmetrics.version>
    </properties>

    <dependencies>

        <!-- Commons CSV -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-csv</artifactId>
            <version>${commons-csv.version}</version>
        </dependency>

        <!-- Apache Commons Lang -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang.version}</version>
        </dependency>

        <!-- Log4j -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j.version}</version>
        </dependency>
<!--        <dependency> -->
<!--            <groupId>org.apache.logging.log4j</groupId> -->
<!--            <artifactId>log4j-slf4j-impl</artifactId> -->
<!--            <version>${log4j.version}</version> -->
<!--        </dependency> -->
        <!--HIBERNATE LOGGER (log4j)-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.6</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- Old JDBC4 for PostgreSQL 9.1 -->
        <dependency>
            <groupId>postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>${postgresql-jdbc.version}</version>
        </dependency>

        <!-- Hibernate -->
        <dependency><!-- Core -->
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency><!-- c3p0 -->
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency><!-- postgis/spatial -->
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-spatial</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency><!-- hibernate validator -->
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>${hibernate-validator.version}</version>
        </dependency>
            <dependency>
                <groupId>javax.el</groupId>
                <artifactId>javax.el-api</artifactId>
                <version>${javax-el-api.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.transaction</groupId>
                <artifactId>jta</artifactId>
                <version>1.1</version>
            </dependency>
        <dependency><!-- hibernate search -->
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-search-orm</artifactId>
            <version>${hibernate-search.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-search-engine</artifactId>
            <version>${hibernate-search.version}</version>
        </dependency>

        <dependency>
            <groupId>com.github.mpkorstanje</groupId>
            <artifactId>simmetrics-core</artifactId>
            <version>${simmetrics.version}</version>
        </dependency>

    </dependencies>

</project>

有人知道为什么我会收到这个奇怪的错误吗？

编辑:

根据要求，我将发布整个类和父类(super class)。

抽象DAO:

package dao;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.search.FullTextSession;
import org.hibernate.search.Search;
import org.hibernate.search.SearchFactory;
import org.hibernate.stat.Statistics;

public abstract class AbstractDao {

    private Session currentSession;
    private Transaction currentTransaction;
    private SessionFactory factory;

    private Statistics stats;

    /**
     * Hibernate Search Engine
     */
    private FullTextSession fullTextSession = null;
    private SearchFactory searchFactory = null;

    protected AbstractDao(){
        factory = getSessionFactory();
    }

    public Session openCurrentSession() throws HibernateException {
        if(currentSession == null || !currentSession.isOpen())
            currentSession = factory.openSession();
        return currentSession;
    }

    public Session openCurrentSessionwithTransaction() throws HibernateException {
        if(currentSession == null || !currentSession.isOpen())
            currentSession = factory.openSession();
        currentTransaction = currentSession.beginTransaction();
        return currentSession;
    }

    public void closeCurrentSession() {
        currentSession.close();
    }

    public void closeCurrentSessionwithTransaction() {
        currentTransaction.commit();
        currentSession.close();
    }

    protected abstract SessionFactory getSessionFactory() throws HibernateException;

    public Session getCurrentSession() {
        return currentSession;
    }

    public void setCurrentSession(Session currentSession) {
        this.currentSession = currentSession;
    }

    public Transaction getCurrentTransaction() {
        return currentTransaction;
    }

    public void setCurrentTransaction(Transaction currentTransaction) {
        this.currentTransaction = currentTransaction;
    }

    public void commitTransaction(){
        if(currentTransaction != null)
            currentTransaction.commit();
    }

    public void rollbackTransaction(){
        if(currentTransaction != null)
            currentTransaction.rollback();
    }

    /**

        @return the factory
     */
    public SessionFactory getFactory() {
        return factory;
    }

    /**

        @param factory the factory to set
     */
    public void setFactory(SessionFactory factory) {
        this.factory = factory;
    }

    /**

        @return the stats
     */
    public Statistics getStats() {
        return stats;
    }

    /**

        @param stats the stats to set
     */
    public void setStats(Statistics stats) {
        this.stats = stats;
    }

    /**

        @return the fullTextSession
     */
    public FullTextSession getFullTextSession() {
        return fullTextSession;
    }

    /**

        @param fullTextSession the fullTextSession to set
     */
    public void setFullTextSession(FullTextSession fullTextSession) {
        this.fullTextSession = fullTextSession;
    }

    protected SearchFactory getHibernateSearch(){
        if(fullTextSession == null){
            fullTextSession = Search.getFullTextSession(getCurrentSession());
        }
        if(searchFactory == null){
            searchFactory = fullTextSession.getSearchFactory();
        }
        return searchFactory;
    }

    /**

        @return the searchFactory
     */
    public SearchFactory getSearchFactory() {
        return searchFactory;
    }

    /**

        @param searchFactory the searchFactory to set
     */
    public void setSearchFactory(SearchFactory searchFactory) {
        this.searchFactory = searchFactory;
    }

    public void finish() throws Throwable{
        Session session = getCurrentSession();
        if(session != null)
            session.close();
        if(factory != null)
            factory.close();
    }

}

ServiceDAOParadasWS 类:

package dao.paradasws;

import java.util.List;

import org.apache.lucene.search.Query;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
import org.hibernate.search.FullTextQuery;
import org.hibernate.search.FullTextSession;
import org.hibernate.search.SearchFactory;
import org.hibernate.search.query.dsl.QueryBuilder;

import dao.AbstractDao;
import model.paradasws.OperadorWS;
import model.paradasws.ParadaWS;

public class ServiceDaoParadasWs extends AbstractDao implements IDaoParadasWs {

    public ServiceDaoParadasWs(){
        super();
    }

    @Override
    protected SessionFactory getSessionFactory() throws HibernateException {
        // already posted
    }

    @Override
    public List<ParadaWS> getParadas() {
        openCurrentSession();
        @SuppressWarnings("unchecked")
        List<ParadaWS> paradasWs = (List<ParadaWS>) getCurrentSession().createQuery("from ParadaWS").list();

        return paradasWs;
    }

    @Override
    public List<ParadaWS> getParadaPorNombre(String pDescripcionCorta, OperadorWS pOperador) {
        openCurrentSession();

        Criteria c = getCurrentSession().createCriteria(ParadaWS.class);
        c.add(
            Restrictions.and(
                    Restrictions.eq("descripcionCorta", pDescripcionCorta).ignoreCase(),
                    Restrictions.eq("operador", pOperador)
            )
        );

        @SuppressWarnings("unchecked")
        List<ParadaWS> paradas = c.list();

        return paradas;
    }

    @Override
    public OperadorWS getOperador(Integer pId) {
        openCurrentSession();
        Criteria c = getCurrentSession().createCriteria(OperadorWS.class);//createQuery("from OperadorWS op where op.codigoOperador=:id");
        c.add(Restrictions.eq("codigoOperador", pId));

        OperadorWS op = (OperadorWS) c.uniqueResult();

        return op;
    }

    public void indexarParadas(){
        openCurrentSession();
        getHibernateSearch();
        FullTextSession txtSession = getFullTextSession();
        txtSession.getTransaction().begin();
        @SuppressWarnings("unchecked")
        List<ParadaWS> paradas = txtSession.createQuery("from ParadaWS").list();
        for (ParadaWS paradaWS : paradas) {
            txtSession.index(paradaWS);
        }
        txtSession.getTransaction().commit();
    }

    @SuppressWarnings("unchecked")
    public List<ParadaWS> buscarSimilitudesNombreParada(String pNombreCorto){
        openCurrentSession();
        SearchFactory fact = getHibernateSearch();
        FullTextSession txtSession = getFullTextSession();
        QueryBuilder b = fact.buildQueryBuilder().forEntity(ParadaWS.class).get();

        Query query = b.keyword()
            .fuzzy()
                .withEditDistanceUpTo(2)
            .onField("descripcionCorta")
            .matching(pNombreCorto)
            .createQuery();

        FullTextQuery txtQuery = txtSession.createFullTextQuery(query, ParadaWS.class);

        return (List<ParadaWS>) txtQuery.list();

    }

}

注意AbstractDAO的实现者必须重写getSessionFactory()方法(此处引发异常)

最佳答案

该错误意味着当 Hibernate ORM SessionFactory 启动时，在类路径中找不到 Hibernate Search 服务。

这些类似乎在那里(因为您有一个 org.hibernate.search.hcore.impl.HibernateSearchSessionFactoryObserver 已成功加载到您的堆栈跟踪中)。

所以我可以猜测 maven-assembly-plugin 插件未能包含来自 Hibernate Search jar 的服务定义。

具体来说，您似乎缺少 META-INF/services/ 中的这些定义:

https://github.com/hibernate/hibernate-search/tree/5.5.1.Final/orm/src/main/resources/META-INF/services

我对那些 Maven 插件不够熟悉，无法向您建议应该如何配置它，但我认为它可以使用不同的配置。

我会建议先尝试让它工作，而不是尝试重新打包:使用带有我们发布的原始 jar 的普通类路径应该就可以了。

关于Java 程序在 eclipse 中运行但不在命令提示符中，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34133694/

文章推荐： ios - iOS 键盘显示通知扩展

文章推荐： java - 具有持久性的实体类中的 Id 与引用

文章推荐： javascript正则表达式单行

文章推荐： Java 的 HttpCookie 类

C 程序我想知道是否有办法简化我的 dayofyear 程序？
我是 C 语言新手，我编写了这个 C 程序，让用户输入一年中的某一天，作为返回，程序将输出月份以及该月的哪一天。该程序运行良好，但我现在想简化该程序。我知道我需要一个循环，但我不知道如何去做。这是程序
java - GUI Java 程序 - Paint 程序
我一直在努力找出我的代码有什么问题。这个想法是创建一个小的画图程序，并有红色、绿色、蓝色和清除按钮。我有我能想到的一切让它工作，但无法弄清楚代码有什么问题。程序打开，然后立即关闭。 import ja
homebrew - 从 Homebrew 程序/欺骗程序到 Homebrew 程序/核心的迁移是什么？
我想安装screen，但是接下来我应该做什么？ $ brew search screen imgur-screenshot screen
python - 客户端(python 程序)没有收到服务器(c 程序)返回的响应？
我有一个在服务器端工作的 UDP 套接字应用程序。为了测试服务器端，我编写了一个简单的 python 客户端程序，它发送消息“hello world how are you”。服务器随后应接收消息，将
python - 运行一个 shell 脚本，该脚本运行一个 python 程序，然后运行一个 R 程序
我有一个 shell 脚本，它运行一个 Python 程序来预处理一些数据，然后运行一个 R 程序来执行一些长时间运行的任务。我正在学习使用 Docker 并且我一直在运行 FROM r-base:l
python - 在 Linux 中从 Python 启动一个 c 程序，将一个大文本字符串作为参数传递给 c 程序
在 Linux 中。我有一个 c 程序，它读取一个 2048 字节的文本文件作为输入。我想从 Python 脚本启动 c 程序。我希望 Python 脚本将文本字符串作为参数传递给 c 程序，而不是将
VHDL 程序
对于一个类，我被要求编写一个 VHDL 程序，该程序接受两个整数输入 A 和 B，并用 A+B 替换 A，用 A-B 替换 B。我编写了以下程序和测试平台。它完成了实现和行为语法检查，但它不会模拟。尽
haskell 程序
module Algorithm where import System.Random import Data.Maybe import Data.List type Atom = String ty
求给定N个数的最小公倍数的C++程序
我想找到两个以上数字的最小公倍数求给定N个数的最小公倍数的C++程序最佳答案 int lcm(int a, int b) { return (a/gcd(a,b))*b; } 对于gcd，请查看
索引器的c#程序
这个程序有错误。谁能解决这个问题？ Error is :TempRecord already defines a member called 'this' with the same paramete
铁路围栏密码的C++程序
当我运行下面的程序时，我在 str1 和 str2 中得到了垃圾值。所以 #include #include #include using namespace std; int main() {
死兔子的C++程序
这是我的作业: 一对刚出生的兔子(一公一母)被放在田里。兔子在一个月大时可以交配，因此在第二个月的月底，每对兔子都会生出两对新兔子，然后死去。注:在第0个月，有0对兔子。第 1 个月，有 1 对兔子
十进制转十六进制的C++程序
我编写了一个程序，通过对字母使用 switch 命令将十进制字符串转换为十六进制，但是如果我使用 char，该程序无法正常工作!没有 switch 我无法处理 9 以上的数字。我希望你能理解我，因为我
连接MySQL的C++程序
我是 C++ 新手(虽然我有一些 C 语言经验)和 MySQL，我正在尝试制作一个从 MySQL 读取数据库的程序，我一直在关注这个 tutorial但当我尝试“构建”解决方案时出现错误。 (我正在使
Swift If 程序
仍然是一个初学者，只是尝试使用 swift 中的一些基本函数。有人能告诉我这段代码有什么问题吗？ import UIKit var guessInt: Int var randomNum = arc
折叠常量的C++程序
我正在用 C++11 编写一个函数，它采用 constant1 + constant2 形式的表达式并将它们折叠起来。 constant1 和 constant2 存储在 std::string 中，
2个矩阵相加和相乘的C++程序
我用 C++ 编写了这段代码，使用运算符重载对 2 个矩阵进行加法和乘法运算。当我执行代码时，它会在第 57 行和第 59 行产生错误，非法结构操作(两行都出现相同的错误)。请解释我的错误。提前致谢:
交换字符串中两个字符的C++程序
我是 C++ 的初学者，我想编写一个简单的程序来交换字符串中的两个字符。例如；我们输入这个字符串:“EXAMPLE”，我们给它交换这两个字符:“E”和“A”，输出应该类似于“AXEMPLA”。我在
确定三角形的C++程序
我需要以下代码的帮助: 声明 3 个 double 类型变量，每个代表三角形的三个边中的一个。提示用户为第一面输入一个值，然后将用户的输入设置为您创建的代表三角形第一条边的变量。将最后 2 个步
矩阵旋转的c++程序
我是新来的，如果问题不好请见谅任务:将给定矩阵旋转180度输入: 1 4 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 输出: 16 15 14 13 12 11

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

Java 程序在 eclipse 中运行但不在命令提示符中