Jersey 泽西岛2.6杰克逊供应商注册

我正在用Jersey 2.6实现REST web服务

我在注册Jackson提供者以获得JSON支持方面遇到了麻烦，我已经根据jeresy文档（）实现了它

添加maven依赖项-jersey media json jackson

实现了一个ContextResolver类

使用@Provider对其进行注释，以启用“自动发现功能”

xml具有提供程序类的包名称，因此在扫描期间将注册提供程序

参考：

---

由于某些原因，Jackson JSON提供程序未注册，我是否遗漏了一些内容？

直到Jersey 2.9，该功能尚未自动发现。我们需要（1）在

应用程序/ResourceConfig

子类中显式注册

JacksonFeature

，（2）在web.xml中列出要扫描的包的Jackson包，或者（3）将JacksonFeature添加到web.xml中的提供者列表中

应用程序子类：

公共类MyApplication扩展了ResourceConfig{
公共应用程序（）{
// (1)
寄存器（JacksonFeature.class）；//
jersey.config.server.provider.classnames
org.glassfish.jersey.jackson.JacksonFeature
1.

查看更多详细信息。请注意，对于

…classnames

属性，如果要注册多个提供程序，则应将其列在相同的参数值中，并用逗号、分号或换行符分隔

---

哦，仅供参考，

ContextResolver

只在可检索的上下文中注册

ObjectMapper

，因此

MessageBodyReader/MessageBodyWriters

可以重用它。但它不注册编组/解编所需的实际

MessageBodyReader/Writer

。

嗨，我不这么认为以上nk是很好的解决方案。 因为我面临着同样的问题，那就是必须提供jersey springboot jackson

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

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


import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;
import org.springframework.beans.factory.annotation.Autowired;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

@Provider
public class ObjectMapperContextResolver implements ContextResolver<ObjectMapper> {

private final ObjectMapper mapper;

public ObjectMapperContextResolver() {
mapper = new ObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
}

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

}

公共类MyApplication扩展了ResourceConfig{
公共应用程序（）{
// (1)
注册（ObjectMapperContextResolver.class）；//以防有人正在寻找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>

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


上下文配置位置
/WEB-INF/conf/*-config.xml
CXF服务器
org.apache.cxf.transport.servlet.CXFServlet
javax.ws.rs.Application
com.myproject.common.application.ApplicationConfig
jersey.config.server.disableMoxyJson
真的
jersey.config.server.provider.packages
org.codehaus.jackson.jaxrs
1.

/WEB-INF/conf/app config.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>

 <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;
    }    
}

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;
    }    
}

package com.myproject.common.provider；
导入javax.ws.rs.products；
导入javax.ws.rs.core.MediaType；
导入javax.ws.rs.ext.ContextResolver；
导入javax.ws.rs.ext.Provider；
导入org.codehaus.jackson.map.ObjectMapper；
导入org.codehaus.jackson.map.SerializationConfig；
导入org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion；
导入org.springframework.stereotype.Component；
@组件（“objectMapperContextResolver”）
@提供者
@产生（MediaType.APPLICATION_JSON）
公共类ObjectMapperContextResolver实现ContextResolver{
私有最终对象映射器映射器；
公共对象MapPercontextResolver（）{
映射器=新的ObjectMapper（）；
configure（SerializationConfig.Feature.WRAP\u ROOT\u值，false）；
mapper.setSerializationInclusion（Inclusion.ALWAYS）；
}
@凌驾
公共对象映射器getContext（类类型）{
返回映射器；
}    
}

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

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;
    }    
}

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;
    }    
}

package com.myproject.common.application；
导入java.util.Set；
导入javax.ws.rs.ApplicationPath；
导入javax.ws.rs.core.Application；
导入org.glassfish.jersey.jackson.JacksonFeature；
导入com.myproject.common.provider.ObjectMapperContextResolver；
@应用程序路径（“/”）
公共类应用程序配置扩展应用程序{
@凌驾
public Set>classes=new java.util.HashSet（）；
添加（JacksonFeature.class）；
添加（ObjectMapperContextResolver.class）；
返回类；
}    
}

在weblogic-application.xml中将Jackson provider包指定为首选应用程序包在我的示例中，可以是web.xml:

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

    <!-- 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>


org.codehaus.jackson.jaxrs*

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

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

    <!-- 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>


org.glassfish.jersey.media
泽西媒体公司
2.0-m10
org.glassfish.jersey.core
泽西服务器
org.glassfish.jersey.media
泽西媒体公司
2.0-m10
Grate，我错过了“org.codehaus.jackson.jaxrs”在web.xml中，现在它试图加载jackson库，但我得到以下错误java.lang.NoClassDefFoundError:org/codehaus/jackson/map/JsonMappingException什么时候得到的？在启动时还是在尝试发送请求时？我希望可以测试它，但我不使用Weblogic。你知道Weblogic是否仍然使用Jersey 1吗？也许这是一个骗局如果是这样的话，我不知道如何让你的服务器忽略球衣1。你