Top 50 J2ee Interview Questions You Must Prepare 03.Feb.2023

Two things have to be done for tomcat to acknowledge SSI scripts: 

@Rename $CATALINA_BASE/server/lib/servlets-ssi.renametojar to $CATALINA_BASE/server/lib/servlets-ssi.jar. 

@Uncomment the section of web.xml found in $CATALINA_BASE/conf/web.xml that deals with SSI. it looks like this when it is uncommented: 

    <servlet>
        <servlet-name>ssi</servlet-name>
        <servlet-class>
          org.apache.catalina.ssi.SSIServlet
        </servlet-class>
        <init-param>
          <param-name>buffered</param-name>
          <param-value>1</param-value>
        </init-param>
        <init-param>
          <param-name>debug</param-name>
          <param-value>0</param-value>
        </init-param>
        <init-param>
          <param-name>expires</param-name>
          <param-value>666</param-value>
        </init-param>
        <init-param>
          <param-name>isVirtualWebappRelative</param-name>
          <param-value>0</param-value>
        </init-param>
        <load-on-startup>4</load-on-startup>
    </servlet>

Message is a light weight message having only header and properties and no payload. Thus if the receivers are to be notified about an event, and no data needs to be exchanged then using Message can be very efficient.

An Action is an adapter between the contents of an incoming HTTP request and the corresponding business logic that should be executed to process this request. The controller (ActionServlet) will select an appropriate Action for each request, create an instance (if necessary), and call the perform method. Actions must be programmed in a thread-safe manner, because the controller will share the same instance for multiple simultaneous requests. In this me you should design with the following items in mind:

  • Instance and static variables MUST NOT be used to store information related to the state of a particular request. They MAY be used to share global resources across requests for the same action.
  •  Access to other resources (JavaBe, session variables, etc.) MUST be synchronized if those resources require protection. (Generally, however, resource classes should be designed to provide their own protection where necessary. When an Action instance is first created, the controller servlet will call setServlet() with a non-null argument to identify the controller servlet instance to which this Action is attached. When the controller servlet is to be shut down (or restarted), the setServlet() method will be called with a null argument, which can be used to clean up any allocated resources in use by this Action.

A collection of custom tags described via a tag library descriptor and Java classes.

A container that provides the same services as a servlet container and an engine that interprets and processes JSP pages into a servlet.

An architecture for integration of J2EE products with enterprise information systems. There are two parts to this architecture: a resource adapter provided by an enterprise information system vendor and the J2EE product that allows this resource adapter to plug in. This architecture defines a set of contracts that a resource adapter must support to plug in to a J2EE product-for example, tractions, security, and resource management.

A vendor that supplies a J2EE product.

J2EE clients are the software that access the services components installed on the J2EE container. Following are the J2EE clients:
a) Applets
b) Java-Web Start clients
c) Wireless clients
d) Web applications.

In an XML document, the part that occurs after the prolog, including the root element and everything it contains.

If you want tomcat to accept requests for different hosts e.g., www.myhostname.com then you must 

@create ${catalina.home}/www/appBase , ${catalina.home}/www/deploy, and ${catalina.home} /conf /Catalina /www.myhostname.com 

@add a host entry in the server.xml file 
  <Host appBase="www/appBase" name="www.myhostname.com"/>

@Create the the following file under conf/Catalina/www.myhostname.com/ROOT.xml 
<?xml version="1.0" encoding="UTF-8"?>
<Context
    path="/"
    docBase="www/deploy/mywebapp.war"
    reloadable="true" antiJARLocking="true">
</Context>
Add any parameters specific to this hosts webapp to this context file 

@put your war file in ${catalina.home}/www/deploy 

When tomcat starts, it finds the host entry, then looks for any context files and will start any apps with a context 

To add more sites just repeat and rinse, all webapps can share the same war file location and appbase.

• Tune the entity be pool size to avoid overhead of creation and destruction of be.
• Tune the entity be cache size to avoid overhead of activation, passivation and database calls.
• Use setEntityContext() method to cache bean specific resources.
• Release acquired resources in unSetEntityContext() method.
• Use Lazy loading to avoid unnecessary pre-loading of child data.
• Choose optimal traction isolation level to avoid blocking of other tractional clients.
• Use proper locking strategy.
• Make read-only entity be for read only operations.

That part of a DTD that is defined by references to external DTD files.

It is important to understand that the calling semantics of local interfaces are different from those of remote interfaces. For example, remote interfaces pass parameters using call-by-value semantics, while local interfaces use call-by-reference. This me that in order to use local interfaces safely, application developers need to carefully consider potential deployment scenarios up front, then decide which interfaces can be local and which remote, and finally, develop the application code with these choices in mind. While EJB 2.0 local interfaces are extremely useful in some situations, the long-term costs of these choices, especially when changing requirements and component reuse are taken into account, need to be factored into the design decision.

