jetty服务器使用jersey作为Restful框架

已于 2023-10-20 11:01:11 修改
阅读量2.8k 收藏
点赞数
文章标签： jersey maven jetty webapi
于 2017-10-12 12:29:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ar__ha/article/details/78213511
版权

使用 Maven 的简单 Java SE 应用程序，从一个现有项目学习尝试搭建一个新的项目。

首先完成最基础的GET POST请求的功能。

1.新建项目 Maven-Java应用程序

2.打开POM，编辑POM.XML，添加jetty,jersey

<project>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.glassfish.jersey</groupId>
                <artifactId>jersey-bom</artifactId>
                <version>${jersey.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    
    <dependencies>
        <dependency>
            <groupId>org.glassfish.jersey.containers</groupId>
            <artifactId>jersey-container-jetty-servlet</artifactId>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.inject</groupId>
            <artifactId>jersey-hk2</artifactId>
        </dependency>

        <!-- json support -->
        <dependency>
            <groupId>org.glassfish.jersey.media</groupId>
            <artifactId>jersey-media-json-jackson</artifactId>
        </dependency>
        <!-- moxy for xml -->
        <dependency>
            <groupId>org.glassfish.jersey.media</groupId>
            <artifactId>jersey-media-moxy</artifactId>
        </dependency>
        <!-- jersey-media-multipart for file -->
            <dependency>
	        <groupId>org.glassfish.jersey.media</groupId>
	        <artifactId>jersey-media-multipart</artifactId>
    	</dependency>
        <dependency>
	        <groupId>commons-io</groupId>
	        <artifactId>commons-io</artifactId>
	        <version>2.4</version>
	    </dependency>
        
        <!-- jetty is our HTTP server -->
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-server</artifactId>
            <version>${jetty.version}</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-rewrite</artifactId>
            <version>${jetty.version}</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-util</artifactId>
            <version>${jetty.version}</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-servlet</artifactId>
            <version>${jetty.version}</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-servlets</artifactId>
            <version>${jetty.version}</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>${project.artifactId}-${project.version}-${build.specifier}</finalName>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
                <includes>
                    <include>*.properties</include>
                    <include>*.xml</include>
                </includes>
            </resource>
        </resources>
        <plugins>
        <!--打包
            docs:https://maven.apache.org/plugins/maven-shade-plugin/shade-mojo.html -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <!--Setting Manifest Entries with the ManifestResourceTransformer-->
                                <transformer
                                    implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.test.Main</mainClass>
                                </transformer>
                                <!--  use transformer to handle merge of META-INF/services - see http://java.net/jira/browse/JERSEY-440?focusedCommentId=14822&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_14822 -->
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
                            </transformers>
                            <!-- Exclude signature files. Combining all dependencies into one uber jar means that some jars may contribute
                            signature files, which won't be valid for the resulting jar, and will cause the jar to be un-runnable as it
                            won't pass a signature check -->
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <shadedArtifactAttached>true</shadedArtifactAttached>
                            <shadedClassifierName>${build.specifier}-uber</shadedClassifierName>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- @Inject @Contract @Service-->
            <plugin>  
                <groupId>org.glassfish.hk2</groupId>  
                <artifactId>hk2-inhabitant-generator</artifactId>  
                <version>2.6.1</version>
                <executions>  
                    <execution>  
                        <goals>  
                            <goal>generate-inhabitants</goal>  
                        </goals>  
                    </execution>  
                </executions>  
            </plugin>
        </plugins>
    </build>

    <properties>
        <jetty.version>9.4.35.v20201120</jetty.version>
        <jersey.version>2.32</jersey.version>
        
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.build.timestamp.format>yyyyMMdd-HHmm</maven.build.timestamp.format>
    </properties>
</project>


3.编辑Main.java

package com.test;

import org.eclipse.jetty.http.HttpVersion;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.HttpConfiguration;
import org.eclipse.jetty.server.HttpConnectionFactory;
import org.eclipse.jetty.server.SecureRequestCustomizer;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.SslConnectionFactory;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.ContextHandlerCollection;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.eclipse.jetty.util.thread.QueuedThreadPool;
import org.glassfish.jersey.servlet.ServletContainer;

/**
 *
 * @author Admin
 */
public class Main {

    public static void main(String[] args) throws Exception {
        startServer();
    }

    /**
     * 服务器 jetty doc https://www.eclipse.org/jetty/documentation.php jetty api
     * https://www.eclipse.org/jetty/javadoc/9.4.35.v20201120/index.html?overview-summary.html
     *
     * @return
     * @throws Exception
     */
    private static Server startServer() throws Exception {
        int maxThreadPool = 50;

        //Set the maximum number of threads.  
        QueuedThreadPool threadPool = new QueuedThreadPool();
        threadPool.setMaxThreads(maxThreadPool);
        threadPool.setMinThreads(maxThreadPool / 10);
        threadPool.setIdleTimeout(30 * 1000);
        Server server = new Server(threadPool);

        //设置connector, http/https连接
        Connector[] connectors = createConnectors(server);
        server.setConnectors(connectors);

        //设置handler, 业务处理
        ContextHandlerCollection handlers = createContextHandlerCollection();
        server.setHandler(handlers);

        server.start();
        server.join();
        return server;
    }

    /**
     * 创建connector，acceptors,selectors都用默认值
     *
     * @param server
     * @param properties
     * @return
     */
    private static Connector[] createConnectors(final Server server) {
        long idleTimeOut = 15 * 1000;
        // Configuration
        HttpConfiguration httpConfig = new HttpConfiguration();
//        httpConfig.setSecureScheme("https");
//        httpConfig.setSecurePort(securePort);
//        httpConfig.setOutputBufferSize(32768);
        httpConfig.setRequestHeaderSize(32768);
        httpConfig.setResponseHeaderSize(32768);
//        httpConfig.setSendServerVersion(true);
//        httpConfig.setSendDateHeader(false);
        httpConfig.setIdleTimeout(idleTimeOut);
        // httpConfig.addCustomizer(new ForwardedRequestCustomizer());

        boolean httpEnabled = true;
        int httpPort = 8080;
        boolean httpsEnabled = true;
        int httpsPort = 8081;
        String SSLKeyStorePath = "aSSL.jks";
        String SSLPassword = "PASSWORD";

        ServerConnector httpConnector = null, httpsConnector = null;
        if (httpEnabled) {
            httpConnector = new ServerConnector(server, new HttpConnectionFactory(httpConfig));
            httpConnector.setPort(httpPort);
            httpConnector.setIdleTimeout(idleTimeOut);
        }

        if (httpsEnabled) {
            HttpConfiguration httpsConfig = new HttpConfiguration(httpConfig);
            httpsConfig.addCustomizer(new SecureRequestCustomizer());
            // SSL
//            SslContextFactory sslContextFactory = new SslContextFactory();
            SslContextFactory sslContextFactory = new SslContextFactory.Server();
            sslContextFactory.setKeyStorePath(SSLKeyStorePath);
            sslContextFactory.setKeyManagerPassword(SSLPassword);
            sslContextFactory.setKeyStorePassword(SSLPassword);

            httpsConnector = new ServerConnector(server,
                    new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
                    new HttpConnectionFactory(httpsConfig));
            httpsConnector.setPort(httpsPort);
            httpsConnector.setIdleTimeout(idleTimeOut);
        }

        if (httpsConnector != null) {
            if (httpConnector != null) {
                return new Connector[]{httpsConnector, httpConnector};
            } else {
                return new Connector[]{httpsConnector};
            }
        } else if (httpConnector != null) {
            return new Connector[]{httpConnector};
        } else {
            return null;
        }
    }

    /**
     * 创建handler
     *
     * @param properties
     * @return
     * @throws Exception
     */
    private static ContextHandlerCollection createContextHandlerCollection() throws Exception {
        String path = "/hi";
        ContextHandler apiContextHandler = buildContextHandler(path);
        return new ContextHandlerCollection(apiContextHandler);
    }

    /**
     * servlet handler : 实现后端功能
     *
     * @param basePath
     * @return
     */
    private static ContextHandler buildContextHandler(String basePath) {
        //由jersey提供restful web服务
        ServletHolder jerseyServlet = new ServletHolder(ServletContainer.class);
        jerseyServlet.setInitParameter("javax.ws.rs.Application", "com.test.inject.MyJerseyConfig");
        jerseyServlet.setInitOrder(1);

        ServletContextHandler contextHandler = new ServletContextHandler(ServletContextHandler.NO_SESSIONS);
        contextHandler.setContextPath(basePath);
        contextHandler.addServlet(jerseyServlet, "/*");
        return contextHandler;
    }
}

4.修改MyJerseyConfig.java

package com.test.inject;

import com.test.inject.filter.*;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.inject.Inject;
import org.glassfish.hk2.api.ActiveDescriptor;
import org.glassfish.hk2.api.DynamicConfigurationService;
import org.glassfish.hk2.api.MultiException;
import org.glassfish.hk2.api.Populator;
import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.jersey.jackson.JacksonFeature;
import org.glassfish.jersey.server.ResourceConfig;
import org.slf4j.LoggerFactory;

/**
 *
 * @author Admin
 */
public class MyJerseyConfig extends ResourceConfig {

    @Inject
    public MyJerseyConfig(
            ServiceLocator serviceLocator
    ) {

        DynamicConfigurationService dcs = serviceLocator.getService(DynamicConfigurationService.class);
        Populator populator = dcs.getPopulator();

        try {
            LoggerFactory.getLogger(getClass()).debug("Populating descriptors...");
            //The default populate() looks in META-INF/hk2-locator  
            List<ActiveDescriptor<?>> descriptors = populator.populate();
            for (ActiveDescriptor<?> desc : descriptors) {
                LoggerFactory.getLogger(getClass()).debug("Added descriptor: " + desc);
            }

            //We also want to check hk2-locator/ because that's where WAR packaging places it  
            descriptors = populator.populate(() -> {
                List<InputStream> streams = new ArrayList<>();
                InputStream stream = getClass().getClassLoader().getResourceAsStream("hk2-locator/default");
                if (stream != null) {
                    streams.add(stream);
                }
                return streams;
            });
            for (ActiveDescriptor<?> desc : descriptors) {
                LoggerFactory.getLogger(getClass()).debug("Added descriptor: " + desc);
            }
        } catch (IOException e) {
            throw new MultiException(e);
        }

        //json转换
        register(JacksonFeature.class);

        // 启用Java Moxy支持xml
        register(MoxyXmlFeature.class);

        //MultiPartFeature 支持文件上传/下载
        register(MultiPartFeature.class);

        //手动处理部分Inject
        register(new Binder());

        //扫描服务类所在的包  
        packages("com.test.rest");

        //继承javax.ws.rs.container.ContainerRequestFilter,在服务开始之前, 处理request
        //javax.ws.rs.container.ContainerResponseFilter,在服务完成以后,处理response
        //报错后本地log输出        
        register(ExceptionLoggerFilter.class);
        //直接处理OPTION请求
        register(OptionsMethodFilter.class);
        //webGL需要的相应头
        register(WebGLHeaderWriterInterceptor.class);

        //输出所有请求与相应
        boolean logAll = true;
        if (logAll) {
            register(CustomLoggingFilter.class);
        }

        //运行报错返回response
        register(MyExceptionMapper.class);
    }
}

部分用到的

package com.test.inject;

import javax.inject.Singleton;
import org.glassfish.hk2.utilities.binding.AbstractBinder;

/**
 *
 * @author Admin
 */
public class Binder extends AbstractBinder {

    @Override
    protected void configure() {
//        //工厂
//        bindFactory(SomeThingFactory.class).to(SomeThing.class).in(Singleton.class);
//        //唯一实例
//        bindAsContract(SomeThing.class).in(Singleton.class);
    }
}
package com.test.inject.filter;

import org.glassfish.jersey.message.internal.ReaderWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.container.ContainerResponseContext;
import javax.ws.rs.container.ContainerResponseFilter;
import java.io.*;

public class CustomLoggingFilter implements ContainerRequestFilter, ContainerResponseFilter {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public void filter(ContainerRequestContext requestContext) throws IOException {
        StringBuilder sb = new StringBuilder();
        sb.append("User: ").append(requestContext.getSecurityContext().getUserPrincipal() == null ? "unknown"
                : requestContext.getSecurityContext().getUserPrincipal());
        sb.append(" - Path: ").append("★").append(requestContext.getUriInfo().getPath()).append("★");
        sb.append(" - Method: ").append(requestContext.getMethod());
        sb.append(" - Header: ").append(requestContext.getHeaders());
        sb.append(" - Entity: ").append(getEntityBody(requestContext));
        logger.info("HTTP REQUEST : " + sb.toString());
    }

    private String getEntityBody(ContainerRequestContext requestContext) {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        InputStream in = requestContext.getEntityStream();

        final StringBuilder b = new StringBuilder();
        try {
            ReaderWriter.writeTo(in, out);

            byte[] requestEntity = out.toByteArray();
            if (requestEntity.length == 0) {
                b.append("").append("\n");
            } else {
                b.append(new String(requestEntity)).append("\n");
            }
            requestContext.setEntityStream(new ByteArrayInputStream(requestEntity));

        } catch (IOException ex) {
            //Handle logging error
        }
        return b.toString();
    }

    @Override
    public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
        if (!"swagger.json".equals(requestContext.getUriInfo().getPath())) {
            StringBuilder sb = new StringBuilder();
            sb.append("Header: ").append(responseContext.getHeaders());
            sb.append(" - Entity: ");
            if (responseContext.getEntity() != null) {
                sb.append(responseContext.getEntity().toString());
//                sb.append(JsonUtil.getObjectMapper().writeValueAsString(responseContext.getEntity()));
            } else {
                sb.append("nothing");
            }
            sb.append('\n');
            //System.out.println("HTTP RESPONSE : " + sb.toString());
            logger.info("HTTP RESPONSE : " + sb.toString());
        } else {
            logger.info("HTTP RESPONSE : " + "swagger");
        }
    }
}
package com.test.inject.filter;

import java.io.IOException;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerResponseContext;
import javax.ws.rs.container.ContainerResponseFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 * @author Administrator
 */
public class ExceptionLoggerFilter implements ContainerResponseFilter {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
        if (responseContext.getStatus() >= 400) {
            logger.error("server error at path:[{}], status:{}", requestContext.getUriInfo().getPath(), responseContext.getStatus());
        }
    }

}
package com.test.inject.filter;

import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;
import javax.ws.rs.core.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Created by Administrator
 */
@Provider
public class MyExceptionMapper implements ExceptionMapper<Exception> {

    private final static Logger logger = LoggerFactory.getLogger(MyExceptionMapper.class);
    
    @Override
    public Response toResponse(Exception exception) {
//        exception.printStackTrace();
        logger.error("exception:", exception);
        return Response.serverError().entity(exception.getMessage()).build();
    }
}
package com.test.inject.filter;

import java.io.IOException;
import javax.inject.Inject;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.core.Response;

/**
 *
 * @author Administrator
 */
public class OptionsMethodFilter implements ContainerRequestFilter {
    

    @Inject
    public OptionsMethodFilter(
    ) {
    }
    
    @Override
    public void filter(ContainerRequestContext containerRequestContext) throws IOException {
        if("OPTIONS".equals(containerRequestContext.getMethod())){
            containerRequestContext.abortWith(
                    Response.status(Response.Status.OK)
                    .entity("ok")
                    .header("Access-Control-Max-Age", "3600")
//                    .header("Access-Control-Allow-Origin", "*")
//                    .header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
//                    .header("Access-Control-Allow-Credentials", "true")
//                    .header("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time, content-type, content-encoding")
                    .build());
        }
    }
}
package com.test.inject.filter;

