Leandro Cofre

In this tutorial, we'll set up an H2 database in Node.js and Express and code the CRUD functionality for a REST API.

Integrating H2 with Node.js and Express

<h2 id="introduction">Introduction</h2>
In this article, we are going to take a look at what CORS is, how you can configure CORS with Express, and how to customize the CORS middleware to your needs.
<h2 id="whatiscors">What is CORS</h2>
CORS is shorthand for Cross-Origin Resource Sharing. It is a mechanism to allow or restrict requested resources on a web server depending on where the HTTP request was initiated.
This policy is used to secure a certain web server from access by other websites or domains. For example, only the allowed domains will be able to access hosted files in a server such as a stylesheet, image, or a script.
If you are currently on <code>http://example.com/page1</code> and you are referring an image from <code>http://image.com/myimage.jpg</code> you won't be able to fetch that image unless <code>http://image.com</code> allows cross-origin sharing with <code>http://example.com</code>.
There is an HTTP header called <code>origin</code> in each HTTP request. It defines where the domain request has originated from. We can use header information to restrict or allow resources from our web server to protect them.
<blockquote>
By default requests from any other origins will be restricted by the browser.
</blockquote>
For example, while you are still in the development stage - if you are using a frontend library such as React, your front end application will be served on <code>http://localhost:3000</code>. Meanwhile, your Express server might be running on a different port such as <code>http://localhost:2020</code>.
Because of this, you'll need to allow CORS between those servers.
If you see this common error in your browser console. CORS restrictions could be the issue:
<img src="https://stackabuse.s3.amazonaws.com/media/handling-cors-with-node-js-1.png" alt="chrome cors">
CORS is really useful when you're offering a public API and would like to control the access to certain resources and how people use them.
Also, if you want to use your own API or files on a different web page you can simply configure CORS to allow that, while still blocking others out.
<h2 id="configuringcorswithexpress">Configuring CORS with Express</h2>
Let's start off with a fresh project. We'll make a directory for it, enter it and run <code>npm init</code> with the default settings:
<pre><code class="hljs">$ mkdir myapp
$ cd myapp
$ npm init -y
</code></pre>
Then let's install the required modules. We'll be using <code>express</code> and the <code>cors</code> middleware:
<pre><code class="hljs">$ npm i --save express
$ npm i --save cors
</code></pre>
Then let's start creating an express web application with two routes to demonstrate how CORS works.
We'll make a file, called <code>index.js</code> that acts as a web server, with a couple of request handlers:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
const cors = require(&#x27;cors&#x27;);

const app = express();

app.get(&#x27;/&#x27;, (req, res) =&gt; {
 res.json({
 message: &#x27;Hello World&#x27;
 });
});

app.get(&#x27;/:name&#x27;, (req, res) =&gt; {
 let name = req.params.name;

 res.json({
 message: `Hello ${name}`
 });
});

