Short Link Service

For years, I have taken advantage of an unofficial URL shortening service provided by Google. I had been using it for so long that I had completely taken it for granted. Then, one day, * poof * it was gone. To be fair, I'm pretty sure that Google gave us notice that it was going to be taken down, but there are some emails that just slip through the cracks, this was probably one of those. This became a real issue for me in one particular location: my patents' memoirs. As a bound publication, we didn't want the readers to have to type out the almost 80 hyperlinks that were included in the endnotes, and how to avoid the dreaded 404 error if a linked-to page gets taken down in the future. To solve these issues, each hyperlink was shortened using Google's service and tied to the family domain. Now the challenge arose: How to get those same shortened URLs to point to the same long URLs. I looked at several free options out there, but there were issues with them all. Either I couldn't reuse the domain name, or the shortened code was too short, etc. So, after testing my father's patience, I decided to create my own Short Link Service.

Features:

• Runs through my Spring Cloud Gateway, so I can control which domain names can be used;
• If the shortened code is not provided, a new random alphanumeric code is generated that excludes ambiguous characters for ease of re-typing;
• The shortened links can be given an expiry date; and
• The shortened links are tied to the user who created them.

In order to address the last feature, the service is only available to registered users.

This Short Link Service can be purchased if you would like to host it locally. Otherwise, we can work out a hosting plan for you.

Implementation:

In designing the service, I implemented a sophisticated algorithm to generate unique short codes for URLs. I needed to be able to ensure that multiple users across multiple domains (for now) would not accidentally create the same short link. I also wanted to ensure that enough effort was made to come up with a short random code before moving on to the next length of code. Here's a detailed description of its execution flow:

1. Initial Call:
   • The parameterless generateShortCode() method is called, which in turn calls generateShortCode(0). The zero represents the number of characters to add to the BASE_CODE_LENGTH. Since we are using recursion to gradually lengthen the short code as needed, this begins at zero.
2. Short Code Generation:
   • A StringBuilder is initialized to create the short code.
   • It loops BASE_CODE_LENGTH + extraLen times (initially just BASE_CODE_LENGTH as extraLen is 0).
   • In each iteration, it appends a random character from the CHARACTERS string. (This is a string that is made up of numbers and letters that are not easily confused.)
3. First Retry Loop:
   • The method enters a loop that runs up to MAX_RETRIES times.
   • It checks if the generated short code already exists in the repository.
   • If it exists, it recursively calls generateShortCode() to generate a new code.
   • If it doesn't exist, it returns the unique short code.
4. Length Increase Loop:
   • If the first retry loop doesn't find a unique code, it enters another loop.
   • This loop incrementally increases the length of the short code up to MAX_CODE_LENGTH.
   • For each length, it calls generateShortCode(n) where n is the extra length.
   • If a unique code is found, it's returned immediately.
5. Error Handling:
   • If no unique code is found even after increasing the length to MAX_CODE_LENGTH, it throws a custom Exception.

Key Elements of the Algorithm:

• The method uses recursion to generate new codes when collisions occur.
• It first tries to find a unique code of the base length through multiple attempts.
• If unsuccessful, it gradually increases the code length.
• This approach balances between keeping codes short and ensuring uniqueness.

The method is designed to handle high load and potential collisions efficiently, making it suitable for a robust URL shortening service.