import java.io.IOException;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.WriterInterceptor;
import javax.ws.rs.ext.WriterInterceptorContext;

/**
 * @author Administrator
 */
public class WebGLHeaderWriterInterceptor implements WriterInterceptor {

    @Override
    public void aroundWriteTo(WriterInterceptorContext context)
            throws IOException, WebApplicationException {
        
        MultivaluedMap<String,Object> headers = context.getHeaders();
        headers.add("Access-Control-Allow-Origin", "*");
        headers.add("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
        headers.add("Access-Control-Allow-Credentials", "true");
        headers.add("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time, content-type, content-encoding");
        
        context.proceed();
    }
}

5.rest包添加服务类

5.1 GET

package com.test.rest.gettest;

import javax.inject.Inject;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.CookieParam;
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.Context;
import javax.ws.rs.core.MediaType;

/**
 *
 * @author Admin
 */
@Path("gett")
public class GetTestResource {

    @Inject
    public GetTestResource() {

    }

    @GET
    @Path("a")
    @Produces(MediaType.TEXT_HTML)
    public String a(
            @DefaultValue("0") @QueryParam("f") int f,
            @DefaultValue("0") @QueryParam("t") int t
    ) {
        return t + "/" + f;
    }
    //>>curl localhost:8080/hi/gett/a?f=12
    //0/12

