Learning Vaadin 7: Second Edition

Learning Vaadin 7: Second Edition
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
  • Construct top-notch web applications with one of the best frameworks based on Java
  • Learn about components, events, layouts, containers, and bindings
  • Create outstanding new components by yourself

Book Details

Language : English
Paperback : 436 pages [ 235mm x 191mm ]
Release Date : September 2013
ISBN : 1782169776
ISBN 13 : 9781782169772
Author(s) : Nicolas Fränkel
Topics and Technologies : All Books, Application Development, Java, 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 Components
Chapter 7: Core Advanced Features
Chapter 8: Featured Add-ons
Chapter 9: Creating and Extending Components and Widgets
Chapter 10: Enterprise Integration
  • Chapter 1: Vaadin and its Context
    • Rich applications
      • Application tiers
        • Tier 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 integration
        • Integrated frameworks
        • Integration platforms
      • Using Vaadin in the real world
        • Concerns about using a new technology
    • 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
        • When Eclipse is already installed
          • Checking if WTP is present
          • Adding WTP to Eclipse
      • Vaadin in IntelliJ IDEA
        • Setting up IntelliJ
        • Adding the Vaadin 7 plugin
        • Creating our first IntelliJ IDEA Vaadin project
          • Adjusting the result
          • Adding framework support
          • Deploying the application automatically
        • Testing the application
        • Final touches
          • Changing the Vaadin version
          • Context-root
          • Servlet mapping
      • Vaadin and other IDEs
        • Adding Vaadin libraries
        • Creating the application
        • Adding the servlet mapping
          • Declaring the servlet class
          • Declaring 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
            • 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 a Vaadin servlet
          • Vaadin request handling
          • What does a UI do?
            • UI features
            • UI configuration
            • UI 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 client connector
              • Abstract component
            • UIs
              • HasComponents
              • Single component container
              • UI
              • Panel
            • Windows
              • Window structure
              • Customizing windows
            • Labels
              • Label class hierarchy
              • Property
              • Label
            • Text inputs
              • Conversion
              • Validation
              • Change buffer
              • Input
            • More Vaadin goodness
              • Page
              • Third-party content
              • User messages
          • Laying out the components
            • Size
            • Layouts
              • About layouts
              • Component container
              • Layout and abstract layout
              • Layout types
              • Choosing the right layout
            • Split panels
          • Bringing it all together
            • Introducing Twaattin
              • The Twaattin design
              • The login screen
              • The main screen
            • 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
                • Method event source details
                • Abstract component and event router
              • Expanding our view
                • Button
              • Events outside UI
                • User change event
              • Architectural considerations
                • Anonymous inner classes as listeners
                • Components as listeners
                • Presenters as listeners
                • Services as listeners
                • Conclusion on architecture
              • Twaattin is back
                • Project sources
                • Additional features
            • Summary
            • Chapter 6: Containers and Related Components
              • Data binding
                • Data binding properties
                  • Renderer and editor
                  • Buffering
                  • Data binding
              • Data in Vaadin
                • Entity abstraction
                  • Property
                  • Item
                  • Container
                • Containers and the GUI
                  • Container datasource
                  • Container components
                  • Tables
                  • Trees
              • Refining Twaattin
                • Prerequisites
                • Adaptations
                • Sources
                  • The login screen
                  • The login behavior
                  • The timeline screen
                  • The tweets refresh behavior
                  • Column generators
              • Summary
              • Chapter 7: Core Advanced Features
                • Accessing the JavaEE API
                  • Servlet request
                  • Servlet response
                  • Wrapped session
                • Navigation API
                  • URL fragment
                  • Views
                  • Navigator
                    • Initial view
                    • Error view
                    • Dynamic view providers
                  • Event model around the Navigation API
                  • Final word on the Navigator API
                • Embedding Vaadin
                  • Basic embedding
                  • Nominal embedding
                    • Page headers
                    • The div proper
                    • The bootstrap script
                    • UI initialization call
                • Real-world error handling
                  • The error messages
                  • Component error handling
                  • General error handling
                • SQL container
                  • Architecture
                  • Features
                  • Queries and connections
                  • Database compatibility
                  • Joins
                    • References
                    • Free form queries
                  • Related add-ons
                • Server push
                  • Push innards
                  • Installation
                  • How-to
                  • Example
                • Twaattin improves!
                  • Ivy dependencies
                  • Twaattin UI
                  • Tweet refresher behavior
                  • Twitter service
                • Summary
                • Chapter 8: Featured Add-ons
                  • Vaadin add-ons directory
                    • Add-ons search
                    • Typology
                    • Stability
                    • Add-ons presentation
                      • Summarized view
                      • Detailed view
                  • Noteworthy add-ons
                    • Button group
                      • Prerequisites
                      • Core concepts
                      • How-to
                      • Conclusion
                    • Clara
                      • Prerequisites
                      • How-to
                      • Limitations
                      • Conclusion
                    • JPA Container
                      • Concepts
                      • Prerequisites
                      • How-to
                      • Conclusion
                    • CDI Utils
                      • Core concepts
                      • Prerequisites
                      • How-to
                      • Conclusion
                  • Summary
                  • Chapter 9: Creating and Extending Components and Widgets
                    • Component composition
                      • Manual composition
                      • Designing custom components
                      • Graphic composition
                        • Visual editor setup
                        • Visual Designer use
                        • Limitations
                    • Client-side extensions
                      • Connector architecture
                      • How-to
                    • Shared state
                      • How-to
                    • Server RPC
                      • Server RPC architecture
                      • How-to
                    • GWT widget wrapping
                      • Vaadin GWT architecture
                      • How-to server-side
                      • How-to client-side
                        • Widget styling
                      • Example
                        • Prerequisites
                        • Server component
                        • Client classes
                    • JavaScript wrapping
                      • How-to
                      • Example
                        • Prerequisites
                        • Core
                    • Componentized Twaattin
                      • Designing the component
                      • Updating Twaattin's code
                        • Data Transfer Object
                        • Status component
                        • Status converter
                        • Timeline screen
                    • Summary
                    • Chapter 10: Enterprise Integration
                      • Build tools
                        • Available tools
                          • Apache Ant
                          • Apache Maven
                          • Fragmentation
                          • Final choice
                        • Tooling
                        • Maven in Vaadin projects
                          • Mavenize Vaadin projects
                          • 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
                      • OSGi
                        • Choosing a platform
                          • Glassfish
                        • Tooling
                        • Vaadin OSGi use cases
                          • Vaadin bundling
                          • Modularization
                        • Hello OSGi
                          • Making a bundle
                          • Export, deploy, and run
                          • Correcting errors
                        • Integrating Twaattin
                          • Bundle plugin
                          • Multiplatform build
                      • Cloud
                        • Cloud offering levels
                        • State of the market
                        • Hello cloud
                          • Registration
                          • Cloud setup
                          • Application deployment
                      • 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.

                      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 19 May 2014

                      Errata Type: Others | Page Number: 94

                      EmailValidatoris used for validating e-mails

                      should be replaced by

                      EmailValidatoris used for validating e-mails addresses

                      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 7: Second Edition +    (MCTS): Microsoft BizTalk Server 2010 (70-595) Certification Guide =
                      50% Off
                      the second eBook
                      Price for both: $45.60

                      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 Hibernate, CDI, and JPA
                      • Deploy Vaadin on JBoss GateIn and Jelastic

                      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 as a developer. Vaadin is a web framework that addresses common issues such as poor choice of controls, heterogeneity of technology stacks, page-flow paradigm, and browser compatibility.

                      This book a practical guide that will help you in creating top-notch web applications with one of the best frameworks based on Java. You will learn about the fundamental concepts that are the cornerstones of the framework. Also, this book will show you how to integrate Vaadin with popular frameworks and how to run it on top of internal as well as externalized infrastructures.

                      Learning Vaadin: Second Edition 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 as 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.

                      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.


                      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 development either on JSP/Servlet or on Swing, and want to enter the world of rich Internet applications, then this technology and book is ideal for you. Learning Vaadin will be perfect as your next step towards building eye-catching, 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