Skip to main content

Home/ SoftwareEngineering/ Group items tagged remote

Rss Feed Group items tagged

Filter: All | Bookmarks | Topics Simple Middle
kuni katsuya

3. Gas3 Code Generator - Confluence - 0 views

www.graniteds.org/...3.+Gas3+Code+Generator

graniteds Gas3 documentation CodeGeneration

shared by kuni katsuya on 21 Jan 13 - No Cached
  • 3. Gas3 Code Generator
  • Known Limitations
  • Gas3 does not support inner classes
  • ...26 more annotations...
  • except of enum type
    • kuni katsuya
      kuni katsuya on 21 Jan 13
       
      not quite sure what this means...
  • must declare your classes in separated source files if you want them to be correctly handled by the generator
  • Java enums
  • enum.gsp
  • JPA entity beans
  • entity.gsp
  • Java interfaces
  • interface.gsp
  • Java services
  • remote.gsp
  • Java events
  • bean.gsp
  • All other Java classes
  • bean.gsp
  • beanBase.gsp
  • beanBase.gsp
  • remoteBase.gsp, or tideRemoteBase.gsp
  • entityBase.gsp, or tideEntityBase.gsp
  • @Entity
  • @MappedSuperclass
  • @RemoteDestination
  • @TideEvent
  • templates are bundled in the granite-generator.jar
  • accessible as resources via the class loader
  • GraniteDS comes with an ActionScript3 code generator that writes AS3 beans for all externalized JavaBeans, with specific support for lazily loaded EJB 3 entities
  • 3. Gas3 Code Generator
kuni katsuya

The WebSocket API - 0 views

dev.w3.org/websockets

HTML5 WebSockets WebSocketsAPI specification

shared by kuni katsuya on 16 Mar 13 - No Cached
  • two-way communication with a remote host.
kuni katsuya

Spring Flex | SpringSource.org - 0 views

www.springsource.org/spring-flex

spring flex spring flex adobe blazeds

shared by kuni katsuya on 11 May 12 - Cached
  • Spring Flex
  • purpose is to make it easier to build Spring-powered Rich Internet Applications using Adobe Flex as the front-end client
  • providing first-class support for using the open source Adobe BlazeDS project and its powerful remoting and messaging facilities in combination with the familiar Spring programming model
kuni katsuya

Chapter 7. Integration with EJB3 - 0 views

www.graniteds.org/...graniteds.ejb3.html

graniteds ejb3 integration

shared by kuni katsuya on 15 May 12 - No Cached
  • Integration with EJB3
  • important to note that identity caches the user access rights so only the first call to hasRole() will be remote
kuni katsuya

Chapter 10. Integration with CDI - 0 views

www.graniteds.org/...graniteds.ee6cdi.html

graniteds cdi integration

shared by kuni katsuya on 15 May 12 - No Cached
  • Integration with CDI
  • GraniteDS provides out-of-the-box integration with CDI via the Tide API
  • tideAnnotations
  • ...5 more annotations...
  • tideInterfaces
  • tideRoles
  • exceptionConverters
  • amf3MessageInterceptor
  • define the list of interface/class names that enable remote access to CDI beans
kuni katsuya

Chapter 5. AS3 Code Generator - 0 views

www.graniteds.org/...graniteds.gas3.html

graniteds as3 actionscript3 code generator

shared by kuni katsuya on 15 May 12 - No Cached
  • AS3 Code Generator
  • GraniteDS comes with an ActionScript3 code generator that writes AS3 beans for all Java beans
  • ActionScript 3 generator is able to write AS3 typed client proxies for exposed remote services
  • ...6 more annotations...
  • Gas3 may also replicate validation annotations in order to use the Flex side validation framework
  • implemented as an Eclipse plugin
  • Ant task.
  • Maven Plugin (Flexmojos)
  • flexmojos-maven-plugin
  • org.sonatype.flexmojos
kuni katsuya

Chapter 2. Usage Scenarios - 0 views

www.graniteds.org/...graniteds.usagescenarios.html

graniteds usage scenarios javaee6 jboss glassfish jpa2 cdi tide

shared by kuni katsuya on 15 May 12 - No Cached
  • Client Options
  • client there are two main choices
  • standard Flex RemoteObject API
  • ...16 more annotations...
  • GraniteDS does not support the standard Consumer and Producer Flex messaging API
  • its own client implementations of these classes org.granite.gravity.Consumer and org.granite.gravity.Producer that provide very similar functionality
  • Tide remoting API with the GraniteDS/Tide server framework integration
  • most advanced features and greatly simplifies asynchronous handling and client data management
  • preferred for new projects
  • Server Options
  • two options
  • GraniteDS service factory
  • RemoteObject API,
  • GraniteDS support for externalization of lazily loaded JPA entities/collections, and support for scalable messaging though Gravity
  • GraniteDS/Tide service factory
  • Tide API
  • full feature set of Tide data management and further integration with data push through Gravity
  • complete support for Spring and Seam security or integration with CDI events
  • Tide/CDI/JPA2/Java EE 6 on JBoss 6/7 or GlassFish 3
  • If you are on a Java EE 6 compliant application server, it is definitely the best option
kuni katsuya

Adobe - real time data streaming | Adobe LiveCycle Data Services ES3: Solutions - 0 views

www.adobe.com/...compare.html

livecycle es blazeds comparison lcds

