The capabilities of Java EE 7.0 are as follows:

This following diagram depicts the JEE framework 7.0 capabilities:

Figure 1: Capabilities of Java EE 7.0

Probability indicator:

SMEs have observed that EJB 3 is an entirely different ball game. It includes configuration, annotations, dependency injection, and aspect orientation making EJBs a lean alternative to JAR-heavy frameworks. EJB technology is lean and weightless. There is no longer a need for JARs, XML configuration, or added frameworks. They integrate Java persistence API, are scalable on multicore machines; and are only vendor-neutral solution for enterprise applications. EJB 2.1 specification was not concise and violated the Don't Repeat Yourself (DRY) principle. The EJB component was spread across remote, home interfaces, bean classes, and the deployment descriptor. Without tools, refactoring was tedious and IDEs weren't good at refactoring.

The following are the list of improvements in EJB 3 over the previous implementations:

Probability indicator:

Separation of Concerns (SoC) is a design principle for separating a program into different sections, so that each section addresses a different concern. A concern is a set of information that affects the code of a program. A concern can be as general as the details of the hardware the code is optimized for, or as specific as the name of the class to instantiate.

A program that embodies SoC is called a modular program. Modularity, and hence separation of concerns, is achieved by encapsulating information inside a section of the program having well-defined interfaces. Encapsulation facilitates information hiding. Layered designs are another embodiment of separation of concerns (for example, presentation, business, data access, and persistence).

Benefits of SoC

The value of separation of concerns is in simplifying the development and maintenance of implementations. Well-separated, concerned facilitates the reuse of individual sections, as well as independent development, with the ability to modify one section of a program without having to know the details of other sections.

Probability indicator:

HTTP is a stateless protocol, and a web server in a cluster can potentially process an application client request. Session management allows a user's session state to be persisted.

For example, after a user has been authenticated by the web server, there is no need to re-authenticate at the next HTTP request if the user's authentication persists in the user's session state. The convenience of session management, however, comes with a price. Applications that use session management must maintain each user's session state, which is usually stored in memory. This can greatly increase an application's run-time memory footprint and tends to link user sessions to specific servers, requiring those sessions to be migrated to another node if the server is taken offline or fails. If session management is not implemented, applications can have a smaller footprint, and any cluster node can service requests from any user.

Approach

The user sessions are stored in cookies or in a hidden entries on a HTML page. An application can allocate a unique identifier to a user and then track the user's progress on the site. A user's interaction spans across multiple web pages by archiving the user's session state, and the application can capture the user's recent interaction with the website. In some instances, the user's session state is persisted to moderate subsequent visits. Some applications apply the user's session state to dynamically pages based on a user's preferences and patterns. Session cookies are stored often in a cryptographically signed format, but the data is usually unencrypted. Session data stored in cookies should not contain any sensitive information such as credit card data or other personal data. User sessions are also stored in a database or via Memcached. There are scripting frameworks such as PHP WASP and Zend that offer session management features.

Probability indicator:

Session tracking is a technique leveraged by application servlets to maintain the state of user requests across a time span. The different techniques for session tracking are:

Probability indicator:

Sessions and cookies are leveraged to store the user data. A cookies stores user information on the client side and a session does it on the server side and this is the key difference between cookies and sessions. Sessions and cookies are leveraged in the application for preferences, authentication, and application parameters across multiple user requests. Both sessions and cookies are meant for the same purpose. A cookie is leveraged for storing only textual information. The session can be used to store both textual information and objects.

Probability indicator:

Configuring the distributable tag in web XML enables an application to support session replication but it may not guarantee it will work fine in a session replicated environment.

A JEE application needs to enable the following during application development:

Options for enabling session replication

Session replication between clusters can be done in a variety of ways but the efficient approach depends on the type of application. The following are a few common techniques that are leveraged:

Probability indicator:

There may be a requirement to modify service logic or to add a functional scope of the services. In these cases, a new version of the service logic or service contract will need to be introduced. To ensure that the versioning of a service can be carried out with minimal impact and disruption to consumers that are dependent on the service, a formal service versioning technique needs to be in place which is the service inventory.

Approach

There are different versioning strategies, each of which introduces its own set of rules and priorities when it comes to managing the services compatibilities including the contracts. The service versioning phase is associated with SOA governance because it is a recurring part of the overall service life-cycle processes. Governance processes guide the service versioning and will have a significant influence on a service which will evolve over time. Because this stage also encompasses the retirement of a service, these influences are further factored into the service's overall life-span.

Probability indicator:

The explanation is as follows:

A library is a collection of routines or class and facilitates simple code reuse. The routines or classes define specific operations in a specific domain area. For example, there are libraries of mathematics call the function without redo the implementation algorithm.

In the framework, all the control flow is already there, and there's are pre-defined white spots that one should fill out with custom implementation. A framework is more complex than a library and defines a skeleton where the application needs to fill out this skeleton. The benefit is that we do not worry about whether a design is good or not, but just about implementing domain-specific features.

The key difference between a framework and a library is inversion of control. When one calls a method from a library, one is in control but with a framework, the control is inverted, that is, the framework calls you.

Probability indicator:

Applications have a tendency to increase in complexity over a period of time and thus become difficult to maintain and modify. They also become difficult to articulate. Refactoring is a modularization technique that deals with the separation of responsibilities. Refactored implementation makes code more reusable by virtue of loose coupling and minimum dependencies.

Refactoring has merits in terms of correctness and quality, but refactoring pays off the most with software maintenance and upgrades. Often a mechanism to add new requirements to a poorly factored implementation is to refactor the code and then add these features. This takes less effort than trying to add the new feature without refactoring, and it's an excellent way to enhance code quality.

Benefits

Refactoring can have multiples incentives:

Probability indicator:

Object Oriented Programming (OOP):

Aspect Oriented Programming (AOP):

Probability indicator:

The domain model is a conceptual or logical model of the specific domain related to a specific business domain. It explains entities, attributes, roles, relationships, and constraints that govern the problem domain but not the solutions to the problem. The domain model is defined as the vocabulary and concepts of the problem domain or the business domain. The domain model establishes the relationships between the entities in the scope of the problem domain and identifies their properties. The domain model encapsulates methods within entities and is properly associated with object oriented models. The domain model enables a structural view of the domain complemented with other dynamic views, such as use cases.

Probability indicator:

This will be based on your past expertise and be prepared with a key engagement as a case study and to answer details pertaining to the following:

Probability indicator:

A distributed database is an architecture in which parts of the database are stored on a different server in a network. Users have access to part of the database at their location to access data relevant to their processes. A centralized distributed database management system (DBMS) manages the database as a single entity. DBMS syncs all data at regular time intervals. In cases where multiple users access the same data, DBMS ensures that updates that are performed on the data at one location are reflected in the data stored in others.

The following are the benefits of distributed databases:

Probability indicator:

Database sharding means horizontal partitioning in a database. The purpose is to split data between multiple nodes while ensuring that the data is accessed from the correct location. Sharding is sometimes referred to as horizontal scaling or horizontal partitioning. Sharding is a proven database scalability technique and is leveraged in some of the world's most popular web applications. With sharding, instead of storing data in just one database instance, it's distributed across multiple instances.

Sharding is an architectural technique that distributes one logical database system into a cluster of machines. In sharded database systems, the database rows of a table are stored separately, instead of being split into columns like normalization or vertical partitioning. Each partition is then a shard, and is independently locatable on a separate database node.

The total number of rows in a database table is reduced since the tables are distributed across multiple nodes. This also reduces the index size, providing excellent performance. Hashing of a unique ID in the application is the most common approach for defining shards.

The downsides of sharding include:

The difference is as follows:

A master/slave approach is only for replication. This method only improves performance for applications dealing with static data since only the master can receive and update information. Sharding does not replicate anything. It simply partitions the data in different files, which may be located in different folders, filesystems, or even machines.

Probability indicator:

The two popular techniques to achieve this are to use clustering to deal with failover and load balancing. The Active/Active mode is enabled to provide for database or session replication and redundancy. Load balancers can be deployed to route requests according to server performance and on the basis of the algorithm.

Active/Passive mode

Active/Passive configuration offers advantages in that the primary load balancer distributes the network traffic to a suitable server while the second load balancer operates in listening mode to monitor the performance of the primary load balancer, ready to take over the load balancing duties should the primary load balancer fail.

Load balancers, when configured in Active/Passive mode, provide the ability to sustain uninterrupted customer services. One more advantage is the ability to deal with either planned or unplanned outages. Business today requires a 24/7 service for customers and any outage is costly in terms of lost as well as damage to the reputation.

Active/Active mode

In the Active/Active mode, two or more servers aggregate the network traffic and, working as a team, distributes it to the server clusters. The load balancers remember information requests from users and keep this information in the cache. Should the user return, the user will be locked onto the load balancer that previously served them and the information provided again from the cache, therefore reducing network traffic load. One potential disadvantage is that you run them near full capacity.

Probability indicator:

The following are the performance issues:

Probability indicator:

The descriptions are explained in the following table:

Probability indicator:

DB resolution: Query optimization, restructuring indexes, DB caching tuning leveraging ORM frameworks

Probability indicator:

Java EE provides various ways and APIs to facilitate async capabilities. The following table illustrates the Java EE spec capabilities that provide the async feature:

Probability indicator:

Persisting data and querying it back is a major consideration. Here are a few ways of designing your persistence tier:

Probability indicator:

Performance testing: Performance testing is done to establish how the application components are performing, under a simulated situation. Resource usage, scalability, and reliability are validated under this testing. This testing may be a spin-off of performance engineering, which is focused on tackling the performance issues architecture of software applications.

The primary goal of performance testing is establishing the benchmark behavior of the application.

Load testing: Load testing tests the application by constantly and incrementally increasing the work load on the application until it reaches the threshold limit. It is the easiest form of testing and leverages automation tools such as Load Runner. Load testing is also known as volume or endurance testing. The purpose of load testing is to assign the largest job to the application so that it can test the endurance results.

The target of load testing is to determine the upper limit of all the components of the applications such as databases, hardware, networks, and so on, so that it can manage the anticipated load in future.

Stress testing: In stress testing, various tasks to overload the applications are executed in an attempt to break the application. Negative testing, including the removal of components from the application is also done as a part of stress testing. This is also known as fatigue testing. This testing establishes the stability of the application by testing it beyond its bandwidth capacity. The objective of stress testing is to ascertain the failure and to monitor the recovery gracefully.

The goal is to analyze crash reports to define the behavior of the application post-failure. The challenge is to ensure that the application does not compromise the security of sensitive data after the failure.

Best practices for load and performance testing include:

Probability indicator:

Use case diagram explains IT application objectives from the user perspective. Use cases are added in requirement specifications to depict clarity regarding an application. There are three key parts to use cases: scenario, actor, and use case:

Primary and secondary actors

Actors are represented by a stick man symbol and use cases by an oval shape. Actors are further classified into two categories: primary and secondary. Primary actors are the users that are active participants, and they trigger the use case, while secondary actors passively participate in the use case.

Probability indicator:

The explanation is as stated as follows:

Probability indicator:

There are two types of association: aggregation and composition:

Probability indicator:

Specialization and generalizations define parent-child relationships between the classes. In many instances, classes may have the same operation and properties and these classes are called super classes and later one inherits from the super class to create sub-classes with their own custom properties. In the diagram, there are three classes for showing generalization and specialization relationships. All the phone types have a phone number as a generalized property, but depending upon landline or mobile you can have wired or sim card connectivity as a specialized property. In this diagram, the cell-phone represents generalization whereas clslandline and clsmobile represent specialization.

Figure 3: Generalization and specialization

Probability indicator:

Probability indicator:

The Spring framework helps build simple, portable, fast, and flexible JVM-based applications. Spring is a lightweight open source framework for developing enterprise applications. The Spring framework resolves the complexity of enterprise application development and provides a cohesive framework for application development based on dependency injection and inversion of control and design patterns.

The benefits of the Spring framework include:

Probability indicator:

When multiple entities are trying to access the DB locks they go into the cyclic wait state, making it unresponsive. Deadlock is a condition that occurs with multiple threads for any applications, not just on a RDBMS.

For example, a thread in multithreaded an OS might acquire one or more resources, such as blocks of memory. If the resource being acquired is currently owned by another thread, the first thread will have to wait for the owning thread to release the resources. The waiting thread is said to have a dependency on the owning thread. In the instance of the database engine, sessions can deadlock when acquiring non-database resources, such as memory or threads.

Few listed as follows:

Probability indicator:

The Document Object Model (DOM) parser creates a tree structure in memory from a document. In a DOM, the parser serves the application with the entire document. In contrast, the Simple API for XML SAX parser does not create any internal structure. A SAX parser always serves the client application only with part of the document at any given time.

The SAX parser, however, is much more space efficient if dealing with a big document whereas the DOM parser is rich in functionality. Leverage the DOM parser if you need to refer to different document areas before giving back the information. Leverage a SAX parser if you just need unrelated nuclear information from different areas.

Examples: Crimson are SAX Parsers whereas XercesDOM, SunDOM, and OracleDOM are DOM parsers.

Probability indicator:

The connection pooling technique allows multiple clients to make use of cached shared and reusable connection objects, providing access to a database. Connecting to a database consists of several time-consuming steps. A physical channel such as a socket or a named pipe must be established, the handshake must occur, the connection string information needs to be parsed, and the connection must be authenticated by the server.

In practice, applications leverage only a few configurations for connections. This means that during the application execution, many similar connections will be repeatedly created and closed. To minimize the cost of connections management, an optimization technique called connection pooling is leveraged. Connection pooling reduces the times that new connections need to be opened. The pool maintains ownership of these physical connection. It manages connections by ensuring a set of active connections for different connection configurations.

Connection pooling provides the following benefits:

Probability indicator:

Hibernate is an ORM framework and has numerous pros and cons. This section mainly lists the advantages of using Hibernate.

The advantages are as follows:

The following are differences between Hibernate and JPA.

Java Persistence API is a specification for ORM implementations whereas Hibernate is the actual ORM framework implementation. JPA is a specification that guides the implementation of ORM frameworks. Implementations abiding by the specification would mean that one can be replaced with others in an application without much hassle. Only the features that are added to the specification need to be taken care of if any such change is made.

Probability indicator:

String is immutable for several reasons; here is a summary:

Probability indicator:

Garbage collection does not guarantee that a program will not run out of memory. It is possible for programs to use up memory resources faster than they are garbage collected and it is possible for programs to create objects that are not garbage collected.

The methodology used is as follows.

The Java runtime environment deletes objects when it determines that they are no longer leveraged and this is known as garbage collection. The Java runtime environment provides a garbage collector that periodically frees the memory used by objects that are no longer needed. The Java garbage collector scans Java's dynamic memory areas for objects, marking those that are referenced. After all possible paths to objects are investigated, those objects that are not referenced are garbage collected.

Probability indicator:

Java doesn't support multiple inheritances. Interfaces don't facilitate inheritance and hence the implementation of multiple interfaces doesn't make multiple inheritances.

Checked exceptions are checked at compile time. If some code within a function throws a checked exception, then the function must either handle the exception or it must specify the exception using the throws keyword.

Unchecked exceptions are not checked at compile time. In C++, all exceptions are unchecked, so it is not forced by the compiler to either handle or specify the exception. It is up to the programmers to decide and catch these exceptions.

Probability indicator:

Casting means taking an object of one type and turning it into another type. There are two types of casting, casting between object references and casting between primitive numeric types. Casting between numeric types is leveraged to convert larger values, such as double values, to smaller values, such as byte values. Casting between object references is leveraged to refer to an object by a compatible class, interface, or array type reference.

Probability indicator:

The final variable is a constant variable. The variable value can't be changed after instantiation. A method that cannot be overridden in the subclass. A class that cannot be sub-classed. A class using only immutable; objects cannot be changed after initialization can be created.

Probability indicator:

The thread is a lightweight process, the smallest unit of a scheduled execution. An instance of the Thread class in Java could be in one of the following states. A thread can only be in one state at a given time. These states are virtual machine states which do not reflect any operating system thread states.

The following diagram depicts different thread states:

Probability indicator:

The advantages are as follows:

Arrays: An array is a collection of objects of similar type. Because arrays can be any length, they are leveraged to store thousands of objects, but the size is fixed when the array is created. Each item in the array is accessed by an index, which is a number that indicates the position where the object is stored. Arrays can be leveraged to store both value or reference types.

Collections: An array is just one of the different options for storing data. The option selected depends on various factors, such as how you manipulate or access the data. For example, a list is generally faster than an array if you must insert items at the beginning or in the middle of the collection. Other types of collections include maps, trees, and stacks; each one has its own advantages:

Probability indicator:

Java is a portable language because without any modification we can use Java byte code in any platform (which supports Java). So this byte code is portable, and we can use it in any other major platform.

Probability indicator:

The differences are as follows:

Processes: Processes are often synonymous with applications, but what the user sees as a single application is, in fact, a set of cooperating processes. A process has a self-contained execution environment which includes a private set of basic runtime resources and its own memory space.

Threads: Threads are lightweight processes and both processes and threads provide an execution environment, but creating a new thread requires fewer resources than processes. Threads exist within a process; every process has at least one thread. Threads share the process's resources, including memory and files.

Comparison:

Probability indicator:

A string buffer creates a mutable sequence of characters. A string buffer is a string but can be modified. It contains some sequence of characters, but the length and content of the sequence can be changed through method calls. The String class represents character strings. All string literals in Java, such as "xyz", are constants and implemented as instances of the string class; their values cannot be changed after the initial creation.

Probability indicator:

Object Relational Mapping (ORM) and O/R mapping is a technique for converting data between incompatible types in OO languages. This creates, in effect, a "virtual database" that can be leveraged from the programming language.

The benefits of ORM include:

Probability indicator:

In JEE applications, the modules are packaged as WAR, JAR and EAR based on functionality:

Probability indicator:

JavaServer Pages (JSP) is a technology that helps create dynamically generated web pages based on HTML, XML, or other types. Released in 1999 by Sun Microsystems, JSP is similar to PHP, but it uses the Java language.

Probability indicator:

ACID is an acronym commonly used to define the properties of a RDBMS; it stands for the following terms:

Probability indicator:

A shared nothing architecture is a distributed approach in which each node is independent and self-reliant, and there is no single point of failure across the landscape:

This approach is highly scalable since it avoids the existence of bottlenecks. Shared nothing is popular for web development due to its linear scalability. Google has been leveraging it for a long time. A shared nothing architecture can scale almost infinitely by adding nodes in the form of inexpensive machines.

Probability indicator:

Deploying a newer version of a live website can be a challenging task when a website has heavy traffic. Any small downtime is going to affect the end users. There are a few best practices that we can follow.

Before deploying on production:

When deploying on a production environment, keep these things in mind:

Probability indicator:

The core competencies of architects are illustrated in the following diagram:

Figure 5: Competencies and soft skills of architects

The following diagram illustrates the key soft qualities of architects:

Figure 6: Key soft qualities of architects

Figure 7: Modern programming practices

Probability indicator:

Figure 8: Code quality

Code quality is an attitude to refactor things that are wrong. The attitude to be a boy scout. An architect has to encourage an environment where such an attitude is appreciated. There are bad sheep, who take the code quality to such a level that it is not fun anymore. Have a good static analysis tool which is part of continuous integration. Understand the limits of static analysis. Results from static analysis are a signal and help to decide where to look during architect reviews. Every user story has to be reviewed. Put focus on peer reviews when there is a new developer or there is a new change being done and make the best use of pair programming.

Probability indicator: 

Agile and architecture do go hand in hand. Agile brings in the need to separate architecture and design and the architecture is about things which are difficult to change, such as technology, frameworks, communication, and so on. It a best practice if a big chunk of architectural decisions is done before the team starts. There will be things that are uncertain. Inputs to these can come from spikes as part of the scrum team but it is better to plan ahead.

Architecture choices should be well thought out. It's good to spend time thinking before you make an architectural choice. Change is continuous only when the team is sure nothing is broken. And automation test suites play a great role in providing immediate feedback. Important principles are tested early, fail fast, and automate.

Probability indicator:

Figure 7: Modern programming practices

Probability indicator:

Probability indicator:

The following lis are the important considerations:

Probability indicator:

Probability indicator:

Figure 9: Traditional web applications

Web applications are based on HTTP requests and responses. Following are the steps:

Probability indicator:

Various layers of web applications can be implemented using different Spring modules. The beauty of the Spring framework is that Spring provides great integration support with other non-Spring open source frameworks.

Probability indicator:

A design pattern is a reusable solution to a commonly occurring problem within a context in software design. A design pattern is not a finalized design that can be transformed into a machine code. It is a template for solving a problem that can be leveraged in different situations. Patterns are best practices that can be used to solve common problems when designing an application. Object-oriented patterns typically show interactions between objects, without specifying the final application classes that are involved. Patterns that imply object-orientation or a more generally mutable state are not as applicable in functional programming languages.

Benefits of design patterns

Please refer the table for a detailed description:

Probability indicator:

MVC stands for model, view, and controller and is a software architectural pattern for implementing UIs:

Probability indicator:

Probability indicator:

Figure 10: Hibernate best practices

Java Persistence API (JPA) is a specification of how the object-relational mapping should be done. Java is an object-oriented language. Data from Java objects need to be stored in relational SQL tables. JPA defines the interface of how mapping should be done. JPA is a specification with no implementation. Hibernate is an implementation of JPA. All annotations specified in JPA are implemented in Hibernate. The main benefit of using JPA is that at a later point in time, you can switch to another implementation of JPA. If I directly leverage Hibernate annotations, I'm locked into Hibernate. I cannot easily switch to other ORM frameworks.

Probability indicator:

There are three basic classifications of patterns: creational, structural, and behavioral.

Creational patterns include:

Structural patterns include:

Behavioral patterns include:

Probability indicator:

There are various avenues to keep abreast with the technology and domain which are:

Probability indicator: