DEV Community: Rose

What Are The Characteristics of Quality Code?

Rose — Thu, 17 Sep 2020 11:03:03 +0000

Nowadays, we heavily rely on software running all sorts of applications, from banking solutions to browsing through our social media. And, let's be honest, that last one is the most important of all these days. Because we are so dependent on software, companies have to make sure that the code runs smoothly at all times. For that, we need quality code. But what are the characteristics of quality code?

Cover Photo by Chris Ried on Unsplash

I have been reading the book series "Write Great Code" by Randall Hyde. The very first book of the series, Understanding the Machine, starts with defining what great code actually is. Of course, Hyde's opinion strongly influences the definition of great code in this book. However, it has prompted me to take a deeper dive in the subject and see what other opinions are out there.

System Quality Attributes

When googling with search terms like "code quality" and "characteristics of quality code" the result vary a lot. The primary reason: each piece of software has different requirements. The definition of quality code depends on the requirements for the software. Say, you have an application that has to be super quick, then high speed is the characteristic of quality code. In that case, it might not be an issue that the portability of the software is practically non-existent.

There is no clear set of characteristic for quality code in place. However, you'll see that there is a set that many people in the software engineering industry agree upon.

These are just some of the common software quality attributes that students get taught during many software engineering courses. However, in the end, it all boils down to what the application requires. Since there are so many different quality attributes, you can always pick the ones that apply most for you. This Wikipedia page offers a list of system quality attributes that you can choose from for your next project.

In Short

Great code is software written using a consistent and prioritised set of good software characteristics. In particular, great code follows a set of rules that guide the decision a programmer makes when implementing an algorithm as source code.

Randall Hyde; Understanding the Machine

Hyde gives this quote in his first book, in the very first chapter. This quote perfectly summarises what quality code should be. So, what are the characteristics of quality code? That depends on your requirements and what you want out of your system.

What is your experience as/with software tester(s)?

Rose — Wed, 09 Sep 2020 10:49:29 +0000

Software testers are often stereotyped by developers and vice versa. I'm curious to see what the community here thinks of software testers.

So, the question for the devs: what's your experience with software testers? Do you work with the stereotypical software tester that wants to break your application at all cost, or do they have a different mindset?

For the testers in our community, what's your experience being a software tester? Do you feel like you're getting stereotyped by the devs around you? Or do you stereotype the devs? ;)

What characterises quality code?

Rose — Tue, 01 Sep 2020 05:47:54 +0000

We all want to write quality code for our projects, but what defines quality code to begin with?

The Road to My Ultimate Training System

Rose — Fri, 28 Aug 2020 11:25:07 +0000

If you've seen me around, you might have noticed that there is one massive project I want to accomplish: building an operating system from scratch. However, my college got in the way many times as it always does, keeping me from putting serious effort into the project. So, with my degree in the bag, it is finally time to walk the road to My Ultimate Training System.

Cover Photo by Hayden Walker on Unsplash

The Humble Beginnings

So, how did I even decide to undertake this journey? Let me take you back to two years ago. I had just started my internship at the company where I'm still working. My task was to convert some internal tooling, consisting of multiple script files, into a whole application with front- and backend. At the start, I was researching software architectures which made me fall in love with the subject. Especially the microkernel architecture took my breath away.

One day, when I was travelling back home by train, I was messaging with my best friend, Valentin. We were talking about this microkernel architecture I had just discovered that week. The following conversation ensued:

Valentin: "So, this microkernel architecture, du you know any examples of software that use it?"
Me: "Hmm, I cannot give you any examples from the top of my head, but I'm quite sure there are plenty. I mean, the main feature is having a core system handling the communications and plugins having the business logic."
Valentin: "Interesting..."
Me: "There is still a lot I have to learn about this architecture, but damn, it's interesting!"
Valentin: "That for sure it is!"
A small moment of silence creeps in, the train passing by field after field.
Me: "You know what.. I'm going to build my own operating system! From scratch!"
Valentin: "Are you insane?! Do you know how long that'll take?!"
Me: "Hahaha, yeah, it'll most likely be a 10-year project or so, but hell, why not!"

And so, the idea of building my operating system was born.

Road to My Ultimate Training System

It's been two years since I've decided to walk the path of the operating system. But, as I said, college managed to get in the way of my plans. However, now that I finally have my degree, some free time has opened up. Still, diving in a project of this magnitude like a headless chicken isn't the way to go.

Recently, I read a post on Dev.to on things to do when starting a side project. The first step stood out to me most: Announce Your Idea. Now, I have thrown my idea around here and there in some comments and on my blog, but I have never really sat down to think and plan what I want to do.

Get These In Place Before Starting Your Next Side Project 👀

Niharika Singh ⛓ ・ Aug 25 ・ 2 min read

#beginners #javascript #productivity #career

