DEV Community: Ali Zaidi

Go-ing Go-ing Gone! CRUD with Go

Ali Zaidi — Thu, 24 Feb 2022 00:09:22 +0000

Alright, let's Go. Last tortured pun, I promise.. kind of.

Although I would classify myself as a polyglot developer, the vast majority of my backend development has been in Java 8/11. After being recommended Go by several colleagues, I gave it a go (sorry) and was pleasantly surprised by the simplicity.

Coming from the land of annotations, JVMs, JDKs & CDI, it was a breath of fresh air to strip back to the basics. There's no magic in Go like there is with Java. No secret filters, no ambiguous qualifiers and no Spring minefields. Go is far more verbose and makes you jump through all the hoops. More effort typing but far less effort understanding.

Don't get me wrong, I think modern Java services are still fantastic but it's becoming increasingly difficult in an enterprise environment to utilise the newer features.

When you type in go run main.go

After dabbling in Go for a while, I decided to write a simple CRUD project and post it to Github.

https://github.com/alizaidi93/task-list-service

The main goals of the project were to demonstrate the following :

Hexagonal Architecture
Running a ReSTful web service
Utilising a global logger
Writing unit tests
Connecting into a Postgres DB running through Docker

Has anyone else learnt Go from a Java background?

Let’s touch base.. with Firebase 🔥

Ali Zaidi — Sat, 29 Aug 2020 11:18:04 +0000

To put it mildly, Firebase is a beast.

There are so many facets of Firebase which make it a dream platform for many start ups, side projects and quick hack ups. That’s not to say you can’t scale up massively with Firebase, just ask Google Play Music which has a cool 5 Billion installs.

Just to name a few features without scratching the technical depth that Firebase has to offer :

Cloud Firestore

Cloud Functions

CDN Hosting

Authentication

Firebase Cloud Messaging

The point being is that Firebase is a fantastic resource to power start your development 🚀

Too real.. or way too real

I first stumbled across Firebase when a few university friends were speaking to me about an app idea they were developing. My first question to them was, how are you going to handle the IAM? From previous experience, I know a full IAM system can be burdening to a new developing venture. In the age of sophisticated crypto attacks, salted hashes and privacy concerns cough GDPR cough - it's a headache to say the least. I googled ways in which other apps were solving this problem, especially with easy social sign-ins and Firebase Authentication was the answer.

Slightly on a tangent, this is where as Cloud technologies are becoming so powerful, it empowers developers to do what they actually enjoy doing - which is burning out code 🔥. Gone are the days where you would have to worry about maintaining a database or UNIX box with security patches, or architecting an entire development environment before you even get to experiment with different technologies.

Innovation occurs most often when those that can ask the right questions, have the best opportunity to answer.

Back to Firebase and IAM, Firebase provides a simple entry point to Authenticating users with a wide variety of options, including Facebook, Twitter, Apple etc.

A full list of Authentication providers at time of writing

So, how does it all piece together?

Firebase has a client side library which allows a user to enter their credentials, with one of the enabled providers above, and if successful, return a Firebase token. This Firebase token is a JWT. We can use this token to identify the user to calls made to the back end.

Note : Pre-requisite for using Firebase, is signing up for an account.

We now need to install the Firebase SDK in a preferred server-side language. We can choose from Node.JS, Java, Python, Go & C#. If your favourite language isn't here, you can always use the implementation described here.

In Java, initialising the application would like somewhat like this :

    /**
     * Initialises Firebase connection.
     * 
     * @throws IllegalStateException if application can't be initialised.
     */
    @PostConstruct
    public void initialiseFirebase() {
        try {
            FileInputStream serviceAccount = new FileInputStream(firebaseCredentials);
            FirebaseOptions options = new FirebaseOptions.Builder()
                    .setCredentials(GoogleCredentials.fromStream(serviceAccount))
                    .setDatabaseUrl("https://****.firebaseio.com").build();

            FirebaseApp.initializeApp(options);
        } catch (IOException e) {
            throw new IllegalStateException("Unable to initalise Firebase Application", e);
        }
    }

Maven dependency :

        <dependency>
            <groupId>com.google.firebase</groupId>
            <artifactId>firebase-admin</artifactId>
            <version>6.12.2</version>
        </dependency>

With the use of provided methods, we can pass in the token, which will then be verified of structure and expiration etc. We can decode the token, retrieve the UUID of our user and call more information if needed. For example, a user's email address as below - all of this through the SDK!

    /**
     * If the provided ID token has the correct format, is not expired, and is
     * properly signed, the method returns the decoded UUID.
     * 
     * @param idToken
     * @return {@code String} Firebase UUID
     */
    public String getFirebaseDecodedUid(String idToken) {
        try {
            FirebaseToken decodedToken = getFirebaseToken(idToken);
            return decodedToken.getUid();
        } catch (IllegalArgumentException e) {
            throw new NotAuthorizedException("Unable to read authentication client side token.", e);
        }
    }

    /**
     * Returns email of a user by their Firebase UUID.
     * 
     * @param firebaseId
     * @return {@code String}
     */
    public String getUser(String firebaseId) {
        try {
            return FirebaseAuth.getInstance().getUser(firebaseId).getEmail();
        } catch (FirebaseAuthException e) {
            throw new InternalServerErrorException("Unable to return user", e);
        }
    }

We have successfully found a way to authenticate users with little hassle, so we can focus on writing application logic.

Firebase has a whole arsenal of functionality to explore, this is a small look into what a powerful platform it can be.

The next logical phase once users are authenticated is how can you differentiate and authorise them to the right back-end calls. That's for another day and another blog post.

Log Log Log .. how to deforest with Java CDI

Ali Zaidi — Sun, 31 May 2020 12:52:26 +0000

Hello World!

..sorry had to do it. Welcome to my first dev.to post, hopefully the first of many!

I wanted to start off with a really simple utility that Java developers can easily integrate in their code and improve the codebase.

Something I see very often, usually in legacy projects, is a logger being declared for every class.

1   public class MyClass {
2 
3       private static Logger logger = LoggerFactory.getLogger(MyClass.class);
4
5   ...
6   }

Realistically this won't be very resource intensive but we can definitely make improvements to simplify.

You don't know what it is, but it's there, like a splinter in your mind, driving you mad

Introducing.. logging with CDI!

With CDI, we can inject a SL4J (or your favourite implementation) logger.

First thing we need to do is implement a logging producer using the Injection Point API.

1   @ApplicationScoped
2   public class LoggerProducer {
3
4      @Produces
5      public Logger getLogger(final InjectionPoint ip) {
6          return LoggerFactory.getLogger(ip.getMember().getDeclaringClass());
6      }
7   }

We specify the scope of the class as @ApplicationScoped. The injection point API allows us to know the declaring class of the injected logger.

Imports :

import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Produces;
import javax.enterprise.inject.spi.InjectionPoint;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

Note : Ensure that the correct @Produces annotation is imported, not the JAX-RS producer

Next step is to simply @Inject our logger into our class and begin to log.

1   @ApplicationScoped
2   public class MyClass {
3 
4       @Inject
5       private Logger logger;
6       
7       public void myMethod(){
8          logger.info("My log!");
9       }
10   }

There we have it, an easy CDI logger.

There are other implementations such as a Lombok logger. However, there are some steps to make Lombok compatible with your IDE and I believe a CDI logger is easier to integrate with an existing codebase.