ASPW

represents an (authenticated) user

represents

group of principals who share common set of permissions

group

@PermitAll
@DenyAll
@RolesAllowed
@DeclareRoles
@RunAs

@PermitAll

Pros and cons of application-managed security
Pro: complete control
Pro: can fine-tune for performance
Con: you might forget to put it in a method
Con: managing site-wide may be a problem

Pros and cons of application-managed security

Native Queries are a concise and type-safe way to express queries directly as Java method.

Java Method

Using named queries may improve code organisation by separating the JPQL query strings from the Java code. It also enforces the use of query parameters rather than embedding literals dynamically into the query string and results in more efficient queries.

Using named queries may improve code organisation

Using named queries may improve code organization by separating the JPQL query strings from the Java code. It also enforces the use of query parameters rather than embedding literals dynamically into the query string and results in more efficient queries.

test

Hibernate,
Toplink, we use this for JPA implementation in our coursework
OpenJPA

Toplink, we use this for JPA implementation in our coursework

JPQL queries are defined as strings, similarly to SQL. JPA criteria queries, on the other hand, are defined by instantiation of Java objects that represent query elements.
Advantage of using the criteria API is that errors can be detected earlier, during compilation rather than at runtime. On the other hand, for many developers string based JPQL queries, which are very similar to SQL queries, are easier to use and understand.
For simple static queries - string based JPQL queries may be preferred.
For dynamic queries that are built at runtime - the criteria API may be preferred. It is cleaner when using the JPA criteria API, because it eliminates the need for building the query using many string concatenation operations.

need for building the query using many string concatenation operations.

Native Queries are a concise and type-safe way to express queries directly as Java method.

Java method.

Optimistic locking is applied on transaction commit. Any database object that has to be updated or deleted is checked

Any database object that has to be updated or deleted is checked

A persistence unit defines a set of all entity classes that are managed by EntityManager
While The EntityManager is the primary interface used by application developers to interact with the JPA runtime

A persistence unit defines a set of all entity classes that are managed by EntityManager

A persistence-unit provides a convenient way of specifying a set of metadata files, and classes, and jars that contain all classes to be persisted in a grouping.
To define a persistence-unit you first need to add a file persistence.xml to the META-INF/ directory of your application jar.
http://www.datanucleus.org/products/datanucleus/jpa/emf.html#persistenceunit

A persistence-unit provides a convenient way of specifying a set of metadata files, and classes, and jars that contain all classes to be persisted in a grouping.

The Data Access Object is basically an object or an interface that provides access to an underlying database or any other persistence storage.

any other persistence storage.

A named query is a statically defined query with a predefined unchangeable query string.

A named query

The main difference between JPQL and SQL lies in that the former deals with JPA entities, while the latter deals directly with relational data. As a Java developer, you also maybe interested to learn that using JPQL, unlike SQL/JDBC, eliminates the need for you to use JDBC API from your Java code—the container does all this work for you behind the scenes.

The main

The Java Persistence Query Language (JPQL) is a platform-independent object-oriented query language defined as part of the Java Persistence API (JPA) specification. JPQL is used to make queries against entities stored in a relational database.

The Java Persistence Query Language (

It is platform-independent.

its

A detached entity is an entity which state must not be reflected by the JPA provider.

In other words, if you change its state (i.e. through setters methods) these changes will not be saved to the underlying database, as the JPA provider doesn't have to "observe" such entities.

A detached entity is an entity which state must not be reflected by the JPA provider.

A container-managed entity manager is obtained in an application through dependency injection or through JNDI lookup. A container-managed entity

manager requires the use of a JTA transaction. An Application managed entity manager is retrieved through the EntityManagerFactory API.

A container-managed entity manager is obtained in an application through dependency injection or through JNDI lookup

The EntityManager is the primary interface used by application developers to interact with the JPA runtime.
The methods of the EntityManager can be divided into the following functional categories:
• Transaction association.
• Entity lifecycle management.
• Entity identity management.
• Cache management.
• Query factory.
• Closing.

• Closing.

one to one → eager many to many → lazy

one to one → eager

3
a InheritanceType.SINGLE_TABLE -
b InheritanceType.TABLE_PER_CLASS
c InheritanceType.JOINED

a InheritanceType.SINGLE_TABLE -

It gives a hint to the persistence provider runtime that data should be fetched lazily (only when the application asks for the property) or eagerly (when the entity is initially loaded by the provider).

the entity is initially loaded by the provider).

@OneToOne @JoinColumn(name="parent_id", referencedColumnName="ID") private Parent parent; }

(name="parent_id", referencedColumnName="ID") private Parent parent; }

it is a message from client to server requesting resources

requesting resources

it is traveling through TCPIP protocol

protocol

It is the message from the server to the client as per the request sent from the client to server.

from the client to server.

404 code is the status code from the server to the client indicating the resource not found. 200 it is the code from server to client indicating that the request is received successful

request is received successful

Multipurpose Internet Mail Extension. The relation between the HTTP and MIME type is MIMIE type is part of HTTP header response

The relation between the HTTP and MIME type is MIMIE type is part of HTTP header response

