Java Courses Online

Learn how to write awesome Java JUnit Unit Tests with Spring Boot and Mockito in 40 Easy Steps

About

Spring Boot is the most popular framework to develop RESTful services. It has testing of the impressive unit through the Spring Boot Starter Test. Mockito is the most popular mocking framework. JUnit is the most popular Java unit testing framework. You will build unit tests steps by step - in 40 easy steps. This course would be the perfect first step as an  introductionto a unit testing with Spring Boot and Mockito frameworks. You will use the Spring 9dependence management), Spring Boot, Maven (dependencies management), Eclipse (IDE), in memory database H2 and Tomcat embedded web server. We will help you configure each of them. You will use all frameworks, part of the Spring Boot Starter Test- JUnit, Spring Test, Spring Boot Test, AssertJ, Hamcrest, Mockito, JSONassert, and JsonPath. You will learn how to use the most important unit testing annotations - @Runwith(SpringRunner.class), @SpringBootTest, @WebMvcTest, @DataJpaTest and @MockBean.

Style and approach

In this course, you will learn to build unit tests for simple RESTful services with Spring Boot Starter Test, Mockito and JUnit.

Content

• You will learn how to write great Unit and Integration tests using Spring Boot Starter Test
• You will learn to write unit tests using Mocks and Spys created  ith Mockito
• You will learn to write independent unit tests for the RESTful web services talking with several layers - web, business, and data
• You will learn how to use the most important unit testing annotations - @Runwith(SpringRunner), @SpringBootTest, @WebMvcTest, @DataJpaTest and @MockBean.
• You will learn to use all the frameworks, which are part of the Spring Boot Starter Test- JUnit, Spring Test, Spring Boot Test, AssertJ, Hamcrest, Mockito, JSONassert, and JsonPath
• You will learn how to write integration tests by using an in-memory database - H2

Features

• Learn to write independent unit tests for the RESTful services talking with several layers - web, business, and data
• Learn to write integration tests using an in-memory database - H2

Develop your coding skills by exploring Java concepts and techniques such as Strings, Objects and Types, Data Structures and Algorithms, Concurrency, and Functional programming

About

The super-fast evolution of the JDK between versions 8 and 12 has increased the learning curve of modern Java, therefore has increased the time needed for placing developers in the Plateau of Productivity. Its new features and concepts can be adopted to solve a variety of modern-day problems. this course enables you to adopt an objective approach to common problems by explaining the correct practices and decisions with respect to complexity, performance, readability, and more.

Java Coding Problems will help you complete your daily tasks and meet deadlines. You can count on the 300+ applications containing 1,000+ examples in this course to cover the common and fundamental areas of interest: strings, numbers, arrays, collections, data structures, date and time, immutability, type inference, Optional, Java I/O, Java Reflection, functional programming, concurrency and the HTTP Client API. Put your skills on steroids with problems that have been carefully crafted to highlight and cover the core knowledge that is accessed in daily work. In other words (no matter if your task is easy, medium or complex) having this knowledge under your tool belt is a must, not an option.

By the end of this course, you will have gained a strong understanding of Java concepts and have the confidence to develop and choose the right solutions to your problems.

Content

• Adopt the latest JDK 11 and JDK 12 features in your applications
• Solve cutting-edge problems relating to collections and data structures
• Get to grips with functional-style programming using lambdas
• Perform asynchronous communication and parallel data processing
• Solve strings and number problems using the latest Java APIs
• Become familiar with different aspects of object immutability in Java
• Implement the correct practices and clean code techniques

Features

• Solve Java programming challenges and get interview-ready by using the power of modern Java 11
• Test your Java skills using language features, algorithms, data structures, and design patterns
• Explore areas such as web development, mobile development, and GUI programming

Barefoot

An open source Java library for online and offline map matching with OpenStreetMap. Together with its extensive set of geometric and spatial functions, an in-memory map data structure and basic machine learning functions, it is a versatile basis for scalable location-based services and spatio-temporal data analysis on the map. It is designed for use in parallel and distributed systems and, hence, includes a stand-alone map matching server and can be used in distributed systems for map matching services in the cloud.

Flexible and extensive

Barefoot consists of a software library and a (Docker-based) map server that provides access to street map data from OpenStreetMap and is flexible to be used in distributed cloud infrastructures as map data server or side-by-side with Barefoot's stand-alone servers for offline (matcher server) and online map matching (tracker server), or other applications built with Barefoot library. Access to map data is provided with a fast and flexible in-memory map data structure. Together with GeographicLib [1] and ESRI's geometry API [2], it provides an extensive set of geographic and geometric operations for spatial data analysis on the map.

State-of-the-art map matching

Barefoot includes a Hidden Markov Model map matching implementation for both, offline map matching as proposed by Newson and Krumm in [3] and online map matching as proposed by Goh et al. in [4]. Offline map matching is the path reconstruction of a moving object from a recorded GPS trace. In contrast, online map matching determines an object's position and movement on the map iteratively from live GPS position updates in real-time.

Scalable and versatile

Barefoot is designed for use in parallel and distributed high-throughput systems [5]. For map matching large batches of GPS traces (offline map matching), it can be easily integrated in Apache Hadoop or Apache Spark (see example below), whereas Apache Storm and Apache Spark Streaming provide a runtime environment for processing massive data streams (online map matching). To support other data analysis functions, Barefoot comes with basic machine learning support, e.g., DBSCAN for spatial cluster analysis [6].

Open source and open data

Barefoot is licensed under the business-friendly Apache License 2.0 and uses only business-friendly open source software with open map data from OpenStreetMap.

LMDB for Java

• Transactions (full ACID semantics)
• Ordered keys (enabling very fast cursor-based iteration)
• Memory-mapped files (enabling optimal OS-level memory management)
• Zero copy design (no serialization or memory copy overhead)
• No blocking between readers and writers
• Configuration-free (no need to "tune" it to your storage)
• Instant crash recovery (no logs, journals or other complexity)
• Minimal file handle consumption (just one data file; not 100,000's like some stores)
• Same-thread operation (LMDB is invoked within your application thread; no compactor thread is needed)
• Freedom from application-side data caching (memory-mapped files are more efficient)
• Multi-threading support (each thread can have its own MVCC-isolated transaction)
• Multi-process support (on the same host with a local file system)
• Atomic hot backups LmdbJava adds Java-specific features to LMDB:
• Extremely fast across a broad range of benchmarks, data sizes and access patterns
• Modern, idiomatic Java API (including iterators, key ranges, enums, exceptions etc)
• Nothing to install (the JAR embeds the latest LMDB libraries for Linux, OS X and Windows)
• Buffer agnostic (Java ByteBuffer, Agrona DirectBuffer, Netty ByteBuf, your own buffer)
• 100% stock-standard, officially-released, widely-tested LMDB C code (no extra C/JNI code)
• Low latency design (allocation-free; buffer pools; optional checks can be easily disabled in production etc)
• Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
• Actively maintained and with a "Zero Bug Policy" before every release (see issues)
• Available from Maven Central and OSS Sonatype Snapshots
• Continuous integration testing on Linux, Windows and macOS with Java 8, 11 and 14

   

EclipseLink is the open source Eclipse Persistence Services Project from the Eclipse Foundation. The product provides an extensible framework that allows Java developers to interact with various data services, including databases, XML, and Enterprise Information Systems (EIS). EclipseLink supports a number of persistence standards including the Java Persistence API (JPA), Java API for XML Binding (JAXB), Java Connector Architecture (JCA), and Service Data Objects (SDO).

There are various ways in which Java code can be executed. A complex Java application usually uses third party APIs or services. In this course, we list the most popular ways a piece of Java code may be packed together and/or executed.

JSE code execution

Java language first edition came out in the client-server era. Thick clients were developed with rich GUI interfaces. Java first edition, JSE (Java Standard Edition) had/has the following in its belt:

• GUI capabilities (AWT, Swing)
• Network computing capabilities (RMI)
• Multi-tasking capabilities (Threads)

This course is about Enterprise JavaBeans 2.1. It also covers EJB 2.0, which is still in widespread use. Just as the Java platform has revolutionized the way we think about software development, Enterprise JavaBeans has revolutionized the way we think about developing mission-critical enterprise software. It combines server-side components with distributed object technologies, asynchronous messaging, and web services to greatly simplify the task of application development. It automatically takes into account many of the requirements of business systems, including security, resource pooling, persistence, concurrency, and transactional integrity.

This course will show you how to use Enterprise JavaBeans to develop scalable, portable business systems. But before we can start talking about EJB itself, we'll need a brief introduction to the technologies addressed by EJB, such as component models, distributed objects, asynchronous messaging, and web services. It's particularly important to have a basic understanding of component transaction monitors, the technology that lies beneath EJB.

Understand the Gang of Four, architectural, functional, and reactive design patterns and how to implement them on modern Java platforms, like Java 12 and beyond

About

Java design patterns are reusable and proven solutions to software design problems. This course covers more than 60 battle-tested design patterns used by developers to create functional, reusable, and flexible software.

The hands-on design patterns with Java starst with an introduction to Unified Modeling Language (UML) and delves in class and object diagrams with the help of detailed examples. You will study concepts and approaches to the object-oriented programming (OOP) and OOP design patterns to build robust applications. As you progess, you explore the GOF design patterns categories, such as behavior, creational,and structural, which help you improve readability of codes and allow the reuse of large-scale software. You will also discover how to function effectively with microservices and sevreless architectures using the cloud patterns, each of them is explained completely and accompanied by real-world programming solutions.

At the end of the course, you will be able to speed up your software development process using the right patterns, and you will be comfortable working on scalable and maintainable projects of any size.

Content

• Understand the importance of design patterns for software engineering
• Visualize Software design with UML diagrams
• Strengthen your OOP understanding to create reusable software systems
• Discover GoF design patterns to develop scalable applications
• Examine programming challenges and the design that solve them
• Explore architectural patterns for micro-services and cloud development

Features

• Learn OOP, functional and reactive design patterns to create a readable and permanent code
• Explore architecture patterns and practices for the scalable and reliable applications
• Tackle all kinds of performance-related problems and streamline development using design patterns

Be an expert in the art of implementing scalable and raective microservices in your production environment with Java 11

About

Microsarvices are the key of designing scalable,  east-to-maintain applications. This latest edition of Mastering Microservices with Java, works on Java 11. It covers a wide range of new exclusive developments in the world of microservices, including patterns, interprocess communication with gRPC and service orchestrartion.

This course will help you understand how to implement microservice systems from scratch. You will begin with understanding the basic concepts and framework, before focusing on the high-level design of large software projects. You will then use the Spring Security to secure microservices and test them effectively using REST Java clients and other tools. You will also gain the experience of using the Netflix OSS suite, including the API Gateway, the service discovery, and registration, and the Circuit Breaker. In addition, you will be introduced to the best patterns, common practices and principles of microservice design that will help you understand how to troubleshoot and debug the problems encountered during development.

At the end of this course, you will have learned to build smaller, lighter and faster free services that can be easily implemented in a production environment.

Content

• Use domain-driven designs to develop and implement microservices
• Understand how to implement microservices using Spring Boot
• Explore the service correction and transactions distributed using Sagas
• Discover interprocessing communication using a statement of REpresentational State Transfer (REST)  and events
• Generate the knowledge of implementation and design reactive microservices
• Deploy and test various microservices

Features

• Use domain-driven designs build microservices
• Explore various microservices patterns such as the discovery of service, registration and gateway API
• Use the Kafka, Avro and Spring Current to implement events-based microservices

Build robust and reliable Java applications that work on the modern infrastructure such as containers and cloud, using the new features of Quarkus 1.0

About

Quarkus is a new Kubernetes-Native framework that allows Java developers to combine the power of containers, microservices, and cloud-native to build reliable applications. The course is a development guide that will teach you to build Java-native applicatio s using Quarkus and GraalVM.

We start by learning the basic concepts of a cloud-native application and its advantages on the standard company application. Then we move quickly to application development, by installing the necessary tools to build our first application on Quarkus. Then we will learn how to create a picture of our application containers and execute it in a Platform-as-a-Service environment, such as the Minishift. Later, we will build a complete real-world application that will use the REST and Contexts and Dependency injection stacks with the web frontend. We will also learn how to add database persistence to our application using PostgreSQL. We will learn to work with various API available in Quarkus such as the Camel, Eclipse Microprofile, and the Spring DI. Towards the end, we will learn advanced development techniques such as securing applications, application configuration, and working with non-blocking programming models using Vert.x.

At the end of this course, you will be competent with all the Quarkus and develop fast applications leveraging modern technology infrastructure.

Content

• Build a native application using Quarkus and GraalVM
• Secure your applications using Elytron and the Micproffile JWT extension
• Manage data persistence with Quarkus using PostgreSQL
• Use non-blocking programming model with Quarkus
• Learn to make the Camel and Infinispan in native mode
• Deploy an apllication in a Kubernetes-Native environment using the Minishift
• Discover the responsive programming with Vert.x

Features

• Build applications with a faster start time and low RSS memory using the latest Quarkus 1.0 features
• Effectively integrate imperative and responsive programming models to build modern Java application
• Discover efficient solutions to run Java on applications, microservices, containers, FaaS and the cloud

An enterprise Java developer's guide to learning JAX-RS, context and dependency injection, JavaServer Faces (JSF), and microservices with Eclipse MicroProfile using the latest features of Jakarta EE

About

Jakarta EE is widely used around the world for developing enterprise applications for a variety of domains. With this course, Java professionals will be able to enhance their skills to deliver powerful enterprise solutions using practical recipes.

This second edition of the Jakarta EE Cookbook takes you through the improvements introduced in its latest version and helps you get hands-on with its significant APIs and features used for server-side development. You'll use Jakarta EE for creating RESTful web services and web applications with the JAX-RS, JSON-P, and JSON-B APIs and learn how you can improve the security of your enterprise solutions. Not only will you learn how to use the most important servers on the market, but you'll also learn to make the best of what they have to offer for your project. From an architectural point of view, this Jakarta book covers microservices, cloud computing, and containers. It allows you to explore all the tools for building reactive applications using Jakarta EE and core Java features such as lambdas. Finally, you'll discover how professionals can improve their projects by engaging with and contributing to the community.

By the end of this course, you'll have become proficient in developing and deploying enterprise applications using Jakarta EE.

Content

• Work with Jakarta EE's most commonly used APIs and features for server-side development
• Enable fast and secure communication in web applications with the help of HTTP2
• Build enterprise applications with reusable components
• Break down monoliths into microservices using Jakarta EE and Eclipse MicroProfile
• Improve your enterprise applications with multithreading and concurrency
• Run applications in the cloud with the help of containers
• Get to grips with continuous delivery and deployment for shipping your applications effectively

Features

• Explore Jakarta EE's latest features and API specifications and discover their benefits
• Build and deploy microservices using Jakarta EE 8 and Eclipse MicroProfile
• Build robust RESTful web services for various enterprise scenarios using the JAX-RS, JSON-P, and JSON-B APIs

Learn how to build, test, and deploy enterprise-grade Java applications

About

Building web application has been a challenge for many Java developers because of the complexities of their software requirements, leading to a bloated and unmanaged framework library repository and configurations. Spring Boot 2.x, a feature-rich platform built from the Spring 5.x framework, is created by to help developers solve their complex problems with fewer configurations but with strong dependency management features.

In this course, you will learn how to create various modules in a Human Resources Information System (HRIS) such as employee timesheets, leave management, and profiling. You will use Spring Boot 2.x to create your HRIS app while integrating Spring Web MVC, Spring WebFlux, Spring Data, RESTful web services, and clients. Above all, you'll use the latest version of Spring Security—5.0—to secure your apps and OAuth 2.x to implement an OpenID connection. You'll apply reactive programming with its Spring Web Flux and Project Reactor features. Finally, you will deploy your apps and services using some popular cloud and container platforms such as Spring Cloud Foundry, Docker, and AWS.

By the end of the course, you will be confident in implementing the core features of Spring Boot 2.x to create scalable, optimal, and robust enterprise web applications.

All the related code files are placed on GitHub repository at: https://github.com/PacktPublishing/Modern-Java-Web-Applications-with-Spring-Boot-2.x

Content

• Create model view controller web applications with Spring Web MVC
• Create RESTful web services and consume them in web pages with Spring Web MVC
• Secure your applications and services with Spring Security
• Include social login in your applications with OpenID Connect
• Persist data with Spring Data and MongoDB
• Build reactive applications and services with Spring Web Flux and Project Reactor
• Build stream-based and reactive applications using Kotlin
• Use Spring Cloud Config to configure your application
• Creating API gateways using Spring Cloud
• Deploy your web applications and services to a PaaS provider

Features

• Covers the latest version of Spring Boot with up-to-date techniques and code examples to address customer and business needs
• Create, secure, and test your web applications and services quickly with minimal configurations via Spring Boot 2.x
• Effectively build web-based applications and microservices with less configuration and fewer managed libraries

Cut through the noise and get real results with a step-by-step approach to learn Java programming

About

You already know that you want to learn Java, and a smarter way to learn that Java 12 is to learn by doing. The Java Workshop focuses on the construction of your practical skills so that you can develop high performance Java applications that works perfectly in the JVM across web, mobile and desktop. You will learn real examples that lead to real results.

Throughout the Java Workshop, you will take a forward approach approaching being confident at understanding Java. You will not have to sit through a unnecessary theory. If you are running short, you can jump into one year every day or spend an entire weekend in learning on reactive programming and unit tests. This is your choice. Learn about your terms, you will accumulate and strengthen the key skills in a way that is sent.

Each physical copy of the Java Workshop unlocks access to the interactive edition. With videos detailing all the exercises and activities, you will always have a guided solution. You can also tell you about the evaluations, track progress and receive free content updates. You will even gain a secure identification information that you can share and check online at the end. It is a premium learning experience that is included with your printed copy. To exchange, follow the instructions at the beginning of your Java book. Easy right and direct, The Java Workshop is the perfect companion for Java beginners. You will build and iterate your code as a software developer, by learning along the way. This process means that you will find that your new skills are gathered, embedded as best practices. A solid base for the years to come.

Content

• Bring to GRIPS with fundamental concepts and conventions of Java 12
• Write a clean and well-commented code that is easy to maintain
• Debug and compile logical errors and manipulate exceptions in your programs
• Understand how to work with the games in the Java API and Java Streams
• Learn to use third-party libraries and software development kits (SDKs)
• Find out how you can work with information stored in databases
• Understand how you can retain data secure with cryptography and encryption
• Learn to keep your development process without bug with Java tests

Features

• Ideal for the Java beginner that starts at the first time
• A step-by-step Java tutorial and activities that help build key skills
• Structured to allow you to progress at your own pace, on your own terms
• Use your physical print copy to exchange free access to the interactive online edition