JAXRSClientSpringBoot

http://cxf.apache.org/docs/jaxrsclientspringboot.html

CXFSpringBoot

http://cxf.apache.org/docs/springboot.html

Restfull Webservice書源碼

https://github.com/feuyeux

JAX-RS 2.0 REST客戶端編程實例

http://www.importnew.com/8939.html

本人的DEMO

https://git.oschina.net/paulwong/test-cxf

paulwong 2017-09-24 17:19 發表評論

import javax.xml.bind.annotation.XmlRootElement;

import org.codehaus.jackson.annotate.JsonProperty;

@XmlRootElement
public class TestUser {
    
    /*@XmlElement(name="username")*/
    @JsonProperty("username")
    private String userName;
    
    private String email;

    public String getEmail() {
        return email;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "TestUser [userName=" + userName + ", email=" + email + "]";
    }
    
    

}

import java.io.IOException;

import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class Test {
    
    private Logger logger = LoggerFactory.getLogger(Test.class);
    
    /*private String getBaseUri()
    {
        return "http://192.168.1.223:8080/restfull-api";
    }*/
    
    @Test
    public void testTest()
    {
        ObjectMapper mapper = new ObjectMapper();
        /*AnnotationIntrospector introspector = new JaxbAnnotationIntrospector();
        // make deserializer use JAXB annotations (only)
        mapper.getDeserializationConfig().setAnnotationIntrospector(introspector);
        // make serializer use JAXB annotations (only)
        mapper.getSerializationConfig().setAnnotationIntrospector(introspector);*/
        mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        
        String userStr = "{\"username\":\"paul\",\"email\":\"paul@paul.com\"}";
        try {
            TypeReference<TestUser> temp = new TypeReference<TestUser>(){};
            TestUser testUser = mapper.readValue(userStr, temp);
            System.out.println(testUser.toString());
            
            String result = mapper.writeValueAsString(testUser);
            System.out.println(result);
            
        } catch (JsonParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JsonMappingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

paulwong 2014-07-04 09:07 發表評論

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee">

    <display-name>Restful Web Application</display-name>
    
    <servlet>
        <servlet-name>jersey-serlvet</servlet-name>
        <servlet-class>
            com.sun.jersey.spi.spring.container.servlet.SpringServlet
        </servlet-class>
        <init-param>
            <param-name>com.sun.jersey.config.property.packages</param-name>
            <param-value>restfullapi.rest.service,restfullapi.common.provider,restful.web</param-value>
        </init-param>
        <init-param>
            <param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>2</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>jersey-serlvet</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
    
 
     <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    
    <listener>
        <listener-class>
            org.springframework.web.context.request.RequestContextListener
        </listener-class>
    </listener>
    
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/mvc-dispatcher-servlet.xml</param-value>
    </context-param>
    
    <!-- spring logback -->
    <context-param>
        <param-name>logbackConfigLocation</param-name>
        <param-value>classpath:logback.xml</param-value>
    </context-param>  
    <listener>
        <listener-class>ch.qos.logback.ext.spring.web.LogbackConfigListener</listener-class>
    </listener>

    <context-param>
        <param-name>webAppRootKey</param-name>
        <param-value>restfull-api</param-value>
    </context-param>
    
    <welcome-file-list>
        <welcome-file>/index.jsp</welcome-file>
    </welcome-file-list>
    

</web-app>

AbstractBaseRestfulException.java

public abstract class AbstractBaseRestfulException extends Exception{

    private static final long serialVersionUID = 6779508767332777451L;
    
    public AbstractBaseRestfulException()
    {
    }
    
    public AbstractBaseRestfulException(String message)
    {
        super(message);
    }

    public abstract String getErrcode();

    public abstract void setErrcode(String errcode);

    public abstract String getDescription();

    public abstract void setDescription(String description);
    

}

AbstractBaseRestfulExceptionMapper.java

import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.paul.common.exception.AbstractBaseRestfulException;
import com.paul.common.json.DefaultJsonResponse;

@Provider
public class AbstractBaseRestfulExceptionMapper implements ExceptionMapper<AbstractBaseRestfulException>{

    private Logger logger = LoggerFactory.getLogger(AbstractBaseRestfulExceptionMapper.class);
    
    public Response toResponse(AbstractBaseRestfulException exception) {
        
        logger.error(exception.getMessage(), exception);
        
        DefaultJsonResponse<Object> response = new DefaultJsonResponse<Object>();
        response.setDescription(exception.getDescription());
        response.setErrcode(exception.getErrcode());
        response.setResult(null);
            
        return Response.status(Status.BAD_REQUEST)
                .entity(response)
                .type(MediaType.APPLICATION_JSON + ";charset=utf-8")
                .build();
    }

}

OtherExceptionMapper.java

import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.paul.common.json.DefaultJsonResponse;
import com.paul.common.json.JsonResponseStatus;

@Provider
public class OtherExceptionMapper implements ExceptionMapper<Exception>{
    
    private Logger logger = LoggerFactory.getLogger(OtherExceptionMapper.class);

    public Response toResponse(Exception exception) {
        
        logger.error(exception.getMessage(), exception);
        
        DefaultJsonResponse<Object> response = new DefaultJsonResponse<Object>();
        response.setDescription(JsonResponseStatus.OTHER_ERROR.getMessage() + exception.getMessage());
        response.setErrcode(JsonResponseStatus.OTHER_ERROR.getCode());
        response.setResult(null);
            
        return Response.status(Status.BAD_REQUEST)
                .entity(response)
                .type(MediaType.APPLICATION_JSON + ";charset=utf-8")
                .build();
    }

}

WebApplicationExceptionMapper.java

import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.paul.common.json.DefaultJsonResponse;

@Provider
public class WebApplicationExceptionMapper implements ExceptionMapper<WebApplicationException >{

    private Logger logger = LoggerFactory.getLogger(WebApplicationExceptionMapper.class);
    
    public Response toResponse(WebApplicationException exception) {
        
        logger.error(exception.getMessage(), exception);
        
        DefaultJsonResponse<Object> response = new DefaultJsonResponse<Object>();
        response.setDescription(exception.getMessage());
        response.setErrcode(String.valueOf(exception.getResponse().getStatus()));
        response.setResult(null);
            
        return Response.status(exception.getResponse().getStatus())
                .entity(response)
                .type(MediaType.APPLICATION_JSON + ";charset=utf-8")
                .build();
    }

}

import javax.ws.rs.DefaultValue;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import com.paul.common.json.DefaultJsonResponse;
import com.paul.common.json.JsonResponseStatus;
import com.paul.program.stbstart.valueobject.StbStart;
import com.paul.stbstart.valueobject.StbStartRequest;
import com.paul.restfullapi.rest.service.AdvertisementRestfulService;

@Path("/advertisement")
@Controller
public class AdvertisementRestfulController {
    
    private Logger logger = LoggerFactory.getLogger(AdvertisementRestfulController.class);
    
    @Autowired
    AdvertisementRestfulService advertisementRestfulService;
    
    @Path("/getAdvertisement")
    @Produces({MediaType.APPLICATION_JSON + ";charset=utf-8"})
    @GET
    public DefaultJsonResponse<StbStart> getAdvertisement(
            @DefaultValue("") @QueryParam("version")String version,
            @QueryParam("token")String token) throws Exception
    {
        DefaultJsonResponse<StbStart> response = new DefaultJsonResponse<StbStart>();
        StbStartRequest request = new StbStartRequest();
        logger.info(version);
        request.setVersion(version);
        request.setToken(token);
        StbStart result = advertisementRestfulService.findByVersion(request);
        response.setResult(result);
        response.setDescription(JsonResponseStatus.SUCCESS.getMessage());
        response.setErrcode(JsonResponseStatus.SUCCESS.getCode());
        
        logger.info("----------------");
//        double i = 1/0;
        return response;
    }
    

}

paulwong 2014-04-28 14:44 發表評論

基于JAXB注釋的JSON與JAVA BEAN的互轉

http://wiki.fasterxml.com/JacksonDataBinding

http://stackoverflow.com/questions/10699038/generating-more-json-like-json-from-jaxb-and-jersey

http://wiki.fasterxml.com/JacksonJAXBAnnotations

例子：
https://github.com/jersey/jersey/tree/2.4.1/examples

paulwong 2013-11-27 12:03 發表評論