Java 9 Cookbook

Java 9 Cookbook

By : Mohamed Sanaulla, Nick Samoylov

Buy this Book

Java 9 Cookbook

By: Mohamed Sanaulla, Nick Samoylov

Buy this Book

Overview of this book

Java is an object-oriented programming language. It is one of the most widely accepted languages because of its design and programming features, particularly in its promise that you can write a program once and run it anywhere. This cookbook offers a range of software development examples in simple and straightforward Java 9 code, providing step-by-step resources and time-saving methods to help you solve data problems efficiently. Starting with the installation of Java, each recipe addresses a specific problem, with a discussion that explains the solution and offers insight into how it works. We cover major concepts such as Project Jigsaw and various tools that will enable you to modularize your applications. You will learn new features in the form of recipes that will make your applications modular, secure, and fast.

Title Page

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Customer Feedback

Preface

Free Chapter

Installation and a Sneak Peek into Java 9

Introduction

Installing JDK 9 on Windows and setting up the PATH variable

Installing JDK 9 on Linux (Ubuntu, x64) and configuring the PATH variable

Compiling and running a Java application

New features in Java 9

Using new tools in JDK 9

Comparing JDK 8 and JDK 9

Fast Track to OOP - Classes and Interfaces

Introduction

Implementing object-oriented design using classes

Using inner classes

Using inheritance and composition to make the design extensible

Coding to an interface

Creating interfaces with default and static methods

Creating interfaces with private methods

Using enums to represent constant entities

Using the @Deprecated annotation to deprecate APIs

Using HTML5 in Javadocs

Modular Programming

Introduction

Using jdeps to find dependencies in a Java application

Creating a simple modular application

Creating a modular JAR

Using a module JAR with pre-JDK 9 applications

Bottom-up migration

Top-down migration

Using services to create loose coupling between consumer and provider modules

Creating a custom modular runtime image using jlink

Compiling for older platform versions

Creating multirelease JARs

Using Maven to develop a modular application

Going Functional

Introduction

Understanding and creating a functional interface

Understanding lambda expressions

Using method references

Creating and invoking lambda-friendly APIs

Leveraging lambda expressions in your programs

Stream Operations and Pipelines

Introduction

Using the new factory methods to create collection objects

Creating and operating on streams

Creating an operation pipeline on streams

Parallel computations on streams

Database Programming

Introduction

Connecting to a database using JDBC

Setting up the tables required for DB interactions

Performing CRUD operations

Using prepared statements

Using transactions

Working with large objects

Executing stored procedures

Concurrent and Multithreaded Programming

Introduction

Using the basic element of concurrency - thread

Different synchronization approaches

Immutability as a means to achieve concurrency

Using concurrent collections

Using the executor service to execute async tasks

Using fork/join to implement divide-and-conquer

Using flow to implement the publish-subscribe pattern

Better Management of the OS Process

Introduction

Spawning a new process

Redirecting the process output and error streams to file

Changing the working directory of a subprocess

Setting the environment variable for a subprocess

Running shell scripts

Obtaining the process information of the current JVM

Obtaining the process information of the spawned process

Managing the spawned process

Enumerating live processes in the system

Connecting multiple processes using pipe

Managing subprocesses

GUI Programming Using JavaFX

Introduction

Creating a GUI using JavaFX controls

Using the FXML markup to create a GUI

Using CSS to style elements in JavaFX

Creating a bar chart

Creating a pie chart

Creating a line chart

Creating an area chart

Creating a bubble chart

Creating a scatter chart

Embedding HTML in an application

Embedding media in an application

Adding effects to controls

Using the new TIFF I/O API to read TIFF images

RESTful Web Services Using Spring Boot

Introduction

Creating a simple Spring Boot application

Interacting with the database

Creating a RESTful web service

Creating multiple profiles for Spring Boot

Deploying RESTful web services to Heroku

Containerizing the RESTful web service using Docker

Networking

Introduction

Making an HTTP GET request

Making an HTTP POST request

Making an HTTP request for a protected resource

Making an asynchronous HTTP request

Making an HTTP request using Apache HttpClient

Making an HTTP request using the Unirest HTTP client library

Memory Management and Debugging

Introduction

Understanding the G1 garbage collector

Unified logging for JVM

Using the new diagnostic commands for the JVM

Try with resources for better resource handling

Stack walking for improved debugging

Some best practices for better memory usage

The Read-Evaluate-Print Loop (REPL) Using JShell

Introduction

Getting familiar with REPL

Navigating JShell and its commands

Evaluating code snippets

Object-oriented programming in JShell

Saving and restoring the JShell command history

Using the JShell Java API

Scripting Using Oracle Nashorn

Introduction

Using the jjs command-line tool

Embedding the Oracle Nashorn engine

Invoking Java from Oracle Nashorn

Using the ES6 features implemented in Oracle Nashorn

Testing

Introduction

Unit testing of an API using JUnit

Unit testing by mocking dependencies

Using fixtures to populate data for testing

Behavioral testing

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Managing subprocesses

When a process launches another process, the launched process becomes the subprocess of the launching process. The launched process, in turn, can launch another process and this chain can continue. This results in a process tree. Often, we would have to deal with a buggy subprocess and might want to kill that subprocess, or we might want to know the subprocesses that are launched and might want to get some information about it.

In Java 9, two new APIs in the Process class have been added: children() and descendants(). The children() API allows you to get a list of the snapshot of processes that are the immediate children of the current process, and the descendants() API provides a snapshot of processes that are recursively children() of the current process, that is, they are invoking children() recursively on each child process.

In this recipe, we will look at both the children() and descendants() APIs and see what information we can gather from the snapshot of the process...

Java 9 Cookbook

By : Mohamed Sanaulla, Nick Samoylov

Java 9 Cookbook

By: Mohamed Sanaulla, Nick Samoylov

Overview of this book

Related Content you might be interested in

Current Title:

Java 9 Cookbook

Managing subprocesses