<h2 id="overview">Overview</h2>
<a rel="nofollow" target="_blank" href="https://spring.io/projects/spring-data">Spring Data</a> is an umbrella project which contains many submodules, each specific to a particular database. In this article, we'll be covering <a rel="nofollow" target="_blank" href=https://spring.io/projects/spring-data-mongodb>Spring Data MongoDB</a> by building an application that stores and retrieves data from MongoDB, a document based NO-SQL database.
If you'd like to read more about Spring Data, we've covered it in detail in - <a target="_blank" href="/guide-to-spring-data-jpa/">Guide to Spring Data JPA</a>.
<h2 id="mongodb">MongoDB</h2>
<a rel="nofollow" target="_blank" href="https://www.mongodb.com/">MongoDB</a> is a document-oriented NoSQL database that stores JSON-like documents with dynamic schemas. It is commonly used for high volume data storage.
Before moving forward, it would be good to know some of the NoSQL database terms. Please note that these terms are not exactly a one-to-one in comparison with relational SQL databases:
<ul>
<li>Database: It is a container for collections and can be thought of as similar to an RDBMS database, which is a container for Tables.</li>
<li>Collection: It is equivalent to Tables in RDBMS, but unlike a collection it has a dynamic schema. A collection exists within a database.</li>
<li>Document: It is a single record in a MongoDB collection. It can be thought of as a row in RDBMS.</li>
<li>Field: A document has zero or more fields. It's like an RDBMS column having a key-value pair.</li>
</ul>
To setup MongoDB server on your local machine you can download the installable <a target="_blank" rel="nofollow" href="https://www.mongodb.com/download-center/community">here</a> according to your operating system. You can then also download a tool like <a target="_blank" rel="nofollow" href="https://www.mongodb.com/download-center/compass">Compass</a> for a nice GUI to interact with your server.
Another option and the one which we will be using is <a rel="nofollow" target="_blank" href="https://www.mongodb.com/download-center/cloud">MongoDB Atlas</a>, which is a cloud database as a service. After you sign up, login and build a cluster using the free tier:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-1.png" alt="MongoDB Atlas create cluster">
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-2.png" alt="MongoDB Atlas cluster overview">
To connect to our cluster, we have to create a user:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-3.png" alt="MongoDB Atlas create user">
Let's now create our database and collection:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-4.png" alt="MongoDB create database">
We are now set to connect to our collection using our Spring application.
<h2 id="springdatamongodbproject">Spring Data MongoDB Project</h2>
<h3 id="setup">Setup</h3>
The best way to start with a skeleton project is to visit <a rel="nofollow" target="_blank" href="https://start.spring.io/">Spring Initializr</a>. Select your preferred version of Spring Boot and add the <code>Web</code> and <code>MongoDB</code> dependencies:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-5.png" alt="Spring Initializr">
After this, generate it as a Maven project and you're all set!
<h3 id="definingacollection">Defining a Collection</h3>
First, let's define our collection <code>Candidate</code> model class:
<pre><code class="hljs">@Document(collection = &quot;candidate&quot;)
public class Candidate {
 @Id
 private String id;

 private String name;

 private double exp;

 @Indexed(unique = true)
 private String email;

 // getters and setters
}
</code></pre>
Now let's take a look at these annotations:
<ul>
<li>@Document: This marks the class as a domain object that will be persisted into the database. The default collection name that is used is the class name (first character lowercased). We can map to a different collection in the database by using the <code>collection</code> attribute of the annotation.</li>
<li>@Id: This marks the field used for identity purposes.</li>
<li>@Indexed(unique = true): This is applied to the field that will be indexed with a constraint of unique.</li>
</ul>
<h3 id="definingrepository">Defining Repository</h3>
We create a repository by making an interface:
<pre><code class="hljs">public interface CandidateRepository extends MongoRepository&lt;Candidate, String&gt; {}
</code></pre>
<code>CandidateRepository</code> extends the <code>MongoRepository</code> interface and plugs in the datatype of the document that we are working with, i.e <code>Candidate</code> and <code>String</code> respectively.
This will give us access to all the CRUD operations around the MongoDB collection.
<h3 id="connectionsetup">Connection Setup</h3>
To set up a proper connection, we need to define the connection properties in <code>application.properties</code>:
<pre><code class="hljs">spring.data.mongodb.uri=mongodb+srv://&lt;USERNAME&gt;:&lt;PASSWORD&gt;@&lt;ClUSTER-NAME&gt;-&lt;INSTANCE-ID&gt;/&lt;DATABASE-NAME&gt;?retryWrites=true
</code></pre>
You can get these values directly from the MongoDB Atlas UI:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-6.png" alt="Atlas connection URL">
Note: If your password contains special characters then it must be URL encoded.
By default, your cluster is secured not to take requests from any client IP. We need to allow our IP to be able to connect to this cluster via an IP Whitelist:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-7.png" alt="Atlas IP whitelist 1">
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-8.png" alt="Atlas IP whitelist 2">
<h3 id="definingthecontroller">Defining the Controller</h3>
Now, let's use our repository in our <code>CandidateController</code> via the <code>@Autowired</code> annotation:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/candidate&quot;)
public class CandidateController {

