Better, Faster, Lighter Java

(ebook) (audiobook) (audiobook)

Autorzy:: Bruce Tate, Justin Gehtland

Promocja Przejdź

Better, Faster, Lighter Java Bruce Tate, Justin Gehtland - okladka książki

Better, Faster, Lighter Java Bruce Tate, Justin Gehtland - audiobook MP3

Better, Faster, Lighter Java Bruce Tate, Justin Gehtland - audiobook CD

Wydawnictwo:: O'Reilly Media (Z chęcią przeczytam książkę w języku polskim)
Ocena:: Bądź pierwszym, który oceni tę książkę
Stron:: 266
Dostępne formaty:: ePub

Mobi

Ebook (101,15 zł najniższa cena z 30 dni)

~~119,00 zł~~ (-15%)
101,15 zł

Dodaj do koszyka lub Kup na prezent Kup 1-kliknięciem

(101,15 zł najniższa cena z 30 dni)

Przenieś na półkę

Do przechowalni

Sometimes the simplest answer is the best. Many Enterprise Java developers, accustomed to dealing with Java's spiraling complexity, have fallen into the habit of choosing overly complicated solutions to problems when simpler options are available. Building server applications with "heavyweight" Java-based architectures, such as WebLogic, JBoss, and WebSphere, can be costly and cumbersome. When you've reached the point where you spend more time writing code to support your chosen framework than to solve your actual problems, it's time to think in terms of simplicity.In Better, Faster, Lighter Java, authors Bruce Tate and Justin Gehtland argue that the old heavyweight architectures are unwieldy, complicated, and contribute to slow and buggy application code. As an alternative means for building better applications, the authors present two "lightweight" open source architectures: Hibernate--a persistence framework that does its job with a minimal API and gets out of the way, and Spring--a container that's not invasive, heavy or complicated.Hibernate and Spring are designed to be fairly simple to learn and use, and place reasonable demands on system resources. Better, Faster, Lighter Java shows you how they can help you create enterprise applications that are easier to maintain, write, and debug, and are ultimately much faster.Written for intermediate to advanced Java developers, Better, Faster, Lighter Java, offers fresh ideas--often unorthodox--to help you rethink the way you work, and techniques and principles you'll use to build simpler applications. You'll learn to spend more time on what's important. When you're finished with this book, you'll find that your Java is better, faster, and lighter than ever before.

Wybrane bestsellery

Bruce Tate, Justin Gehtland - pozostałe książki

Ebooka "Better, Faster, Lighter Java" przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook, Onyx Booxs i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Audiobooka "Better, Faster, Lighter Java" posłuchasz:

w aplikacji Ebookpoint na Android, iOS, HarmonyOs
na systemach Windows, MacOS i innych

na dowolonych urządzeniach
i aplikacjach obsługujących format MP3
(pliki spakowane w ZIP)

Masz pytania? Zajrzyj do zakładki Pomoc »

Kurs Video "Better, Faster, Lighter Java" zobaczysz:

Oceny i opinie klientów: Better, Faster, Lighter Java Bruce Tate, Justin Gehtland (0) Weryfikacja opinii następuję na podstawie historii zamówień na koncie Użytkownika umieszczającego opinię. Użytkownik mógł otrzymać punkty za opublikowanie opinii uprawniające do uzyskania rabatu w ramach Programu Punktowego.

Szczegóły książki

ISBN Ebooka:: 978-05-965-5279-4, 9780596552794
Data wydania ebooka :: 2004-05-28 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@helion.pl.
Język publikacji:: angielski
Rozmiar pliku ePub:: 1MB
Rozmiar pliku Mobi:: 2.8MB

Zgłoś erratę
Kategorie:
Programowanie » Java - Programowanie

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