Events
Group items matching
in title, tags, annotations or url
3More
40More
Java Persistence/Advanced Topics - Wikibooks, open books for an open world - 0 views
-
-
hook into a system that allows the execution of some code when the event occurs
-
JPA defines several events for the persistent
- ...37 more annotations...
-
life-cycle
-
of Entity objects
-
JPA defines the following events:
-
PostLoad
-
PrePersist
-
PostPersist
-
PreUpdate
-
PostUpdate
-
PreRemove
-
PostRemove
-
after an Entity is loaded into the
-
persistence context
-
before the persist operation is invoked on an Entity
-
after a refresh operation.
-
before the remove operation is invoked on an Entity
-
cascade of a remove operation
-
during a flush or commit for orphanRemoval in JPA 2.0
-
after an instance is deleted from the database
-
occurs during a flush or commit operation
-
after the database DELETE has occurred
-
before the transaction is committed
-
after an instance is updated in the database
-
occurs during a flush or commit operation
-
after the database UPDATE has occurred
-
before the transaction is committed
-
before an instance is updated in the database
-
occurs during a flush or commit operation
-
after the database UPDATE has occurred
-
before the transaction is committed
-
after a new instance is persisted to the database
-
occurs during a flush or commit operation
-
after the database INSERT has occurred
-
before the transaction is committed
-
Id of the object should be assigned
-
merge for new instances
-
cascade of a persist operation
-
Id of the object may not have been assigned, and code be assigned by the event
12More
From Spring to Java EE 6 - Java Code Geeks - 1 views
-
prototyped application was designed as a standalone pure Spring applicatio
-
Spring v3
-
analyzed the interest of switching to a Java EE 6
- ...9 more annotations...
-
can we do in Java EE 6 everything we can do in Spring ? can we do that as easy as in Spring ?
-
yes we can !
-
I am still - a real Spring fanboy (which I, historically speaking, discovered after having been literally disgusted by EJB's 1.0)
-
Contexts & Dependency Injection Messaging Transaction management Web services
-
Spring has an outstanding JMS support
-
Conclusion
-
Arguing that things are in Spring much simpler, much lighter than in Java EE is not - more exactly, no more – true
-
booting really fast
-
From Spring to Java EE 6
4More
flex - What are the drawbacks of using Spring BlazeDS Integration? - Stack Overflow - 0 views
-
It has no benefits unless you are using Spring on the server
-
What are the drawbacks of using Spring BlazeDS Integration?
-
starting a new project and would like to use Spring and Flex.
- ...1 more annotation...
-
In short, it provides much easier configuration of the backend infrastructure and services you want to expose to the client and it integrates perfectly with the Spring application contexts and the Spring programming model in general.
7More
The JPA 2 Enhancements Every Java Developer Should Know - Developer.com - 0 views
-
JPA 2 Enhancements Every Java Developer Should Know
-
JPA 2 also introduced a second layer of cache, which is shared across various persistence contexts and can be accessed using the EntityManagerFactory
-
Cache cache = emf.getCache();
- ...4 more annotations...
-
Enhancements in EntityManagerFactory Interface
-
Enhancements in EntityManager Interface
-
detach
-
getEntityManagerFactory
6More
Import Binary Module [Enterprise Architect User Guide] - 0 views
-
Import Binary Module
-
To import a binary module, right-click on the target package in the Project Browser and select the Code Engineering | Import Binary Module context menu option
-
note: the file dialog that opens after selecting 'import binary module' opens with filtering for .net binaries, so .jars won't be visible. change filter to .jar and happy happy
-
-
-
eg. to import jdk classes, import C:\Program Files\Java\jdk1.7.0_05\jre\lib\rt.jar
-
- ...2 more annotations...
-
Java Archive (.jar)
-
Do not import private members checkbox excludes private members from libraries from being imported into the model
26More
Enterprise JavaBeans 3.1 with Contexts and Dependency Injection: The Perfect Synergy - 0 views
-
stateless EJB 3.1 bean as boundary (Facade)
-
injected managed beans (controls)
-
@Inject
- ...22 more annotations...
-
@Inject
-
CDI managed beans. The @EJB annotation is removed and @Inject is used instead
-
Annotating the boundary (Cart) with the @Named annotation makes the Cart immediately visible for expression language (EL) expressions in JSP and JSF
-
@Named annotation takes the simple name of the annotated class, puts the first character in lowercase, and exposes it directly to the JSF pages (or JSP). The Cart bean can be accessed directly, without any backed or managed beans, by the JSF pages: <h:commandButton value="Check out!" action="#{cart.checkout}" />
-
If there is a need for abstraction, the class can be turned into an interface (or abstract class)
-
local implementation (with CDI events
-
@Inject Event<String> event;
-
event.fire("Order proceeded!");
-
remote implementation:
-
javax.enterprise.event.Event belongs to the CDI-implementation
-
class Event can be considered to be a lightweight alternative to the java.beans.PropertyChangeSupport class
-
@Inject Event<String> event;
-
event.fire("Order proceeded!");
-
event can be received by any managed bean and also by EJB beans
-
provide a method with a single @Observes annotated parameter
-
@Observes String event
-
there is no real event, just the payload:
-
The during attribute in the @Observes annotation allows you to select in which transactional phase the event gets delivered. The default setting is IN_PROGRESS, which causes an immediate event delivery regardless of the transaction outcome. The AFTER_SUCCESS configuration causes the delivery to occur only after successful transaction completion
-
Although CDI events work only inside a single process (in the default case, CDI is extensible), they are perfectly suitable for decoupling packages from modules
-
The method checkout() starts a transaction that gets "reused" by the OrderSystem and CustomerNotification session beans
-
ordering.placeOrder(); notifier.sendNotification();
-
-
EJB beans cannot be directly exposed to JSF or JSP without a little help from CDI
4More
3. Remoting - Confluence - 0 views
-
Service initializer
-
DefaultServiceInitializer
-
{ contextRoot: "/context-root" }
- ...1 more annotation...
-
It is also possible to define serverName, serverPort and the url mappings for Granite AMF remoting and for Gravity push graniteUrlMapping and gravityUrlMapping.
10More
shared by kuni katsuya on 20 Aug 12
- No Cached
2. Flex application initialization - Confluence - 0 views
www.graniteds.org/...lex+application+initialization
graniteds graniteds-tide-cdi-jpa flex client remoting initialization configuration
shared by kuni katsuya on 20 Aug 12
- No Cached
-
Application initialization
-
correct integration singleton for your application
-
depends on the server framework
- ...7 more annotations...
-
Spring, Seam, Ejb, Cdi
-
It's even possible to use the Tide framework if you don't use GraniteDS as the AMF remoting provider by initializing the application with the singleton Tide.
-
Client-side setup for remoting
-
initialize manually the Flex remoting channels that will be used by Tide
-
use the DefaultServiceInitializer component
-
of course don't forget to change the context root to your web app path
-
{ contextRoot: "/my-app" }
5More
The Future Of JBoss Seam And Apache DeltaSpike - 0 views
-
The Future Of JBoss Seam And Apache DeltaSpike
-
Apache DeltaSpike (currently in incubation) is a set of extensions on Java CDI (Contexts and Dependency Injection)
-
Apr 11, 2012
- ...2 more annotations...
-
We have no intention of releasing Seam 4
-
eventual aim is to migrate all of Seam 3 and MyFaces CODI to DeltaSpike
5More
symbiont/cdiqi · GitHub - 0 views
-
CDI Quartz Scheduler integration
-
simple integration of Quartz Scheduler into CDI application
-
it is not a real CDI extension and doesn't try to fit quartz classes into CDI programming model
- ...2 more annotations...
-
cdiqi just forces Quartz to use CDI beans as its jobs
-
bounds request context to every job execution so that it's possible to use @RequestScoped, @Dependent and @ApplicationScoped jobs and especially beans
40More
Chapter 10. Integration with CDI - 0 views
-
Chapter 10. Integration with CDI
-
GraniteDS provides out-of-the-box integration with CDI via the Tide API
-
GraniteDS also integrates with container security for authentication and role-based authorization
- ...37 more annotations...
-
always have to include this library in either WEB-INF/lib
-
support for CDI is included in the library granite-cdi.jar
-
10.1. Configuration with Servlet 3 On Servlet 3 compliant containers, GraniteDS can use the new APIs to automatically register its own servlets and filters and thus does not need any particular configuration in web.xml. This automatic setup is triggered when GraniteDS finds a class annotated with @FlexFilter in one of the application archives:
-
@FlexFilter(configProvider=CDIConfigProvider.class) public class GraniteConfig { }
-
list of annotation names that enable remote access to CDI beans
-
ConfigProvider
-
override these values by setting them in the annotation properties
-
tide=true, type="cdi", factoryClass=CDIServiceFactory.class, tideInterfaces={Identity.class}
-
@FlexFilter declaration will setup an AMF processor for the specified url pattern
-
tideAnnotations
-
defines suitable default values
-
@TideEnabled
-
@RemoteDestination
-
always declared by default
-
tideInterfaces
-
tideRoles
-
exceptionConverters
-
amf3MessageInterceptor
-
10.3.2. Typesafe Remoting with Dependency Injection
-
It is possible to benefit from even more type safety by using the annotation [Inject] instead of In. When using this annotation, the full class name is used to find the target bean in the CDI context instead of the bean name.
-
Security
-
integration between the client RemoteObject credentials and the server-side container security
-
client-side component named
-
identity
-
API to define runtime authorization checks on the Flex UI
-
login()
-
logout()
-
login(username, password, loginResult, loginFault)
-
logout()
-
bindable property
-
represents the current authentication state
-
loggedIn
-
identity.loggedIn
-
integrated with server-side role-based security
-
identity.hasRole('admin')
-
clear the security cache manually with
-
identity.clearSecurityCache()
24More
Dependency Injection in Java EE 6 - Part 1 - 0 views
-
Dependency Injection in Java EE 6 - Part 1
-
high-level look at CDI, see how it fits with Java EE overall and discuss basic dependency management as well as scoping.
-
CDI is designed to solve
- ...21 more annotations...
-
highly type-safe
-
consistent
-
portable
-
CDI enhances the Java EE programming model in two more important ways
-
allows you to use EJBs directly as JSF backing beans
-
CDI allows you to manage the scope, state, life-cycle and context for objects in a much more declarative fashion, rather than the programmatic way
-
CDI has no component model of its own
-
set of services that are consumed by Java EE components such as managed beans, Servlets and EJBs.
-
well-defined create/destroy life-cycle that you can get callbacks for via the @PostConstruct and @PreDestroy annotations.
-
Managed beans
-
@ManagedBean
-
annotation
-
CDI also integrates with JSF via EL bean name resolution
-
CDI does not directly support business component services such as transactions, security, remoting, messaging
-
Dependency Injection for Java
-
JSR 330
-
JSR 330 defines a minimalistic API for dependency injection solutions and is primarily geared towards non-Java EE environments.
-
Figure 1 shows how CDI fits with the major APIs in the Java EE platform.
-
none of this uses string names that can be mistyped and all the code is in Java and so is checked at compile time
-
Qualifiers
-
are additional pieces of meta-data that narrow down a particular class when more than one candidate for injection exists
47More
shared by kuni katsuya on 13 Sep 12
- No Cached
5. Exception Handling - Confluence - 0 views
www.graniteds.org/...5.+Exception+Handling
graniteds ExceptionHandling javaee6 Flex ActionScript actionscript3
shared by kuni katsuya on 13 Sep 12
- No Cached
-
Exception Handling
-
5. Exception Handling
-
server exceptions
- ...41 more annotations...
-
can be handled on the
-
client-side
-
by defining a
-
fault callback
-
each remote call
-
very tedious
-
possible to define common handlers for particular fault codes on the client-side, and exception converters on the server-side, to convert server exceptions to common fault codes
-
define an
-
ExceptionConverter
-
class
-
Converter
-
ExceptionConverter
-
accepts(Throwable t, Throwable finalException)
-
convert( Throwable t, String detail, Map<String, Object> extendedData)
-
t.getMessage(), detail, t
-
* instead of *wrapping* the server-side exception and rethrowing it to the client, ** extract only details relevant to the client (eg. include: human-friendly error message and any helpful parametrized data, exclude: stack traces), ** "wrap" it in a generic ServiceException, which gets "thrown" remotely to the client * client can check ServiceException.getCode() to implement behavior tailored to server-side exception 'type'
-
-
ENTITY_NOT_FOUND
-
-
This class will
-
intercept
-
all EntityNotFound exceptions on the server-side, and convert it to a proper ENTITY_NOT_FOUND fault event.
-
exception converter has to be
-
declared on the GDS server config :
-
scan="true" in granite-config.xml
-
META-INF/granite-config.properties
-
in the jar containing the exception converter class
-
granite-config.xml
-
<exception-converters> <exception-converter type="com.package.SomeExceptionConverter"/> </exception-converters>
-
Flex side
-
Handler
-
Handler
-
IExceptionHandler
-
-
accepts(emsg:ErrorMessage)
-
handle(context:Basecontext, emsg:ErrorMessage)
-
register it as an exception handler for the
-
Tide context
-
in a static initializer block to be sure it is
-
registered before anything else happens.
-
addExceptionHandler(EntityNotFoundExceptionHandler);
-
ExceptionConverter
-
5. Exception Handling
-
5. Exception Handling
-
5. Exception Handling
4More
Mapping JPA Entities To SQL Views - It Works Even With Derby : Adam Bien's Weblog - 0 views
-
Mapping JPA Entities To SQL View
-
return a different “view” to the client
-
Especially in the context of pagination, where the data is mostly retrieved for read-only purposes, database views are the easier and more efficient alternative. Instead of implementing a lot of plumbing on the “Java-side” all the work could be easily done in the database
- ...1 more annotation...
-
There is a drawback: not all views are updatable. Whether a view is updatable or not highly depends on the complexity and particular database
4More
Enterprise JavaBeans 3.1 with Contexts and Dependency Injection: The Perfect Synergy - 0 views
-
EJB beans cannot be directly exposed to JSF or JSP without a little help from CDI
-
CDI doesn't provide any transactional, monitoring, or concurrency aspect out of the box
-
stateless EJB 3.1 bean as boundary (Facade)
- ...1 more annotation...
-
injected managed beans (controls) results in the simplest possible architecture
8More
7. Tide Framework - Confluence - 0 views
-
GDS/Tide project represents the Data Services part of GDS
-
comparable to LiveCycle Data Services, which is neither open source nor free, as it provides similar features such as client container of managed entities, data paging, and integration with server components, but it is based on completely different principles:
-
strongly typed Hibernate/JPA detached objects
- ...5 more annotations...
-
All managed entity instances are unique in a Tide context
-
Tide keeps the classic three layers web architecture, when LCDS removes the service layer, and is some kind of remote JPA provider for Flex applications
-
Tide approach is to minimize the amount of code needed to make things work between the client and the server
-
principles are very similar to the ones of JBoss Seam, which is the main reason why the first integration of Tide has been done with this framework. Integrations with Spring, EJB 3 and CDI are also available
-
need to compile your MXML/AS sources with the granite-essentials.swc and granite.swc libraries
23More
Chapter 16. Extensibilty - 0 views
-
16.2. Writing a Security Service
-
login(Object credentials)
-
authorize(AbstractSecurityContext Context)
- ...20 more annotations...
-
logout()
-
An implementation of this interface must be thread safe
-
If authorization fails, either because the user is not logged in or because it doesn't have required rights, it must throw an appropriate org.granite.messaging.service.security.SecurityServiceException.
-
Writing a Security Service
-
SecurityService interface
-
nothing to do with a true Flex destination
-
only one instance of this service is used in the entire web-app and will be called by concurrent threads
-
configure
-
login
-
This method is called upon each and every service method call invocations (RemoteObject) or subscribe/publish actions (Consumer/Producer). When used with RemoteObjects, the authorize method is responsible for checking security, calling the service method, and returning the corresponding result.
-
authorize
-
logout
-
handleSecurityException
-
default implementation of this method in AbstractSecurityService is to do nothing
-
security services are not exposed to outside calls
-
configure
-
login
-
authorize
-
logout
-
handleSecurityException
18More
Seam - Contextual Components - 0 views
-
15.6. Authorization
-
Seam Security is built around the premise of users being granted roles and/or permissions, allowing them to perform operations that may not otherwise be permissible for users without the necessary security privileges
-
15.6.1. Core concepts
- ...15 more annotations...
-
15.6.1.1. What is a role? A role is a group, or type, of user that may have been granted certain privileges for performing one or more specific actions within an application
-
used to create logical groups of users for the convenient assignment of specific application privileges
-
15.6.1.2. What is a permission? A permission is a privilege (sometimes once-off) for performing a single, specific action. It is entirely possible to build an application using nothing but permissions, however roles offer a higher level of convenience when granting privileges to groups of users
-
consisting of three "aspects";
-
a target
-
an action
-
a recipient
-
An empty @Restrict implies a permission check of componentName:methodName
-
implied permission required to call the delete() method is account:delete
-
equivalent of this would be to write @Restrict("#{s:hasPermission('account','delete')}")
-
@Restrict annotation may reference any objects that exist within a Seam context. This is extremely useful when performing permission checks for a specific object instance.
-
selectedAccount
-
selectedAccount
-
Identity.instance().checkRestriction
-
If the expression specified doesn't evaluate to true, either if the user is not logged in, a NotLoggedInException exception is thrown or if the user is logged in, an AuthorizationException exception is thrown.