org.glassfish.jersey.test.grizzly.GrizzlyTestContainerFactory.create（Ljava/net/URI；Lorg/glassfish/jersey/test/DeploymentContext；

我正在准备一个有一些测试用例的应用程序，这个应用程序正在使用JERSY api来提供REST服务。如果没有测试用例，它将是一个成功的构建，但是当我使用JUNIT编写测试用例时，我得到了错误

控制台出现以下日志错误：

java.lang.AbstractMethodError: org.glassfish.jersey.test.grizzly.GrizzlyTestContainerFactory.create(Ljava/net/URI;Lorg/glassfish/jersey/test/DeploymentContext;)Lorg/glassfish/jersey/test/spi/TestContainer;
    at org.glassfish.jersey.test.JerseyTest.createTestContainer(JerseyTest.java:277)
    at org.glassfish.jersey.test.JerseyTest.setUp(JerseyTest.java:609)
    at com.verizon.uis.rest.mock.RestServiceTestBase.setUp(RestServiceTestBase.java:90)
    at com.verizon.uis.rest.resources.AuthIdentityTest.setUp(AuthIdentityTest.java:128)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
    at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:24)
    at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:27)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.apache.maven.surefire.junit4.JUnit4Provider.execute(JUnit4Provider.java:252)
    at org.apache.maven.surefire.junit4.JUnit4Provider.executeTestSet(JUnit4Provider.java:141)
    at org.apache.maven.surefire.junit4.JUnit4Provider.invoke(JUnit4Provider.java:112)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.apache.maven.surefire.util.ReflectionUtils.invokeMethodWithArray(ReflectionUtils.java:189)
    at org.apache.maven.surefire.booter.ProviderFactory$ProviderProxy.invoke(ProviderFactory.java:165)
    at org.apache.maven.surefire.booter.ProviderFactory.invokeProvider(ProviderFactory.java:85)
    at org.apache.maven.surefire.booter.ForkedBooter.runSuitesInProcess(ForkedBooter.java:115)
    at org.apache.maven.surefire.booter.ForkedBooter.main(ForkedBooter.java:75)

restestbaseclass

扩展了

JerssyTest

类。因此，当我们在JUNIT案例中检查此api时，我们得到了所述错误。下面是

restestbaseclass

类

public abstract class RestServiceTestBase extends JerseyTest {

    private static final Logger LOGGER = Logger
            .getLogger(RestServiceTestBase.class.getName());

    protected static MemoryHandler logHandler = new MemoryHandler();

    public RestServiceTestBase() throws TestContainerException {
        super();
    }

    public RestServiceTestBase(final TestContainerFactory testContainerFactory) {
        super(testContainerFactory);
    }

    @Override
    protected Application configure() {
        return new RestApplicationBase();
    }

    @BeforeClass
    public static void setupOnce() throws Exception {
        System.setProperty(TestProperties.CONTAINER_PORT,
                String.valueOf(getPort(0)));

        System.setProperty(TestProperties.RECORD_LOG_LEVEL,
                String.valueOf(Level.ALL.intValue()));

        final LogManager lm = LogManager.getLogManager();
        final Enumeration<String> loggers = lm.getLoggerNames();
        while (loggers.hasMoreElements()) {
            final String name = loggers.nextElement();
            final Logger logger = lm.getLogger(name);
            if (logger != null && logHandler != null) {
                logger.addHandler(logHandler);
            }
        }
    }

    @Override
    public void setUp() throws Exception {
        super.setUp();

        final ConfigurationManager cm = SingletonFactory
                .getInstance(ConfigurationManager.class);

        final InMemoryConfiguration apigee = new InMemoryConfiguration(
                Configuration.CTX_APIGEE);
        cm.registerConfiguration(apigee);
        apigee.setSetting("API_MIN_VERSION", "1");
        apigee.setSetting("API_MAX_VERSION", "6");
    }