 @Autowired
 private CandidateRepository candidateRepository;
</code></pre>
<h3 id="simplecrudoperations">Simple CRUD Operations</h3>
<h4 id="insert">Insert</h4>
Let's create a <code>POST</code> mapping that will insert data to our MongoDB:
<pre><code class="hljs">@PostMapping
@ResponseStatus(code = HttpStatus.CREATED)
public Candidate add(@RequestBody Candidate candidate) {
 return candidateRepository.save(candidate);
}
</code></pre>
We used the <code>save()</code> method on the <code>candidateRepository</code> object. The <code>Candidate</code> object is captured by <code>@RequestBody</code> and is used directly in the <code>save()</code> method.
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-9.png" alt="MongoDB insert 1">
If we try to use the same email ID again, we will get a duplicate key error:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-10.png" alt="MongoDB insert 2">
We can check our collection status in Atlas too:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-11.png" alt="MongoDB insert 3">
<h4 id="read">Read</h4>
Let's create a couple of <code>GET</code> mappings to fetch our records.
<pre><code class="hljs">@GetMapping
public List&lt;Candidate&gt; getAll() {
 return candidateRepository.findAll();
}

@GetMapping(value = &quot;/{id}&quot;)
public Candidate getOne(@PathVariable String id) {
 return candidateRepository.findById(id)
 .orElseThrow(() -&gt; new ResourceNotFoundException());
}
</code></pre>
<code>findAll()</code> will return all the records in our database, while the <code>findById()</code> method will return a single record based on the ID passed.
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-12.png" alt="MongoDB insert">
If the record is not present it <code>throws</code> a custom runtime exception. <code>ResourceNotFoundException</code> is a custom class that returns <code>404</code> status if it's thrown:
<pre><code class="hljs">@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
 public ResourceNotFoundException() {
 }
}
</code></pre>
If you'd like to read more about this, we've covered it in detail in - <a target="_blank" href="/exception-handling-in-spring/">Exception Handling in Spring</a>.
<h4 id="update">Update</h4>
Now to update a particular record, we'll use a <code>PUT</code> mapping:
<pre><code class="hljs">@PutMapping(value = &quot;/{id}&quot;)
public Candidate update(@PathVariable String id, @RequestBody Candidate updatedCandidate) {
 Candidate candidate = candidateRepository.findById(id)
 .orElseThrow(() -&gt; new ResourceNotFoundException());
 candidate.setName(updatedCandidate.getName());
 candidate.setExp(updatedCandidate.getExp());
 candidate.setEmail(updatedCandidate.getEmail());
 return candidateRepository.save(candidate);
}
</code></pre>
We first check whether the <code>Candidate</code> with the given <code>id</code> is present or not. If not, we return a <code>404</code> status, otherwise we update the whole object and save it using the <code>save()</code> method:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-13.png" alt="MongoDB update">
<h4 id="delete">Delete</h4>
Now, let's delete a particular record by using the <code>DELETE</code> mapping:
<pre><code class="hljs">@DeleteMapping(value = &quot;/{id}&quot;)
@ResponseStatus(code = HttpStatus.ACCEPTED)
public void delete(@PathVariable String id) {
 Candidate candidate = candidateRepository.findById(id)
 .orElseThrow(() -&gt; new ResourceNotFoundException());
 candidateRepository.delete(candidate);
}
</code></pre>
We used the <code>delete()</code> method on the <code>candidateRepository</code> to delete the entry:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-14.png" alt="MongoDB delete">
<h3 id="customquerymethods">Custom Query Methods</h3>
We can add some methods to our <code>CandidateRepository</code> to have some additional functionality based on our business requirements:
<pre><code class="hljs">public interface CandidateRepository extends MongoRepository&lt;Candidate, String&gt; {

 Optional&lt;Candidate&gt; findByEmail(String email);

 List&lt;Candidate&gt; findByExpGreaterThanEqual(double exp);

 List&lt;Candidate&gt; findByExpBetween(double from, double to);
}
</code></pre>
Above, we added search functionality based on email and experience. All we need to do is follow a naming convention laid down by <a rel="nofollow" target="_blank" href="https://docs.spring.io/spring-data/mongodb/docs/current/reference/html/">Spring Data</a>.
After the <code>findBy()</code> method we write the name of the attribute in camel case, followed by any other restriction that we may want to enforce. The arguments to the method should match the where clause expectation. Spring Data will create actual queries for you during the startup of the application by using this interface.
Let's use this in our controller:
<pre><code class="hljs">@GetMapping(&quot;/searchByEmail&quot;)
public Candidate searchByEmail(@RequestParam(name = &quot;email&quot;) String email) {
 return candidateRepository.findByEmail(email)
 .orElseThrow(() -&gt; new ResourceNotFoundException());

}

@GetMapping(&quot;/searchByExp&quot;)
public List&lt;Candidate&gt; searchByExp(@RequestParam(name = &quot;expFrom&quot;) Double expFrom, @RequestParam(name = &quot;expTo&quot;, required = false) Double expTo) {
 List&lt;Candidate&gt; result = new ArrayList&lt;&gt;();
 if (expTo != null) {
 result = candidateRepository.findByExpBetween(expFrom, expTo);
 } else {
 result = candidateRepository.findByExpGreaterThanEqual(expFrom);
 }
 return result;
}
</code></pre>
<img src="https://s3.amazonaws.com/stackabuse/media/spring-data-mongodb-tutorial-15.png" alt="MongoDB custom queries">
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered how to use Spring Data MongoDB to connect to a MongoDB server. We first created a MongoDB server in the cloud using MongoDB Atlas and then used Spring Data to connect to it. After that, we performed some simple CRUD operations as well as wrote some custom queries.
As always, the code for the examples used in this article can be found on <a rel="nofollow" target="_blank" href="https://github.com/StackAbuse/spring-data/tree/master/mongodb">GitHub</a>.

Dhananjay Singh

Spring Data: MongoDB Tutorial

