Struts:The good, the bad, the ugly - PowerPoint PPT Presentation

1 / 62
About This Presentation
Title:

Struts:The good, the bad, the ugly

Description:

Struts:The good, the bad, the ugly A detailed evaluation of Struts 1.1 and Enterprise Web Applications. By Paul Smith Ancept, Inc. (www.ancept.com) – PowerPoint PPT presentation

Number of Views:153
Avg rating:3.0/5.0
Slides: 63
Provided by: Bub72
Category:
Tags: bad | good | java | servlet | struts | ugly

less

Transcript and Presenter's Notes

Title: Struts:The good, the bad, the ugly


1
StrutsThe good, the bad, the ugly
  • A detailed evaluation of Struts 1.1 and
    Enterprise Web Applications.
  • By Paul Smith
  • Ancept, Inc. (www.ancept.com)
  • psmith_at_ancept.com

2
Presentation Overview
  • Themes
  • Struts Overview (Basic Features)
  • Development Challenges in 1.0
  • Problem Description
  • Solution in 1.1
  • Example
  • Architectural Challenges Struts Applications
  • Problem Description
  • Possible Solution
  • Q A

3
Themes
  1. Struts 1.1 provides small to medium sized
    applications all the functionality they should
    need out of the box
  2. A large project team should be aware of
    limitations of Struts 1.1 which may require
    customized solutions
  3. Large architecture teams may need a custom
    implementation of Struts 1.1 to enterprise class
    architectures

4
Supporting the Themes
  • To illustrate the themes
  • Section 1 describes Struts basic features
  • Section 2 describes the new features of Struts
    1.1 and why they exist
  • Section 3 describes architectural challenges in
    large projects and possible solutions

5
Section 1-Basic Features
  • Why Use A Framework
  • Struts Overview

6
Why Use the Struts Framework
  • A pre-built framework is better than
    roll-your-own
  • Increased productivity in JSP production
  • Cleaner design
  • More time on business logic

7
Easier than building your own
  • Probably very similar to what you would end up
    building anyway
  • Strong industry support instead of your own
    custom framework
  • The Struts framework is configurable so it will
    probably work for your project without building
    your own
  • Customizing open-source is simpler than building
    from scratch

8
JSP Productivity
  • Writing pages in Struts is roughly 40-60 faster
    than without struts because you use tags NOT java
    code
  • The custom tags, form object, messages
    architecture makes data display easy (for medium
    sized apps)
  • Tiles development helps manage page complexity

9
Cleaner Design
  • Struts applications are easier to develop and
    maintain because the design concepts are elegant
  • Non-technical staff better understands layout and
    design
  • Since code is targeted at specific business
    problems, the team communicates better
  • Design is easier to expand for very large
    application architectures

10
More Time on Business Logic
  • Less coding of web infrastructure means more time
    for business logic
  • Page flow design
  • Action execution synchronization
  • Page model objects
  • Validation
  • Page templates
  • Focus on re-usable custom frameworks to use with
    Struts (J2EE integration, Web services)

11
Struts Overview
  • Struts Description
  • Common Infrastructure Tasks
  • Struts Solutions to Infrastructure Tasks
  • How does Struts works
  • The Struts Configuration File
  • Where does it fit in J2EE applications
  • Case Study

12
Struts Description
  • Struts is a Web Application Framework (custom tag
    libraries, servlet, xml control files) which
    increase the productivity of web developers
  • Struts was invented by Craig McClanahan in 2000
  • Struts solves common problems with web
    application development by abstracting common
    infrastructure tasks

13
Common Infrastructure Tasks
  • Page flow design and control
  • Code execution framework (Command Pattern)
  • Automated data objects (MVC Pattern)
  • Easy to use custom tags for display
  • Validation
  • Page templates layout
  • Re-usable text messages
  • Much more

14
Struts Solutions to Infrastructure
  • Forwards Page flow design and control
  • Actions Code execution framework (Command
    Pattern)
  • Forms Automated data objects (MVC Pattern)
  • Struts Tags Easy to use custom tags for display
  • Validator Validation
  • Tiles Page templates layout
  • Message Resources Handles re-usable text
    messages in multiple languages

15
How Struts Works
16
Struts Configuration
  • Struts is controlled by a Configuration file
  • Struts Configuration contains
  • Form Definitions Data objects for JSP pages
  • Forward Definitions Abstract pages for page flow
    control
  • Action Definitions maps requests to Command
    class
  • Message Resources Storage of common text
    messages
  • Plug-In Definitions Startup classes used for
    initializing custom functionality

17
Where does Struts fit into J2EE
18
Case Study
  • Department of Transportation created an aircraft
    registration application for internal staff (J2EE
    with a 2nd Generation Framework)
  • 100 JSPs
  • 13.5 k lines of code in the web tier (no business
    logic).
  • 20,000 lines of code for business logic.
  • 8 months of development with a team of 5

19
Section 1 Conclusion
  • Struts base feature-set include significant
    functionality for small to medium applications
  • Small applications should not need to customize
    Struts significantly
  • Form objects and Action classes provide MVC
    design
  • Action classes house functional code
  • Forwards abstract page flow control
  • Form objects and Struts tags provide page display
  • Tiles provides flexible page layout
  • Validator provides flexible form/page level
    validation
  • Message Resources provide re-usable text

20
Development Challenges in 1.0
  • Large Numbers of Form Classes
  • Large teams and Resources
  • Handling Errors More Flexibly
  • Problems with Page Layout
  • Validating Pages and Forms
  • Initializing Custom Functionality

21
Lots of Form Classes
  • In Struts 1.0 developers had to write a custom
    class for every form (generally 1 per JSP form)
  • Form classes are generally very simple
  • Task assigned to junior programmers (drudge work)
  • Form classes sometimes not consistent

22
1.1 Solution Dynamic Form Objects
  • Declare Forms in the struts-config.xml file
  • Form objects are created when the action executes
    and stored in the session or request scope
  • Form fields are set and retrieved using the
    PropertyUtils.setSimpleProperty() method or
    treated as HashMap

23
Dynamic Form Example
  • Declaration
  • ltformgt
  • ltform-property name type value/gt
  • lt/formgt

Java Use Public void execute(mapping, form,
) String testProp (String)PropertyUtils.getSi
mpleProperty(form, testProp) PropertyUtils.set
SimpleProperty(form, testProp, value)
24
Large Teams and Resources
  • It has been difficult to co-ordinate the
    struts-config file and other resources with large
    teams and projects
  • Resources declared in config file might need to
    be different for portions of the application
    (shippingForm)
  • Partitioning development teams has been somewhat
    difficult

25
1.1 Solution Modules
  • Separate, independent applications (uses
    different configuration file) under default
    application
  • Modules are based on paths (xyz.com/app/sub-app)
    and web.xml entries
  • Created to modularize large applications
  • Break modules up according to team
  • Unable to share resources between modules

26
Module Example
Jakarta Struts 1.1 Ready for Prime Time (PDF) by
Chuck Cavaness.
27
Handling Errors
  • Struts 1.0 applications had to do all of their
    error handling inside the Action classes
  • This could mean a significant amount duplication
    of error handling code
  • Some large apps had to customize the framework to
    do flexible error handling

28
1.1 Solution Declarative Error Handling
  • Provides global and per Action handling of errors
  • Declare errors by Exception class
  • Create custom error handlers by implementing
    interface

29
Error Handling Example
  • Declaration
  • ltglobal-exceptionsgt
  • ltexception handler"CustomHandler"
    key"error.message" path"/error.jsp"
    scope"request" type"java.lang.Exception"/gt
  • lt/global-exceptionsgt

Java Use public ActionForward execute( Exception
ex, ExceptionConfig exConfig, ActionMapping
mapping, ActionForm formInstance,
HttpServletRequest request, HttpServletResponse
response ) throws ServletException handle
error return mapping.findForward(errorPage)
30
Problems with Page Layout
  • Struts 1.0 provided some page layout mechanism
  • Large application pages can get very complicated
    without a better layout mechanism
  • 1.0 version could not change based on Locale
  • 1.0 version did not have significant re-use
    functionality

31
1.1 SolutionTiles Integration
  • Tiles code has been integrated into core Struts
  • Tiles provides flexible page layout and re-use
    mechanism
  • Provides support for Locales
  • Tiles can be nested
  • Tiles can be used as Struts Forwards by tile name

32
Tiles Example
  • Tiles-Config.xml
  • ltdefinitionsgt
  • ltdefinition namehome.default
    path/index.jsp/gt
  • ltput nameheader valueheader.jsp/gt
  • lt/definitiongt
  • ltdefinition namehome.default
  • extendshome.default/gt
  • ltput nameheader valueother.jsp/gt
  • lt/definitiongt
  • lt/definitionsgt

