Website

Check out Restfulie’s website if you still did not.

Restfulie: quit pretending

CRUD through HTTP is a good step forward to using resources and becoming RESTful, another step further into it is to make use of hypermedia based services and this gem allows you to do it really fast.

You can read the article on using the web for real which gives an introduction to hypermedia/aware resources.

Why would I use restfulie?

1. Easy —> writing hypermedia aware resource based clients
2. Easy —> hypermedia aware resource based services
3. Small → it’s not a bloated solution with a huge list of APIs
4. HATEOAS —> clients you are unaware of will not bother if you change your URIs
5. HATEOAS —> services that you consume will not affect your software whenever they change part of their flow or URIs

Could you compare it with other REST related APIs?

Restfulie was the first API trying to somehow implement Jim Webber point of view on how RESTFul systems use hypermedia as the way to lead your client’s path through a business process.

You can see a 3rd party comparison between all REST frameworks.

Therefore Restfulie is unique in its feature set when compared to other (JAX-RS) based implementations: looking for simple code and favoring conventions over manual configurations when creating hypermedia aware system. Restfulie also handle content negotiation and its client implements cache and other set of features unsupported so far in other frameworks.

According to Richardson Maturity Model , systems are only to be called RESTFul if they support this kind of state flow transition through hypermedia content contained within resources representations:

<order>
    <product>basic rails course</product>
    <product>RESTful training</product>
    <atom:link rel="payment" href="http://www.caelum.com.br/orders/1/pay" xmlns:atom="http://www.w3.org/2005/Atom"/>
    <atom:link rel="cancel" href="http://www.caelum.com.br/orders/1" xmlns:atom="http://www.w3.org/2005/Atom"/>
</order>

If you are to implement a 3rd level (restful) service, Restfulie is the way to go.

More examples

There is a Restfulie guide being built but still in beta version.
You can also download a sample application , both client and server code.
FInally, do not forget to ask your questions at our mailing list .

Java or Ruby

Restfulie comes many different flavors, java and ruby.

One minute examples

Client side

The client side code allows you to hide http-protocol specifics if required, while allowing you to re-configure it when needed.
Example on accessing a resource and its services through the restfulie API:

Order order = new Order();

// place the order
order = service("http://www.caelum.com.br/order").post(order);

// cancels it
resource(order).getRelation("cancel").execute();

Server side

This is a simple example how to make your state changes available to your resource consumers:

public class Order implements HypermediaResource {

    public List<Relation> getRelations(Restfulie control) {
        if (status.equals("unpaid")) {
            control.relation("latest").uses(OrderingController.class).get(this);
            control.relation("cancel").uses(OrderingController.class).cancel(this);
        }
        return control.getRelations();
    }

}

Installation

Download everything

Start downloading all data : the client jars, vraptor jars and both server side and client side application.

You can download a sample client and server side application on the same link, those will be helpful for you too understand how to use Restfulie.

Client side installation

In order to use Restfulie in your client side app, simply add all required jars to your classpath.

Server side installation

Download vraptor’s blank project and configure your web.xml file. You are ready to go.

Client side usage

The entry point for Restfulie’s api is the Restfulie class. It’s basic usage is through the resource method which, given an URI, will allow
you to retrieve a resource or post to a resource controller:

  Order order = Restfulie.resource("http://www.caelum.com.br/orders/1").get();
  
  Client client = new Client();
  Restfulie.resource("http://www.caelum.com.br/clients").post(client);

Due to the nature of the entry point and the java bytecode, Restfulie is still unable to allow the user to make the http verb even more transparent.

As seen earlier, as soon as you have acquired an object through the use of the restfulie api, you can invoke its transitions:

Order order = Restfulie.resource("http://www.caelum.com.br/orders/1").get();
resource(order).getRelation("cancel").access();

The resource method can be statically imported from the Restfulie class.

Serialization configuration

Restfulie uses XStream behind the scenes, therefore all XStream related annotations are supported by default when using it.
The following example shows how to alias a type:

@XStreamAlias("order")
public class Order {
}

More info on how to configure XStream through the use of annotations can be “found in its website”:“http://xstream.codehaus.org”.

By default, Restfulie serializes all primitive, String and enum types. In order to serialize child elements, one has pre-configure Restfulie. This is
the typical usage-pattern applications will face while using restfulie:

Resources resources = Restfulie.resources();
resources.configure(Order.class).include("items");