In the <a target="_blank" href="/monitoring-data-changes-using-a-hids/">previous article</a> I explained how to monitor your data and how to detect changes using tools like Integrit, which is a Host-based Intrusion Detection System (HIDS). Discovering the changes in files is already quite nice, but keeping track of the content and its changes over time is much better. In this article, we will have a look at different ways to use a revision control system by doing commits automatically.
The solutions we looked at up to now will help you to answer the question, &quot;Did my data change?&quot; - although you do not know what has changed exactly. The original data has already been overwritten, and in retrospect only you will notice the changes. There are two ways to identify the differences - comparing the current data with your external backup, or use a revision control system like <a rel="nofollow" target="_blank" href="https://git-scm.com/">Git</a> or <a rel="nofollow" target="_blank" href="https://subversion.apache.org/">Apache Subversion</a> (SVN). Both tools offer you a version history for the files and directories.
As an example, the command <code>git status</code> displays changes that have been made:
<pre><code class="hljs">$ git status
# On branch master
# Changes not staged for commit:
# (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
# (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
#
# modified: dataset1.txt
#
no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)
</code></pre>
The disadvantage of these solutions is that they require an additional step - a commit as soon as an entry in the file system has changed. Both Git and Subversion do not do that automatically.
A very straight-forward solution is the following one:
<pre><code class="hljs">$ git add --all
$ git commit -a -m &quot;current changes&quot;
</code></pre>
In line one all the local changes are tracked, and in line two these changes are committed. This covers temporary files, too, which may not be your desire. To prevent this, a file named <code>.gitignore</code> helps. This file contains the file names that are excluded from version control, for example temporary files created by the Vim text editor:
<pre><code class="hljs">*~
*.sw?
</code></pre>
<h2 id="usingtheinotifyinterface">Using the <code>inotify</code> Interface</h2>
Combining Git/SVN commands with <code>find</code>, <code>xargs</code>, <a rel="nofollow" target="_blank" href="http://inotify.aiken.cz/?section=incron&page=about&lang=en">incron</a>, <a rel="nofollow" target="_blank" href="http://emcrisostomo.github.io/fswatch/">fswatch</a>, or <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Inotify">inotify</a> helps, and allows you to process such events without manual intervention.
Inotify works by watching for changes to the filesystem and notifying applications of those changes.
The following code shows a call based on the <code>inotify</code> kernel subsystem using <a rel="nofollow" target="_blank" href="https://packages.debian.org/stretch/inotify-tools">inotifywait</a>. A Git commit happens as soon as the changes in the file <code>file.txt</code> are written to disk.
<pre><code class="hljs">$ inotifywait -q -m -e CLOSE_WRITE --format=&quot;git commit -m &#x27;autocommit on change&#x27; %w&quot; file.txt | sh
...
</code></pre>
In order to track entire directories you should use the additional switch <code>-r</code>.
<h2 id="combiningfindxargsandgit">Combining <code>find</code>, <code>xargs</code>, and <code>git</code></h2>
The following bash script uses tools that exist on every Linux system, and combines <code>find</code>, <code>xargs</code>, and <code>git</code>. Once per hour the script checks for files having changed within the last hour, and commits them in a local Git repository.
<pre><code class="hljs">#!/bin/bash

while true
do
 # calculate time range
 currentSec=$(date + &quot;%s&quot;)
 currentTime=$(date + &quot;%Y%m%d %H:%M:%S&quot;)

 previousSec=$(echo &quot;$currentSec-3600&quot; | bc)
 previousTime=$(date + &quot;%Y%m%d %H:%M:%S&quot; --date=&quot;@$previousSec&quot;)

 echo &quot;--- $previousTime - $currentTime ---&quot;
 currentPath=$(pwd)
 workingPath=&quot;$1&quot;

 cd &quot;$workingPath&quot;
 echo &quot;now here: $workingPath&quot;

 find . -type f -newermt &quot;$previousTime&quot; ! -newermt &quot;$currentTime&quot; -print | xargs git add -v

 git commit -v -m &quot;changes from $previousTime - $currentTime&quot;

 cd &quot;$currentPath&quot;
 echo &quot;now here: $currentPath&quot;

 # wait for 1 hour
 sleep 60m
done
</code></pre>
Calling the script results in an output like the following:
<pre><code class="hljs">$ ./find-changes.sh /home/frank/data &amp; 
...
--- 20190115 14:06:29 - 20190115 15:06:29 ---
now here: .
add &#x27;.data.txt&#x27;
[master 65797bb] changes from 20190115 14:06:29 - 20190115 15:06:29
 1 file changed, 2 insertions(+), 2 deletions(-)
 create mode 100644 data.txt
now here: /home/frank/data
...
</code></pre>
In order for one to see what has changed between the single commits, they may use <a rel="nofollow" target="_blank" href="https://git-scm.com/docs/gitk">gitk</a> - a graphical repository browser - to display that.
<img class="img-responsive" alt="gitk" src="https://s3.amazonaws.com/stackabuse/media/automating-version-control-commits-1.png">
<h2 id="gitwatchandflashbake"><code>gitwatch</code> and Flashbake</h2>
In the same category of tools you'll find <a rel="nofollow" target="_blank" href="https://github.com/gitwatch/gitwatch">gitwatch</a> and <a rel="nofollow" target="_blank" href="https://pypi.org/project/flashbake/">Flashbake</a>. Basically, <code>gitwatch</code> is an extended version of the bash script from above, and also uses the <code>inotify</code> kernel subsystem. Nonetheless, <code>gitwatch</code> has not been packaged for Debian or Ubuntu yet.
Download the script from the project website on GitHub, first, and then call it from the command line with the name of the file or directory to be tracked. Here you see how it works while working on the article:
<img class="img-responsive" alt="gitwatch" src="https://s3.amazonaws.com/stackabuse/media/automating-version-control-commits-2.png">
However, the second project - Flashbake - has been in existence for a much longer time, and connects Git and Cron. Written in Python, it is available from the project website as well as a regular Debian package.
In order to track file modifications, Flashbake requires a Git repository as well as a file named <code>.flashbake</code> in it. The latter one is meant to contain the list of files to be tracked.
<pre><code class="hljs">$ cat .flashbake 

# files to track

