Index
A
- abstract classes, Where to Begin
- abstract factory design pattern, Dependency Inversion and Dependency Injection
- abstraction, Functional Programming
- accumulators, reduce()
- Action interface, Test Driven Development
- mocking and verifying interaction with Action object, Mocking
- refactoring so perform method can use Facts object as argument, Modeling State
- actions, Business Rules Engine Requirements, Modeling the Domain
- adapters, The Hexagonal Architecture
- add method in repositories, Persistence and the Repository Pattern
- aggregations
- Agile, or iterative, development methodologies, Where to Begin
- anaemic domain model, Where to Begin
- Android push notifications, Communication
- anti-cohesion, Too Granular
- anti-patterns, Code Maintainability and Anti-Patterns
- APIs
- assertAttributeEquals method, Don’t Repeat Yourself
- assertion statements, Assert statements
- AssertionError, Good Diagnostics
- attributes
- authentication, The Hexagonal Architecture
- automated testing, Automated Testing
B
- bank statements analyzer (example), The Challenge-Completing the Challenge
- applying single responsibility pattern to code, Single Responsibility Principle
- calculating sum of all statements, KISS Principle
- class-level cohesion in, Class-Level Cohesion-Method-Level Cohesion
- decoupling from the parser, Coupling
- decoupling interface from implementation, Coupling
- enhancing functionalities of, Completing the Challenge
- extending, The Challenge-Completing the Challenge
- declaring class implementing BankTransactionFilter, Creating an Instance of a Functional Interface
- exception handling, Exception Handling-Try<T>
- explicit vs. implicit API for BankTransactionProcessor, Explicit Versus Implicit API-Domain Class or Primitive Value?
- exporting summary statistics in different formats, Multiple Exporters-Exception Handling
- finding transactions in certain month, Open/Closed Principle
- finding transactions over certain amount, Open/Closed Principle
- implementing BankTransactionFilter using lambda expression, Lambda Expressions
- interface gotchas, Interfaces Gotchas-Too Granular
- requirements, Extended Bank Statements Analyzer Requirements
- using a build tool, Using a Build Tool-Gradle commands
- requirements, Bank Statements Analyzer Requirements
- testing CSV parser, Defining a test method
- behavior
- big design up front (BDUF), Where to Begin
- BigDecimal class, Domain Class or Primitive Value?
- boolean values indicating success or failure, Modeling Errors
- bottom-up approach to software development, Followers and Twoots
- Bouncy Castle library, Passwords and Security
- break statements in switch statement, Switch Expressions
- build tools, Why Use a Build Tool?-Gradle commands, Packages and Build Systems
- build.gradle files, Example build file
- builder pattern, Builder Pattern-Takeaways
- business logic, separation from data stores, Query Objects
- business rules engine (example), The Challenge-Completing the Challenge
C
- chaining methods in Fluent APIs, Builder Pattern
- changes, robustness to, Robustness to changes
- checked exceptions, Why Use Exceptions?
- class-level cohesion, Class-Level Cohesion-Method-Level Cohesion
- classes
- adapter, Where to Begin
- capabilities, Making Importer a Class
- changing behavior without modifying code, Open/Closed Principle
- class hierarchy for Documents, Attributes and Hierarchical Documents
- coupling, Coupling
- decoupling, Coupling
- exceptions hierarchy in Java, Why Use Exceptions?
- inline, in future Java version, The Contract Between equals and hashCode
- modeling real-world objects as, Extending and Reusing Code
- single responsibility principle, Single Responsibility Principle
- test classes with Test suffix, Defining a test method
- client-server model, Design Overview
- Cobertura code coverage tool, Code Coverage
- code
- code coverage, Code Coverage
- cohesion, The Goal, Cohesion-Method-Level Cohesion
- Collectors API, Functional Programming
- combine operation, reduce()
- comma-separated values (CSV) format, Bank Statements Analyzer Requirements
- communication in Twootr (example), Communication
- composition over inheritance principle, The Goal
- conditions, Business Rules Engine Requirements, Modeling the Domain
- constants
- constructors
- control flow versus exceptions, Exceptions versus Control flow
- coupling, The Goal, Coupling
- cryptographic hash functions, Passwords and Security
- CSVSyntaxException, Deciding between unchecked and checked
D
- data access object (DAO) pattern, Informational
- data stores, separation from business logic, Query Objects
- data types
- dead code, Designing the Repositories
- Decision Model and Notation (DMN) standard, Business Rules Engine Requirements
- delete method in repositories, Persistence and the Repository Pattern
- deliberate practice, Deliberate Practice
- delimiter-separated formats, KISS Principle
- dependencies
- dependency injection, Dependency Inversion and Dependency Injection
- dependency inversion principle (DIP), SOLID, Dependency Inversion and Dependency Injection
- design
- diagnostics, good, for failing tests, Good Diagnostics-Good Diagnostics
- diamond operator (<>), Local Variable Type Inference
- digests, Passwords and Security
- discoverability, Open/Closed Principle, Too Granular, The Document Class
- Document class hierarchy, defining, Attributes and Hierarchical Documents
- document management system (example), The Challenge-Completing the Challenge
- documenting exceptions, Document exceptions
- domain classes, Domain Class or Primitive Value?
- domain-specific language (DSL), use by Gradle, Using Gradle
- domains, Single Responsibility Principle
- Don't Repeat Yourself, Don’t Repeat Yourself
- double value, wrapping in domain class, Domain Class or Primitive Value?
- Drools, Business Rules Engine Requirements
E
- EasyMock, Mocking Libraries
- Emma code coverage tool, Code Coverage
- encapsulation, Code Maintainability and Anti-Patterns
- enum types, Modeling Errors
- equals method, The equals and hashcode Methods
- Error class, Why Use Exceptions?
- errors
- events
- Exception class, Why Use Exceptions?
- exception handling, Exception Handling-Try<T>
- exceptions
- exec plug-in (Maven), Maven commands
- execute around pattern, Execute Around
- exhaustiveness in switch statement, Switch Expressions
- explicit versus implicit API, Explicit Versus Implicit API-Domain Class or Primitive Value?
- exporters, multiple, Multiple Exporters-Exception Handling
F
- facts (in business rules engine), Business Rules Engine Requirements
- fall-through behavior, Switch Expressions
- File class, Importers
- files imported into document management system, representing, Importers
- Files.readAllLines method, KISS Principle
- filter function, filter()
- final keyword
- final variables, final Variables
- Fluent APIs, designing, Designing a Fluent API-Takeaways
- followers, notifying of twoots in Twootr (example), Twooting
- for loops, map operations with, map()
- forEach function, forEach()
- functional cohesion, Functional
- functional interface, Open/Closed Principle
- functional programming, Functional Programming-Optional
- functional programming languages, Functional Programming
G
- generic Exception, not catching, Do not catch the generic Exception
- get method in repositories, Persistence and the Repository Pattern
- Given-When-Then formula, Assert statements, Mocking, Verifying with Mocks
- God class, Code Maintainability and Anti-Patterns
- God interface, God Interface
- Gradle, Using Gradle-Gradle commands
- granularity, too granular interfaces, Too Granular
- Groovy programming language, Using Gradle
- GUI (graphical user interface) in Twootr (example), GUI
- Guice framework, Dependency Inversion and Dependency Injection
H
- Hamcrest library, matchers from, Good Diagnostics
- hashCode method, The equals and hashcode Methods
- HashMap class, Document class extending, The Document Class
- Hexagonal architecture, The Hexagonal Architecture
- Hibernate, Query Objects
- high coupling, Coupling
- history rule (in LSP), The Liskov Substitution Principle (LSP)
- hosted cloud-based message queues, Communication
I
- IllegalArgumentException, Overly apathetic
- images
- immutability
- implementation-specific exceptions, avoiding, Watch out for implementation-specific exceptions
- implicit versus explicit API, Explicit Versus Implicit API
- importers
- informational cohesion, Informational
- inheritance
- inline classes, The Contract Between equals and hashCode
- int-based status codes, Modeling Errors
- IntelliJ IDE, using to run tests, Defining a test method
- inter-process communication, Communication
- interface segregation principle (ISP), SOLID
- interfaces
- invariants of supertype, preserving in subtype, The Liskov Substitution Principle (LSP)
- is a relationship, Making Importer a Class
- isEnd predicate, Extending and Reusing Code
- iterative development methodologies, Where to Begin
J
- Jackson library, User Interface
- JaCoCo, Code Coverage
- Java
- java.io.File class, Importers
- java.lang.Object, The equals and hashcode Methods
- java.math.BigDecimal, Domain Class or Primitive Value?
- java.util.function.Predicate<T> interface, Open/Closed Principle, Modeling the Domain
- java.util.Objects class, SenderEndPoint
- java.util.Optional<T>, Optional<T>
- jOOQ, library for interacting with databases using intuitive API, What Is a Fluent API?
- JSON, User Interface
- JUnit, Testing
M
- man-in-the-middle attacks, securing WebSockets against, Passwords and Security
- map function, map()
- maps
- matchers, Good Diagnostics
- Maven, Using Maven-Using Gradle
- message queues
- method references, Lambda Expressions, Method References-Method References
- method-level cohesion, Method-Level Cohesion
- methods
- mock method, Mocking
- mocking, Mocking-Mocking
- Mockito library, Mocking
O
- object class, equals and hashCode methods, The equals and hashcode Methods
- object-oriented programming
- object-relational mappers (ORMs), Query Objects
- Objects class, SenderEndPoint
- on prefix for methods, Where to Begin
- onFollow method, Followers and Twoots
- onLogon method, Where to Begin
- onSendTwoot method, Twooting, SenderEndPoint
- onTwoot method, Twooting
- open source message transports or message queues, Communication
- open/closed principle (OCP), SOLID, The Goal, Open/Closed Principle-Lambda Expressions
- Optional type, Where to Begin, Functional Programming, Optional-Optional
- creating empty Optional and checking if it contains a value, Optional
- creating Optional instance from a value, Optional
- methods defined for use like Stream API, Optional
- using orElse and orElseGet methods, Optional
- Optional<T> type, Optional<T>
- ORMs (object-relational mappers), Query Objects
- overly specific exceptions, Overly specific
P
- package scope, Scoping and Encapsulation Choices
- packages, Packages and Build Systems-Packages and Build Systems
- passwords, Where to Begin
- Path class, KISS Principle
- paths
- persistence in Twootr (example), Persistence
- plain text, passwords stored in, Passwords and Security
- Point class, Positions
- pom.xml files (Maven), Example build file
- ports and adapters, The Hexagonal Architecture
- positions (in Twootr example), Positions-The Contract Between equals and hashCode, Designing the Repositories
- postconditions, no weakening in subtypes, The Liskov Substitution Principle (LSP)
- Powermock, Mocking Libraries
- practices and principles over technology, Starting the Journey
- precision in decimal numbers, Domain Class or Primitive Value?
- preconditions, not strengthening in subtypes, The Liskov Substitution Principle (LSP)
- primitive values, returned from aggregations, Domain Class or Primitive Value?
- principle of least surprise, Single Responsibility Principle
- program comprehension through testing, Program comprehension
- Project Valhalla, The Contract Between equals and hashCode
- projects
- public modifier
- pull-based communications, Pull-Based
- push-based communications, Push-Based
R
- rainbow table, Passwords and Security
- ReceiverEndPoint interface, Where to Begin, Twooting
- reduce function, reduce()
- reference objects, The equals and hashcode Methods
- registering importers, Implementing and Registering Importers
- repository pattern, Persistence and the Repository Pattern-Query Objects
- robustness to changes, Robustness to changes
- rules, Business Rules Engine Requirements, Modeling the Domain
- run method, basic implementation, Mocking
- RuntimeException class, Why Use Exceptions?
S
- salts, Passwords and Security
- scope
- Scrypt hashing function, Passwords and Security
- search
- security, Passwords and Security
- SenderEndPoint class, Where to Begin, SenderEndPoint
- sequential cohesion, Sequential
- servers, Design Overview
- Set interface, Modeling Errors
- settings.gradle files, Example build file
- single responsibility principle (SRP), SOLID, The Goal, Single Responsibility Principle-Single Responsibility Principle
- software design and architecture, Software Design and Architecture
- software development
- SOLID principles, SOLID
- source code for this book, The Goal
- Spring framework, Dependency Inversion and Dependency Injection
- Spring integration, What Is a Fluent API?
- src/main/java directory, Defining a test method
- src/test/java directory, Defining a test method
- start index, Extending and Reusing Code
- state, modeling in business rules engine, Modeling State
- static modifier, Implementing and Registering Importers
- streams, Streams-Optional
- Streams API, Explicit Versus Implicit API, What Is a Fluent API?, Functional Programming
- strict mocking, Mocking Libraries
- strings
- strong typing, Importers
- subtypes, The Liskov Substitution Principle (LSP)
- switch statement
T
- temporal cohesion, Temporal
- test-driven development (TDD), Fleshing Out the Design, Test Driven Development-The TDD Cycle
- testing, Testing, Testing-Code Coverage
- TextFile class, Extending and Reusing Code
- themes, Themes-Testing
- Throwable class, Why Use Exceptions?
- top-down approach to software development, Followers and Twoots
- Transport Layer Security (TLS), Passwords and Security
- Try<T> type, Try<T>
- tuples
- building user tuple with for loop, map()
- building user tuple with map function, map()
- Twoot class (example), Verifying with Mocks
- Twootr (example), The Challenge-Completing the Challenge
- type inference, Local Variable Type Inference
U
- ubiquitous language (describing software), The Document Class
- unchecked exceptions, Why Use Exceptions?, Do not ignore an exception
- unit of work pattern, Query Objects
- unit tests, Using JUnit
- UnsupportedOperationException, The TDD Cycle
- unused code (or dead code), Designing the Repositories
- update method in repositories, Persistence and the Repository Pattern
- user interfaces (UIs)
- disadvantages of coupling to core server-side business logic, GUI
- in Twootr (example), User Interface
- users
- utility classes, Extending and Reusing Code
- utility cohesion, Utility
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.