Better, Faster, Lighter Java Bruce Tate, Justin Gehtland

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

• Better, Faster, Lighter Java
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • A Note Regarding Supplemental Files
  • Preface
    • Who Should Read This Book?
    • Organization of This Book
    • Conventions Used in This Book
    • Comments and Questions
    • Acknowledgments
      • Bruce A. Tate
      • Justin Gehtland
  • 1. The Inevitable Bloat
    • 1.1. Bloat Drivers
      • 1.1.1. Enterprise Mega-Frameworks
      • 1.1.2. Progress
      • 1.1.3. Economic Forces
      • 1.1.4. Misuse
    • 1.2. Options
    • 1.3. Five Principles for Fighting the Bloat
      • 1.3.1. 1. Keep It Simple
      • 1.3.2. 2. Do One Thing, and Do It Well
      • 1.3.3. 3. Strive for Transparency
      • 1.3.4. 4. Allow for Extension
      • 1.3.5. 5. You Are What You Eat
    • 1.4. Summary
  • 2. Keep It Simple
    • 2.1. The Value of Simplicity
      • 2.1.1. Choosing the Foundations
        • 2.1.1.1. Technology you buy
        • 2.1.1.2. Design patterns
        • 2.1.1.3. Your own code
    • 2.2. Process and Simplicity
      • 2.2.1. The Best of Agile
      • 2.2.2. Pick Your Battles
        • 2.2.2.1. Algorithms
        • 2.2.2.2. Architecture
        • 2.2.2.3. Performance
        • 2.2.2.4. Design patterns
    • 2.3. Your Safety Net
      • 2.3.1. Getting Started with JUnit
        • 2.3.1.1. Organizing tests
        • 2.3.1.2. Initialization and clean up
        • 2.3.1.3. Assertions
        • 2.3.1.4. Exceptions and intentional failure
      • 2.3.2. Automating Test Cases with Ant
      • 2.3.3. Refactoring for Testability
        • 2.3.3.1. Reuse and testability
        • 2.3.3.2. Coupling
    • 2.4. Summary
  • 3. Do One Thing, and Do It Well
    • 3.1. Understanding the Problem
      • 3.1.1. Gathering Requirements
      • 3.1.2. Controlling Scope Creep
        • 3.1.2.1. Managing good change
        • 3.1.2.2. Curtailing disruptive change
    • 3.2. Distilling the Problem
      • 3.2.1. Collecting Requirements
      • 3.2.2. Whittling Away the Noise
      • 3.2.3. Refining Your Design
    • 3.3. Layering Your Architecture
      • 3.3.1. The Basics of Layering
      • 3.3.2. Interfaces Between Layers
        • 3.3.2.1. A word about good interfaces
      • 3.3.3. Common Layers
        • 3.3.3.1. Business domain models
        • 3.3.3.2. Data access
        • 3.3.3.3. Communication
        • 3.3.3.4. Façades
        • 3.3.3.5. User interfaces
    • 3.4. Refactoring to Reduce Coupling
      • 3.4.1. Microcoupling
        • 3.4.1.1. Direct access
        • 3.4.1.2. Inheritance
        • 3.4.1.3. Transitive coupling
        • 3.4.1.4. The role of transparency
        • 3.4.1.5. Testing and coupling
      • 3.4.2. Macrocoupling
        • 3.4.2.1. Communication model
        • 3.4.2.2. Façades
        • 3.4.2.3. Shared data
        • 3.4.2.4. Databases
        • 3.4.2.5. Configuration
    • 3.5. Summary
  • 4. Strive for Transparency
    • 4.1. Benefits of Transparency
    • 4.2. Whos in Control?
      • 4.2.1. Active Domain Models
      • 4.2.2. The Power of Passive Models
    • 4.3. Alternatives to Transparency
      • 4.3.1. Techniques That Compromise Transparency
        • 4.3.1.1. Invading the model
        • 4.3.1.2. Subclassing
        • 4.3.1.3. Building a hardwired service
        • 4.3.1.4. Code metadata
        • 4.3.1.5. Imposing an invasive programming paradigm
      • 4.3.2. Moving Forward
    • 4.4. Reflection
      • 4.4.1. The Reflection API
      • 4.4.2. Accessing a Class
      • 4.4.3. Accessing Fields
      • 4.4.4. Accessing Methods and Constructors
        • 4.4.4.1. Invoking a method
    • 4.5. Injecting Code
      • 4.5.1. Byte code enhancement frameworks
    • 4.6. Generating Code
      • 4.6.1. How Code Generation Works
      • 4.6.2. Code Generation and Transparency
    • 4.7. Advanced Topics
      • 4.7.1. Coarse- and Fine-Grained Services
      • 4.7.2. A New Programming Paradigm
    • 4.8. Summary
  • 5. You Are What You Eat
    • 5.1. Golden Hammers
      • 5.1.1. The Allure
        • 5.1.1.1. The sales process
      • 5.1.2. Some Examples
        • 5.1.2.1. Java
        • 5.1.2.2. J2EE
        • 5.1.2.3. Distribution
        • 5.1.2.4. EJB
        • 5.1.2.5. XML
        • 5.1.2.6. Persistence frameworks
        • 5.1.2.7. Web services
    • 5.2. Understanding the Big Picture
      • 5.2.1. Modern Cathedrals
        • 5.2.1.1. Aligning your goals
        • 5.2.1.2. A hypothetical example
        • 5.2.1.3. It's all business
        • 5.2.1.4. Passion and software
    • 5.3. Considering Technical Requirements
      • 5.3.1. Outer Questions
      • 5.3.2. Inner Questions
        • 5.3.2.1. Prototypes
        • 5.3.2.2. Documentation
    • 5.4. Summary
  • 6. Allow for Extension
    • 6.1. The Basics of Extension
      • 6.1.1. Inheritance and Interfaces
      • 6.1.2. Planned Extension
        • 6.1.2.1. The Inventor's Paradox
      • 6.1.3. Unplanned Extension
    • 6.2. Tools for Extension
      • 6.2.1. Standards
      • 6.2.2. Configuration
        • 6.2.2.1. Client-side configuration with Java Preferences
        • 6.2.2.2. Server-side configuration with Apache Digester
      • 6.2.3. Class Loading
        • 6.2.3.1. Loading a class with Class.forName
        • 6.2.3.2. Invoking methods
        • 6.2.3.3. Which class loader?
      • 6.2.4. What Should You Configure?
        • 6.2.4.1. Fundamental concepts
        • 6.2.4.2. External touch points
        • 6.2.4.3. External resources
    • 6.3. Plug-In Models
      • 6.3.1. Plug-Ins at a Lower Level
        • 6.3.1.1. Service locators
        • 6.3.1.2. Inversion of control
      • 6.3.2. The Role of Interfaces
    • 6.4. Who Is the Customer?
    • 6.5. Summary
  • 7. Hibernate
    • 7.1. The Lie
    • 7.2. What Is Hibernate?
      • 7.2.1. Simple Example
      • 7.2.2. Writing the Object Model
      • 7.2.3. Building the Schema
      • 7.2.4. Configuring the Mapping
        • 7.2.4.1. Identifiers
        • 7.2.4.2. Relationships
        • 7.2.4.3. Types
    • 7.3. Using Your Persistent Model
      • 7.3.1. Configuring Hibernate
      • 7.3.2. Using Your Model
        • 7.3.2.1. Loading data
        • 7.3.2.2. Updating the database
    • 7.4. Evaluating Hibernate
      • 7.4.1. Keep It Simple
      • 7.4.2. Do One Thing, and Do It Well
      • 7.4.3. Strive for Transparency
      • 7.4.4. Allow for Extension
      • 7.4.5. You Are What You Eat
        • 7.4.5.1. Going against the grain
      • 7.4.6. The Down Side
        • 7.4.6.1. Alternatives
    • 7.5. Summary
  • 8. Spring
    • 8.1. What Is Spring?
      • 8.1.1. Inversion of Control
    • 8.2. Pet Store: A Counter-Example
      • 8.2.1. The Configuration
    • 8.3. The Domain Model
    • 8.4. Adding Persistence
      • 8.4.1. The Model
      • 8.4.2. The Mapping
      • 8.4.3. The DAO Interface
      • 8.4.4. The DAO Implementation
      • 8.4.5. Using the Model Through a Façade
      • 8.4.6. Configuration for the DAO Layer
      • 8.4.7. The Benefits
    • 8.5. Presentation
      • 8.5.1. Configuration
      • 8.5.2. Controllers
      • 8.5.3. Forms
      • 8.5.4. Validation
    • 8.6. Summary
  • 9. Simple Spider
    • 9.1. What Is the Spider?
    • 9.2. Examining the Requirements
      • 9.2.1. Breaking It Down
      • 9.2.2. Refining the Requirements
    • 9.3. Planning for Development
    • 9.4. The Design
    • 9.5. The Configuration Service
      • 9.5.1. Principles in Action
    • 9.6. The Crawler/Indexer Service
      • 9.6.1. Principles in Action
    • 9.7. The Search Service
      • 9.7.1. Principles in Action
    • 9.8. The Console Interface
      • 9.8.1. Principles in Action
    • 9.9. The Web Service Interface
      • 9.9.1. Principles in Action
    • 9.10. Extending the Spider
  • 10. Extending jPetStore
    • 10.1. A Brief Look at the Existing Search Feature
      • 10.1.1. Deciding on the Spider
      • 10.1.2. Extending jPetStore
    • 10.2. Replacing the Controller
      • 10.2.1. Rewrite or Replace?
      • 10.2.2. Implementing the Interface
      • 10.2.3. Registering Our New Class with jPetStore
        • 10.2.3.1. Principles in action
    • 10.3. The User Interface (JSP)
      • 10.3.1. Changes to the Original Code to Fit the JSP
      • 10.3.2. What if We Don't Have the Spider Source?
      • 10.3.3. Principles in Action
    • 10.4. Setting Up the Indexer
      • 10.4.1. Embed in jPetStore or Launch Externally?
      • 10.4.2. Using the System Scheduler
      • 10.4.3. Smell the Roses
      • 10.4.4. Principles in Action
    • 10.5. Making Use of the Configuration Service
      • 10.5.1. Principles in Action
    • 10.6. Adding Hibernate
      • 10.6.1. Existing Architecture
      • 10.6.2. Hibernate Mappings for Existing Domain Objects
      • 10.6.3. Hibernate DAOs
      • 10.6.4. Changing the Application Configuration
      • 10.6.5. Spring's Built-In Hibernate Support
      • 10.6.6. Principles in Action
    • 10.7. Summary
  • 11. Where Do We Go from Here?
    • 11.1. Technology
      • 11.1.1. Less Is More
      • 11.1.2. Open Source
      • 11.1.3. Aspect-Oriented Programming (AOP)
      • 11.1.4. Persistence
      • 11.1.5. Containers
    • 11.2. Process
    • 11.3. Challenges
    • 11.4. Conclusion
  • 12. Bibliography
    • 12.1. Books
    • 12.2. Referenced Internet Sources
    • 12.3. Helpful Internet Sources
    • 12.4. Other References
  • About the Authors
  • Colophon
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje