Forem: Ashish Agre

Multi-module Multi-feature gradle project

Ashish Agre — Sun, 07 Jun 2020 06:56:55 +0000

Introduction

So you are starting new backend work and have planned to use spring boot because of existing java development skills in the team.
For me when i'll be in this situation i'll be like

Why would I choose spring boot?

A LOT of boilerplate code is removed
Have strong Spring framework support
Good Support of DB layer more here(https://thorben-janssen.com/what-is-spring-data-jpa-and-why-should-you-use-it/)
Handy and configurable Spring security
Easier management of profiles
Ready to use starter-packs
And not to forget spring integration
And many more plug and play components

If you have ever developed a servlet/jsp based application then you will find there is no web.xml in SpringBoot application.

While starting a new project it is very easy to jump start coding. As a normal spring boot application it is easy to get up and running from https://start.spring.io/ project and evolves as we develop further.

Controllers
Services
Repositories

Until the features goes on increasing and the basic root package becomes collection of many sub packages and then you need drill down or search for matching file of a feature.

in.silentsudo
    configs
        mysql
        kafka
    controllers
        validators
            annotations
                [@interface]
        dto
            [*.java]
        [either-feature-wise packaging or individuals]
    services
        [either-feature-wise packaging or individuals]
    reposotories
        domain
            [*.java]
        dto
            [*.java]
        [either-feature-wise packaging or individuals]

Spring project by default is shipped with either maven or gradle build tool. We use this to further structure our code properly.
Instead of getting right into developing a feature we can spend some time deciding meta info about the feature.
Consider a simple use case of file uploading feature. If we are ok to share our credentials to the public client then the burden on this feature reduces. But since this is our sample usecase we are not sharing any credentials to the public client to have write access to our storage system and it is through the api server itself a user can upload a file. 😡

Let's try to define our interface before we start anything else.
Simple File Upload feature-

Get a file
store in one of the provider we are supporting[disk, aws or azure storage]

Implementation

Definition is as below:

Create the following project structure:

PROJECT_ROOT
    build.gradle
    settings.gradle

This becomes the root of the project.
All child project mentioned below reside under PROJECT_ROOT.

Spring boot web application
storageservice(base interface for storing files)
awsstoreservice(concrete implementation of storageservice to fulfill storing file on aws)
azurestoreservice(concrete implementation of storageservice to fulfill storing file on aws)
diskstorageservuce(concrete implementation of storageservice to fulfill storing file on local or attached disk)

Create a base interface definition project module inside PROJECT_ROOT.

This is how it should look.

PROJECT_ROOT
    build.gradle
    settings.gradle
    storageservice
        build
        src
        build.gradle

The only code in this module is this

package in.silentsudo.storageservice;

import java.io.File;

public interface FileStorageService {
    String store(File file);
}

Similarly lets create different implementers for this

PROJECT_ROOT
    build.gradle
    settings.gradle
    storageservice
        build
        src
        build.gradle
    diskstorageservice
        build
        src
        build.gradle
    awsstorageservice
        build
        src
        build.gradle
    azurestorageservice
        build
        src
        build.gradle

One of the sample implementer like this

For example, if AwsStore is implemented as below:

@Service
@Qualifier("awsstore")
public class AwsStore implements FileStorageService {
    // Define bunch of constant or a connection/reference to aws store to put file
    @Override
    public String store(File file) {
        // awsSdk.store(file) similar call
        return "Storing File in AWS Storage";
    }
}

Finally create application module which uses these services

PROJECT_ROOT
    build.gradle
    settings.gradle
    storageservice
        build
        src
        build.gradle
    diskstorageservice
        build
        src
        build.gradle
    awsstorageservice
        build
        src
        build.gradle
    azurestorageservice
        build
        src
        build.gradle                       
    application
        build
        src
        build.gradle

At this moment we have not configured any of the dependencies for any module.

As shown in above diagram diskstorageservice, awsstorageservice, azurestorageservice are concrete implementer of storageservice which just defines the contract to store. Here implementers by their name indicates where they are storing those files.

Directory structure for this.

dependencies of application module is as follow:

implementation project(':storageservice')
implementation project(':diskstorageservice')
implementation project(':awsstore')

Usage

Let us see how we can use this different implementation of storage service

@SpringBootApplication(scanBasePackages = "in.silentsudo")
@RestController
public class MainApplication {

    private final MyService myService;
    private final FileStorageService fileStorageService;
    private final FileStorageService awsStore;

    @Autowired
    public MainApplication(MyService myService,
                           @Qualifier("diskstorage") FileStorageService diskStorageService,
                           @Qualifier("awsstore") FileStorageService awsStore) {
        this.myService = myService;
        this.fileStorageService = diskStorageService;
        this.awsStore = awsStore;
    }

    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }

    // This is post request all the time, get is for demo purpose
    @GetMapping("/store")
    public String store() {
        // You would get file from request this is for test purpose
        return fileStorageService.store(new File("/home/ashish/remove_outliers"));
    }

    // This is post request all the time, get is for demo purpose
    @GetMapping("/awsstore")
    public String awsStore() {
        // You would get file from request this is for test purpose
        return awsStore.store(new File("/home/ashish/remove_outliers"));
    }
}

