How to Create Sitemap - Make Sitemap Generator

How to make Sitemap or Sitemap Generator

People always search on google to generate sitemap for own website. There are two popular versions of a site map. An XML Sitemap is a structured format that a user doesn't need to see, but it tells the search engine about the pages in a site, their relative importance to each other, and how often they are updated. HTML sitemaps are designed for the user to help them find content on the page, and don't need to include each and every subpage.
            Here, I will not give information how to make sitemap but I will teach you how to make your own sitemap generator, So Web Developers can easily make sitemap.

 Lets Make your own Sitemap Generator

Follow below steps:

Step 1:
Make HTML file with name Sitemap.html
Here is code
 <!DOCTYPE html>  
     <title>Sitemap Ganerator</title>     
         <td width="200px">Enter links:</td>  
           <Textarea name="recommend" rows="22" id="txtOutput" cols="100"></Textarea>  
     <button id="DownloadButton">Create file</button>  
     <div id="generated" style="display:none">  
       <a href="#" id="DownloadLink">Download</a>  
       <textarea id="ResultXml" style="width: 100%; height: 30em" readonly="readonly"></textarea>  

Step 2:
Put below code before </head>. Its JS source files.
 <script src=""></script>  
 <script type="text/javaScript" src="sitemap.js"></script>  

Step 3:
Make JavaScript file with name sitemap.js
Here is code
 $(function() {  
       var template = [  
         '<?xml version="1.0" encoding="UTF-8"?>',    '<urlset',  
         '<!-- Code by Rakesh Patil, Protected with DMCA-->',  
       function update() {  
         var $root = $('<XMLDocument />');  
         $(document).ready(function() {  
           var arrayOfLines = $('textarea[name=recommend]').val().split('\n');  
           $.each(arrayOfLines, function(index, item) {  
                     $('<url />').append  
                         $('<loc />').append(item),  
                         $('<priority />').append('1'),  
                         $('<changefreq />').append('monthly')  
             var variables = {  
               'loc': $root.html()  
             var newXml = template.replace(/<\?(\w+)\?>/g, function(match, name) {  
               return variables[name];  
                 .attr('href', 'data:text/xml;base64,' + btoa(newXml))  
                 .attr('download', 'sitemap.xml');  
       if (!window.btoa) {  
       btoa = function (input) {  
       var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';  
           var result = '';  
           var chr1, chr2, chr3;  
           var enc1, enc2, enc3, enc4;  
           var i = 0;  
           do {  
       chr1 = input.charCodeAt(i++);  
           chr2 = input.charCodeAt(i++);  
           chr3 = input.charCodeAt(i++);  
      enc1 = chr1 >> 2;  
      enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);  
      enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);  
      enc4 = chr3 & 63;  
      if (isNaN(chr2)) {  
       enc3 = enc4 = 64;  
      } else if (isNaN(chr3)) {  
       enc4 = 64;  
      result += chars.charAt(enc1) + chars.charAt(enc2) + chars.charAt(enc3) + chars.charAt(enc4);  
     } while (i < input.length);     
     return result;  

Step 4:
Save all files in one folder and open Sitemap.html in browser. Done.
Now your own sitemap generator is ready to make sitemap for your website.
If any query or problem, free to ask via comment.
Note: Don't use above code to publish on website or blog.


Java Filter Problem Solution

           A filter is an object that is used to perform filtering tasks such as conversion, log maintain, compression, encryption and decryption, input validation etc. I'm not going to discuss about Java filter tutorial or javax filter tutorial here, there are many sites and books provide good tutorial for how to use java servlet filter in application.
           One common problem to exclude css, javaScript or any image and icon content with Java Filter in Java Web Application. Its a particular issue when during authentication via filter in java web application. Here I explain how to out from problem with java filter in java web application.

For example if we want to exclude css which in use with before authentication or home page accessible without even being logged in, we can add below code to resolve the issue.
       this.context.log("Unauthorized access request");  
       // pass the request along the filter chain  
       chain.doFilter(request, response);  
Do same as with javaScript or jQuery file
       this.context.log("Unauthorized access request");  
       // pass the request along the filter chain  
       chain.doFilter(request, response);  
 we can also use regular expressions or regex
       this.context.log("Unauthorized access request");  
       // pass the request along the filter chain  
       chain.doFilter(request, response);  

So this is the easy way to make pages or contents becomes accessible without even being logged in with Java Filter in Java Web application
If anyone have any query or problem then free to ask via comment.

File Handling using Input-Output Streams in Java

        Java provides an extensive library of classes for managing input and output of all forms of data. These classes are built around a stream model. You can think of a stream as a sequence of characters (in the case of textual data) or bytes (in the case of binary data) that can be accessed in order. A stream can represent many different kinds of sources and destinations, disk files, devices, other programs, etc. Streams support many different kinds of data simple bytes, primitive data types, localized characters, and objects. Some streams simply pass on data; others manipulate and transform the data in useful ways. Data is transferred to devices by streams. There is a better approach created to File handling using input output Stream in Java.
The goal of InputStream and OutputStream is to abstract different ways to input and output: whether the stream is a file, a web page, or the screen shouldn't matter. All that matters is that you receive information from the stream. The package contains a full set of Input and Output streams; Java programs use input streams to read data from some input source and output streams to write data to some output source. Input and output sources can be anything that can contain data: a file, a string, or memory.

Java views a file as a stream of bytes. File ends with end-of-file marker or a specific byte number. File as a stream of bytes associated with an object.
Java also associates streams with devices 
  •, System.out, and System.err 
  •      Streams can be redirected
You would typically first read from the input stream and then close it. You can wrap the FileInputStream in another InputStream (or Reader). It will be automatically closed when you close the wrapping stream/reader.

Java I/O Stream can be defined as below 3 types:

1. Byte Streams

Programs use byte streams to perform input and output of 8-bit bytes. Byte Streams classes are rooted as
  • InputStream
  • OutputStream
There are many byte stream classes for example FileInputStream and FileOutputStream. Following example shows how to use these classes to copy file.

Example to copy a file
 public class CopyBytes { public static void main(String[] args) throws IOException  
   FileInputStream in = null;  
   FileOutputStream out = null;  
   try {  
     in = new FileInputStream(“myfile.txt");  
     out = new FileOutputStream("outagain.txt");  
     int c;  
     while ((c = != -1) {  
       out.write(c); }  
   } finally {  
      if (in != null) {  
     if (out != null)  
     { out.close(); }  
   }} }  
Important Methods
  • int read() : Reads a byte of data from this input stream
  • int read(byte[] b) : Reads up to b.length bytes of data from this input stream into an array of bytes
  • void write (int b) : Writes the specified byte to this file output stream.
  • void write(byte[] b) : Writes b.length bytes from the specified byte array to this file output stream.
  • void close() : Closes the file input and output streams and releases any system resources associated with the stream

2. Character Streams

The Java platform stores character values using Unicode conventions. Character stream I/O automatically translates this internal format to and from the local character set. A program that uses character streams in place of byte streams automatically adapts to the local character set. Root Classes for Character Streams
  • Reader Class
  • Writer Class (both are abstract)
Character streams are often “wrappers” for byte streams. The character stream uses the byte stream to perform the physical I/O, while the character stream handles translation between characters and bytes. FileReader, for example, uses FileInputStream, while FileWriter uses FileOutputStream.

Copy Characters Example
 public class CopyCharacters {  
   public static void main(String[] args) throws IOException {  
   FileReader inputStream = null;  
   FileWriter outputStream = null;  
    try {  
     inputStream = new FileReader(“myfile.txt");  
     outputStream = new FileWriter("characteroutput.txt");  
     int c;  
     while ((c = != -1)  
        { outputStream.write(c); }  
     } finally {  
        if (inputStream != null)  
       { inputStream.close();  
       } if (outputStream != null)  
       { outputStream.close();  
   } } } }  
Input and Output Streams
Can read from these streams. Root classes of all input streams:
  • The InputStream Class
  • The Reader Class
Output or sink (destination) streams. Can write to these streams. Root classes of all output streams:
  • The OutputStream Class
  • The Writer Class
Control Flow of an I/O operation
  1. Create a stream object and associate it with a datasource (data-destination)
  2. Give the stream object the desired functionality through stream chaining while (there is more information)
  3. read(write) next data from(to) the stream
  4. close the stream

3. Buffered Streams

The examples shown so far use unbuffered I/O. This means each read or write request is handled directly by the underlying OS. This can make a program much less efficient, since each such request often triggers disk access, network activity, or some other operation that is relatively expensive. To reduce this kind of overhead, the Java platform implements buffered I/O streams. Buffered input streams read data from a memory area known as a buffer. Similarly, buffered output streams write data to a buffer. A program can convert an unbuffered stream into a buffered stream using the wrapping.
 inputStream = new BufferedReader(new FileReader("xanadu.txt"));  
 outputStream = new BufferedWriter(new FileWriter("characteroutput.txt"));  
There are four buffered stream classes used to wrap unbuffered streams:
  • BufferedInputStream
  • BufferedOutputStream (create buffered byte streams )
  • BufferedReader
  • BufferedWriter (create buffered character streams )
Flushing Buffered Streams
It often makes sense to write out a buffer at critical points, without waiting for it to fill. This is known as flushing the buffer. To flush a stream manually, invoke its flush method. The flush method is valid on any output stream, but has no effect unless the stream is buffered. Some buffered output classes support autoflush, specified by an optional constructor argument. When autoflush is enabled, certain key events cause the buffer to be flushed. For example, an autoflush PrintWriter object flushes the buffer on every invocation of println or format
CopyLine Example
 public class CopyLines { public static void main(String[] args) throws IOException {  
 BufferedReader  inputStream = null;  
 PrintWriter  outputStream = null;  
 try {  
   inputStream = new BufferedReader(new FileReader("xanadu.txt"));  
   outputStream = new PrintWriter(new FileWriter("characteroutput.txt"));  
 String l;  
  while ((l = inputStream.readLine()) != null) {  
   outputStream.println(l); }  
   } finally { if (inputStream != null)  
     { inputStream.close(); } if (outputStream != null)  
     { outputStream.close(); } } } }  
I/O from the Command Line
The Java platform supports three Standard Streams:
  • Standard Input, accessed through;
  • Standard Output, accessed through System.out; and
  • Standard Error, accessed through System.err
These standard streams are byte streams. To use Standard Input as a character stream, wrap in InputStreamReader.

ReadingLine Example
 public class ReadString {  
   public static void main (String[] args) {  
       System.out.print("Enter your name: ");  
    BufferedReader br = new BufferedReader(new InputStreamReader(;  
    String  userName = null;  
    // read the username from the command-line;  
    try {  
      userName = br.readLine();  
    } catch (IOException ioe) {  
        System.out.println("IO error trying to read your name!");  
    System.out.println("Thanks for the name, " + userName);  
 } // end of ReadString class  

Hope you get better understanding from above article about Java I/O streams.


JSch: SCP a File in Java

If you want to upload a file to another computer, SCP is an excellent way to go. And if you want to do it from within a Java program, your best bet is to use the JSch library from JCraft. They've implemented the SSH protocol purely in Java, and it works splendidly. I've written a nice little class that encapsulates the action of sending a file.

Using the class is pretty simple. It goes like this:
 FileSender fs = new FileSender("", "user", "user");  
 boolean ret = fs.sendFile("/home/sschulte/Desktop/AllPhysics.wmv", "AllPhysics.wmv");  
The constructor takes a host, a username, and a password. The sendFile() method takes a source filename and a destination filename. It returns true if the upload was successful, false if it failed.

I developed it in Netbeans, and in order to use JSch, the first step is to download the JAR and add it as a library in your project. (When I first tried it, I downloaded the ZIP instead, and added the source to my project; this works, but it's not necessary to compile this library along with your project unless you plan to edit it. I didn't.)

Most of the code in this class is taken from the ScpTo example included in the ZIP file. I recommend reading it. Something to pay close attention to, however, is the SSH known_hosts file. Their example file doesn't take this into account, so if you just run their code, you get an unknown host exception and it doesn't work. So be sure to include the following:
 String knownHostsFilename = "/home/sschulte/.ssh/known_hosts";  
(This is, of course, after you instantiate your JSch object.)

I like it, and it works. But it definitely needs a few things before I'm satisfied.
  • Read the known_hosts filename from a config file, rather than compiling it into the code.
  • Have a config file for the host/username/password information, possibly for multiple hosts at once.
  • Throw exceptions for various types of failures, rather that simply returning false.

Learn inner classes in Java

Inner class, also called Nested class, is a non-static class which is defined inside another class. Inner classes are nothing but classes that are defined within other classes. The nesting is a relationship between classes, not objects.
They may be defined as public, protected, private, or with package access. They may only be used "in the context" of the containing class (outer class, or enclosing class), unless they are marked as static

Java inner classes have feature that makes them richer and more useful. An object of an inner class has an implicit reference to the outer class object that instantiated it. Through this pointer, it gains access to any variable of the outer object. Only static inner classes don’t have this pointer. It is actually invisible when we write the code, but compiler takes care of it. Inner classes are actually a phenomenon of the compiler and not the JVM.

Inner Classes:

  • The outer class (the class containing the inner class) can instantiate as many number of inner class objects as it wishes, inside it’s code.
  • If the inner class is public & the containing class as well, then code in some other unrelated class can as well create an instance of the inner class.
  • No inner class objects are automatically instantiated with an outer class object.
  • If the inner class is static, then static inner class can be instantiated without an outer class instance, otherwise, the inner class object must be associated with an instance of the outer class.
  • Inner class code has free access to all elements of the outer class object that contains it, by name (no matter what the access level of the elements is), if the inner class has a varible with same name then the outer class’s variable can be accessed.
There are two more types of inner classes, i.e local inner classes & anonymous inner classes. The local inner class are defined within a method. Anonymous inner classes are also defined with in a method but have no name.

Local Inner Classes:

  • Local classes are never declared with an access specifier (that is, public or private). Their scope is always restricted to the block in which they are declared.
  • Local classes have a great advantage: they are completely hidden from the outside world.
  • They can not only access the instance variables but local variables of the method (in which they are defined) as well, but the local varible has to be declared final.

Anonymous Inner Classes:

When using local inner classes, you can often go a step further. If you want to make only a single object of this class, you don’t even need to give the class a name.
Such a class is called an anonymous inner class. Usually the inner class extend some interface or extend other class.

  • Here, SuperType can be an interface, such as ActionListener; then, the inner class implements that interface. Or SuperType can be a class; then, the inner class extends that class.
  • An anonymous inner class cannot have constructors because the name of a constructor must be the same as the name of a class, and the class has no name. Instead, the construction parameters are given to the superclass constructor. In particular, whenever an inner class implements an interface, it cannot have any construction parameters.

  • It is recommended to refrain from using them as many programmers find too many anonymous classes hard to read.

Static Inner Classes:

  • Static members of the outer class are visible to the static inner class, what ever their access level be.
  • Non-static members of the outer class are not available, because there is not instance of the outer class.
  • An inner class may not have static members unless the inner class is itself marked as static.
  • Sometimes static nested class are not refered to as inner class at all, as they don’t require outer classes instance.
  • A static inner class is just like any other inner class, but it dose not have the reference to its outer class object that generated it.
  • The outer class can call even the private methods of the inner class.

Example for Inner Classes:

public class OuterClass {
 private int x;
 OuterClass(int x, int y) {
  this.x = x;
  new InnerClass(y).privateDisplay();
 public class InnerClass {
  private int y;
  InnerClass(int y) {
   this.y = y;
  private void privateDisplay() {
   System.out.println("privateDisplay x = " + x + " and y = " + y);
  public void publicDisplay() {
   System.out.println("publicDisplay x = " + x + " and y = " + y);

Explanation of above example:
  • OuterClass has one property, x; the inner class InnerClass has one property, y
  • the OuterClass constructor accepts two parameters; the first is used to populate x
  • it creates one InnerClass object, whose y property is populated with the second parameter
  • note that the inner class has free access to the private outer class x element
  • and the outer class has free access to the private inner class privateDisplay() method
The connection between the two classes is handled automatically