<properties>
    <dropwizard.version>INSERT VERSION HERE</dropwizard.version>
</properties>

<dependencies>
    <dependency>
        <groupId>io.dropwizard</groupId>
        <artifactId>dropwizard-core</artifactId>
        <version>${dropwizard.version}</version>
    </dependency>
</dependencies>

package com.example.helloworld;

import com.example.helloworld.core.Template;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.collect.ImmutableMap;
import io.dropwizard.Configuration;
import io.dropwizard.db.DataSourceFactory;
import org.hibernate.validator.constraints.NotEmpty;

import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.Collections;
import java.util.Map;

public class HelloWorldConfiguration extends Configuration {
    @NotEmpty
    private String template;

    @NotEmpty
    private String defaultName = "Stranger";

    @Valid
    @NotNull
    private DataSourceFactory database = new DataSourceFactory();

    @NotNull
    private Map<String, Map<String, String>> viewRendererConfiguration = Collections.emptyMap();

    @JsonProperty
    public String getTemplate() {
        return template;
    }

    @JsonProperty
    public void setTemplate(String template) {
        this.template = template;
    }

    @JsonProperty
    public String getDefaultName() {
        return defaultName;
    }

    @JsonProperty
    public void setDefaultName(String defaultName) {
        this.defaultName = defaultName;
    }

    public Template buildTemplate() {
        return new Template(template, defaultName);
    }

    @JsonProperty("database")
    public DataSourceFactory getDataSourceFactory() {
        return database;
    }

    @JsonProperty("database")
    public void setDataSourceFactory(DataSourceFactory dataSourceFactory) {
        this.database = dataSourceFactory;
    }

    @JsonProperty("viewRendererConfiguration")
    public Map<String, Map<String, String>> getViewRendererConfiguration() {
        return viewRendererConfiguration;
    }

    @JsonProperty("viewRendererConfiguration")
    public void setViewRendererConfiguration(Map<String, Map<String, String>> viewRendererConfiguration) {
        final ImmutableMap.Builder<String, Map<String, String>> builder = ImmutableMap.builder();
        for (Map.Entry<String, Map<String, String>> entry : viewRendererConfiguration.entrySet()) {
            builder.put(entry.getKey(), ImmutableMap.copyOf(entry.getValue()));
        }
        this.viewRendererConfiguration = builder.build();
    }
}

template: Hello, %s!
defaultName: Stranger

2. 新建Application类

package com.example.helloworld;

import io.dropwizard.Application;
import io.dropwizard.setup.Bootstrap;
import io.dropwizard.setup.Environment;
import com.example.helloworld.resources.HelloWorldResource;
import com.example.helloworld.health.TemplateHealthCheck;

public class HelloWorldApplication extends Application<HelloWorldConfiguration> {
    public static void main(String[] args) throws Exception {
        new HelloWorldApplication().run(args);
    }

    @Override
    public String getName() {
        return "hello-world";
    }

    @Override
    public void initialize(Bootstrap<HelloWorldConfiguration> bootstrap) {
        // nothing to do yet
    }

    @Override
    public void run(HelloWorldConfiguration configuration,
                    Environment environment) {
        // nothing to do yet
    }

}

      正如我们所看到的，HelloWorldApplication使用应用程序的configuration进行参数化，（因为用了我们的HelloWorldConfiuration，而它是Configuration的子类），initialize方法用于配置应用在正式启动之前所需：包，配置源等，同时我们需要加入一个main方法，这是我们应用的入口，到目前为止，我们并没有实现任何的功能，所以我们的run方法有点无趣，让我们开始丰富它。

3. 新建Representation类

    在我们开始继续我们的程序之前，我们需要停下来思考一下我们程序的API。幸运的是，我们的应用需要符合行业标准RFC 1149，它指定了helloworld saying的如下json表达形式：

{
  "id": 1,
  "content": "Hi!"
}

id字段是唯一标识，content是文字内容。下面是representation实现，一个简单的POJO类：

