使用Spring使用MongoDB服务时出现异常

我创建了一个简单的项目“使用SpringData的mongoDB”来读写mongoDB。项目按预期进行。现在，当我尝试将该项目集成到另一个现有的独立Java项目时，我看到了一个例外。 为了进一步调试这个问题，我在独立Java应用程序中添加了这两行代码

mongo=newmongoclient（“xx.xx.xx.xx”）；
SimpleMongoDbFactory SimpleMongoDbFactory=新的SimpleMongoDbFactory（mongo，“MongoDBName”）；

到目前为止没有异常，但是当我添加下面的行时，我得到一个异常

    MongoTemplate mongoTemplate = new MongoTemplate(mongo, "MongoDBName" );

有人能告诉我为什么我会看到这个错误吗？我可以在不使用SpringData的情况下让它工作

使用的罐子：

mongo-java-driver-2.11.1.jar、spring-data-mongodb-1.2.1.RELEASE.jar、spring-data-commons-1.5.1.RELEASE.jar、spring-tx-4.0.2.RELEASE.jar、cglib-2.2.jar

应用程序日志文件中的异常堆栈跟踪：

java.lang.NullPointerException
位于org.springframework.core.SerializableTypeWrapper$TypeProxyInvocationHandler.invoke（SerializableTypeWrapper.java:239）
位于org.springframework.core.$Proxy0.hashCode（未知源代码）
位于org.springframework.util.ObjectUtils.nullSafeHashCode（ObjectUtils.java:273）
位于org.springframework.core.ResolvableType.hashCode（ResolvableType.java:779）
位于org.springframework.util.ConcurrentReferenceHashMap.getHash（ConcurrentReferenceHashMap.java:214）
位于org.springframework.util.ConcurrentReferenceHashMap.getReference（ConcurrentReferenceHashMap.java:246）
位于org.springframework.util.ConcurrentReferenceHashMap.get（ConcurrentReferenceHashMap.java:226）
位于org.springframework.core.ResolvableType.forType（ResolvableType.java:1154）
位于org.springframework.core.ResolvableType.forType（ResolvableType.java:1133）
位于org.springframework.core.ResolvableType.forTypes（ResolvableType.java:812）
位于org.springframework.core.ResolvableType.getInterfaces（ResolvableType.java:388）
位于org.springframework.core.ResolvableType.as（ResolvableType.java:350）
位于org.springframework.core.convert.support.GenericConversionService.getRequiredTypeInfo（GenericConversionService.java:266）
位于org.springframework.core.convert.support.GenericConversionService.addConverterFactory（GenericConversionService.java:103）
位于org.springframework.core.convert.support.DefaultConversionService.addScalarConverters（DefaultConversionService.java:79）
位于org.springframework.core.convert.support.DefaultConversionService.addDefaultConverters（DefaultConversionService.java:63）
位于org.springframework.core.convert.support.DefaultConversionService。（DefaultConversionService.java:50）
位于org.springframework.core.convert.support.ConversionServiceFactory.createDefaultConversionService（ConversionServiceFactory.java:69）
位于org.springframework.data.mongodb.core.convert.MappingMongoConverter。（MappingMongoConverter.java:100）
位于org.springframework.data.mongodb.core.MongoTemplate.getDefaultMongoConverter（MongoTemplate.java:1692）
位于org.springframework.data.mongodb.core.MongoTemplate（MongoTemplate.java:189）
位于org.springframework.data.mongodb.core.MongoTemplate（MongoTemplate.java:154）
位于com.rccl.promotions.processor.AbstractPromotionProcessor.process（AbstractPromotionProcessor.java:92）
在com.rccl.promotions.processor.MessageProcessor.process（MessageProcessor.java:73）上
在com.rccl.promotions.messageadapter.processor.MessageProcessorTest.TestGetVoyageBestatePromotion_step1（MessageProcessorTest.java:66）
在sun.reflect.NativeMethodAccessorImpl.invoke0（本机方法）处
位于sun.reflect.NativeMethodAccessorImpl.invoke（NativeMethodAccessorImpl.java:76）
在sun.reflect.DelegatingMethodAccessorImpl.invoke（DelegatingMethodAccessorImpl.java:43）中
位于java.lang.reflect.Method.invoke（Method.java:607）
位于junit.framework.TestCase.runTest（TestCase.java:168）
位于junit.framework.TestCase.runBare（TestCase.java:134）
位于junit.framework.TestResult$1.protect（TestResult.java:110）
位于junit.framework.TestResult.runProtected（TestResult.java:128）
运行（TestResult.java:113）
运行（TestCase.java:124）
位于junit.framework.TestSuite.runTest（TestSuite.java:232）
运行（TestSuite.java:227）
位于org.junit.internal.runners.JUnit38ClassRunner.run（JUnit38ClassRunner.java:83）
位于org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run（JUnit4TestReference.java:49）
位于org.eclipse.jdt.internal.junit.runner.TestExecution.run（TestExecution.java:38）
在org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests（RemoteTestRun`在这里输入代码`ner.java:467）
位于org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests（RemoteTestRunner.java:683）
位于org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run（RemoteTestRunner.java:390）
位于org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main（RemoteTestRunner.java:197）