    protected <R> R post(final WebTarget resource,
            final Map<String, Object> headers, final String mediaType,
            final Class<R> responseClass, final Object entity)
            throws JAXBException {
        final Response response = WebServiceUtil.post(resource, headers,
                mediaType, entity);
        assertNotNull(response);

        assertEquals("Unexpected Media Type", mediaType, response
                .getMediaType().toString());

        final R postResponse = response.readEntity(responseClass);
        assertNotNull(postResponse);
        print(responseClass, postResponse, mediaType);
        return postResponse;
    }

    protected <R> R post(final WebTarget resource,
            final Map<String, Object> headers, final Class<R> responseClass,
            final Object entity) throws JAXBException {
        return post(resource, headers, MediaType.APPLICATION_XML,
                responseClass, entity);
    }

    protected <R> R post(final WebTarget resource,
            final Class<R> responseClass, final Object entity)
            throws JAXBException {
        return post(resource, null, MediaType.APPLICATION_XML, responseClass,
                entity);
    }

    protected <R> R put(final WebTarget resource,
            final Map<String, Object> headers, final String mediaType,
            final Class<R> responseClass, final Object entity)
            throws JAXBException {
        final Response response = WebServiceUtil.put(resource, headers,
                mediaType, entity);
        assertNotNull(response);
        assertEquals("Unexpected Media Type", mediaType, response
                .getMediaType().toString());

        final R putResponse = response.readEntity(responseClass);
        assertNotNull(putResponse);
        print(responseClass, putResponse, mediaType);
        return putResponse;
    }

    protected <R> R put(final WebTarget resource,
            final Map<String, Object> headers, final Class<R> responseClass,
            final Object entity) throws JAXBException {
        return put(resource, headers, MediaType.APPLICATION_XML, responseClass,
                entity);
    }

    protected <R> R put(final WebTarget resource, final Class<R> responseClass,
            final Object entity) throws JAXBException {
        return put(resource, null, MediaType.APPLICATION_XML, responseClass,
                entity);
    }

    @SuppressWarnings("unchecked")
    protected <R> R get(final WebTarget resource,
            final Map<String, Object> headers, final String mediaType,
            final Class<R> responseClass) throws JAXBException {
        final Response response = WebServiceUtil.get(resource, headers,
                mediaType);
        assertNotNull("Response is null!", response);
        assertNotNull("Response media type is null!", response.getMediaType());
        assertEquals("Unexpected Media Type", mediaType, response
                .getMediaType().toString());

        if (Response.class.equals(responseClass)) {
            return (R) response;
        }
        final R getResponse = response.readEntity(responseClass);
        if (mediaType != null && "application/pdf".equalsIgnoreCase(mediaType)) {
            return getResponse;
        }

        assertNotNull(getResponse);
        print(responseClass, getResponse, mediaType);
        return getResponse;
    }

    protected <R> R get(final WebTarget resource, final Class<R> responseClass)
            throws JAXBException {
        return get(resource, null, MediaType.APPLICATION_XML, responseClass);
    }

    protected <R> R delete(final WebTarget resource,
            final Map<String, Object> headers, final String mediaType,
            final Class<R> responseClass, final Object entity)
            throws JAXBException {
        final Response response = WebServiceUtil.delete(resource, headers,
                mediaType, entity);
        assertNotNull(response);
        assertEquals("Unexpected Media Type", mediaType, response
                .getMediaType().toString());

        final R deleteResponse = response.readEntity(responseClass);
        assertNotNull(deleteResponse);
        print(responseClass, deleteResponse, mediaType);
        return deleteResponse;
    }

    protected <R> R delete(final WebTarget resource,
            final Class<R> responseClass, final Object entity)
            throws JAXBException {
        return delete(resource, null, MediaType.APPLICATION_XML, responseClass,
                entity);
    }

    protected <J> void print(final Class<J> jaxbClass, final J jaxbObject,
            final String mediaType) throws JAXBException {
        if (MediaType.APPLICATION_JSON.equalsIgnoreCase(mediaType)) {
            printJson(jaxbClass, jaxbObject);
        } else {
            printXml(jaxbClass, jaxbObject);
        }
    }

    protected <J> void printXml(final Class<J> jaxbClass, final J jaxbObject)
            throws JAXBException {
        final JAXBContext jaxbContext = JAXBContext.newInstance(jaxbClass);
        final Marshaller jaxbMarshaller = jaxbContext.createMarshaller();

        // output pretty printed
        jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

        jaxbMarshaller.marshal(jaxbObject, System.out);
    }

    protected <J> void printJson(final Class<J> jaxbClass, final J jaxbObject)
            throws JAXBException {
        final JAXBContext jaxbContext = JAXBContext.newInstance(jaxbClass);
        final Marshaller jaxbMarshaller = jaxbContext.createMarshaller();

        // output pretty printed
        jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

        final org.codehaus.jettison.mapped.Configuration config = new org.codehaus.jettison.mapped.Configuration();
        final MappedNamespaceConvention con = new MappedNamespaceConvention(
                config);
        final Writer writer = new OutputStreamWriter(System.out);
        final XMLStreamWriter xmlStreamWriter = new MappedXMLStreamWriter(con,
                writer);
        jaxbMarshaller.marshal(jaxbObject, xmlStreamWriter);
    }

    protected static int getPort(final int defaultPort) {
        ServerSocket server = null;
        int port = -1;
        try {
            server = new ServerSocket(defaultPort);
            port = server.getLocalPort();
        } catch (final IOException e) {
            // ignore
            LOGGER.log(Level.FINEST, e.getMessage(), e);
        } finally {
            if (server != null) {
                try {
                    server.close();
                } catch (final IOException e) {
                    LOGGER.log(Level.FINEST, e.getMessage(), e);
                    // ignore
                }
            }
        }
        if (port != -1 || defaultPort == 0) {
            return port;
        }
        return getPort(0);
    }

    protected void writeLogsToStdOut() {
        final List<LogRecord> logs = logHandler.getLogs();
        for (final LogRecord r : logs) {
            LOGGER.log(Level.INFO, r.getMessage());
        }
    }

    protected void assertResponseSuccess(
            final IUISResponseStatus uisStatusResponse) {
        assertResponseStatus(uisStatusResponse, 0, "SUCCESS");
    }

    protected void assertResponseFailure(
            final IUISResponseStatus uisStatusResponse) {
        assertResponseStatus(uisStatusResponse, 1, "FAILED");
    }

    protected void assertResponseStatus(
            final IUISResponseStatus uisStatusResponse, final int code,
            final String label) {
        assertNotNull("UIS Response Status not provided", uisStatusResponse);
        assertEquals("Request did not succeed -- bad status code", code,
                uisStatusResponse.getStatusCd());
        assertEquals("Request did not succeed -- bad status label", label,
                uisStatusResponse.getStatusLabel());
    }

    protected void assertMessagesContain(final String messageType,
            final List<IUISResponseStatusMessage> messages,
            final String... codes) {
        final Set<String> codeset = new HashSet<String>();
        for (final IUISResponseStatusMessage m : messages) {
            codeset.add(m.getMessageCode());
        }
        if (codes == null) {
            return;
        }
        for (final String code : codes) {
            if (StringUtils.isEmpty(code)) {
                continue;
            }
            assertTrue("Missing " + messageType + " " + code,
                    codeset.contains(code));
        }
    }

}

