Simple reference to URL pattern in RESTful methodology


Guidelines for RESTful URLs



Finding restful rules between REST clients and servers was more time consuming than other searches.  It must have been a block for others, too as I saw the question posted on various groups.  So I thought maybe it made sense to post my results here.

Books as an example seems common, so I use books in my sample below.

References:

  • My instructor
  • This reference.  While under a Ruby site, it applies to other languages:
    • https://guides.rubyonrails.org/routing.html#crud-verbs-and-actions 
    • This reference was very useful, but it only goes what I call "one deep"  that means in their example of "photos" we can act on photos/collection of photos.  However, it does not teach us how to add other "things" to photos.  For example, if the application is about users having photos, then we would add photos to a user. Or, if about the various users who have a certain photo, then we would be adding photos to that user
  • A Tutorial I found.
  • Various sources on these methods and when they should and should not be used:
      • GET
      • POST
      • PUT
      • DELETE
    • Note:  Opinions vary on implementation of these, too.
  • Idempotency

Here is a sample set of URLs for the case where a certain book (same ISBN not same physical copy, of course) can be owned by many people, and a single person can own many books.

  • /books
    • GET:  shows/delivers all books
    • GET with suffix as below renders a page for creation of a new book (used with html views)
      • /books/new
    • POST:  creates a new book
  • /books/2  Note:  2 is just an example...could be any integer
    • GET:  renders/delivers book number 2
      • with suffix edit renders page for editing as in:
        • /books/2/edit
    • POST:  creates book number 2
    • PUT:  edits or updates book number 2
    • Delete:  deletes book number 2
  • /books/2/users/opt#3  note that in the html case, opt#3 may be handled by session, but for independent client exchange (simulated by Postman) it must be supplied
    • GET:  ??  I suppose that could be about showing/delivering the case of book#2 owned by user 3
    • POST:  adds user3 to book 2
    • PUT:  ?? modifies something...I don't think this would be used..unless there is something unique for this relationship between this book and this user...like maybe the due back date that could be changed
    • DELETE:  deletes user 3 from book 2...or user 3 returns or disposes of book

Some of the rules used as basis for above:

  • GET should never alter data. Further to quote one of my sources listed above:
    • GET, HEAD, OPTIONS and TRACE methods are defined as safe, meaning they are only intended for retrieving data. This makes them idempotent as well since multiple, identical requests will behave the same.
  • Note the definition of idempotent:
    • From a RESTful service standpoint, for an operation (or service call) to be idempotent, clients can make that same call repeatedly while producing the same result. In other words, making multiple identical requests has the same effect as making a single request. Note that while idempotent operations produce the same result on the server (no side effects), the response itself may not be the same (e.g. a resource's state may change between requests).
  • PUT is used for modifications
  • Only POST can really be used for non-idempotent cases. For example POST  always gives something different
The above is some of what I learned and a reference.


Comments

Post a Comment

Popular posts from this blog

Spring Boot, parsing the pom.xml

Image
Spring Boot can be easy to start up:options Diving right in letting Spring Boot introductions be covered in another blog.... One way is to navigate to:  https://start.spring.io and find a page like the below: Just select the options then click Generate (not shown).  This will download a zip file which can then be imported easily into your IDE.  I use STS eclipse, after import, the result was: Because I selected Maven, there is a pom.xml file which is instructive.  It includes the necessary dependencies.  I could have specified them on the web page, but I usually just paste them in. Below is the pom.xml file contents from the demo: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelV...
Read more

Coding Philosophy

Coding Philosophy/Goals/Mindset: Achieve business and technical requirements Agility means these may change as the environment changes, or coding realities drive changes upstream We must adapt to these changes Consider those (including yourself) who will be reading/modifying the code : Extensibility How easily can new features be added? Readability Includes formatting, proper ID naming, and good quality comments--not too many Maintainability How easy will it be to make changes to this code? Scalability What about growth?  For example, another server, or database may be required Efficiency Especially for larger projects, it is important to minimize resource consumption Project velocity While subordinate to the above and within the bounds of efficiency completing quickly/on-time matters There are many techniques and guidelines for achieving the above such as avoiding magic numbers (use constants) and keeping methods short and single purpose. ...
Read more

Java: Reference vs. Object

Image
Declaring and initializing reference variables When learning Java we see reference variables declared and initialized like this: Case A:  ABC varName = new ABC(); Later in our learning, we see something like this: Case B:  ABC varName = new DEF(); Let's take this as an example for discussion: Dthing varName = new Othing(); What is Dthing and what is Othing? From the first chapters of introduction to Java we know that Dthing is the type, and Othing is a constructor, and so is the class of varName. More advanced instruction shows: Dthing is the Declared Type, or Reference Type (I have found them used interchangeably) Othing is the Object Type This vocabulary is needed for reasons including discussion about when to declare/instantiate with the Declared Type being the same as the Object type, and when they should be different. An example of that decision would be in the below. The why is another subject/post: List<String> varStrin...
Read more