// the configuration step is completed, so lets use it now:
resources.entryAt("http://www.caelum.com.br/clients").post(new Client());

The entire serialization process can be configured either through the Resources interface’s methods or using *XStream*’s explicit configuration.

Caching

Most REST frameworks will not help the developer providing etags, last modified and other cache related headers.

Meanwhile, in the server side, Restfulie might add extra headers to handle last modified, etag and max age situations that will improve response time and avoid useless bandwidth consumption. In order to benefit from such cache characteristics, simply implement the RestfulEntity interface.

Accessing all possible transitions

One can access all possible transitions for an object by invoking a resource’s getRelations method:

   List<Relation> relations = resource(order).getRelations();

While typical level 2 frameworks will only provide a statically, compilation time checked, relation/transition invocation, Restfulie allows clients/bots to adapt to REST results, giving your clients even less coupling to your services protocol.

HTTP verbs

By default, restfulie uses a well known table of defaults for http verb detection according to the rel element:

  • destroy, cancel and delete send a DELETE request
  • update sends a PUT request
  • refresh, reload, show, latest sends a GET request
  • other methods sends a POST request

If you want to use a custom http verb in order to send your request, you can do it:

 payment = resource(order).getRelation("payment").method(HttpMethod.PUT).accessAndRetrieve(payment);
 

Sending some parameters

If you need to send some information to the server, this can be done by passing an argument to the execute method, which will be serialized and sent as the request body’s content:

 payment = resource(order).getRelation("payment").method(HttpMethod.PUT).accessAndRetrieve(payment);
 

More info

Once you have found the entry point you want to use (retrieving a resource or creating one), the javadoc api is a resourcefull place for more info.

Server side usage

The default way to use Restfulie is to define the getRelations method in your resource. The method receives a Restfulie instance (server side version) which allows you to dsl-like create transitions. In order to do that, given a Restfulie object, invoke the transition method with your rel name and the relative controller action:

   public List<Relation> getRelations(Restfulie control) {
        control.relation("delete").uses(OrderingController.class).cancel(this);
        return control.getRelations();
    }

Note that both the OrderingController class with its cancel method are web methods made available through the use of vraptor:

@Resource
public OrderingController {

    @Delete
    @Path("/order/{order.id}")
    @Transition
    public void cancel(Order order) {
        order = database.getOrder(order.getId());
        order.cancel();
        status.ok();
    }
}

Now you need to set up your application package in web.xml. This is the only configuration required:

   <context-param>
        <param-name>br.com.caelum.vraptor.packages</param-name>
        <param-value>br.com.caelum.vraptor.restfulie,com.your.app.package.without.leading.whitespace</param-value>
    </context-param>

Relation/Transition invocation

By using the @Transition to annotate your method, Restfulie will automatically load the order from the database and check for either 404 (object not found), 405 (method not allowed), 409 (conflict: transition is not allowed for this resource’s state) and 406 (content negotiation failed).

This is one of the advantages of using Restfulie over other level 2 Rest frameworks. By supporting hypermedia content and handling transitions out of the box, Restfulie creates a new layer capable
of helping the server to deal with unexpected states.

Typical example

1. Create your model (i.e. Order)

@XStreamAlias("order")
public class Order {

    private String id;
    private Location location;
    private List<Item> items;

    private transient String status;
    private Payment payment;

    public enum Location {
        takeAway, drinkIn
    };
    
    // ...

}

@XStreamAlias("item")
public class Item {
    enum Coffee {LATTE, CAPPUCINO, ESPRESSO};
    enum Milk {SKIM, SEMI, WHOLE};
    enum Size {SMALL, MEDIUM, LARGE};

    private Coffee drink;
    private int quantity;
    private  Milk milk;
    private Size size;

    // ...

}

2. Usually the getRelations method would check the resource state in order to coordinate which transitions can be executed:
So add the getRelations method returning an array of possible transitions/relations:

public class Order implements HypermediaResource {


    public List<Relation> getRelations(Restfulie control) {
        if (status.equals("unpaid")) {
            control.relation("latest").uses(OrderingController.class).get(this);
            control.relation("cancel").uses(OrderingController.class).cancel(this);
            control.relation("payment").uses(OrderingController.class).pay(this,null);
        }
        return control.getRelations();
    }

}