公共抽象类RestServiceTestBase扩展了JerseyTest{
专用静态最终记录器=记录器
.getLogger（RestServiceTestBase.class.getName（））；
受保护的静态MemoryHandler logHandler=新MemoryHandler（）；
public RestServiceTestBase（）引发TestContainerException{
超级（）；
}
公共RestServiceTestBase（最终TestContainerFactory TestContainerFactory）{
超级（testContainerFactory）；
}
@凌驾
受保护的应用程序配置（）{
返回新的RestApplicationBase（）；
}
@课前
public static void setupOnce（）引发异常{
System.setProperty（TestProperties.CONTAINER\u端口，
字符串.valueOf（getPort（0））；
System.setProperty（TestProperties.RECORD_日志_级别，
String.valueOf（Level.ALL.intValue（））；
final LogManager lm=LogManager.getLogManager（）；
最终枚举记录器=lm.getLoggerNames（）；
while（loggers.hasMoreElements（））{
最终字符串名称=loggers.nextElement（）；
最终记录器=lm.getLogger（名称）；
if（logger！=null&&logHandler！=null）{
logger.addHandler（logHandler）；
}
}
}
@凌驾
public void setUp（）引发异常{
super.setUp（）；
最终配置管理器cm=SingletonFactory
.getInstance（ConfigurationManager.class）；
最终InMemoryConfiguration apigee=新InMemoryConfiguration(
配置（CTX_APIGEE）；
cm.注册表配置（apigee）；
apigee.setSetting（“API最小版本”，“1”）；
apigee.setSetting（“API_最大版本”，“6”）；
}
受保护的R post（最终WebTarget资源，
最终映射头、最终字符串mediaType、，
最终类响应类，最终对象实体）
抛出异常{
最终响应=WebServiceUtil.post（资源、标题、，
媒体类型、实体）；
assertNotNull（响应）；
assertEquals（“意外的媒体类型”、媒体类型、响应
.getMediaType（）.toString（））；
最终R postResponse=response.readEntity（responseClass）；
assertNotNull（postResponse）；
打印（responseClass、postResponse、mediaType）；
返回应答；
}
受保护的R post（最终WebTarget资源，
最终地图标题，最终类响应类，
最终对象实体）抛出JAXBEException{
回帖（资源、标题、MediaType.APPLICATION_XML、，
响应类、实体）；
}
受保护的R post（最终WebTarget资源，
最终类响应类，最终对象实体）
抛出异常{
return post（资源，null，MediaType.APPLICATION\u XML，responseClass，
实体）；
}
受保护的R put（最终WebTarget资源，
最终映射头、最终字符串mediaType、，
最终类响应类，最终对象实体）
抛出异常{
最终响应=WebServiceUtil.put（资源、头、，
媒体类型、实体）；
assertNotNull（响应）；
assertEquals（“意外的媒体类型”、媒体类型、响应
.getMediaType（）.toString（））；
最终putrresponse=response.readEntity（responseClass）；
assertNotNull（putResponse）；
打印（responseClass、putResponse、mediaType）；
返回响应；
}
受保护的R put（最终WebTarget资源，
最终地图标题，最终类响应类，
最终对象实体）抛出JAXBEException{
返回put（资源、头、MediaType.APPLICATION\u XML、响应类、，
实体）；
}
受保护的R put（最终WebTarget资源、最终类响应类、，
最终对象实体）抛出JAXBEException{
返回put（资源，null，MediaType.APPLICATION\u XML，responseClass，
实体）；
}
@抑制警告（“未选中”）
受保护的R get（最终WebTarget资源，
最终映射头、最终字符串mediaType、，
最后一个类responseClass）抛出JAXBEException{
最终响应=WebServiceUtil.get（资源、头、，
媒体类型）；
assertNotNull（“响应为null！”，响应）；
assertNotNull（“响应媒体类型为null！”，Response.getMediaType（））；
assertEquals（“意外的媒体类型”、媒体类型、响应
.getMediaType（）.toString（））；
if（Response.class.equals（responseClass））{
返回（R）响应；
}
最终R getResponse=response.readEntity（responseClass）；
if（mediaType！=null&“application/pdf”.equalsIgnoreCase（mediaType））{
返回getResponse；
}
assertNotNull（getResponse）；
打印（responseClass、getResponse、mediaType）；
返回getResponse；
}
受保护的R get（最终WebTarget资源、最终类responseClass）
抛出异常{
返回get（resource，null，MediaType.APPLICATION\uxml，responseClass）；
}
受保护的R删除（最终WebTarget资源，
最终映射头、最终字符串mediaType、，
最终类响应类，最终对象实体）