Get $1 credit for every $25 spent!

Mastering Java & Spring Framework Essentials Bundle

Ending In:
Add to Cart - $24.99
Add to Cart ($24.99)
$800
96% off
wishlist
Courses
4
Lessons
230

What's Included

Product Details

Access
Lifetime
Content
2.0 hours
Lessons
61

JUnit & Mockito Unit Testing for Java Developers

Test Java Applications Using JUnit, Mockito, & Hamcrest

By Matt Speake | in Online Courses

Do you want to get hands-on demonstrations of JUnit and Mockito in action, want a simple no-fluff guide to how unit testing works, including getting an understanding of best practices along the way? This course packs all the good stuff that's been distilled down through the years - it's the best practice and gets you up and running with knowing the stuff the APIs don't tell you. This course covers writing tests with JUnit and mock objects-based unit tests with Mockito. You'll also learn how to harness the power of Hamcrest to do more powerful assertions.

4.7/5 average rating: ★ ★ ★ ★

  • Access 61 lectures & 2 hours of content 24/7
  • Write unit tests confidently using JUnit
  • Appreciate mocking & mock objects
  • Use Mockito to create test fixtures, stub methods by programmatic & annotation-driven test setup
  • Analyze production code to guide writing unit tests
  • Gain an appreciation of the JUnit Assertions API
  • Understand modern unit testing concepts & best practices
  • Write assertions using Hamcrest
Matt Speaker | Java Technologist & Trainer
4.3/5 Instructor Rating: ★ ★ ★ ★

Matt Speake is a professional software engineer specializing in Java technologies. He has over 20 years of experience working everywhere from small startups to large global corporations and is the principal trainer at Zention in the UK.

Important Details

  • Length of time users can access this course: lifetime
  • Access options: desktop & mobile
  • Certificate of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Updates included
  • Experience level required: beginner

Requirements

  • Some knowledge of coding in Java to at least a basic level

Course Outline

  • Your First Program
  • Unit Testing Foundations
    • Overview of the Course Structure - 1:34
    • What is Unit Testing? - 2:45
    • Introducing a Simple Unit Test in JUnit - 3:02
    • Structure of a Unit Test - 5:08
    • Conventions for Writing Unit Tests - 2:41
    • Characteristics of Proper Unit Tests - 5:48
  • Creating a Java Project which uses JUnit
    • 01 - Section Introduction - 0:49
    • Creating a Java project which includes JUnit using the Maven Quickstart Archetype - 2:51
    • Introducing a typical Java project structure (production vs test source trees) - 2:47
    • Understanding the basic conventions for creating unit tests (package and naming conventions) - 3:42
    • 01 - Section Introduction - 0:36
  • Writing and Running Unit Tests with JUnit and IntelliJ IDEA
    • Section Introduction - 0:52
    • Creating a test method with the @Test annotation - 1:39
    • Running a unit test within the IDE and understanding test success - 1:21
    • Understanding test failures with exceptions - 2:21
    • Failing a unit test explicitly with Assert.fail - 0:45
    • Using Assert.fail to check validation logic in a try:catch - 2:23
    • An introduction to the JUnit Assertions API
    • Structuring unit tests with Arrange:Act:Assert - 2:04
    • Understanding execution of assertions and JUnit's fail-fast test failure mechanism - 3:28
    • Adding descriptive comments to assertions and test failures to aid diagnostics - 0:48
    • Coding a unit test following Arrange-Act-Assert - 1:12
    • Keeping test setup DRY with @Before - 4:55
    • Understanding test fixture instantiation - 2:14
  • Unit Testing with Mock Objects and Mockito
    • What is Mockito and what are Mock Objects? - 3:58
    • Introduction to testing with mock objects - 4:56
    • Configuring Projects to Use Mockito - 2:45
    • Creating a project which uses JUnit and Mockito - 4:07
    • Coding a Layered Architecture - Presentation Layer - 3:26
    • Coding a Layered Architecture - Business Layer - 3:32
    • Coding a Layered Architecture - Persistence Layer - 4:11
    • Putting the correct packages in place to respect the layering - 2:44
    • Writing a test for the Login Controller in the presentation layer - 9:48
    • Understanding the test fixture setup when writing mock object based unit tests - 1:01
    • Writing a test for the Authentication Service in the business layer - 3:57
    • Thinking about design decisions when unit testing - 0:38
  • Looking at the Hamcrest Assertions Library
    • Section Introduction - 0:58
    • Evolving the Domain and Repository Classes - 6:36
    • Ignoring Tests with @ignore - 4:17
    • Implementing a Finder in the Repository - 0:57
    • Implementing Business Logic in the Service - 3:13
    • Configuring Maven to use Java 8 - 2:32
    • Evolving the Repository Class - 1:32
    • Adding a Parameter-driven Finder to the Service - 1:34
    • Refactoring to Evolve a New Service - 1:16
    • Generating Test Methods in the IDE and Toggling Between Production and Test Code - 1:26
    • Introducing the JUnit Mockito Runner and @Mock - 1:04
    • Analyzing the Production Code to Determine How to Write the Arrange Section - 3:58
    • Using Mockito's @InjectMocks to Create the System Under Test with it's Dependencies - 1:33
    • Keep Yourself Motivated by Checking the Happy Path Test Output - 2:06
    • Using the JUnit Assertions API to write the Assert Section - 5:17
    • Thinking About the Weaknesses of the JUnit Assertions API - 1:59
    • The Importance of Checking Your Work as you Go - 2:29
    • Upgrading a JUnit project to use the full Hamcrest version - 3:11
    • Replacing JUnit assertions with Hamcrest assertions and using assertions with collections - 2:12
    • Understanding and Reading Hamcrest Test Failures - 2:46
    • Quick thoughts on Hamcrest individual vs collection Assertions - 0:29
    • Don't invoke unneeded production code in your test classes - 1:01
    • Understanding Evaluation of Hamcrest Matchers - 1:17
    • Thinking about why we keep production code to a minimum in tests - 1:19
    • Creating Complex Hamcrest Assertions with allOf and Property Matchers - 4:32