3. Create your retrieval method:

   @Get
    @Path("/order/{order.id}")
    public void get(Order order) {
        order = database.getOrder(order.getId());
        result.use(xml()).from(order).include("items").serialize();
    }

You are ready to go. Create a new order and access it through your /order/id path.
The best way to start is to download the sample application and go through the OrderingController and Order classes.

Content negotiation

While most REST frameworks only support rendering xml out of the box, Restfulie already provides (through VRaptor and Spring) xml, xhtml and json representations of your resource. You can add new serializers as required. In order to take
content negotiation into play, simply use VRaptor’s representation() renderer:

   @Get
    @Path("/order/{order.id}")
    public void get(Order order) {
        order = database.getOrder(order.getId());
        result.use(representation()).from(order).include("items").serialize();
    }

Creating relations to other servers

public class Order implements HypermediaResource {


    public List<Relation> getRelations(Restfulie control) {
        control.relation("up").at('http://caelumobjects.com');
        return control.getRelations();
    }

}

Note that you can either create relations or transitions. We suggest clients to only use relations, but for clear semantics in some servers, you might want to invoke control.transition.

Accepting more than one argument

While typical JAX-RS services will deserialize your request body into your method argument and require you to retrieve extra URI information through the requested URI, Restfulie accepts one core parameter (based on its alias) and extra parameters to be extracted through the URI itself:

   @Post
    @Path("/order/{order.id}/pay")
    @Consumes
    @Transition
    public void pay(Order order, Payment payment) {
        order = database.getOrder(order.getId());
        order.pay(payment);
        status.ok();
    }

Parameter support is provided through VRaptor, so Iogi and Paranamer support is already built-in.

Asynchronous Request

To make an asynchronous request, you can use getAsync, postAsync, putAsync or deleteAsync methods. For that, you must provide a RequestCallback instance with a callback method implementation (the code to be executed when the response comes), like this:

RequestCallback requestCallback = new RequestCallback() {
    @Override
    public void callback(Response response) {
        // code to be executed when the response comes
    }
};

Future<Response> future1 = Restfulie.at("http://www.caelum.com.br/clients").getAsync(requestCallback);

If you prefer, you can abbreviate it this way:

Future<Response> future1 = Restfulie.at("http://www.caelum.com.br/clients").getAsync(new RequestCallback() {
    @Override
    public void callback(Response response) {
        // code to be executed when the response comes
    }
});

Using Log4j to log exceptions from Asynchronous Request

If you want Log4j to log the exceptions occurred when something goes wrong with the asynchronous request, you can create a log4j.xml configuration file on your classpath like this:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
        
        <appender name="stdout" class="org.apache.log4j.ConsoleAppender">
                <layout class="org.apache.log4j.PatternLayout">
                        <param name="ConversionPattern" 
                                value="%d{HH:mm:ss,SSS} %5p [%-20c{1}] %m%n"/>
                </layout>
        </appender>

        <category name="br.com.caelum.restfulie">
                <priority value="ERROR" />
                <appender-ref ref="stdout" />
        </category>

</log4j:configuration>

Getting help and mailing lists

If you are looking for or want to help, let us know at the mailing list:

http://groups.google.com/group/restfulie-java

VRaptor’s website also contain its own mailing list which can be used to get help on implementing controller’s.

Team

Restfulie was created and is maintained within Caelum by

Projetct Founder

Contributors

Example

You can see an application’s source code, both client and server side were implemented using restfulie:

Contributing

Users are encouraged to contribute with extra implementations for each layer (i.e. spring mvc implementation for the controller layer).

Inner libraries

In its Java version, Restfulie uses by default:

XStream is the most famous java serialization tool around with support both to json and xml while VRaptor (as Rails) supplies a reverse URI lookup system upon its controller which provides a way to identify URI’s from well defined transitions.

License

Check the license file



Website

如果您还没有,请查看 Restfulie的网站

Restfulie: quit pretending

通过HTTP的CRUD是使用资源并成为RESTful的一个很好的一步,进一步的另一步是利用基于超媒体的服务,这个gem允许你真正做到这一点。

您可以阅读使用相关文章网络为真实的,它介绍了超媒体/感知资源。

为什么要使用restfulie?

1。容易 - &gt;编写基于超媒体感知资源的客户端 容易 - &gt;超媒体感知资源服务 小→这不是一个庞大的解决方案,有大量的API HATEOAS - &gt;您不知道的客户如果更改您的URIs不会打扰 HATEOAS - &gt;您消费的服务不会影响您的软件,只要他们更改其流程或URI的一部分