Because the request might not reach to the server because of network error. or might be the server is switched off.

switched off.

Developers generally create static pages with HTML, but use languages like PHP, Javascript, or Actionscript to create dynamic pages. They can also use frameworks like Ruby on Rails, Django, or Flex for dynamic pages. Dynamic languages and frameworks also have the technical capacity to create static Web page content. However, doing so creates source code that is unnecessarily complex for its purpose while being more difficult to maintain

html

PHP, Javascript, or Actionscript

a

CGI, server side include, server module and auxiliary server

auxiliary server

By adding more auxiliary server

by adding more auxiliary server

high availability, fault tolerance

ssss

by adding more web servers and auxiliary server

auxiliary server

min program receive the request from the client and map it to functionality

functionality

java web programming get translated to servlet once received by servlet engine

servlet engine

JSP is a servlet

servlet

threading and at each time CGI has to run a program which is not good practice for OS. The problem of php is in case the module is crashed than the web server is also down

The problem of php is in case the module is crashed than the web server is also down

it is used to reporting the error.( exception is an event which occur during the execution of a program, that disrupts the normal flow of the program instructions.

( exception is an event which occur during the execution of a program, that disrupts the normal flow of the program instructions.

Creating an object and handing it to the runtime system is called throwing exception. The exception handler chosen is said to catch the exception.

Creating an object

It is the mechanism where in a new class is derived from existing class. class may inherit or acquire the properties and methods of other class.

It is the mechanism where in

StaffMember and Student are sub class of Person

Person

packages

p

Private:- filed it can be use within the class and it can not be used outside the class
protected:- visible only to the class where it is declared and to subclasses
public:- it is visible to all class, subclass and packages

packages

it is a variable which is not changed wherever it called or used

used

A Collection represents a group of objects known as its elements. The Collection interface is used to pass around collections of objects where maximum generality is desired.
A Set is a Collection that cannot contain duplicate elements.
A List is an ordered Collection (sometimes called a sequence). Lists may contain duplicate elements.
Array List:- general purpose implementation list which is usually the best performing implementation

e

A Map is an object that maps keys to values

values

mapping from string to person

w

it is part of java server written in xml

xml

it is a class with constructor and getter and setter. Also it is JSF controller

Also it is JSF controller

it is mean the lifetime of the object

lifetime of the object

Session scope:- (session end when its timeout)
Request scope:- start when request started and end after request is received
Application scope:-
View scope:-

start when request

in JAVA EE6 is request scope, in JAVA EE7 is non scoped

JAVA EE6

h:inputText , h:inputHidden, h:inputSecret, h:inputTextarea, h:link, h:commandButton, h:button, h:form, h:panelGrid , h:dataTable

h:inputText

the data which can be share between view and controller

controller

expression language #

&&

jsp is not supported MVC pattern fully, while jsf is fully supported for JSF

upported for JSF

stateless, stateful and Singleton

Singleton

stateful: The bean needs to hold information about the client across method invocations.
stateless:- The bean’s state has no data for a specific client.
Singleton:-State needs to be shared across the application.

Singleton:-State needs to be shared across the application.

stateless

l

message bean used to deal with messages while session beans used in business logic to interact with database

database

Dependency injection (DI) is the concept of providing an external dependency to a specific resource, generally by a Java EE container It enables you to provide a set of services to Java EE components

Java EE components

Who=java EE container, what= @EJB

ll

@EJB

l

@REMOVE annotation

@REMOVE annotationl

destroyed? @PreDestroy @PostConstruct

@PostConstruct

Enables you to schedule timed notifications for all types of enterprise beans except for stateful session beans. You can schedule a timed notification to occur according to a calendar schedule, at a specific time, after a duration of time, or at timed. How to use it? intervals.timerService.createSingleActionTimer(duration, new TimerConfig());

TimerConfig());

When EJB does not explicitly specify as interface type it is assume to be local otherwise it is remote. @localBean @remoteBean No -Interface :Is almost same as local client view, but there are differences. Your bean class is not required to implement client view interfaces in this case. All public methods of the bean class are automatically exposed to the caller. no-interface view always acquires an EJB reference

l

There's a limited number of beans in a pool and the container picks instances from the pool to serve requests as they come.

picks instances from the pool to serve requests as they come.

Mapping object to database, representing business object

object

@enitity annotation

by

is the annotation used to specify primary key

primary key

@embeddedID

@

when the database column not match the entity class column

entity class column

In a unidirectional relationship, only one entity has a relationship field or property that refers to the other. For example, LineItem would have a relationship field that identifies Product, but Product would not have a relationship field or property for LineItem. In other words,LineItem knows about Product, but Product doesn’t know which LineItem instances refer to it.
while in a bidirectional relationship, each entity has a relationship field or property that refers to the other entity. Through the relationship field or property, an entity class’s code can access its related object. If an entity has a related field, the entity is said to “know” about its related object. For example, if Order knows what LineItem instances it has and if LineItem knows what Order it belongs to, they have a bidirectional relationship.

relationship,

@inheritence Before the constructor class.

constructor class.

@orderBySource

Source