That was until a late evening. I was feeling pooped as hell and not motivated to do anything. I told my partner: "Bleeeehhh, I'm pooped; I cannot focus; I cannot do anything tonight; tonight SUCKS!". He looked at me and almost literally picked me up from the bed. Before I knew, he'd put me on a chair in the living room with a book and notebook. Next, he squashed a pair of headphones on my head and set a vinyl in the player with some Bob Marley (don't ask me why, I don't know it either). Without realising, my brain was swinging along with Marley 10 minutes later and producing all sorts of strange creative stuff.

The Path to My Operating System

You don't "just" build an operating system. You need knowledge for that, and lots of it too. So, before I even dare start writing a single line of code for my operating system, I need to work on that brain! I managed to create a high level overview of what I think I need to learn to get started and in which order.

Learning about Computer Architecture and Organisation;
Learning C Programming;
Learning Assembly Language;
Learning about Operating System Structure;
Building MUTS!!

Gaining this knowledge won't fall out of the sky magically in my brain, unfortunately. Boy, would it be interesting for that to happen! But no, I need books for this, and I have started with the first one this week! I have got a big list of all the books that I could find that would be interesting for this project. However, reading them all would take me... an eternity. So, I've tried to keep the list short, for now.

Write Great Code - Understand the Machine by Randall Hyde
Write Great Code - Thinking Low-Level Writing High-Level by Randall Hyde
C Programming - A Modern Approach by K.N. King
The Art of Assembly by Randall Hyde
Modern Operating Systems by Andrew Tanenbaum
Operating Systems from 0 to 1

Show The World

Still inspired, I'm now trying to announce my idea to you all! I hope this gives you a bit of background for my motives even to dare touch this project. Believe me, I'm scared to bits and almost shitting my pants. Still, I also feel exhilarated and motivated to work on this fantastic project. Even if it fails miserably, I'm confident that I will learn so much along the way that it won't be a waste of time.

But more importantly, I want to share my strides and struggles with you all. The first idea I have is to keep writing articles and posting them on my blog. Furthermore, I want to cross-post my articles to Dev.to, and maybe to Medium and other dev communities. I'm not too sure about the last two, but if you have any ideas on that, please do let me know!

I also do have one other idea, but I'd like your opinion on that too. Would it be interesting if I stream my C and Assembly programming on Twitch, sowing my learning process and progress on the languages? Afterwards, I can upload the stream to my YouTube channel, so you can watch it later.

Finally, I would like to ask you: Do you have any ideas on how you'd like to keep updated on projects like this? Things that I can do to expose it more, so I can hold myself accountable to stay motivated even during the tougher learning times. I'm curious to see what you think!

Some Last Thoughts

The road to My Ultimate Training System will be a long one, that is a given. Projects like these will have their ups and downs, but I'm hoping that I can stick to my plan. The learning possibilities are endless, which is what motivates me the most. Naturally, the development of my operating system will be open source. There is one question that always lingers in the back of my brain: Will I, or anyone, ever use my OS seriously? That, I won't know until I've "finished" it. However, I'd like to think that one day I'll run my OS on a device and use it for simple tasks. That is the end goal for now.

Let's Get Started with Understanding the Machine

Rose — Wed, 26 Aug 2020 12:17:10 +0000

Last week, it finally came in the mail! The 2nd edition of Randall Hyde's book Write Great Code - Understand the Machine. I am excited to study this book and gain more in-depth knowledge of computer organisation. So, let's get started with understanding the machine!

Cover Photo by Umberto on Unsplash

Write Great Code

Writing great code is not as easy as it may sound. There are a lot of aspects to take into account. One of the important elements is understanding how a computer works. If you can utilise the computer's strengths and avoid its weaknesses, I'm confident that your applications will improve.

In order to write great code, you need to know how to write efficient code, and to write efficient code, you must understand how computer systems execute programs and how abstractions in programming languages map to low-level hardware capabilities of the machine. - Randall Hyde

This quote summarises Hyde's view on what it takes to write code. In the past, well over 20 years ago, there was only one way to learn the absolute best of coding techniques: learning the Assembly languages. The reason behind that is not because of the language itself. Instead, it is because you'll learn a ton about machine organisation.

Machine organisation is a subset of computer architecture. It covers topics such as:

Low-level data types;
Internal CPU organisations;
Memory organisation;
Peripherals;
Computer communication.

Write Great Code - Understand the Machine covers machine organisation quite in detail, which is essential information for me to gain. Not only because it would allow me to write better code, but also because I need this knowledge to write my operating system. Everything I'll learn from this book, I'll share with you.

Get Started with Understanding the Machine

So, what topics does Hyde cover in this book? It is quite a list, and they can all be related to the subjects of machine organisation. This list gives an outline of what the book covers. That is what I will write about in the many articles to come.

Basic Computer Data Representation
- What do integers, characters, character sets and many more primal data types look like in a computer?
Basic Arithmetic & Bit Operations
- How does the computer perform calculations and operations with bits only?
Memory (RAM)
- How does a computer access memory, and what are the characteristics of memory performance?
Complex Computer Data Representation
- What do composite data types and memory objects (e.g. pointers and arrays) look like in a computer?
Boolean Logic & Digital Design
- How can I optimise the boolean expressions in if and while loops?
CPU Architecture
- How can I write code in a "CPU friendly" manner?
CPU Instruction Set Architecture
- Why do some statements take longer to execute than others?
Computer Communication to the Outside World
- How does the computer communicate with peripherals (e.g. hard drive and sound card)?

