Group items tagged

Single table inheritance is the default

mapped superclass is

but allow common mappings to be define for its subclasses

Single Table Inheritance

single table is used to store all of the instances of the entire inheritance hierarchy

table will have a column for

in the hierarchy

is used to determine which class the particular row belongs to

abstract

Project

extends Project

extends Project

@DiscriminatorValue("S")

@DiscriminatorValue("L")

@DiscriminatorColumn(name="PROJ_TYPE")

@Inheritance

@Table(name="PROJECT")

single table inheritance

Joined, Multiple Table Inheritance

mirrors the object model in the data model

table is defined for each class in the inheritance hierarchy to store only the local attributes of that class

Each table in the hierarchy must also store the object's id (primary key), which is

share the same id attribute

joined inheritance

@Inheritance(strategy=

@DiscriminatorColumn(name="PROJ_TYPE")

@Table(name="PROJECT")

abstract

Project

@DiscriminatorValue("L")

@Table(name=

Project

@DiscriminatorValue("S")

@Table(name=

Project

Table Per Class Inheritance

Advanced

table is defined for

in the inheritance hierarchy to store

of that class and

table per class inheritance

@Inheritance(strategy=

abstract

Project

@Table(name="LARGEPROJECT")

LargeProject

Project

@Table(name="SMALLPROJECT")

SmallProject

Project

Mapped Superclasses

similar to table per class inheritance, but does not allow querying, persisting, or relationships to the superclass

mapped superclass

@MappedSuperclass

abstract

Project

@Column(name="NAME")

@Table(name="LARGEPROJECT")

LargeProject

Project

@AttributeOverride

"PROJECT_NAME"

"name"

@Table("SMALLPROJECT")

SmallProject

Project

cannot have a relationship to a mapped superclass

creates a bad sort of dependency where we need to update the base class every time we make a new derived class. Not good!

and allows data modifications to be queued up (like a shopping cart),

EXTENDED

is managed by the underlying persistence provider.

an entity is new if it has just been instantiated using the new operator, and it is not associated with a persistence context. It has no persistent representation in the database and no identifier value has been assigned.

a managed entity instance is an instance with a persistent identity that is currently associated with a persistence context.

the entity instance is an instance with a persistent identity that is no longer associated with a persistence context, usually because the persistence context was closed or the instance was evicted from the context.

a removed entity instance is an instance with a persistent identity, associated with a persistence context, but scheduled for removal from the database.

Replacing the current Hibernate 4.0.x jars with a newer version

update the current as7/modules/org/hibernate/main folder

Delete *.index files in as7/modules/org/hibernate/main and as7/modules/org/hibernate/envers/main folders

Remove the older jars and copy new Hibernate jars into as7/modules/org/hibernate/main + as7/modules/org/hibernate/envers/main.

Update the as7/modules/org/hibernate/main/module.xml

as7/modules/org/hibernate/envers/main/module.xml to name the jars that you copied in.

@Size(min = 3, max = 80)

@NotNull

LastName

extend AbstractBuilder

must implement the buildInternal() method:

Builder extends AbstractBuilder<Customer>

@Override protected Customer buildInternal()

Implementing the Builder Pattern using the Bean Validation API

variation of the Builder design pattern for instantiating objects with multiple optional attributes.

this pattern frees you from providing multiple constructors with the different optional attributes as parameters (hard to maintain and hard to read for clients)

or providing setter methods for the optional attributes

JdbcRealm

A Realm is a security component that can access application-specific security entities such as users, roles, and permissions to determine authentication and authorization operations

security-specific DAOs

If for some reason you don't want your Realm implementation to perform authentication duties, you should override the supports(org.apache.shiro.authc.AuthenticationToken) method to always return false

does not require you to implement or extend any User, Group or Role interfaces or classes

Shiro tries to maintain a non-intrusive development philosophy

Asynchronous Servlets Performance

With a non NIO or non Continuation based server, this would require around 11,000 threads to handle 10,000 simultaneous users. Jetty handles this number of connections with only 250 threads.

Classical synchronous model: 10,000 concurrent users -> 11,000 server threads. 1.1 ratio.

Comet asynchronous model: 10,000 concurrent users -> 250 server threads. 0.025 ratio.

classical (synchronous) servlet model

request -> immediate processing -> response

Comet implementations rely on a different model:

request -> wait for available data -> response

With synchronous servlet processing, each request is handled by one dedicated server thread

listen to lifecycle events during a session's lifetime

retain the IP address or host name of the host from where the session was initiated

can be prolonged via a touch() method to keep them 'alive' if desired

can use Shiro sessions in existing web applications and you

easily stored in any data source

can be

across applications if needed

'poor man's SSO'

simple sign-on experience since the shared session can retain authentication state

interface-based and implemented with POJOs

allows you to easily configure all session components with any JavaBeans-compatible configuration format, like JSON, YAML

easily extend

customize session management functionality

session data can be easily stored in any number of data sources

easily clustered using any of the readily-available networked caching products

no matter what container you deploy to, your sessions will be clustered the same way

No need for container-specific configuration!

Shiro sessions can be 'shared' across various client technologies

listen for these events and react to them for custom application behavior

SecurityUtils.getSubject()

currentUser.getSession()

If the Subject already has a Session, the boolean argument is ignored and the Session is returned immediately

If the Subject does not yet have a Session and the create boolean argument is true,

and returned.

If the Subject does not yet have a Session and the create boolean argument is false, a new session will not be created and null is returned.

method functions the same way as the

HttpServletRequest.getSession(boolean create) method:

EJB MDG Technology for Enterprise Java Beans allows the user to model EJB entities and EJB sessions, complete with UML profiles for modeling EJB, EJB patterns and Code Management. (requires Enterprise Architect 4.1 or later)

ICONIX AGILE DDT ICONIX Agile Developer - Design-Driven Testing (DDT) streamlines the ICONIX modeling process, providing: Convenient modeling of robustness diagrams Automatic generation of sequence diagram structures from robustness diagrams Transformation of robustness control elements to test diagrams Transformation of sequence diagram elements to test diagrams Transformation of requirement diagrams to test diagrams Transformation between test cases and test classes. (JUnit & NUnit) Built-in model validation rules for ICONIX robustness diagrams (requires Enterprise Architect 7.5 or later)

Testing MDG Technology for Testing helps users to rapidly model a wide range of testing procedures including component testing, SUT, Test Cases and more. (requires Enterprise Architect 4.1 or later)

Instructions for loading an MDG Technology EXE file: Download and run the .exe file to install the MDG technology. Open Enterprise Architect. Select from the Main Menu Add-Ins | XYZ Technology | Load.

Built-in MDG Technologies: Most of the MDG Technologies provided by Sparx Systems are built into Enterprise Architect directly. Depending on your edition of Enterprise Architect, some or all of the following MDG Technologies will be available:

Gang of Four Patterns

Mind Mapping

Web Modeling

Data Flow (DFD)

Entity-Relationship (ERD)

Business Rule Model

BPMN™

Think of JSR-299 as the core of Seam 3 - it's the basic programming model for your application components, and for the built-in components that make up the Seam framework

Seam 3 is implemented as a set of portable extensions, or modules

run in any environment which supports JSR-299 (including any Java EE 6 environment).

BPM integration, Seam Security, Drools integration, RESTeasy integration, PDF and email templates, Excel generation, etc

2.0.0.Final End of 2012 Full specification compliance

Weld 2

AuthorizationInfo getAuthorizationInfo(PrincipalCollection principals)

Returns an account's authorization-specific information for the specified principals, or null if no account could be found

automatically perform access control checks for the corresponding Subject

-Dorg.granite.logger.impl=path.to.my.CustomLogger