An authentication mechanism in which a Web server authenticates an entity via a user name and password obtained using the Web application's built-in authentication mechanism.

Follow the standard instructions for when the isapi_redirector.dll 

Configure IIS to use "integrated windows security" 

In server.xml, make sure you disable tomcat authentication: 

<Connector port="8009" enableLookups="false" redirectPort="8443"
protocol="AJP/1.3"tomcatAuthentication="false" />

A framework for building server-side user interfaces for Web applications written in the Java programming language.

Document-driven programming. The use of XML to define applications.

An object whose class implements the enterprise bean's remote interface. A client never references an enterprise bean instance directly; a client always references an EJB object. The class of an EJB object is generated by a container's deployment tools.

• Use Buffered IO classes.
• File information such as file length requires a system call and can be slow. Don't use it often. Similarly, System.currentTimeMillis() uses a native call to get current time. Make sure your production code does not have this statement.
• Many java.io.File methods are system calls which can be slow.
• Use BufferedIO streams to access URLConnection sInput/Output streams.
• Use the trient keyword to define fields to avoid having those fields serialized. Examine serialized objects to determine which fields do not need to be serialized for the application to work.
• Increase server listen queues for high load or high latency servers.

A preconfigured JMS object (a resource manager connection factory or a destination) created by an administrator for the use of JMS clients and placed in a JNDI namespace.

Automatic variable have to be initialized explicitly.

An application developer who produces enterprise bean classes, remote and home interfaces, and deployment descriptor files, and packages them in an EJB JAR file.

A predefined XML tag for character data that me "don't interpret these characters," as opposed to parsed character data (PCDATA), in which the normal rules of XML syntax apply. CDATA sections are typically used to show examples of XML syntax.

If the variable is primitive datatype then it is passed by copy.
If the variable is an object then it is passed by reference.

The runtime portion of a J2EE product. A J2EE server provides EJB or Web containers or both.

The CORBA Lifecycle specification defines a GenericFactory interface from which all factories should inherit, but this is not required. The CORBA specification also defines a factory for factories, known as a factory finder. The factory finder is a just a CORBA factory which act as a factory for other factory interfaces.

Servlet is a script, which resides and executes on server side, to create dynamic HTML. In servlet programming we will use java language. A servlet can handle multiple requests concurrently.

The process whereby software is installed into an operational environment.

A JMS administered object that encapsulates the identity of a JMS queue or topic. See point-to-point messaging system, publish/subscribe messaging system.

Software that provides services to an EJB container. For example, an EJB container typically relies on a traction manager that is part of the EJB server to perform the two-phase commit across all the participating resource managers. The J2EE architecture assumes that an EJB container is hosted by an EJB server from the same vendor, so it does not specify the contract between these two entities. An EJB server can host one or more EJB containers.

Set the staging mode to -nostage (using weblogic.Deployer or the Administration Console) if you don't want to copy deployment files but want to deploy an application from its present location. All target servers must be able to access the same set of deployment files.

• Use jspInit() method to cache static data
• Use StringBuffer rather than using + operator when you concatenate multiple strings
• Use print() method rather than println() method
• Use ServletOutputStream instead of JSPWriter to send binary data
• Initialize the 'out' object (implicit object) with proper size in the page directive.
• Flush the data partly.
• Minimize code in the synchronized block.
• Set the content length.
• Release resources in jspDestroy() method.
• Give 'false' value to the session in the page directive to avoid session object creation.
• Use include directive instead of include action when you want to include the child page content in the trlation phase.
• Avoid giving unnecessary scope in the 'useBean' action.
• Do not use custom tags if you do not have reusability.
• Use application server caching facility.
• Use Mixed session mechanisms such as 'session' with hidden fields.
• Use 'session' and 'application' as cache.
• Use caching tags provided by different organizations like openSymphony.com.
• Remove 'session' objects explicitly in your program whenever you finish the task.
• Reduce session time out value as much as possible.
• Use 'trient' variables to reduce serialization overhead if your session tracking mechanism uses serialization process.
• Disable JSP auto reloading feature.

An XML file provided with each module and J2EE application that describes how they should be deployed. The deployment descriptor directs a deployment tool to deploy a module or application with specific container options and describes specific configuration requirements that a deployer must resolve.

Common Object Request Broker Architecture. A language-independent distributed object model specified by the OMG.

That part of the DTD that is defined within the current XML file.

B2B stands for Business-to-business.

• Tune the Stateless session be pool size to avoid overhead of creation and destruction of be.
• Use setSessionContext() or ejbCreate() method to cache bean specific resources.
• Release acquired resources in ejbRemove() method.

See here.
You need to escape the string to "D:\Code\include" or use "D:/Code/include" instead!

Believe me or not? Forward slash works on windows in all ant or java code. It also works in windows environment variables. It does not work in cmd (dos) window before XP. It also works in XP dos window now!

