最新章節
- Summary
- Walking up the ladder
- Code repository
- Release management
- Continuous integration and deployment
- The "I like it" factor
品牌：中圖公司
上架時間：2021-07-02 18:55:15
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Summary 更新時間：2021-07-02 23:38:15
- Walking up the ladder
- Code repository
- Release management
- Continuous integration and deployment
- The "I like it" factor
- Number of users
- Maturity
- Project alive
- Documentation
- License
- Fit for the purpose
- Selecting libraries
- Black box versus white box
- Test automation
- Types of tests
- Testing
- Issue tracking
- Knowledge base
- Code review
- Software versioning
- Source code version control
- Static code analysis
- Programming in the enterprise
- Annotation processing
- Problems with polyglot
- Business DSL
- Polyglot scripting
- Polyglot configuration
- Polyglot programming
- Java agent
- Java deep technologies
- Finalizing Java Knowledge to a Professional Level
- Summary
- Implementing inventory
- Reactive programming in Java
- Reactive streams
- Back-pressure
- Message-driven
- Elastic
- Resilient
- Responsive
- Reactive systems
- Reactive programming in a nutshell
- Reactive... what?
- Building an Accounting Application Using Reactive Programming
- Summary
- Scripting in Java 9
- Method references
- Functional interfaces
- Streams
- Lambda
- Functional programming in Java
- Setting fields
- Invoking methods
- Getting annotations
- Using reflection
- JDK annotations
- @Documented annotations
- Annotation inheritance
- Repeatable annotations
- Annotation parameters
- Annotation target
- Annotation retention
- Annotations
- Consistency checker
- Order controller and DTOs
- Setting up the project
- The MyBusiness ordering
- Extending Our E-Commerce Application
- Summary
- Dynamic proxy-based AOP
- Audit logging and AOP
- Servlet filters
- Application test
- Integration test
- Testing the application
- Compiling and running the application
- Service classes
- Spring core
- Architecture of Spring
- Spring framework
- Model View Controller
- REST
- JSON
- Service interface design
- Microservices
- Sample business architecture
- The MyBusiness web shop
- Building a Commercial Web Application Using REST
- Summary
- Other technologies
- Logging practice
- Java 9 logging
- Log frameworks
- Performance
- Configurability
- Logging
- Running the Jetty web servlet
- The GameSessionSaver class
- Storing state on the server
- The MastermindHandler class
- Dependency injection with Guice
- Storing state on the client
- HTTP session
- Storing state
- Mastermind servlet
- HTML CSS and JavaScript
- Java Server Pages
- Hello world servlet
- Writing servlets
- Client server and web architecture
- Cookies
- HTTP/2.0
- Status codes
- HTTP methods
- The HTTP protocol
- DNS
- TCP/IP
- IP
- Web and network
- Making Our Game Professional - Do it as a Webapp
- Summary
- Microbenchmarking
- ParallelGamePlayer
- IntervalGuesser
- LinkedTransferQueue
- ArrayBlockingQueue
- LinkedBlockingDeque
- LinkedBlockingQueue
- BlockingQueue
- Atomic classes
- ReentrantReadWriteLock
- ReentrantLock
- Condition
- Lock
- Wait and notify
- Synchronized block
- Volatile variables
- The CPU heartbeat
- Variable access
- ForkJoinPool
- ExecutorService
- Starving
- Overused locks
- Race conditions
- Deadlocks
- Pitfalls
- java.lang.Thread
- Fibers
- Threads
- Processes
- Refactoring
- How to make Mastermind parallel
- Extending the Game - Run Parallel Run Faster
- Summary
- Creating an integration test
- The Game class
- GeneralGuesser
- UniqueGuesser
- Guesser
- Table
- Row
- JavaDoc and code comments
- The class color
- ColorManager
- Implementing the game
- Dependency injection
- IdentityHashMap
- HashMap
- Map
- Deque
- Queue
- ArrayList
- LinkedList
- List
- TreeSet
- NavigableSet
- SortedSet
- LinkedHashSet
- EnumSet
- HashSet
- Implementing equals and hashCode
- Method hashCode
- Method equals
- Hash functions
- Set
- Interface collection
- Java collections
- The model of the game
- The Game
- Mastermind - Creating a Game
- Summary
- What is a Java module
- Why modules are needed
- Creating modules
- Implementing the API class
- Non-recursive sorting
- Recursive sorting
- The partitioning class
- Implementing QuickSort
- Test Driven Development
- Generics
- Handling exceptions
- Collections with wrong elements
- Refactor the test
- Unit tests cover the code
- Unit tests are isolated
- Assertions should be as simple as possible
- Unit tests are deterministic
- Unit tests are fast
- A good unit test is readable
- Good unit tests
- Writing the BubbleSortTest class
- Adding JUnit as dependency
- Creating unit tests
- Architectural considerations
- Amending the interfaces
- Creating BubbleSort
- Creating the interfaces
- Code the sort
- Maven dependency management
- Project structure and build tools
- Quick sort
- A brief overview of various sorting algorithms
- The general sorting program
- Optimizing the Sort - Making Code Professional
- Summary
- Compiling and running the program
- Object initializers and constructors
- Modifiers
- Fields
- Argument passing
- Interfaces
- Methods
- Packages
- Inner nested local and anonymous classes
- Classes
- Final variables
- Conditional execution
- Loops
- Expressions
- Arrays
- Types
- Variables
- Blocks
- Understanding the algorithm and language constructs
- Coding the sort
- Setting up the project with Maven
- Installing Gradle
- Gradle
- Using Maven
- Installing Maven
- Maven
- Using Ant
- Installing Ant
- Ant
- Make
- Getting started with project structure and build tools
- Bubble sort
- Getting started with sorting
- The First Real Java Program - Sorting Names
- Summary
- Debugging Java
- Build the code and run it
- Managing projects
- Editing files
- IDE screen structure
- IDE services
- IntelliJ
- Eclipse
- NetBeans
- Using an IDE
- Managing the running Java application
- Packaging classes into a JAR file
- Looking at the byte code
- Executing jshell
- Setting JAVA_HOME
- Installation on Linux
- Installation on MAC OS X
- Installation on Windows
- Installing Java
- Getting started with Java
- Getting Started with Java 9
- Questions
- Piracy
- Errata
- Downloading the example code
- Customer support
- Reader feedback
- Conventions
- Who this book is for
- What you need for this book
- What this book covers
- Preface
- Customer Feedback
- www.PacktPub.com
- About the Reviewer
- About the Author
- Credits
- 版權信息
- 封面
- 封面
- 版權信息
- Credits
- About the Author
- About the Reviewer
- www.PacktPub.com
- Customer Feedback
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Reader feedback
- Customer support
- Downloading the example code
- Errata
- Piracy
- Questions
- Getting Started with Java 9
- Getting started with Java
- Installing Java
- Installation on Windows
- Installation on MAC OS X
- Installation on Linux
- Setting JAVA_HOME
- Executing jshell
- Looking at the byte code
- Packaging classes into a JAR file
- Managing the running Java application
- Using an IDE
- NetBeans
- Eclipse
- IntelliJ
- IDE services
- IDE screen structure
- Editing files
- Managing projects
- Build the code and run it
- Debugging Java
- Summary
- The First Real Java Program - Sorting Names
- Getting started with sorting
- Bubble sort
- Getting started with project structure and build tools
- Make
- Ant
- Installing Ant
- Using Ant
- Maven
- Installing Maven
- Using Maven
- Gradle
- Installing Gradle
- Setting up the project with Maven
- Coding the sort
- Understanding the algorithm and language constructs
- Blocks
- Variables
- Types
- Arrays
- Expressions
- Loops
- Conditional execution
- Final variables
- Classes
- Inner nested local and anonymous classes
- Packages
- Methods
- Interfaces
- Argument passing
- Fields
- Modifiers
- Object initializers and constructors
- Compiling and running the program
- Summary
- Optimizing the Sort - Making Code Professional
- The general sorting program
- A brief overview of various sorting algorithms
- Quick sort
- Project structure and build tools
- Maven dependency management
- Code the sort
- Creating the interfaces
- Creating BubbleSort
- Amending the interfaces
- Architectural considerations
- Creating unit tests
- Adding JUnit as dependency
- Writing the BubbleSortTest class
- Good unit tests
- A good unit test is readable
- Unit tests are fast
- Unit tests are deterministic
- Assertions should be as simple as possible
- Unit tests are isolated
- Unit tests cover the code
- Refactor the test
- Collections with wrong elements
- Handling exceptions
- Generics
- Test Driven Development
- Implementing QuickSort
- The partitioning class
- Recursive sorting
- Non-recursive sorting
- Implementing the API class
- Creating modules
- Why modules are needed
- What is a Java module
- Summary
- Mastermind - Creating a Game
- The Game
- The model of the game
- Java collections
- Interface collection
- Set
- Hash functions
- Method equals
- Method hashCode
- Implementing equals and hashCode
- HashSet
- EnumSet
- LinkedHashSet
- SortedSet
- NavigableSet
- TreeSet
- List
- LinkedList
- ArrayList
- Queue
- Deque
- Map
- HashMap
- IdentityHashMap
- Dependency injection
- Implementing the game
- ColorManager
- The class color
- JavaDoc and code comments
- Row
- Table
- Guesser
- UniqueGuesser
- GeneralGuesser
- The Game class
- Creating an integration test
- Summary
- Extending the Game - Run Parallel Run Faster
- How to make Mastermind parallel
- Refactoring
- Processes
- Threads
- Fibers
- java.lang.Thread
- Pitfalls
- Deadlocks
- Race conditions
- Overused locks
- Starving
- ExecutorService
- ForkJoinPool
- Variable access
- The CPU heartbeat
- Volatile variables
- Synchronized block
- Wait and notify
- Lock
- Condition
- ReentrantLock
- ReentrantReadWriteLock
- Atomic classes
- BlockingQueue
- LinkedBlockingQueue
- LinkedBlockingDeque
- ArrayBlockingQueue
- LinkedTransferQueue
- IntervalGuesser
- ParallelGamePlayer
- Microbenchmarking
- Summary
- Making Our Game Professional - Do it as a Webapp
- Web and network
- IP
- TCP/IP
- DNS
- The HTTP protocol
- HTTP methods
- Status codes
- HTTP/2.0
- Cookies
- Client server and web architecture
- Writing servlets
- Hello world servlet
- Java Server Pages
- HTML CSS and JavaScript
- Mastermind servlet
- Storing state
- HTTP session
- Storing state on the client
- Dependency injection with Guice
- The MastermindHandler class
- Storing state on the server
- The GameSessionSaver class
- Running the Jetty web servlet
- Logging
- Configurability
- Performance
- Log frameworks
- Java 9 logging
- Logging practice
- Other technologies
- Summary
- Building a Commercial Web Application Using REST
- The MyBusiness web shop
- Sample business architecture
- Microservices
- Service interface design
- JSON
- REST
- Model View Controller
- Spring framework
- Architecture of Spring
- Spring core
- Service classes
- Compiling and running the application
- Testing the application
- Integration test
- Application test
- Servlet filters
- Audit logging and AOP
- Dynamic proxy-based AOP
- Summary
- Extending Our E-Commerce Application
- The MyBusiness ordering
- Setting up the project
- Order controller and DTOs
- Consistency checker
- Annotations
- Annotation retention
- Annotation target
- Annotation parameters
- Repeatable annotations
- Annotation inheritance
- @Documented annotations
- JDK annotations
- Using reflection
- Getting annotations
- Invoking methods
- Setting fields
- Functional programming in Java
- Lambda
- Streams
- Functional interfaces
- Method references
- Scripting in Java 9
- Summary
- Building an Accounting Application Using Reactive Programming
- Reactive... what?
- Reactive programming in a nutshell
- Reactive systems
- Responsive
- Resilient
- Elastic
- Message-driven
- Back-pressure
- Reactive streams
- Reactive programming in Java
- Implementing inventory
- Summary
- Finalizing Java Knowledge to a Professional Level
- Java deep technologies
- Java agent
- Polyglot programming
- Polyglot configuration
- Polyglot scripting
- Business DSL
- Problems with polyglot
- Annotation processing
- Programming in the enterprise
- Static code analysis
- Source code version control
- Software versioning
- Code review
- Knowledge base
- Issue tracking
- Testing
- Types of tests
- Test automation
- Black box versus white box
- Selecting libraries
- Fit for the purpose
- License
- Documentation
- Project alive
- Maturity
- Number of users
- The "I like it" factor
- Continuous integration and deployment
- Release management
- Code repository
- Walking up the ladder
- Summary 更新時間：2021-07-02 23:38:15