data.txt
gitk.png
gitwatch.png
iviewdb.png
find-changes.sh
ils.png
</code></pre>
Next, an according cron entry is required to run Flashbake regularly. Use the command <code>crontab -e</code> to open the crontab file, and add the following line:
<pre><code class="hljs">*/15 * * * * flashbake /home/frank/data 15 &gt; /dev/null
</code></pre>
This entry calls Flashbake every 15 minutes, and tracks the content of the directory <code>/home/frank/data</code> (although you'll want to change this path to suit your needs). The error messages sent to <code>stdout</code> are simply redirected to the digital trash called <code>/dev/null</code>.
In order to see the changes between the commits you may either use <code>gitk</code> (see above), or use the command <code>git diff</code>.
<img class="img-responsive" alt="git-diff" src="https://s3.amazonaws.com/stackabuse/media/automating-version-control-commits-2.png">
<h2 id="conclusion">Conclusion</h2>
With the help of these tools you can figure out if, when, and especially what kind of data has changed on your system. By using Git you can resort to previous versions. It is recommended to keep space for additional data - the backup has to be stored somewhere, and on an external device, ideally.
In the context of security, in order to prevent unwanted changes it is required to work with further safety measures, for example on the level of the access rights, and the system services.
<h2 id="acknowledgements">Acknowledgements</h2>
The author would like to thank Axel Beckert, Veit Schiele, and Zoleka Hofmann for their help and critical remarks while preparing this article.

Frank Hofmann

Automating Version Control Commits

<h2 id="introduction">Introduction</h2>
Data structures organize storage in computers so that we can efficiently access and change data. Stacks and Queues are some of the earliest data structures defined in computer science.
Simple to learn and easy to implement, their uses are common and you'll most likely find yourself incorporating them in your software for various tasks.
It's common for Stacks and Queues to be implemented with an Array or <a target="_blank" href="/python-linked-lists/">Linked List</a>. We'll be relying on the <code>List</code> data structure to accommodate both Stacks and Queues.
<blockquote>
In this article, we'll go over the basics of these two data structures. We'll define what they are, and how they work, and then, we'll take a look at two of the most common ways to implement stack and queue in Python.
</blockquote>
<h2 id="whatisastack">What Is a Stack?</h2>
Stacks, as the name suggests, are a data structure that follows the Last-in-First-Out (LIFO) principle. As if stacking coins one on top of the other, the last coin we put on the top is the one that is the first to be removed from the stack later.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Another useful example to help you wrap your head around the concept of how stacks work is to imagine people getting in and out of an elevator - the last person who enters an elevator is the first to get out!

 </div>
 </div>
 </div>
 To implement a stack, therefore, we need two simple operations:
<ul>
<li><code>push</code> - adds an element to the top of the stack:</li>
</ul>
<img src="https://s3.amazonaws.com/stackabuse/media/stacks-and-queues-in-python-1.jpg" alt="Adding an item to a stack">
<ul>
<li><code>pop</code> - removes the element at the top of the stack:</li>
</ul>
<img src="https://s3.amazonaws.com/stackabuse/media/stacks-and-queues-in-python-2.jpg" alt="Removing an item from a stack">
<h2 id="whatisaqueue">What Is a Queue?</h2>
Queues, as the name suggests, follow the First-in-First-Out (FIFO) principle. As if waiting in a queue for movie tickets, the first one to stand in line is the first one to buy a ticket and enjoy the movie.
To implement a queue, therefore, we need two simple operations:
<ul>
<li><code>enqueue</code> - adds an element to the end of the queue:</li>
</ul>
<img src="https://s3.amazonaws.com/stackabuse/media/stacks-and-queues-in-python-3.jpg" alt="Adding an item to a queue">
<ul>
<li><code>dequeue</code> - removes the element at the beginning of the queue:</li>
</ul>
<img src="https://s3.amazonaws.com/stackabuse/media/stacks-and-queues-in-python-4.jpg" alt="Removing an item from a queue">
<h2 id="implementingstacksandqueuesusinglists">Implementing Stacks and Queues using Lists</h2>
Python's built-in <code>List</code> data structure comes bundled with methods to simulate both stack and queue operations.
Let's consider a stack of letters:
<pre><code class="hljs">letters = []

# Let&#x27;s push some letters into our list
letters.append(&#x27;c&#x27;)
letters.append(&#x27;a&#x27;)
letters.append(&#x27;t&#x27;)
letters.append(&#x27;g&#x27;)

# Now let&#x27;s pop letters, we should get &#x27;g&#x27;
last_item = letters.pop()
print(last_item)

# If we pop again we&#x27;ll get &#x27;t&#x27;
last_item = letters.pop()
print(last_item)

# &#x27;c&#x27; and &#x27;a&#x27; remain
print(letters) # [&#x27;c&#x27;, &#x27;a&#x27;]
</code></pre>
We can use the same functions to implement a Queue. The <code>pop</code> function optionally takes the index of the item we want to retrieve as an argument.
So we can use <code>pop</code> with the first index of the list i.e. <code>0</code>, to get queue-like behavior.
Consider a &quot;queue&quot; of fruits:
<pre><code class="hljs">fruits = []

# Let&#x27;s enqueue some fruits into our list
fruits.append(&#x27;banana&#x27;)
fruits.append(&#x27;grapes&#x27;)
fruits.append(&#x27;mango&#x27;)
fruits.append(&#x27;orange&#x27;)

# Now let&#x27;s dequeue our fruits, we should get &#x27;banana&#x27;
first_item = fruits.pop(0)
print(first_item)

# If we dequeue again we&#x27;ll get &#x27;grapes&#x27;
first_item = fruits.pop(0)
print(first_item)

# &#x27;mango&#x27; and &#x27;orange&#x27; remain
print(fruits) # [&#x27;c&#x27;, &#x27;a&#x27;]
</code></pre>
Again, here we use the <code>append</code> and <code>pop</code> operations of the list to simulate the core operations of a queue.
<h3 id="stacksandqueueswiththedequelibrary">Stacks and Queues with the Deque Library</h3>
Python has a <code>deque</code> (pronounced 'deck') library that provides a sequence with efficient methods to work as a stack or a queue.
<code>deque</code> is short for Double Ended Queue - a generalized queue that can get the first or last element that's stored:
<pre><code class="hljs">from collections import deque

# you can initialize a deque with a list 
numbers = deque()

# Use append like before to add elements
numbers.append(99)
numbers.append(15)
numbers.append(82)
numbers.append(50)
numbers.append(47)

# You can pop like a stack
last_item = numbers.pop()
print(last_item) # 47
print(numbers) # deque([99, 15, 82, 50])

# You can dequeue like a queue
first_item = numbers.popleft()
print(first_item) # 99
print(numbers) # deque([15, 82, 50])
</code></pre>

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: If you'd like to learn more about the <code>deque</code> library and other types of collections Python provides, you can read our <a target="_blank" href="/introduction-to-pythons-collections-module/">&quot;Introduction to Python's Collections Module&quot;</a> article.

 </div>
 </div>
 </div>
 <h2 id="stricterimplementationsinpython">Stricter Implementations in Python</h2>
If your code needs a stack and you provide a <code>List</code>, there's nothing stopping a programmer from calling <code>insert()</code>, <code>remove()</code> or other list methods that will affect the order of your stack! This fundamentally ruins the point of defining a stack, as it no longer functions the way it should.
There are times when we'd like to ensure that only valid operations can be performed on our data. We can create classes that only expose the necessary methods for each data structure. To do so, let's create a new file called <code>stack_queue.py</code> and define two classes:
<pre><code class="hljs"># A simple class stack that only allows pop and push operations
class Stack:

 def __init__(self):
 self.stack = []

 def pop(self):
 if len(self.stack) &lt; 1:
 return None
 return self.stack.pop()

 def push(self, item):
 self.stack.append(item)

 def size(self):
 return len(self.stack)

# And a queue that only has enqueue and dequeue operations
class Queue:

 def __init__(self):
 self.queue = []

 def enqueue(self, item):
 self.queue.append(item)

 def dequeue(self):
 if len(self.queue) &lt; 1:
 return None
 return self.queue.pop(0)

 def size(self):
 return len(self.queue) 
</code></pre>
The programmers using our <code>Stack</code> and <code>Queue</code> are now encouraged to use the methods provided to manipulate the data instead.
<h3 id="examples">Examples</h3>
Imagine you're a developer working on a brand new word processor. You're tasked with creating an undo feature - allowing users to backtrack their actions till the beginning of the session.
A stack is an ideal fit for this scenario. We can record every action the user takes by pushing it to the stack. When the user wants to undo an action they'll pop it from the stack. We can quickly simulate the feature like this:
<pre><code class="hljs">document_actions = Stack()

# The first enters the title of the document
document_actions.push(&#x27;action: enter; text_id: 1; text: This is my favorite document&#x27;)
# Next they center the text
document_actions.push(&#x27;action: format; text_id: 1; alignment: center&#x27;)
# As with most writers, the user is unhappy with the first draft and undoes the center alignment
document_actions.pop()
# The title is better on the left with bold font
document_actions.push(&#x27;action: format; text_id: 1; style: bold&#x27;)
</code></pre>
Queues have widespread uses in programming as well. Think of games like Street Fighter or Super Smash Brothers. Players in those games can perform special moves by pressing a combination of buttons. These button combinations can be stored in a queue.
Now imagine that you're a developer working on a new fighting game. In your game, every time a button is pressed, an input event is fired. A tester noticed that if buttons are pressed too quickly the game only processes the first one and special moves won't work!
You can fix that with a queue. We can enqueue all input events as they come in. This way it doesn't matter if input events come with little time between them, they'll all be stored and available for processing. When we're processing the moves we can dequeue them. A special move can be worked out like this:
<pre><code class="hljs">input_queue = Queue()

# The player wants to get the upper hand so pressing the right combination of buttons quickly
input_queue.enqueue(&#x27;DOWN&#x27;)
input_queue.enqueue(&#x27;RIGHT&#x27;)
input_queue.enqueue(&#x27;B&#x27;)

# Now we can process each item in the queue by dequeueing them
key_pressed = input_queue.dequeue() # &#x27;DOWN&#x27;

# We&#x27;ll probably change our player position
key_pressed = input_queue.dequeue() # &#x27;RIGHT&#x27;

# We&#x27;ll change the player&#x27;s position again and keep track of a potential special move to perform
key_pressed = input_queue.dequeue() # &#x27;B&#x27;

# This can do the act, but the game&#x27;s logic will know to do the special move
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Stacks and queues are simple data structures that allow us to store and retrieve data sequentially. In a stack, the last item we enter is the first to come out. In a queue, the first item we enter is the first come out.
We can add items to a stack using the <code>push</code> operation and retrieve items using the <code>pop</code> operation. With queues, we add items using the <code>enqueue</code> operation and retrieve items using the <code>dequeue</code> operation.
In Python, we can implement stacks and queues just by using the built-in <code>List</code> data structure. Python also has the <code>deque</code> library which can efficiently provide stack and queue operations in one object. Finally, we've made our stack and queue classes for tighter control of our data.
There are many real-world use cases for stacks and queues, understanding them allows us to solve many data storage problems in an easy and effective manner.

Marcus Sanatan

Dimitrije Stamenic

Stacks and Queues in Python

Robley Gori

Web Scraping the Java Way

<h2 id="introduction">Introduction</h2>
For any fully functional deployable application, the persistence of data is indispensable. A trivial way of storing data would be to write it to a file in the hard disk, but one would prefer writing the application specific data to a database for obvious reasons. Python provides language support for writing data to a wide range of databases.
<h2 id="pythondbapi">Python DB API</h2>
At the heart of Python support for database programming is the Python DB API (<a rel="nofollow" target="_blank" href="https://www.python.org/dev/peps/pep-0249/">PEP – 249</a>) which does not depend on any specific database engine. Depending on the database we use at the persistence layer, an appropriate implementation of Python DB API should be imported and used in our program. In this tutorial, we will be demonstrating how to use Python to connect to MySQL database and do transactions with it. For this, we will be using the <a rel="nofollow" target="_blank" href="https://mysqlclient.readthedocs.io/">MySQLdb</a> Python package.
Before we proceed with connecting to the database using Python, we need to install MySQL connector for Python. This can be done in two ways:
<ul>
<li>One way is to download the appropriate installer for the OS and bit version directly from the <a rel="nofollow" target="_blank" href="https://dev.mysql.com/downloads/connector/python/">MySQL official site</a>.</li>
<li>Another way is to use pip to install it.</li>
</ul>
<pre><code class="hljs">$ pip install mysql-connector-python
</code></pre>
If there is a specific MySQL version installed in the local machine, then you may need a specific MySQL connector version so that no compatibility issues arise, which we can get using the following command:
<pre><code class="hljs">$ pip install mysql-connector-python==&lt;insert_version_number_here&gt;
</code></pre>
Finally, we need to install MySQL client module that will enable us to connect to MySQL databases from our Python application, which acts as the client:
<pre><code class="hljs">$ pip install mysqlclient
</code></pre>
<h2 id="connectingtothedatabase">Connecting to the Database</h2>
Once we have the connector installed in place, the <code>import MySQLdb</code> statement should not throw any error on executing the Python file.
<h3 id="prerequisites">Prerequisites</h3>
Note: It is assumed that the readers have basic understanding of databases in general and the MySQL database in specific, along with knowledge of structured query language (SQL). However, the basic process to create a database and a user has been explained in this section. Follow these steps:
<ul>
<li>Ensure that your MySQL server is running. This can be checked via MySQL WorkBench -&gt; Server Status.</li>
<li>Open MySQL WorkBench or MySQL CLI. Create a new database. Let us call it <code>pythondb</code>.</li>
</ul>
<pre><code class="hljs">CREATE DATABASE pythondb;
USE pythondb;
</code></pre>
<ul>
<li>Create a new user <code>pythonuser</code> with password <code>pythonpwd123</code> and grant access to <code>pythondb</code></li>
</ul>
<pre><code class="hljs">CREATE USER &#x27;pythonuser&#x27;@&#x27;localhost&#x27; IDENTIFIED BY &#x27;pythonpwd123&#x27;
GRANT ALL PRIVILEGES ON pythondb.* To &#x27;pythonuser&#x27;@&#x27;localhost&#x27;
FLUSH PRIVILEGES
</code></pre>
<h3 id="checkingyourconnectiontopythondb">Checking your Connection to <code>pythondb</code></h3>
Here is a simple script that can be used to programmatically test connection to the newly created database:
<pre><code class="hljs">#!/usr/bin/python

import MySQLdb

dbconnect = MySQLdb.connect(&quot;localhost&quot;, &quot;pythonuser&quot;, &quot;pythonpwd123&quot;, &quot;pythondb&quot;)

cursor = dbconnect.cursor()
cursor.execute(&quot;SELECT VERSION()&quot;)

data = cursor.fetchone()
if data:
 print(&#x27;Version retrieved: &#x27;, data)
else:
 print(&#x27;Version not retrieved.&#x27;)

dbconnect.close()
</code></pre>
Output
<pre><code class="hljs">Version retrieved: 5.7.19
</code></pre>
The version number shown above is just a dummy number. It should match the installed MySQL server's version.
Let us take a closer look at the sample program above to learn how it works. First off, <code>import MySQLdb</code> is used to import the required python module.
<code>MySQLdb.connect()</code> method takes hostname, username, password, and database schema name to create a database connection. On successfully connecting with the database, it will return a connection object (which is referred to as <code>dbconnect</code> here).
Using the connection object, we can execute queries, commit transactions and rollback transactions before closing the connection.
Once we get the connection object, we need to get a <code>MySQLCursor</code> object in order to execute queries using the <code>execute</code> method. The result set of the transaction can be retrieved using the <code>fetchall</code>, <code>fetchone</code>, or <code>fetchmany</code> methods, which will be discussed later in this tutorial.
There are three important methods related to database transactions apart from the execute method. We will learn briefly about these methods now.
The <code>dbconnect.commit()</code> method informs the database that the changes executed before calling this function shall be finalized and there is no scope for rolling back to the previous state if the transaction is successful.
Sometimes, if a transaction failure occurs, we will need to change the database to the previous state before the failure happens so that the data is not lost or corrupted. In such a case, we will need to rollback the database to the previous state using <code>dbconnect.rollback()</code>.
Finally, the <code>dbconnect.close()</code> method is used to close the connection to the database. To perform further transactions, we need to create a new connection.
<h2 id="createanewtable">Create a New Table</h2>
Once the connection with <code>pythondb</code> is established successfully, we are ready to go to the next step. Let us create a new table in it:
<pre><code class="hljs">import MySQLdb

dbconnect = MySQLdb.connect(&quot;localhost&quot;,&quot;pythonuser&quot;,&quot;pythonpwd123&quot;,&quot;pythondb&quot; )

cursor = dbconnect.cursor()
cursor.execute(&quot;DROP TABLE IF EXISTS MOVIE&quot;)

query = &quot;CREATE TABLE MOVIE( \
 id int(11) NOT NULL,\
 name varchar(20),\
 year int(11),\
 director varchar(20),\
 genre varchar(20),\
 PRIMARY KEY (id))&quot;

cursor.execute(query)

dbconnect.close()
</code></pre>
After executing the above script, you should be able to see a new table <code>movie</code> created for the schema <code>pythondb</code>. This can be viewed using MySQL WorkBench.
<h2 id="performingcrudoperations">Performing CRUD Operations</h2>
Now we'll perform some insert, read, modify, and delete operations in the newly created database table via the Python script.
<h3 id="creatinganewrecord">Creating a New Record</h3>
The following script demonstrates how to insert a new record into MySQL database using a Python script:
<pre><code class="hljs">#!/usr/bin/python

import MySQLdb

dbconnect = MySQLdb.connect(&quot;localhost&quot;, &quot;pythonuser&quot;, &quot;pythonpwd123&quot;, &quot;pythondb&quot;)

cursor = dbconnect.cursor()

query = &#x27;insert into movie(id, name, year, director, genre) \
 values (1, &quot;Bruce Almighty&quot;, 2003, &quot;Tom Shaydac&quot;, &quot;Comedy&quot;)&#x27;
try:
 cursor.execute(query)
 dbconnect.commit()
except:
 dbconnect.rollback()
finally:
 dbconnect.close()
</code></pre>
<h3 id="readingrowsfromatable">Reading Rows from a Table</h3>
Once a new row is inserted in the database, you can fetch the data in three ways using the cursor object:
<ul>
<li><code>cursor.fetchall()</code> – can be used to get all rows</li>
<li><code>cursor.fetchmany()</code> – can be used to get a selected number of rows</li>
<li><code>cursor.fetchone()</code> – can be used to get only the first row from the result set</li>
</ul>
For simplicity, we will use the &quot;select all&quot; SQL query and use a for loop over the result set of the <code>fetchall</code> method to print individual records.
<pre><code class="hljs">#!/usr/bin/python

import MySQLdb

dbconnect = MySQLdb.connect(&quot;localhost&quot;, &quot;pythonuser&quot;, &quot;pythonpwd123&quot;, &quot;pythondb&quot;)

cursor = dbconnect.cursor()

query = &quot;SELECT * FROM movie&quot;
try:
 cursor.execute(query)
 resultList = cursor.fetchall()
 for row in resultList:
 print (&quot;Movie ID =&quot;, row[0])
 print (&quot;Name =&quot;, row[1])
 print (&quot;Year =&quot;, row[2])
 print (&quot;Director = &quot;, row[3])
 print (&#x27;Genre = &#x27;, row[4])
except:
 print (&quot;Encountered error while retrieving data from database&quot;)
finally:
 dbconnect.close()
</code></pre>
Output:
<pre><code class="hljs">Movie ID = 1
Name = Bruce Almighty
Year = 2003
Director = Tom Shaydac
Genre = Comedy
</code></pre>
<h3 id="updatingarow">Updating a Row</h3>
Let us now update the Genre of &quot;Bruce Almighty&quot; from Comedy to Satire:
<pre><code class="hljs">import MySQLdb

dbconnect = MySQLdb.connect(&quot;localhost&quot;, &quot;pythonuser&quot;, &quot;pythonpwd123&quot;, &quot;pythondb&quot;)

# The cursor object obtained below allows SQL queries to be executed in the database session.
cursor = dbconnect.cursor()

updatequery = &quot;update movie set genre = &#x27;Satire&#x27; where id = 1&quot;

cursor.execute(updatequery)

dbconnect.commit()

print(cursor.rowcount, &quot;record(s) affected&quot;)
</code></pre>
Output:
<pre><code class="hljs">1 record(s) affected
</code></pre>
<h3 id="deletingarecord">Deleting a Record</h3>
Here is a Python script that demonstrates how to delete a database row:
<pre><code class="hljs">import MySQLdb

dbconnect = MySQLdb.connect(&quot;localhost&quot;, &quot;pythonuser&quot;, &quot;pythonpwd123&quot;, &quot;pythondb&quot;)

# The cursor object obtained below allows SQL queries to be executed in the database session.
cursor = dbconnect.cursor()

updatequery = &quot;DELETE FROM movie WHERE id = 1&quot;

cursor.execute(updatequery)

dbconnect.commit()

print(cursor.rowcount, &quot;record(s) deleted&quot;)
</code></pre>
After executing the above script, you should be able to see the following output if everything goes well.
Output
<pre><code class="hljs">1 record(s) deleted
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we learned how to use the Python DB API to connect to a database. Specifically, we saw how a connection can be established to a MySQL database using the MySQLdb implementation of Python DB API. We also learned how to perform transactions with the database.

Guest Contributor

Getting Started with MySQL and Python

<h2 id="introduction">Introduction</h2>
<a rel="nofollow" target="_blank" href="https://router.vuejs.org">Vue-Router</a> is a JavaScript package which allows you to set up routing for Single Page Applications (SPA).
SPA refers to a web application which only serves a single <code>index.html</code> page and renders content dynamically, being this the way modern JavaScript frameworks such as <a rel="nofollow" target="_blank" href="https://reactjs.org/">React.js</a> or <a rel="nofollow" target="_blank" href="https://vuejs.org/">Vue.js</a> are most likely setup.
<h2 id="whyusevuerouter">Why use Vue-Router?</h2>
Using a SPA has a lot of advantages, but one of the main caveats is that all the components of the web page are being delivered, added or removed via JavaScript with no extra HTML pages being fetched from the server. This is what SPA's are all about, but the main issue is being able to navigate through &quot;pages&quot; as users are accustomed to with most websites.
This is where Vue-Router kicks in!
<h2 id="installationandsetup">Installation and Setup</h2>
If you are using <a target="_blank" href="/getting-started-with-vue-cli-3-x/">Vue CLI</a>, you might have already encountered a situation where you're asked if you want to include Vue-Router to the project configuration.
Vue-Router can easily be installed using your preferred package manager, be it NPM or Yarn:
<pre><code class="hljs">$ npm install vue-router
OR
$ yarn add vue-router
</code></pre>
This will add <code>vue-router</code> to your <code>package.json</code> file and you are good to go.
It's recommended to write router related code inside a separate file called <code>router.js</code> and add it to the Vue application inside the <code>main.js</code> file:
<pre><code class="hljs">import Vue from &#x27;vue&#x27;
import App from &#x27;./App&#x27;
import Router from &#x27;./router // Router being imported

Vue.config.productionTip = false

/* eslint-disable no-new */
new Vue({
 el: &#x27;#app&#x27;,
 router: Router, // Router added to the Vue instance
 components: { App },
 template: &#x27;&lt;App/&gt;&#x27;
})
</code></pre>
<h2 id="therouterjsfilecreatingroutes">The router.js File: Creating Routes</h2>
Firstly we need to import <code>router</code> from the Vue-Router package, and add it to Vue as a plugin with the method <code>use</code>.
After that, we treat the router as an object, which will hold all the routes. And of course, we have to export it so the rest of the application can access it.
<pre><code class="hljs">import Vue from &#x27;vue&#x27;
import Router from &#x27;vue-router&#x27;

Vue.use(Router)

export default new Router({
 routes: []
})
</code></pre>
The <code>routes</code> property is an array which will hold objects, each of which will be the specific routes for your web page. The most basic one would look like this:
<pre><code class="hljs"> const Home = { template: &#x27;&lt;div&gt;Welcome to Stack Abuse!&lt;/div&gt;&#x27; }
 routes: [
 {
 path: &#x27;/&#x27;,
 name: &#x27;Home&#x27;,
 component: Home
 }
 ]
</code></pre>
Vue-Router accepts plentiful properties for it is routed objects:
<ul>
<li>
<code>path</code>: This is the relative path to the base route of your web application where you want a certain component being rendered on.
</li>
<li>
<code>name</code>: The name property will be useful when referring to this particular object inside your Vue components.
</li>
<li>
<code>component</code>: With this property, a Vue component will be injected into the route path you assign.
</li>
<li>
<code>redirect</code>: A component route can be redirected to another route when it gets matched.
</li>
<li>
<code>alias</code>: Pretty similar to redirect, but whenever you enter the alias path, the router will show the router root path.
</li>
</ul>
<pre><code class="hljs">const router = new VueRouter({
 routes: [
 { 
 path: &#x27;/users&#x27;, 
 component: Users, 
 alias: &#x27;/alias&#x27; // When entering &#x27;/alias&#x27; the content of the component Users will render
 }
 ]
})
</code></pre>
<ul>
<li><code>children</code>: This is an array with more routes which will be concatenated to the path whilst keeping the parent path in the URL.</li>
</ul>
<pre><code class="hljs">const router = new VueRouter({
 routes: [
 { 
 path: &#x27;/users/&#x27;, 
 component: Users,
 children: [
 {
 // when /users/profile gets matched
 path: &#x27;profile&#x27;,
 component: UserProfile
 },
 {
 // when /users/info gets matched
 path: &#x27;info&#x27;,
 component: UserInfo
 }
 ]
 }
 ]
})
</code></pre>
<ul>
<li>
<code>params</code>: These are properties or certain information that could be passed to the component.
</li>
<li>
<code>meta</code>: Whenever a route (or multiple routes) are matched to the path, the meta property will be available. This is especially useful when using navigation guards.
</li>
</ul>
We can also add a <code>mode</code> property to the <code>Router</code> object. By default, Vue-Router is set up to <code>hash</code> mode, which means all URLs will have a <code>#</code> at the end. This can be removed, as you most likely will want, by setting the <code>mode</code> property to <code>history</code>:
<pre><code class="hljs">export default new Router({ 
 mode: &#x27;history&#x27;,
 routes: []
})
</code></pre>
This mode comes with a problem though. Without a proper configuration, accessing, for an example, <code>http://localhost:8080/user/id</code>, directly in their browser will result in a 404 error.
To fix this, you need to add a simple fallback route to your server. If the path does not match any static assets, it should serve the same <code>index.html</code>.
For example, if you would want to setup history mode inside a Node.js server this could be set up:
<pre><code class="hljs">const http = require(&#x27;http&#x27;)
const fs = require(&#x27;fs&#x27;)
const httpPort = 80

http.createServer((req, res) =&gt; {
 fs.readFile(&#x27;index.htm&#x27;, &#x27;utf-8&#x27;, (err, content) =&gt; {
 if (err) {
 console.log(&#x27;We cannot open &quot;index.htm&quot; file.&#x27;)
 }

 res.writeHead(200, {
 &#x27;Content-Type&#x27;: &#x27;text/html; charset=utf-8&#x27;
 })

 res.end(content)
 })
}).listen(httpPort, () =&gt; {
 console.log(&#x27;Server listening on: http://localhost:%s&#x27;, httpPort)
})
</code></pre>
<h2 id="accessingtherouterfromacomponent">Accessing the Router from a Component</h2>
Given a particular component, you can access the router object with the <code>$</code> notation in order to react to user input or being able to render routes depending on a certain condition.
To have the Vue-Router routes be rendered you will need to pass the <code>&lt;router-view&gt;</code> tag inside a Vue component.
You could also access the routes from an <code>&lt;a&gt;</code> tag, but this will trigger a page re-render, to avoid this behavior you could use <code>router-link</code> with the <code>to</code> property instead of a <code>href</code>. This special tag tells the router to navigate to the given &quot;page&quot;.
<pre><code class="hljs">&lt;template&gt;
 &lt;div&gt;
 &lt;h3&gt; Vue Router - Stack Abuse &lt;/h3&gt;
 &lt;h4&gt; { $router.params.id } &lt;/h4&gt;
 &lt;button @click=&quot;goBack&quot;&gt; Go Back &lt;/button&gt;
 &lt;router-view&gt;&lt;/router-view&gt;
 &lt;router-link :to=&quot;/users&quot;&gt; Users Route &lt;/router-link&gt;
 &lt;/div&gt;
&lt;/template&gt;

export default {
 methods: {
 goBack () {
 this.$router.go(-1)
 }
 }
}
</code></pre>
The router object has certain methods attached to it, which will help you redirect your application to the desired URL:
<ul>
<li>
<code>$router.go()</code>: Takes a number as a parameter which refers to the number of positions you want to go forward or behind inside the browser history stack array.
</li>
<li>
<code>$router.push()</code>: This function can take a string, referring to the name or path of the route you want to access, or an object with the route configuration.
</li>
</ul>
<pre><code class="hljs">router.push(
 { 
 name: &#x27;users&#x27;
 params: { id: 1 }
 }
)
</code></pre>
<ul>
<li><code>$router.replace()</code>: Pretty much the same as push, instead of that other than adding a new entry to the browser history stack, it replaces the current one with the one we are adding.</li>
</ul>
<h3 id="routeguards">Route Guards</h3>
Most applications need a way to forbid access to certain routes. This can be easily done with route guards, which we discussed previously when talking about the <code>meta</code> property.
Each route has a navigation resolution flow, and there are certain hooks that can be used for your benefit.
<ul>
<li><code>beforeEach</code>: Certainly the most useful one when needing a global guard to keep users out of restricted areas, you can set up a callback function which will receive <code>to</code>, <code>from</code>, <code>next</code> from the <code>beforeEach</code> function which lets you know, where you are navigation from, and to, as well as the next step to take:</li>
</ul>
<pre><code class="hljs">router.beforeEach((to, from, next) =&gt; {
 if (to.matched.some(record =&gt; record.meta.auth)) {
 if (!userIsLoggedIn)
 next(&#x27;/&#x27;)
 console.log(&#x27;Not allowed here&#x27;)
 } else {
 next(&#x27;/secret-endpoint&#x27;)
 }
 }
})
</code></pre>
<ul>
<li>
<code>beforeEnter</code>: Gets triggered before a user enters a certain route.
</li>
<li>
<code>afterEach</code>: This gets called whenever navigation has been successful for each route.
</li>
</ul>
<h3 id="conclusion">Conclusion</h3>
Vue-Router is a must-have tool if you build any Vue.js Single Page Applications, it gives you the flexibility to manage the user's navigation to the fullest.
You can always get more information visiting the <a rel="nofollow" target="_blank" href="https://router.vuejs.org/">Vue-Router official page</a>.

Spring Data: MongoDB Tutorial

Automating Version Control Commits

Stacks and Queues in Python

Web Scraping the Java Way

Getting Started with MySQL and Python

Vue-Router: Navigating Vue.js Apps

Dockerizing Python Applications

Spring Security: Email Verification Registration

Spring Custom Password Validation