View Full Curriculum


Access
Lifetime
Content
2.0 hours
Lessons
48

Spring Boot Essentials

Take Your Spring Productivity to the Next Level by Mastering Spring Boot

By Matt Speake | in Online Courses

If you like to master what actually happens inside a Spring Boot application and start your journey with the most important technology to hit Java enterprise development since the Spring Framework itself was launched, then this is the course for you. It takes you on a fascinating step-by-step journey into how Spring Boot applications work. In this way, you get an excellent foundational basis of Spring Boot, understanding that will have you in good stead so you'll feel at ease exploring further and tapping into the amazing power that this versatile and powerful platform offers.

New course!

  • Access 48 lectures & 2 hours of content 24/7
  • Understand the foundations of the Spring Boot platform & its operation
  • Create & build Spring Boot projects
  • Examine existing Spring Boot projects & be able to step through and reason about how the app works
  • Understand layered architecture basics
  • Know how starter dependencies work & be able to create projects out of various technologies using these
  • Learn how autoconfiguration works & understand how to use and troubleshoot it where required
Matt Speaker | Java Technologist & Trainer
4.3/5 Instructor Rating: ★ ★ ★ ★

Matt Speake is a professional software engineer specializing in Java technologies. He has over 20 years of experience working everywhere from small startups to large global corporations and is the principal trainer at Zention in the UK.

Important Details

  • Length of time users can access this course: lifetime
  • Access options: desktop & mobile
  • Certificate of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Updates included
  • Experience level required: intermediate

Requirements

  • Prior knowledge of the basics of Spring is helpful but not essential
  • At least a minimal knowledge of Java development experience is assumed