app.listen(2020, () =&gt; {
 console.log(&#x27;server is listening on port 2020&#x27;);
});
</code></pre>
Let's run the app and the server:
<pre><code class="hljs">$ node index.js
</code></pre>
Now, if you go to <code>http://localhost:2020/</code> - the server should return a JSON message:
<pre><code class="hljs">{
 &quot;message&quot;: &quot;Hello World&quot;
}
</code></pre>
Alternatively, if you go to <code>http://localhost:2020/something</code> you should see:
<pre><code class="hljs">{
 &quot;message&quot;: &quot;Hello something&quot;
}
</code></pre>
<h2 id="enableallcorsrequests">Enable All CORS Requests</h2>
If you want to enable CORS for all the request you can simply use the <code>cors</code> middleware before configuring your routes:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
const cors = require(&#x27;cors&#x27;);

const app = express();

app.use(cors())

......
</code></pre>
This will allow all the routes to be accessed anywhere on the web if that is what you need. So in our example, both routes will be accessible for every domain.
For example, if our server is running on <code>http://www.example.com</code> and serves content such as images - we allow other domains, such as <code>http://www.differentdomain.com</code> to refer the content from <code>http://www.example.com</code>.
Thus, a web page on <code>http://www.differentdomain.com</code> can use our domain as a source for an image:
<pre><code class="hljs">&lt;img src=&quot;http://www.example.com/img/cat.jpg&quot;&gt;
</code></pre>
<h2 id="enablecorsforasingleroute">Enable CORS for a Single Route</h2>
But if you need a certain route to be accessible and not other routes, you can configure <code>cors</code> in a certain route as a middleware instead of configuring it to the whole app:
<pre><code class="hljs">app.get(&#x27;/&#x27;, cors(), (req, res) =&gt; {
 res.json({
 message: &#x27;Hello World&#x27;
 });
});
</code></pre>
This will allow a certain route to be accessible by any domain. So in your case, only the <code>/</code> route will be accessible for every domain. The <code>/:name</code> route will be only accessible for the requests that are initiated in the same domain as the API which is <code>http://localhost:2020</code> in our case.
For example, if you try to send a fetch request to the <code>/</code> path from a different origin - it will be successful and you will get the <code>Hello World</code> message as the response:
<pre><code class="hljs">fetch(&#x27;http://localhost:2020/&#x27;)
 .then(response =&gt; response.json())
 .then(data =&gt; console.log(data))
 .catch(err =&gt; console.error(err));
</code></pre>
You should see the response from the server is successfully logged into the console if you run this code:
<pre><code class="hljs">{
 message: &#x27;Hello World&#x27;
}
</code></pre>
But if you try to access any other path other than the root path such as <code>http://localhost:2020/name</code> or <code>http://localhost:2020/img/cat.png</code> this request will be blocked by the browser:
<pre><code class="hljs">fetch(&#x27;http://localhost:2020/name/janith&#x27;)
 .then(response =&gt; response.json())
 .then(data =&gt; console.log(data))
 .catch(err =&gt; console.error(err));
</code></pre>
You should see the following error if you try to run this code in a different web app:
<img src="https://stackabuse.s3.amazonaws.com/media/handling-cors-with-node-js-2.png" alt="console error">
<h2 id="configurecorswithoptions">Configure CORS with Options</h2>
You can also use the configuration options with CORS to customize this further. You can use configuration to allow a single domain or subdomain access, configure HTTP methods that are allowed such as <code>GET</code> and <code>POST</code> depending on your requirements.
Here is how you can allow a single domain access using CORS options:
<pre><code class="hljs">var corsOptions = {
 origin: &#x27;http://localhost:8080&#x27;,
 optionsSuccessStatus: 200 // For legacy browser support
}

app.use(cors(corsOptions));
</code></pre>
If you configure the domain name in the origin - the server will allow CORS from the configured domain. So the API will be accessible from <code>http://localhost:8080</code> in our case and blocked for other domains.
If we send a <code>GET</code> request, accessing any path should work, since the options are applied at app-level, not at function-level.
So, if we run the following code and send a request from <code>http://localhost:8080</code> to <code>http://localhost:2020</code>:
<pre><code class="hljs">fetch(&#x27;http://localhost:2020/&#x27;)
 .then(response =&gt; response.json())
 .then(data =&gt; console.log(data))
 .catch(err =&gt; console.error(err));

// Or

fetch(&#x27;http://localhost:2020/name/janith&#x27;)
 .then(response =&gt; response.json())
 .then(data =&gt; console.log(data))
 .catch(err =&gt; console.error(err));
</code></pre>
We're allowed to fetch the information from that application and domain.
You can also configure allowed HTTP methods if you'd like:
<pre><code class="hljs">var corsOptions = {
 origin: &#x27;http://localhost:8080&#x27;,
 optionsSuccessStatus: 200 // For legacy browser support
 methods: &quot;GET, PUT&quot;
}

app.use(cors(corsOptions));
</code></pre>
If we send a <code>POST</code> request from <code>http://localhost:8080</code>, it'll be blocked by the browser as only <code>GET</code> and <code>PUT</code> are supported:
<pre><code class="hljs">fetch(&#x27;http://localhost:2020&#x27;, {
 method: &#x27;POST&#x27;,
 body: JSON.stringify({name: &quot;janith&quot;}),
})
.then(response =&gt; response.json())
.then(data =&gt; console.log(data))
.catch(err =&gt; console.error(err));
</code></pre>
To see a full list of configuration options, please refer the <a rel="nofollow noopener" target="_blank" href="<https://www.npmjs.com/package/cors#configuration-options>">official documentation</a>.
<h2 id="configuringdynamiccorsoriginsusingafunction">Configuring Dynamic CORS Origins using a Function</h2>
If configurations do not satisfy your requirements, you can create your function to customize CORS.
For example, let's assume that you want to allow CORS sharing for <code>.jpg</code> files <code>http://something.com</code> and <code>http://example.com</code>:
<pre><code class="hljs">const allowlist = [&#x27;http://something.com&#x27;, &#x27;http://example.com&#x27;];

 const corsOptionsDelegate = (req, callback) =&gt; {
 let corsOptions;

 let isDomainAllowed = whitelist.indexOf(req.header(&#x27;Origin&#x27;)) !== -1;
 let isExtensionAllowed = req.path.endsWith(&#x27;.jpg&#x27;);

 if (isDomainAllowed &amp;&amp; isExtensionAllowed) {
 // Enable CORS for this request
 corsOptions = { origin: true }
 } else {
 // Disable CORS for this request
 corsOptions = { origin: false }
 }
 callback(null, corsOptions)
}

app.use(cors(corsOptionsDelegate));
</code></pre>
The callback function will accept two parameters. The first one is an error where we passed <code>null</code> and the second one is options where we passed <code>{ origin: false }</code>. The second parameter could be many options that are constructed using the <code>request</code> object from the Express request handler.
So a web app which is hosted on <code>http://something.com</code> or <code>http://example.com</code> would be able to refer to an image with <code>.jpg</code> extension from the server as we have configured in our custom function.
So the following image attachment will be successful from either of these:
<pre><code class="hljs">&lt;img src=&quot;http://yourdomain.com/img/cat.jpg&quot;&gt;
</code></pre>
But the following attachment will be blocked:
<pre><code class="hljs">&lt;img src=&quot;http://yourdomain.com/img/cat.png&quot;&gt;
</code></pre>
<h2 id="loadinglistofallowedoriginsfromasdatasource">Loading List of Allowed Origins from as Data Source</h2>
You can use also use a list of allowed domains from a database or using any backing data source to allow CORS:
<pre><code class="hljs">var corsOptions = {
 origin: function (origin, callback) {
 // Loading a list of allowed origins from the database
 // Ex.. origins = [&#x27;http://example.com&#x27;, &#x27;http//something.com&#x27;]
 database.loadOrigins((error, origins) =&gt; {
 callback(error, origins);
 });
 }
}

app.use(cors(corsOptions));
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered what CORS is and how you can configure it with Express. Then, we've set up CORS for all requests, for specific requests, added options and restrictions as well as defined a custom function for dynamic CORS configuration.

Janith Kasun

In this article, we'll set up CORS with Express and Node.js and configure it for single routes, all routes and allow for dynamic configuration.

Handling CORS with Node.js

<h2 id="introduction">Introduction</h2>
Command line arguments (parameters) are strings of text used to pass additional information to a program when an application is run through the <a target="_blank" href="https://en.wikipedia.org/wiki/Command-line_interface">command line interface</a> (CLI) of an operating system.
In this tutorial, we'll be accessing the arguments (parameters) passed into the main method of a Java application and reading them. We'll also map them to different data types so that we can handle them and alter the flow of the code based on the input.
<h2 id="accessingcommandlinearguments">Accessing Command Line Arguments</h2>
The entry-point for every Java program is the <code>main()</code> method:
<pre><code class="hljs">public static void main(String[] args) {
 // Do something
}
</code></pre>
The arguments passed to the program as it was initialized are stored in the <code>args</code> array. Alternatively, Java also supports a vararg in this place:
<pre><code class="hljs">public static void main(String... args) {
 // Do something
}
</code></pre>
That being said, we can easily access each argument passed into this method. Let's start out by printing them out, one by one:
<pre><code class="hljs">public class Main {
public static void main(String[] args) {
 for (int i = 0; i &lt; args.length; i++)
 System.out.println(String.format(&quot;Argument %d: %s&quot;, i, args[i]));
 }
}
</code></pre>
We'll then compile this <code>.java</code> file:
<pre><code class="hljs">javac Main.java
</code></pre>
After which, we can run it:
<pre><code class="hljs">java Main Hello World
</code></pre>
This results in:
<pre><code class="hljs">Argument 0: Hello
Argument 1: World
</code></pre>
<h2 id="mappingargumentstodatatypes">Mapping Arguments to Data Types</h2>
The arguments themselves are an array of Strings. So really, everything we pass is a String. Though, we can convert Strings into different data types as well:
<pre><code class="hljs">java Main Hello 15 true 
</code></pre>
This prints out:
<pre><code class="hljs">Argument 0: Hello
Argument 1: 15
Argument 2: true
</code></pre>
Say we wanted to allow the users to print a String a set number of times, and have a flag that toggles a log message that displays the number of the iteration. The arguments provided above would thus print <code>Hello</code> 15 times, with a log message on each <code>print()</code> statement.
Let's do that:
<pre><code class="hljs">public class Main {
 public static void main(String[] args) {

 String s = &quot;&quot;;
 int n = 0;
 boolean flag = false;

 try {
 s = args[0];
 } catch (Exception e) {
 System.out.println(&quot;The first argument must be present.&quot;);
 System.exit(1);
 }
 try {
 n = Integer.parseInt(args[1]);
 } catch (NumberFormatException e) {
 System.out.println(&quot;The second argument must be an integer.&quot;);
 System.exit(1);
 }

 try {
 flag = Boolean.parseBoolean(args[2]);
 } catch (Exception e) {
 System.out.println(&quot;The third argument must be parseable to boolean.&quot;);
 System.exit(1);
 }

 for (int i = 0; i &lt; n; i++) {
 System.out.println(s);
 if (flag)
 System.out.println(String.format(&quot;Iteration %d&quot;, i));
 }
 }
}
</code></pre>
Now, let's compile the code again:
<pre><code class="hljs">javac Main.java
</code></pre>
And then, let's run it with no arguments:
<pre><code class="hljs">java Main
</code></pre>
We're greeted with:
<pre><code class="hljs">The first argument must be present.
</code></pre>
If we provide the arguments:
<pre><code class="hljs">java Main Hello 5 true
</code></pre>
We'll be greeted with:
<pre><code class="hljs">Hello
Iteration 0
Hello
Iteration 1
Hello
Iteration 2
Hello
Iteration 3
Hello
Iteration 4
</code></pre>
<h2 id="settingargumentsinides">Setting Arguments in IDEs</h2>
This assumes that you run the code through the command line, which isn't always the case. Most people use IDEs to work on their projects, which have a convenient &quot;Run&quot; button instead.
Thankfully, you can tell the IDE to pass these arguments into the run call. Here are examples of how you can do that with some popular IDEs:
<h3 id="eclipse">Eclipse</h3>
Under &quot;Run&quot;-&gt;&quot;Run Configurations&quot;:
<img src="https://stackabuse.s3.amazonaws.com/media/command-line-arguments-in-java-1.PNG" alt="Eclipse set arguments">
<h3 id="intellij">IntelliJ</h3>
Under &quot;Run&quot;-&gt;&quot;Edit Configurations&quot;:
<img src="https://stackabuse.s3.amazonaws.com/media/command-line-arguments-in-java-2.PNG" alt="IntelliJ Setting arguments">
<h2 id="conclusion">Conclusion</h2>
In this article, we've taken a look at how we can access the command line arguments passed into a Java application when it's run.
Then, we've mapped the passed arguments into different data types and handled them accordingly. With this in mind, it's easy to create simple CLI tools and alter the flow of code based on the passed arguments.

David Landup

In this tutorial, we'll be handling command line arguments in Java. We'll access and read them, as well as map the arguments to data types to alter the flow of code.

Command Line Arguments in Java - Accessing and Mapping to Data Types

<h2 id="introduction">Introduction</h2>
Text translation is a difficult computer problem that gets better and easier to solve every year. Big companies like Google are actively working on improving their text translation services which enables the rest of us to use them freely.
Apart from their great personal use, these services can be used by developers through various APIs. This article is about <code>TextBlob</code> which uses one such API to perform text translation.
<h2 id="whatistextblob">What is TextBlob?</h2>
<code>TextBlob</code> is a text-processing library written in Python. According to its <a rel="nofollow noopener" target="_blank" href="https://textblob.readthedocs.io/en/dev/">documentation</a>, it can be used for part-of-speech tagging, parsing, sentiment analysis, spelling correction, translation, and more. In this article, we'll focus on text translation.
Internally, <code>TextBlob</code> relies on Google Translate's API. This means that an active Internet connection is required for performing translations.
<h2 id="installingtextblob">Installing TextBlob</h2>
Let's start off by installing <code>TextBlob</code> using <code>pip</code>, and downloading the corpora of words it needs to function:
<pre><code class="hljs">$ pip install -U textblob
$ python -m textblob.download_corpora
</code></pre>
<h2 id="usingtextblob">Using TextBlob</h2>
Using <code>TextBlob</code> is straightforward and simple. We just import it, assign a string to the constructor and then translate it via the <code>translate()</code> function:
<pre><code class="hljs">from textblob import TextBlob

blob = TextBlob(&quot;Buongiorno!&quot;)
print(blob.translate(to=&#x27;en&#x27;))
</code></pre>
The <code>translate()</code> function accepts two arguments - <code>from_lang</code> and <code>to</code>. The <code>from_lang</code> is automatically set depending on the language TextBlob detects.
The above example uses the Italian phrase <code>Buongiorno</code> which translates to <code>Good morning</code> in English.
Sometimes, we might wish to detect a language to decide if the text needs translation at all. To detect the language of some text, <code>TextBlob</code>'s <code>detect_language()</code> function is used:
<pre><code class="hljs">from textblob import TextBlob

blob = TextBlob(&quot;Buongiorno!&quot;)
if (blob.detect_language() != &#x27;en&#x27;)
 blob.translate(to=&#x27;en&#x27;))
</code></pre>
<h2 id="translationexamplesandaccuracy">Translation Examples and Accuracy</h2>
<h3 id="sentencetranslationfromenglishintohindi">Sentence Translation From English into Hindi</h3>
As our first example, we'll see how well English is translated into Hindi:
<pre><code class="hljs">blob = TextBlob(&#x27;TextBlob is a great tool for developers&#x27;)
print(blob.translate(to=&#x27;hi&#x27;))
</code></pre>
The result is the following:
<pre><code class="hljs">डेवलपर्स के लिए एक बढ़िया टूल है
</code></pre>
<h3 id="translatingrussianpoetryintocroatian">Translating Russian Poetry into Croatian</h3>
Let's see how TextBlob manages poetry. The following is the work of a Russian poet Vladimir Mayakovsky, first in Russian and then in English:
<pre><code class="hljs">Послушайте! 
Ведь, если звезды зажигают - 
значит - это кому-нибудь нужно? 
Значит - кто-то хочет, чтобы они были? 
Значит - кто-то называет эти плевочки 
жемчужиной?
</code></pre>
<pre><code class="hljs">Listen! 
See, if stars light up 
does it mean that there is someone who needs it? 
Does it mean that someone wants them to exist? 
It means that someone calls these little spits 
magnificent.
</code></pre>
We'll feed the original poem in Cyrillic to <code>TextBlob</code> and see how well it translates into Croatian. Since both Russian and Croatian and Slavic languages, the translation is expected to be relatively good:
<pre><code class="hljs">from textblob import TextBlob

poem = &#x27;Послушайте! Ведь, если звезды зажигают - значит - это кому-нибудь нужно? Значит - кто-то хочет, чтобы они были? Значит - кто-то называет эти плевочки жемчужиной?&#x27;

blob = TextBlob(poem)
print(blob.translate(to=&#x27;hr&#x27;))
</code></pre>
By running the above code, we get the following output (formatted for convenience):
<pre><code class="hljs">Slušati!
Uostalom, ako su zvijezde upaljene
znači li to nekome treba?
Dakle - netko želi da to budu?
Dakle - netko naziva ove pljuvačke
biserom?
</code></pre>
Most of the translation is good except for the first word which would sound better if it were <code>Slušajte</code> instead of <code>Slušati</code>, in vocative. Although not perfect, you could understand the translation.
<h3 id="translatingarrayofgermanwordsintoenglish">Translating Array of German Words into English</h3>
In some cases, we won't have full sentences to translate. We might have a list or an array of words. These are a lot easier to translate, since there's no context to potentially change the translation:
<pre><code class="hljs">from textblob import TextBlob

worter = [&#x27;einer&#x27;, &#x27;zwei&#x27;, &#x27;drei&#x27;, &#x27;vier&#x27;, &#x27;fünf&#x27;, &#x27;sechs&#x27;, &#x27;sieben&#x27;, &#x27;acht&#x27;, &#x27;neun&#x27;, &#x27;zehn&#x27;]

for w in worter:
 blob = TextBlob(w)
 print(blob.translate(to=&#x27;en&#x27;))
</code></pre>
The result is:
<pre><code class="hljs">one
two
three
four
five
six
seven
eight
nine
ten
</code></pre>
Looks good!
<h3 id="translatingfoodfromenglishintofrench">Translating Food from English into French</h3>
Finally, let's translate an English word into French:
<pre><code class="hljs">from textblob import TextBlob

blob = TextBlob(&#x27;An apple&#x27;)
print(blob.translate(to=&#x27;fr&#x27;))
</code></pre>
The French translation is <code>Une pomme</code>. Bon Appétit!
<h2 id="conclusion">Conclusion</h2>
Translation is an interesting but difficult computer problem. Deep learning and other AI methods are becoming increasingly good at understanding language and performing automated language translation. <code>TextBlob</code> is one of the tools available to developers that can be used for performing such automated language translations.
There are many benefits to this kind of approach, however, not all translations are perfect. These techniques are still evolving and if you're in need of a high-quality translation of great importance, it is always best to consult with a professional translator.
For all other purposes, however, tools such as <code>TextBlob</code> are more than enough to provide convenience for simple translation and satisfy the curiosity of developers using them.

Luka Čupić

In this tutorial, we'll use TextBlob with Python to perform translation of strings and words through various languages.

Translating Strings in Python with TextBlob

In this tutorial, we'll use the JayDeBeApi package to connect Python to the H2 Database driver. We've created a RESTful Flask application with CRUD capabilities.

Integrating H2 with Python and Flask

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll be reading a file into a String in Java. There are a few ways we can read the textual contents of a file.
Here's a list of all the classes and methods we'll go over:
<ul>
<li><a href="#files.lines">Files.lines()</a></li>
<li><a href="#files.readstring">Files.readString()</a></li>
<li><a href="#files.readallbytes">Files.readAllBytes()</a></li>
<li><a href="#filereader">FileReader</a></li>
<li><a href="#bufferedreader">BufferedReader</a></li>
<li><a href="#scanner">Scanner</a></li>
</ul>
<h2 id="fileslines">Files.lines()</h2>
The <code>Files</code> class contains static methods for working with files and directories. A useful method is <code>lines()</code> which returns a stream of strings: <code>Stream&lt;String&gt;</code>. From this stream, one can obtain lines contained in a file.
The method accepts a <code>Path</code> to the file we'd like to read with an optional <code>Charset</code>. We'll use <a target="_blank" href="/the-try-with-resources-statement-in-java"><code>try-with-resources</code></a> syntax to automate flushing and closing:
<pre><code class="hljs">Path path = Paths.get(&quot;input.txt&quot;);

try (Stream&lt;String&gt; stream = Files.lines(path, StandardCharsets.UTF_8)) {
 stream.forEach(System.out::println);
} catch (IOException ex) {
 // Handle exception
}
</code></pre>
Since the method returns a <code>Stream</code>, we use its <a target="_blank" href="/guide-to-java-streams-foreach-with-examples/"><code>forEach()</code></a> method to iterate over the lines, with a <a target="_blank" href="/method-references-in-java-8">method reference</a> for brevity.
Instead of printing each line, a <code>StringBuilder</code> can be used to append lines:
<pre><code class="hljs">Path path = Paths.get(&quot;input.txt&quot;);

StringBuilder sb = new StringBuilder();

try (Stream&lt;String&gt; stream = Files.lines(path)) {
 stream.forEach(s -&gt; sb.append(s).append(&quot;\n&quot;));
 
} catch (IOException ex) {
 // Handle exception
}

String contents = sb.toString();
</code></pre>
With <code>StringBuilder</code>, the entire file can be represented in a single <code>String</code> (the <code>contents</code> variable above). Before performing such iterations, it's important to consider the length of the input file.
If the file is not too large, it's okay to put it in a String, though, if it's hundreds of megabytes in size, it's not so wise.
<h2 id="filesreadstring">Files.readString()</h2>
Since Java 11, the <code>Files</code> class introduced us to the <code>readString()</code> method, which accepts a <code>Path</code> to the file, as well as a <code>Charset</code>.
Unlike <code>Files.lines()</code>, it returns a <code>String</code> directly, instead of a <code>Stream</code> object:
<pre><code class="hljs">Path path = Paths.get(&quot;input.txt&quot;);

String contents = null;
try {
 contents = Files.readString(path, StandardCharsets.ISO_8859_1);
} catch (IOException ex) {
 // Handle exception
}
</code></pre>
<h2 id="filesreadallbytes">Files.readAllBytes()</h2>
A more low-level approach to reading is the <code>Files.readAllBytes()</code> method, which returns a <code>byte[]</code>. It's up to the developer to use these bytes - convert them to a String, process them as they are, etc.
This method also accepts a <code>Path</code> to the file we'd like to read:
<pre><code class="hljs">Path path = Paths.get(&quot;input.txt&quot;);

byte[] bytes = null;
try {
 bytes = Files.readAllBytes(path);
} catch (IOException ex) {
 // Handle exception
}
</code></pre>
Now, the <code>bytes</code> array holds all the information from the <code>input.txt</code> file. The easiest way to convert it into a String is to put them in a constructor with an optional <code>Charset</code>:
<pre><code class="hljs">String str = new String(bytes, StandardCharsets.UTF_8);
</code></pre>
Note: Solutions like reading all bytes are only appropriate in circumstances where we're dealing with small file sizes. It's not performance-friendly and it doesn't make much sense to keep large files in the program's memory.
<h2 id="scanner">Scanner</h2>
<code>Scanner</code> is a particularly useful class for reading content from streams. Since it works with abstract streams, it can also be used for reading strings. <code>Scanner</code> works by breaking the input into tokens which are sequentially retrieved from the input stream.
Since we are working with strings, we would like to use methods that return strings. <code>Scanner</code> has <code>next()</code> and <code>nextLine()</code> exactly for that. Both methods return objects of type <code>String</code>. The former is used to read arbitrary strings, whereas the latter parses and returns entire lines.
If each line contains the right amount of data then <code>nextLine()</code> is an ideal choice. If there is important information in the file that's broken down into smaller chunks but not necessarily lines (or the file contains, say, a single line) then <code>next()</code> might be a better option.
<code>Scanner</code>'s constructor accepts many objects - <code>Path</code>s, <code>InputStream</code>s, <code>File</code>s, etc. We'll use a <code>File</code>:
<pre><code class="hljs">File file = new File(&quot;input.txt&quot;);
Scanner sc = new Scanner(file);

while(sc.hasNext()) {
 System.out.println(sc.next());
}
</code></pre>
We're using a <code>while</code> loop as long as the <code>sc</code> has more elements. If we didn't check with <code>hasNext()</code>, <code>sc</code> would throw a <code>NoSuchElementexception</code> if we try accessing an element after the last one.
The idea of using <code>hasNext()</code> and <code>next()</code> methods come from the <a target="_blank" href="java-iterable-interface-iterator-listiterator-and-spliterator"><code>Iterator</code></a> interface, as <code>Scanner</code> internally implements it.
<h2 id="filereader">FileReader</h2>
The <code>FileReader</code> is used to read files. It offers the <code>read()</code> and <code>read(char[])</code> methods, which return a single character and multiple characters respectively. Also, it accepts a <code>File</code> or <code>String</code> into the constructor.
<h3 id="filereaderreadchar">FileReader.read(char[])</h3>
Let's open a file using <code>FileReader</code> and read its contents:
<pre><code class="hljs">FileReader in = new FileReader(&quot;input.txt&quot;);

char[] chars = new char[256];
int n = in.read(chars, 0, chars.length);

String contents = new String(chars);
</code></pre>
The <code>read()</code> method accepts a sequence of characters (that we're storing the read characters in), the starting point and the ending point of what we'd like to read. Specifically, we've decided to read 256 characters at most. If <code>input.txt</code> has more, we'll read only 256 characters. If it has less, the readable characters are returned.
The return value, stored inside integer <code>n</code> can be used to check how many characters the method actually read. In case the end of the stream has been reached, the method returns <code>-1</code>.
Since the method fills a <code>char[]</code>, we can convert it into a <code>String</code>. A similar result can be obtained by using <code>String.valueOf(char[])</code>.
<h3 id="filereaderread">FileReader.read()</h3>
The <code>read()</code> method, without a <code>char[]</code> reads a single character at a time. We'll want to iterate through the contents and read each character ourselves:
<pre><code class="hljs">FileReader in = new FileReader(&quot;input.txt&quot;);

StringBuilder sb = new StringBuilder();

while(in.read() != -1) {
 sb.append(in.read());
}

String contents = sb.toString();
in.close();
</code></pre>
Here, we check if the read character isn't <code>-1</code>, which indicates that there are no characters left to read. If not, we <code>append()</code> it to a <code>StringBuilder</code> and finally, convert it to a <code>String</code>.
Note: Both <code>read()</code> and <code>read(char[])</code> read bytes, convert them into characters, and return them one by one. This is inefficient and should be done with buffering when possible.
<h2 id="bufferedreader">BufferedReader</h2>
<code>BufferedReader</code> is an object designed to read text from a character-input stream. It is buffered, meaning that it uses an internal buffer for temporary storage. As we've seen in the previous section, &quot;regular&quot; <code>Reader</code>s can sometimes be inefficient.
It's advised to wrap any potentially costly <code>Reader</code> into a <code>BufferedReader</code> to increase performance since buffering characters enables more efficient reading of the input text.
Let's instantiate a <code>BufferedReader</code>:
<pre><code class="hljs">BufferedReader in = new BufferedReader(new FileReader(&quot;input.txt&quot;));
</code></pre>
At this point, we have a buffered reader object ready to read contents from <code>input.txt</code>. In this example, we'll be reading the file line-by-line, although <code>BufferedReader</code> supports reading single characters individually and also multiple characters into an array.
Let's use this <code>BufferedReader</code> instance to read a file and store its contents, line-by-line, into a String:
<pre><code class="hljs">StringBuilder sb = new StringBuilder();

while(in.readLine != null) {
 sb.append(in.readLine()).append(&quot;\n&quot;);
}

String contents = sb.toString();
in.close();
</code></pre>
Once again, we are using <code>StringBuilder</code> to collect all the lines. To separate each line, we append the null-terminator (<code>\n</code>) between them. Finally, we close the stream.
<h2 id="conclusion">Conclusion</h2>
In this article, we went over some common techniques for reading files into strings in Java. There are many options but most of them have a similar core principle: provide a path to the file, read the contents into a data structure (e.g. <code>char[]</code> or a String); then perform some final processing to collect all file contents in an appropriate manner.
We've covered the <code>File.lines()</code> method, the <code>Files.readString()</code> method, the <code>Files.readAllBytes()</code> method, as well as the <code>Scanner</code>, <code>FileReader</code> and <code>BufferedReader</code> classes.

In this tutorial, we'll use the Files.lines(), Files.readString(), Files.readAllBytes() methods, and the FileReader, BufferedReader and Scanner classes to read a File into a String in Java with examples.

Java: Read a File into a String

Java: Read a File Into a String

<h2 id="introduction">Introduction</h2>
Saving a String into files can be done in a few ways using Java. In this article, we'll show some common methods for writing a String into a file.
Here's a list of all the classes and methods we'll go over:
<ul>
<li><a href="#files.writestring">Files.writeString()</a></li>
<li><a href="#files.write">Files.write()</a></li>
<li><a href="#filewriter">FileWriter</a></li>
<li><a href="#bufferedwriter">BufferedWriter</a></li>
<li><a href="#printwriter">PrintWriter</a></li>
</ul>
<h2 id="fileswritestring">Files.writeString()</h2>
Since Java 11, the <code>Files</code> class contains a useful utility method <code>Files.writeString()</code>. This method comes in two variants. The most basic form requires a <code>Path</code> of the file to write to and the textual contents. The other variant also accepts an optional <code>CharSet</code>:
<pre><code class="hljs">Path path = Paths.get(&quot;output.txt&quot;);
String contents = &quot;Hello&quot;;

try {
 Files.writeString(path, contents, StandardCharsets.UTF_8);
} catch (IOException ex) {
 // Handle exception
}
</code></pre>
There is little room for flexibility here, but it works great if you need to write something down into a file quickly.
<h2 id="fileswrite">Files.write()</h2>
A String, like other objects, can be converted into a <code>byte[]</code>. The <code>Files.write()</code> method deals with bytes:
<pre><code class="hljs">Path path = Paths.get(&quot;output.txt&quot;);
String someString = &quot;Hello World&quot;;
byte[] bytes = someString.getBytes();

try {
 Files.write(path, bytes);
} catch (IOException ex) {
 // Handle exception
}
</code></pre>
There is no need to close any resources since we haven't opened any resources ourselves.
<h2 id="filewriter">FileWriter</h2>
<code>FileWriter</code> is one of the simplest ways to write some textual contents into a file. We'll create a <code>File</code> instance and pass it into the <code>FileWriter</code> constructor to &quot;bridge&quot; them.
Then, we simply use the <code>FileWriter</code> instance to write to it:
<pre><code class="hljs">File output = new File(&quot;output.txt&quot;);
FileWriter writer = new FileWriter(output);

writer.write(&quot;This text was written with a FileWriter&quot;);
writer.flush();
writer.close();
</code></pre>
After using the writer, it's important to flush and close the resources. Alternatively, you can do this with the <a target="_blank" href="/the-try-with-resources-statement-in-java/"><code>try-with-resources</code></a> syntax:
<pre><code class="hljs">try(FileWriter writer = new FileWriter(&quot;output.txt&quot;)) {
 writer.write(&quot;This text was written with a FileWriter&quot;); 
}
catch(IOException e){
 // Handle the exception
}
</code></pre>
<h2 id="bufferedwriter">BufferedWriter</h2>
<code>BufferedWriter</code> is a wrapper object that is used around objects of type <code>Writer</code>. If we have an existing <code>Writer</code> such as <code>FileWriter</code>, we can wrap it inside a <code>BuffereWriter</code>.
<code>BufferedWriter</code> is best used when there are multiple <code>write()</code> operations for a file. In this case, those multiple writes are temporarily stored into an internal buffer and written into a file only when there is enough content. This avoids having to store each new chunk of text into a file and instead provides an appropriate buffer for temporary storage.
Using a <code>BufferedWriter</code> is much more efficient than <code>FileWriter</code> for multiple writes, but it doesn't help with a single write.
In fact, using <code>BufferedWriter</code> for a single write would cause unnecessary overhead. For such simple cases, <code>FileWriter</code> is a much better option.
Let's create a <code>BufferedWriter</code>:
<pre><code class="hljs">BufferedWriter writer = new BufferedWriter(new FileWriter(&quot;output.txt&quot;));
</code></pre>
<code>BufferedWriter</code> and <code>FileWriter</code> both extend <code>Writer</code> so they have the same methods:
<pre><code class="hljs">try(BufferedWriter writer = new BufferedWriter(new FileWriter(&quot;output.txt&quot;))) {
 writer.write(&quot;Written with BufferedWriter);
}
catch(IOException e){
 // Handle the exception
}
</code></pre>
<h2 id="printwriter">PrintWriter</h2>
<code>PrintWriter</code> lets us format the text before writing it down. It contains methods we're used to, such as <code>printf()</code>, <code>println()</code>, etc. Let's create a <code>PrintWriter</code>:
<pre><code class="hljs">File output = new File(&quot;output.txt&quot;);
PrintWriter writer = new PrintWriter(output);
</code></pre>
A better way to work with a <code>PrintWriter</code> is with the <code>try-with-resources</code> syntax:
<pre><code class="hljs">try(PrintWriter writer = new PrintWriter(new FileWriter(&quot;output.txt&quot;))) {
 // Write using the PrintWriter instance
} catch {
 // Handle Exception
}
</code></pre>
Once we have a <code>PrintWriter</code> instance, let's explore some of the methods it provides.
<h3 id="printwriterwithappend">PrintWriter with append()</h3>
<code>PrintWriter</code>, like the <code>StringBuilder</code> provides the <code>append()</code> method which allows us to append contents to the end of an existing file.
Let's <code>appent()</code> some text to an empty <code>writer</code>:
<pre><code class="hljs">writer.append(&quot;Welcome to my fruit store! From me, you can buy:\n&quot;);
writer.append(&quot;Apples&quot;);
writer.append(&quot;\n&quot;);
writer.append(&quot;Oranges&quot;);
writer.append(&quot;\n&quot;);
writer.append(&quot;Bananas&quot;);
</code></pre>
The <code>append()</code> method returns the <code>PrintWriter</code> object it was called upon. This makes it possible to chain <code>append()</code> methods and organize them more neatly:
<pre><code class="hljs">writer.append(&quot;Welcome to my fruit store! From me, you can buy:\n&quot;);
writer.append(&quot;Apples\n&quot;).append(&quot;Oranges\n&quot;).append(&quot;Bananas\n&quot;);
</code></pre>
<h3 id="printwriterwithprint">PrintWriter with print()</h3>
<code>PrintWriter</code> contains methods for formatted printing. These include <code>print()</code>, <code>printf()</code>, and <code>println()</code>:
<pre><code class="hljs">writer.print(&quot;Welcome to my fruit store %f&quot;, 2.0);
writer.printf(&quot;From me, you can buy %s and %s.&quot;, &quot;apples&quot;, &quot;oranges&quot;);
</code></pre>
<h3 id="printwriterwithwrite">PrintWriter with write()</h3>
With <code>write()</code>, we can write many different types of textual contents into the stream. Examples include char arrays, Strings, and integers:
<pre><code class="hljs">char[] hello = {&#x27;H&#x27;, &#x27;e&#x27;, &#x27;l&#x27;, &#x27;l&#x27;, &#x27;o&#x27;, &#x27;!&#x27;, &#x27;\n&#x27;};

writer.write(hello);
writer.write(&quot;Welcome to my fruit store\n&quot;);
writer.write(&quot;From me, you can buy apples and oranges&quot;);
</code></pre>
The <code>write()</code> method only accepts content without formatting options so it's similar to <code>print()</code>, but can't format Strings.
To finalize each <code>PrintWriter</code> &quot;session&quot; of either appending, printing, or writing, it's important to flush and close the stream:
<pre><code class="hljs">writer.flush();
writer.close();
</code></pre>
The <code>flush()</code> method &quot;flushes&quot; the contents into the file and <code>close()</code> permanently closes the stream.
Note: If you use the <code>try-with-resources</code> syntax, it'll flush and close the stream automatically.
<h2 id="conclusion">Conclusion</h2>
In this article, we've shown some common methods for writing strings into files. There are many options because there are many possible use-cases.
We've covered the <code>Files.writeString()</code>, <code>Files.write()</code> methods, as well as the <code>FileWriter</code>, <code>BufferedWriter</code> and <code>PrintWriter</code> classes.

In this tutorial, we'll save or write a String into a File in Java using Files.writeString(), Files.write(), FileWriter, BufferedWriter and PrintWriter with formatting.

Java: Save/Write String in to a File

Java: Save/Write String Into a File

<h2 id="introduction">Introduction</h2>
<a rel="nofollow noopener" target="_blank" href="https://nodejs.org/api/async_hooks.html#async_hooks_async_hooks">Async Hooks</a> are a core module in Node.js that provides an API to track the lifetime of asynchronous resources in a Node application. An asynchronous resource can be thought of as an object that has an associated callback.
Examples include, but are not limited to: Promises, Timeouts, TCPWrap, UDP etc. The whole list of asynchronous resources that we can track using this API can be found <a rel="nofollow noopener" target="_blank" href="https://nodejs.org/api/async_hooks.html#async_hooks_type">here.</a>
The Async Hooks feature was introduced in 2017, in Node.js version 8 and is still experimental. This means that backwards-incompatible changes may still be made to future releases of the API. That being said, it's currently not deemed fit for production.
In this article, we will take a deeper look at Async Hooks - what they are, why they are important, where we can use them and how we can leverage them for a particular use case, that is, request context handling in a Node.js and Express application.
<h2 id="whatareasynchooks">What are Async Hooks?</h2>
As stated earlier, the Async Hooks class is a core Node.js module that provides an API for tracking asynchronous resources in your Node.js application. This also includes tracking of resources created by native Node modules such as <code>fs</code> and <code>net</code>.
During the lifetime of an async resource, there are 4 events which fire and we can track, with Async Hooks. These include:
<ol>
<li><code>init</code> - Called during the construction of the async resource</li>
<li><code>before</code> - Called before the callback of the resource is called</li>
<li><code>after</code> - Called after the callback of the resource has been invoked</li>
<li><code>destroy</code> - Called after the async resource is destroyed</li>
<li><code>promiseResolve</code> - Called when the <code>resolve()</code> function of a Promise is invoked.</li>
</ol>
Below is a summarized snippet of the Async Hooks API from the <a rel="nofollow noopener" target="_blank" href="https://nodejs.org/api/async_hooks.html#async_hooks_overview">overview in the Node.js documentation</a>:
<pre><code class="hljs">const async_hooks = require(&#x27;async_hooks&#x27;);

const exec_id = async_hooks.executionAsyncId();
const trigger_id = async_hooks.triggerAsyncId();
const asyncHook = async_hooks.createHook({
 init: function (asyncId, type, triggerAsyncId, resource) { },
 before: function (asyncId) { },
 after: function (asyncId) { },
 destroy: function (asyncId) { },
 promiseResolve: function (asyncId) { }
});
asyncHook.enable();
asyncHook.disable();
</code></pre>
The <code>executionAsyncId()</code> method returns an identifier of the current execution context.
The <code>triggerAsyncId()</code> method returns the identifier of the parent resource that triggered the execution of the async resource.
The <code>createHook()</code> method creates an async hook instance, taking the aforementioned events as optional callbacks.
To enable tracking of our resources, we call the <code>enable()</code> method of our async hook instance which we create with the <code>createHook()</code> method.
We can also disable tracking by calling the <code>disable()</code> function.
Having seen what the Async Hooks API entails, let's look into why we should use it.
<h2 id="whentouseasynchooks">When to use Async Hooks</h2>
The addition of Async Hooks to the core API has availed many advantages and use cases. Some of them include:
<ol>
<li>Better debugging - By using Async Hooks, we can improve and enrich stack traces of async functions.</li>
<li>Powerful tracing capabilities, especially when combined with Node's Performance API. Also, since the Async Hooks API is native, there is minimal performance overhead.</li>
<li>Web request context handling - to capture a request's information during the lifetime of that request, without passing the request object everywhere. Using Async Hooks this can be done anywhere in code and could be especially useful when tracking the behavior of users in a server.</li>
</ol>
In this article, we will be looking at how to handle request ID tracing using Async Hooks in an Express application.
<h2 id="usingasynchooksforrequestcontexthandling">Using Async Hooks for Request Context Handling</h2>
In this section, we will be illustrating how we can leverage Async Hooks to perform simple request ID tracing in a Node.js application.
<h3 id="settinguprequestcontexthandlers">Setting up Request Context Handlers</h3>
We'll begin by creating a directory where our application files will reside, then move into it:
<pre><code class="hljs">mkdir async_hooks &amp;&amp; cd async_hooks 
</code></pre>
Next, we'll need to initialize our Node.js application in this directory with <code>npm</code> and default settings:
<pre><code class="hljs">npm init -y
</code></pre>
This creates a <code>package.json</code> file at the root of the directory.
Next, we'll need to install <code>Express</code> and <code>uuid</code> packages as dependencies. We will use the <code>uuid</code> package to generate a unique ID for each incoming request.
Finally, we install the <code>esm</code> module so Node.js versions lower than v14 can run this example:
<pre><code class="hljs">npm install express uuid esm --save
</code></pre>
Next, create a <code>hooks.js</code> file at the root of the directory:
<pre><code class="hljs">touch hooks.js
</code></pre>
This file will contain the code that interacts with the <code>async_hooks</code> module. It exports two functions:
<ul>
<li>One that enables an Async Hook for an HTTP request, keeping track of its given request ID and any request data we'd like to keep.</li>
<li>The other returns the request data managed by the hook given its Async Hook ID.</li>
</ul>
Let's put that into code:
<pre><code class="hljs">require = require(&#x27;esm&#x27;)(module);
const asyncHooks = require(&#x27;async_hooks&#x27;);
const { v4 } = require(&#x27;uuid&#x27;);
const store = new Map();

const asyncHook = asyncHooks.createHook({
 init: (asyncId, _, triggerAsyncId) =&gt; {
 if (store.has(triggerAsyncId)) {
 store.set(asyncId, store.get(triggerAsyncId))
 }
 },
 destroy: (asyncId) =&gt; {
 if (store.has(asyncId)) {
 store.delete(asyncId);
 }
 }
});

asyncHook.enable();

const createRequestContext = (data, requestId = v4()) =&gt; {
 const requestInfo = { requestId, data };
 store.set(asyncHooks.executionAsyncId(), requestInfo);
 return requestInfo;
};

const getRequestContext = () =&gt; {
 return store.get(asyncHooks.executionAsyncId());
};

module.exports = { createRequestContext, getRequestContext };
</code></pre>
In this piece of code, we first require the <code>esm</code> module to provide backwards compatibility for Node versions that do not have native support for experimental module exports. This feature is used internally by the <code>uuid</code> module.
Next, we also require both the <code>async_hooks</code> and <code>uuid</code> modules. From the <code>uuid</code> module, we de-structure the <code>v4</code> function, which we shall use later to generate version 4 UUIDs.
Next, we create a store that will map each async resource to its request context. For this, we utilize a simple JavaScript map.
Next, we call the <code>createHook()</code> method of the <code>async_hooks</code> module and implement the <code>init()</code> and <code>destroy()</code> callbacks. In the implementation of our <code>init()</code> callback, we check if the <code>triggerAsyncId</code> is present in the store.
If it exists, we create a mapping of the <code>asyncId</code> to the request data stored under the <code>triggerAsyncId</code>. This in effect ensures that we store the same request object for child asynchronous resources.
The <code>destroy()</code> callback checks if the store has the <code>asyncId</code> of the resource, and deletes it if true.
To use our hook, we enable it by calling the <code>enable()</code> method of the <code>asyncHook</code> instance we've created.
Next, we create 2 functions - <code>createRequestContext()</code> and <code>getRequestContext</code> that we use to create and get our request context respectively.
The <code>createRequestContext()</code> function receives the request data and a unique ID as arguments. It then creates a <code>requestInfo</code> object from both arguments and attempts to update the store with the async ID of the current execution context as key, and the <code>requestInfo</code> as the value.
The <code>getRequestContext()</code> function, on the other hand, checks if the store contains an ID corresponding to the ID of the current execution context.
We finally export both functions using the <code>module.exports()</code> syntax.
We've successfully set up our request context handling functionality. Let's proceed to set up our <code>Express</code> server that will receive the requests.
<h3 id="settinguptheexpressserver">Setting up the Express Server</h3>
Having set up our context, we'll now proceed to create our <code>Express</code> server so we can capture HTTP requests. To do so, create a <code>server.js</code> file at the root of the directory as follows:
<pre><code class="hljs">touch server.js
</code></pre>
Our server will accept an HTTP request on port 3000. It creates an Async Hook to track every request by calling the <code>createRequestContext()</code> in a middleware function - a function that has access to an HTTP's request and response objects. The server then sends a JSON response with the data captured by the Async Hook.
Inside the <code>server.js</code> file, enter the following code:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
const ah = require(&#x27;./hooks&#x27;);
const app = express();
const port = 3000;

app.use((request, response, next) =&gt; {
 const data = { headers: request.headers };
 ah.createRequestContext(data);
 next();
});

const requestHandler = (request, response, next) =&gt; {
 const reqContext = ah.getRequestContext();
 response.json(reqContext);
 next()
};

app.get(&#x27;/&#x27;, requestHandler)

app.listen(port, (err) =&gt; {
 if (err) {
 return console.error(err);
 }
 console.log(`server is listening on ${port}`);
});
</code></pre>
In this piece of code, we require <code>express</code> and our <code>hooks</code> modules as dependencies. We then create an <code>Express</code> app by calling the <code>express()</code> function.
Next, we set up a middleware that de-structures the request headers saving them to a variable called <code>data</code>. It then calls the <code>createRequestContext()</code> function passing <code>data</code> as an argument. This ensures that the headers of the request will be preserved throughout the request's lifecycle with the Async Hook.
Finally, we call the <code>next()</code> function to go to the next middleware in our middleware pipeline or invoke the next route handler.
After our middleware, we write the <code>requestHandler()</code> function that handles a <code>GET</code> request on the server's root domain. You'll notice that in this function, we can have access to our request context through the <code>getRequestContext()</code> function. This function returns an object representing the request headers and request ID generated and stored in the request context.
We then create a simple endpoint and attach our request handler as a callback.
Finally, we make our server listen to connections on port 3000 by calling the <code>listen()</code> method of our app instance.
Before running the code, open the <code>package.json</code> file at the root of the directory and replace the <code>test</code> section of the script with this:
<pre><code class="hljs">&quot;start&quot;: &quot;node server.js&quot;
</code></pre>
This done, we can run our app with the following command:
<pre><code class="hljs">npm start
</code></pre>
You should receive a response on your terminal indicating that the app is running on port 3000, as shown:
<pre><code class="hljs">&gt; async-hooks-demo@1.0.0 start /Users/allanmogusu/StackAbuse/async-hooks-demo
&gt; node server.js

(node:88410) ExperimentalWarning: Conditional exports is an experimental feature. This feature could change at any time
server is listening on 3000
</code></pre>
With our app running, open a separate terminal instance and run the following <code>curl</code> command to test out our default route:
<pre><code class="hljs">curl http://localhost:3000
</code></pre>
This <code>curl</code> command makes a <code>GET</code> request to our default route. You should get a response similar to this:
<pre><code class="hljs">$ curl http://localhost:3000
{&quot;requestId&quot;:&quot;3aad88a6-07bb-41e0-ab5a-fa9d5c0269a7&quot;,&quot;data&quot;:{&quot;headers&quot;:{&quot;host&quot;:&quot;localhost:3000&quot;,&quot;user-agent&quot;:&quot;curl/7.64.1&quot;,&quot;accept&quot;:&quot;*/*&quot;}}}%
</code></pre>
Notice that the generated <code>requestId</code> and our request headers are returned. Repeating the command should generate a new request ID since we shall be making a new request:
<pre><code class="hljs">$ curl http://localhost:3000
{&quot;requestId&quot;:&quot;38da84792-e782-47dc-92b4-691f4285b172&quot;,&quot;data&quot;:{&quot;headers&quot;:{&quot;host&quot;:&quot;localhost:3000&quot;,&quot;user-agent&quot;:&quot;curl/7.64.1&quot;,&quot;accept&quot;:&quot;*/*&quot;}}}%
</code></pre>
The response contains the ID we generated for the request and the headers we captured in the middleware function. With Async Hooks, we could easily pass data from one middleware to another for the same request.
<h2 id="conclusion">Conclusion</h2>
Async Hooks provides an API for tracking the lifetime of asynchronous resources in a Node.js application.
In this article, we have looked briefly at the Async Hooks API, the functionality it provides, and how we can leverage it. We have specifically covered a basic example of how we can use Async Hooks to do web request context handling and tracing efficiently and cleanly.
Since Node.js version 14 however, the Async Hooks API ships with async local storage, an API that makes request context handling easier in Node.js. You can read more about it <a rel="nofollow noopener" target="_blank" href="https://nodejs.org/api/async_hooks.html#async_hooks_class_asynclocalstorage">here.</a> Also, the code for this tutorial can be accessed <a rel="nofollow noopener" target="_blank" href="https://github.com/Allan690/async-hooks-demo">here.</a>

Marcus Sanatan

Allan Mogusu

Node.js Async Hooks provide an API to track the lifetime of asynchronous resources in a Node application. Let's use Async Hooks to track HTTP requests.

Using Async Hooks for Request Context Handling in Node.js

<h2 id="introduction">Introduction</h2>
The <code>forEach()</code> method is part of the <code>Stream</code> interface and is used to execute a specified operation, defined by a <code>Consumer</code>.
The <code>Consumer</code> interface represents any operation that takes an argument as input, and has no output. This sort of behavior is acceptable because the <code>forEach()</code> method is used to change the program's state via side-effects, not explicit return types.
Therefore, the best target candidates for <code>Consumers</code> are lambda functions and method references. It's worth noting that <code>forEach()</code> can be used on any <code>Collection</code>.
<h2 id="foreachonlist">forEach() on List</h2>
The <code>forEach()</code> method is a terminal operation, which means that after we call this method, the stream along with all of its integrated transformations will be materialized. That is to say, they'll &quot;gain substance&quot;, rather than being streamed.
Let's generate a small list:
<pre><code class="hljs">List&lt;Integer&gt; list = new ArrayList&lt;Integer&gt;();
list.add(1);
list.add(2);
list.add(3);
</code></pre>
Traditionally, you could write a for-each loop to go through it:
<pre><code class="hljs">for (Integer element : list) {
 System.out.print(element + &quot; &quot;);
}
</code></pre>
This would print:
<pre><code class="hljs">1 2 3
</code></pre>
Alternatively, we can use the <code>forEach()</code> method on a <code>Stream</code>:
<pre><code class="hljs">list.stream().forEach((k) -&gt; {
 System.out.print(k + &quot; &quot;);
});
</code></pre>
This also outputs:
<pre><code class="hljs">1 2 3
</code></pre>
We can make this even simpler via a <a target="_blank" href="/method-references-in-java-8">method reference</a>:
<pre><code class="hljs">list.stream().forEach(System.out::println);
</code></pre>
<h2 id="foreachonmap">forEach() on Map</h2>
The <code>forEach()</code> method is really useful if we want to avoid chaining many stream methods. Let's generate a map with a few movies and their respective IMDB scores:
<pre><code class="hljs">Map&lt;String, Double&gt; map = new HashMap&lt;String, Double&gt;();
map.put(&quot;Forrest Gump&quot;, 8.8);
map.put(&quot;The Matrix&quot;, 8.7);
map.put(&quot;The Hunt&quot;, 8.3);
map.put(&quot;Monty Python&#x27;s Life of Brian&quot;, 8.1);
map.put(&quot;Who&#x27;s Singin&#x27; Over There?&quot;, 8.9);
</code></pre>
Now, let's print out the values of each film that has a score higher than <code>8.4</code>:
<pre><code class="hljs">map.entrySet()
 .stream()
 .filter(entry -&gt; entry.getValue() &gt; 8.4)
 .forEach(entry -&gt; System.out.println(entry.getKey() + &quot;: &quot; + entry.getValue()));
</code></pre>
This results in:
<pre><code class="hljs">Forrest Gump: 8.8
The Matrix: 8.7
Who&#x27;s Singin&#x27; Over There?: 8.9
</code></pre>
Here, we've converted a <code>Map</code> to a <code>Set</code> via <code>entrySet()</code>, streamed it, filtered based on the score and finally printed them out via a <code>forEach()</code>. Instead of basing this on the return of <code>filter()</code>, we could've based our logic on side-effects and skipped the <code>filter()</code> method:
<pre><code class="hljs">map.entrySet()
 .stream()
 .forEach(entry -&gt; {
 if (entry.getValue() &gt; 8.4) {
 System.out.println(entry.getKey() + &quot;: &quot; + entry.getValue());
 }
 }
 );
</code></pre>
This results in:
<pre><code class="hljs">Forrest Gump: 8.8
The Matrix: 8.7
Who&#x27;s Singin&#x27; Over There?: 8.9
</code></pre>
Finally, we can omit both the <code>stream()</code> and <code>filter()</code> methods by starting out with <code>forEach()</code> in the beginning:
<pre><code class="hljs">map.forEach((k, v) -&gt; {
 if (v &gt; 8.4) {
 System.out.println(k + &quot;: &quot; + v);
 }
 });
</code></pre>
This results in:
<pre><code class="hljs">Forrest Gump: 8.8
The Matrix: 8.7
Who&#x27;s Singin&#x27; Over There?: 8.9
</code></pre>
<h2 id="foreachonset">forEach() on Set</h2>
Let's take a look at how we can use the <code>forEach</code> method on a <code>Set</code> in a bit more tangible context. First, let's define a class that represents an <code>Employee</code> of a company:
<pre><code class="hljs">public class Employee {
 private String name;
 private double workedHours;
 private double dedicationScore;
 
 // Constructor, Getters and Setters
 
 public void calculateDedication() {
 dedicationScore = workedHours*1.5;
 }
 
 public void receiveReward() {
 System.out.println(String
 .format(&quot;%s just got a reward for being a dedicated worker!&quot;, name));
 }
}
</code></pre>
Imagining we're the manager, we'll want to pick out certain employees that have worked overtime and award them for the hard work. First, let's make a <code>Set</code>:
<pre><code class="hljs"> Set&lt;Employee&gt; employees = new HashSet&lt;Employee&gt;();

 employees.add(new Employee(&quot;Vladimir&quot;, 60));
 employees.add(new Employee(&quot;John&quot;, 25));
 employees.add(new Employee(&quot;David&quot;, 40));
 employees.add(new Employee(&quot;Darinka&quot;, 60));
</code></pre>
Then, let's calculate each employee's dedication score:
<pre><code class="hljs">employees.stream().forEach(Employee::calculateDedication);
</code></pre>
Now that each employee has a dedication score, let's remove the ones with a score that's too low:
<pre><code class="hljs">Set&lt;Employee&gt; regular = employees.stream()
 .filter(employee -&gt; employee.getDedicationScore() &lt;= 60)
 .collect(Collectors.toSet());
employees.removeAll(regular);
</code></pre>
Finally, let's reward the employees for their hard work:
<pre><code class="hljs">employees.stream().forEach(employee -&gt; employee.receiveReward());
</code></pre>
And for clarity's sake, let's print out the names of the lucky workers:
<pre><code class="hljs">System.out.println(&quot;Awarded employees:&quot;);
employees.stream().map(employee -&gt; employee.getName()).forEach(employee -&gt; System.out.println(employee));
</code></pre>
After running the code above, we get the following output:
<pre><code class="hljs">Vladimir just got a reward for being a dedicated worker!
Darinka just got a reward for being a dedicated worker!
Awarded employees:
Vladimir
Darinka
</code></pre>
<h2 id="sideeffectsvsreturnvalues">Side-effects Vs Return Values</h2>
The point of every command is to evaluate the expression from start to finish. Everything in-between is a side-effect. In this context, it means altering the state, flow or variables without returning any values.
Let's take a look at the difference on another list:
<pre><code class="hljs">List&lt;Integer&gt; targetList = Arrays.asList(1, -2, 3, -4, 5, 6, -7);
</code></pre>
This approach is based on the returned values from an <code>ArrayList</code>:
<pre><code class="hljs">long result1 = targetList
 .stream()
 .filter(integer -&gt; integer &gt; 0)
 .count();
System.out.println(&quot;Result: &quot; + result1);
</code></pre>
This results in:
<pre><code class="hljs">Result: 4
</code></pre>
And now, instead of basing the logic of the program on the return type, we'll perform a <code>forEach()</code> on the stream and add the results to an <code>AtomicInteger</code> (streams operate concurrently):
<pre><code class="hljs">AtomicInteger result2 = new AtomicInteger();

targetList.stream().forEach(integer -&gt; {
 if (integer &gt; 0)
 result2.addAndGet(1);
 });
System.out.println(&quot;Result: &quot; + result2);
</code></pre>
<h2 id="conclusion">Conclusion</h2>
The <code>forEach()</code> method is a really useful method to use to iterate over collections in Java in a functional approach.
In certain cases, they can massively simplify the code and enhance clarity and brevity. In this article, we've gone over the basics of using a <code>forEach()</code> and then covered examples of the method on a <code>List</code>, <code>Map</code> and <code>Set</code>.
We've covered the difference between the <code>for-each</code> loop and the <code>forEach()</code>, as well as the difference between basing logic on return values versus side-effects.

Vladimir Batoćanin

In this tutorial, we'll be going over the Java Streams forEach() method. We'll cover basic usage and examples of forEach() on a List, Map and Set.