JSF Interview Questions And Answers

56 JSF Interview Questions And Answers – Java Server Faces Interview Questions For Experienced  from Codingcompiler. Test your JSF knowledge by answering these tricky interview questions on JSF. Let’s start learning JSF interview questions and prepare for JSF interviews. All the best for your future and happy learning.

JSF Interview Questions

1. What is JSF?
2. What is Managed Bean?
3. What are the three types of tags for text fields exist in JSF?
4. What does the @ManagedProperty annotation mean?
5. What does the @ApplicationScoped annotation indicate?
6. What is resource binding in JSF?
7. Explain the difference between the required and requiredMessage attributes in the <h: inputText> tag.
8. What are the different types of page navigation supported in JSF?
9. What are the phases of the life cycle in JSF?
10. Explain the purpose of the <h: form> tag.
11. What tags are used for action and navigation?
12. What components are used to display data in a table form?
13. What is an event?
14. How can we get the generated event?
15. What are the different types of events in JSF?
16. What is a class student?
17. What is the purpose of the facelets tag?
18. Name several facelets tags.
19. What are the different types of validation used in JSF?
20. What are the different types of expressions supported by JSF EL (Expression Language)?
21. What is the difference between instant and deferred expressions?
22. Explain the difference between value expression and method expression.
23. Tell us about the @ViewScoped, @SessionScoped, @CustomScoped and @RequestScoped annotations.
24. What are some ways to declare a class a managed JSF bean?
25. How are the name and eager attributes used in Managed Bean?
26. What tags for validation exist in JSF?
27. What are the benefits of using the JSF Framework?
28. What different JSF tags are used for conversion?
29. List the benefits of using an expression language?
30. Explain the name backing bean.
31. What standard JSF tag libraries do you know?
32. What are the main functions of the method in backing bean?
33. What are the various JSF API implementations you know?
34. Explain the JSF architecture.
35. How are the various components rendered on the JSF page?
36. Can JSF contain multiple configuration files?
37. What is the difference between backing bean and managed bean?
38. How to display error messages in JSF?
39. Explain the purpose of the selectOne menu tag in JSF.
40. Explain the difference between the attributes immediate and rendered?
41. What are two ways to bind JSF supported?
42. What is the minimum configuration required for a JSF application?
43. What does navigation rule mean in JSF?
44. Tell us about the purpose of the converter tags in JSF.
45. List the benefits of a data table in JSF.
46. ​​How to implement internationalization (localization) (i18n) in JSF?
47. Which rendering model is used in JSF?
48. What is a render kit?
49. What is a view object?
50. What is meant by Bean Scope?
51. What is the difference between JSF-1 and JSF-2?
52. Can there be no faces-config.xml for JSF application?
53. Compare the JSF and Spring Framework.
54. Why is JSF not as popular as, for example, MVC frameworks like Spring MVC, although JSF is older and included in JEE?
55. Can we integrate JSF with other popular frameworks like Spring, Hibernate, etc.?
56. JSF Best Practices.

JSF Interview Questions And Answers

1. What is JSF?

JavaServer Faces (JSF) is a web application framework written in Java. It serves to facilitate the development of user interfaces for Java EE applications. Unlike other MVC frameworks that are driven by requests, the JSF approach is based on the use of components. The state of the user interface components is saved when the user requests a new page and then is restored if the request is repeated.

JavaServer Faces technology includes a set of APIs for presenting user interface (UI) components and managing their state, event handling and validation of input information, defining navigation, and support for internationalization (i18n) and accessibility. In JSF 2.0, Facelets technology is used as a presentation handler, which replaces JSP.

2. What is Managed Bean?

In JSF technology, managed beans are used to maintain the state of web pages. The creation of bins and their manipulation are carried out under the control of the JSF implementation, which performs the following:

1. 1. Creation and destruction of bins as necessary (this explains the origin of the term “managed bins”). To create, you can use the @ManagedBean annotation.

1. 1. Reading Bean Properties When Displaying a Web Page

1. Setting Bean Properties When Submitting a Form

3. What are the three types of tags for text fields exist in JSF?

1. 1. <h: inputText> is a standard text field for data entry.

1. 1. <h: inputSecret> – the input data is hidden (for example, dots).

1. <h: inputTextarea> – used to enable input of large amounts of textual information.

4. What does the @ManagedProperty annotation mean?

The @ManagedProperty annotation allows you to inject one managed bin into another.

1 2	@ManagedProperty(value = “#{beanName}”) private BeanName beanName;

5. What does the @ApplicationScoped annotation indicate?

The @ApplicationScoped annotation indicates that the managed bean will be available throughout the lifetime of the application.

6. What is resource binding in JSF?

Saving UI labels, dates, messages, and other text information of graphic components in various properties files is called resource binding. A typical example is the localization of an application, when several files of several languages are recorded in several resuorcebundle.propertiesfiles . This allows not hard-coding information on the views, but to be able to dynamically link the view and code in a managed bin or properties file.

1 2 3 4 5 6 7 8

//resourcebundle.properties name=Ivan age=twenty weight=75 kg //resourcebundle_ru.properties name=Иван age=двадцать weight=75 кг

Then this information can be linked on the xhtml page:

1 2 3 4

<c:loadBundle basename=”ru.javastudy.messages.resourcebundle” var=”res” /> <h:form> <h:outputLabel value=”#{res.name}”></h:outputLabel> <h:outputLabel value=”#{res.weight}” id=”weightId”></h:outputLabel >

You can also link data to xhtml pages with a managed bean using getters and setters.

7. Explain the difference between the required and requiredMessage attributes in the <h: inputText> tag.

These two tags declare the need to fill in a text field, as well as a message that will be executed if this rule is violated. This approach is used in the validation of components, for example, to require you to fill in a username, password, or email in the appropriate fields.

8. What are the different types of page navigation supported in JSF?

1. 1. Implicit Navigation,

1. 1. Navigation through Managed Bean (navigation using a managed bean),

1. 1. Navigation through faces-config.xml (navigation through settings faces-config.xml),

1. 1. Forward versus Redirect navigation

1. Conditional Navigation (conditional navigation)

9. What are the phases of the life cycle in JSF?

Life cycle phases:

• Restore view – for the requested page, either the component tree is retrieved (if the page has already been requested), or a new component tree is created (if the page is first requested). For the components of the requested page, their past states are restored (the web form fills in with the entered values).

• Application of request values – all objects of the component tree are assigned the corresponding values ​​from the request. Also, in this phase, if necessary, events are added (click on the button or link) to the event queue.

• Processing checks – sent string values ​​are converted to “local values”, which can be objects of any type. Validators are applied.

• Updating model values — changes properties of component-bound beans.

• Calling the application – the action method of the button or link is executed, clicking on which led to the form being sent. This method can perform any application processing. It returns a string that is passed to the navigation handler.

• Response visualization – generated by html and sent to the client.

Java Server Faces Interview Questions And Answers

10. Explain the purpose of the <h: form> tag.

The <h: form> tag generates an HTML form element that uses a “POST” request to confirm the form and send data from the form. Decoding behavior: gets the Map from the “requestParameterMap” property from ExternalContext.

If the map contains the “clientId” of this UIForm component, then setSubmitted (true) on the form is called, otherwise setSubmitted (false) on the form is called.

Encoding behavior: The value of the attribute “method” must be “post”. The value of the “action” attribute should be the result of passing the identifier of the current view to the getActionURL () method from the ViewHandler of this application, then passing the String to the encodeActionURL () method from ExternalContext.

You must call ViewHandler.writeState () before closing the form element. More details about the details of the behavior of the form can be found on the Oracle site.

11. What tags are used for action and navigation?

Tags for action and navigation commands include:

1. 1. <h: commandButton> – generates an HTML button that confirms the form and thus allows you to start processing the data entered by the user.

1. <h: commandLink> – generates an HTML hyperlink equivalent to the HTML anchor tag. It can be associated with a managed bean or an Action class for handling events.

12. What components are used to display data in a table form?

The main component for working with tables is <h: dataTable>. Contains extensive display and interaction settings between the view and managed beans.

13. What is an event?

Event – a reaction to a user action, such as clicking a button, activating a link, or changing a component. JSF supports listeners (listeners) that respond to various emerging events and allow them to be processed.

14. How can we get the generated event?

To get the generated event, we can use the following entry:

1 2 3

UIComponent ui = new UIComponent(); MyFacesEvent ev1 = new MyFacesEvent(ui); UIComponent sc1 = ev1.getComponent();

15. What are the different types of events in JSF?

JSF distinguishes between three types of events:

1. 1. Action Events: an event that is created by the ui component, for example, command button or command hyperlink. It is processed in ManagedBean using the processAction method  (ActionEvent ae) .

1. 1. Value Change Events: an event associated with a change in the value of a component’s UI. Components that can generate value change events include: textfield, radio button, list box, etc .. This type of event is created immediately after changing the value in the UI component. It is processed in ManagedBean using the method someMethod (ValueChangeEvent vc) .

1. Phase Events: This type of event occurs in one of the six phases of the JFS life cycle and runs either at the beginning or at the end of each phase. It is processed in ManagedBean using the methods:  beforePhase (PhaseEvent pe) ,  afterPhase (PhaseEvent pe) ,  PhaseId getPhaseId () .

16. What is a class student?

The class that is associated with the event that occurs is called the listener class. You can create such a class by implementing the interfaces  PhaseListener ,  ActionListener or a method with an input parameter (ValueChangeEvent ev) .

17. What is the purpose of the facelets tag?

JSF provides a special set of tags that gives more flexibility to manage common tags / parts in one place for multiple applications. These tags allow you to create a single template that can be used in various applications. Enable the facelets tags as follows:

1 2 3 4

<html   xmlns=”https://www.w3.org/1999/xhtml”   xmlns:ui=”https://java.sun.com/jsf/facelets” >

18. Name several facelets tags.

The most common facelets tags are:  <ui: component> ,  <ui: composition> ,  <ui: decorate> ,  <ui: define> ,  <ui: fragment> ,  <ui: include> ,  <ui: insert> ,  <ui: param> ,  <ui: remove> ,  <ui: repeat> .

19. What are the different types of validation used in JSF?

There are two types of validation in JSF:

1. 1. Declarative Validations  is a validation that works with standard JSF validators or Bean validators.

1. Imperative validation  – standard verification messages are usually not enough and validation, which overrides the standard, refers to the imperative type of verification.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

//Declarative validation <h:inputText id=”name” required=”true”                requiredMessage=”Name can’t be empty!”></h:inputText> //Imperative validation h:inputText id=”name” value=”#{mobile.mno}” required=”true”            validator=”#{meBean.validateField}”> @ManagedBean @SessionScoped public class Mobile implements Serializable { //… public void validateField(FacesContext context, UIComponent comp,            Object value) {            //TODO: } }

It is also possible to create your own class validator using the implementation of the Validator interface and redefining the required method.

Interview Questions on JSF

20. What are the different types of expressions supported by JSF EL (Expression Language)?

There are three types of expressions in JSF Expression Language:

1. 1. Immediate value expressions – are executed immediately when the page is displayed. Logged as $ {} .

1. 1. Deferred value expressions – are performed when necessary (when they are addressed). Syntax: # {expression} . Subdivided into value expression and method expression.

1. Value expression and method expression. Value expressions are divided into read only and rear-write. Logged as # {beanName.propertyName} . Method expressions allow you to call a method from a view. Syntax # {beanName.methodName ()} .

21. What is the difference between instant and deferred expressions?

Instant expressions are executed and calculated at the stage of rendering the display. Deferred expressions are executed by a direct call. For example, executing a method when clicking a button or getting a property value when building a fragment of a display (for example, when building a table, you need to get data values).

22. Explain the difference between value expression and method expression.

Value expression is used to work with properties in a managed bin. In case there is only a getter for the property, such an expression is referred to as read only. If there are both a getter and a setter for the property, then the property is readable and writable.

A method expression is used to invoke a method in a managed bean and get (if necessary) its result for subsequent processing in a view or other code.

23. Tell us about the @ViewScoped, @SessionScoped, @CustomScoped and @RequestScoped annotations.

@ViewScoped : means that a managed bean exists over the lifetime of the JSF view (while the page is being shown).

@SessionScoped : The bean will be available throughout the HTTP session.

@CustomScoped : the bin will live for as long as it is in the Map, which is created to control the lifetime of the beans.

@RequestScoped : The bean exists for the life of the request-response (HTTP request-response).

24. What are some ways to declare a class a managed JSF bean?

To declare a class as a managed bean, use the @ManagedBean annotation  (name = “beanName”, eager = “true \ false”) . Another way to declare a managed bean is to specify it in faces-config.xml :

1 2 3 4 5

<managed-bean>    <managed-bean-name>myBean</managed-bean-name>    <managed-bean-class>ru.javastudy.MyBean</managed-bean-class>    <managed-bean-scope>request</managed-bean-scope> </managed-bean>

25. How are the name and eager attributes used in Managed Bean?

name : specifies the unique name of the class (bean) in JSF. If the name is not specified, the name is the same as the name of the class where the first letter is in lower case.

eager : indicates the creation time of the bean. If true, then a bin will be created at the start of the application, if false, the bin will be created upon the first request to it.

26. What tags for validation exist in JSF?

• • f: validateLength : checks the length of the string

• • f: validateLongRange : checking numeric range,

• • f: validateDoubleRange : range checking for float, double,

• f: validateRegex : validation of the value according to a regular expression.

27. What are the benefits of using the JSF Framework?

• • Separate business logic from presentation.

• • Manage the state of the user interface UI with multiple requests to the server.

• • Supported implementation of its own components.

• • Easy data transfer between different components.

• JSF is a JEE standard, which gives confidence in the work of the declared functions. There are many third-party libraries for JSF, such as the PrimeFaces component library.

28. What different JSF tags are used for conversion?

• • f: convertNumber : is used to convert a string to a number.

• • f: convertDateTime : is used to convert a string to a date format.

• CustomConverter : A user-created JSF converter.

29. List the benefits of using an expression language?

• • Arithmetic, logical, relational operations can be used in the expression language.

• • Automatic type conversion.

• • Shows empty or missing values ​​as empty strings instead of NullPointerException.

• Provides easy access to predefined objects, such as a request.

JavaServer Faces (JSF) Interview Questions And Answers

30. Explain the name backing bean.

Backing Bean is a special JavaBean (java class) that collects values ​​from components, reacts to events, interacts with business logic. Associated with each component.

There may be several of them and the bin is not optional for the component’s UI, but simply uses it. Backing bean contains fields that will be populated from the component (it will add the values ​​entered by the user). The JSF component will not work with Java classes or with anything other than Backing bean.

31. What standard JSF tag libraries do you know?

JSF Core Tags library and JSF HTML tags library. You can set the namespace in the xhtml page as follows:

1 2 3 4

<html xmlns=”https://www.w3.org/1999/xhtml”    xmlns:h=”https://java.sun.com/jsf/html”    xmlns:ui=”https://java.sun.com/jsf/facelets”    xmlns:c=”https://java.sun.com/jsf/core”>

Then, using the specified prefixes, you can specify any components, for example <h: form>, <c: validator>, etc.

32. What are the main functions of the method in backing bean?

• • Checks component data

• • Handles component events

• Performs request processing to determine which next page to navigate to.

33. What are the different implementations of the JSF API?

• • ADF Faces: Oracle’s implementation of the JSF standard.

• • Reference Implementation (RI): from Sun Microsystems.

• • Apache MyFaces: open source implementation of JavaServer Faces (JSF).

• Primefaces: a powerful library of JSF components with support for Ajax and JavaScript.

34. Explain the JSF architecture.

JSF is based on the MVC design pattern, which means separating business logic from views. The JSF application contains:

• • UI components that represent the state of objects on the server.

• • Server-side helpers.

• • Validators, event handlers and navigation handlers.

• • Application configuration and resources used.

• • JavaBeans components that are used as a model with the necessary functionality and information.

• • Own tag libraries for working with event handlers and validators.

• Own library of tags for working with graphic components.

Below is a diagram of the JSF architecture:

35. How are the various components rendered on the JSF page?

JSF components are displayed on the xhtml page, which includes tag libraries like jsf core, html, facelets tags.

36. Can JSF contain multiple configuration files?

Yes maybe. They must be specified in the web.xml.

1 2 3 4 5 6 7 8 9 10

<?xml version=”1.0″ encoding=”UTF-8″?> <web-app version=”3.1″ xmlns=”https://xmlns.jcp.org/xml/ns/javaee”    xmlns:xsi=”https://www.w3.org/2001/XMLSchema-instance”    xsi:schemaLocation=”https://xmlns.jcp.org/xml/ns/javaee    https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd”> <context-param>    <param-name>javax.faces.CONFIG_FILES</param-name>    <param-value>/WEB-INF/faces-config1.xml,/WEB-INF/faces-config2.xml</param-value> </context-param> </web-app>

37. What is the difference between backing bean and managed bean?

In general, at the moment there is an opinion that these concepts should not be distinguished (for example, spring does this). But if you need to somehow answer differently, then:

• • backing bean should be specified in request scoped . Backing bean is associated with a form.

• Managed bean can be defined in request , session , application scopes. This type of bean is registered in the context of the JSF application and can be invoked or created at any time and place. Managed beans work with JSF graphics components.

38. How to display error messages in JSF?

You can display any system errors using the <h: messages> tag , which can refer to a graphical component using the for attribute .

39. Explain the purpose of the selectOne menu tag in JSF.

The selectOneMenu component allows you to select one of the list of values. A component may look like a list box, radio buttons, or a menu.

JSF Interview Questions And Answers For Experienced

40. Explain the difference between the attributes immediate and rendered?

The immediate attribute with a value of true allows you to skip some phases of the JSF life cycle. For example, when you click on the submitbutton and the form must be submitted, validation and conversions will be skipped. Data, for example, component inputTextField will not be sent to the model. In general, the presentation will not reach its model and the commands on the button with the attribute = immediate = ‘true’ will be executed .

The rendered attribute indicates the need to create (draw) a component on the view. This attribute can be set using a logical expression.

41. What are two ways to bind JSF supported?

1. 1. Binding a component value to a property in a bin or an external resource.

1. Associate a component instance with a property in a bin.

42. What is the minimum configuration required for a JSF application?

You must configure at least two configuration files:

1. 1. web.xml – the main web application configuration file. Contains deployment details, application configuration, and JSF handlers.

1. faces-config.xml – provides application settings, managed beans, navigation, converters, validators.

43. What does navigation rule mean in JSF?

The navigation rule describes the navigation rules in an application.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

<?xml version=’1.0′ encoding=’UTF-8′?> <faces-config version=”2.2″              xmlns=”https://xmlns.jcp.org/xml/ns/javaee”              xmlns:xsi=”https://www.w3.org/2001/XMLSchema-instance”              xsi:schemaLocation=”https://xmlns.jcp.org/xml/ns/javaee              https://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd”>    <navigation-rule>        <from-view-id>/first.xhtml</from-view-id>        <navigation-case>            <from-action>#{beanMain.method1()}</from-action>            <from-outcome>moveToView2</from-outcome>            <to-view-id>/view2.xhtml</to-view-id>        </navigation-case>        <navigation-case>            <from-action>#{beanName.exit}</from-action>            <from-outcome>exit</from-outcome>            <to-view-id>/logout.xhtml</to-view-id>        </navigation-case>    </navigation-rule> </faces-config>

44. Tell us about the purpose of the converter tags in JSF.

Using the converter tag in the component allows you to convert the data to the desired view. For example, in the <h: outpuText> tag, you can specify a converter that will cut a string that is too long:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

<h:inputText value=”#{bean.longStringProp}”>        <f:converter converterId=”cutTheStringConverter” /> </h:inputText> @FacesConverter(value = “cutTheStringConverter “) public class CutTheStringConverter implements Converter {    @Override    public Object getAsObject(FacesContext context, UIComponent component,            String value) {    //TODO:        return object;    }    @Override    public String getAsString(FacesContext context, UIComponent component,            Object value) {    //TODO:        return string;    } }

45. List the benefits of a data table in JSF.

The use of the table component in JSF provides ample opportunities to work with collections or arrays and display their contents in a table. It supports iteration, provides data conversion capabilities in the required form, and much more.

46. ​​How to implement internationalization (localization) (i18n) in JSF?

There are various ways to implement localization in JSF, both by standard methods and using other frameworks (for example, Spring). The main meaning of localization in JSF is the absence of hardcoded component values, text data, etc. in the code. You must set a property and link it using the resource bundle file, which will store the set of values ​​for each language (locale).

47. Which rendering model is used in JSF?

The JavaServer Faces rendering architecture is component-based. The state of the user interface components is saved when the user requests a new page and then is restored if the request is repeated.

48. What is a render kit?

Render kit defines a set of components and classes that are suitable for display to a specific user. For example,  <f: view renderKitId = “PRIMEFACES_MOBILE” /> means using the mobile set of components of the Primefaces library.

49. What is a view object?

View object is used specifically for the view, but is defined outside of it. It contains the information that needs to be displayed in the view, as well as validation logic, event handlers, and defines the interaction with the business logic code.

Advanced JSF Interview Questions And Answers

50. What is meant by Bean Scope?

Bean scope is a mechanism for associating bins and other objects so that they can be accessed from various components of a web application.

51. What is the difference between JSF-1 and JSF-2?

JSF 1 need to forget :). Does not support Ajax, annotations, the use of templates and generally quite a curve in terms of stability.

52. Can there be no faces-config.xml for JSF application?

You can opt out of the xml file when using annotations in the code.

53. Compare the JSF and Spring Framework.

Spring uses Inversion of Control (IoC) and Dependency Injection (DI), but JSF does not.

Spring consists of many different modules, such as Spring Data, Security, MVC, and many other perfectly interacting parts. This helps create larger applications at lower cost, while JSF is likely to require more coding for the many necessary functions.

Using DI in the spring allows you to embed POJO classes, while JSF can only work with JEE architecture.

54. Why is JSF not as popular as, for example, MVC frameworks like Spring MVC, although JSF is older and included in JEE?

This is a rather controversial issue, but you can list the possible benefits of Spring.

• • Many JSF implementations (Mojarra, Primefaces, Richfaces, etc.) make it difficult to choose, training application support for developers, while Spring MVC has one and sufficiently high-quality implementation.

• • Spring provides many of its developments for versatile tasks that greatly facilitate many engineering and managerial software design tasks.

• • DI and IoC patterns allow you to scale and use existing code in various applications.

• JSF is based on a component architecture, while Spring is based on a request-response. The second approach is perceived by many more easily, used in many frameworks like MVC, Struts2 and others.

55. Can we integrate JSF with other popular frameworks like Spring, Hibernate, etc.?

Yes, it is possible with all popular frameworks. Typically, a JSF, Spring, Hibernate, etc. collaboration application configuration. not complicated, but because of the amount of code required, they will not be given here. See the documentation for the required framework.

56. JSF Best Practices.

• • Avoid using JSF components with static properties.

• • Use short id components.

• • Avoid binding components.

• Use facelets for dynamic nesting.

Must Read Java Interview Questions Books 2020

• • Java Interview Guide: How to Build Confidence with a Solid Understanding of Core Java Principles

• • Core JAVA Interview Questions You’ll Most Likely Be Asked: Volume 8 (Job Interview Questions)

• • Java / J2EE: Interview Questions You’ll Most Likely Be Asked: Volume 10 (Job Interview Questions)

• • 500+ Java & J2ee Interview Questions & Answers: Java & J2ee Programming
  • Java / J2EE Interview Questions: A Guide for Interview

• • Java/J2EE Job Interview Companion
  • Data Structures and Algorithms Made Easy in Java: Data Structure and Algorithmic Puzzles

• • Cracking the C, C++ and Java Interview

• • JAVA/J2EE: Interview Questions (With Set of 2 CDs)

• Java Programming Interviews Exposed (WROX)

RELATED INTERVIEW QUESTIONS

1. JSP Interview Questions
2. JPA Interview Questions
3. Spring Framework Interview Questions
4. Spring Boot Interview Questions
5. GIT Interview Questions And Answers
6. Network Security Interview Questions
7. CheckPoint Interview Questions
8. Page Object Model Interview Questions
9. Apache Pig Interview Questions
10. Python Interview Questions And Answers
11. Peoplesoft Integration Broker Interview Questions
12. PeopleSoft Application Engine Interview Questions
13. RSA enVision Interview Questions
14. RSA SecurID Interview Questions
15. Archer GRC Interview Questions
16. RSA Archer Interview Questions
17. Blockchain Interview Questions
18. Commvault Interview Questions
19. Peoplesoft Admin Interview Questions
20. ZooKeeper Interview Questions
21. Apache Kafka Interview Questions
22. Couchbase Interview Questions
23. IBM Bluemix Interview Questions
24. Cloud Foundry Interview Questions
25. Maven Interview Questions
26. VirtualBox Interview Questions
27. Laravel Interview Questions
28. Logstash Interview Questions
29. Elasticsearch Interview Questions
30. Kibana Interview Questions