Module 3: Data Representation and JAX-RS
READING A FILE CONTENT FROM A DATA FILE
import java.io.IOException;
import java.nio.file.Files;
public class CustomerUtility {
// this will read the file and return a string
public static String readFileContents(String filename) {
// this is finding the path for the file
try {
java.nio.file.Path file = java.nio.file.Path.of(
// this is going to return the URI in String format
String.valueOf(
CustomerUtility.class.getResource(filename))
.substring(6)); // will return a substring of
the URI where it will delete 'http:/" which is generated automatically
return Files.readString(file);
} catch (IOException e) {
// something went wrong
return "Did you forget to create the file?\n" +
"Is the file in the right location?\n" +
e.toString();
}
}
}
Converting from a JSON object to Java object
public class CustomerResource {
Customers customersList;
// will convert to and from a json object to a java object
ObjectMapper objectMapper = new ObjectMapper(); // this is a built-in
function from the Jackson library
// this is initializing the data and calling the mapping function
CustomerResource() {
loadResource();
}
private void loadResource(){
try {
// reading from the json file converting to a java object
this.customersList =
objectMapper.readValue(readFileContents("/customers.json"),
Customers.class); // mapping the customers json object to java object
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
public class Customers {
// this will store a list of customer objects which maps to the key
customers in the json object
@JsonProperty("customers")
public List<Customer> customersList;
// will allow you to return one customer ID if it finds it in the list
public Customer findCustomerId(String id){
Customer cfound = null;
for(Customer c: customersList){ // loop through list of
customers
if (Objects.equals(c.getId(), id)){ // if the id is found
cfound= c;
}
}
return cfound;
}
}
Module 4: REST Representation
POPULATING A TABLE WITH DATA WITH JAVASCRIPT
function loadDataAsTable(){
// setting this variable divRef to the element divTable
let divRef = document.getElementById("divTable");
// Then set this variable to the table id and APPEND this table to the
div
let tableRef = document.createElement("table");
divRef.appendChild(tableRef);
// Creating a thead variable and appending the header to the table
let tableHeaderRef = document.createElement("thead");
tableRef.appendChild(tableHeaderRef);
// Creating a tbody variable and then appending the header to the table
let tableBodyRef = document.createElement("tbody");
tableRef.appendChild(tableBodyRef);
// looping through the object key - value pairs
let headers = Object.keys(customerData.customers[0]);
// looping through each header
for (let header of headers){
// Then setting the headers to the header tag in html, then append the
headers to the table
let headerRef= document.createElement("th");
headerRef.innerHTML=header;
tableHeaderRef.appendChild(headerRef);
}
// looping through each object in the json data
for (let c of customerData.customers){
// Create a row for each object
let rowRef = document.createElement("tr");
// Then loop through each element [key-value pairs] for each json
object
for (let key in c){
// Since each key-value pair, create a table data for each
let dataRef=document.createElement("td");
// Append each key-value pair in the table data
dataRef.innerHTML=c[key];
// Then append the table data into the table rows
rowRef.appendChild(dataRef);
}
// Then append the rows to the table
tableRef.appendChild(rowRef);
}
}
// ----------------- Returning a response from the API
----------------------- //
@GET
@Produces("application/json")
public Response getAllCustomers() { // will return a response object
using the CORS policy
loadResource();
String val = "Problem";
try {
val = objectMapper.writeValueAsString(customersList); // will
be converting the json to java here
} catch (JsonProcessingException e) { // handling exceptions
throw new RuntimeException(e);
}
// CORS Policy is a security measure that does not allow you to
run a file from one domain in another domain. It is blocked by default
// So you can manually set the port that the domain you are trying
to return is in
// creating a response
Response myResp = Response.status(200)
.header("Access-Control-Allow-Origin",
"http://localhost:8448") // this will allow the localhost 8448 to be
hosted
.header("Content-Type", "application/json") // the data
returning will be json format
.entity(val) // the data is customers
.build();
return myResp;
}
// will request a customer json object from the findCustomerId
function
@GET
@Path("/{id}")
@Produces("application/json")
public String getCustomerId(@PathParam("id") String cId){ // will use
the path parameter id from the path URI
loadResource();
Customer c = customersList.findCustomerId(cId);
if (c!=null){ // if you cannot find a customer object then return
the object as a json property
try {
return objectMapper.writeValueAsString(c); // this will
convert the customer java object to a json object
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
return "{\"Error\": \"Customer not found.\"}";
}
}
/**
* Function makes a HTTP request to an API
* **/
function requestData(apiCallURL){
// the fetch request is an asynchronous request to an API
fetch(apiCallURL, {
// defining request headers in the fetch request
method: 'GET',
headers: {
'Accept': 'application/json',
},
})
.then(response => response.json())
.then(response => loadDataAsTable("customers", response)); // this
will dynamically make the data inputted into the table in the html file
}
Module 5: File Input/Output
public class ExampleParser {
private File directory = null;
ExampleParser(File dir){
this.directory = dir;
}
// finding the average for each column (e.g assignment1 grades, etc)
public String findColumnAVG(String col){
// File inFile = new File();
String columnName = col;
String msg = "Not found or error occurred";
try {
FileReader fileInput = new FileReader(directory);
BufferedReader input = new BufferedReader(fileInput);
// read the first line
String line = null;
try {
line = input.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
// find the index of the named column
int columnIndex = -1;
String[] columnNames = line.split(","); // will split the line
at each column
for (int i = 0; i < columnNames.length; i++) {
if (columnNames[i].equals(columnName)) {
columnIndex = i;
break;
}
}
// there must be an error if the column is less than 0
if (columnIndex < 0) {
System.err.println("Error: Column name not found");
System.exit(0);
}
// calculate the average for that column
float total = 0f;
int count = 0;
// reading line by line
while ((line = input.readLine()) != null) {
String[] data = line.split(",");
float nextVal = Float.parseFloat(data[columnIndex]); //
will convert to float since our data is in floats
total += nextVal;
count++;
}
msg = "The average for "+ columnName+" is "+ (total/count);
input.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return msg;
}
}
public class BookParser {
public Map<String, Integer> wordFrequencyDir(File dir) throws
IOException {
Map<String, Integer> frequencies = new TreeMap<>(); // will hold
all the merged frequency maps
File[] filesInDir = dir.listFiles();
int numFiles = filesInDir.length;
// iterate over each file in the dir and count their words
for (int i = 0; i<numFiles; i++){
Map<String, Integer> wordMap = countWordFile(filesInDir[i]);
// get a frequency map between the word and its frequency
// merge the file wordMap into the global frequencies
Set<String> keys = wordMap.keySet(); // will get the set of
the keys in the frequency map
Iterator<String> keyIterator = keys.iterator();
while (keyIterator.hasNext()){
String word = keyIterator.next();
int count = wordMap.get(word);
if(frequencies.containsKey(word)){
// increment
int oldCount = frequencies.get(word);
frequencies.put(word, count + oldCount);
}
else{
frequencies.put(word, count);
}
}
return frequencies;
}
}
Function to count the words in the file
private Map<String, Integer> countWordFile(File file) throws
IOException {
Map<String, Integer> wordMap = new TreeMap<>();
if(file.exists()){
// load all the data and process it into words
Scanner scanner = new Scanner(file); // note: a scanner will
by default use a white space as a delimiter
while(scanner.hasNext()){
// ignore the casing for words
String word = (scanner.next()).toLowerCase(); // will
convert all uppercase letters to lowercase so the same word is not
duplicated
if (isWord(word)){ // only if the string is a word, then
add it in the map
// add the word if not exists yet
if(!wordMap.containsKey(word)){
wordMap.put(word, 1);
}
// increment the count if exists
else{
int oldCount = wordMap.get(word);
wordMap.put(word, oldCount+1);
}
}
}
}
return wordMap;
}
// Checking is word is actually a word (not a number, etc)
private Boolean isWord(String word){
if (word == null){
return false;
}
String pattern = "^[a-zA-Z]*$"; // this is checking if it has
alphabets in it consecutively.
if(word.matches(pattern)){
return true;
}
return false;
Function to write to a file
public class ExampleWriter {
public void createFile(File dir, String name, String content) throws
IOException {
File myFile = null;
myFile = new File(dir, name);
if(myFile.createNewFile()){
System.out.println("File created at: "+ myFile.getPath());
}else{
System.out.println("File already existed at: "+
myFile.getPath());
}
if(myFile!=null){
PrintWriter output = new PrintWriter(myFile);
output.print(content);
output.close();
}
}
}
// Will read the data in the specified url and find the column name
and then store it in the string
public String readData(@PathParam("col") String colName) {
URL url =
this.getClass().getClassLoader().getResource("/records/data.csv"); // This
will get the url for the specified file we want to read
System.out.print(url);
File data = null;
try {
data = new File(url.toURI());
} catch (URISyntaxException e) {
throw new RuntimeException(e);
}
String res = "Something went wrong";
if (data!=null){
ExampleParser myparser = new ExampleParser(data);
res = myparser.findColumnAVG(colName);
}
return res;
}
// Will return the frequency of each word
@GET
@Produces("application/json")
@Path("/book")
/**
* Endpoint URL:
http://localhost:8080/ParsingFiles-1.0-SNAPSHOT/api/read/book
* **/
public Response readBook() throws IOException {
URL url =
this.getClass().getClassLoader().getResource("/documents"); // this will
get the url of the of the class
File data = null;
try {
data = new File(url.toURI());
} catch (URISyntaxException e) {
throw new RuntimeException(e);
}
BookParser myParser = new BookParser();
// call function from parser to calculate the freq of words in
text
Map<String, Integer> freq = myParser.wordFrequencyDir(data);
System.out.println("-----------------Hello world!");
Response myResp =
Response.status(200).header("Access-Control-Allow-Origin",
"http://localhost:8448")
.header("Content-Type", "application/json")
.entity(mapper.writeValueAsString(freq)) // since we have
a map object and we need a json object, we will use the jackson library
.build();
return myResp;
}
Writing data to the server
@POST
@Consumes("text/plain")
@Path("/save")
public Response save(String content) throws IOException {
Map<String, Object> result = mapper.readValue(content,
HashMap.class);
String title = (String) result.get("title");
String body = (String) result.get("content");
URL url =
this.getClass().getClassLoader().getResource("/records");
File data = null;
try {
data = new File(url.toURI());
} catch (URISyntaxException e) {
throw new RuntimeException(e);
}
ExampleWriter myWriter = new ExampleWriter();
myWriter.createFile(data, title, body);
Response myResp = Response.status(200)
.header("Access-Control-Allow-Origin",
"http://localhost:8448")
.header("Content-Type", "application/json")
.build();
return myResp;
Module 6: Network Programming; TCP, UDP, and Sockets
public class BookData {
public static void main(String[] args) throws IOException {
System.out.println("Hello world!");
String url =
"http://localhost:8080/ParsingFiles-1.0-SNAPSHOT/api/read/book";
URL netURL = new URL(url);
URLConnection conn = netURL.openConnection();
conn.setDoOutput(false);
conn.setDoInput(true);
InputStream inStream = conn.getInputStream();
BufferedReader in = new BufferedReader(new
InputStreamReader(inStream));
System.out.println(url);
StringBuffer buffer = new StringBuffer();
String line;
while ((line = in.readLine()) != null) {
buffer.append(line);
}
String jsonData = buffer.toString();
System.out.println(jsonData);
Transforming the string into objects using org.json library
JSONObject data = new JSONObject(jsonData);
Map<String, Object> mapData = data.toMap();
Set<String> keys = mapData.keySet();
Iterator<String> keyIterator = keys.iterator();
// iterating over items in the map
while(keyIterator.hasNext()){
String word = keyIterator.next();
int count = (int) mapData.get(word);
System.out.printf("Found: %s (%s)\n", word, count);
}
inStream.close();
}
}
public class BikeShare {
public static void main(String[] args) throws IOException,
ParserConfigurationException, SAXException {
// create URL
String url =
"https://api.mockaroo.com/api/e9cc2e00?count=20&key=e99c5530"; //
accessing this mock api, generates random information
URL netURL = new URL(url);
URLConnection conn = netURL.openConnection();
// we are doing a GET request
conn.setDoOutput(false);
conn.setDoInput(true);
// load the data using a URLConnection
InputStream inStream = conn.getInputStream();
// DocumentBuilder to parse the XML data
DocumentBuilderFactory dbFactory =
DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = dbFactory.newDocumentBuilder();
Document document = docBuilder.parse(inStream);
document.getDocumentElement().normalize(); // remove any extra
whitespace, and format correctly
NodeList itemNodes = document.getElementsByTagName("station");
// iterating over all the stations
for (int i = 0; i < itemNodes.getLength(); i++) {
Node itemNode = itemNodes.item(i);
// retrieve properties for each station
if (itemNode.getNodeType() == Node.ELEMENT_NODE) {
Element itemElement = (Element)itemNode;
// read each individual property
String name = getTagValue("name", itemElement);
String lat = getTagValue("lat", itemElement);
String lon = getTagValue("long", itemElement);
String num = getTagValue("nbBikes", itemElement);
String id = getTagValue("id", itemElement);
// output the formatted date into the console
System.out.printf("[%s] %s (%s, %s): %s bikes
available.\n",
id,
name,
lat,
lon,
num
);
}
}
}
private static String getTagValue(String name, Element itemElement) {
NodeList tags = itemElement.getElementsByTagName(name);
if(tags.getLength()>0) {
return tags.item(0).getTextContent(); // get the textcontent
of the first item
}
return null;
}
}
