It is a Java programming language for the implementation of scripting language which is developed by researchers at AT&T Labs. Its syntax and grammar is very learn for the people who are familiar with the C programming language and Java. This application is indistinguishable from a Java application, for a application developer, it provides a simpler coding.

It is a procedural scripting language which is inspired by Perl and Objective-C. It is the only known implementation of the language is written in Java intended for embedding into existing Java applications to provide scripting services. It integrates easier with applications.

It is a Java scripting language which was invented by Pat Niemeyer and runs in the Java Runtime Environment and mainly utilizes Java’s own syntax.

BeanShell allows its users to designate its functions that can be called from within a script, its main has been to not pollute its syntax with too many extensions and “syntactic sugar” and ensuring that code written for a Java compiler are executed interpretively by BeanShell without changes which make BeanShell a popular testing and debugging tool.

It is basically an open source project and has mainly been incorporated into many applications and provides easy integrated API and can run in command-line mode or within its graphical environment. It can be called as a part of java platform.

Apache Tomcat is the servlet container that is used in the official Reference Implementation for the Java Servlet and JavaServer Pages technologies. Apache Tomcat is developed in an open and participatory environment and released under the Apache Software License.

Apache Tomcat powers numerous large-scale, mission-critical web applications across a diverse range of industries and organizations.

INSTALLING TOMCAT

cd /root

wget http://www.visionexcomm.com/downloads/tc5-install.tar.gz

tar -zxvf tc5-install.tar.gz

cd TC5Install/

./pre-install.sh

./fix-my-jvm.sh

./install.sh