    @GET
    @Path("b")
    @Produces(MediaType.APPLICATION_JSON)
    public GetTestResponse b() {
        GetTestResponse response = new GetTestResponse();
        response.setVal(123);
        return response;
    }
    //>>curl localhost:8080/hi/gett/b
    //{"val":123}

    @GET
    @Path("c")
    @Produces(MediaType.TEXT_HTML)
    public String c(
            @CookieParam("session") String session,
            @DefaultValue("0") @QueryParam("t") int t
    ) {
        return "s:" + session;
    }
    //>>curl --cookie "session=aSession" localhost:8080/hi/gett/c?t=44
    //s:aSession

    @GET
    @Path("d")
    @Produces(MediaType.TEXT_HTML)
    public String d(
            @Context HttpServletRequest request
    ) {
        Cookie[] c = request.getCookies();
        return request.getContextPath() + request.getPathInfo();
    }
    //>>curl --cookie "session=aSession" -H "h: 1" localhost:8080/hi/gett/d
    ///hi/gett/d
}


package com.test.rest.gettest;

import com.fasterxml.jackson.annotation.JsonProperty;

/**
 *
 * @author Admin
 */
public class GetTestResponse {

    @JsonProperty("val")
    private int val;

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }
}

5.2 JSON

-H 'Content-Type: application/json'

