可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试):

问题:

Every tutorial or explanation of REST just goes too complicated too quickly - the learning curve rises so fast after the initial explanation of CRUD and the supposed simplicity over SOAP. Why can't people write decent tutorials anymore!

I'm looking at Restlet - and its not the best, there are things missing in the tutorial and the language/grammar is a bit confusing and unclear. It has took me hours to untangle their First Steps tutorial (with the help of another Java programmer!)

RESTlet Tutorial Comments

Overall I'm not sure exactly who the tutorial was aimed at - because there is a fair degree of assumed knowledge all round, so coming into REST and Restlet framework cold leaves you with a lot of 'catchup work' to do, and re-reading paragraphs over and over again.

We had difficulty working out that the jars had to be in copied into the correct lib folder.
Problems with web.xml creating a HTTP Status 500 error -

The server encountered an internal error () that prevented it from fulfilling this request

, the tutorial says:

"Create a new Servlet Web application as usual, add a "com.firstStepsServlet" package and put the resource and application classes in."

This means that your fully qualified name for your class FirstStepsApplication is com.firstStepsServlet.FirstStepsApplication, so we had to alter web.xml to refer to the correct class e.g:

original:

<param-value>
         firstStepsServlet.FirstStepsApplication
</param-value>

should be:

<param-value>
         com.firstStepsServlet.FirstStepsApplication
</param-value>

Conclusion

I was under the impression that the concepts of REST were supposed to be much simpler than SOAP - but it seems just as bad if not more complicated - don't get it at all! grrrr

Any good links - much appreciated.

回答1:

It sounds like you could use a solid understanding of the fundamentals of REST, and for that I highly recommend RESTful Web Services by Leonard Richardson and Sam Ruby. I provides a great introduction to REST: what it is and how to implement a (practical) RESTful web service.

Most of the example code in the book is actually Ruby, but it's easy enough to understand even if you're not a Ruby expert. But one thing that should help you specifically is that one of the later chapters of the book contains overviews of several RESTful frameworks, including Restlet. It doesn't really get into any code (it's a 50,000-foot flyover) but I think it'll give you just what you need at this stage.

回答2:

Could you describe precisely what caused you troubles in our Restlet tutorials? We are interested in fixing/improving what needs to.

Did you check the screencasts? http://www.restlet.org/documentation/1.1/screencast/

Otherwise, there is a Restlet tutorial in the O'Reilly book that we wrote in their Chapter 12.

If you still have troubles, please contact our mailing list: http://www.restlet.org/community/lists

Best regards, Jérôme Louvel

Restlet ~ Founder and Lead developer ~ http://www.restlet.org Noelios Technologies ~ Co-founder ~ http://www.noelios.com

回答3:

The Restlet framework is composed of four main parts.

1. Restlet API

First, there is the "Restlet API", a neutral API supporting the concepts of REST and facilitating the handling of calls for both client-side and server-side applications. This API is backed by the Restlet Engine and both are now shipped in a single JAR ("org.restlet.jar").

This separation between the API and the implementation is similar to the one between the Servlet API and Web containers like Jetty or Tomcat, or between the JDBC API and concrete JDBC drivers.

2. Retrieving the content of a Web page

As we mentioned in the introduction paper, the Restlet framework is at the same time a client and a server framework. For example, Restlet can easily work with remote resources using its HTTP client connector. A connector in REST is a software element that enables the communication between components, typically by implementing one side of a network protocol. Restlet provides several implementations of client connectors based on existing open-source projects. The connectors section lists all available client and server connectors and explain how to use and configure them.

Here we will get the representation of an existing resource and output it in the JVM console:

// Outputting the content of a Web page  
new ClientResource("http://").get().write(System.out);

Note that the example above uses a simplified way to issue calls via the ClientResource class. If you need multi-threading or more control it is still possible to manipulate use the Client connector class or the Request objects directly. The example below how to set some preferences in your client call, like a referrer URI. It could also be the languages and media types you prefer to receive as a response:

// Create the client resource  
ClientResource resource = new ClientResource("http://www.restlet.org");  

// Customize the referrer property  
resource.setReferrerRef("http://www.mysite.org");  

// Write the response entity on the console  
resource.get().write(System.out);

3. Listening to Web browsers

Now, we want to see how the Restlet framework can listen to client requests and reply to them. We will use the internal Restlet HTTP server connector (even though it is possible to switch to others such as the one based on Mortbay's Jetty) and return a simple string representation "hello, world" as plain text. Note that the Part03 class extends the base ServerResource class provided by Restlet:

 public class Part03 extends ServerResource {  

    public static void main(String[] args) throws Exception {  
        // Create the HTTP server and listen on port 8182  
        new Server(Protocol.HTTP, 8182, Part03.class).start();  
    }  

    @Get  
    public String toString() {  
        return "hello, world";  
    }  

}

If you run this code and launch your server, you can open a Web browser and hit the . Actually, any URI will work, try also. Note that if you test your server from a different machine, you need to replace "localhost" by either the IP address of your server or its domain name if it has one defined.

So far, we have mostly showed you the highest level of abstraction in the Restlet API, with the ClientResource and ServerResource classes. But as we move forward, you will discover that those two classes are supported by a rich API, letting you manipulate all the REST artifacts.

4. Overview of a REST architecture

Let's step back a little and consider typical web architectures from a REST point of view. In the diagram below, ports represent the connector that enables the communication between components which are represented by the larger boxes.

回答4:

Not specifically Java-related, but I thought these InfoQ articles were quite good:

A Brief Introduction to REST
Addressing Doubts about REST
REST Anti-Patterns

回答5:

you point to an error inside the web.xml, but I've just checked in both Restlet 1.0 and 1.1 documentation, and I don't see this kind of error. I would like to mention that you can find at the end of the page a zip that contains a complete war file and the list of source files in case you want to run in "standalone" mode. Did you try the standalone mode? As explained in the tuto, you only need 2 jars in the classpath, and the source files.

We would like also to point that the "firstSteps" tutorial is not a tutorial on REST but on the programmation with Restlet. You can also have a look at the "firstResource" tutorial (http://www.restlet.org/documentation/1.1/firstResource) which describes how to develop a simple resource and which introduces some concepts of the REST architecture style. It should help you.

回答6:

In addition, the qualified named suggested in the tutorial is indeed "firstStepsServlet.FirstStepsApplication" and not "com.firstStepsServlet.FirstStepsApplication".

Therefore, the suggested param value in web.xml is correct.

Could you confirm that this fixes your issue? Also, did you have Servlet deployment knowledge before reading the tutorial? If not, that would explain the pain. In this case, the standalone mode is probably a better fit.