Browsing File System Using Servlet

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.jini.FileList;

public class FileServlet extends HttpServlet {
      
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       
            String path = (String) request.getParameter("path");
            System.out.println("PATH => " + path);
           
             ServletContext context = request.getServletContext();
             String realPath = context.getRealPath("/");
             StringBuilder realPathBuilder = new StringBuilder();
             realPathBuilder.append(realPath);
             realPathBuilder.append("<br/>");
             System.out.println("ACTUAL PATH were this servlet exists => " + realPath);
           
            if(null != path && path.length() == 0 ){
                existOnError(response);
                return;
            }
           
            File[] fileList= FileList.FileList(path);
            if(fileList == null){
                existOnError(response);
                return;
            }
           
            System.out.println("File List .................... "  );
            StringBuilder filebuilder= new StringBuilder();
            for(int i=0; i<fileList.length;i++){
                File file = fileList[i];
                // System.out.println(file.toString());
                filebuilder.append("<a href=\"");
                filebuilder.append(file.toString());
                filebuilder.append("\">");
                filebuilder.append(file.toString());
                filebuilder.append("</a>");
                filebuilder.append("<br/>");
                //<a href="url">Link text</a>
            } // end of for
            filebuilder.append("<br/>");
          System.out.println("Directory List ....................... "  );
          StringBuilder dirbuilder= new StringBuilder();
          fileList= FileList.DirectoryList(path);
            for(int i=0; i<fileList.length;i++){
                File file = fileList[i];
                // System.out.println(file.toString());
                dirbuilder.append(file.toString());
                dirbuilder.append("<br/>");
            } // end of for
           
              // Set response content type
              response.setContentType("text/html");
              PrintWriter out = response.getWriter();
              out.println("================== SERVLET ACTUAL PATH ==================" + "<br/>");
              out.println(realPathBuilder.toString());
              out.println("=================== FILE LIST ==================" + "<br/>");
              out.println(filebuilder.toString());
              out.println("=================== DIRECTORY LIST ==================" + "<br/>");
              out.println(dirbuilder.toString());
       
    } // end of doGet()
   
    void existOnError(HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("=================== Invalid or Empty Path  ==================" + "<br/>");

    }
}

=============================
  <servlet>
      <servlet-name>FileServlet</servlet-name>
    <servlet-class>com.jini.FileServlet</servlet-class>
  </servlet>
   <servlet-mapping>
    <servlet-name>FileServlet</servlet-name>
    <url-pattern>/filelist</url-pattern>
  </servlet-mapping>
============================

File List Util

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

public class FileList {

    public static File[] FileList(String directoryName) {
        File dir = new File(directoryName);
        // // Filter files, not to return any files that start with `.'.
        // FilenameFilter filter = new FilenameFilter() {
        // public boolean accept(File dir, String name) {
        // return !name.startsWith(".");
        // }
        // };
        // This filter only returns directories
        FileFilter fileFilter = new FileFilter() {
            public boolean accept(File file) {
                return file.isFile();
            }
        };
        File[] files = dir.listFiles(fileFilter);
        return files;
    } // end of method

    public static File[] DirectoryList(String directoryName) {
        File dir = new File(directoryName);
        // This filter only returns directories
        FileFilter fileFilter = new FileFilter() {
            public boolean accept(File file) {
                return file.isDirectory();
            }
        };
        File[] files = dir.listFiles(fileFilter);
        return files;
    } // end of method

    public static String getCurrentDirPath() {
        File dir1 = new File(".");
        String currentDir = null;
        try {
            currentDir = dir1.getCanonicalPath();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return currentDir;
    } // end of getCurrentDir()

    public static String getParent() {
        File dir1 = new File("..");
        String parrentDir = null;
        try {
            parrentDir = dir1.getCanonicalPath();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return parrentDir;
    } // end of getParrentDir()

    public static void createDirectoryIfNotExist(String directoryName) {
        File theDir = new File(directoryName);
          // if the directory does not exist, create it
          if (!theDir.exists())
          {
            boolean result = theDir.mkdir();
            if(result)            {  
               System.out.println("Directory created ... ");
             } // end of if
          }
        } // end of createDirectory()
   
    public static void main(String[] args) {
        String path = "C:\\";
        File[] fileList = FileList(path);
        System.out.println("File List .................... ");
        for (int i = 0; i < fileList.length; i++) {
            File file = fileList[i];
            System.out.println(file.toString());
        } // end of for

        System.out.println("Directory List ....................... ");
        fileList = DirectoryList(path);
        for (int i = 0; i < fileList.length; i++) {
            File file = fileList[i];
            System.out.println(file.toString());
        } // end of for

        System.out.println("Current Directory Path ....................... "
                + getCurrentDirPath());

        System.out
                .println("Parent Path ....................... " + getParent());
    } // end of main

} // end of class

Reloadble Properties using Apache Commons Configuration

import java.io.File;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.configuration.reloading.FileChangedReloadingStrategy;
import org.apache.log4j.Logger;
public class ConfigUtil {
    private static Logger log = Logger.getLogger(ConfigUtil.class);
    private static PropertiesConfiguration configuration = null;
    private static final String PROPERTY_FILENAME = "config.properties";
    private static String RELOADBLE_PROPERTY_FILENAME = null;
    private static PropertiesConfiguration reloadConfiguration = null;
    static
    {
        try {
            configuration = new PropertiesConfiguration(PROPERTY_FILENAME);
            log.info("Loading property file from classpath :");
            RELOADBLE_PROPERTY_FILENAME = ConfigUtil.getProperty("RELOAD_PROERTY_FILENAME");
             if(null != RELOADBLE_PROPERTY_FILENAME){
                File f = new File(RELOADBLE_PROPERTY_FILENAME);
                if(f.exists()){
                    reloadConfiguration = new PropertiesConfiguration(RELOADBLE_PROPERTY_FILENAME);
                    reloadConfiguration.setReloadingStrategy(new FileChangedReloadingStrategy());
                    log.info("Loading reloadble property file from path : "  + RELOADBLE_PROPERTY_FILENAME);
                }else{
                    log.info("Error: reloadble property file not Found : "  + RELOADBLE_PROPERTY_FILENAME);
                    }
            } // end of if
          } catch (ConfigurationException e) {
          //  e.printStackTrace();
              log.debug(e.getStackTrace().toString());
        }
    }
    public static synchronized String getProperty(final String key)
    {
        if(reloadConfiguration != null){
            if(getReloadableProperty(key) != null){
                return getReloadableProperty(key);
            }
            else
                return  configuration.getString(key);
        }
        else
            return  configuration.getString(key);
    }
    private static synchronized String getReloadableProperty(final String key)
    {
        return  reloadConfiguration.getString(key);
    }
    public static void main(String[] args) {
        System.out.println(RELOADBLE_PROPERTY_FILENAME);
    }
}
=========================================
RELOAD_PROERTY_FILENAME=C:/config.properties
#DB Properties
db-url=jdbc:db2://127.0.0.1:3306/test
db-username=jini
db-password=123
=========================================
import com.jini.util.ConfigUtil;
public class zzZZTestReloading {
    public static void main(String[] args)
    {
        while(true)
        {
            try
            {
                Thread.sleep(2000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
                System.out.println(ConfigUtil.getProperty("DATASOURCE_ENABLE=TRUE"));
        }
    }
}
 

LOG4JDBC (JDBC proxy driver for logging SQL)

# Click => Here <= for help
########################################
# log4jdbc-log4j
# jdbc.driverClassName=net.sf.log4jdbc.DriverSpy
# Add to DB url=jdbc:log4
########################################
# Below lines in log4jdbc.properties file
log4jdbc.drivers=com.ibm.db2.jcc.DB2Driver
log4jdbc.auto.load.popular.drivers=false
log4jdbc.dump.booleanastruefalse=true
log4jdbc.trim.sql.extrablanklines=false
log4jdbc.dump.sql.addsemicolon=true
log4jdbc.dump.sql.select=true
log4jdbc.dump.sql.insert=true
log4jdbc.dump.sql.update=true
log4jdbc.dump.sql.delete=true
log4jdbc.dump.sql.create=true
log4jdbc.debug.stack.prefix=com.jini.dao
########################################
# log4jdbc-log4j2
# jdbc.driverClassName=net.sf.log4jdbc.sql.jdbcapi.DriverSpy 
# Below line in log4jdbc.log4j2.properties
log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator
########################################
# Below line in log4j.properties 
log4j.logger.jdbc.sqlonly=OFF
log4j.logger.jdbc.sqltiming=INFO,sql,stdout
log4j.logger.jdbc.audit=OFF
log4j.logger.jdbc.resultset=OFF
log4j.logger.jdbc.connection=OFF
log4j.logger.jdbc.resultsettable=INFO,sql,stdout

log4j.additivity.jdbc.sqlonly=false
log4j.additivity.jdbc.sqltiming=false
log4j.additivity.jdbc.audidt=false
log4j.additivity.jdbc.resultset=false
log4j.additivity.jdbc.connection=false
log4j.additivity.jdbc.resultsettable=false

## Daily rolling file appender for JDBC Log
#the appender used for the JDBC API layer call logging above, sql only
log4j.appender.sql=org.apache.log4j.DailyRollingFileAppender
log4j.appender.sql.File=logs/sql.log
llog4j.appender.sql.DatePattern='.'dd-MM-yyyy
log4j.appender.sql.layout=org.apache.log4j.PatternLayout
log4j.appender.sql.layout.ConversionPattern=%-5p [%d{DATE} %c]: %m%n
log4j.additivity.sql=false
log4j.appender.sql.Append=false
########################################

LOG4J

# Root logger option
log4j.rootLogger=INFO,stdout,file

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L -  %m%n`
#log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
#log4j.appender.stdout.layout.ConversionPattern=%p %t %c - %m%n

# Daily rolling file appender for PROJECT
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File=logs/logs.log
log4j.appender.file.DatePattern='.'dd-MM-yyyy
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{dd-MM-yyyy HH:mm:ss} %-5p %c{1}:%L - %m%n
#log4j.appender.file.layout.ConversionPattern=%p %t %c - %m%n

log4j.logger.jdbc.sqlonly=OFF
log4j.logger.jdbc.sqltiming=INFO,sql,stdout
log4j.logger.jdbc.audit=OFF
log4j.logger.jdbc.resultset=OFF
log4j.logger.jdbc.connection=OFF
log4j.logger.jdbc.resultsettable=INFO,sql,stdout

log4j.additivity.jdbc.sqlonly=false
log4j.additivity.jdbc.sqltiming=false
log4j.additivity.jdbc.audidt=false
log4j.additivity.jdbc.resultset=false
log4j.additivity.jdbc.connection=false
log4j.additivity.jdbc.resultsettable=false

## Daily rolling file appender for SQL Log
#the appender used for the JDBC API layer call logging above, sql only
log4j.appender.sql=org.apache.log4j.DailyRollingFileAppender
log4j.appender.sql.File=logs/sql.log
llog4j.appender.sql.DatePattern='.'dd-MM-yyyy
log4j.appender.sql.layout=org.apache.log4j.PatternLayout
log4j.appender.sql.layout.ConversionPattern=%-5p [%d{DATE} %c]: %m%n
log4j.additivity.sql=false
log4j.appender.sql.Append=false

## Spring JDBC logging
#log4j.logger.org.springframework.jdbc=DEBUG
#log4j.logger.org.springframework.jdbc.core.JdbcTemplate=DEBUG, file
##log4j.logger.org.springframework.jdbc.core.StatementCreatorUtils=TRACE, file

## Spring Transaction logging
#log4j.logger.org.springframework.transaction=INFO
#log4j.logger.org.springframework.transaction.interceptor=TRACE
##log4j.logger.org.springframework.jdbc.datasource.DataSourceTransactionManager=DEBUG
##log4j.logger.org.springframework.orm.jpa=INFO

## Hibernate Transaction logging
#log4j.logger.org.hibernate.SQL=DEBUG
#log4j.logger.org.hibernate.engine.transaction=DEBUG
#log4j.logger.org.springframework.orm.hibernate3.HibernateTransactionManager=DEBUG

# BoneCP Connection Pooling logging
#log4j.category.com.jolbox=DEBUG,stdout

XML Encoder and Decoder

import java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;

public class OXMUtil {
    public static void main(String args[]) {
        ArrayList testArrayList = new ArrayList();
        testArrayList.add(new String("Test"));
        testArrayList.add(new String("Test1"));
        String testString = objectToXML(testArrayList);
        System.out.println("XML String .....");
        System.out.println(testString);
        ArrayList finalArrayList = (ArrayList) XMLToObject(new String(
                testString));
        System.out.println("Actual Object.....");
        for (int i = 0; i < finalArrayList.size(); i++)
            System.out.println(finalArrayList.get(i).toString());
    }
    public static String objectToXML(Object voObj) {
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        XMLEncoder xmlEncoder = null;
        try {
            xmlEncoder = new XMLEncoder(new BufferedOutputStream(stream));
            xmlEncoder.writeObject(voObj);
            xmlEncoder.close();
            return stream.toString("UTF-8");
        } catch (Exception e) {
            System.out.println("Error while Converting from object to XML : "
                    + e.getMessage());
            xmlEncoder.close();
        }
        return null;
    }
    public static Object XMLToObject(String dataXML) {
        XMLDecoder xMLDecoder = null;
        try {
            xMLDecoder = new XMLDecoder(new ByteArrayInputStream(
                    dataXML.getBytes("UTF-8")));
            Object voObj = xMLDecoder.readObject();
            xMLDecoder.close();
            return voObj;
        } catch (Exception e) {
            System.out.println("Error while Converting XML to Object : "
                    + e.getMessage());
            xMLDecoder.close();
        }
        return null;
    }
}

ResultSet PrintColumns

package com.jini.jdbc;

import java.sql.*;
public class PrintColumns {
    public static void main(String args[]) {
        String url = "jdbc:mysql://localhost/test";
        Connection con;
        String query = "select * from STUDENT";
        Statement stmt;
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (java.lang.ClassNotFoundException e) {
            System.err.print("ClassNotFoundException: ");
            System.err.println(e.getMessage());
        }
        try {
            con = DriverManager.getConnection(url, "root", "123");
            stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery(query);
            ResultSetMetaData rsmd = rs.getMetaData();

            PrintColumnTypes.printColTypes(rsmd);
            System.out.println("");

            int numberOfColumns = rsmd.getColumnCount();

            for (int i = 1; i <= numberOfColumns; i++) {
                if (i > 1)
                    System.out.print(",  ");
                String columnName = rsmd.getColumnName(i);
                System.out.print(columnName);
            }
            System.out.println("");

            while (rs.next()) {
                for (int i = 1; i <= numberOfColumns; i++) {
                    if (i > 1)
                        System.out.print(",  ");
                    String columnValue = rs.getString(i);
                    System.out.print(columnValue);
                }
                System.out.println("");
            }

            stmt.close();
            con.close();
        } catch (SQLException ex) {
            System.err.print("SQLException: ");
            System.err.println(ex.getMessage());
        }
    }
} // end of class

class PrintColumnTypes {
    public static void printColTypes(ResultSetMetaData rsmd)
            throws SQLException {
        int columns = rsmd.getColumnCount();
        for (int i = 1; i <= columns; i++) {
            int jdbcType = rsmd.getColumnType(i);
            String name = rsmd.getColumnTypeName(i);
            System.out.print("Column " + i + " is JDBC type " + jdbcType);
            System.out.println(", which the DBMS calls " + name);
        }
    }
} // end of class

Beanutils CopyUtil

import java.lang.reflect.InvocationTargetException;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.BeanUtilsBean;
import org.apache.commons.beanutils.converters.DateConverter;
public class BeanPropertyCopyUtil {
        public static void copyProperties(Object src, Object dest, String... properties)
                    throws IllegalAccessException, InvocationTargetException, NoSuchMethodException
         {
            DateConverter dtConverter = new DateConverter();
            dtConverter.setPattern("dd-MMM-yyyy");
            BeanUtilsBean beanUtilsBean = BeanUtilsBean.getInstance();
            beanUtilsBean.getConvertUtils().register(dtConverter, java.util.Date.class);
           
                for (String property : properties) {
                        String[] arr = property.split(" ");
                        String srcProperty;
                        String destProperty;
                        if (arr.length == 2) {
                                srcProperty = arr[0];
                                destProperty = arr[1];
                        } else {
                                srcProperty = property;
                                destProperty = property;
                        }
                        String tmpStr = BeanUtils.getProperty(src, srcProperty).trim();
                        if(!tmpStr.equals("")){
                            //System.out.println("String is :" + tmpStr+":size:"+tmpStr.length() );
                            //BeanUtils.setProperty(dest, destProperty, BeanUtils.getProperty(src, srcProperty));
                            BeanUtils.setProperty(dest, destProperty, tmpStr);
                        }
                }
        } // end of method
}

Linear Search (Grouping)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Data;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ListMultimap;
class LinearSearchDemo {
      public static void main( String ... args ) {
          List list = Arrays.asList(
                                      Person.create("Oscar", 0x20),
                                      Person.create("Reyes", 0x30),
                                      Person.create("Java", 0x10),
                                      Person.create("Java", 0x20),
                                      Person.create("Java", 0x30),
                                        Person.create("Java", 0x40)
                              ); 
            // Based on Generic
           List result = searchIn(list, new Matcher() {
                public boolean matches(Person p) {
                    return p.getName().equals("Java");
                }
            });
            System.out.println("Using Generic : " + result);

            result = searchIn(list, new Matcher() {
                public boolean matches(Person p) {
                    return p.getAge() > 16;
                }
            });
            System.out.println(result);
            // Based on Guava Multimap
            ListMultimap peopleByFirstName = ArrayListMultimap.create();
            for (Person person : list) {
                peopleByFirstName.put(person.getName(), person);
            }
            System.out.println("Usign Guava : " + peopleByFirstName.get("Java"));
            // Normal Coding
            Map> map = new HashMap>();
            for (Person person : list) {
                String key = person.getName();
                if (map.get(key) == null) {
                    map.put(key, new ArrayList());
                }
                map.get(key).add(person);
            }
            System.out.println("Normal Coding :" + map.get("Java"));

      } // end of main

      public static List searchIn( List list , Matcher m ) {
          List r = new ArrayList();
          for( T t : list ) {
              if( m.matches( t ) ) {
                  r.add( t );
              }
          }
          return r;
      } // end of method

    } // end of class

    interface Matcher {
      public boolean matches( T t );
    } // end of interface

    @Data
    class Person {
      String name;
      int age;
      static Person create( String name, int age ) {
          Person p = new Person();
          p.name = name;
          p.age = age;
          return p;
      }
    } // end of class

Send Mail using Java

import java.util.Properties;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class MailTest {
     public static void main(String[] args) throws Exception{
        System.err.println("Sending Email : ");
        sendSMTP("bip@gmail.com", "Hi", "Testing from MailTest");
        System.err.println("Email Send Successfully : ");
    }
    // Set up the mail profile in the static initializer of the class
    private static final Properties props;
    static {
        props = new Properties();
        props.put("mail.transport.protocol", "smtp");
        props.put("mail.smtp.host", "gmail.com");
        props.put("mail.smtp.port", "25");
//      props.put("mail.smtp.port", "587");
        props.put("mail.stmp.user", "bg@gmail.com");
        props.put("mail.smtp.password", "doom3$");
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.starttls.required", "true");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.auth.ntlm.domain", "gmail.com");
        props.put("mail.smtp.auth.mechanisms", "LOGIN NTLM");
        props.put("mail.debug", "true");
        props.put("mail.smtp.ssl.trust", "gmail.com");
    }
    public static int sendSMTP(String toAddress, String subject, String content) throws Exception
    {
        InternetAddress from = new InternetAddress("bipin_gupta@syntelinc.com");
        InternetAddress recipient = new InternetAddress(toAddress);
        // Create a Session to send e-mail from static profile
        Session session = Session.getInstance(MailTest.props);
        // Create the message
        MimeMessage msg = new MimeMessage(session);
        msg.setFrom(from);
        msg.setSubject(subject);
        msg.setText(content);
        msg.addRecipient(Message.RecipientType.TO, recipient);
        msg.saveChanges();
        // Send the message
        Transport transport = session.getTransport(); 
transport.connect(props.get("mail.smtp.host").toString(),props.get("mail.stmp.user").toString(),props.get("mail.smtp.password").toString());
        transport.sendMessage(msg, msg.getAllRecipients());
        transport.close();
        return 0;
    }
}

JSTL Example

• JSTL Tutorial
• JSTL Sample 

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page isELIgnored ="false" %>

<table>
<tr>
    <th>UserId</th>
    <th>Name</th>
</tr>
    <c:forEach var="user" items="${ALLUSERLIST}">
    <tr>
        <td><c:out value="${user.userId}"/></td>
        <td><c:out value="${user.personName}"/></td>
    </tr>
</c:forEach>
</table>

<c:set var="salary" scope="session" value="${2000*2}"/>
<c:if test="${salary > 2000}">
   <p>My salary is: <c:out value="${salary}"/><p>
</c:if>

===============
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
================

Javascript Collection

Best Practices:  JavaScript should be at declared right before the closing body tag.
If script uses document.write to insert part of the page's content, it can't be moved lower in the page.
========================
onsubmit="return !!(ValidateEmail(document.PREMIUM_FORM.email) & ValidatePhone(document.PREMIUM_FORM.phone) )"
========================
function ValidateName(inputtxt)
{
    if(inputtxt.value=="")
    {
        alert("Please Enter Your Name");
        return false;
    }
    return true
}
========================
function ValidatePhone(inputtxt)
{

var phoneno = /^\d{10}$/;  

  var phoneno = /^\d{10}$/;
  if(inputtxt.value.match(phoneno))
     {
       return true;
     }
   else
     {
       alert("Please provide a valid Phone Number");
       return false;
     }
}
========================
function ValidateEmail(email)
{
    var filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
    if (!filter.test(email.value)) {
        alert("Please provide a valid email address");
    return false;
    }
    return true
}
========================
Example:
sample-javascript-registration
========================

Date and Time Method

    public static String getCurrentDateTime(){
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH.mm.ss");
        Date date = new Date();
        log.info("Current System Date_Time as : " + dateFormat.format(date));
        return dateFormat.format(date);
    } // end of method
   
    public static void storeCurrentDateTimeinPropertyFile(String currentDateTime) {
        //long hour = 3600 * 1000; // 3600 seconds times 1000 milliseconds
        Properties prop = new Properties();
        try {
            // set the properties value
            prop.setProperty("CurrentDateTime", currentDateTime);
            prop.store(new FileOutputStream(getCurrentDirPath()+"//" +"time.properties"), null);
            log.info("store current start_Date_Time to property file : " +  currentDateTime);
        } catch (IOException ex) {
            ex.printStackTrace();
        } // end of catch
    }
   
    // load from property file and parse to date and then increment it by one second
    public static void incDateTimeByOneSecoud(){
    try {
        Properties prop = loadProperty();
        String startTime = prop.getProperty("StartDateTime");
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH.mm.ss");
        Date date = dateFormat.parse(startTime);
        Date newDt = new Date(date.getTime() + 1000L);
        String newDT = dateFormat.format(newDt).toString();
        prop.setProperty("StartDateTime", newDT);
        prop.store(new FileOutputStream(getCurrentDirPath()+"//" +"time.properties"), null);
        log.info("increment C1_START_DATE_TIME  to property file : " + newDT);
        } catch (Exception ex) {
            ex.printStackTrace();
        } // end of catch
    } // end of method

 // load property file if missing then create new and reload it
private static Properties loadProperty(){
        Properties prop = new Properties();
        try {
            // load a properties file from class path, inside static method
            //prop.load(SyncTimeProperty.class.getClassLoader().getResourceAsStream("config.properties"));
             prop.load(new FileInputStream("time.properties"));
            log.info("loading property file : ");
        } catch (IOException ex) {
            ex.printStackTrace();
            log.info("Creating new property file : ");
            storeCurrentDateTimeinPropertyFile(getCurrentDateTime());
            return loadProperty();
        } // end of catch
        return prop;
    } // end of method

/shift the given Date by exactly 24 hours. 

private final static long MILLISECONDS_PER_DAY = 1000L * 60 * 60 * 24; 
public static void shiftDate(Date d) {
    long time = d.getTime();
    time += MILLISECONDS_PER_DAY;
    d.setTime(time);
}