pico /usr/sbin/starttomcat
————————-
#!/bin/sh
export JAVA_HOME=/usr/local/jdk
export PATH=$JAVA_HOME/bin:$PATH
export XML=$JAVA_HOME/lib
export SSL=$JAVA_HOME/lib
export JAVAMYSQL=$JAVA_HOME/lib
export CLASSPATH=.:$JAVA_HOME/lib/classes.zip
export JAKARTA_HOME=/usr/local/jakarta
for file in $JAKARTA_HOME/lib/*
do
export CLASSPATH=”$CLASSPATH:$file”
done
export PATH=”$PATH:/usr/local/bin:/usr/X11R6/bin”
export TOMCAT_HOME=$JAKARTA_HOME/tomcat
export CATALINA_HOME=/usr/local/jakarta/tomcat
(cd ; ./bin/startup.sh)

========make change to above file =========

#!/bin/sh
export JAVA_HOME=/usr/local/jdk
export PATH=$JAVA_HOME/bin:$PATH
export XML=$JAVA_HOME/lib
export SSL=$JAVA_HOME/lib
export JAVAMYSQL=$JAVA_HOME/lib
export CLASSPATH=.:$JAVA_HOME/lib/classes.zip
export JAKARTA_HOME=/usr/local/jakarta
for file in $JAKARTA_HOME/lib/*
do
export CLASSPATH=”$CLASSPATH:$file”
done
export PATH=”$PATH:/usr/local/bin:/usr/X11R6/bin”
export TOMCAT_HOME=$JAKARTA_HOME/tomcat
export CATALINA_HOME=/usr/local/jakarta/tomcat
(cd /usr/local/jakarta/tomcat; ./bin/startup.sh)

————————-

pico /usr/sbin/stoptomcat

————————-

#!/bin/sh
export JAVA_HOME=/usr/local/jdk
export PATH=$JAVA_HOME/bin:$PATH
export XML=$JAVA_HOME/lib
export SSL=$JAVA_HOME/lib
export JAVAMYSQL=$JAVA_HOME/lib
export CLASSPATH=.:$JAVA_HOME/lib/classes.zip
export JAKARTA_HOME=/usr/local/jakarta
for file in JAKARTA_HOME/common/lib/*
do
export CLASSPATH=”.:/usr/local/jdk/lib/classes.zip:/usr/local/jakarta/lib/activation.jar:/usr/local/jakarta/lib/cimapi.jar:/usr/local$
done
export PATH=”$PATH:/usr/local/bin:/usr/X11R6/bin”
export TOMCAT_HOME=$JAKARTA_HOME/tomcat
export CATALINA_HOME=/usr/local/jakarta/tomcat
(cd ; ./bin/shutdown.sh)
sleep 3
kill -9 `ps xww |grep tomcat|grep java|grep -v grep |awk ‘{ print $1 }’`

========make change to above file =========

#!/bin/sh
export JAVA_HOME=/usr/local/jdk
export PATH=$JAVA_HOME/bin:$PATH
export XML=$JAVA_HOME/lib
export SSL=$JAVA_HOME/lib
export JAVAMYSQL=$JAVA_HOME/lib
export CLASSPATH=.:$JAVA_HOME/lib/classes.zip
export JAKARTA_HOME=/usr/local/jakarta
for file in JAKARTA_HOME/common/lib/*
do
export CLASSPATH=”.:/usr/local/jdk/lib/classes.zip:/usr/local/jakarta/lib/activation.jar:/usr/local/jakarta/lib/cimapi.jar:/usr/local$
done
export PATH=”$PATH:/usr/local/bin:/usr/X11R6/bin”
export TOMCAT_HOME=$JAKARTA_HOME/tomcat
export CATALINA_HOME=/usr/local/jakarta/tomcat
(cd /usr/local/jakarta/tomcat; ./bin/shutdown.sh)
sleep 3
kill -9 `ps xww |grep tomcat|grep java|grep -v grep |awk ‘{ print $1 }’`

————————-

/usr/sbin/starttomcat

/root/TC5install/cpinstall.sh

cp /usr/local/jakarta/jakarta-tomcat-5.0.19/conf/web.xml /usr/local/jakarta/conf/

/etc/init.d/httpd restart

Site: http://tomcat.apache.org

Introduction to Struts
Apache Struts is a free open-source framework for creating Java web applications.
Web applications differ from conventional websites in that web applications can create a dynamic response. Many websites deliver only static pages. A web application can interact with databases and business logic engines to customize a response.
Web applications based on JavaServer Pages sometimes commingle database code, page design code, and control flow code. In practice, we find that unless these concerns are separated, larger applications become difficult to maintain.
One way to separate concerns in a software application is to use a Model-View-Controller (MVC) architecture.
· The Model represents the business or database code,
· View represents the page design code, that means jsp,html pages
· Controller represents the navigational code.i.e.servlet.

Basic idea behinds MVC architecture is to separate your business logic and presentation part separate.so if design changes it does not affect business logic.
The Struts framework is designed to help developers create web applications that utilize a MVC architecture.
The framework provides three key components:
· A “request” handler provided by the application developer that is mapped to a standard URI.
· A “response” handler that transfers control to another resource which completes the response.
· A tag library that helps developers create interactive form-based applications with server pages.
The framework’s architecture and tags are buzzword compliant. Struts works well with conventional REST applications and with technologies like SOAP and AJAX.

This framework enables design and implementation of large web applications to be handled by different groups of people. In other words, page designers, component developers and other developers can handle their own bit of the project, all in tandem and in a decoupled manner. It features I18N(internationalization), a powerful custom tag library, tiled displays and form validation. It also supports a variety of presentation layers, including JSP, XMl/XSLT,Java Server Faces (JSF), as well as a variety of model layers, includingJava Beans and EJB.

JavaBeans Architecture

Java Bean is a reusable software component that can be manipulated visually in a builder tool.

JavaBeans is an architecture for both using and building components in Java. This architecture supports the features of software reuse, component models, and object orientation. One of the most important features of JavaBeans is that it does not alter the existing Java language. If you know how to write software in Java, you know how to use and create Beans. The strengths of Java are built upon and extended to create the JavaBeans component architecture.
Although Beans are intended to work in a visual application development tool, they don’t necessarily have a visual representation at run-time (although many will). What this does mean is that Beans must allow their property values to be changed through some type of visual interface, and their methods and events should be exposed so that the development tool can write code capable of manipulating the component when the application is executed.
Creating a Bean doesn’t require any advanced concepts. So before here is some code that implements a simple Bean:
public class MyBean implements java.io.Serializable
{
protected int theValue;

public MyBean()
{
}

public void setMyValue(int newValue)
{
theValue = newValue;
}

public int getMyValue()
{
return theValue;
}
}
This is a real Bean named MyBean that has state (the variable theValue) that will automatically be saved and restored by the JavaBeans persistence mechanism, and it has a property named MyValue that is usable by a visual programming environment. This Bean doesn’t have any visual representation, but that isn’t a requirement for a JavaBean component.
JavaSoft is using the slogan “Write once, use everywhere.” Of course “everywhere” means everywhere the Java run-time environment is available. But this is very important. What it means is that the entire run-time environment required by JavaBeans is part of the Java platform. No special libraries or classes have to be distributed with your components. The JavaBeans class libraries provide a rich set of default behaviors for simple components (such as the one shown earlier). This means that you don’t have to spend your time building a lot of support for the Beans environment into your code.
*Some features of java bean
1) Properties, Methods, and Event
2) Introspection
3) Customization
4)Persistence
5)Visibility
6) Multithreading
7)Security