<h2 id="introduction">Introduction</h2>
In Python, a module is a self-contained file with Python statements and definitions. For example, <code>file.py</code>, can be considered a module named <code>file</code>. This differs from a package in that a package is a collection of modules in directories that give structure and hierarchy to the modules.
Modules help us break down large programs into small files that are more manageable. With modules, code reusability becomes a reality. Suppose we have a function that is frequently used in different programs. We can define this function in a module then import it into the various programs without having to copy its code each time.
In this article, we will see how to create Python modules and how to use them in Python code.
<h2 id="writingmodules">Writing Modules</h2>
A module is simply a Python file with the <code>.py</code> extension. The name of the file becomes the module name. Inside the file, we can have definitions and implementations of classes, variables, or functions. These can then be used in other Python programs.
Let us begin by creating a function that simply prints &quot;Hello World&quot;. To do this, create a new Python file and save it as <code>hello.py</code>. Add the following code to the file:
<pre><code class="hljs">def my_function():
 print(&quot;Hello World&quot;)
</code></pre>
If you run the above code, it will return nothing. This is because we have not told the program to do anything. It is true that we have created a function named <code>my_function()</code> within the code, but we have not called or invoked the function. When invoked, this function should print the text &quot;Hello World&quot;.
Now, move to the same directory where you have saved the above file and create a new file named <code>main.py</code>. Add the following code to the file:
<pre><code class="hljs">import hello

hello.my_function()
</code></pre>
Output
<pre><code class="hljs">Hello World
</code></pre>
The function was invoked successfully. We began by importing the module. The name of the file was <code>hello.py</code>, hence the name of the imported module is <code>hello</code>.
Also, note the syntax that we have used to invoke the function. This is called the &quot;dot notation&quot;, which allows us to call the function by first specifying the module name, and then the name of the function.
However, that is just one way of importing the module and invoking the function. We could have done it as follows:
<pre><code class="hljs">from hello import my_function

my_function()
</code></pre>
Output
<pre><code class="hljs">Hello World
</code></pre>
In the above example, the first line commands the Python interpreter to import a function named <code>my_function</code> from a module named <code>hello</code>. In such a case, you don't have to use the dot notation to access the function, you can just call it directly.
However, in the case where our <code>hello</code> module has multiple functions, the statement <code>from hello import my_function</code> will not import all <code>hello</code>'s functions into our program, only <code>my_function</code>. If you attempt to access any other function, an error will be generated. You have to import the whole module or import each individual function in order to use them.
We can define a variable within a module, which can then be used by other modules. To demonstrate this, open the file <code>hello.py</code> and add the following code to it:
<pre><code class="hljs">def my_function():
 print(&quot;Hello World&quot;)

# The variable that&#x27;ll be used in other modules
name = &quot;Nicholas&quot;
</code></pre>
Now, open the <code>main.py</code> file and modify it as follows:
<pre><code class="hljs">import hello

hello.my_function()

print(hello.name)
</code></pre>
Output
<pre><code class="hljs">Hello World
Nicholas
</code></pre>
We have successfully invoked both the function and the variable defined in the module since we imported the whole module instead of just the <code>my_function()</code> function.
We stated earlier that we can define a class within a module. Let's see how to do this in the next example. Open the <code>hello.py</code> file and modify it as follows:
<pre><code class="hljs">def my_function():
 print(&quot;Hello World&quot;)

# Defining our variable
name = &quot;Nicholas&quot;

# Defining a class
class Student:
 def __init__(self, name, course):
 self.course = course
 self.name = name

 def get_student_details(self):
 print(&quot;Your name is &quot; + self.name + &quot;.&quot;)
 print(&quot;You are studying &quot; + self.course)
</code></pre>
Here we have defined a class named <code>Student</code>. Two variables have been defined in this class, <code>name</code> and <code>course</code>. The method <code>get_student_details()</code> has also been defined within this, which prints the student details to the console.
Now, open the file <code>main.py</code> and modify it as follows:
<pre><code class="hljs">import hello

hello.my_function()

print(hello.name)

nicholas = hello.Student(&quot;Nicholas&quot;, &quot;Computer Science&quot;)
nicholas.get_student_details()
</code></pre>
Output
<pre><code class="hljs">Hello World
Nicholas
Your name is Nicholas.
You are studying Computer Science
</code></pre>
In the script above, we again used the dot notation to create an object of the <code>student</code> class from the <code>hello</code> module. We then used the <code>get_student_details()</code> function to get the student details.
Although modules mostly consist of class definitions (in most cases), it is possible for them to actually run their own code as well when imported. To demonstrate this, let us modify the <code>hello.py</code> file, where we have a definition of the function <code>my_function()</code>, along with the call to the function:
<pre><code class="hljs">def my_function():
 print(&quot;Hello World&quot;)
 
my_function()
</code></pre>
Now, open the file <code>main.py</code> and delete all the lines except the following:
<pre><code class="hljs">import hello
</code></pre>
Output
<pre><code class="hljs">Hello World
</code></pre>
The above output shows that we defined and called the function within the module. When the module is imported, it directly returns the result from the function without having to invoke the function. This behavior isn't always desired, but it's helpful for certain use-cases, like preloading data from cache when the module is imported.
<h2 id="importingallmoduleobjects">Importing all Module Objects</h2>
To import all objects (functions, variables, classes, etc.) from a module, we can use the <code>import *</code> statement. For example, to import all objects contained in the <code>hello</code> module, we can use the following statement:
<pre><code class="hljs">from hello import *
</code></pre>
After adding the above statement to a program, we will be able to use any function, variable, or class contained in the <code>hello</code> module without having to prefix it with <code>hello</code>.
<h2 id="accessingamodulefromanotherpath">Accessing a Module from Another Path</h2>
In Python, modules are used in more than one project. Hence, it makes no sense if you keep your modules in the directory of one of the projects, since other projects wouldn't be able to use it as easily.
You have a couple of options whenever you need to access a module that is not stored in the same directory as your program. Let us discuss these in the next few sections:
<h3 id="appendingpaths">Appending Paths</h3>
To import a module from another path, you first need to import the <code>sys</code> module as well as any other Python modules that you would like to use in your program.
The <code>sys</code> module is provided by the Python Standard Library and it provides functions and parameters that are system-specific. The <code>path.append()</code> function from the <code>sys</code> module can be used to add the path of the module to the current project.
To demonstrate this, cut the <code>hello.py</code> file from the directory where you have the file <code>main.py</code>. Paste it in another directory. In my case, I have pasted it in the directory &quot;F:\Python.&quot;
Now, open the file <code>main.py</code>, import the <code>sys</code> module and specify the path in which the Python interpreter will look for files. This is demonstrated below:
<pre><code class="hljs">import sys
sys.path.append(&#x27;F:/Python/&#x27;)

import hello
</code></pre>
Output
<pre><code class="hljs">Hello World
</code></pre>
In the above script, the line <code>sys.path.append('F:/Python/')</code> tells the Python interpreter to include this path in the list of paths that will be searched while importing the modules.
<h3 id="addingamoduletopythonpath">Adding a Module to Python Path</h3>
The above method works only if you import the <code>sys</code> module. If you don't import the <code>sys</code> module and specify the path to the module, an error will be generated. To make the module available to the entire system, you can add it to the path where Python normally checks for modules and packages. This way, you will not have to import the <code>sys</code> module and specify the path to the module as we have done in the previous section.
Before doing anything else, you should first identify the path that Python searches for modules and packages. Just open the command line of your operating system and run the <code>python</code> command. This will take you to the Python terminal.
Import the <code>sys</code> module as follows:
<pre><code class="hljs">import sys
</code></pre>
You can then run the following command to print out the path:
<pre><code class="hljs">print(sys.path)
</code></pre>
The output will contain at least one system path. If you do it from a programming environment, you will get several paths. In my case, I got the following:
<pre><code class="hljs">$ python
Python 2.7.10 (default, Oct 23 2015, 19:19:21) 
[GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.5)] on darwin
Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
&gt;&gt;&gt; import sys
&gt;&gt;&gt; print(sys.path)
[&#x27;&#x27;, &#x27;/Library/Python/2.7/site-packages/six-1.10.0-py2.7.egg&#x27;, &#x27;/Library/Python/2.7/site-packages/cffi-1.2.1-py2.7-macosx-10.9-intel.egg&#x27;, &#x27;/Library/Python/2.7/site-packages/pycparser-2.14-py2.7.egg&#x27;, &#x27;/Library/Python/2.7/site-packages/virtualenv-13.1.2-py2.7.egg&#x27;, &#x27;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python27.zip&#x27;, &#x27;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7&#x27;, &#x27;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/plat-darwin&#x27;, &#x27;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/plat-mac&#x27;, &#x27;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/plat-mac/lib-scriptpackages&#x27;, &#x27;/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python&#x27;, &#x27;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-tk&#x27;, &#x27;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-old&#x27;, &#x27;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload&#x27;, &#x27;/Library/Python/2.7/site-packages&#x27;]
&gt;&gt;&gt; 
</code></pre>
Your goal should be to find the one in the environment that you are currently using. You should look for something like the following:
<pre><code class="hljs">/Library/Python/2.7/site-packages
</code></pre>
Move your <code>hello.py</code> file to the path. After that, you will be able to import the <code>hello</code> module from any directory in the usual way, as shown below:
<pre><code class="hljs">import hello
</code></pre>
Output
<pre><code class="hljs">Hello World
</code></pre>
<h2 id="conclusion">Conclusion</h2>
This marks the end of this article. A module is simply a Python file with a set of variables and function definitions. A module facilitates code reusability since you can define a function in a module and invoke it from different programs instead of having to define the function in every program. Although a module is mostly used for function and class definitions, it may also export variables and class instances.

Nicholas Samuel

Creating and Importing Modules in Python

Guest Contributor

Predicting Customer Ad Clicks via Machine Learning

In this article, we'll examine how to strip characters from both ends of a string in Python.
The built-in <code>String</code> type is an essential Python structure, and comes with a built-in set of methods to simplify working with text data. There are many situations in which a programmer may want to remove unwanted characters, i.e. strip certain characters, from either the beginning or ending of a string.
The most common requirement is to strip whitespace (spaces, tabs, newline characters, etc.) from both ends of a string. This usually occurs after importing raw text data from a file, database, web service, or after accepting user input, which may contain typos in the form of extra spaces. This can be handled by the default usage of the <code>String.strip()</code> method, as seen here:
<pre><code class="hljs">&gt;&gt;&gt; orig_text = &#x27; The cow jumped over the moon! \n&#x27;
&gt;&gt;&gt; print(orig_text.strip())
The cow jumped over the moon!
&gt;&gt;&gt;
</code></pre>
Note that this method does not change the original value of the string, i.e. it does not change the string in-place. It simply returns a new string with the whitespace on either end stripped out. We can verify this by printing out the original string:
<pre><code class="hljs">&gt;&gt;&gt; print(orig_text)
 The cow jumped over the moon! 

&gt;&gt;&gt;
</code></pre>
The <code>strip</code> method also enables us to specify which types of characters we want to strip. This can be useful if we want to remove other characters besides whitespace. To do this we simply specify the characters to strip by passing an argument containing these characters to the <code>String.strip()</code> method:
<pre><code class="hljs">&gt;&gt;&gt; orig_text = &#x27;-----The cow jumped over the moon!$$$$$&#x27;
&gt;&gt;&gt; print(orig_text.strip(&#x27;-$&#x27;))
The cow jumped over the moon!
&gt;&gt;&gt;
</code></pre>
This is useful for removing characters at the start or end of a string that were used for formatting purposes, for example. So if you have a Markdown-formatted string, you can easily remove the header syntax like this:
<pre><code class="hljs">&gt;&gt;&gt; md_text = &#x27;### My Header Here&#x27; # Denotes an H3 header in Markdown
&gt;&gt;&gt; print(md_text.strip(&#x27;# &#x27;))
My Header Here
&gt;&gt;&gt;
</code></pre>
Finally, Python provides a way to strip characters from only one side of the string via the <code>String.rstrip()</code> and <code>String.lstrip()</code> methods. These methods work exactly the same way as the <code>String.strip()</code> method, but <code>String.rstrip()</code> only removes characters from the right side of the string and <code>String.lstrip()</code> only removes characters from the left side of the string:
<pre><code class="hljs">&gt;&gt;&gt; orig_text = &#x27;*****The cow jumped over the moon!*****&#x27;
&gt;&gt;&gt; print(orig_text.rstrip(&#x27;*&#x27;))
*****The cow jumped over the moon!
&gt;&gt;&gt; print(orig_text.lstrip(&#x27;*&#x27;))
The cow jumped over the moon!*****
</code></pre>
Once again we can print the original string to see that it was unaffected by these operations:
<pre><code class="hljs">&gt;&gt;&gt; print(orig_text)
*****The cow jumped over the moon!*****
</code></pre>
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com">Initial Commit</a> - a site dedicated to helping curious developers learn how their favorite programs are coded. Its featured project helps people <a rel="nofollow" target="_blank" href="https://initialcommit.com/blog/Learn-Git-Code-Definitive-Guide">learn Git</a> at the code level.

Jacob Stopak

The Python String strip() Function

In this article, we'll examine how to use the built-in Python <code>zip()</code> function.
The <code>zip()</code> function is a Python built-in function that allows us to combine corresponding elements from multiple sequences into a single list of tuples. The sequences are the arguments accepted by the <code>zip()</code> function. Any number of sequences can be supplied, but the most common use-case is to combine corresponding elements in two sequences.
For example, let's say we have the two lists below:
<pre><code class="hljs">&gt;&gt;&gt; vehicles = [&#x27;unicycle&#x27;, &#x27;motorcycle&#x27;, &#x27;plane&#x27;, &#x27;car&#x27;, &#x27;truck&#x27;]
&gt;&gt;&gt; wheels = [1, 2, 3, 4, 18]
</code></pre>
We can use the <code>zip()</code> function to associate elements from these two lists based on their order:
<pre><code class="hljs">&gt;&gt;&gt; list(zip(vehicles, wheels))
[(&#x27;unicycle&#x27;, 1), (&#x27;motorcycle&#x27;, 2), (&#x27;plane&#x27;, 3), (&#x27;car&#x27;, 4), (&#x27;truck&#x27;, 18)]
</code></pre>
Notice how the output is a sequence of tuples, where each tuple combines elements of the input sequences with corresponding indexes.
One important thing to note is that if the input sequences are of differing lengths, <code>zip()</code> will only match elements until the end of the shortest list is reached. For example:
<pre><code class="hljs">&gt;&gt;&gt; vehicles = [&#x27;unicycle&#x27;, &#x27;motorcycle&#x27;, &#x27;plane&#x27;, &#x27;car&#x27;, &#x27;truck&#x27;]
&gt;&gt;&gt; wheels = [1, 2, 3]
&gt;&gt;&gt; list(zip(vehicles, wheels))
[(&#x27;unicycle&#x27;, 1), (&#x27;motorcycle&#x27;, 2), (&#x27;plane&#x27;, 3)]
</code></pre>
Since the <code>wheels</code> list is shorter in this example (3 items as opposed to the 5 that <code>vehicles</code> has), the sequence stopped at &quot;plane&quot;.
As previously mentioned, the <code>zip()</code> function can be used with more than two sequences:
<pre><code class="hljs">&gt;&gt;&gt; vehicles = [&#x27;unicycle&#x27;, &#x27;motorcycle&#x27;, &#x27;plane&#x27;, &#x27;car&#x27;, &#x27;truck&#x27;]
&gt;&gt;&gt; wheels = [1, 2, 3, 4, 18]
&gt;&gt;&gt; energy_sources = [&#x27;pedal&#x27;, &#x27;gasoline&#x27;, &#x27;jet fuel&#x27;, &#x27;gasoline&#x27;, &#x27;diesel&#x27;]
</code></pre>
<pre><code class="hljs">&gt;&gt;&gt; list(zip(vehicles, wheels, energy_sources))
[(&#x27;unicycle&#x27;, 1, &#x27;pedal&#x27;), (&#x27;motorcycle&#x27;, 2, &#x27;gasoline&#x27;), (&#x27;plane&#x27;, 3, &#x27;jet fuel&#x27;), (&#x27;car&#x27;, 4, &#x27;gasoline&#x27;), (&#x27;truck&#x27;, 18, &#x27;diesel&#x27;)]
</code></pre>
One reason to connect multiple sequences like this is to create a cleaner way to iterate over the items in multiple sequences. Without the <code>zip()</code> function, we would have to do something like this:
<pre><code class="hljs">&gt;&gt;&gt; for i in range(len(vehicles)):
... print(&#x27;A &#x27; + vehicles[i] + &#x27; has &#x27; + str(wheels[i]) + &#x27; wheels and runs on &#x27; + energy_sources[i])
...
A unicycle has 1 wheels and runs on pedal
A motorcycle has 2 wheels and runs on gasoline
A plane has 3 wheels and runs on jet fuel
A car has 4 wheels and runs on gasoline
A truck has 18 wheels and runs on diesel
</code></pre>
But with the <code>zip()</code> function we can use the following cleaner syntax via tuple unpacking:
<pre><code class="hljs">&gt;&gt;&gt; for v, w, es in zip(vehicles, wheels, energy_sources):
... print(&#x27;A &#x27; + v + &#x27; has &#x27; + str(w) + &#x27; wheels and runs on &#x27; + es)
...
A unicycle has 1 wheels and runs on pedal
A motorcycle has 2 wheels and runs on gasoline
A plane has 3 wheels and runs on jet fuel
A car has 4 wheels and runs on gasoline
A truck has 18 wheels and runs on diesel
</code></pre>
One final thing to understand about the <code>zip()</code> function is that it actually returns an iterator, not a list of tuples. Note that in our first two examples above, we wrapped the <code>zip()</code> function inside the <code>list()</code> type to convert the result to a list. If we tried to display the return value of the <code>zip()</code> function directly we would see something like this:
<pre><code class="hljs">&gt;&gt;&gt; zip(vehicles, wheels)
&lt;zip object at 0x1032caf48&gt;
</code></pre>
This 'zip object' is an iterable instance of the <code>Zip</code> class, which means it will return its contents one by one in a for-loop, instead of all at once, the way a list does. This is more efficient for large sequences that would be very memory intensive if accessed all at once.
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com">Initial Commit</a> - a site dedicated to helping curious developers learn how their favorite programs are coded. Its featured project helps people <a rel="nofollow" target="_blank" href="https://initialcommit.com/blog/Learn-Git-Code-Definitive-Guide">learn Git</a> at the code level.

The Python zip() Function

<h2 id="overview">Overview</h2>
In this article, we'll introduce you to <a rel="nofollow" target="_blank" href="https://github.com/spring-cloud/spring-cloud-netflix/tree/master/spring-cloud-netflix-turbine">Spring Cloud Netflix Turbine</a>. It aggregates multiple Hystrix Metrics Streams into one, so that it could be displayed into a single dashboard view.
To give a small introduction to <a rel="nofollow" target="_blank" href="https://github.com/Netflix/Hystrix">Hystrix</a>. In a microservice architecture, we have many small applications that talk to each other to complete a request.
There is always a possibility that one of these downstream services won't respond correctly or simply fails completely. To prevent any cascading failures we set up a Hystrix fallback mechanism for our microservices.
Each microservice that implements Hystrix can choose to expose the Hystrix Metrics Streams (via the actuator endpoint <code>/hystrix.stream</code>) that can be viewed via the Hystrix Dashboard.
We've covered this in detail in <a target="_blank" href="/spring-cloud-hystrix">Spring Cloud: Hystrix</a> if you want to learn more.
<a rel="nofollow" target="_blank" href="https://github.com/Netflix/Turbine/wiki">Turbine</a> is an open-source tool from Netflix for aggregating multiple streams into a single stream. Spring provided a nice wrapper around it to be easily used in the Spring ecosystem.
<h2 id="setup">Setup</h2>
The setup is similar to the Spring Cloud: Hystrix setup. Here's what our back-end service looks like:
<ul>
<li>Eureka Server: Acts as a service registry and runs on port <code>8761</code>.</li>
<li>Recommendation Service: A simple REST service that has a single endpoint of <code>/recommendations</code> and runs on port <code>8070</code>.</li>
<li>User Service: A simple REST service that has a single endpoint of <code>/personalized/{id}</code> and runs on port <code>8060</code>.</li>
<li>Hystrix Turbine: A Hystrix dashboard service to display Hystrix streams running on port <code>9090</code>.</li>
</ul>
Here is what our services look like on the <a target="_blank" href="/spring-cloud-service-discovery-with-eureka/">Eureka server</a>:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-turbine-1.png" alt="spring-cloud-turbine-setup">
Both the <code>user-service</code> and <code>recommendation-service</code> have implemented the Hystrix fallback mechanism and have the <code>/hystrix.stream</code> endpoint exposed via <a rel="nofollow" target="_blank" href="https://docs.spring.io/spring-boot/docs/current/reference/html/production-ready-endpoints.html">Actuator</a>:
<ul>
<li>Hystrix endpoint for user-service: <code>http://localhost:8060/actuator/hystrix.stream</code></li>
<li>Hystrix endpoint for recommendation-service: <code>http://localhost:8070/actuator/hystrix.stream</code></li>
</ul>
We can check both this individually in our Hystrix Dashboard by typing the URL in the box and clicking &quot;Monitor Stream&quot;:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-turbine-2.png" alt="spring-cloud-turbine-dashboard">
We'll see a metric like this:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-turbine-3.png" alt="spring-cloud-turbine-dashboard-single-stream">
Note: If you don't see any stream, then you probably have to hit the endpoints of the service whose stream you want to see. Ex: for<code>user-service</code> we have to hit <code>http://localhost:8060/personalized/1</code> to generate the stream.
<h2 id="installingturbine">Installing Turbine</h2>
You might have realized that looking at the individual stream is not very productive, especially when we have many microservices.
Turbine can aggregate all these individual <code>hystrix.stream</code>s to a single <code>turbine.stream</code>, which can be viewed on the Hystrix Dashboard.
It uses the <code>DiscoveryClient</code> interface to find out relevant services that produce <code>/hystrix.stream</code>s.
To add Turbine to your Hystrix Dashboard, add the following dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt;
 &lt;artifactId&gt;spring-cloud-starter-netflix-turbine&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
Note: This is a starter dependency of turbine, which by default uses Spring Cloud Eureka as the discovery server. If you are using Spring Cloud Consul, use the following dependencies:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt;
 &lt;artifactId&gt;spring-cloud-netflix-turbine&lt;/artifactId&gt;
&lt;/dependency&gt;
&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt;
 &lt;artifactId&gt;spring-cloud-starter-consul-discovery&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
In this article we'll be using the starter dependency, i.e <code>spring-cloud-starter-netflix-turbine</code>.
To enable Turbine, we simply annotate our main class with <code>@EnableTurbine</code>:
<pre><code class="hljs">@SpringBootApplication
@EnableTurbine
@EnableDiscoveryClient
@EnableHystrixDashboard
public class HystrixTurbineApplication {

 public static void main(String[] args) {
 SpringApplication.run(HystrixTurbineApplication.class, args);
 }
}
</code></pre>
For Turbine to work as expected we have to add few details to our <code>application.properties</code>:
<pre><code class="hljs">server.port= 9090
spring.application.name= hystrix-turbine
eureka.client.serviceUrl.defaultZone= http://localhost:8761/eureka/
turbine.appConfig= user-service,recommendation-service
turbine.clusterNameExpression= new String(&quot;default&quot;)
</code></pre>
Here, we are telling Turbine the Eureka server location, applications whose <code>/hystrix.stream</code> it needs to fetch and <code>turbine.clusterNameExpression</code> as <code>new String(&quot;default&quot;)</code>, which gives the cluster name of &quot;default&quot;.
We can open up <code>http://localhost:9090/turbine.stream?cluster=default</code> to see the aggregate stream of both <code>user-service</code> and <code>recommendation-service</code>:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-turbine-4.png" alt="spring-cloud-turbine-stream">
Again, if you are not viewing anything, just hit the <code>user-service</code> and <code>recommendation-service</code> endpoints to generate the streams.
We can also use this URL on our Hystrix dashboard to generate a nice aggregated view:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-turbine-5.png" alt="spring-cloud-turbine-stream-in-dashboard">
Sometimes, you may want to use Eureka's <code>serviceId</code>s as cluster names for your dashboard. This can be done by using <code>turbine.aggregator.clusterConfig</code>:
<pre><code class="hljs">server.port= 9090
spring.application.name= hystrix-turbine
eureka.client.serviceUrl.defaultZone= http://localhost:8761/eureka/
turbine.aggregator.clusterConfig= USER-SERVICE,RECOMMENDATION-SERVICE
turbine.appConfig= user-service,recommendation-service
</code></pre>
You can also check what clusters are currently configured in your Turbine application by hitting the <code>/clusters</code> endpoint.
This endpoint can be disabled by setting <code>turbine.endpoints.clusters.enabled</code> to <code>false</code>.
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-turbine-6.png" alt="spring-cloud-turbine-cluster-endpoint">
So, now we can view <code>turbine.stream</code> as Eureka IDs such as: <code>http://localhost:9090/turbine.stream?cluster=USER-SERVICE</code>
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-turbine-7.png" alt="spring-cloud-turbine-service-id-cluster">
If there are multiple instances of a particular service running, Turbine will pick it up as per cluster and display it in the result.
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered how to set up the Turbine on top of our Hystrix stream for an aggregated view. We first saw the classical Turbine approach of fetching Hystrix stream from all services.
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-cloud/tree/master/spring-turbine">GitHub</a>.

Dhananjay Singh

Spring Cloud: Turbine

David Landup

Dan Nelson

Image Recognition and Classification in Python with TensorFlow and Keras

Adam McQuistan

Asynchronous Tasks in Django with Redis and Celery

<h2 id="introduction">Introduction</h2>
Hypertext Transfer Protocol (HTTP) is an application-layer protocol, which without exaggeration, is pretty much the backbone of Internet browsing as we know it.
It's used for transferring hypermedia documents between the client and the server and is an essential part of every single web application, including any APIs that use the REST architecture.
It allows the browser to communicate with the server by sending requests for certain documents, be it HTML documents (returned as the pages we see) or the hypermedia (pictures, videos, etc) that are served on the pages.
<h2 id="howdoeshttpwork">How Does HTTP Work?</h2>
When we decide to visit a website, what happens behind the curtains is that our computer generates and sends a request to the server on which the website is hosted.
An HTTP request could look something like this:
<pre><code class="hljs">GET /tag/java/ HTTP/1.1
Host: stackabuse.com
Accept: */*
User-Agent: Mozilla/5.0 (platform; rv:geckoversion) Gecko/geckotrail Firefox/firefoxversion
</code></pre>
Here, we request that the server sends back the page under the URL <code>stackabuse.com/tag/java/</code> using HTTP version 1.1.
What the server should respond is something like this:
<pre><code class="hljs">HTTP/1.1 200 OK
Date: Fri, 01 Feb 2019 22:07:06 GMT
Content-Type: text/html; charset=utf-8
Transfer-Encoding: chunked
Connection: keep-alive
Set-Cookie: __cfduid=dd40ff971a6cefddc4855e028541f79581549051234; expires=Sat, 01-Feb-20 22:07:06 GMT; path=/; domain=.stackabuse.com; HttpOnly; Secure
...
</code></pre>
Followed by the response body:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;
&lt;head&gt;
 &lt;meta charset=&quot;utf-8&quot; /&gt;
 &lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot; /&gt;
 &lt;title&gt;java - Page 1 - Stack Abuse&lt;/title&gt;
 &lt;meta name=&quot;description&quot; content=&quot;&quot; /&gt;
 &lt;meta name=&quot;keywords&quot; content=&quot;&quot;&gt;

&lt;!-- rest of the page --&gt;
</code></pre>
The response body will then be rendered in our browser and we're greeted with a page!
<img src="https://s3.amazonaws.com/stackabuse/media/how-to-send-http-requests-in-java-1.JPG" alt="stackabuse_java">
Besides the <code>HTTP/1.1 200 OK</code> status code that we've received as a response, there are several others that you have likely encountered in your daily lives:
<ul>
<li>1xx: Any status starting with '1' is an informational status. The request is received and is being processed.</li>
<li>2xx: Any status starting with '2' means that the request was successful. Most of the time it's <code>200 OK</code> which simply means that everything went smoothly.</li>
<li>3xx: Any status starting with '3' means that the user needs to be redirected to finish the action.</li>
<li>4xx: Any status starting with '4' indicates a client error. The most notorious one is <code>404 Not Found</code>, usually due to a bad request or syntax. Alongside it, there are <code>400 Bad Request</code>, <code>401 Unauthorized</code> and <code>403 Forbidden</code>. These status codes are the most common and there's a wide range of them.</li>
<li>5xx: Any status starting with '5' indicates a server error.</li>
</ul>
The <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/List_of_HTTP_status_codes">full list of HTTP status codes</a> is quite long, though it's not a bad idea to go through it.
<h2 id="sendingrequestswithhttpurlconnection">Sending Requests with HttpURLConnection</h2>
<a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/net/HttpURLConnection.html">HttpURLConnection</a> is the Java core class for handling HTTP requests and responses.
Using <code>HttpURLConnection</code> is perfectly fine for simple HTTP requests, though if you'd like to more easily add things like headers or authentication, you'll have an easier time relying on other libraries such as Apache Commons.
The simplest way to instantiate the <code>HttpURLConnection</code> object is using the <code>URL</code> object:
<pre><code class="hljs">URL url = new URL(&quot;https://www.stackabuse.com&quot;);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
</code></pre>
<h3 id="requesttypes">Request Types</h3>
Now that our <code>HttpURLConnection</code> instance exists, we can define an HTTP request type for it:
<pre><code class="hljs">// For a GET request
connection.setRequestMethod(&quot;GET&quot;);

// For a POST request
connection.setRequestMethod(&quot;POST&quot;);

// For a HEAD request
connection.setRequestMethod(&quot;HEAD&quot;);

// For a OPTIONS request
connection.setRequestMethod(&quot;OPTIONS&quot;);

// For a PUT request
connection.setRequestMethod(&quot;PUT&quot;);

// For a DELETE request
connection.setRequestMethod(&quot;DELETE&quot;);

// For a TRACE request
connection.setRequestMethod(&quot;TRACE&quot;);
</code></pre>
Though, in most cases you'll only use GET, POST, and DELETE.
<h3 id="requestparameters">Request Parameters</h3>
In some cases, we'd want to send an HTTP request with certain query parameters, such as <code>www.youtube.com/watch?v=dQw4w9WgXcQ</code>.
To achieve this, we'd usually come up with a way to pair these values. Sometimes, people define their own classes to hold these values, though a simple <code>HashMap</code> will do just fine:
<pre><code class="hljs">Map&lt;String, String&gt; params = new HashMap&lt;&gt;();
params.put(&quot;v&quot;, &quot;dQw4w9WgXcQ&quot;);
</code></pre>
Now that we have our parameter(s) mapped, we need to do a couple of things to get them prepared for our request:
<ul>
<li>Generate the parameter in a String-like format. We'll be using <code>StringBuilder</code> as it's ideal for concatenation that we'll perform</li>
<li>Use the <a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/index.html?java/net/URLEncoder.html">URLEncoder</a> class to encode our parameters</li>
<li>Convert the data into bytes, as our <code>DataOutputStream</code> that fires the request expects an array of type <code>byte</code></li>
</ul>
Note: If you're unsure why we need to encode our URL - it's because certain characters can have special meaning within URLs. Characters such as &quot;/&quot;, &quot;.&quot;, &quot;#&quot;, and &quot;?&quot; can alter the request, so if they're present we need to encode them in a way that won't affect how the URL is interpreted.
Let's implement the items from the list:
<pre><code class="hljs">// Instantiate a requestData object to store our data
StringBuilder requestData = new StringBuilder();

for (Map.Entry&lt;String, String&gt; param : params.entrySet()) {
 if (requestData.length() != 0) {
 requestData.append(&#x27;&amp;&#x27;);
 }
 // Encode the parameter based on the parameter map we&#x27;ve defined
 // and append the values from the map to form a single parameter
 requestData.append(URLEncoder.encode(param.getKey(), &quot;UTF-8&quot;));
 requestData.append(&#x27;=&#x27;);
 requestData.append(URLEncoder.encode(String.valueOf(param.getValue()), &quot;UTF-8&quot;));
}

// Convert the requestData into bytes 
byte[] requestDataByes = requestData.toString().getBytes(&quot;UTF-8&quot;);
</code></pre>
And thus, our parameter is ready to be used in the request.
<h3 id="requestheaders">Request Headers</h3>
If you'd like to add a header to a request, it's as easy as:
<pre><code class="hljs">connection.setRequestProperty(&quot;Content-Type&quot;, &quot;application/json&quot;);
connection.setRequestProperty(&quot;Content-Length&quot;, String.valueOf(requestDataBytes.length));
</code></pre>
And if you'd like to read a header from a request:
<pre><code class="hljs">String contentType = connection.getHeaderField(&quot;Content-Type&quot;);
</code></pre>
<h3 id="timeouts">Timeouts</h3>
Another feature <code>HttpURLConnection</code> offers is setting timeouts. We can define timeout intervals for reading or connecting:
<pre><code class="hljs">connection.setConnectTimeout(10000);
connection.setReadTimeout(10000);
</code></pre>
The intervals are, as usual, defined in milliseconds.
So, for example, the connection will timeout if it can't be established within 10 seconds. Similarly, it will also timeout if data can't be read from the connection within 10 seconds.
<h3 id="postrequest">POST Request</h3>
With our request all set up, we can go ahead and fire the POST request:
<pre><code class="hljs">// Set the doOutput flag to true
connection.setDoOutput(true);

// Get the output stream of the connection instance
// and add the parameter to the request
try (DataOutputStream writer = new DataOutputStream(connection.getOutputStream())) {
 writer.write(postDataBytes);
}
</code></pre>
Note: Since we're using a <a target="_blank" href="https://stackabuse.com/the-try-with-resources-statement-in-java/"><code>try-with-resources</code> block</a>, there's no need to flush and close the connection, as it's done automatically at the end of the block.
If you're using a traditional <code>try-catch</code> block, remember to always flush and close the connection:
<pre><code class="hljs">// Always flush and close
writer.flush();
writer.close();
</code></pre>
Here we're sending <code>postDataBytes</code> in our POST request, which is an array of bytes. Check out the demo below for more details on how to generate this.
<h3 id="getrequest">GET Request</h3>
Once we send a POST request, we'd typically want to do something to (or at least view) the response.
GET requests are only meant to retrieve data, so let's go ahead and get a response:
<pre><code class="hljs">// To store our response
StringBuilder content;

// Get the input stream of the connection
try (BufferedReader input = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
 String line;
 content = new StringBuilder();
 while ((line = input.readLine()) != null) {
 // Append each line of the response and separate them
 content.append(line);
 content.append(System.lineSeparator());
 }
} finally {
 connection.disconnect();
}

// Output the content to the console
System.out.println(content.toString());
</code></pre>
We can extract many different kinds of information from the <code>connection</code> at this point:
<pre><code class="hljs">// Returns the value of the content-type header field
connection.getContentType();

// Returns an unmodifiable Map of the header fields
connection.getHeaderFields();

// Gets the status code from an HTTP response message
connection.getResponseCode();

// Gets the HTTP response message returned along with the response code from a server
connection.getResponseMessage();

// Returns the error stream if the connection failed but the server sent useful data nonetheless
connection.getErrorStream();

// ...etc
</code></pre>
<h2 id="demo">Demo</h2>
Here's how a very simple application would generate a POST request, send it, and then read the response:
<pre><code class="hljs">public static void main(String[] args) throws MalformedURLException, ProtocolException, IOException {
 URL url = new URL(&quot;https://www.youtube.com&quot;);
 HttpURLConnection connection = (HttpURLConnection) url.openConnection();

 connection.setRequestMethod(&quot;POST&quot;);
 Map&lt;String, String&gt; params = new HashMap&lt;&gt;();
 params.put(&quot;v&quot;, &quot;dQw4w9WgXcQ&quot;);

 StringBuilder postData = new StringBuilder();
 for (Map.Entry&lt;String, String&gt; param : params.entrySet()) {
 if (postData.length() != 0) {
 postData.append(&#x27;&amp;&#x27;);
 }
 postData.append(URLEncoder.encode(param.getKey(), &quot;UTF-8&quot;));
 postData.append(&#x27;=&#x27;);
 postData.append(URLEncoder.encode(String.valueOf(param.getValue()), &quot;UTF-8&quot;));
 }

 byte[] postDataBytes = postData.toString().getBytes(&quot;UTF-8&quot;);
 connection.setDoOutput(true);
 try (DataOutputStream writer = new DataOutputStream(connection.getOutputStream())) {
 writer.write(postDataBytes);

 StringBuilder content;

 try (BufferedReader in = new BufferedReader(
 new InputStreamReader(connection.getInputStream()))) {
 String line;
 content = new StringBuilder();
 while ((line = in.readLine()) != null) {
 content.append(line);
 content.append(System.lineSeparator());
 }
 }
 System.out.println(content.toString());
 } finally {
 connection.disconnect();
 }
}
</code></pre>
Running this piece of code surely enough yields the source code of the page we specified to get:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;sr&quot; data-cast-api-enabled=&quot;true&quot;&gt;
&lt;head&gt;
&lt;!-- rest of the page --&gt; 
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Hypertext Transfer Protocol (HTTP) is an application-layer protocol which, without exaggeration, is a very large and critical component to Internet applications.
<code>HttpURLConnection</code> is the Java core class for handling HTTP requests and responses.
Using <code>HttpURLConnection</code> is perfectly fine for simple HTTP requests, though if you'd like to create more complex HTTP requests with headers or authentication, you'll have a much simpler experience with libraries such as Apache Commons.