Index.jsp lt_at_ taglib URIWEB-INF/tiles.tld
nametilesgt lthtmlhtmlgt ltbodygt lttilesinsert
attributeheader/gt lttilesinsert
attributebody/gt lttilesinsert
attributefooter/gt
33
Validating Pages and Forms
  • Struts 1.0 only provided automatic support for
    validating form objects (by calling the validate
    method)
  • Programmers had to implement validation code
    inside of the class (ex. making sure phone was
    really a number) by hand
  • Client-side validation had to be implemented by
    hand

34
1.1 Solution Validator Integration
  • Validator integrated into core code base
  • Use a xml file to declaratively validate form
    objects
  • Validators are keyed against the form by name
  • Comes with many pre-built validators (e-mail,
    date, etc)
  • Supports client-side (JavaScript) and server-side
    validation

35
Validator Config Example
  • Struts-Config.xml
  • ltform nameshippingFormgt
  • ltform-property nameaddress typejava.lang.Stri
    ng /gt
  • lt/formgt

Validator.xml ltform nameshippingFormgt ltfield
propertyaddress dependsrequired,
mask/gt ltarg0 keylabel.address/gt ltvargt
ltvar-namegtmasklt/var-namegt
ltvar-valuegt\wlt/var-valuegt lt/vargt lt/fieldgt
36
Validator JSP Example
  • Index.jsp
  • lt_at_ taglib URIWEB-INF/tiles.tld nametilesgt
  • lthtmlhtmlgt
  • ltbodygt
  • lthtmlform actionlogonSubmit
    onsubmitvalidateLogonForm(this)gt
  • (this makes the form call the validation
    JavaScript onSubmit)
  • lttablegt
  • etc.
  • lt/tablegt
  • ltvalidatorjavascript formNamelogonForm/gt
    (This inserts the javascript which executes the
    validation)

37
Initializing Custom Functionality
  • Often custom applications need to initialize
    information when the application starts up
  • Since Struts runs off of a servlet this was very
    difficult

38
1.1 Solution Plug-Ins
  • Plug-Ins provide a means for initializing
    components on application startup
  • Provide means for Factory functionality or
    customization
  • Init-parameters let you pass information into
    plug-in

39
Plug-in Example
  • Struts-Config.xml
  • ltplug-in classnameTestPlugingt
  • ltset-property propertydatasource
    valuetestData/gt
  • ltset-property propertyuser valueuser/gt
  • lt/plug-ingt

TestPlugin Code public void init(ActionServlet
servlet, ApplicationConfig config) perform
initialization Public void destroy() perfor
m shutdown
40
Section 2 Conclusion
  • Struts 1.1 has added significant functionality to
    help medium to large application teams
  • Even large application teams should be able to
    use Struts without actually modifying the
    underlying Struts code
  • Plug-ins allow initialization of advanced
    patterns
  • Declarative error handling allows re-use of error
    code
  • Dynamic forms save tremendous effort
  • Validation saves significant effort
  • Modules provide large team partitioning

41
Architectural Challenges
  • Contextual Pages Declarative Branching
  • Composable Actions
  • Re-Use
  • Event Handling
  • J2EE Integration
  • Content Management Integration

42
Contextual Pages
  • Sometimes the developer wants to use JSPs in
    different locations in the page flow
  • These pages and their associated action classes
    must then have large if/then blocks
  • Certain types of context tracking are almost
    impossible without extending the framework
    (dynamically modifying actions, etc)

43
Contextual Pages
44
Declarative Branching
45
Solutions Context Subsystem
  • Create Context object which tracks the path the
    user has traveled
  • Create ContextualAction super-class which adds
    the page and action to the context
  • Make all Action classes subclass ContextualAction
    and use path history for logic

46
Composable Actions
  • Actions are currently made up of only one class
    file
  • To partition an Action the developer must use
    large if/then blocks and Request properties
  • The developer must put all of this code in one
    action or write custom JavaScript to call
    different actions based on the users mouse-click
  • This is not made easy for the developer and can
    cause problems if not thought through early on

47
Composable Actions
48
SolutionComposable Actions
  • Some amount of composition can be achieved
    using local ActionForwards
  • Better composition can be achieved with the
    Struts Action Plug-in Extension 1.0.2 by
    ASQdotCOM
  • Struts 2.0 should have a workflow component to
    compose actions from re-usable steps

