Definitions of JRE JDK JVM J2SE J2EE

Java SE Overview

There are two principal products in the Java SE platform family: Java SE Runtime Environment (JRE) and Java Development Kit (JDK).

Java Runtime Environment (JRE)
The Java Runtime Environment (JRE) provides the libraries, the Java Virtual Machine, and other components to run applets and applications written in the Java programming language. In addition, two key deployment technologies are part of the JRE: Java Plug-in, which enables applets to run in popular browsers; and Java Web Start, which deploys standalone applications over a network. It is also the foundation for the technologies in the Java 2 Platform, Enterprise Edition (J2EE) for enterprise software development and deployment. The JRE does not contain tools and utilities such as compilers or debuggers for developing applets and applications.
Java Development Kit (JDK)
The JDK is a superset of the JRE, and contains everything that is in the JRE, plus tools such as the compilers and debuggers necessary for developing applets and applications. The conceptual diagram above illustrates all the component technologies in Java SE platform and how they fit together.

Java SE API

The Java SE application programming interface (API) defines the manner by which an applet or application can make requests to and use the functionality available in the compiled Java SE class libraries. (The Java SE class libraries are also part of the Java SE platform.)
The Java SE API consists of core technologies, Desktop (or client) technologies, and other technologies.

• Core components provide essential functionality for writing powerful enterprise-worthy programs in key areas such as database access, security, remote method invocation (RMI), and communications.
• Desktop components add a full range of features to help build applications that provide a rich user experience – deployment products such as Java Plug-in, component modeling APIs such as JavaBeans, and a graphical user interface.
• Other components round out the functionality.

Java Virtual Machine
The Java Virtual Machine is responsible for the hardware- and operating system-independence of the Java SE platform, the small size of compiled code (bytecodes), and platform security.
Java Platform Tools
The Java SE platform works with an array of tools, including Integrated Development Environments (IDEs), performance and testing tools, and performance monitoring tools.

Java EE Overview

The Java 2 Platform, Enterprise Edition (J2EE) defines the standard for developing multitier enterprise applications. The J2EE platform simplifies enterprise applications by basing them on standardized, modular components, by providing a complete set of services to those components, and by handling many details of application behavior automatically, without complex programming.

The J2EE platform takes advantage of many features of the Java 2 Platform, Standard Edition (J2SE), such as "Write Once, Run Anywhere" portability, JDBC API for database access, CORBA technology for interaction with existing enterprise resources, and a security model that protects data even in internet applications. Building on this base, the Java 2 Platform, Enterprise Edition adds full support for Enterprise JavaBeans components, Java Servlets API, JavaServer Pages and XML technology. The J2EE standard includes complete specifications and compliance tests to ensure portability of applications across the wide range of existing enterprise systems capable of supporting the J2EE platform. In addition, the J2EE specification now ensures Web services interoperability through support for the WS-I Basic Profile.
The J2EE specification also supports emerging Web Services technologies through inclusion of the WS-I Basic Profile . WS-I Basic Profile compliance means that the developers can build applications on the J2EE platform as Web services that interoperate with Web services from non-J2EE compliant environments.

With simplicity, portability, scalability, and legacy integration, the J2EE platform is the platform for enterprise solutions.

For more info
                    Source(J2SE) sun.com
                    Source(J2EE) sun.com

Java’s String pooling

A string pool is a collection of references to String objects.

Strings, even though they are immutable, are still objects like any other in Java. Objects are created on theheap and Strings are no exception.

So, Strings that are part of the "String Literal Pool" still live on the heap, but they have references to them from the String Literal Pool.

When a .java file is compiled into a .class file, any String literals are noted in a special way, just as all constants are. When a class is loaded (note that loading happens prior to initialization), the JVM goes through the code for the class and looks for String literals. When it finds one,  it checks to see if an equivalent String is already referenced from the heap. If not, it creates a String instance on the heap and stores a reference to that object in the constant table. Once a reference is made to that String object, any references to that String literal throughout your program are simply replaced with the reference to the object referenced from the String Literal Pool.

If you use the new keyword, a new String object will be created. Note that objects are always on the heap - the string pool is not a separate memory area that is separate from the heap.

The string pool is like a cache. If you do this:

String s = "abc";
String p = "abc";

then the Java compiler is smart enough to make just one String object, and s and p will both be referring to that same String object. If you do this:

String s = new String("abc");

then there will be one String object in the pool, the one that represents the literal "abc", and there will be a separate String object, not in the pool, that contains a copy of the content of the pooled object. Since String is immutable in Java, you're not gaining anything by doing this; calling new String("literal") never makes sense in Java and is unnecessarily inefficient.

Note that you can call intern() on a String object. This will put the String object in the pool if it is not already there, and return the reference to the pooled string. (If it was already in the pool, it just returns a reference to the object that was already there). See the API documentation for that method for more info.

Java String intern Function

public String intern() 

Returns a canonical representation for the string object.

A pool of strings, initially empty, is maintained privately by the class String.

When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.

Source  Stack Overflow  &  allinterview.com

Inversion of Control ( IOC ) Design pattern

Inversion of Control (IoC) design pattern  Basics

The Inversion of Control (IoC) pattern is also known as Dependency Injection.

The basic concept of the Inversion of Control pattern is that programmers don’t need to create the objects but describe how they should be created.

IOC  design pattern  alleviates  application objects from the responsibility of creating, and managing their dependencies. Instead, these application objects are free to concentrate solely on fulfilling their business purpose .

Types of IoC
     Interface Injection (Type 1)
     Setter Injection (Type 2)
     Constructor Injection (Type 3)

Some frameworks implementing IOC

Avalon , Spring and PicoContainer .

For more detailed Information on IOC 

Introduction to IOC (Inversion of Control)
Inversion of Control Containers and the Dependency Injection pattern

Servlet Container & Request processing

Why we need Container for Servlets?

    Servlets don't have main() method,They run under
    control of another java application called container.
    Ex: Tomcat

When Server gets request for servlet the server handovers
the request to container in which Servlet is deployed.

In simple "Container manages and runs the Servlet".

Advantages of using Container:

Communication
The container provides easy way of communication between servlets and web server.

Life-cycle Management:
The container controls the life cycle of servlet.
    Loading classes.
    Instantiating and initializing the servlet.
    Invoking servet methods ie  like init service & destroy .
    Destroying servlets for garbage collection ( Resource management ).

Threading support:
Container automatically creates a new java thread for every
request it receives.The thread dies when servlet completes
running the HTTP service method.
  
Security:   
    Container provides XML based configuration for security configuration and
modification of servlet with out changing the java code of servlet.
  
JSP support:
    Container takes care of converting JSP code into java.      

Handling the request:

When user request for Dynamic content
1)Container gets request  for servlet.
2)Container creates HTTPServletResponse and HTTPResponse objects.
3)Based on the requested URL Container maps the request to a  sevlet
and creates a thread for the request  and  passes the references of
HTTPServletResponse and HTTPResponse objects.
4)Container calls the service(),Which in-turn calls the doXXX()
methods based on the request type.
5)the doXXX() method constructs the dynamic page into HTTPResponse object.
6)When response is sent to client container deletes the objects and thread.

Creating jasper reports in 4 simple steps

Download the jasper reports Lib and Source from here.
Intro:
    JasperReports is an open-source Java class library
    designed to aid developers with the task of adding
    reporting capabilities to Java applications.
    JasperReports is licensed under the Lesser GNU Public License (LGPL).
Features:
    It has flexible report layout.
    It is capable of presenting data textually or graphically.
    It allows developers to supply data in multiple ways.
    It can accept data from multiple datasources.
    It can generate watermarks.
    It can generate subreports.
    It is capable of exporting reports to a variety of formats.
Flow chart of Jasper Reports Creation
    We can Create Jasper report in Following four steps.

Create JRXML files:
    The first step is to create a report template
    as an XML file.Even though JasperReports'
    report templates are XML files,template filenames
    are given an extension of .jrxml.
    JasperReports XML templates are commonly referred to as JRXML files
Compile JRXML files to create Jasper File :
    JRXML files are compiled into a JasperReports
    native binary template.The resulting compiled
    template is commonly known as the Jasper
    file, and is typically saved to disk with a .jasper extension.
Fill The report:
    The Jasper file is then used to generate the final report,
    by providing it with its required data.
    This process is known as filling the report.
Display the report:
    Filled reports can be saved to disk in a JasperReports 
    native format. Reports saved in this format are known
    as JasperPrint files.
    JasperPrint file names have a .jrprint extension.
    JasperPrint files can be exported to other
    formats so that they can be opened with commonly
    available tools like PDF viewers and word processors.

MySQL monitoring Using ' mycheckpoint '

Download the packge from here .
Dependencies
    yum install MySQL-python.
Installation   
  untar the file and run follwoing commands
          tar xzfv mycheckpoint-XXX.tar.gz
          cd mycheckpoint-XXX
          sudo python setup.py install

Run follwing commads on mysql prompt
     CREATE DATABASE mycheckpoint;   
     GRANT ALL PRIVILEGES ON mycheckpoint.* TO                        
                     'monitoring_user'@'localhost' IDENTIFIED BY '_password';
    GRANT SUPER ON *.* TO 'monitoring_user'@'localhost';
    GRANT REPLICATION CLIENT ON *.* TO 'monitoring_user'@'localhost';

Run following command on command prompt
  
           mycheckpoint --user=monitoring_user --password=_password
           --host=localhost --socket=/tmp/mysql.sock -v --chart-width=500
           --chart-height=300 deploy

Creating defaults-file:

[client]
user=monitoring_user
password=_password
socket=/tmp/mysql.sock
port=3306
host=localhost
Create a file with above contents and save it as /root/.my-checkpoint.cnf
make follwing crontab entry

      */5 * * * *     mycheckpoint --defaults-file=/root/.my-checkpoint.cnf

Detecting parameters change:
   
    SELECT * FROM sv_param_change;
   
Generating Google charts:
    DESC sv_report_chart_sample;

    SELECT DML FROM sv_report_chart_hour \G
     we can create google charts for all the values in sv_report_chart_sample.

Generating HTML reports:

        mysql --user=monitoring_user --password=_password
                   --host=localhost   mycheckpoint 
                    -e "SELECT html FROM sv_report_html" --silent --raw >
                       /tmp/mycheckpoint_report.html

Generating human Readable reports:

Previous hour’s report by:

    SELECT report FROM sv_report_human_hour ORDER BY id DESC LIMIT 1,1 \G

Last week’s report by:

    SELECT report FROM sv_report_human_day WHERE ts = DATE(NOW()) - INTERVAL 7 DAY\G

And all 24 of yesterday’s hourly reports by:

    SELECT report FROM sv_report_human_hour WHERE ts >= DATE(NOW()) - INTERVAL 1 DAY AND ts < DATE(NOW())\G
   
Replication Monitoring:
   
    SELECT seconds_behind_master FROM sv_report_chart_hour\G

Estimating slave catchup time   

    SELECT ts, estimated_slave_catchup_seconds FROM sv_report_hour;

Configuration of MySQL network related variables

max_connect_errors

connect_timeout

skip-name-resolve

slave_net_timeout

For more details ...