Professional Documents
Culture Documents
CONTENTS INCLUDE:
n
Flex Remoting
Integrating Flex with Hibernate
Flex 4 & Spring 3 Integration
n
n
Integrating Pub / Sub Messaging
n
Flex and Spring Security
n
Hot Tips and more...
By Jon Rose and James Ward
extract the ZIP files for the other dependencies specified above. When
INTEGRATING FLEX AND SPRING you’ve completed these steps, run Eclipse. In Eclipse create a server
that will run the application:
Adobe Flex has strong ties to Java, which include an Eclipse-based 1. Choose File > New > Other
IDE and BlazeDS, its open source server-based Java remoting and 2. Select Server > Server
web messaging technology. In late 2008, the Spring community began 3. Click Next
working on the Spring BlazeDS Integration project to add support for 4. Select Apache > Tomcat v6.0 Server
Flex development with Java and Spring. 5. Click Next
6. Specify the location where Tomcat is installed and select the JRE
By default BlazeDS creates instances of server-side Java objects and
(version 5 or higher) to use
uses them to fulfill remote object requests. This approach doesn’t work
7. Click Finish
with Spring, as the framework is built around injecting the service beans
through the Spring container. The Spring integration with BlazeDS There are two ways to begin setting up the Dynamic Web project in
allows you to configure Spring beans as BlazeDS destinations for use as Eclipse. You can either start with a prepackaged project containing
remote objects in Flex. all of the dependencies or you can start from scratch and configure
everything by hand. Starting from scratch will help you to better
This tutorial assumes that you are already familiar with Spring and Flex.
understand how everything fits together, however it will take a little bit
If you need an introduction or refresher to either, check out the Very
more time to download all of the dependencies and configure Spring
First Steps in Flex and Spring Configuration DZone Refcardz. and BlazeDS.
www.dzone.com
BlazeDS provides simple two-way communication with Java To begin with the prepackaged project, download this project archive:
back ends. Flash Player supports a serialization protocol called http://static.springsource.org/spring-flex/refcard/flexspring-refcard_justdeps.zip
AMF that alleviates the bottlenecks of text-based protocols and
provides a simpler way to communicate with servers. AMF is a Then, in Eclipse select File > Import and select the Existing Projects Into
Hot binary protocol for exchanging data that can be used over HTTP Workspace option. Using the Select Archive File option and Browse
Tip in place of text-based protocols that transmit XML. Applications
using AMF can eliminate an unnecessary data abstraction
button, locate the flexspring.zip file, and then click Finish.
layer and communicate more efficiently with servers. To see a Alternatively to start from scratch, set up the server-side Java web
demonstration of the performance advantages of AMF, see the project in Eclipse by creating a web application from the blazeds.war file
Census RIA Benchmark at: http://www.jamesward.org/census (found inside the BlazeDS zip file).
To follow along with this tutorial you will initially need: In Eclipse, import the blazeds.war file to create the project:
• An Eclipse 3.5 Distribution. You may choose either the standard 1. Choose File > Import
distribution: Eclipse 3.5 (Galileo) for Java EE Developers (On Mac use 2. Select the WAR file option. Specify the location of the blazeds.war file.
the Eclipse Carbon version): http://www.eclipse.org/downloads/ For the name of the web project, type flexspring
Or, for enhanced Spring support you might consider using the
3. Click Finish
SpringSource Tool Suite:
http://www.springsource.com/products/springsource-tool-suite-download/ First remove the xalan.jar file from the WebContent/WEB-INF/lib
folder. Next, go into the project properties. One way to get there is
Flex 4 & Spring 3 Integration
First install your chosen Eclipse distribution and then install Flash
Builder 4 as a plug-in to the Eclipse distribution you just installed. Also
properties, select Java Build Path and then click the Source tab. Set the xmlns:context=”http://www.springframework.org/schema/context”
Default Output Folder to be the following (you will need to create the xsi:schemaLocation=”
http://www.springframework.org/schema/beans
classes folder): http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/flex
http://www.springframework.org/schema/flex/spring-flex-1.0.xsd
flexspring/WebContent/WEB-INF/classes
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd”>
This causes all Java classes that are created in the project to be <flex:message-broker>
<flex:remoting-service default-channels=”my-amf”/>
deployed in the web application. </flex:message-broker>
<context:component-scan base-package=”flex” />
In the WebContent/WEB-INF/flex folder update the services-config.xml </beans>
file with the following contents: Listing 3: The basic Spring configuration for Flex Remoting.
In order to communicate with the Friend entity from Flex you will need arg0 label and rename it by typing Name.
a Remoting service to connect to. Similar to the HelloWorldService While you were manipulating elements in the Design canvas for the
example, you can create a Spring bean that will be exposed to Flex. myFriends.mxml application you were actually writing Flex code. Switch
Create a new Java class in the flex package called FriendService with back to Source view so you can see the code and make a few minor
the following contents: changes to the generated code.
package flex; First, you need to tell the generated FriendService instance how to
import java.util.List;
import org.hibernate.SessionFactory; connect to the server. Find the <services:FriendService tag and add a
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.flex.remoting.RemotingDestination; property called endpoint with a value of
import org.springframework.flex.remoting.RemotingInclude;
http://localhost:8080/flexspring/messagebroker/amf, for example:
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Repository <services:FriendService id=”friendService”
@RemotingDestination endpoint=”http://localhost:8080/flexspring/messagebroker/amf”/>
public class FriendService {
private SessionFactory sessionFactory; Listing 10: myFriends.mxml snippet - FriendService with an endpoint.
@Autowired
public void setSessionFactory(SessionFactory factory) { Another small change you will want to make is to refresh the data
sessionFactory = factory;
} in the DataGrid after a new Friend has successfully been created.
@SuppressWarnings(“unchecked”)
@RemotingInclude To do that, first make the event parameter in the dataGrid_
@Transactional creationCompleteHandler function optional. For example:
public List<Friend> getFriends() {
return sessionFactory.getCurrentSession().createQuery(“from Friend”).list();
} protected function dataGrid_creationCompleteHandler(event:FlexEvent=null):void {
@RemotingInclude
@Transactional Listing 11: myFriends.mxml snippet - Optional FlexEvent parameter.
public void createFriend(String name) {
Friend f = new Friend(); Finally update the createFriendResult CallResponder so that on a
f.setName(name);
sessionFactory.getCurrentSession().save(f); result event the dataGrid_creationCompleteHandler function is called.
}
<s:CallResponder id=”createFriendResult”
}
result=”dataGrid_creationCompleteHandler()”/>
Listing 9: FriendService.java - A Spring bean to manage Friend entities.
Listing 12: myFriends.mxml snippet - Refresh the data on result event
The FriendService class is annotated with @Repository to allow it to
Now run the myFriends application and create a new Friend by typing
connect to a DataSource and @RemotingDestination to expose it as
a name in the TextInput and clicking CreateFriend. Verify that the new
a Flex Remoting destination. The SessionFactory is Autowired into
Friend shows up in the DataGrid. You now have a Flex application that
instances of the FriendService using Spring’s dependency injection.
calls a Spring service to interact with Hibernate!
In this case the SessionFactory that is injected is defined in the
applicationContext.xml file. The getFriends method is included Hibernate Lazy Loading and Flex
for Remoting access but also uses the @Transactional annotation When BlazeDS serializes data to send to Flex, that data must
to wrap the database query into a transaction. The createFriend be serializable. This can cause problems with lazy loading of
method, which simply creates a new Friend entity and saves, is also
Hot associations in Hibernate. There are several approaches for
Transactional and included for Remoting.
Tip dealing with this problem. One is to potentially not serialize the
same object graph that is defined in Hibernate Entities but instead
After making these changes, restart your Tomcat server. Verify that utilize Data Transfer Objects for serialization to AMF.
there were no errors on startup.
Create the Flex Application Integrating Pub / Sub Messaging with Flex and Spring
Create a new Flex project called myFriends. Specify the same Flex Remoting is always done in a request / response manner.
parameters as in the first example for the Application Type, Flex SDK Sometimes applications also need to communicate in a publish
version, and Server technology. Click Next and specify the same / subscribe manner. BlazeDS provides the ability for Flex clients
parameters as the sayHello project for Server Location. Click Finish. to connect to a message service and listen for messages or send
messages. The message service can optionally be connected to other
Instead of writing code this time, switch to Design view for the
messaging systems like JMS, ActiveMQ, or any messaging system
myFriends.mxml file. Now in the Data/Services View click Connect to
supported in Spring Integration.
Data/Service, select BlazeDS, and then click Next. When you are asked
for a username and password, check No Password Required and click Sending messages over HTTP is usually technically simple to enable
OK. You should now see a list of services that are configured on your because it can easily be built on HTTP’s request / response nature.
server. Among them should be friendService; select the checkbox However receiving messages is more difficult since the client must
next to that service and then click Finish. This automatically generates initiate connections. To overcome this hurdle BlazeDS has various
the client-side service stubs and value objects used to connect to channels that are configured to do a pseudo push of messages from
friendService. In the Data/Services view you should now see the the server to the client. The primary channels available in BlazeDS are
friendService methods and data types used. HTTP Streaming, HTTP Long-Polling, and HTTP Polling. Each of these
channels has different advantages and disadvantages. For instance
To create the UI for the application, locate the DataGrid component
HTTP Streaming provides very low latency for sending messages but
in the Components view. Drag the DataGrid onto the Design canvas
consumes one of the available HTTP connections the browser allows
of the myFriends.mxml application. Now drag the getFriends method
to a given site. HTTP Streaming in BlazeDS also uses the default HTTP
from the Data/Services View onto the DataGrid of the myFriends.mxml
connector in the Java app server, which usually has a very limited
application. When you are prompted to confirm how you want to bind
number of concurrent connections available. Java NIO provides a
the service call to the DataGrid, click OK. Your DataGrid should now
way to work around those connection limits but today NIO-backed
have two columns: id and name.
connections are only available in Adobe’s commercial superset of
Next, you need some way to create new Friend objects. Right-click the BlazeDS, called LiveCycle Data Services. HTTP Long-Polling and
createFriend method in the Data/Services View and select Generate HTTP Polling can help alleviate some of the connection load but they
Form. When you are presented with a dialog box asking for details also increase latency for sending messages from the server to the
about how to create the form, simply click Finish. You should now have client. Ultimately which channel configuration you select will depend
a form in the Design canvas for myFriends.mxml. You can reposition on your requirements. It’s important to also note that channels can
the form so that it doesn’t overlap the DataGrid. Now double-click the be configured to do automatic failover. So if an HTTP Streaming
connection can’t be made then Flex can try Long-Polling or Polling. service is used simply for application management to do things like
Channel configuration is done in the services-config.xml file. notify the client that their version of the data is stale.
The Spring BlazeDS integration exposes the Messaging features of Flex and Spring Security
BlazeDS so that they can be configured in Spring config and easily Most real-world Flex applications require a user to login before
connected to Spring services and messaging systems. To configure they can perform certain actions in the application. Enabling user
a Messaging destination for Flex simply add the message-service to authentication and application security with Flex and Spring is simple
the message broker in the applicationContext.xml file. Then create a to set up and implement. To get started you will need to download
message-destination in that same file. For this example set the id of Spring Security 3.0.2 from http://www.springsource.org/download and
the message-destination to chat. copy the following JAR files into the WEB-INF/lib for the flexspring web
app project:
<flex:message-broker>
<flex:remoting-service default-channels=”my-amf” /> • spring-security-acl-3.0.2.RELEASE.jar
<flex:message-service
default-channels=”my-streaming-amf,my-polling-amf” /> • spring-security-config-3.0.2.RELEASE.jar
</flex:message-broker> • spring-security-core-3.0.2.RELEASE.jar
<flex:message-destination id=”chat” />
• spring-security-web-3.0.2.RELEASE.jar
Listing 13: applicationContext.xml - Messaging enabled configuration.
Now modify the applicationContext.xml file to add in some Spring
Now create a new Flex Project just as before but call it “chat”. Update Security information:
the chat.mxml file with the following code: <?xml version=”1.0” encoding=”UTF-8”?>
<beans xmlns=”http://www.springframework.org/schema/beans”
<?xml version=”1.0” encoding=”utf-8”?> xmlns:flex=”http://www.springframework.org/schema/flex”
<s:Application xmlns:fx=”http://ns.adobe.com/mxml/2009” xmlns:context=”http://www.springframework.org/schema/context”
xmlns:s=”library://ns.adobe.com/flex/spark” xmlns:tx=”http://www.springframework.org/schema/tx”
xmlns:mx=”library://ns.adobe.com/flex/mx”> xmlns:jdbc=”http://www.springframework.org/schema/jdbc”
<fx:Script> xmlns:security=”http://www.springframework.org/schema/security”
import mx.messaging.messages.AsyncMessage; xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
</fx:Script> xsi:schemaLocation=”
<fx:Declarations> http://www.springframework.org/schema/beans
<s:ChannelSet id=”channelSet”> http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
<s:StreamingAMFChannel http://www.springframework.org/schema/flex
uri=”http://localhost:8080/flexspring/messagebroker/streamingamf”/> http://www.springframework.org/schema/flex/spring-flex-1.0.xsd
<s:AMFChannel http://www.springframework.org/schema/context
uri=”http://localhost:8080/flexspring/messagebroker/amfpolling” http://www.springframework.org/schema/context/spring-context-3.0.xsd
pollingEnabled=”true” pollingInterval=”5”/> http://www.springframework.org/schema/tx
</s:ChannelSet> http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
<s:Consumer id=”c” destination=”chat” channelSet=”{channelSet}” http://www.springframework.org/schema/jdbc
message=”ta.text += event.message.body + ‘\n’”/> http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
<s:Producer id=”p” destination=”chat” channelSet=”{channelSet}”/> http://www.springframework.org/schema/security
</fx:Declarations> http://www.springframework.org/schema/security/spring-security-3.0.xsd”>
<s:applicationComplete> c.subscribe(); </s:applicationComplete> <security:global-method-security secured-annotations=”enabled”
<s:layout><s:VerticalLayout/></s:layout> jsr250-annotations=”enabled”/>
<s:TextArea id=”ta” width=”300” height=”150”/> <security:http entry-point-ref=”preAuthenticatedEntryPoint”>
<s:TextInput id=”ti”/> <security:anonymous enabled=”false”/>
<s:Button label=”send” click=”p.send(new AsyncMessage(ti.text))”/> </security:http>
</s:Application> <bean id=”preAuthenticatedEntryPoint”
class=”org.springframework.security.web.authentication.Http403ForbiddenEntryPoint”
Listing 14: chat.mxml - A simple Chat application using Flex Messaging />
<security:authentication-manager>
<security:authentication-provider>
Restart the Tomcat server and run the application. Open two browser <security:user-service>
windows to verify that the messaging is happening correctly. <security:user name=”john” password=”john” authorities=”ROLE_USER” />
</security:user-service>
</security:authentication-provider>
In the Chat application there is a ChannelSet declaration that defines </security:authentication-manager>
<flex:message-broker>
how messages will be sent and received from the server. The first <flex:remoting-service default-channels=”my-amf” />
<flex:message-service
child inside the ChannelSet is the StreamingAMFChannel. Flex default-channels=”my-streaming-amf,my-polling-amf” />
will try to make that connection first. Next is the AMFChannel with <flex:secured/>
</flex:message-broker>
polling enabled on a 5 second poll interval. Also declared in the ... (file truncated)
Chat application is a Consumer, which can listen for messages from Listing 15: applicationContext.xml snippet - Enable Security annotations.
the server using the ChannelSet. A message event handler on the
The configuration in Listing 15 simply tells Spring about a basic
Consumer tells the application to append the body of the message to
user-service authentication-provider. Real-world applications use a
the TextArea. A Producer declaration is used to send messages to the
database or LDAP server for user credentials and authentication.
message service. Notice that both the Consumer and Producer have
their destination set to chat, which is the id of the message-destination Add the following filter, and filter-mapping to the web.xml file to
that was defined in the Spring configuration. enable Spring Security for the web application:
An applicationComplete event handler calls the subscribe method on <filter>
<filter-name>springSecurityFilterChain</filter-name>
the Consumer to begin listening for messages from the server. <filter-class>
org.springframework.web.filter.DelegatingFilterProxy
The UI for the Chat application is very simple. The TextArea displays </filter-class>
</filter>
the chat messages. A TextInput allows the user to enter the text for a <filter-mapping>
<filter-name>springSecurityFilterChain</filter-name>
new chat message, and a Button allows the user to send the message. <url-pattern>/*</url-pattern>
In the click handler for the Button a new AsyncMessage is created with </filter-mapping>
its body set to the text the user entered in the TextInput. That message Listing 16: web.xml snippet - Enables Spring Security for the web application.
is then sent to the Producer, which connects to the server and sends Modify the HelloWorldService.java file to protect calls to the sayHello
the message. BlazeDS then tries to send that message out to all clients method by adding the following annotation above the method:
that are connected to the destination. When a connection is available
@Secured(“ROLE_USER”)
the Consumer will receive any queued messages on the server and fire
Listing 17: HellowWorldService.java snippet - Only users with ROLE_USER can call the
message events for each message. sayHello method
Flex Messaging uses AMF internally so complex objects can be sent Make sure you add the import statement for org.springframework.
and received through the message service, just like with Remoting. security.access.annotation.Secured then save the class and restart
On top of the Producer and Consumer APIs, very powerful real-time Tomcat. Now run the sayHello Flex application. Remote calls to the
and near real-time applications can be built. These can range from helloWorldService sayHello method should now fail. Update the
collaborative applications to trader desktops. Sometimes the message sayHello.mxml file with the following contents:
<?xml version=”1.0” encoding=”utf-8”?> user to login to the server. In this example the credentials for login
<s:Application xmlns:fx=”http://ns.adobe.com/mxml/2009” are hardcoded. For a real-world application the credentials would
xmlns:s=”library://ns.adobe.com/flex/spark”
xmlns:mx=”library://ns.adobe.com/flex/mx”> likely come from TextInput controls – allowing the user to enter their
<fx:Script>
import mx.rpc.AsyncResponder; username and password. Also the Boolean variable loggedIn tracks
import mx.rpc.events.FaultEvent;
import mx.rpc.events.ResultEvent; whether the user is authenticated or not. This Boolean is also used to
private function handleFault(event:FaultEvent, o:Object=null):void { enable and disable the login and logout buttons.
l.text = event.fault.faultString;
}
</fx:Script> Rerun the sayHello application and try to call the sayHello method
<fx:Declarations>
<fx:Boolean id=”loggedIn”>false</fx:Boolean>
when not logged in. Now login and try it again. That is how simple it is
<s:RemoteObject id=”ro” to set up Spring Security with Flex!
destination=”helloWorldService”
fault=”handleFault(event)”>
<s:channelSet>
<s:ChannelSet>
<s:AMFChannel uri=”/flexspring/messagebroker/amf”/>
CONCLUSION
</s:ChannelSet>
</s:channelSet>
</s:RemoteObject>
</fx:Declarations> In this Refcard, you learned how to use Flex Remoting and Messaging to
<s:layout><s:VerticalLayout/></s:layout>
<s:TextInput id=”t”/>
connect to Spring and Hibernate. You also learned how to use Spring
<s:Button label=”sayHello” click=”ro.sayHello(t.text)”/> Security with Flex. As you can see, the Spring BlazeDS Integration
<s:Label id=”l” text=”{ro.sayHello.lastResult}”/>
<s:Button label=”login” enabled=”{!loggedIn}”> project makes integrating Flex and Spring easy and straightforward.
<s:click>
ro.channelSet.login(‘john’, ‘john’).addResponder(new AsyncResponder( The combination of the two technologies creates a powerful platform
function(result:ResultEvent, o:Object):void {
loggedIn = true;
for building robust RIAs. You can learn more about integrating Flex and
l.text = “logged in”; Spring on the Spring BlazeDS Integration project site:
}, handleFault));
</s:click> http://www.springsource.org/spring-flex
</s:Button>
<s:Button label=”logout” enabled=”{loggedIn}”>
<s:click> To receive help with Spring BlazeDS integration ask questions in the
ro.channelSet.logout().addResponder(new AsyncResponder( Spring Forums: http://forum.springsource.org/forumdisplay.php?f=61
function(result:ResultEvent, o:Object):void {
loggedIn = false;
l.text = “logged out”; Download the full source code, configuration, and dependencies for
}, handleFault));
</s:click> all of the projects from: http://static.springsource.org/spring-flex/refcard/
</s:Button>
</s:Application> flexspring-refcard_completed.zip
Listing 18: sayHello.mxml - Enables the user to login and logout. Find screencasts which explain these code examples at:
The updated sayHello application now has buttons that allow the http://www.jamesward.com/flex-and-java-resources/
#82
CONTENTS INCLUDE:
■
■
About Cloud Computing
Usage Scenarios Getting Started with
Aldon Cloud#64Computing
■
Underlying Concepts
Cost
by...
■
Upcoming Refcardz
youTechnologies ®
■
Data
t toTier
brough Comply.
borate.
Platform Management and more...
■
Chan
ge. Colla By Daniel Rubio
tion:
dz. com
tegra ternvasll
ABOUT CLOUD COMPUTING one time events. TEN TS
INC ■
HTML LUD E:
us Ind Anti-PPaat
Basics
Automated growthHTM
ref car
nuorn
■
Valid
ation one time events, cloud ML
connected to what is now deemed the ‘cloud’. Having the capability to support
Apache Ant
Usef
Du
ti
■
ul M.
computing platforms alsoulfacilitate
#84
Open the gradual growth curves
n an
Page Source
o
■
s
Vis it
C
faced by web applications. Tools
Core
By Key ■
Elem
Patte
has changed substantially in recent years, especially with Structur
E: al Elem ents
INC LUD gration the entrance of service providers like Amazon, Google and Large scale growth scenarios involvingents
specialized
NTS and mor equipment
rdz !
HTML
CO NTE Microsoft. es e... away by
(e.g. load balancers and clusters) are all but abstracted
Continu at Every e chang
m
About ns to isolat
relying on a cloud computing platform’s technology.
Software i-patter
space
Hadoop
rdz .co
■
n
Re fca
e Work
Build
riptio
and Ant
Desc
These companies have a Privat
are in long deployed
trol repos
itory
webmana applications
ge HTM
L BAS
■
Build
re
Buil Repo
This Refcard active
will introduce are within
to you to cloud riente computing, with an
d units
RATION etc. Some platforms ram support large grapRDBMS deployments.
■
The src
dy Ha
softw
e ine loping and Java s written in hical on of
INTEG attribute
task-o it all
softwar emphasis onDeve es by
Mainl these
ines providers, so youComm can better understand
also rece JavaScri user interfac web develop and the rris
Vis it
Spring Security
codel chang desc
INUOU ding Task Level as the
e code
w ww.dzone.com
Label
Build
manu
al
d tool
depe deplo t need but as if
eve , a ) stalle the same nmen for stan overlap uen
(i.e. , inef Build t, use target enviro Amazon EC2: Industry standard it has
software and uagvirtualization ine. HTM , so <a>< tly are) nest
with terns problem ce pre-in whether dards
ated b></
ory. ns (i.e. Autom Redu ymen
has bec become e with a> is
via pat ticular d deploEAR) in each very little L
Subversion
reposit -patter s that Pay only cieswhat you consume
tagge or Amazon’s cloud
the curr you cho platform
computing isome
heavily based moron fine. b></ ed insid
lained ) and anti the par solution duce nden For each (e.g. WAR es t
ent stan ose to writ more e imp a></ e
not lega each othe
x” b> is
be exp text to “fi are al Depeapplication deployment
Web ge until t a
librarifew years agonmen
t enviro was similar that will softwaredard
industry standard and virtualization app
e HTM technology.
orta nt,
tterns to pro Minim packa nden
Mo re
CI can ticular con used can rity all depe all targe
s will L or XHT arent. Reg the HTM l, but r. Tags
etimes Anti-pa they
tend
es, but to most phone services:
y Integ alizeplans with le that
late fialloted resources, ts with an and XHT simplify all help ML, und ardless
L VS
XHTM <a><
in a par hes som
Centr
end,
Binar
pro cess. the practic enti ng incurred costgeme
nt
whether e a single
such
temp
resources on
were consumed
t enviro
nmen
orthenot. Virtualization MLaare your
othe
you prov
erst of L
b></
in muchallows physical piece of hardware to
ide be HTM
rily bad
Mana based
approac ed with the cial, but, implem anding
Creat targe es to actually r web
nden
cy rties are nt
of the a solid L has
into differe coding.resources
necessa pared to
chang
efi Depe prope itting utilized by multiple operating
function systems.simplerThis allows foundati job adm been arou
associat to be ben
er
Ge t
te builds commo
are not Fortuna
late Verifi e comm than on
n com Cloud computing asRun it’sremo
known etoday has changed this.
befor alitytohas irably, nd for
They they
etc.
Temp Build (e.g. bandwidth, n memory, CPU) be allocated exclusively to tely exp that som
lts whe
ually,
appear effects. Privat y, contin Every elem mov used
to be, HTML
ecte job e time
ed resu The various resourcesPerfo rm a
consumed by webperio applications
dicall (e.g. nt team
pag
individual operating entsinstances. ed to CSS
system Brow d. Earl
y HTM has expand . Whi
gration
opme because
adverse unintend d Builds sitory Build r to devel common e (HTML . ser ed far le it has don
ous Inte web dev manufacture L had very
Stage Repo
e bandwidth, memory, CPU) areIntegtallied
ration on a per-unit CI serve basis or XHT
produc tinu e Build rm an from
extensio .) All are more e its
e.com
DZone, Inc.
Cloud Computing
the
s on
expand
ISBN-13: 978-1-934238-71-4
140 Preston Executive Dr. ISBN-10: 1-934238-71-6
Suite 100
50795
Cary, NC 27513