Learning Vaadin

There is a newer version of this book available - Learning Vaadin 7: Second Edition
Learning Vaadin
eBook: $29.99
Formats: PDF, PacktLib, ePub and Mobi formats
save 15%!
Print + free eBook + free PacktLib access to the book: $79.98    Print cover: $49.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Table of Contents
Sample Chapters
  • Discover the Vaadin framework in a progressive and structured way
  • Learn about components, events, layouts, containers, and bindings
  • Create outstanding new components by yourself
  • Integrate with your existing frameworks and infrastructure
  • Pragmatic and no-nonsense approach

Book Details

Language : English
Paperback : 412 pages [ 235mm x 191mm ]
Release Date : October 2011
ISBN : 1849515220
ISBN 13 : 9781849515221
Author(s) : Nicolas Fränkel
Topics and Technologies : All Books, Web Development, Open Source, Web Development

Table of Contents

Chapter 1: Vaadin and its context
Chapter 2: Environment Setup
Chapter 3: Hello Vaadin!
Chapter 4: Components and Layouts
Chapter 5: Event listener model
Chapter 6: Containers and Related Widgets
Chapter 7: Advanced Features
Chapter 8: Creating Custom Components
Chapter 9: Integration with Third-party Products
Chapter 10: Beyond Application Servers
  • Chapter 1: Vaadin and its context
    • Rich applications
      • Application tiers
        • Tiers migration
      • Limitations of the thin-client applications approach
        • Poor choice of controls
        • Many unrelated technologies
        • Browser compatibility
        • Page flow paradigm
      • Beyond the limits
        • What are rich clients?
        • Some rich client approaches
    • Why Vaadin?
      • State of the market
      • Importance of Vaadin
      • Vaadin's integration
        • Integrated frameworks
        • Integration platforms
      • Using Vaadin in the real world
        • Concerns about using a new technology
        • More reasons
    • Summary
    • Chapter 2: Environment Setup
      • Vaadin in Eclipse
        • Setting up Eclipse
          • When Eclipse is not installed
          • Installing the Vaadin plugin
          • Creating a server runtime
          • Creating our first Eclipse Vaadin project
          • Testing our application
        • Alternatives
          • Vendor-specific distribution
          • When Eclipse is already installed
      • Vaadin in NetBeans
        • Setting up NetBeans
          • Checking if Java Web features are present
          • Checking if the Vaadin plugin is installed
          • Installing the Vaadin plugin
        • Creating our first NetBeans Vaadin project
          • Changing the Vaadin version
        • Testing the application
      • Vaadin and other IDEs
        • Adding the Vaadin library
        • Creating the application
        • Adding the servlet mapping
          • Declaring the servlet class
          • Declaring the Vaadin's entry point
          • Declaring the servlet mapping
      • Summary
      • Chapter 3: Hello Vaadin!
        • Understanding Vaadin
          • Vaadin's philosophy
          • Vaadin's architecture
            • Client server communication
            • The client part
            • The server part
            • Terminal and adapter
            • Client server synchronization
        • Deploying a Vaadin application
          • Inside the IDE
            • Creating an IDE-managed server
            • Adding the application
            • Launching the server
          • Outside the IDE
            • Creating the WAR
            • Launching the server
        • Using Vaadin applications
          • Browsing Vaadin
          • Out-of-the-box helpers
            • The debug mode
            • Restart the application, not the server
        • Behind the surface
          • Stream redirection to Vaadin servlet
          • Vaadin request handling
          • What does an application do?
            • Application responsibilities
            • Application configuration
            • Application and session
          • Scratching the surface
            • The source code
            • The generated code
            • Things of interest
        • Summary
        • Chapter 4: Components and Layouts
          • Thinking in components
            • Terminology
            • Component class design
              • Component
              • MethodEventSource
              • Abstract component
            • Windows
              • ComponentContainer
              • Panel
              • Window
              • Subwindow
            • Labels
              • Label class hierarchy
              • Property
              • Label
            • Text inputs
              • Validation
              • Change buffer
              • Input
          • Laying out the components
            • Size
            • Layouts
              • About layouts
              • Layout and abstract layout
              • Layout types
              • Choosing the right layout
              • Split panels
          • Bringing it all together
            • Introducing Twaattin
              • The Twaattin design
              • The login window
              • The main window
            • Let's code!
              • Project setup
              • Project sources
          • Summary
          • Chapter 5: Event listener model
            • Event-driven model
              • The observer pattern
                • Enhancements to the pattern
              • Events in Java EE
                • UI events
            • Event model in Vaadin
              • Standard event implementation
                • Event class hierarchy
                • Listener interfaces
                • Managing listeners
              • Alternative event implementation
                • Method event source details
                • Listener methods
                • Abstract component and event router
              • Expanding our view
                • Button
              • Events outside UI
                • User changed event
              • Architectural considerations
                • Anonymous inner classes as listeners
                • Widgets as listeners
                • Presenters as listeners
                • Services as listeners
                • Conclusion on architecture
              • Twaattin is back
                • Project sources
                • Additional features
            • Summary
            • Chapter 6: Containers and Related Widgets
              • Data binding
                • Data binding properties
                  • Renderer and editor
                  • Buffering
                  • Data binding
              • Data in Vaadin
                • Entity abstraction
                  • Property
                  • Item
                  • Container
                • Containers and the GUI
                  • Container data source
                  • Container widgets
                  • Tables
                  • Trees
              • Refining Twaattin
                • Requisites
                • Adaptations
                • Sources
                  • The login window
                  • The Twaattin application
                  • The timeline window
                  • The name column generator
                  • The date column generator
              • Summary
              • Chapter 7: Advanced Features
                • Core features
                  • Accessing with the request-response model
                    • The brute force approach
                    • The integrated approach
                  • Bookmarks
                    • URL fragment
                    • URI fragment utility
                  • Embedding Vaadin
                    • Basic embedding
                    • Nominal embedding
                  • Custom error handling
                    • Design
                    • Error listener example
                  • Lifecycles
                    • Application lifecycle
                • Third-party additional features
                  • Vaadin add-ons
                    • Add-ons directory
                    • Noteworthy add-ons
                • Twaattin improves!
                  • Twaattin application
                  • Timeline window
                  • New item handler
              • Summary
                • Chapter 8: Creating Custom Components
                  • Widget composition
                    • Manual composition
                    • Strategy for custom components
                    • Graphic composition
                      • Visual editor setup
                      • Visual editor use
                      • Limitations
                  • GWT widget wrapping
                    • Vaadin GWT architecture
                      • Client side
                      • Server side
                      • Server client communication
                      • Client server communication
                  • Componentized Twaattin
                    • Designing the component
                    • Updating Twaattin's code
                      • Tweet component
                      • Tweet label
                      • When label
                      • Timeline window
                      • Final touch
                  • Summary
                  • Chapter 9: Integration with Third-party Products
                    • Spring
                      • Inversion of Control and Dependency Injection
                        • Inversion of Control
                        • Dependency Injection
                      • Spring use-cases
                      • Prerequisites
                        • Downloading Spring
                        • IDE enhancements
                      • Design
                        • Bean factory and application context
                        • Vaadin application and servlet
                        • Requirements and specifications
                      • Code
                        • Servlet code
                        • Spring configuration
                      • Additional thoughts
                    • Java EE 6
                      • Introduction
                        • Profiles
                        • Tomcat and the web profile
                      • Prerequisites
                        • Glassfish 3.1
                      • Code
                        • Servlet
                        • Application
                        • Window
                    • Hibernate
                      • Hibernate mappings
                        • Seeing is believing
                      • Hibernate container
                        • Container architecture
                        • Managing transactions
                        • At last, the window
                      • Putting it all together
                        • Hibernate
                        • SLF4J
                        • HbnContainer
                      • Final notes
                        • Serialization exception
                        • Optimizations
                        • Rollback management
                    • Java Persistence API
                    • Summary
                    • Chapter 10: Beyond Application Servers
                      • Build tools
                        • Available tools
                          • Apache Ant
                          • Apache Maven
                          • Fragmentation
                          • Final choice
                        • Tooling
                        • Maven in Vaadin projects
                          • Mavenize a Vaadin project
                          • Vaadin support for Maven projects
                        • Mavenizing Twaattin
                          • Preparing the migration
                          • Enabling dependency management
                          • Finishing touches
                          • Final POM
                      • Portals
                        • Portal, container, and portlet
                        • Choosing a platform
                          • Liferay
                          • GateIn
                        • Tooling
                        • A simple portlet
                          • Creating a project
                          • Portlet project differences
                          • Using the portlet in GateIn
                        • Configuring GateIn for Vaadin
                          • Themes and widgetsets
                        • Advanced integration
                          • Restart and debug
                          • Handling portlet specifics
                        • Portlet development strategies
                          • Keep our portlet servlet-compatible
                          • Portal debug mode
                          • Updating a deployed portlet
                        • Integrating Twaattin
                          • Portlet deployment descriptor
                          • Web deployment descriptor
                          • Maven changes
                      • OSGi
                        • Choosing a platform
                          • Glassfish
                        • Tooling
                        • Vaadin OSGi use-cases
                          • Vaadin bundling
                          • Modularization
                        • Hello OSGi
                          • Making a bundle
                          • Export, deploy, run
                          • Correcting errors
                        • Integrating Twaattin
                          • Bundle plugin
                          • Multiplatform build
                          • Build and deploy
                      • Cloud
                        • Cloud offering levels
                        • State of the market
                        • Tooling
                        • Hello cloud
                          • Registration
                          • Cloud setup
                          • Application deployment
                          • Alternative deployment
                        • Integrating Twaattin
                          • Creating the datasource
                          • Using the datasource
                          • Finishing touches
                      • Summary

                      Nicolas Fränkel

                      Nicolas Fränkel operates as a successful Java/Java EE architect with more than 10 years' experience in consulting for different clients. Based in France, he also practices (or has practiced) as a WebSphere Application Server administrator, a certified Valtech trainer, and a part-time lecturer in different French universities, so as to broaden his understanding of software craftsmanship. His interests in IT are diversified, ranging from Rich Client Application, to Quality Processes through open source software and build automation. When not tinkering with new products or writing blog posts, he may be found practicing sports: squash, kickboxing, and skiing at the moment. Other leisure activities include reading novels, motorcycles, photography, and drawing, not necessarily in that order.
                      Sorry, we don't have any reviews for this title yet.

                      Code Downloads

                      Download the code and support files for this book.

                      Submit Errata

                      Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.


                      - 1 submitted: last submission 13 Sep 2013

                      Errata type: Code | Page numbers: 92

                      Label label = new LabelWelcomeLabel("WelcomeLabelWelcome to <i style='color:red' title='Vaadin rules!'>Vaadin", Label.CONTENT_XHTML);

                      Should be

                      Label label = new Label("Welcome to <i style='color:red' title='Vaadin rules!'>Vaadin", Label.CONTENT_XHTML);


                      Errata type: Typo | Page numbers: 103

                      In the table, the third unit millimeter. In the Description section, 1000mm = 1 cm.

                      It should be:

                      10mm = 1 cm


                      Errata type: Typo | Page numbers: 18

                      Diagram mentions point 1 arrow as point 7 arrow, (user to JNLP file)    Step 7 is non-existent, 7 should have been 1


                      Errata type: Typo | Page numbers: 341

                      code reads ".. implements PortletListene"

                      Should be:

                      "...  implements PortletListener"


                      Errata type: code | Page numbers: 141




                      should be 

                      addListener((UserChangeListener) timelineWindow);






                      Errata type: Technical | Page numbers: 19


                      "It isolates developers as much as possible from the request/response model in order to think in screens and not in windows." 


                      Should be: 


                      "It isolates developers as much as possible from the request/response model in order to think in *windows* and not in *screens*."





                      Errata type: code | Page numbers: 344


                      Should be :


                      Sample chapters

                      You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

                      Frequently bought together

                      Learning Vaadin +    BizTalk Server 2010 Cookbook =
                      50% Off
                      the second eBook
                      Price for both: £29.05

                      Buy both these recommended eBooks together and get 50% off the cheapest eBook.

                      What you will learn from this book

                      • Understand the limitations of the thin-client approach and the rationale behind Vaadin
                      • Develop web applications with your favorite IDE
                      • Grasp key concepts: components, layouts, events, containers and bindings
                      • Easily create full-fledged web applications
                      • Use the Vaadin directory to add exciting features on top of Vaadin
                      • Extend Vaadin to create and share new components
                      • Integrate Vaadin on top of Spring, CDI, and Hibernate
                      • Deploy Vaadin on the JBoss Portal and Cloud Foundry

                      In Detail

                      Vaadin is a new Java web framework for making applications look great and perform well, making your users happy. Vaadin promises to make your user interfaces attractive and usable while easing your development efforts and boosting your productivity. With this book in hand you will be able to utilize the full range of development and deployment features offered by Vaadin while thoroughly understanding the concepts.

                      Learning Vaadin is a practical step-by-step tutorial to understanding, using, and mastering the art of RIA development with Vaadin. You will learn about the fundamental concepts that are the cornerstones of the framework, at the same time making progress on building your own web application. The book will also show you how to integrate Vaadin with other popular frameworks and how to run it on top of internal as well as externalized infrastructures.

                      This book will show you how to become a professional Vaadin developer by giving you a concrete foundation through diagrams, practical examples and ready-to-use source code. It will enable you to grasp all the notions behind Vaadin one step at a time: components, layouts, events, containers, and bindings. You will learn to build first-class web applications using best-of-breed technologies. You will find detailed information on how to integrate Vaadin's presentation layer on top of other widespread technologies, such as Spring, CDI, and Hibernate. Finally, the book will show you how to deploy on different infrastructures like JBoss Portal and Cloud Foundry.

                      An authoritative and complete step-by-step tutorial on how to create top-notch web applications with the RIA Vaadin framework


                      This book begins with a tutorial on Vaadin 7, followed by a process of planning, analyzing, building, and deploying a fully functional RIA while covering troubleshooting details along the way, making it an invaluable resource for answers to all your Vaadin questions.

                      Who this book is for

                      If you are a Java developer with some experience in Java web development and want to enter the world of Rich Internet Applications this technology and book are ideal for you. Learning Vaadin will be perfect as your next step towards building eye-candy dynamic web applications on a Java-based platform.

                      Code Download and Errata
                      Packt Anytime, Anywhere
                      Register Books
                      Print Upgrades
                      eBook Downloads
                      Video Support
                      Contact Us
                      Awards Voting Nominations Previous Winners
                      Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
                      Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software