An entity that is referenced as part of an XML document's content, as distinct from a parameter entity, which is referenced in the DTD. A general entity can be a parsed entity or an unparsed entity.

There are many different performance characteristics that are important. Performance should also scale linearly as connections or objects increase. While raw throughput between one client and one server is important, it is not the only or the most critical characteristic. Many characteristics of the CORBA implementation should be considered. As always, actual application requirements to the relative importance of these different characteristics. With the high speed nature of most CORBA implementations, raw client/server throughput is often not a bottleneck. It is also important that factors such as the number of operations does not slow down individual remote invocations. Here is a list of some important performance characteristics.

• Scalability across connected client applications.
• Scalability across objects within a CORBA server.
• Raw throughout between one client and one server.
• Activation time of server processes.
• Activation time of CORBA objects.
• Streaming time for different IDL types.
• Connection time associated with the first remote operation, _narrow call, _is_a call etc.
• Minimum memory consumed by a CORBA object.
• Number of file descriptors consumed by a complex network of distributed objects.

The Java Authentication and Authorization Service (JAAS) provides a way for a J2EE application to authenticate and authorize a specific user or group of users to run it. It is a standard Pluggable Authentication Module (PAM) framework that extends the Java 2 platform security architecture to support user-based authorization.

Yes. The words client and server are really only applicable in the context of a remote call. In other words, the "client process" can also receive calls on CORBA objects that it implements and hands out the references to.

If you create the object reference from a string via a CORBA 2.0 compliant library then the object reference is an IOR. If you create the object reference via resolve_initial_references() the ORB libraries might create an OR or an IOR. Some ORBs from companies such as Expersoft and Visigenic ORBs support only native IIOP and thus all references are IORs. On the other hand, some commericial vendors who shipped ORBS that supported IDL before IIOP existed pass around references that are not IORs and thus these referencesmight not always be IORs. Many cases an ORB vendor might support a proprietary protocol in addition to IIOP. Note: even if resolve_initial_references() returns and IOR, the IOR almost always refers to an object implemented with the same ORB environment as the application calling resolve_initial_references(). If the object reference is obtained from a server, a NameContext, or from a factory, the process and ORB libraries that originially created the object reference, determine if the reference is an OR or an IOR.

An environment for developing and deploying enterprise applications. The J2EE platform consists of a set of services, application programming interfaces (APIs), and protocols that provide the functionality for developing multitiered, Web-based applications.

The CORBA specification defines two mechanisms for invoking operations on a CORBA Object. Functionaly, the two mechanisms provide the same capabilities. They allow basically the IDL defined operations on the CORBA object to be invoked, allow program variables to be passed to the operation as inbound parameters, and allow return values or out parameters to be passed from the server to the client. The first mechanism is known as the Static Invocation Interface (SII), the other is known as Dynamic Invocation Interface . Developers of client applications which use SII must know the name of the operation, and all parameters/return types prior to program compilation. The actual operation names and parameters/return values are in effect hard coded into the application source code.

Remember that is_equivalent() is invoked on one of the two objects, and there are cases where this can cause deadlock. The following example illustrates how this can happen on one particular single-threaded ORB that won't allow a server to invoke a method on the client (contributed by Jeff Stewart, jstewart+@andrew.cmu.edu; used with permission): Suppose a server receives updates from cached clients and then has to update all clients except for the one that reported (updating the reporting client would cause a deadlock on this ORB). So, as the server iterates through its client list it must ensure that it does not invoke the reporting client. But it can't use is_equivalent() because this will eventually cause an invocation on the reporting client just to do the is_equivalent() check, inadvertently creating a deadlock.

CORBA is the acronym for Common Object Request Broker Architecture, OMG's open, vendor-independent architecture and infrastructure that computer applications use to work together over networks. Using the standard protocol IIOP, a CORBA-based program from any vendor, on almost any computer, operating system, programming language, and network, can interoperate with a CORBA-based program from the same or another vendor, on almost any other computer, operating system, programming language, and network.

lookup() :attempts to find the specified object in the given context. I.e., it looks for a single, specific object and either finds it in the current context or it fails.

list(): attempts to return an enumeration of all of the NameClassPair’s of all of the objects in the current context. I.e., it’s a listing of all of the objects in the current context but only returns the object’s name and the name of the class to which the object belongs.

listBindings(): attempts to return an enumeration of the Binding’s of all of the objects in the current context. I.e., it’s a listing of all of the objects in the current context with the object’s name, its class name, and a reference to the object itself.

search(): attempts to return an enumeration of all of the objects matching a given set of search criteria. It can search across multiple contexts (or not). It can return whatever attributes of the objects that you desire. It’s by far the most complex and powerful of these options but is also the most expensive.

Message, TextMessage, BytesMessage, StreamMessage, ObjectMessage, MapMessage are the different messages available in the JMS API.