Course Outline

  • Introduction
    • Welcome to the Course! - 1:06
  • Getting Started
    • Section Introduction - 0:35
    • Creating a Spring Boot Application with Spring Initilizr - 12:11
    • Exploring a Spring Initilizr Generated Spring Boot Project - 4:26
    • Using Maven with Spring Boot - 5:45
    • Using Gradle with Spring Boot - 11:06
    • Running and Debugging Spring Boot Apps in the IDE - 6:06
    • Understanding Layered Architecture in Spring Applications - 6:36
    • Important Spring Boot Resources You Should Know - 4:07
  • Taking a Tour of a Sample Spring Boot Application
    • Section Introduction - 0:17
    • Downloading Spring Pet Clinic - 1:21
    • Building the Sprint Pet Clinic Application - 1:11
    • Running the app and taking a tour of the application - 2:05
    • Examining the project and it's dependencies in the IDE - 3:31
    • Examining the controllers and web layer - 2:26
    • Examining the repositories and data layer - 1:18
    • Examining the startup of a Spring Boot application - 1:06
    • Examining the application properties, logging configuration and profiles - 2:34
    • Summing Up the essence of how a spring boot application works - 1:25
  • Understanding Starter Dependencies
    • Section Introduction - 0:19
    • Understanding Spring Boot Starter Dependencies and their resolution - 6:12
    • Relating the Spring Boot dependency graph within your IDE - 2:52
    • Looking at the Flattened Resolved Dependencies Set - 1:22
    • Changing the Starter Dependency to Bring in a Different Spring Boot Technology Stack - 1:53
    • The Relationship of Starter Dependencies with Autoconfiguration - 0:55
  • Understanding Autoconfiguration
    • Section Introduction - 0:23
    • How Spring Boot Creates the Spring Application Container - 2:08
    • How @SpringBootApplication Configures a Spring Boot App - 1:58
    • Spring Factories for Autoconfigured Libraries - 2:27
    • Understanding a Typical Autoconfiguration - 4:25
    • Property Injection in Autoconfiguration Classes - 0:57
    • Understanding Conditions and Excluding and Overriding Autoconfiguration - 5:58
    • Debugging Autoconfiguration by Enabling Autoconfig Reporting - 2:24
  • Understanding Spring Boot Properties
    • Section Introduction - 0:14
    • Common Properties in Spring Boot Which You Can Configure - 7:26
    • Injecting Properties into Spring Managed Beans - 4:23
    • Providing Default Values for Properties - 0:43
    • Overriding Properties at Runtime with System Properties - 1:39
    • Specifying Properties in YAML File Format - 1:53
    • Accessing Nested Properties and Strongly-Typed Property Values - 1:25
  • Exploring Startup of a Spring Boot Application
    • Section Introduction - 0:33
    • Examining a Foundational Spring Boot Project - 3:19
    • Registration of Important Spring Application Listeners - 4:58
    • Preparing and Establishing the Spring Application Context - 2:22
    • Creating the Beans of the Spring Runtime - 3:38
    • Creating the Embedded Tomcat Web Server - 0:53
    • Publishing Spring Events to Application Listeners - 0:48
  • Wrapping Up
    • Thanks! - 0:54

View Full Curriculum


Access
Lifetime
Content
5.0 hours
Lessons
90

Mastering Spring Framework Fundamentals

Master the Essential Everyday Aspects of the Spring Framework to Boost Your Development Career

By Matt Speake | in Online Courses

This course takes you headfirst into the exciting world of Spring development! You'll get to know and understand the major parts of the core framework, such as the Spring container, dependency injection, proxies, profiles, and more. Spring is the most in-demand skill for Java developers beyond a knowledge of the Java programming language itself. In this course, you'll be up and running and be able to confidently work with existing Spring applications and have the confidence to start building your own from the ground up.

4.6/5 average rating: ★ ★ ★ ★

  • Access 90 lectures & 5 hours of content 24/7
  • Use confidently use the Spring framework container in the workplace
  • Gain a deep practical understanding of the concepts of dependency injection, inversion of control & autowiring and the Spring container
  • Understand and be able to use XML, annotation-based & Java based configuration
  • Learn how the Spring container is used in modern Java applications
  • Use properties in Spring applications
  • Apply profiles in Spring applications to manage environment-specific property sets
  • Use & apply Spring Aspects to tackle cross-cutting project concerns
Matt Speaker | Java Technologist & Trainer
4.3/5 Instructor Rating: ★ ★ ★ ★

Matt Speake is a professional software engineer specializing in Java technologies. He has over 20 years of experience working everywhere from small startups to large global corporations and is the principal trainer at Zention in the UK.

Important Details

  • Length of time users can access this course: lifetime
  • Access options: desktop & mobile
  • Certificate of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Updates included
  • Experience level required: beginner

Requirements

  • Understand Java to at least a basic level
  • Understand basic concepts of object oriented programming