-H 'Accept:application/json'

package com.test.rest.posttest;

import com.test.rest.posttest.sub.SubResource;
import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

/**
 *
 * @author Admin
 */
@Path("postt")
public class PostTestResource {

    @Inject
    public PostTestResource() {

    }

    @POST
    @Path("a")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public PostTestResponse a(PostTestRequest request) {
        PostTestResponse response = new PostTestResponse();
        response.setVal(request.getAInt());
        return response;
    }
    //>>curl -H "Content-Type: application/json" -X POST -d {\"aInt\":3} localhost:8080/hi/postt/a
    //{"val":3}

    @Path("b")
    public SubResource b() {
        return new SubResource();
    }
    //>curl -H "Content-Type: application/json" -X POST -d {\"aInt\":3} localhost:8080/hi/postt/b
    //{"val":3}
}


package com.test.rest.posttest;

import com.fasterxml.jackson.annotation.JsonProperty;

/**
 *
 * @author Admin
 */
public class PostTestRequest {
    private int aInt;
    
    @JsonProperty("aInt")
    public int getAInt(){
        return aInt;
    }
    
    public void setAInt(int aInt){
        this.aInt = aInt;
    }
}


package com.test.rest.posttest;

import com.fasterxml.jackson.annotation.JsonProperty;

/**
 *
 * @author Admin
 */
public class PostTestResponse {

    @JsonProperty("val")
    private int val;

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }


    //手动序列化mysql的json类型, (jooq 3.17.0以后有提供jooq-jackson-extensions)
    @ApiModelProperty(value = "datas")
    @JsonProperty("datas")
    @JsonSerialize(using = MyJooqJsonSerializer.class)
    private org.jooq.JSON datas;

    public org.jooq.JSON getDatas() {
        return datas;
    }

    @Column(name = "datas")
    public void setDatas(org.jooq.JSON datas) {
        this.datas = datas;
    }
}



package com.test.rest.posttest.sub;

import com.test.rest.posttest.PostTestRequest;
import com.test.rest.posttest.PostTestResponse;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

/**
 *
 * @author Admin
 */
public class SubResource {

    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public PostTestResponse a(PostTestRequest request) {
        PostTestResponse response = new PostTestResponse();
        response.setVal(request.getAInt());
        return response;
    }
}

5.3 XML

-H 'Content-type: application/xml'

-H 'Accept: application/xml'

import io.swagger.annotations.Api;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Consumes;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("xml")
@Api("xml格式.")
public class XmlResource {

    @GET
    @Path("tt")
    @Produces(MediaType.APPLICATION_XML)
    public XmlResponse person() {
        var r = new XmlResponse();

        r.setAge(123);
        r.setName("xiaohei");

        return r;
    }

    @POST
    @Path("te")
    @Consumes(MediaType.APPLICATION_XML)
    @Produces(MediaType.APPLICATION_XML)
    public XmlResponse p2(XmlRequest request) {
        var r = new XmlResponse();

        r.setAge(123);
        r.setName(request.getName());

        return r;
    }

    /*
    curl --location 'http://localhost:8080/hi/xml/te' \
--header 'Content-Type: application/xml' \
--data '<?xml version="1.0" encoding="UTF-8"?>
<request>
<name>heihei</name>
</request>'
     */
}



import java.io.Serializable;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name="response")
public class XmlResponse implements Serializable{

    private String name;
    private int age;

    // Getters and setters

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

import javax.xml.bind.annotation.XmlRootElement;


@XmlRootElement(name = "request")
public class XmlRequest {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

5.4 文件


import io.swagger.annotations.Api;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import org.apache.commons.io.FileUtils;
import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
import org.glassfish.jersey.media.multipart.FormDataParam;

/**
 *
 * @author yaozhen
 */
@Path("file")
@Api("文件.")
public class FileResource {

    @POST
    @Path("upload")
    @Consumes(MediaType.MULTIPART_FORM_DATA)
    @Produces(MediaType.TEXT_PLAIN)
    public String uploadimage1(
            @FormDataParam("file") InputStream fileInputStream,
            @FormDataParam("file") FormDataContentDisposition disposition,
            @Context ServletContext ctx
    ) {

        //设置保存的路径和文件名
        var upload = new File(ctx.getRealPath("/files"),
                disposition.getFileName());

        try {
            FileUtils.copyInputStreamToFile(fileInputStream, upload);
        } catch (Exception ex) {
            return "failed";
        }

        return "success";
    }

    /*
    curl --location 'http://localhost:8080/hi/file/upload' \
    --form 'file=@"~/image.jpg"'
     */
    @GET
    @Path("/images/{name}.{type}")
    public void showImg(
            @PathParam("name") String imageName,
            @PathParam("type") String type,
            @Context ServletContext ctx,
            @Context HttpServletResponse response
    ) {
        try {
            var file = new File(ctx.getRealPath("/files"), imageName + "." + type);
            FileUtils.copyFile(file, response.getOutputStream());
        } catch (Exception ex) {

        }
    }