shared by kuni katsuya on 18 May 12 - Cached
  • BlazeDS
  • Java NIO high-performance messaging (thousands of clients per CPU) No Yes Real Time Messaging Protocol (RTMP) No Yes Data throttling No Yes Reliable communications
  • Managed remoting
  • ...6 more annotations...
  • Transaction (batch processing)
  • Data paging
  • Lazy loading (on demand)
  • Conflict resolution and synchronization
  • SQL adapter
  • Hibernate adapter No Yes "Fiber-aware" assembler No Yes Offline synchronization framework
kuni katsuya

Enterprise JavaBeans 3.1 with Contexts and Dependency Injection: The Perfect Synergy - 0 views

www.oracle.com/...ejb-3-1-175064.html

javaee6 ejb3.1 cdi

shared by kuni katsuya on 12 Jul 12 - No Cached
  • 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();
    • kuni katsuya
      kuni katsuya on 18 Jul 12
       
      both run within same transaction
  • EJB beans cannot be directly exposed to JSF or JSP without a little help from CDI
kuni katsuya

Externalizing Service Configuration using BlazeDS and LCDS - 0 views

coenraets.org/...uration-using-blazeds-and-lcds

flex service configuration

shared by kuni katsuya on 21 Aug 12 - No Cached
  • Externalizing Service Configuration using BlazeDS
  • RemoteObject
  • *when* the configuration of your services is being read.
  • ...26 more annotations...
  • application stops working when you move it to another server
  • project in Flex Builder
  • check “use remote object access service”
  • This adds a compiler argument pointing to the location of your
  • services-config.xml
  • -services
  • services-config.xml
  • When you then
  • compile
  • your application, the required
  • values
  • of services-config.xml are
  • baked into the SWF
  • read at
  • compile time
  • not at runtime
  • {server.name}
  • {server.port}
  • {context.root}
  • {server.name} and {server.port} are replaced at
  • server the SWF was loaded from
  • {context.root} is still substituted at
  • compile time
  • Flex SDK provides an API that allows you to configure your channels at runtime
  • number of ways you can pass values to a SWF at runtime
  • read a configuration file using HTTPService at application startup
kuni katsuya

Dependency Injection in Java EE 6 - Part 1 - 0 views

www.theserverside.com/...-Injection-in-Java-EE-6-Part-1

javaee6 DependencyInjection DI

shared by kuni katsuya on 13 Sep 12 - Cached
  • 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
kuni katsuya

Comparing JSF Beans, CDI Beans and EJBs | Andy Gibson - 0 views

www.andygibson.net/...g-jsf-beans-cdi-beans-and-ejbs

javaee6 ejb3.1 cdi JsfBackingBean

shared by kuni katsuya on 30 Jul 12 - No Cached
  • differences between CDI beans and EJBs is that EJBs are : Transactional Remote or local Able to passivate stateful beans freeing up resources Able to make use of timers Can be asynchronous
  • Stateless EJBs can be thought of as thread safe single-use beans that don’t maintain any state between two web requests
  • Stateful EJBs do hold state and can be created and sit around for as long as they are needed until they are disposed of
  • ...15 more annotations...
  • Stateless beans must have a dependent scope while a stateful session bean can have any scope. By default they are transactional, but you can use the transaction attribute annotation.
  • CDI beans can be injected into EJBs and EJBs can be injected into CDI beans
  • When to use which bean How do you know when to use which bean? Simple.
  • In general, you should use CDI beans unless you need the advanced functionality available in the EJBs such as transactional functions. You can write your own interceptor to make CDI beans transactional, but for now, its simpler to use an EJB until CDI gets transactional CDI beans which is just around the corner
  • Comparing JSF Beans, CDI Beans and EJBs
  • JSF Managed Beans
  • In short, don’t use them if you are developing for Java EE 6 and using CDI. They provide a simple mechanism for dependency injection and defining backing beans for web pages, but they are far less powerful than CDI beans.
  • JSF beans cannot be mixed with other kinds of beans without some kind of manual coding.
  • CDI Beans
  • includes a complete, comprehensive managed bean facility
  • interceptors, conversation scope, Events, type safe injection, decorators, stereotypes and producer methods
  • JSF-like features, you can define the scope of the CDI bean using one of the scopes defined in the javax.enterprise.context package (namely, request, conversation, session and application scopes). If you want to use the CDI bean from a JSF page, you can give it a name using the javax.inject.Named annotation
  • Comparing JSF Beans, CDI Beans and EJBs
  • Comparing JSF Beans, CDI Beans and EJBs
  • JSF Managed Beans
kuni katsuya

Why Service Isn't A ServiceFacade, But ServiceFacade Is Sometimes A Service... : Adam B... - 0 views

www.adam-bien.com/...why_service_isn_t_a

javaee6 ejb3.1 ServiceFacade service boundary

shared by kuni katsuya on 09 Aug 12 - No Cached
  • boundary, which main responsibilities are:Providing coarser granularityEnsuring consistencyProviding a defined entry point which can be easily decorated with aspects / interceptorsExposure of components (what components are we will cover later) functionality to remote clients via IIOP, REST, SOAP, JMS, Hessian etc...
  • ServiceFacade - the facade to Services. The Services just rely on a certain amount of cross cutting aspects and concentrate on the realization of business logic
  • only invokes Services in consistent way, mostly using transactions
  • ...2 more annotations...
  • Services can remain independent
  • ServiceFacade combines them
‹ Previous 21 - 40 of 48 Next ›
Showing 20▼ items per page