Question

我正在使用Jersey 2.6实现REST Web服务，

我在注册杰克逊提供商以获得JSON支持方面遇到了麻烦，我已根据jeresy文档（https://jersey.java.net/documentation/2.6/user-guide.html#json.jackson）实施。

添加maven依赖 - jersey-media-json-jackson
实施了ContextResolver类。
使用@Provider对其进行注释以启用＆＃34;自动发现功能＆＃34;
web.xml具有提供程序类的包名称，因此将在扫描期间注册提供程序。

REF： http://blog.dejavu.sk/2013/11/19/registering-resources-and-providers-in-jersey-2/

由于某种原因杰克逊JSON提供商没有注册，我错过了什么？

Answer 1

直到Jersey 2.9，该功能未被自动发现。我们需要（1）在JacksonFeature子类中明确注册Application/ResourceConfig，（2）在要扫描的包的web.xml中列出Jackson包，或者（3）将JacksonFeature添加到web.xml中的提供者列表

应用程序子类：

public class MyApplication extends ResourceConfig {  
    public MyApplication() {
        // (1)
        register(JacksonFeature.class); // <----- Jackson Support
        packages("the.package.of.your.resources");
    }
}

或web.xml：

<servlet>
    <servlet-name>Jersey Web Application</servlet-name>
    <servlet-class>
        org.glassfish.jersey.servlet.ServletContainer
    </servlet-class>
    <init-param>
        <!-- (2) -->
        <param-name>jersey.config.server.provider.packages</param-name>
        <param-value>
            the.package.of.your.resources,
            org.codehaus.jackson.jaxrs <!-- Jackson providers -->
        </param-value>
    </init-param>
    <init-param>
        <!-- (3) -->
        <param-name>jersey.config.server.provider.classnames</param-name>
        <param-value>
            org.glassfish.jersey.jackson.JacksonFeature
        </param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

查看更多详情here in the "Second Issue"。请注意，对于...classnames属性，如果要注册多个提供程序，则应将其列在以逗号，分号或换行符分隔的相同param-value中。

哦，只是一个FYI，ContextResolver只是在可检索的上下文中注册ObjectMapper，因此MessageBodyReader/MessageBodyWriters可以重复使用它。但它没有注册编组/解组所需的实际MessageBodyReader/Writer。

Answer 2

嗨，我认为以上并不是一个好的解决方案。由于我遇到了同样的问题，必须提供球衣springboot jackson。

JacksonFeature.class上面的内容来自glassfish，它的功能较少，这在将来的springboot应用程序中是个问题

Password

重要的一点是，您需要将ObjectMapper导入为 com.fasterxml.jackson.databind.ObjectMapper ；最新的springboot杰克逊

Answer 3

以防万一有人正在寻找在 Weblogic 12.2.1.4 和 CXF Servlet 2.7.11 上使用 JacksonProvider 生成（序列化）JSON 的方法。该解决方案与 Paul Samsotha 的上述解决方案几乎相同（顺便说一句，非常感谢！），但所有内容都在一个地方提及，因此像我这样迷路的人可以轻松搞定。

web.xml

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/conf/*-config.xml</param-value>
  </context-param>

  <servlet>
    <servlet-name>CXFServlet</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
    <init-param>
      <param-name>javax.ws.rs.Application</param-name>
      <param-value>com.myproject.common.application.ApplicationConfig</param-value>
    </init-param>       
    <init-param>
      <param-name>jersey.config.server.disableMoxyJson</param-name>
      <param-value>true</param-value>
    </init-param>     
    <init-param>
        <param-name>jersey.config.server.provider.packages</param-name>
        <param-value>org.codehaus.jackson.jaxrs</param-value>
    </init-param>      
    <load-on-startup>1</load-on-startup>
  </servlet>

/WEB-INF/conf/app-config.xml

 <bean id="jsonProvider" class="org.codehaus.jackson.jaxrs.JacksonJsonProvider" />
        
 <jaxrs:providers>         
    <ref bean="objectMapperContextResolver" />
    <ref bean="jsonProvider" />
 </jaxrs:providers>

自定义 ObjectMapper ContextResolver

package com.myproject.common.provider;

import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
import org.springframework.stereotype.Component;

@Component("objectMapperContextResolver")
@Provider
@Produces(MediaType.APPLICATION_JSON)
public class ObjectMapperContextResolver implements ContextResolver<ObjectMapper> {
    private final ObjectMapper mapper;
    
    public ObjectMapperContextResolver() {
        mapper = new ObjectMapper();
        mapper.configure(SerializationConfig.Feature.WRAP_ROOT_VALUE, false);
        mapper.setSerializationInclusion(Inclusion.ALWAYS);
    }

    @Override
    public ObjectMapper getContext(Class<?> type) {
        return mapper;
    }    
}

创建应用配置以注册 JacksonFuture 和自定义 ObjectMapperContextResolver

package com.myproject.common.application;

import java.util.Set;
import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;
import org.glassfish.jersey.jackson.JacksonFeature;
import com.myproject.common.provider.ObjectMapperContextResolver;

@ApplicationPath("/")
public class ApplicationConfig extends Application {
  
    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> classes = new java.util.HashSet<>();
        classes.add(JacksonFeature.class);
        classes.add(ObjectMapperContextResolver.class);
        return classes;
    }    
}

在我的例子中，在 weblogic-application.xml 中将 Jackson 提供程序包指定为 preferred-application-packages，可以在 web.xml 中：

<weblogic-application>                
    <prefer-application-packages>
         <package-name>org.codehaus.jackson.jaxrs.*</package-name>
    </prefer-application-packages>
</weblogic-application>

在 pom.xml 中排除任何不必要的 jersey 依赖并添加以下 org.glassfish.jersey.media jars：

    <!-- https://mvnrepository.com/artifact/org.glassfish.jersey.media/jersey-media-sse -->
    <dependency>
        <groupId>org.glassfish.jersey.media</groupId>
        <artifactId>jersey-media-sse</artifactId>
        <version>2.0-m10</version>
        <exclusions>
            <exclusion>
                <groupId>org.glassfish.jersey.core</groupId>
                <artifactId>jersey-server</artifactId>
            </exclusion>
        </exclusions>      
    </dependency>
    
    <!-- https://mvnrepository.com/artifact/org.glassfish.jersey.media/jersey-media-json-jackson -->
    <dependency>
        <groupId>org.glassfish.jersey.media</groupId>
        <artifactId>jersey-media-json-jackson</artifactId>
        <version>2.0-m10</version>
    </dependency>

Jersey 2.6杰克逊提供者注册

3 个答案: