Start Quiz: Enterprise java patterns

Question: You application's performance is affected due to repeated JNDI lookups done by every client accessing your application. Which pattern is most appropriate to improve the performance and solve the problem?

Choices:

Service Locator

Session Facade

Business Delegate

Transfer Object

Question: you are in charge of developing an e-commerce web application, the client expects high traffic volumes and the security is of essence. Which user session management strategy would you choose?

Choices:

Save user session in http cookies

Save user session in html hidden fields

Save user session in an HttpSession object

Save user session in an EJB stateful session bean object

Question: You would like to raise the security level of your system by examining incoming HTTP requests. You would like to log information about each request and to filter requests with malicious scripts. Where would you put such request processing code?

Choices:

in the Service Locator

in the Service Activator

in the Intercepting Filter

in the View Helper

Question: In your web application you decided to use Javascript to validate each user input on the client browser. Where do you need to duplicate the validation code on the server?

Choices:

No double check on the server side is needed as the input is already checked on the client side

double check in the presentation tier

double check in the integration tier

double check in the business tier

Question: How to secure you web application against security risks such as cross site scripting (css) and SQL injection in a centralized manner that avoids code duplicate and ensures that every HTTP request would be inspected?

Choices:

use Intercepting Filter pattern

use Front Controller pattern

use Composite View pattern

use Business Delegate pattern

Question: A service locator is best implemented as a Singleton.

Choices:

true

false

Question: What is TRUE about the Updatable Transfer Objects Strategy?

Choices:

It is used when the client needs not only to read the business component attributes but also to be able to modify them

It reduces the complexity of the system in terms of update propagation and synchronization

It adds on complexity to the system in terms of update propagation and synchronization

Transfer Objects in general can reduce network overhead

Question: Your Parcel delivery company is expanding it's existing web application. Currently the clients can track their parcels using web browsers, and your company wants to expose it's business to it's partners as web-services. However; when you inspected the code base, you discovered that the application passes HttpServletRequest parameters to the business tier for further processing. Your job is to refactor this existing code base to avoid duplicating the business logic to handle the two request channels (http and web service requests). Which refactoring is appropriate for this case without code duplication?

Choices:

Use front controller pattern

Use context object pattern

Use proxy pattern

Use service broker pattern

Question: Your application's performance is affected due to the significant number of remote calls to your business logic. The business logic is exposed as fine grained methods to the clients. Which refactoring can be done to improve the application's performance?

Choices:

Add a Front Controller to centralize requests processing

Implement a Session Facade, which provides a coarse grained service-oriented interface to clients

Move the frequently called business logic to the presentation tier

Encapsulate multiple business data attributes into smaller set of serializable transfer objects, to reduce remote invocations

Question: Which of the following patterns would you use to transfer certain state to the next tier without passing on protocol-specific system information?

Choices:

Transfer Object

Context Object

Context Filter

Service To Worker

Question: Your job is to refactor an application ,which uses JSP technology as a View. The JSP pages are dominated by scriptlet code. Which pattern would be appropriate to solve this problem?

Choices:

View Helper

Composite View

Data Access Object

Context Object