    //http://localhost:8080/hi/file/images/image.jpg
}

javax.ws.rs-api 常用注解

手动序列化org.jooq.JSON

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.io.IOException;

/**
 *
 * @author yaozhen
 */
public class MyJooqJsonSerializer extends JsonSerializer<org.jooq.JSON> {

    @Override
    public void serialize(org.jooq.JSON value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        if (value == null) {
            gen.writeNull();
        } else {
            gen.writeRawValue(value.data());
        }
    }
}

ar__ha
关注
专栏目录
Jetty 服务器架构分析(下)
黄刚的专栏
02-23 7747
Jetty服务器架构分析-请求处理
jetty服务器的使用
qq_41629490的博客
04-14 1314
1.jetty服务器的下载: http://www.eclipse.org/jetty/previousversions.html jetty对于jdk1.8支持到9.4版本，更高需要java11 左侧是win环境解压缩版，右侧是Linux解压缩版本。 2.下载后解压: 目录介绍: -- bin 存放Windows和linux等系统中使用的Jetty启动脚本和相关文件 -- contexts...
jetty介绍
乾坤未定，你我皆是黑马
05-23 2278
jetty是什么 Jetty 是一个开源的servlet容器。 它为基于Java的web容器，例如JSP和servlet提供运行环境。 Jetty是使用Java语言编写的，它的API以一组JAR包的形式发布。开发人员可以将Jetty容器实例化成一个对象，可以迅速为一些独立运行（stand-alone）的Java应用提供网络和web连接。 可以在jetty中配置什么 配置服务 Server实例是Jetty服务的重要组成部分，它为其它Jetty组件提供服务和生命周期管理。 Handlers：一个Jetty服务器
Jetty详解
最新发布
刘皇叔说Java的博客
07-30 804
Jetty是一个开源的、轻量级的Java Web服务器和Servlet容器，由Eclipse基金会维护。它被广泛用于嵌入式系统和开发环境，因其灵活性、高性能和嵌入能力而受到欢迎。Jetty是一款高性能、轻量级、灵活的Java Web服务器和Servlet容器，适用于各种规模的Web应用程序。其支持多种I/O模型和丰富的扩展功能，使其成为开发和生产环境中常用的服务器之一。通过合理配置和扩展，Jetty可以提供高效、可靠的Web服务。
【Jetty Server 开发系列之一】搭建Jetty Server环境&&Http客户端实现交互
李华明Himi
05-25 8595
本站文章均为 李华明Himi 原创,转载务必在明显处注明：转载自【黑米GameDev街区】 原文链接: http://www.himigame.com/java-servlet/862.html　　　　　　　　　　☞ 点击订阅 ☜ 本博客最新动态!及时将最新博文通知您！关于Jetty 简单来说就是一个servlet的容器，如同tomcat 等，至于详细的介绍请大家自行baidu～google那么本
Jersey框架二：Jersey对JSON的支持
cc41798520101的博客
09-12 720
Jersey提供3种基本方式来使用JSON格式 无论使用何种方式，在原有包的基础上，都需要在客户端和服务端Maven配置文件中添加jersey-json包以支持JSON格式 [html] view plain copy dependency>       groupId>com.sun.jerseygroupId>       artifact
RESTWebService实现之一 : Jetty+Jersey（嵌入式Jetty方式）
zzidea的专栏
02-13 1464
说明：本文采用采用Jersey这个Java REST标准来实现，Jersey融入Jetty的方法，参考自Jersey的UserGuide。UserGuide的URI为：https://jersey.github.io/documentation/latest/index.html本文补足了从UserGuide到实现的Maven项目的差距，展示了一个完整的例子。一、实现代码1.主类 实现代码pack...
Jersey框架：封装基于Jetty的通用服务器
机器熊的技术大杂烩
01-04 436
1.需求场景 依赖于Jetty容器封装一个Jersey微服务的启动类，在微服务入口中通过简单的调用即可实现微服务启动。主要需求如下： 可以指定服务启动端口 可以指定服务的应用域路径 可以指定要注册到Jersey容器的资源包 可以指定要注册到Jersey容器的资源类 2.设计思路 在通用封装类中维护一个Jetty的Server实例，代表真正的服务器 默认注册res、filter和excepti...
使用Jersey框架构建Restful web服务（服务端+客户端）
ZhuangM
12-29 2039
一、环境jdk7 + Eclipse + Tomcat7 + jersey2二、服务端1、 新建Web项目，导入jersey+jackson相应的jar包； 2、 新建User、UserDao、UserService这三个类，代码如下： User.javapackage com.rest.server;import java.io.Serializable;import javax.xml.bi
jersey和jetty的restful服务程序
07-03
4. **启动Jetty服务器**：在主程序中，初始化并启动Jetty服务器，然后注册Jersey的Servlet容器。例如： ```java Server server = new Server(8080); ServletContainer servlet = new ServletContainer(new My...
最好的8个Java RESTful框架
09-02
- Jersey是JAX-RS规范的主要实现，是一个开放源代码的RESTful框架，自2012年开始进入2.x版本。 - 它提供了一套全面的API来创建和消费RESTful服务，支持多种内容类型和扩展。 - Jersey具有高度可定制性和灵活性，...
jetty 服务器
01-25
jetty 服务器，解压放到任意文件夹，配置路劲即可，。
jetty服务器
12-15
该资源文件中有jetty服务器安装包，还有eclipse jetty插件，以及配置文档，文档中包含idea的配置和eclipse的配置及跑起web项目的过程。仅供大家下载参考，不知道的可以给我留言。
jersey框架
02-26
jersey框架简单叙述以及 Jersey对HTTPS的支持， Jersey对Json的支持
Jersey+Jetty框架简单搭建（包含文件上传下载）
05-08
在IT行业中，构建Web服务是常见的任务之一，而 Jersey 和 Jetty 框架的结合使用可以帮助我们快速、高效地实现这一目标。本教程将详细讲解如何利用这两个强大的工具搭建一个支持文件上传和下载功能的Web应用。 首先...
MyEclipse + Jetty + Jersey 创建RESTFul service
qazx84265的专栏
08-21 2669
看不到图片，请移步http://note.youdao.com/share/?id=ac91fea21475e33bedaac2f2613278b6&type=note 最近因为项目，需要用java实现一个独立的数据库服务，类似于http Server，与网站后台（NOde.js）之间进行通信。 之前没接触过java以及web开发，经同事介绍，使用了REst风格，具体使用的技术、框
使用Jersey 2.x的RESTFul Web服务（第一部分）
04-03
在Java世界中，Jersey是实现RESTful服务的首选框架之一，尤其在版本2.x中，其功能更为强大且易用。本教程将引导您逐步了解如何使用Jersey 2.x来创建RESTful服务。 ### 1. Jersey简介 Jersey是由Sun Microsystems...
Jetty服务器
qq_31942447的博客
06-29 2335
Jetty服务器一． Jetty1.1 什么是JettyJetty是一个提供HHTP服务器、HTTP客户端和javax.servlet容器的开源项目。 　　这个入门教程分为五个部分：· 第一部分部分重点介绍如何使用Jetty，它提供如下信息，如什么是Jetty，从哪可以下载它，怎么在像Maven一样的仓库中找到它。这一部分同样会提供启动Jetty和如何配置Jetty的快速入门。· 第二部分从更细致...
使用Jersey 2.0构建RESTful Web服务
本书是关于使用Jersey 2.0框架和JAX-RS API来开发RESTful Web服务的指南。RESTful Web服务是一种架构风格，用于构建基于HTTP协议的、无状态的、客户端-服务器通信的Web应用。Jersey是Java平台上的一个开源项目，它...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值