Java EEÊÙ¶¯²ñ
MenuBar
ÊÔ½¸
źÉÕ
¿·µ¬
ºÇ½ª¹¹¿·
°ìÍ÷
ñ¸ì¸¡º÷
�Ļ�Ͽ
/
��05��
-- ¿÷·Á¤È¤¹¤ë¥Ú¡¼¥¸ --
2008-04-19¤Î¥¹¥¤¡¼¥Ä
2008-05-17¤Î¥¹¥¤¡¼¥Ä
ActiveRecord
BSA
BSA/A Pattern Language for Strategic Product Management
BSA/Alternative Thoughts on Software Architecture
BSA/Architectural Care and Feeding
BSA/Architectural Evolution and Maturation Features versus Capabilities
BSA/Augmenting the Product Development Process
BSA/Back Doors
BSA/Beware the Promises You Make
BSA/Brand Element Customizations
BSA/Brand Elements
BSA/Brand and Brand Elements
BSA/Business Ramifications
BSA/Business and License Model Symbiosis
BSA/Changing Brand Elements
BSA/Chapter 1 Chapter Summary
BSA/Chapter 10 Chapter Summary
BSA/Chapter 11 Chapter Summary
BSA/Chapter 12 Chapter Summary
BSA/Chapter 13 Chapter Summary
BSA/Chapter 14 Chapter Summary
BSA/Chapter 15 Chapter Summary
BSA/Chapter 16 Chapter Summary
BSA/Chapter 2 Chapter Summary
BSA/Chapter 3 Chapter Summary
BSA/Chapter 4 Chapter Summary
BSA/Chapter 5 Chapter Summary
BSA/Chapter 6 Chapter Summary
BSA/Chapter 7 Chapter Summary
BSA/Chapter 8 Chapter Summary
BSA/Chapter 9 Chapter Summary
BSA/Choosing a Software Deployment Architecture
BSA/Common Software Business Models
BSA/Common Software Business Models/Hardware¡Á
BSA/Common Software Business Models/Metering
BSA/Common Software Business Models/Time-Based Access or Usage
BSA/Common Software Business Models/Transaction
BSA/Configuration
BSA/Context Diagrams and Target Products
BSA/Contracts - Where the Action Is
BSA/Corporate Influences on Deployment Architecture
BSA/Creating Architectural Understanding
BSA/Creating Layerd Business Architectures
BSA/Creating Portable Applications
BSA/Creating Results in the Short Run while Working in the Long Run
BSA/Creating an Architecture
BSA/Crucial Product Management Concepts
BSA/Customer Control
BSA/Customer Influences on Deployment Architectures
BSA/Defining Software Architecture
BSA/Deployment Architecture
BSA/Deployment Architectures and the Distribution of Work
BSA/Deployment Choice Influences on Software Architecture
BSA/Deployment Choices
BSA/Digital Identity Management
BSA/Early Forces in Solution Development
BSA/Enforcing Licensing Models
BSA/Enforcing Licensing Models/The Client
BSA/Establishing a Baseline
BSA/Feature Benefit Map
BSA/Finishing Touches
BSA/Generating Clarity
BSA/Harnessing Feedback
BSA/Honoring License Agreements
BSA/How to Install
BSA/I Want to Know What¡Çs Happening
BSA/Information Security
BSA/Installation
BSA/Installation and Architecture
BSA/Integration and Extension at the Business Logic Layers
BSA/Integration and Extension of Persistent Data
BSA/It Isn¡Çt Like That
BSA/License Fees
BSA/Licensing Economics
BSA/Licensing Risks Rewards
BSA/Like Installation, Only Worse
BSA/Log Format and Management
BSA/Logging Services
BSA/Logs
BSA/Making Upgrades Less Painful
BSA/Managing APIs Over Multiple Releases
BSA/Managing In-License Brands
BSA/Managing In-Licensed Technology
BSA/Market Events Market Rhythms
BSA/Market Map
BSA/Market Maturity Influences on the Business Model
BSA/Market Maturity and Upgrades
BSA/Mental Models, Metaphors, and Usability
BSA/Not Just the Facts
BSA/Open Source Licensing
BSA/Ouch! That Might Hurt
BSA/Patterns and Architecture
BSA/Postprocessing Log Data
BSA/Principles First, Second, and Third
BSA/Product Development Processes Creating Release 1.0
BSA/Product Development Processes Creating Release n.n.n
BSA/Projecting the Future
BSA/Release Identification
BSA/Release Management
BSA/Release Management Influences on Tarchitecture
BSA/Release Management Introduction
BSA/Rights Associated with Business Models
BSA/SKUs and Serial Numbers
BSA/Secret Algorithms or Secret Keys
BSA/Security
BSA/Security and Marketecture
BSA/Software Architecture
BSA/Software Security
BSA/Tarchitectural Influences on User Interface Design
BSA/Tarchitectural Support for the Business Model
BSA/Tarchitectural Support for the Business Model/Transaction
BSA/Technology In-Licensing
BSA/The Business Case for Portability
BSA/The Business Plan
BSA/The Future of Consumer Software
BSA/The Information Appliance
BSA/The Matrix of Pain
BSA/The Need for Speed/Performance and Tarchitectural Impact¡Á
BSA/The Need for Speed/¡ÁResponding to the User
BSA/The Out of Box Experience
BSA/The Tarchitecture Roadmap
BSA/The Team
BSA/Transaction Security
BSA/Upgrade
BSA/Usability
BSA/Usability Is about Money
BSA/Viruses, Hackers, and Pirates
BSA/What Is Product Management
BSA/When Business Models Collide, Negotiations Ensue
BSA/Who Is Responsible for What
BSA/Why Product Management Matters
BSA/Why Software Architecture Matters
BSA/Working in Unison
BSA/Yes, You Really Need This
BaseAction
BracketName
Chapter Two. Communication and the Use of Language
DDD
DDD/A Declarative Style of Design
DDD/A Design for Developers
DDD/A Final Look
DDD/AGGREGATE Boundaries
DDD/Abstract Core
DDD/Aggregates
DDD/An Escalation of Distillations
DDD/Analysis Patterns Are Knowledge to Draw On
DDD/Angles of Attack
DDD/Anticorruption Layer
DDD/Applying and Implementing SPECIFICATION
DDD/Assertions
DDD/Assessment First
DDD/Associations
DDD/Bounded Context
DDD/CONFORMIST
DDD/Chapter Eight. Breakthrough
DDD/Chapter Eleven. Applying Analysis Patterns
DDD/Chapter Fifteen. Distillation
DDD/Chapter Five. A Model Expressed in Software
DDD/Chapter Four. Isolating the Domain
DDD/Chapter Fourteen. Maintaining Model Integrity
DDD/Chapter Nine. Making Implicit Concepts Explicit
DDD/Chapter Seven. Using the Language An Extended Example
DDD/Chapter Seventeen. Bringing the Strategy Together
DDD/Chapter Six. The Life Cycle of a Domain Object
DDD/Chapter Sixteen. Large-Scale Structure
DDD/Chapter Ten. Supple Design
DDD/Chapter Thirteen. Refactoring Toward Deeper Insight
DDD/Chapter Twelve. Relating Design Patterns to the Model
DDD/Choosing Appropriate Layers
DDD/Choosing Refactoring Targets
DDD/Choosing Your Model Context Strategy
DDD/Closure of Operations
DDD/Cohesive Mechanisms
DDD/Combining Large-Scale Structures and BOUNDED CONTEXTS
DDD/Combining Large-Scale Structures and Distillation
DDD/Composite
DDD/Conceptual Contours
DDD/Contemplate Contradictions
DDD/Context Map
DDD/Continuous Integration
DDD/Continuous Learning
DDD/Core Domain
DDD/Crisis as Opportunity
DDD/Customer/Supplier Development Teams
DDD/Decision Support Responsibilities
DDD/Declarative Design
DDD/Deep Model-Supple Design
DDD/Deep Models
DDD/Deep Models Distill
DDD/Designing Associations in the Shipping Domain
DDD/Designing Objects for Relational Databases
DDD/Digging Out Concepts
DDD/Distinguishing ENTITIES and VALUE Objects
DDD/Documents and Diagrams
DDD/Domain Vision Statement
DDD/Entities (a.k.a. Reference Objects)
DDD/Epilogue
DDD/Epilogues
DDD/Evolving Order
DDD/Example A Working Prototype of the Warehouse Packer
DDD/Example Chemical Warehouse Packer
DDD/ExampleEarning Interest with Accounts
DDD/ExampleInsight into the Nightly Batch
DDD/Explanatory Models
DDD/Explicit Constraints
DDD/Exploration Teams
DDD/Factories
DDD/Focus on Basics
DDD/Foreword
DDD/GENERIC SUBDOMAINS
DDD/GLOSSARY
DDD/Hands-On Modelers
DDD/Highlighted Core
DDD/How Restrictive Should a Structure Be?
DDD/How to Model Less Obvious Kinds of Concepts
DDD/III-Deep Models
DDD/Ingredients of Effective Modeling
DDD/Initiation
DDD/Intention-Revealing Interfaces
DDD/Introducing a New Feature
DDD/Introducing the Cargo Shipping System
DDD/Isolating the Domain
DDD/KNOWLEDGE LEVEL
DDD/Knowledge Crunching
DDD/Knowledge-Rich Design
DDD/Layered Architecture
DDD/Letting the Bones Show
DDD/Listen to Language
DDD/Looking Forward
DDD/MODULES in the Shipping Model
DDD/Model-Driven Design
DDD/Modeling Out Loud
DDD/Modeling Paradigms
DDD/Modeling Paradigms and Tool Support
DDD/Modules (a.k.a. Packages)
DDD/Object Creation
DDD/One Team, One Language
DDD/Open Host Service
DDD/Opportunities
DDD/Other Kinds of Isolation
DDD/Part I Putting the Domain Model to Work
DDD/Part II The Building Blocks of a Model-Driven Design
DDD/Part III Refactoring Toward Deeper Insight
DDD/Part IV Strategic Design
DDD/Pattern Name
DDD/Pause for Refactoring
DDD/Pluggable Component Framework
DDD/Preface
DDD/Prior Art
DDD/Processes as Domain Objects
DDD/Published Language
DDD/Read the Book
DDD/Refactoring Toward a Fitting Structure
DDD/References
DDD/Relationships Between BOUNDED CONTEXTS
DDD/Repositories
DDD/Responsibility Layers
DDD/SERVICES
DDD/SPECIFICATION
DDD/SYSTEM METAPHOR
DDD/Scrutinize Awkwardness
DDD/Segregated Core
DDD/Selecting REPOSITORIES
DDD/Separate Ways
DDD/Shared Kernel
DDD/Side -Effect-Free Functions
DDD/Six Essentials for Strategic Design Decision Making
DDD/Standalone Classes
DDD/Story of a Breakthrough
DDD/Strategy (A.K.A.Policy)
DDD/The Discovery Process
DDD/The Smart UI Anti-Pattern
DDD/The Use of Patterns in This Book
DDD/Timing
DDD/Transformations
DDD/Try, Try Again
DDD/Ubiquitous Language
DDD/Unifying an Elephant
DDD/Value Objects
DDD/Walking Through Scenarios
DDD/Who Sets the Strategy?
DDD/Why Not FLYWEIGHT?
DDD¥Æ¥ó¥×¥ì¡¼¥È
DSL
DSL/A short dip into language theory
DSL/Adaptive Model
DSL/Alternative Computational Models
DSL/Alternative Tokenization
DSL/Annotation
DSL/Annotations
DSL/Architecture of DSL Processing
DSL/Assorted Tactics
DSL/BNF
DSL/Choosing What to Generate
DSL/Class Symbol Table
DSL/Closure
DSL/Closures
DSL/Code Generation
DSL/Communication with Domain Experts
DSL/Composing DSLs
DSL/Construction Builder
DSL/Context Variable
DSL/Cost of Building
DSL/DSL Lifecycle
DSL/Decision Table
DSL/Defining Domain Specific Languages
DSL/Delimiter Directed Translation
DSL/Dependency Network
DSL/Dynamic Reception
DSL/Elements of language workbenches
DSL/Embedded Translation
DSL/Embedment Helper
DSL/Evolving into Generality
DSL/Expression Builder
DSL/External DSL Miscellany
DSL/Fluent and command-query APIs
DSL/Foreign Code
DSL/Function Sequence
DSL/Generation Gap
DSL/Gothic Security
DSL/Grammars and Syntax
DSL/Handling Errors
DSL/How to generate
DSL/Implementing an External DSL
DSL/Language Workbenches
DSL/Languages and Model
DSL/Learning Curve
DSL/Literal Collections
DSL/Literal Extension
DSL/Literal List
DSL/Literal Map
DSL/Macro
DSL/Macros
DSL/Method Chaining
DSL/Migrating DSLs
DSL/Mixing in the Host Language
DSL/Mixing-in Another Language
DSL/Model Ignorant Generation
DSL/Model-Aware Generation
DSL/Nested Closure
DSL/Nested Expression
DSL/Nested Function
DSL/Object Scoping
DSL/Output Production Strategy
DSL/Parse Tree Manipulation
DSL/Parsing Data
DSL/Preface
DSL/Problems with DSLs
DSL/Production Rule System
DSL/Programmer Familiarity
DSL/Programming Miss Grant's Controller
DSL/Runtime Configuration
DSL/Schema-Definition Languages and Meta-Models
DSL/Semantic Model
DSL/Source and Projectional Editing
DSL/State Machine
DSL/Strong Expressiveness Boundary
DSL/Symbol Table
DSL/Syntactic Analysis Strategy
DSL/Syntactic Newlines
DSL/Syntax Directed Translation
DSL/Templated Generation
DSL/Testing with DSLs
DSL/Textual Polishing
DSL/The MDD view of the Language Landscape
DSL/The State Machine Model
DSL/The need for a parsing layer
DSL/The workings of a parser
DSL/Transformer Generation
DSL/Tree Construction
DSL/Using Code-Generation
DSL/Using Functions
DSL/Using Grammars to Choose Internal Elements
DSL/Using Language Workbenches
DSL/Visualization
DSL/Why Use a DSL?
DSL/Wider Language Processing
DSL/template
DSL¥Æ¥ó¥×¥ì¡¼¥È
DataMapper
EIP
EIP/.NET Request-Reply Example
EIP/A Loosely Coupled Integration Solution
EIP/Aggregator
EIP/Asynchronous Implementation with MSMQ
EIP/Asynchronous Implementation with TIBCO ActiveEnterprise
EIP/Canonical Data Model
EIP/Case Study Bond Pricing System
EIP/Ch10 Introduction
EIP/Ch11 Introduction
EIP/Ch2 Introduction
EIP/Ch3 Introduction
EIP/Ch4 Introduction
EIP/Ch5 Introduction
EIP/Ch6 Introduction
EIP/Ch7 Introduction
EIP/Ch8 Introduction
EIP/Channel Adapter
EIP/Channel Purger
EIP/Checking Status
EIP/Claim Check
EIP/Command Message
EIP/Competing Consumers
EIP/Composed Message Processor
EIP/Conclusion
EIP/Content Enricher
EIP/Content Filter
EIP/Content-Based Router
EIP/Control Bus
EIP/Correlation Identifier
EIP/Datatype Channel
EIP/Dead Letter Channel
EIP/Detour
EIP/Document Message
EIP/Durable Subscriber
EIP/Dynamic Router
EIP/Emerging Standards and Futures in Enterprise Integration
EIP/Enhancing the Management Console
EIP/Envelope Wrapper
EIP/Event Message
EIP/Event-Driven Consumer
EIP/File Transfer
EIP/Format Indicator
EIP/Guaranteed Delivery
EIP/Idempotent Receiver
EIP/Integration Challenges
EIP/Invalid Message Channel
EIP/JMS Publish-Subscribe Example
EIP/JMS Request-Reply Example
EIP/Loan Broker Example
EIP/Loan Broker System Management
EIP/Loose Coupling
EIP/Message
EIP/Message Broker
EIP/Message Bus
EIP/Message Channel
EIP/Message Dispatcher
EIP/Message Endpoint
EIP/Message Expiration
EIP/Message Filter
EIP/Message History
EIP/Message Router
EIP/Message Sequence
EIP/Message Store
EIP/Message Translator
EIP/Messaging
EIP/Messaging Bridge
EIP/Messaging Gateway
EIP/Messaging Mapper
EIP/New Catalog
EIP/Normalizer
EIP/One-Minute EAI
EIP/Pattern Form Summary
EIP/Pipes and Filters
EIP/Point-to-Point Channel
EIP/Polling Consumer
EIP/Problem Solving with Patterns
EIP/Process Manager
EIP/Publish-Subscribe Channel
EIP/Recipient List
EIP/Remote Procedure Invocation
EIP/Request-Reply
EIP/Resequencer
EIP/Return Address
EIP/Routing Slip
EIP/Scatter-Gather
EIP/Selective Consumer
EIP/Service Activator
EIP/Shared Database
EIP/Smart Proxy
EIP/Splitter
EIP/Structuring Channels
EIP/Summary
EIP/Synchronous Implementation Using Web Services
EIP/Test Message
EIP/The Need for Integration
EIP/The Wide World of Integration
EIP/Transaction Client
EIP/Transactional Client
EIP/Verify the Credit Bureau Operation
EIP/WS-*
EIP/What Is Messaging_Commercial Messaging Systems
EIP/Widgets Gadgets R Us An Example
EIP/Wire Tap
EIP/ebXML and
FAQ
FormatRule
FormattingRules
FrontPage
Help
InterWiki
InterWikiName
InterWikiSandBox
InterWiki¥Æ¥¯¥Ë¥«¥ë
JavaEEÊÙ¶¯²ñ
KPT
Link
MailingList
MakingSenseofStreamProcessing
MakingSenseofStreamProcessing/1. Replication
MakingSenseofStreamProcessing/2. Secondary Indexes
MakingSenseofStreamProcessing/3. Caching
MakingSenseofStreamProcessing/4. Materialized Views
MakingSenseofStreamProcessing/Bottled Water Change Data Capture with PostgreSQL and Kafka
MakingSenseofStreamProcessing/Bringing Together Event Sourcing and Stream Processing
MakingSenseofStreamProcessing/Bringing the Unix Philosophy to the Twenty-First Century
MakingSenseofStreamProcessing/CEP, Actors, Reactive, and More
MakingSenseofStreamProcessing/Case Study Web Application Developers Driven to Insanity
MakingSenseofStreamProcessing/Composability Requires a Uniform Interface
MakingSenseofStreamProcessing/Conclusion
MakingSenseofStreamProcessing/Conclusion Use Logs to Make Your Infrastructure Solid
MakingSenseofStreamProcessing/Database = Log of Changes
MakingSenseofStreamProcessing/Event Sourcing From the DDD Community
MakingSenseofStreamProcessing/Events and Stream Processing
MakingSenseofStreamProcessing/Example Implementing Twitter
MakingSenseofStreamProcessing/Further Reading
MakingSenseofStreamProcessing/How Databases Are Used
MakingSenseofStreamProcessing/How Logs Are Used in Practice
MakingSenseofStreamProcessing/Implementing Google Analytics A Case Study
MakingSenseofStreamProcessing/Implementing the Snapshot and the Change Stream
MakingSenseofStreamProcessing/Introducing Change Data Capture
MakingSenseofStreamProcessing/Making Sure Data Ends Up in the Right Places
MakingSenseofStreamProcessing/Materialized Views Self-Updating Caches
MakingSenseofStreamProcessing/Pipes and Composability
MakingSenseofStreamProcessing/Simple Log Analysis with Unix Tools
MakingSenseofStreamProcessing/Solving the Data Integration Problem
MakingSenseofStreamProcessing/Status of Bottled Water
MakingSenseofStreamProcessing/Streaming All the Way to the User Interface
MakingSenseofStreamProcessing/Summary Four Database-Related Ideas
MakingSenseofStreamProcessing/The Logical Decoding Output Plug-In
MakingSenseofStreamProcessing/The Ubiquitous Log
MakingSenseofStreamProcessing/The Unbundled Database
MakingSenseofStreamProcessing/The Unix Philosophy of Distributed Data
MakingSenseofStreamProcessing/Tools Putting Ideas into Practice
MakingSenseofStreamProcessing/Transactions and Integrity Constraints
MakingSenseofStreamProcessing/Turning the Database Inside Out
MakingSenseofStreamProcessing/Unix Architecture versus Database Architecture
MakingSenseofStreamProcessing/Using Append-Only Streams of Immutable Events
MakingSenseofStreamProcessing/Using Logs to Build a Solid Data Infrastructure
MakingSenseofStreamProcessing/Why Avro?
MakingSenseofStreamProcessing/Why Kafka?
MenuBar
MessageQueue
MicroservicesVsSOA
MicroservicesVsSOA/Comparing Architecture Capabilities
MicroservicesVsSOA/Comparing Architecture Characteristics
MicroservicesVsSOA/Comparing Service Characteristics
MicroservicesVsSOA/Middleware vs. API Layer
MicroservicesVsSOA/Summary
MicroservicesVsSOA/The World of Service-Based Architectures
ModernJavaEEDesignPatterns
ModernJavaEEDesignPatterns/Additional Technologies and Team Considerations
ModernJavaEEDesignPatterns/Conclusion
ModernJavaEEDesignPatterns/Designing Software for a Scalable Enterprise
ModernJavaEEDesignPatterns/Enterprise Development Today
ModernJavaEEDesignPatterns/History of Java EE
ModernJavaEEDesignPatterns/Independently Deployable and Fully Contained
ModernJavaEEDesignPatterns/Java EE and Microservices
ModernJavaEEDesignPatterns/Microservices Best Practices
ModernJavaEEDesignPatterns/Microservices Design Pattern
Object Creation
PHP
PukiWiki
RecentDeleted
ReentrantLock
SERVICES
SFSB
SLSB
SandBox
Services
SmartProxyReplyConsumer
The Domain Layer Is Where the Model Lives
WikiEngines
WikiName
WikiWikiWeb
YukiWiki
withoutEJB
¤Õ¤ê¤«¤¨¤ê
¥Í¥¿
¥×¥í¥°¥é¥ß¥ó¥°Clojure
¥Ø¥ë¥×
¥Ý¥¸¥·¥ç¥ó¥Ú¡¼¥Ñ
µÄ»öÏ¿
µÄ»öÏ¿/Âè01²ó
µÄ»öÏ¿/Âè02²ó
µÄ»öÏ¿/Âè03²ó
µÄ»öÏ¿/Âè04²ó
µÄ»öÏ¿/Âè05²ó
µÄ»öÏ¿/Âè06²ó
µÄ»öÏ¿/Âè07²ó
µÄ»öÏ¿/Âè39²ó
µÄ»öÏ¿/Âè41²ó
µÄ»öÏ¿/Âè42²ó
µÄ»öÏ¿/Âè43²ó
µÄ»öÏ¿/Âè44²ó
µÄ»öÏ¿/Âè45²ó
µÄ»öÏ¿/Âè46²ó
µÄ»öÏ¿/Âè47²ó
µÄ»öÏ¿/Âè48²ó
µÄ»öÏ¿/Âè51²ó
µÄ»öÏ¿/Âè52²ó
µÄ»öÏ¿/Âè53²ó
µÄ»öÏ¿/Âè54²ó
µÄ»öÏ¿/Âè55²ó
µÄ»öÏ¿/Âè56²ó
¿Ê¤áÊý
¿÷·Á
¿÷·Á/JavaEEÊÙ¶¯²ñ
À°·Á¥ë¡¼¥ë
Âè11²ó J2EEÊÙ¶¯²ñ
ÆüËܸì
ÍѰդ¹¤ë¤â¤Î
¥¿¥¤¥à¥¹¥¿¥ó¥×¤òÊѹ¹¤·¤Ê¤¤
¥Æ¥¥¹¥ÈÀ°·Á¤Î¥ë¡¼¥ë¤òɽ¼¨¤¹¤ë