49
SolutionComposable Actions
  • Step 1Write a Java class that implements the
    ActionPlugIn interface, to create an action
    plug-in.
  • Step 2Declare (and configure) the action plug-in
    that you created in step 1 in the
    action-plug-in-config.xml configuration file.
  • Step 3Add a Struts ltplug-ingt tag to the
    struts-config.xml configuration file to get the
    action plug-in chain initialized on application
    start-up.
  • Step 4Make sure that there is a ltcontrollergt tag
    specified in the struts-config.xml configuration
    file, that has its processClass attribute set to
    be.ff.web.struts.action.ActionPlugInRequestProcess
    or.

50
SolutionComposable Actions
  • Declaration
  • ltaction-plug-in-configgt
  • ltaction-plug-ingt ltclassgtActionPlugInlt/classgt
  • ltinit-paramsgt
  • ltinit-paramsgt
  • ltdisabled-forgt /logon
  • lt/disabled-forgt
  • lt/action-plug-ingt
  • ltaction-plug-ingt ltclassgtWorkflowActionPlugInlt/clas
    sgt
  • lt/action-plug-ingt

Java Use public ActionForward execute() throws
ActionPlugInException UserAccount account
(UserAccount) session.getAttribute(accountSessionK
ey) if (account null) return
mapping.findForward("logon") else
return chain.execute(mapping, form, request,
response)
51
Re-Use
  • There are two possibilities for re-use in Struts,
    pages and actions
  • Re-use of actions is very difficult because
  • the granularity of the actions is too high (one
    action per page)
  • The actions cannot be chained together or
    segmented
  • Re-use of pages in struts is very difficult
    because
  • There is no context object tracking location,
    etc.
  • There is no way of overriding a page/form
    declaration within a context

52
Action Re-use
Action Re-use
53
J2EE Integration
  • Struts does not provide any out of the box
    functionality for J2EE integration (EJBs, JDO,
    JDBC, JMS, JavaMail)
  • Each project/development team must decide ahead
    of time on a mechanism to do J2EE integration
  • Developers must build their own frameworks for
    J2EE integration even in very simple applications

54
Solution J2EE Integration
  • Create Declarative support for long-lived model
    objects (beyond forms)
  • Create Struts J2EE integration (session and
    entity beans) using dynamic value objects and
    session bean proxies
  • Create Struts JDO integration

55
Solution J2EE Integration
56
Events
  • Struts provides no mechanism for event based
    functionality
  • Though not strictly required, it is often much
    easier to write some function using an event
  • For example, if you want to run some function
    every time the user goes to the edit page, but
    the edit page can be reached by 10 different
    actions

57
Solution Event Subsystem
  • Create an Event Multicaster/Controller to manage
    event listeners and publish specific events
  • Most useful events are Navigation, Action, Form
    events
  • Create Action Superclass which fires navigation
    and action events
  • Create Dynamic form superclass which fires form
    events

58
Solution Event Subsystem
Fire Action Event
Fire Navigate Event
59
Content Integration
  • Struts provides very little in terms of content
    management integration.
  • If your team uses custom content management
    systems, you will have to customize the own
    framework
  • The message framework in Struts is only
    acceptable for small to medium applications

60
Solution Content Integration
  • Customize Message Resources classes to handle
    more advanced input
  • Customize Validator framework to handle more
    advanced input
  • Possible input mechanisms
  • Xml files
  • Content Management Systems
  • DBMS

61
Section 3 Conclusion
  • While Struts 1.1 provides excellent features for
    web applications it may be deficient for
    Enterprise class architectures
  • Large Application Teams may need to create a
    custom Struts implementation to accomplish
  • Contextual Page Handling
  • Dynamic Action Branching and page flow
  • Composable Actions for Re-Use
  • Significant J2EE integration
  • Event Handling
  • Content Management Integration

62
Resources
  • Struts website http//jakarta.apache.org/struts
  • Struts Action Plug-in Extension 1.0.2
    http//www.asqdotcom.be/struts/
  • Struts workflow proposal http//jakarta.apache.or
    g/struts/proposals/workflow.html
  • Struts Resources http//jakarta.apache.org/struts
    /resources/index.html
Write a Comment
User Comments (0)
About PowerShow.com