Course Outline

  • Introduction
    • Welcome to the Course! - 1:37
  • Getting Started
    • Section Introduction - 0:30
    • Key Spring Resources you Need to Know - 4:39
    • Configuring a project's dependencies to use Spring - 5:15
    • Adding the Spring BOM to Better Manage Dependency Versions - 5:16
  • Creating the Spring Container with Application Contexts
    • Section Introduction - 0:36
    • A Look at the Application Context (aka The Spring Container) - 10:30
    • Creating the File System XML Application Context - 4:21
    • Configuring Autocomplete when Writing Spring XML Configuration Files - 2:53
  • Creating, Retrieving and Using Spring-Managed Beans
    • Section Introduction - 0:46
    • Creating a Bean Managed with Spring's XML Container Configuration - 2:21
    • Retrieving and Using a Bean from the Spring Container - 2:43
    • Using the Classpath XML Application Context - 2:06
    • Understanding Singleton Scope - 2:18
    • Understanding Prototype Scope - 3:26
    • Understanding How Spring Creates Stateless Beans - 1:03
  • Understanding Dependency Injection and Inversion of Control
    • Section Introduction - 1:04
    • Coding Beans to Use Constructor Dependency Injection - 3:55
    • Interpreting a Spring Container Exception - 1:16
    • Applying Constructor Dependency Injection to XML Configuration - 2:26
    • Verifying the Constructor Dependency Injection with the Debugger - 1:55
    • The Sharability of Beans in an IoC Container - 1:40
    • The Benefits of Dependency Injection in an IoC Container - 1:31
    • The Hollywood Principle - 2:12
    • Coding Beans to Use Setter Dependency Injection - 1:35
    • Applying Setter Dependency Injection in XML Configuration - 1:45
    • Verifying the Setter Dependency Injection with the Debugger - 1:22
  • Autowiring Dependencies in the Spring Container
    • Section Introduction - 0:33
    • Adding Component Scanning to Autodetect Spring Managed Bean Annotations - 2:33
    • Coding Beans to be Automanaged and Autowired by Spring via Annotations - 1:28
    • The Advantage of Annotation-based Configuration over XML Configuration - 0:28
    • Verifying the Annotation-driven Autowired Beans - 1:22
    • Spring's Stereotype Annotations for Better Code Readability - 1:31
    • Setter Dependency Injection with Annotations - 0:41
    • Constructor Dependency Injection with Annotations - 1:38
    • Using the Annotation-Based Application Context - 1:14
    • Creating a Java Configuration Class - 1:42
    • Applying Java-based configuration with @Bean - 5:01
    • Using Scopes with Java-based Configuration - 2:30
    • Modeling a More Complex Application to Demonstrate Autowiring Ambiguity Issues - 7:27
    • Resolving Ambiguous Arguments of the Same Type by Narrowing the Reference Type - 4:04
    • Resolving Ambiguous Arguments of the Same Type by Using @Qualifier - 1:42
  • Using Properties and Profiles in Spring Projects
    • Section Introduction - 0:31
    • Injecting Properties read from a Properties File with @Value in Spring Managed Beans - 3:43
    • Exploring Property Overriding in Spring - 2:40
    • Accessing and using properties with PropertyPlaceholder in XML Configuration - 1:47
    • Specifying default properties for property values - 1:15
    • Exceptions for Missing property keys in Spring - 0:34
    • Resolving and Using a Property Value in a Bean definition in XML Configuration - 1:30
    • Accessing the Current Active Profiles with the Environment interface - 4:17
    • Setting the current active profile programmatically and through a property switch - 1:06
    • Creating Profile-specific bean configuration - 3:47
    • Conditional Beans with @Profile - 5:46
  • Getting to Know the Spring Container
    • The Proxy Design Pattern - 6:18
    • Seeing Proxies in Action - 1:14
    • The Disadvantages of a Regular Proxy - 2:19
    • Understanding JDK Dynamic Proxies - 9:47
    • Dynamic Proxies in Spring - 5:08
    • Understanding How Spring Makes Service Methods Transactional using Proxies - 9:23
    • Spring Managed Bean Lifecycle Callback Methods - 5:41
    • JDK Standard Lifecycle Annotations (@PostConstruct and @PreDestroy) - 2:24
    • The Sequence of Spring Container Callbacks on a Spring Managed Bean - 1:19
    • Application Container Callbacks and Events - 6:26
    • Using the Aware Interfaces to Access Lower-Level Spring Framework Components - 6:11
  • Accessing Databases with Spring
    • Creating and Configuring Data Sources - 7:29
    • Creating a Data Acces Object to Access a Database - 3:28
    • Connection Pool Data Sources in Spring - 3:07
    • Creating a JDBC Template to Access a Database - 4:59
    • Using JDBC Templates to Insert and Query Data - 5:43
    • Using JDBC DAO Support to Remove Boilerplate JDBC Code - 6:51
  • Aspect Oriented Programming in Spring
    • Preparing a Spring Project to Use Aspects - 5:44
    • Creating a Spring Managed Bean to be Intercepted - 2:20
    • Advising Beans in Spring - 3:08
    • Understanding Pointcuts and Joinpoints - 3:21
    • Accessing Joinpoints Programmatically within an Aspect - 3:00
    • Coding Dynamic Advice with Around - 6:23
  • Web Application Development in Spring
    • Preparing a Maven Project to Use Spring MVC - 5:20
    • Registering the Dispatcher Servlet as Front Controller - 7:13
    • Creating the Web Application Context - 2:03
    • Creating a Controller Class - 1:06
    • Configuring the Jetty Plugin in Maven to Run a Web App - 6:40
    • Setting Up Remote Debugging of a Web App - 5:41
    • Understanding the Dispatcher Servlet Processing Flow - 5:39
    • Writing a Controller to Service Web Requests - 3:19
    • Rendering a JSP-Based View with View Resolvers - 6:21
    • Understanding How a Request is Serviced - 8:11
    • Passing a Model to the View for More Dynamic Pages - 4:16
    • Injecting the HTTP Servlet Request and Response into a Controller - 1:40
    • Passing Request Parameters and Query Strings to a Controller - 2:00
    • Using Path Variables to Access Parts of the Request Path - 2:14