When I see this list of things I need to learn, it terrifies me. However, it also excites me. There is still so much out there that I'm eager to learn, but I need to go one step at the time. If you want to follow my journey, keep an eye out for more posts to come! In the meantime, I'll get started with understanding the machine.

How to Throw Custom Exceptions with Spring Boot

Rose — Thu, 20 Aug 2020 19:14:38 +0000

In the process of building my blog, I want to be able to let the user know if something went wrong. It can vary from the standard error 404, a custom message, to my own custom exceptions. I'll show you how to throw custom exceptions with Spring Boot, so you can do it yourself next time!

Handling Exceptions

First, I want to define what my exception response towards the client would look like. I'm doing this with a simple class called ExceptionResponse and some properties.

public class ExceptionResponse {
    private Date timestamp;
    private String message;
    private String details;

    public ExceptionResponse(Date timestamp, String message, String details) {
        this.timestamp = timestamp;
        this.message = message;
        this.details = details;
    }
}

All the properties also have get methods, but I've left that out of the code snippet. Since I don't expect to be changing the property values, I haven't implemented any set methods.

ExceptionResponseHandler

With the class for ExceptionResponse done, I can now start with handling the thrown exceptions. For this, I've created the ExceptionResponseHandler that inherits the ResponseEntityExceptionHandler class. It is also annotated with @ControllerAdvice. This annotation allows me to create one class that handles all exceptions for every controller in my application. So, I can add all the exceptions to be handled in this class keeping it in one spot for maintainability.

So, first things first, I want to have one generic method for handling any exception that is thrown by my application. Whatever happens, I still want to notify the user.

