Following information is contained by a bean definition:
• Configuration information
• Constructor arguments information
• Container specific information like method initialization
• Property values information
• Names of static factory methods
Configuration data is inherited from the parent definition by the child bean definition. Some values are added or overridden by the child definition. There are no direct concerns between the java class
The callback methods are defined by the Bean Post Processor interface and it can be implemented to provide your instatiation logic and dependency resolution logic. When the instantiating, initializating and configuring of a bean is finished by the Spring container, some custom logic implementation can be done by you by integrating Bean Post Processor implementations.
More than one Bean Post Processor interfaces are allowed to use and configure and also it is possible to control the
It is easy to understand the Spring Bean Life Cycle. It is required to perform some initialization on the instantiation of a bean so that it can enter into a usable state. When a bean is not required, some cleanup process is required to remove the bean from the container.
There is a list of activities which are performed behind the scenes during the life of bean instantiation and destruction. Here we will discuss only two important methods of bean life cycle callback. These methods
You can easily declare the bean scope for the bean when you define a bean in Spring. Whenever a new bean instanace is required by you, bean scope attribute is declared as prototype to force the Spring to produce the bean instance. Also whenever you are looking for the same bean instance from the Spring, the bean scope instance is declared as singleton.
The following five scopes are supported by the Spring framework. In case of a web aware ApplicationContext, only three scopes are available.
The beans are the object that forms the backbone of any application and the Spring IoC container manges these beans. The Spring IoC container is responsible for instantiating, assembling and managing of a bean object. The configuration metadata is used to create these beans which are sent to container. For example, they are sent in the form of XML configurations.
The configuration metadata information is contained by the bean definition which is required to know the following by the
The Spring framework core is the Spring container. The Spring IoC container will:
• Create objects
• Wire those created objects
• Configure thos objects
• Manage complete lifecycle of the object
An application is made up of components and these components are managed by the Sping container using dependency injection. These objects are also known as Spring Bean objects.
The configuration metadata is read by the Spring container in
The advanced spring container is the Application Context. Just like the BeanFactory, it can perform the similar operations like wiere beans together, loading of bean definitions and upon request dispense bean. Following enterprise specific functionality is provided:
• From properties file, it can resolve textual messages.
• Application events are published to event listeners.
The ApplicationContext interface defines this container.
The application configuration is provided and configured by a central interface in spring called ApplicationContext.
Following functionalities are provided by the Spring ApplicationContext.
• The ListableBeanFactory inherited Bean factory methods are provided by the ApplicationContext. Also it will help the application to avoid use of singletons in their applications.
• The MessageSoruce interface provides the functionality to support internationalization and
The bean has a very simple lifecycle in a normal traditional java application. The bean is instantiated with the new keywork in Java and it is ready to use. When a created bean is not referred by any other object or is not in use, it is collected by the garbage collector.
Bean life cycle in the Spring framework perform extra functionalities. So it is an important part of the Spring framework to understand its bean life cycle so that all the benefits offered by the spring for bean
Factory design implementation is the bean’s factory. This class has a responsibility is creation or dispension of the beans. Bean factory is basically the general purpose sort of factory. Application objects are instantiated and delivered by the bean factory. Bean factory is aware of various objects present in application. Associations are created b/w the collaborated objects when they are instantiated or configuration burden is being removed from the bean. This also has a vital role in bean life
POJO components are presented by a spring bean which perform certain operations that are considerably useful. All of the SpringBeans which are present in Spring Container are called IOC Container. Spring framework is considered to be very transparent and it hides various infrastructure complexities and communication which occurs b/w spring beans and spring container. Sequence of activities is listed by this section which will be occurring b/w Bean instantiation Bean time and will be handing over
Java classes and components shall not be dependent upon any other java classes. It could be increasing the possibilities of reusage of such classes and they could be tested independently. For decoupling of the java components, there is a need to inject some dependency of various other classes’ persent.
Class A is dependent upon Class B in case Class B is used as variable.
When dependency injection is being used, in that case Class B would be given to A through:
Spring is considered as a widely deployed and popular deployed “open source” framework which assists programmers to create higher quality applications quickly. A consistent configuration model and programming is provided by Spring which is understood very well and is used by developers globally. Range of capabilities are provided by Spring to create rich web, enterprise Jave and enterprise applications which could be utilized in a light weighted manner. Spring used for Enterprise
Few associated benefits of Spring that could be brought to some project are listed here: Your mid-tier objects could be organized effectively by Spring whether you use EJB or not. Plumbing is being taken care by Spring which would be there with you when only struts or some other framework is used particular to J2EE APIs. Most probably this is much more valuable for mid tier so configuration management services of spring could be utilized in any kind of architectural layer, no matter
Configuration model and comprehensive programming is provided by the spring framework for the moderanized java based application for any of the deployment platform. Spring key element is the infra-strutural support provided at the level of application: Spring keeps its focus at the enterprise application plumbing therefore teams could keep their focus at the business logic which is application level without any unessential ties with deployment environment.
Stub & skeleton layer is present below the Java developer view. In this layer RMI utilizes the proxy designed patterns, as per description in a famous book known as Design patterns. For proxy patterns one object present in a context is presented by some other proxy present in other separate context. This given class shows the proxy patterns. Stub and Skeleton Layer
For using proxy pattern of RMI, Sub class has a vital role of
Let us now look at the implementation of higher leveled RMI architecture.
Three abstraction layers are involved in building the RMI implementation. First one is Stub & Skeleton layer that is present below the view of developer. Interception of this layer is done with method calls that are built by client, to referene variable which would be redirecting calls towards the remote services of RMI.
Next layer is known as remote reference layer. This understands that
One principle is associated with RMI architecture and that is the implementation of behavior and definition of behavior are totally separate concepts. Code is allowed by RMI which defines what behavior is and also the code which keeps it separate.
This is nicely fitted with the distributed system needs where clients have major concern regarding the service definition and servers to be focused to provide the services.
Remote service definition in RMI is coded by usage
Argument to the return values could be of any type including remote objects, primitive data type, and local objects. It could be said more precisely that any type’s entity could be passed from or to remote method, as long as this entity would be considered as a type’s instance which is primitive type, aserializable object, or a remote object, that shows that interface java.io.Serializable would be implemented.
There are few object types that are not upto any criteria and hence are
First thing shall be the determination of application architecture which includes the components that are accessible remotely or are the local objects. Steps included are: Remote interfaces are defined. Methods are specified by the remote interface which is remotely invoked by some client. Client would program towards the remote interface instead of implementation classes. Such interfaces design includes the object type determination which is used being parameters and which would
Distributed applications are madeup of classes and interfaces, just the way all other Java applications are made. Methods are declared by the interfaces. Methods which have been declared are implemented by the classes. Perhaps, an additional method would also be declared. In distributed applications certain implementations are present in Java virtual machines, however others are not. Objects along with method which could possibly be invoked are known to be the remote objects.
When a remote
Two separate programs are present in RMI applications, a client and a servlet. Typical program of servlet makes certain remote objects, makes the accessibility of the reference possible to these objects, or waits for invoking methods by the clients at these objects. Typical client progam gets reference to more than one remote object that is present at server which would invoke methods. Mechanism is provided by the RMI which makes communication between client and server. Also, information is passed
The <jsp:include> makes it possible for you to include the dynamic or static file in JSP file. To include dynamic or static file would be generating the different results. In case file is static the contents would be included in “Calling JSP” files. And if files are dynamic then act is done at the request and result is sent which would be included into JSP pages. When finishing of include action is fone then processing is continued of the remainder by JSP container. Attributes
It is determined by the JSP object scope that object could be used at some specific place of an application or not. Four scopes are present for the JSP object, as following: application - Object that has this kind of scope is present with all kind of JSP pages that belong to similar web applications. session - Object that has this kind of scope would be there for all kind of JSP pages which belong to the similar session where such object got instantiated. request - Object
Certain built in kind of functionalities are provided by the servlet container so that the application development could be eased. These functions are used by the programmers in JSP applications. Programmers are abled by the JSP action tags to utilized such functions. XML tags could be used in pages of JSP.
Here is the list of JSP Actions: jsp:include
The jsp:include where action work to be like a subroutine. Requests as well as responses are temporarily passed by the
JSP pages are considered to be the higher leveled servlet extension which make developers able to do embedding of the java code into HTML. Finally, JSP files get compiled in servlet by the help of servlet engine. Compiled servlet serve the requests when is used by the engine.
javax.servlet.jsp package has 2 interfaces:
These interfaces has 3 methods for JSP page. They are:
In case you have dealed with Java Servlets then you would be knowing that they make it possible for you to make the web pages which are dynamically generated which contain data from java objects “server side”. Servlet approach for generation of the web pages is to do embedding of the presentation code and HTML tags in Java class. This shows that alteration in presentation code would be requiring recompilation and modification of the source file of servlet. As web authors of HTML design are not always
JSF reference implementation of SUN gives certain defaulting validation components which are leveraged so that user input validation could be implemented. Core library of JSF provides tags so that input could be validated. Few tags are given here which are used for validation of the input. f:validateDoubleRange: Component value is checked by this tag, within range. It is necessary for value to be convertiable to floating point or floating point type. f:validateLength:
This tag registers as well as adds the validator to that parent component which is nearest. Typically, all of the applications present would be requiring filling some information at the page. Therefore it is considered to be a better thing to get invalid info value or formatting so that to make it “user-friendly”. Hence faults could be found out and corrected. Built in rules of validation are provided by JSF. JSF also customized the rules of validation so that to make them according to the requirements.
When a link or button is clicked by a user, values present in a field get changed or a selection is made in list so that the application might react. Interface components of JSF User would signal certain user action when an event is fired that is being handled by the code.
Event listeners that are very commonly used are value change and action. Others like phase or data model would not be discussed over here. In separate listener or managed bean, it is possible to declare the listeners.