View Full Curriculum


Access
Lifetime
Content
2.0 hours
Lessons
31

Mastering Java 8 Fundamentals

Harness the Power of the Java 8 Platform & Functional Programming with Java Lambdas, Java Streams, and More!

By Matt Speake | in Online Courses

This course is a concise, no-nonsense guide to Java 8, which explains just enough detail so that you can absorb and understand the core concepts and get you up and running quickly and effectively with coding in Java 8. It takes you from knowing nothing about Java 8, assuming just an intermediate level knowledge of Java, and takes you through each concept in the Java 8 platform, step by step, from first principles.

4.3/5 average rating: ★ ★ ★ ★

  • Access 31lectures & 2 hours of content 24/7
  • Gain a sound foundational understanding of the main Java 8 concepts
  • Use & apply lambda expressions and be able to write your own
  • Use & write functional interfaces and work with them in functional code
  • Understand optionals & the optionals API for guarding against null pointer exceptions
  • Understand the basics of streams & be able to process collections with them by forming a pipeline to map, filter and collect elements
  • Read & understand modern functional code written using the Java 8 constructs
  • Appreciate other aspects such as default & static methods, why they're introduced and how they work
Matt Speaker | Java Technologist & Trainer
4.3/5 Instructor Rating: ★ ★ ★ ★

Matt Speake is a professional software engineer specializing in Java technologies. He has over 20 years of experience working everywhere from small startups to large global corporations and is the principal trainer at Zention in the UK.

Important Details

  • Length of time users can access this course: lifetime
  • Access options: desktop & mobile
  • Certificate of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Updates included
  • Experience level required: beginner

Requirements

  • Intermediate level Java programming knowledge

Course Outline

  • Introduction
    • Welcome to the Course - 0:27
    • Introduction- Java 8 Theory and Examples Section - 0:45
    • Difference Between Object-Oriented and Functional Programming Styles - 4:08
    • A Quick Look at the Main Java 8 Features - 6:18
  • Lambda Expressions and Functional Interfaces
    • Lambda Expressions- Syntax and Examples - 3:13
    • Passing Behaviour with Lambda Expressions - 3:34
    • An introduction to Functional Interfaces with Examples - 2:36
    • Using Function Descriptors to Choose Compatible Target Types - 4:25
  • Pipelines and Streams
    • An Overview of Streams, Intermediate and Terminal Operations - 4:19
    • Understanding Pipeline Collection Processing and Stream API Common Operations - 7:43
  • Other Features
    • What is an Optional and How Are They Used - 5:01
    • Understanding the Optionals API - 5:55
    • Mapping and Filtering with Optionals - 3:54
    • Understanding Default Methods - 6:11
    • Understanding Method References and Their Different Types - 9:29
  • Java 8 Coding Demos: Lambda Expressions and Functional Interfaces
    • Introduction- Java 8 Coding Demos Section - 0:30
    • A Look at the Functional Interfaces API - 5:08
    • Coding and Referencing a Simple Lambda Expression - 5:35
    • Refactoring a Lambda Expression by Adapting an Existing Functional Interface - 4:38
    • Providing Alternative Functional Interface Target Types for a Lambda Expression - 1:57
    • Refactoring a Lambda Expression with its Method Reference - 2:53
    • Coding with the Consumer Functional Interface - 1:55
    • Coding with the Supplier Functional Interface - 1:52
    • Coding with the Function Functional Interface - 2:21
    • Coding with the Predicate Functional Interface - 4:59
  • Java 8 Coding Demos: The Stream API
    • Coding a Collection of Domain Classes for Stream Processing - 7:11
    • Coding with the Streams API to Process a Complex Collection - 7:42
  • Java 8 Coding Demos: Other Features
    • Coding with Bound and Unbound Instance Method References - 6:18
    • Coding with Static Method References - 2:01
    • Coding with Constructor Method References - 1:48
  • Wrapping Up
    • Well Done and Thanks - 0:27

View Full Curriculum



Terms

  • Unredeemed licenses can be returned for store credit within 30 days of purchase. Once your license is redeemed, all sales are final.