Note @Qualifier annotation is used to locate bean with name specified because in our use case if you can see

 @Autowired
    public MainApplication(MyService myService,
                           @Qualifier("diskstorage") FileStorageService diskStorageService,
                           @Qualifier("awsstore") FileStorageService awsStore) {
        this.myService = myService;
        this.fileStorageService = diskStorageService;
        this.awsStore = awsStore;
    }

We are trying to wire aws/azure/disk store for reference to FileStorageService. It is as good as asking

Give me concrete implementer of `FileStorageService` named `awsstore`

Of Course no one uses different storage mechanism but this same principle can be used for example when implementing
mongodb and mysql in the same project for different use cases.
This implementation gives feature separation in large projects where dependencies are not cluttered in 1 build.gradle file instead they are in their own modules. Modules are not limited to spring-boot modules only but can be any library module.
If It is modular to write, it should be modular enough to separate it in a module.

Play Video Using video.js and videojs-hls-quality-selector

Ashish Agre — Sun, 24 May 2020 04:16:12 +0000

Introduction

How to play hls video in Angular using video.js and show quality-selectors

Create simple angular App and use following commands to install video js components

npm install --save video.js
npm install --save videojs-hls-quality-selector
npm install --save videojs-contrib-quality-levels

video-player.component.html

<video
id="my-video"
class="video-js vjs-default-button vjs-big-play-centered"
  controls
  playsinline
  preload="auto"
  width="640"
  height="480"
  data-setup="{}"
>
  <source src="{{this.url}}" type="application/x-mpegURL"/>
  <p class="vjs-no-js">
    To view this video please enable JavaScript, and consider upgrading to a
    web browser that
    <a href="https://videojs.com/html5-video-support/" target="_blank"
    >supports HTML5 video</a
    >
  </p>
</video>

video-player.component.ts

import {AfterViewInit, Component, ElementRef, OnDestroy, OnInit, ViewChild} from '@angular/core';
import videojs from 'video.js';

declare var require: any;
require('videojs-contrib-quality-levels');
require('videojs-hls-quality-selector');

@Component({
  selector: 'app-video-player',
  templateUrl: './video-player.component.html',
  styleUrls: ['./video-player.component.css']
})

export class VideoPlayerComponent implements OnInit, AfterViewInit, OnDestroy {

  public player: videojs.Player;



  url = 'https://bitdash-a.akamaihd.net/content/MI201109210084_1/m3u8s/f08e80da-bf1d-4e3d-8899-f0f6155f6efa.m3u8';

  constructor() {
  }

  ngOnInit(): void {
  }

  ngAfterViewInit() {
    const options = {
      'sources': [{
        'src': this.url,
        'type': 'application/x-mpegURL'
      }
      ],
      // 'poster' : this.urlPoster
    };
    this.player = videojs('my-video', options, function onPlayerReady() {
      console.log('Player ready');
      var myPlayer = this, id = myPlayer.id();
      myPlayer.hlsQualitySelector();
    });

  }

  ngOnDestroy(): void {
    if (this.player != null) {
      this.player.dispose();
    }
  }

}

package.json

{
  "name": "videojs-player",
  "version": "0.0.0",
  "scripts": {
    "ng": "ng",
    "start": "ng serve",
    "build": "ng build",
    "test": "ng test",
    "lint": "ng lint",
    "e2e": "ng e2e"
  },
  "private": true,
  "dependencies": {
    ...    
    "video.js": "^7.7.5",  
    "videojs-contrib-quality-levels": "^2.0.9",
    "videojs-hls-quality-selector": "^1.1.1",
    ...  
  }
}

Source
https://silentsudo.gitlab.io/post/angular/2020-05-04-videojs-quality-selector-hls-streaming/

Angular App and Spring Boot Api for Country, State and City

Ashish Agre — Tue, 19 May 2020 13:13:47 +0000

Introduction

Address WebApi and test example to display
Country, State and City

Prerequisite

Java SDK
node.js

Building Backend

https://gitlab.com/address-api/api-server.git

Create Database in mysql create database address_api_db;

Export Env variable

MYSQL_HOST=localhost
MYSQL_PORT=3306
MYSQL_SECRET=my_super_secret_password

Execute maven command to run project

./mvnw spring-boot:run

API Details

Name	Path
All Countries	http://localhost:8080/country/all
State By Country	http://localhost:8080/state/all?countryId={countryId}
City By State	http://localhost:8080/city/all?stateId={stateId}

Building Frontend

https://gitlab.com/address-api/frontend.git

Build

ng build

Run

ng serve

Navigate to http://localhost:4200

Demo

Ref:

Thanks to https://github.com/hiiamrohit/Countries-States-Cities-database 🙇

Source
https://silentsudo.gitlab.io/post/angular/2020-05-19-api-country-state-city/

Famous CSS Colors for my T-Shirt

Ashish Agre — Sat, 28 Dec 2019 12:52:08 +0000

Hi Everyone, I need a little help with my geek T-Shirt.

Old one's colors are fading away and I need to get it printed again.
Unfortunately, this time I have only 1 white color options for a t-shirt hence I need to find 3 most famous css color which I can choose.

In Stone age, when I last worked with html/css Cyan was the color I loved the most <3.

Please let me know if there are any other cool colors which I can select.

Only 3 Colors. Below is the current one.

Thank you! Have fun!

Create light weight api server using Spark Java [3]

Ashish Agre — Sat, 09 Sep 2017 11:20:58 +0000

Hi everyone,

Continuing from previous section https://dev.to/silentsudo/create-light-weight-api-server-using-spark-java-2

We are done setting up our urls, now lets create our routers using Spark Java, we will join router-service-db in following sequence

Database
Service
Router

Lets see database:
As discussed we will create light weight in-memory database using collections framework.
There will a database class and respective table, we can call them datastores of specific type like User, Tweet, Like.

Below is our database and datastores classes.
AppDatabase.java

package in.silentsudo.blabber.database;

public final class AppDatabase {
    private static AppDatabase ourInstance = new AppDatabase();

    public static AppDatabase getInstance() {
        return ourInstance;
    }

    private UsersStore usersStore;
    private TweetsStore tweetsStore;
    private LikesStore likesStore;

    private AppDatabase() {
        usersStore = new UsersStore();
        tweetsStore = new TweetsStore();
        likesStore = new LikesStore();
    }

    public UsersStore getUsersStore() {
        return usersStore;
    }

    public TweetsStore getTweetsStore() {
        return tweetsStore;
    }

    public LikesStore getLikesStore() {
        return likesStore;
    }
}

Datastores classes below:

UsersStore.java

package in.silentsudo.blabber.database;

import in.silentsudo.blabber.models.User;

import java.util.LinkedList;
import java.util.List;

public final class UsersStore {

    private List<User> users = new LinkedList<>();

    UsersStore() {
        //Alert, always use some encryption while storing ans distributing password
        //This is dummy data
        users.add(new User("ashish@ashish.com", "qwerty"));
    }

    public User findUser(final User user) {
        return this.users.stream()
                .filter(u ->
                        u.getEmail().equalsIgnoreCase(user.getEmail()) &&
                                u.getPassword().equalsIgnoreCase(user.getPassword())
                )
                .findFirst()
                .orElse(null);
    }
}

TweetsStore

package in.silentsudo.blabber.database;

import in.silentsudo.blabber.models.Tweet;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public final class TweetsStore {

    private List<Tweet> tweets = new LinkedList<>();

    TweetsStore() {
    }


    public void addTweet(Tweet tweet) {
        tweets.add(tweet);
    }

    public List<Tweet> getAllTweets() {
        return Collections.unmodifiableList(this.tweets);
    }

    public void deleteTweet(Tweet tweet) {
        if (this.tweets.contains(tweet)) {
            this.tweets.remove(tweet);
        }
    }
}

and finally LikesStore