@ControllerAdvice
@RestController
public class ExceptionResponseHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(Exception.class)
    public final ResponseEntity<ExceptionResponse> handleAllExceptions(Exception ex, WebRequest req) {
        ExceptionResponse exceptionResponse = new ExceptionResponse(
            new Date(),
            ex.getMessage(),
            req.Description(false)
        );
        return new ResponseEntity<>(exceptionResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

Now, the ExceptionResponseHandler handles any exception that the application throws. It returns the timestamp when the error occurred, the message from the exception, and the request they used. That should provide the client-side application enough information to handle the rest towards the user, without giving away too much details of the backend.

Custom Exceptions in Spring Boot

With the general setup done, it is finally time to get to the custom exceptions in Spring Boot. For that, I need to create an exception class to begin with. In my case, I want to notify that the blog post being posted already exists. However, I am fairly certain that the duplication of items won't apply to just blog posts. Therefore, I made it a little more generic: ResourceAlreadyExistsException.

The ResourceAlreadyExistsException class is a relatively simple one. It extends the RuntimeException class, and you can add as many parameters to it as you like. I've kept it concise like this.

public class ResourceAlreadyExistsException extends RuntimeException {

    public ResourceAlreadyExistsException(String property, String value) {
        super(String.format(
            "Resource with property %s and value %s already exists." +
            "Make sure to insert a unique value for %s",
            property, value, property));
    }
}

Whenever I need to check for a unique resource, I can tell the user which specific property has what value that causes the error. Furthermore, I notify the user what action must be taken to avoid the error.

Choosing The Error Code

For every exception, there is a suitable error code. However, in this case, I wasn't sure what to use. Naturally, I searched around and stumbled upon a question on StackOverFlow discussing this very example.

The accepted answer was the error 409 Conflict code. Using this code means that the request cannot be completed due to a conflict in the current state of the resource. However, when thinking about this meaning, I feel like this is not the correct error code in my case. The state of the resource itself isn't the issue.

Another option is using error 400 Back Request, but that doesn't feel right either. This code suggests that the server doesn't understand the request being made, and therefore cannot process it. That isn't the case here either, because the server perfectly understands the request.

A bit further down the post, I stumbled upon an interesting answer: using error 422 Unprocessable Entity. The following is said about this error code in WebDAV RFC 4918:

The 422 (Unprocessable Entity) status code means the server understands the content type of the request entity (hence a 415 (Unsupported Media Type) status code is inappropriate), and the syntax of the request entity is correct (thus a 400 (Bad Request) status code is inappropriate) but was unable to process the contained instructions.

The definition of this error code seems to fall in line with the situation I am facing. The server understands the request; it is a valid request, but is unable to process the entity. It cannot process the entity, because it is a duplicate.

Updating the ExceptionResponseHandler

Finally, I chose to use error 422 for my ResourceAlreadyExistsException. Still, I need to hook up this error message to the ExceptionResponseHandler. The extra method is very similar to the method I created earlier for handling all exceptions. In fact, you can easily copy-paste this method for all the exceptions you have. All you have to do, is changing the Exception class to your exception and change the HttpStatus.<code>.

@ExceptionHandler(ResourceAlreadyExistsException.class)
public final ResponseEntity<ExceptionResponse> handleResourceAlreadyExistsException(
    ResourceAlreadyExistsException ex, WebRequest req) {
    ExceptionResponse exceptionResponse = new ExceptionResponse(
        new Date(),
        ex.getMessage(),
        req.getDescription(false)
    );
    return new ResponseEntity<>(exceptionResponse, HttpStatus.UNPROCESSABLE_ENTITY);

Conclusion

Figuring out how to get the custom exceptions working in Spring Boot certainly was a fun one to uncover. I'm glad that this solution is reusable for multiple projects as well! Next up is figuring out how to write unit tests for the layers. Preferably, I want to write unit tests with mocks, so I can test the functionality without any dependencies.

Check for Unique Documents in MongoDB with Spring Boot

Rose — Wed, 19 Aug 2020 22:47:15 +0000

Whilst figuring out how exceptions work, I wanted to make sure that the blog posts are always unique. But how do we do that? That's why I'll show you how to check for unique documents in MongoDB with Spring Boot.

@Indexed Annotation

At first, I looked into the @Indexed annotation from Spring Boot. This annotation will make a new index in MongoDB. You can add extra parameters within the annotation to make it do something more specific for you. In my case, I am using the unique parameter to let MongoDB check if a specific field is unique. With that, my blogpost class looks like this.

@Document(collection = "blogposts")
public class BlogPost {

    @Id
    private String documentId;
    @Indexed(unique = true)
    private String endPoint;
    @JsonFormat(pattern="dd-MM-yyyy HH:mm")
    private Date publishDate;
    private List<String> categories;
    private List<String> tags;
    private String article;

When I test this configuration, nothing happens. I can still add blog posts with duplicate endpoints. Later, I come across this post on StackOverFlow, stating that I have to add the line spring.data.mongodb.auto-index-creation=true to my application.properties. So, I added the line, even completely dropped the database and restarted MongoDB, but to no avail.

Query for Unique Documents

After a couple hours of arguing with the @Indexed annotation, I finally give in. Still, I want to find a way to check for unique documents in MongoDB with Spring Boot. So, I resort to another way of getting there: using a database query. It might not be the quickest one, but it will suffice for now.

Ideally, what I want the query to do, is tell me whether there is already a blogpost in my database with the same value for endPoint. I start out working my way through the Spring Data Documentation for MongoDB, trying to figure out how to setup my query. After another search,, I come along the MongoDB Documentation on $exists. One of their examples uses $exists combined with $nin to collect documents where a field exists and its value does not equal to what you've set it to.

$exists and $nin

Brilliant! Let's try that out. First, I start with creating a boolean to store my result in with the following bit of code. Then I use the boolean in my if-statement to decide whether to save the object or not.

@Override
public void createBlogPost(BlogPost blogPost) {
    boolean postExistsAlready = mongoTemplate.query(BlogPost.class)
        .matching(Query.query(where("endPoint").exists(true).nin(blogPost.getEndPoint()))).exists();

    if(!postExistsAlready) {
        mongoTemplate.save(blogPost, "blogposts");
        System.out.println("Posted!!!");
    }
    else {
        System.out.println("Post already exists!!!");
    }
}

I test again, and, of course, it didn't work. With no errors appearing in my console, I resorted to PowerShell and getting right into MongoDB. After logging in, I check what data is already present in my database collection by using db.blogposts.find(). Then, I try the MongoDB version of my query with the following line: db.blogpost.find(endPoint:{$exists:true, $nin:"/test"}}). It might have been a bit late when I was working on this, because there is clearly a typo. However, I did find out one reason why nothing was happening, because I got an error when trying to execute the query.

Apparently, $nin requires an array as input, rather than just a string. Fortunately, that is fairly easy to fix! With a little adjustment of the code, it now looks like this.

@Override
public void createBlogPost(BlogPost blogPost) {
    String[] endPoint = new String[] {blogPost.getEndpoint()};

    boolean postExistsAlready = mongoTemplate.query(BlogPost.class)
        matching(Query.query(where("endPoint").exists(true).nin(endPoint))).exists();

    if(!postExistsAlready) {
        mongoTemplate.save(blogPost, "blogposts");
        System.out.println("Posted!!!");
    else {
        System.out.println("Post already exists!!!");
    }
}

Awesome! Let's try that again. No luck either.

$exists and $in

At this point, I start questioning whether I'm using the correct query methods, especially considering that there will be many more blog posts to come. On a hunch, I fiddled around in mongo with PowerShell. Instead of using $nin, I tried $in with a count method. So, I tried the following query in my PowerShell: db.blogposts.count({"endPoint":{$exists:true,$in:["/test"]}}).

Well, look at that! When I use $nin, my count returns 0, because there are no documents in my database that don't have /test as their endpoint. However, when I use $in, the query returns me the number of articles that do have /test as their endpoint. That is exactly what I need!

So, I adjusted my code again to use this information. The final version so far, looks like this.

@Override
public void createBlogPost(BlogPost blogPost) {
    String[] endPoint = new String[] {blogPost.getEndPoint()};

    Query query = new Query();
    query.addCriteria(Criteria.where("endPoint").in(endpoint));

    boolean postExistsAlready = mongoTemplate.exists(query, BlogPost.class);

    if(!postExistsAlready) {
        mongoTemplate.save(blogPost, "blogposts");
        System.out.println("Posted!!!");
    }
    else {
        System.out.println("Post Already Exists!!!");
    }
}

Conclusion

It took a bit to figure it all out, and I am not yet done with the @Indexed annotation. Using a query like this works for the time being, but ultimately I think it would be better to use what MongoDB has available for us. I have seen ways to add the index manually, but it requires more research. For now, I'm happy to have solved this little riddle.

Now, I do agree that these System.out.println() statements are far from pretty. There is no way to notify the user that something has gone wrong. So, the next step is to figure out how to handle exceptions being thrown!

Adding Functionality to the Backend - Building a Blog

Rose — Fri, 14 Aug 2020 22:27:05 +0000

The proof of concept worked like a charm. Now, I need to create the basis by adding functionality to the backend. today, I'll start with creating a blog post and see what challenges lie ahead on the road.

So, before I start implementing the full feature of creating a blog post. I had to remove the testing code I created last time in my proof of concept. With a clean BlogPostController, I can further structure my Spring Boot project.

High-Level Project Structure

I want to keep my business logic separated from my controller layer, even though there might not be a whole lot of business logic to a blog backend. Between my controller and repository layer, I add a service layer. So, essentially, we get the following structure in my project.

As you can see, I'm using a BlogPostService interface and a BlogPostServiceImpl for the implementation class. In this case, I'd like to use interfaces to future proof my software in case I need to change something in the implementation of my service. At school, I never really understood why, but this post on StackExchange has helped me understand this better.

Adding Functionality

Personally, I'd like to work from bottom to top when it comes to adding new functionality to my backend. Right now, I want to start with the first CRUD operating: create. I expect my frontend to deliver a blog post object in the request body, therefore I'musing my blogpost object in my code.

BlogPostService Interface

So, building from bottom to top, I start with my BlogPostService interface first. For now, the interface is still quite empty, but that will change soon enough when adding more functionality of course. For now, my interface looks like this.

public interface BlogPostService {
    public abstract void CreateBlogPost(BlogPost blogPost);
}

BlogPostService Implementation

With the interface in place, I now have to write the implementation of the method in my BlogPostServiceImpl with the same bit of code I used last time for MongoDB. Also,I have annotated the class with @Service to let Spring Boot know that this is a service component within my application. Furthermore, I have autowired MongoTemplate, so I can use it freely for saving my blog post to the database.

@Service
public class BlogPostServiceImpl implements BlogPostService {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public void CreateBlogPost(BlogPost blogPost) {
        mongoTemplate.save(blogPost, "blogposts");
    }
}

BlogPostController

Finally, I can write the code for my controller layer. I've added a couple annotations to my BlogPostController versus last time.

@RestController()
@RequestMapping("/blog")
public class BlogPostController {

    @Autowired
    private BlogPostService blogPostService;

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public void createBlogPost(@RequestBody BlogPost blogPost) {
        blogPostService.CreateBlogPost(blogPost);
    }
}

Let's go through the annotations. I have started with adding @RestController above my class to notify Spring Boot that this is a controller component, specifically one that accepts REST requests. Furthermore, I have added a custom endpoint set with @RequestMapping("/blog"). That means that every endpoint within this controller is http://localhost:8080/blog. For every method, I have to define what type of method it is with the @PostMapping annotation.

If you want to change the endpoint per method, you can add the name of the endpoint as a string in brackets behind @PostMapping like this: @PostMapping("/test"). The full endpoint for this method will be http://localhost:8080/blog/test. Of course, you can do this for all request types.

The last annotation, @ResponseStatus(HttpStatus.CREATED) allows me to define what response I want my backend to send back. At this stage, I haven't yet figured out how to throw the exceptions. I still have to figure that out, and when I do, I'll write about it of course. For now, this will have to do and it serves its testing purpose.

Last, but definitely not least, I have used te @RequestBody annotation before my BlogPost variable. This annotation lets Spring Boot know to check in the request body for the blog post object, which the service uses to save the post to the database.

Testing My Feature

Excited with my new bits of code, I was eager to test if it works. I run my first test with curl, since I don't have Postman available on my Debian laptop. Failed. Damn it! I check what I tried to send as my request body, and I noticed that I misspelled endpoint.There must be a way to validate the object to get a cleaner error message, right?

Java Bean Validation

After a quick search, I came across two articles (this one and this one) from Baeldung on Java Bean Validation. With a simple annotation, the bean automatically validates the input in the request body to match the object. I only have to make some tiny adjustments.

First, I have to add two dependencies to my pom.xml file:

<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
</dependency>
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator-annotation-processor</artifactId>
</dependency>

After letting maven do its thing, I only have to add the @Valid annotation before the request body annotation, and that's it! Now, the function should work.

Date Format

Yeah, not a chance. The function still doesn't work. This time, I'm getting a parsing error on the data I input. Fortunately, Baeldung came to the rescue again with a little article on the JsonFormat annotation. I added a small adjustment to my BlogPost class with the following line of code:

@JsonFormat(pattern="dd-MM-yyyy HH:mm")
private Date publishDate;

Functionality Added!

At long last, I am able to post a blog post! It is far from perfect yet, as I still have to figure out how to get the exceptions to work. Furthermore, I still have to write unit tests as well to make sure that my code is working as expected. That is what I'll be working on the upcoming few days. Once I get these two parts done, I can continue with adding even more functionality like getting and deleting a specific or all posts.

Insert Data in MongoDB with Spring Boot - Building a Blog

Rose — Thu, 06 Aug 2020 09:12:29 +0000

Last time, we set up our database and Spring Boot project, and secured our database credentials. Now, we have to configure MongoDB in our project. Then we can start to insert data in mongodb and getting a feel for the queries to get the data from the database.

Configuring Spring Boot to Access MongoDB

To get started, we need to configure our Spring application, so our application knows where the database is to begin with. We do that by adding the following lines to the application.properties file in the resources directory.



spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=rosafiore
spring.data.mongodb.authentication-database=admin

When configuring MongoDB, we added a user to our database. This user uses the admin database to authenticate, and thus to access the other databases. That's why we need to define the authentication database, rather than just inputting the credentials to the database we will be talking to.

However, we still have to insert our secured credentials. Truth be told, it took a long time to get this one figured out. There was no clear resource online that I could find. So, after a lot of digging and trying, I have managed to create a mongo configuration that inserts the secured credentials and creates a connection to the database.

MongoConfig

So, let's get started with this new config file. First off, we need to create a new class in our project. I call it MongoConfig, because it contains the configuration for MongoDB. We have to annotate the class with the @Configuration and @EnableMongoRepositories. That way, Spring Boot knows that this is a configuration class, and thus must be taken along during initialization and to enable the repositories. Furthermore, we need to inherit the AbstractMongoClientConfiguration for a couple of methods to complete our configuration. So, our bare config class now looks like this:



@Configuration
@EnableMongoRepositories
public class MongoConfig extends AbstractMongoClientConfiguration {

    @Override
    protected String getDatabaseName() {
        return null;
    }
}

In this class, we will create our own MongoClient to insert data in mongodb. For this, we need the properties we've defined in our application.properties file. We can access the properties by using a spring annotation on our local variable: @Value("${<property name>}"). With this construction, we create our variables with our property values and use them for configuring our client. One such variable will look like this in code:



@Value("${spring.data.mongodb.database}")
private String database;

As you might have seen a bit before, the MongoConfig class inherited the method getDatabaseName(). There, we have to replace the null value with the database variable. Now, we need to dive in to configuring the MongoClient itself.

MongoClientSettings

After searching for some time, I came across the mongodb documentation for connecting to a database. Further down the page, I finally found what I was looking for: applying custom settings. I decided to create a separate private method to configure the settings to keep things tidy. Here is the code for my settings and I'll walk you through the code as we go.



private MongoClientSettings setMongoClientSettings() {
    MongoCredential credential = MongoCredential.createCredential(
        Config.USERNAME, authDatabase, Config.PASSWORD);

    return MongoClientSettings.builder()
            .credential(credential)
            .applyToClusterSettings(builder ->
                    builder.hosts(Arrays.asList(new ServerAddress(host, port))))
            .build();
}

I start off with defining the credentials and the authentication database for my client. That is where I get to use my secured database credentials, instead of hardcoding them.

Then comes the MongoClientSettings.builder(), that is where the actual settings are created. The first thing I do, is setting the credentials to the one I created earlier in the method. Next, I need to configure the location of the database in the applyToClusterSettings. Here, I set the host to a new ServerAddress with the host and port number. Finally, the building can create the settings and return those. The settings are then used to create the MongoClient for Spring Boot to use.



@Override
@Bean
public MongoClient mongoClient() {
    return MongoClients.create(setMongoClientSettings());
}

So, the MongoConfig class now looks like this:



@Configuration
@EnableMongoRepositories
public class MongoConfig extends AbstractMongoClientConfiguration {

    @Value("${spring.data.mongodb.host}")
    private String host;

    @Value("${spring.data.mongodb.port}")
    private int port;

    @Value("${spring.data.mongodb.database}")
    private String database;

    @Value("${spring.data.mongodb.authentication-database}")
    private String authDatabase;

    @Override
    protected String getDatabaseName() {
        return database;
    }

    @Override
    @Bean
    public MongoClient mongoClient() {
        return MongoClients.create(setMongoClientSettings());
    }

    private MongoClientSettings setMongoClientSettings() {
        MongoCredential credential = MongoCredential.createCredential(
            Config.USERNAME, authDatabase, Config.PASSWORD);

        return MongoClientSettings.builder()
                .credential(credential)
                .applyToClusterSettings(builder ->
                        builder.hosts(Arrays.asList(new ServerAddress(host, port))))
                .build();
    }
}

Insert Data in MongoDB

With our configuration completed, it is time to set up the rest of the code to insert data in mongodb. For this, we first need to create a class that is basically the blueprint of our object. In my case, I want to start out with a simple blog post object and the data I expect in it.

BlogPost Model

As I explained in Choosing a Database: SQL or NoSQL?, my blogpost object contains the following properties:

EndPoint
Publish Date
Categories
Tags
Blog Post (the content)

I reflected these properties in my BlogPost class which looks like this (I removed the getters and setters to avoid clutter):



@Document(collection = "blogposts")
public class BlogPost {

    @Id
    private String documentId;
    @Indexed(unique = true)
    private String endPoint;
    private Date publishDate;
    private List<String> categories;
    private List<String> tags;
    private String article;
}

As you can see, I annotated the class with the @Document annotation. That allows me to choose the name of the collection where mongodb will be storing my blog posts. Furthermore, I have created a documentId with the @Id annotation to inform mongodb that this property will contain the ID for every blog post object stored in the database. Finally, I have added the @Indexed(unique = true) annotation to my EndPoint property. This annotation allows me to have mongodb check if the property is actually unique. I don't want duplicate endpoints for my blog posts after all!

BlogPost Repository and Controller

With the model complete, it is time to insert the first blog post in the database. For this, we need a Repository first. Fortunately, this is a relatively simple one, I only need to create the interface and that is about it for now.

With that, the BlogPostRepository looks like this:



@Repository
public interface BlogPostRepository extends MongoRepository <BlogPost, Long> {
}

That is it for the repository, now we can continue with the controller. The controller contains the endpoints for our requests. I've made this a very simple controller, because it is still a proof of concept for me. I created two methods: one for posting a blog post and one for getting a blog post. For the POST method, I have hardcoded the values for the blog post.

In order to insert data into mongodb, I'll be using MongoTemplate which I only have to autowire into the application like this:



@Autowired
private MongoTemplate mongoTemplate;

With the mongoTemplate autowired, creating the POST and GET method was relatively easy and straightforward.



@PostMapping
    public void createPost() {
        BlogPost blogPost = new BlogPost();
        blogPost.setEndPoint("/test");
        blogPost.setPublishDate(new Date());
        blogPost.setCategories(Arrays.asList("TestCategory"));
        blogPost.setTags(Arrays.asList("TestTag"));
        blogPost.setArticle("testPost.md");

        mongoTemplate.save(blogPost, "blogposts");
    }

    @GetMapping
    public List<BlogPost> getPost() {
        Query query = new Query();
        query.addCriteria(Criteria.where("endPoint").is("/test"));
        return mongoTemplate.find(query, BlogPost.class);
    }
}

Of course, the only way to know for sure, is to test it. So, I went into Postman, inserted the requests and finally, after a long days struggle I get the following response when trying to obtain the blog post I had inserted.

With that, I have finally managed to insert data in mongodb! Now, I can start with expanding the backend code with more endpoints. Furthermore, I need to decide how to proceed with this project and what steps I will take next.

Securing Database Credentials - Building a Blog

Rose — Fri, 17 Jul 2020 20:37:36 +0000

With our database set up, it is now time to make a MongoDB connection with Spring Boot. That connects the database to our backend system, making us ready to start implementing our operations. However, I don't want my database credentials to be all over GitHub. Therefore, in this post, I will be securing my database credentials.

I already had my Spring Boot project, but in case you don't, go to https://start.spring.io/. Here, you can easily configure your start project with Spring Boot. For my project, I have selected the following dependencies:

Spring Boot DevTools
Spring Web
Spring Security (I want to use JTW tokens later on in the project)
Spring Data MongoDB

Let the website generate a project for you, unzip it and you should start with a blank Spring Boot project.

Securing Database Credentials

The first thing I want to do, is securing my database credentials. One of the places to put these, is in the application.properties file. However, this file gets uploaded to GitHub, which would mean that the database credentials would be visible to everyone. And, lets be honest, I don't want that and you probably don't want that either. So, it is time to implement a solution that would solve this.

Create the Properties File

Java does have a sweet feature where you can tap into the system properties. In this case, I want to use the method System.getProperty("user.home"). This method allows me to go to the home drive without hard-coding it. On Windows, the user.home directory is usually located at C:\Users\<your username>\. On Linux, it is the home directory. Using this method, we can make the software cross platform as well. I have created a subdirectory that will contain files for my project.

So, in this subdirectory, I created my properties file: rosafiore.properties. In this file, I have set the username and password I'm using for my database connection. It looks somewhat like this:

username=<username>
password=<password>

Note that I am not using any accolades for the string I use to define my username and password. Now, it is time to get back to the project in IntelliJ (or any other Java IDE you prefer). I have created the following file structure for my project:

Reading the Property File on StartUp

The first class I'm going to take a look at is the Config class. I use this class to load the properties from my property file with the following bit of code:

@Component
@ConfigurationProperties(prefix = "config")
@Validated
public class Config {
    public static String USERNAME;
    public static String PASSWORD;
    private static final String PROPERTIES_LOCATION = System.getProperty("user.home") +
            "/RosaFiore/rosafiore.properties";

    public static void getConfig() {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream(PROPERTIES_LOCATION));
            USERNAME = properties.getProperty("username");
            PASSWORD = properties.getProperty("password");
        }
        catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

We can now load the properties from our properties file! However, we need this to be done on startup of the application. So, we need to find a way to tap into the Spring Boot startup process and run this Config class. For this, we need to make some changes in the class where the main method resides.

In the class with our main method, I'm going to add an inner static class. This inner class allows us to use the getConfig() from our Config class. We can achieve that by creating a class that implements an ApplicationListener. To be more specific, a listener that triggers on the ApplicationEnvironmentPreparedEvent. By overriding onApplicationEvent(), we can use Config.getConfig() to load our properties. Then, we have to adjust our main method to add the ApplicationListener, so it triggers our Config.getConfig() on the environment prepared event. Fully finished, it looks somewhat like this:

@SpringBootApplication
public class BlogBackendApplication {

    static class EnvironmentPreperation implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {
        @Override
        public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
            Config.getConfig();
            if (Config.USERNAME.isEmpty() || Config.PASSWORD.isEmpty()) throw new IncompleteConfigException();
        }
    }

    public static void main(String[] args) {
        SpringApplication blogBackend  = new SpringApplication();
        blogBackend.addListeners(new BlogBackendApplication.EnvironmentPreperation());
        blogBackend.setSources(new HashSet(Arrays.asList(BlogBackendApplication.class)));
        ConfigurableApplicationContext context = blogBackend.run(args);
        System.out.println("DbUsername: " + Config.USERNAME + " ; DbPassword: " + Config.PASSWORD);
    }
}

I have added that last line of code to make sure that the properties are loaded correctly. When running the code, I see this beautiful piece of log appearing in my console:

2020-07-17 20:07:05.519  INFO 14676 --- [  restartedMain] e.r.blogbackend.BlogBackendApplication   : Started BlogBackendApplication in 2.4 seconds (JVM running for 2.981)
DbUsername: <username> ; DbPassword: <password>

Now that I have secured my database credentials, I can start working on connecting my MongoDB database to my Spring Boot project. So, next time, I will start implementing and adding my first test blog posts into the database.

How do you keep up with writing?

Rose — Thu, 16 Jul 2020 15:18:25 +0000

I wonder if it's me or not, but I often find myself having a lack of motivation to write. Whether it be writing code or writing a blog post, I struggle with it regularly.

Do you feel the same? Which solution(s) work for you? Or do you have any other thoughts on this? I'm curious to read what you think of it.

Getting Started with MongoDB - Building a Blog

Rose — Sat, 11 Jul 2020 16:01:29 +0000

Last time, I decided to use MongoDB for building my blog. As I have never worked with MongoDB before, I still have to figure out how to get everything to work. So, the only thing left to do now is getting started with MongoDB. How do we set it up, add users, and create our database.

First, lets download the community server which is free and open source. I will be using the Windows version for my desktop and this article. After installing the software, I also installed mongosh since I am an avid command line user. After adding mongosh to my PATH variables, I run powershell to see this:

Creating a User

Awesome! Time to figure out how to add a user. After all, I do not want everyone to simply log into my database. In order to do that, I first have to create an admin user and then enable access control. Figuring out how to do that was quite the task, since mongosh is still in beta an does not contain all functionality yet. So, to create a database with mongosh, we will have to use the following command:

Now, we should have a new user with admin rights. That allows us to shutdown the MongoDB server and enable access control. We can shutdown the server by using db.adminCommand({shutdown:1}). After the server is down, we can take a look at the MongoDB config file to enable access control. You can find the file at <installation directory>/bin/mongod.cfg. Here, we need to add the following lines:

Security:
  authorization: enabled

It is halfway when trying to boot the server again, that I figured that using mongosh might not have been the brightest of ideas. MongoDB is already new to me and using beta software that does not support all commands yet is not making things any easier. So, I switched to the legacy mongo shell, since the documentation is up to date for that. I managed to boot the server again and logging into my database!

Creating a Database

I got my authentication ready, the final step now is to create a database. You can easily create a new database in MongoDB with the use <database> command. If the database doesn't exist yet, it creates it. Keep in mind though that MongoDB will save the database only when you put data in it. Until then, it is not saved and does not show up when using the show dbs command.

With MongoDB running on my desktop, I can finally start with a little proof of concept. I will use that proof of concept to figure out how to connect to MongoDB and add my first set of data using Spring Boot. That should allow me to get a better grip on the technologies to start implementing it for the actual project. You know... less hacky and a bit more clean. However, that is for another post!