Advanced Programming Coursework Assignment

You are required to build a Spring Boot REST application as described in the separate

specification document. The specification is personalised for each student and you must

follow the specification provided for you individually.

Although the finished application must be submitted as a compilable Maven project, the

majority of the marks are for a report documenting the build process. This is a practical

assignment and the report does not need any general background information. You should

closely follow the outline given below.

It is expected that you follow closely the study materials provided in the module. You should

use Spring Initializr and the dependencies listed in the specification and those used in the

lab exercises. You should generally not make any use of code, libraries or techniques that

have not been explicitly described in the module materials, and if you do you must clearly

document where you learned what you have done and why you chose to do it that way

and not in the way you have been shown. Please note that this is an assessed criterion.

Please note that it is essential that you document the process of writing the code, not

merely the finished result. You need to explicitly describe the way your first attempt code

for each piece of functionality is modified to get the final working version. An explanation of

completed code without any documentation of its gradual evolution will not be given much

credit.

Outline of required report document $($headings and expected content$)$:

$1.$ Setting up

Document the initial project you create on the Spring Initializr system and the

dependencies you include.

$2.$ Initial runs

Document your initial attempt at running the project and your first attempts at

responding to a client request. This must include your initial code and relevant

output from the program. This should include any issues that arose and any

experiments you tried in order to get this working, and your reasoning in either case.

$3.$ Domain object class

Your specification will include a description of the data object that will need to be

defined to store in the data base and send to and from the client interface. You need

to present the code you wrote for this and a description of what was required. Again

you should include your thinking as to what was required and behind the choices you

made in your design. You must document the changes that you make to your code as

the application development proceeds $-$ that is$,$ you should present your initial

attempt at the data object and then changes made to it to support persistence

functionality.

$4.$ Persistence and suitable API calls

You need to document the process of getting the persistence working. This should

involve detailed explanation of the code used to implement persistence and all

related changes in the code. You must document the changes that you make to your

code as the application development proceeds $-$ that is$,$ you should present your

CSI$-5-$ADP Advanced Programming $$ Coursework Assignment

$6$

initial attempt and then changes made to it to add functionality, fix problems and

improve the design. To demonstrate this working you will need to implement at least

one API call that stores an object received from the client encoded in JSON, and at

least one API call that retrieves an object and returns it to the client in JSON format.

You need to document the handler method that does this and explain the code used

to implement that, and include relevant screenshots of the interface to demonstrate

that persistence has been achieved.

$5.$ Remaining API calls

You need to document that remaining API calls $-$ the code that implements them and

evidence of them working using the interface. In order to demonstrate all the

functionality you will need to create more than one named collection of items with

items in it$.$ Once again you must document the changes that you make to your code

as the application development proceeds $-$ that is$,$ you should present your initial

attempts and subsequence modifications $-$ however where similar API handlers are

being implemented it might be that the completed code from an earlier one can be

reused for a later one with few incremental modifications.

You are required to develop a Spring Boot based web application similar to that which was developed in the lab exercises. You should start by creating a base project using the online Spring Initializr. You should use the provided generic$-$interface. html JavaScript interface to develop and demonstrate your application $($your application must serve this as a static web page for it to work properly$).$ The application should use JPA persistence with the $H2$ in$-$memory database for development purposes. It should offer the following API to clients:

$\backslash$table$[[$Method$,$URI,Body,Operation$],[$GET$,$api$/$divisions$,$none,$\backslash$table$[[$return a JSON docpersonalised specification is in the given photo $,$ so make the code and document accordingly