package com.example.helloworld.api;

import com.fasterxml.jackson.annotation.JsonProperty;
import org.hibernate.validator.constraints.Length;

public class Saying {
    private long id;

    @Length(max = 3)
    private String content;

    public Saying() {
        // Jackson deserialization
    }

    public Saying(long id, String content) {
        this.id = id;
        this.content = content;
    }

    @JsonProperty
    public long getId() {
        return id;
    }

    @JsonProperty
    public String getContent() {
        return content;
    }
}

     这是一个非常简单的POJO，但是有些需要注意的地方。首先，他是不可更改的。这使得saying在多线程环境和单线程环境非常容易被推理。其次，它使用java的JavaBean来保存id和content属性。这允许jackson把他序列化为我们需要的JSON。jackson对象的映射代码将会使用getId()返回的对象来填充JSON对象的id字段，content同理。最后，bean利用验证来确保内容不大于3。

4. 新建Resource类

    Jersey资源是DW应用程序的主要内容，每个资源类都与URL相关联（这个很重要，后面有说），对于我们的应用程序来说，我们需要一个resources来通过url：/helloworld来返回新的Saying实例对象。

package com.example.helloworld.resources;

import com.example.helloworld.api.Saying;
import com.google.common.base.Optional;
import com.codahale.metrics.annotation.Timed;

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 java.util.concurrent.atomic.AtomicLong;

@Path("/hello-world")
@Produces(MediaType.APPLICATION_JSON)
public class HelloWorldResource {
    private final String template;
    private final String defaultName;
    private final AtomicLong counter;

    public HelloWorldResource(String template, String defaultName) {
        this.template = template;
        this.defaultName = defaultName;
        this.counter = new AtomicLong();
    }

    @GET
    @Timed
    public Saying sayHello(@QueryParam("name") Optional<String> name) {
        final String value = String.format(template, name.or(defaultName));
        return new Saying(counter.incrementAndGet(), value);
    }
}

    HelloWorldResource有两个声明：@Path和@Produces。@Path("/hello-world")告诉Jersey这个resource可以通过 "/hello-world"URL被访问。

@Produces(MediaType.APPLICATION_JSON)让Jersey的内容协商代码知道这个资源产生的是application/json.

    HelloWorldResource构造器接收两个参数，创建saying的template和当用户没有指明名字时的默认名称，AtomicLong为我们提供一种线程安全，简易的方式去生成（ish）ID。sayHello方法是这个类的肉，也是一个非常简单的方法。@QueryParam("name")告诉Jersey把在查询参数中的name映射到方法中的name中。如果一个客户发送请求到：/hello-world?name=Dougie,sayHello 方法将会伴随Optional.of("Dougie")被调用。如果查询参数中没有name，sayHello将会伴随着Optional.absent()被调用。在sayHello方法里面，我们增加计数器的值，使用String.format来格式化模板，返回一个新的Saying实例。因为sayHello被@Timed注释，DW将会自动调用他的持续时间和速率记录为度量定时器。一旦sayHello返回，Jersey将会采用Saying的实例，并寻找一个提供程序类来将Saying实例写为：application/json。

5. 注册Resource

    在这些正式工作之前，我们需要到HelloWorldApplication中，并将新的resouce加入其中，在run方法中我们可以读取到HelloWorldConfiguration的template和defaultName实例，创建一个新的HelloWorldResource实例，并将其加入到新的Jersey环境中。我们HelloWorldApplication中新的run方法如下：

@Override
public void run(HelloWorldConfiguration configuration,
                Environment environment) {
    final HelloWorldResource resource = new HelloWorldResource(
        configuration.getTemplate(),
        configuration.getDefaultName()
    );
    environment.jersey().register(resource);
}

当我们的应用启动的时候，我们使用配置文件中的参数创建一个新的资源类实例，并传递给environment.

转自：http://blog.csdn.net/qq_23660243/article/details/54406075 以及 http://hao.jobbole.com/dropwizard/