检查您的Spring应用程序上下文，为了方便起见，您可以使用他们与mongo相关的命名空间支持：

<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:mongo="http://www.springframework.org/schema/data/mongo"
   xsi:schemaLocation="http://www.springframework.org/schema/data/mongo
      http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <mongo:mongo id="mongo" host="127.0.0.1" port="27017" />
    <mongo:db-factory id="mongoDbFactory" mongo-ref="mongo" dbname="MongoDBName" />

    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
    </bean>

    <mongo:repositories base-package="path.to.your.repository.packages"/>

</beans>

---

您可以在上查看我的已设置示例

之所以会发生这种情况，是因为您的项目同时具有Spring3.0和Spring4.0+作为依赖项（因为这两个版本具有不同的工件名称，是的，这两个版本可以共存！）。两个版本都有这个类'ObjectUtils.java'，但它们的'nullSafeHashCode'方法的实现不同

以spring 2.x和spring 4.x为例： 在v2中

在v4中

public static boolean nullSafeEquals(Object o1, Object o2) {
    if (o1 == o2) {
        return true;
    }
    if (o1 == null || o2 == null) {
        return false;
    }
    if (o1.equals(o2)) {
        return true;
    }
    if (o1.getClass().isArray() && o2.getClass().isArray()) {
        if (o1 instanceof Object[] && o2 instanceof Object[]) {
            return Arrays.equals((Object[]) o1, (Object[]) o2);
        }
        if (o1 instanceof boolean[] && o2 instanceof boolean[]) {
            return Arrays.equals((boolean[]) o1, (boolean[]) o2);
        }
        if (o1 instanceof byte[] && o2 instanceof byte[]) {
            return Arrays.equals((byte[]) o1, (byte[]) o2);
        }
        if (o1 instanceof char[] && o2 instanceof char[]) {
            return Arrays.equals((char[]) o1, (char[]) o2);
        }
        if (o1 instanceof double[] && o2 instanceof double[]) {
            return Arrays.equals((double[]) o1, (double[]) o2);
        }
        if (o1 instanceof float[] && o2 instanceof float[]) {
            return Arrays.equals((float[]) o1, (float[]) o2);
        }
        if (o1 instanceof int[] && o2 instanceof int[]) {
            return Arrays.equals((int[]) o1, (int[]) o2);
        }
        if (o1 instanceof long[] && o2 instanceof long[]) {
            return Arrays.equals((long[]) o1, (long[]) o2);
        }
        if (o1 instanceof short[] && o2 instanceof short[]) {
            return Arrays.equals((short[]) o1, (short[]) o2);
        }
    }
    return false;
}

在spring data mongodb中

public static boolean nullSafeEquals(Object o1, Object o2) {
    if (o1 == o2) {
        return true;
    }
    if (o1 == null || o2 == null) {
        return false;
    }
    if (o1.equals(o2)) {
        return true;
    }
    if (o1.getClass().isArray() && o2.getClass().isArray()) {
        if (o1 instanceof Object[] && o2 instanceof Object[]) {
            return Arrays.equals((Object[]) o1, (Object[]) o2);
        }
        if (o1 instanceof boolean[] && o2 instanceof boolean[]) {
            return Arrays.equals((boolean[]) o1, (boolean[]) o2);
        }
        if (o1 instanceof byte[] && o2 instanceof byte[]) {
            return Arrays.equals((byte[]) o1, (byte[]) o2);
        }
        if (o1 instanceof char[] && o2 instanceof char[]) {
            return Arrays.equals((char[]) o1, (char[]) o2);
        }
        if (o1 instanceof double[] && o2 instanceof double[]) {
            return Arrays.equals((double[]) o1, (double[]) o2);
        }
        if (o1 instanceof float[] && o2 instanceof float[]) {
            return Arrays.equals((float[]) o1, (float[]) o2);
        }
        if (o1 instanceof int[] && o2 instanceof int[]) {
            return Arrays.equals((int[]) o1, (int[]) o2);
        }
        if (o1 instanceof long[] && o2 instanceof long[]) {
            return Arrays.equals((long[]) o1, (long[]) o2);
        }
        if (o1 instanceof short[] && o2 instanceof short[]) {
            return Arrays.equals((short[]) o1, (short[]) o2);
        }
    }
    return false;
}