您可以将其与其他与REST相关的API进行比较吗?

Restfulie是第一个尝试以某种方式实施 Jim Webber 的API,了解RESTFul系统如何使用超媒体作为引导您的方式客户通过业务流程的路径。

您可以在所有REST框架之间查看第三方比较

因此,与其他(基于JAX-RS)的实现相比,Restfulie在其功能集中是独一无二的:在创建超媒体感知系统时,寻找简单的代码并有利于约定手动配置。 Restfulie还处理内容协商,其客户端实现了其他框架目前尚未支持的缓存和其他功能集。

根据理查森成熟度模型,如果系统仅通过资源表示中包含的超媒体内容支持这种状态流转换,则称为RESTFul:

<order>
    <product>basic rails course</product>
    <product>RESTful training</product>
    <atom:link rel="payment" href="http://www.caelum.com.br/orders/1/pay&#34; xmlns:atom="http://www.w3.org/2005/Atom&#34;/>
    <atom:link rel="cancel" href="http://www.caelum.com.br/orders/1&#34; xmlns:atom="http://www.w3.org/2005/Atom&#34;/>
</order>

如果您要实施第三级(休息)服务,那么Restfulie就是要走的路。

更多例子

正在制作的Restfulie指南,但仍处于测试版本。
您还可以下载示例应用程序,客户端和服务器代码。
最后,请不要忘记在我们的邮件列表上提出问题。

Java或Ruby

Restfulie有许多不同的口味, java ruby​​

One minute examples

客户端

如果需要,客户端代码允许您隐藏HTTP协议详细信息,同时允许您在需要时重新配置它。 通过restfulie API访问资源及其服务的示例:

Order order = new Order();

// place the order order = service("http://www.caelum.com.br/order&#34;).post(order);

// cancels it resource(order).getRelation("cancel").execute();

服务器端

这是一个简单的例子,说明如何使您的状态更改可供您的资源消费者使用:

public class Order implements HypermediaResource {

public List&lt;Relation&gt; getRelations(Restfulie control) {
    if (status.equals(&#34;unpaid&#34;)) {
        control.relation(&#34;latest&#34;).uses(OrderingController.class).get(this);
        control.relation(&#34;cancel&#34;).uses(OrderingController.class).cancel(this);
    }
    return control.getRelations();
}

}

Installation

下载一切

启动下载所有数据:客户端jar, vraptor jar和服务器端和客户端应用程序。

您可以在同一个链接上下载示例客户端和服务器端应用程序,那些对您也有帮助,您也了解如何使用Restfulie。

客户端安装

为了在客户端应用程序中使用Restfulie,只需在您的类路径中添加所有必需的jar

服务器端安装

下载 vraptor的空白项目并配置您的web.xml文件。你准备好了。

Client side usage

Restfulie api的入口点是 Restfulie 类。它的基本用法是通过资源方法,给定一个URI,它将允许 您要检索资源或发布到资源控制器:

  Order order = Restfulie.resource("http://www.caelum.com.br/orders/1&#34;).get();

Client client = new Client(); Restfulie.resource("http://www.caelum.com.br/clients&#34;).post(client);

由于入口点和java字节码的性质,Restfulie仍然无法允许用户使http动词更加透明。

如前所述,只要您通过使用restfulie api获取对象,您可以调用其转换:

Order order = Restfulie.resource("http://www.caelum.com.br/orders/1&#34;).get();
resource(order).getRelation("cancel").access();

资源方法可以从 Restfulie 类静态导入。

序列化配置

Restfulie在幕后使用XStream,因此,在使用XStream时,所有XStream相关的注释都将默认支持。 以下示例显示如何别名类型:

@XStreamAlias("order")
public class Order {
}

有关如何通过使用注释配置XStream的更多信息可以在其网站中找到: http://xstream.codehaus。 org

默认情况下,Restfulie将所有原语,String和枚举类型序列化。为了序列化子元素,有一个预配置Restfulie。这是 典型的使用模式应用程序在使用restfulie时将面临:

Resources resources = Restfulie.resources();
resources.configure(Order.class).include("items");

// the configuration step is completed, so lets use it now: resources.entryAt("http://www.caelum.com.br/clients&#34;).post(new Client());

整个序列化过程可以通过资源界面的方法或使用* XStream *的显式配置进行配置。

缓存

大多数REST框架不会帮助开发人员提供etags,上次修改和其他缓存相关的标头。

同时,在服务器端,Restfulie可能会添加额外的头来处理最后一次修改,最大化和最大化的情况,这将改善响应时间,并避免无用的带宽消耗。为了从这样的缓存特性中受益,只需实现RestfulEntity接口。

访问所有可能的转换

可以通过调用资源的 getRelations 方法来访问对象的所有可能的转换:

   List<Relation> relations = resource(order).getRelations();

虽然典型的2级框架只会提供静态,编译时间检查,关系/转换调用,Restfulie允许客户端/机器人适应REST结果,为您的客户端更少的耦合到您的服务协议。

HTTP动词

默认情况下,restfulie根据rel元素使用众所周知的HTTP动词检测表:

  • 销毁,取消和删除发送DELETE请求
  • 更新发送PUT请求
  • 刷新,重新加载,显示,最新发送GET请求
  • 其他方法发送POST请求

如果要使用自定义http动词发送请求,可以执行以下操作:

 payment = resource(order).getRelation("payment").method(HttpMethod.PUT).accessAndRetrieve(payment);
 

发送一些参数

如果您需要向服务器发送一些信息,可以通过将参数传递给execute方法来完成,该方法将被序列化并作为请求主体的内容发送:

 payment = resource(order).getRelation("payment").method(HttpMethod.PUT).accessAndRetrieve(payment);
 

更多信息

一旦您找到要使用的入口点(检索资源或创建一个资源),那么javadoc api是更多信息的资源空间。

Server side usage

使用Restfulie的默认方法是在资源中定义getRelations方法。该方法接收一个 Restfulie 实例(服务器端版本),它允许您像创建转换一样使用dsl。为了做到这一点,给定一个 Restfulie 对象,使用 rel 名称和相对控制器操作

调用转换方法:

   public List<Relation> getRelations(Restfulie control) {
        control.relation("delete").uses(OrderingController.class).cancel(this);
        return control.getRelations();
    }
请注意, OrderingController 类及其 cancel 方法是通过使用vraptor提供的Web方法:

@Resource
public OrderingController {

@Delete
@Path(&#34;/order/{order.id}&#34;)
@Transition
public void cancel(Order order) {
    order = database.getOrder(order.getId());
    order.cancel();
    status.ok();
}

}

现在您需要在web.xml中设置应用程序包。这是唯一需要的配置:

   <context-param>
        <param-name>br.com.caelum.vraptor.packages</param-name>
        <param-value>br.com.caelum.vraptor.restfulie,com.your.app.package.without.leading.whitespace</param-value>
    </context-param>

关系/过渡调用

通过使用 @Transition 来注释方法,Restfulie将自动从数据库加载订单,并检查404(对象未找到),405(不允许方法),409(冲突:该资源的状态不允许转换)和406(内容协商失败)。

这是使用Restfulie超过其他2级Rest框架的优点之一。通过支持超媒体内容和开箱即可处理转换,Restfulie创建一个新的层 帮助服务器处理意外状态。

典型例子

1。创建您的模型(即订单)

@XStreamAlias("order")
public class Order {

private String id;
private Location location;
private List&lt;Item&gt; items;

private transient String status;
private Payment payment;

public enum Location {
    takeAway, drinkIn
};

// ...

}

@XStreamAlias("item") public class Item { enum Coffee {LATTE, CAPPUCINO, ESPRESSO}; enum Milk {SKIM, SEMI, WHOLE}; enum Size {SMALL, MEDIUM, LARGE};

private Coffee drink;
private int quantity;
private  Milk milk;
private Size size;

// ...

}

2。通常, getRelations 方法将检查资源状态,以协调可以执行哪些转换:
因此,添加 getRelations 方法返回可能的转换/关系数组:

public class Order implements HypermediaResource {

public List&lt;Relation&gt; getRelations(Restfulie control) {
    if (status.equals(&#34;unpaid&#34;)) {
        control.relation(&#34;latest&#34;).uses(OrderingController.class).get(this);
        control.relation(&#34;cancel&#34;).uses(OrderingController.class).cancel(this);
        control.relation(&#34;payment&#34;).uses(OrderingController.class).pay(this,null);
    }
    return control.getRelations();
}

}

3。创建检索方法:

   @Get
    @Path("/order/{order.id}")
    public void get(Order order) {
        order = database.getOrder(order.getId());
        result.use(xml()).from(order).include("items").serialize();
    }
你准备去了。创建新的订单并通过您的/ order / id路径进行访问 最好的开始方式是下载示例应用程序并浏览 OrderingController 订单类。

内容协商

尽管大多数REST框架仅支持将xml开箱即用,Restfulie已经通过VRaptor和Spring提供了xml,xhtml和json表示资源。您可以根据需要添加新的序列化程序。为了拿 内容协商进行播放,只需使用VRaptor的表示()渲染器:

   @Get
    @Path("/order/{order.id}")
    public void get(Order order) {
        order = database.getOrder(order.getId());
        result.use(representation()).from(order).include("items").serialize();
    }

创建与其他服务器的关系

public class Order implements HypermediaResource {

public List&lt;Relation&gt; getRelations(Restfulie control) {
    control.relation(&#34;up&#34;).at(&#39;http://caelumobjects.com&#39;);
    return control.getRelations();
}

}

请注意,您可以创建关系或转换。我们建议客户端只使用关系,但是对于某些服务器中的清晰语义,您可能需要调用control.transition。

接受多个参数

虽然典型的JAX-RS服务将将您的请求体反序列入您的方法参数,并要求您通过请求的URI检索额外的URI信息,Restfulie接受一个核心参数(基于其别名)和通过URI本身:

   @Post
    @Path("/order/{order.id}/pay")
    @Consumes
    @Transition
    public void pay(Order order, Payment payment) {
        order = database.getOrder(order.getId());
        order.pay(payment);
        status.ok();
    }

通过VRaptor提供参数支持,因此Iogi和Paranamer支持已经内置。

Asynchronous Request

要进行异步请求,可以使用getAsync,postAsync,putAsync或deleteAsync方法。为此,您必须提供一个具有回调方法实现的RequestCallback实例(响应到来时要执行的代码),如下所示:

RequestCallback requestCallback = new RequestCallback() {
    @Override
    public void callback(Response response) {
        // code to be executed when the response comes
    }
};

Future<Response> future1 = Restfulie.at("http://www.caelum.com.br/clients&#34;).getAsync(requestCallback);

如果你愿意,你可以这样缩写:

Future<Response> future1 = Restfulie.at("http://www.caelum.com.br/clients&#34;).getAsync(new RequestCallback() {
    @Override
    public void callback(Response response) {
        // code to be executed when the response comes
    }
});

使用Log4j从异步请求记录异常

如果您希望Log4j记录异步请求出错时发生的异常,可以在类路径上创建一个log4j.xml配置文件,如下所示:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/&#34;>

    &lt;appender name=&#34;stdout&#34; class=&#34;org.apache.log4j.ConsoleAppender&#34;&gt;
            &lt;layout class=&#34;org.apache.log4j.PatternLayout&#34;&gt;
                    &lt;param name=&#34;ConversionPattern&#34; 
                            value=&#34;%d{HH:mm:ss,SSS} %5p [%-20c{1}] %m%n&#34;/&gt;
            &lt;/layout&gt;
    &lt;/appender&gt;

    &lt;category name=&#34;br.com.caelum.restfulie&#34;&gt;
            &lt;priority value=&#34;ERROR&#34; /&gt;
            &lt;appender-ref ref=&#34;stdout&#34; /&gt;
    &lt;/category&gt;

</log4j:configuration>

获取帮助和邮件列表

如果您正在寻找或想要帮助,请在邮件列表中通知我们:

http://groups.google.com/group/restfulie-java

VRaptor的网站还包含自己的邮件列表,可用于获取有关实施控制器的帮助。

团队

创建了Restfulie,并由Caelum维护 Projectct创始人

贡献者

示例

您可以看到应用程序的源代码,客户端和服务器端都是使用 restfulie

贡献

鼓励用户为每个层提供额外的实现(即控制器层的弹簧mvc实现)。

内部库

在其Java版本中,Restfulie默认使用:

XStream是最着名的java序列化工具,支持json和xml,而VRaptor(作为Rails)在其控制器上提供了一个反向URI查找系统,该系统提供了一种从定义良好的转换中识别URI的方法。

许可证

检查许可证文件




相关问题推荐