package in.silentsudo.blabber.database;

import in.silentsudo.blabber.models.Like;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;

public final class LikesStore {
    private static final Logger logger = Logger.getLogger(LikesStore.class.getSimpleName());
    private List<Like> likes = new LinkedList<>();

    LikesStore() {
        logger.setLevel(Level.ALL);
    }

    public void addLike(Like like) {
        if (like.getTweetId() == null || like.getUserId() == null) {
            logger.warning("Invalid like details");
            return;
        }
        likes.add(like);
    }

    public void delete(Like like) {
        if (likes.contains(like)) {
            likes.remove(like);
        }
    }

    public List<Like> getAll(Long tweetId) {

        return Collections.unmodifiableList(
                this.likes.stream()
                        .filter(like -> like.getTweetId().equals(tweetId))
                        .collect(Collectors.toList())
        );
    }
}

Core functionality of UsersStores is find user if exists and then return result to service classes which then inreturn result to router and finally to client.

Next we will see how service are calling this db and operating on them:
I will give example of only TweetsService as of now(entire projects source code can be found on this link)

There are certain db operation which we are going to do on Tweet and Like data and they seems common, so we will separate out this contract in an interface and for better redability let service classes implement them and operate.

Here is AbstractService.java

package in.silentsudo.blabber.services;

import java.util.List;

public interface AbstractService<E> {
    Object add(E e);

    void delete(E e);

    List<E> getAll();

    List<E> getAll(Long id);

}

And TweetsService.java is the implementor of this interface and provide its own implementation.

package in.silentsudo.blabber.services;

import in.silentsudo.blabber.database.TweetsStore;
import in.silentsudo.blabber.models.Tweet;

import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public final class TweetsService implements AbstractService<Tweet> {
    private static final Logger logger = Logger.getLogger(TweetsService.class.getSimpleName());

    private final TweetsStore tweetsStore;

    public TweetsService(TweetsStore tweetsStore) {
        this.tweetsStore = tweetsStore;
        logger.setLevel(Level.ALL);
    }

    @Override
    public Object add(Tweet tweet) {
        if (tweet != null && tweet.getId() != null &&
                tweet.getUserId() != null && tweet.getContent() != null) {
            tweetsStore.addTweet(tweet);
            logger.info("added");
            return new Object();
        } else {
            logger.info("Few values are null");
            return null;
        }
    }

    @Override
    public void delete(Tweet tweet) {
        tweetsStore.deleteTweet(tweet);
    }

    @Override
    public List<Tweet> getAll() {
        return tweetsStore.getAllTweets();
    }

    @Override
    public List<Tweet> getAll(Long id) {
        return tweetsStore.getAllTweets();
    }
}

Our services and database are ready to use with router, in the next section we will see how to connect all these pieces together and produce api response.

Thank you for reading!

Create light weight api server using Spark Java [2]

Ashish Agre — Thu, 07 Sep 2017 07:18:04 +0000

Hi everyone,

Continuing from previous section https://dev.to/silentsudo/create-light-weight-api-server-using-spark-java

Now that we have our hello world server ready, lets remove hello world and make it a proper api-server.

We will arrange our codebase in following structure:

package
--config (any configuration on server)
--models (usually POJO classess)
--routes (controller for api to manage requests)
--services (business logic to deal with data coming from routes)
--database (for time being we will create in-memory db with java's collection framework)

First we will do some server configuration:
By default Spark server boots on 4567 port, lets change that, using
Spark.port(HTTP_PORT);

we have configuration package now we will use this.
Here is how configuration class looks like:

import spark.Spark;

import java.net.Inet4Address;
import java.net.UnknownHostException;

public final class Config {

    private  final int HTTP_PORT= 9090;

    public Config() {
        Spark.port(HTTP_PORT);
    }

    public int getPort() {
        return this.HTTP_PORT;
    }

    public String getHost() {
        try {
            return Inet4Address.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            return "http://localhost";
        }
    }

}

and below is our main class

import in.silentsudo.blabber.config.Config;
import spark.Spark;


/**
 * Greeting world!
 */
public class Main {
    public static void main(String[] args) {
        System.out.println("Starting server...");
        Config config = new Config();


        Spark.get("/sayhello", (request, response) -> {
            return "Hello buddy!!!";
        });

        System.out.println("Open : " + config.getHost() + ":" + config.getPort());
        System.out.println("Server started successfully.");
    }
}

You should get something like this in console and your server is up and running with these details:

Starting server...
Open : 172.16.1.211:9090
Server started successfully.

We haven't done anything convinsing yet,
Now we create our in-memory database using collection framework.

Designing Backend entities:

Light-weight Entities in our app will be:

User(app user with their information)
Tweet(created by user having 140 chars may or may not have likes)
Like(belongs to only 1 tweet and 1 user, if any such information is absent that like is useless, imagine a like where we dont know who was the person and which was the tweet)
Logger(small class to keep track of what all things happening on server)

Designing URL structures and methods:

There are lots of wonderfull rest-api design documents available:

I took specific part from here: https://www.redhat.com/archives/rest-practices/2011-August/pdfa1nfEjPMmT.pdf

API Methods:

Method	Scope	Semantics
GET	Collection	Retrieve all resources in a collection
GET	resource	Retrieve a single resource
HEAD	Collection	Return all resources in a collection (header only)
POST	Collection	Create a new resource in a collection
PUT	resource	Update a resource
DELETE	resource	Delete a resource

URL Structure:

URL structure also play very crucial role in designing api. We store data that is relevant for our purpose and ignore other irrelevant information, thereafter if multiple clients(mobile, other webserver, html pages using js) wants to access this data we expose them using rest interface, so the way we expose such data should also follow some standard pattern.

We will define url structure in following way:

ip/pathtoresource/
ip/pathtoresource/if-subresource
ip/pathtoresource/if-subresource/if-sub-sub-resource

Considering above pattern lets see how our apis urls should looks like:

ip/users/ (all users, usually this is blocked who wants to tell the world i have so many people)
ip/users/:id (specific user, mostly used when we want to get our own information, call to user data other than current user should be restricted)
ip/users/:id/tweets (get all tweets for specific user)
ip/tweets/ (all public tweets)
ip/tweets/:id (specific tweet with id)
ip/likes/:id (Specific like)
ip/users/:id/likes (get all likes from this user)

I will revisit this if something smells fishy with our URLs...

In next article we will see how to write urls using Spark-Java and associate specific resource with it.

Thank you for reading!

Create light weight api server using Spark Java

Ashish Agre — Tue, 05 Sep 2017 13:48:59 +0000

Hi everyone,

As a mobile developer, one problem i faced a lot is server not ready.
Alternates are available to build api-server, our goal is create light weight api-server, our main purpose is to create minimal usable server which we are not going to deploy anywhere.
So we will focus on Spark Java(http://sparkjava.com).

We will try to create a small twitter like api-server using spark java.

Lets get started:

We will use Intellij IDE for creating our api-server application(i still like full application instead calling it as app ❤️ )

File->New Project->Maven
Create from archtype->maven-archtype-quickstart
Fill in group-id and artifacts details then proceed
Let other defaults be as it is
Name project

After all these you will be presented with ready to use maven project,
add a run configuration using App class having main method and press play button app should print Hello World! thats our maven project created.

Add some server code to it.

To use spark java we first need to add spark-java dependency to maven(pom.xml) file.

Lets move ahead to http://sparkjava.com/documentation
copy maven dependency and paste it inside dependencies tag in pom.xml

here is how it looks as of writing this article:

<dependency>
    <groupId>com.sparkjava</groupId>
    <artifactId>spark-core</artifactId>
    <version>2.6.0</version><!-- check for the updated version from documentation -->
</dependency>

spark.Spark class has all the necessary stuffs to get started with HelloWorld api.

add these lines to main method:

Spark.get("/sayhello", (request, response) -> {
            return "Hello buddy!!!";
});

Save and run the application then launch http://localhost:4567/sayhello on your browser, it should respond Hello buddy!!!

Congrats you just created a very tiny server-application.

Thats it for now, in the next section we will configure our application to behave more like an api-server intead of hello world.

Thank you for reading.

Forem: Ashish Agre

Multi-module Multi-feature gradle project

Introduction

Implementation

Usage

Source Code

Reference

Article source

Play Video Using video.js and videojs-hls-quality-selector

Introduction

Create simple angular App and use following commands to install video js components

Angular App and Spring Boot Api for Country, State and City

Introduction

Prerequisite

Building Backend

Building Frontend

Demo

Ref:

Famous CSS Colors for my T-Shirt

Create light weight api server using Spark Java [3]

Create light weight api server using Spark Java [2]

Create light weight api server using Spark Java