Java for the Real World

Understand how the Java Virtual Machine sits between compiled Java code and the operating system to enable multi-platform execution, plus six-month cadence and Oracle vs OpenJDK.

See how Java versions affect backwards compatibility and how code compiled on one version runs on others. Understand why choosing the target JVM version matters for deployment.

Learn why build tools matter for deploying Java apps, managing dependencies, and creating jar files. See how jars, fat and thin variants, and the classpath shape real-world builds.

Explore Ant, a legacy Java build tool, to compile code, run tests, and create build artifacts with flexible targets, then see how Ivy enables dependency management for Google Guava library.

Maven is a declarative XML-based tool that handles build and dependency management out of the box; it uses phases like compile, test, package, verify, install, and deploy.

Learn how a Maven POM file defines groupId, artifactId, version, packaging, and dependencies like Guava, and how mvn package builds a fat jar with the shade plugin.

Discover how Maven repositories store artifacts and how to access Maven Central and private repositories, including alternatives like JCenter and Artifactory.

Explore how Maven works out of the box, manages dependencies, and extends via plugins, while balancing complexity and the Maven way compared to Ant and Gradle.

Explore Gradle, a Groovy-based JVM build tool that uses a concise build.gradle, offers tasks like assemble, build, clean, jar, and test, and supports dependencies and the shadowJar fat jar workflow.

Prepare the IScream application for testing using JUnit with Maven or Gradle, structure tests under src/test/java, and validate JSON parsing with mock data and daily specials tests using mocky.io.

Learn how to write and run unit tests with JUnit, understand version differences between 4 and 5, and compare JUnit style with Hamcrest fluent assertions in Java projects.

Explore TestNG, an xUnit style framework like JUnit, with data providers for running tests against multiple data sets and an actual-then-expected assert order; it supports mvn test and gradle test.

Explore test doubles, including mocks and stubs, to replace external dependencies in unit tests. Create a mock DailySpecialService for MenuCreator and compare EasyMock, Mockito, and PowerMock.

Create a mock DailySpecialService with EasyMock, set expectations for getSpecials, enable the mock, inject it into MenuCreator, and verify the menu uses the daily specials without calling the internet.

Explore Mockito for Java: mock creation, when-thenReturn expectations, verification, and annotations like @Mock and @Spy with initMocks, plus stubs vs mocks and default behavior that avoids real network calls.

PowerMock enables mocking static methods, working with EasyMock or Mockito. Explore mocking DailySpecialService's isServiceAvailable() with mockStatic(), replay, and verify, and discuss when to prefer an instance method or framework-provided mocks.

Explore Spring Core and the broader Spring ecosystem, focusing on dependency injection to wire components. Compare xml configuration and annotations, and preview Spring Boot to streamline development.

Explore Spring XML configuration by wiring DailySpecialPrinter and DailySpecialService with bean definitions in applicationContext.xml. Bootstrapping uses ClassPathXmlApplicationContext and getBean to initialize and demonstrate dependency injection.

Explains configuring Spring with annotations, including @Component, @Service, and @Autowired on constructor, field, or setter; describes constructor injection for required dependencies, and annotation-based bootstrapping with AnnotationConfigApplicationContext and component scanning.

Externalize configuration using Java properties files to simplify deploying multiple environments, like dev, test, and production, by reading runtime values without changing code, using dot separated keys.

Learn how Spring uses @PropertySource and expression language to dynamically load environment-specific properties from prod and uat, via environment variables or Java system properties.

Learn how Spring Boot accelerates Java app development with starters, convention over configuration, and Spring Initializr to quickly assemble web, LDAP, security, and routing dependencies.

Explore how Spring Boot bootstraps applications via the static run method, enabling IDE or command-line execution, and manage runtime profiles with properties or YAML configurations across environments.

Explore Java web application frameworks like Spring MVC, Spring Boot, JSF, and Vaadin, and grasp the request–response flow through servlet containers and JSP views.

Spring MVC dominates Java web frameworks and uses POJOs with JSP views to implement a two-view, ice cream point-of-sale system that translates orders into prices.

Render a dynamic flavors dropdown in a Spring MVC view using JSP with JSTL and expression language, and forEach to iterate the flavors collection and display each value via toString.

Explore how Spring MVC controllers use @Controller and @RequestMapping to manage models, pass flavors and toppings to the new-order view, and bind form data to an order with @ModelAttribute.

Configure a Spring MVC app using XML or Java configuration with WebConfig, mapping views via a prefix and suffix. Compare deployment via servlet container or embedded container with Gradle.

Explore Spring Boot's zero-config web development with starters on your Gradle or Maven project, using Spring MVC and Thymeleaf for rapid, browser-ready views.

Explore JavaServer Faces as a UI-focused MVC framework that handles controller logic with managed beans and scopes: application, session, and request—while you focus on views and models.

Discover how a JavaServer Faces app uses an application-scoped IngredientsService and a managed Order bean to bind flavors, calculate price with Ajax, and render results.

Explore Vaadin, a server-side framework that generates front-end code, letting Java developers build desktop-like web apps. Understand Vaadin 8 to 10 fork and the shift from GWT-based to component-based approaches.

Learn to build Vaadin 8 views by composing components in vertical and form layouts, wiring a submit button to create an order from flavor, scoops, and toppings, and show details.

Discover how Vaadin 8 UIs route and render views with setContent, using the View interface to display the order screen, and manage theming with the Valo theme and SCSS.

Learn how web applications deploy to an application server, package as WAR or EAR, and manage code with Gradle or Maven, using folder drop or GUI deployment.

Learn to deploy Java web applications by packaging as war and ear, using docker to run Tomcat or JBoss WildFly, and deploying via webapps or deployments folders.

Explore how to access and modify data in a database using JDBC basics and frameworks, covering connections, prepared statements, result sets, and CRUD data operations with SQL time types.

Explore spring's JDBC template, a low-level, thread-safe database option backed by a data source, with dependency injection and a data model of ingredients, flavors, and toppings.

Pull data from the database using Spring JdbcTemplate and RowMapper to map results to Flavor and Topping, and use prepared statements to prevent SQL injection.

Save orders with Spring JDBC Template by using a GeneratedKeyHolder and PreparedStatementCreator to obtain the order id and save line items within a transactional scope.

Demonstrate saving an order to an in-memory H2 database using Spring Boot, and explore purchases, line items, ingredients, toppings, and flavors via the H2 console.

Discover how MyBatis bridges SQL and object mapping using reflection, with SqlSession as the unit of work; learn configuration tips and the benefits of Spring integration for thread safety.

Explore how MyBatis uses an XML mapper and a backing Java interface to read data, with a namespace, select statements, @Param for id, and automatic implementation of the mapper.

Learn how to write data with MyBatis by inserting a purchase and its line items, returning generated ids, and handling order and line items in a single transaction.

Discover how MyBatis dynamic SQL streamlines in-clause queries with foreach and builds optional where conditions using the where tag, which trims off the leading 'and' when it's the first condition.

Illustrates a spring boot web application in action, placing an order on the new order page and saving it as a purchase with its line items in the h2 console.

Explore Hibernate, a popular object-relational mapper that abstracts SQL and maps domain objects to database tables. Learn configurable options using XML or annotations, and how JPA compatibility shapes Hibernate usage.

Discover how JPA annotations map objects to tables, define primary keys with @Id and @Column, and manage relationships with @ManyToOne, @OneToMany, @JoinColumn, fetch types, mappedBy, and cascade settings in Hibernate.

Explore how Hibernate uses the entity manager to save data with persist, update with merge, and delete with remove, including a single-line order save in a Spring context.

Hibernate provides three retrieval methods: criteria, HQL, and native SQL, each with trade-offs in typing and readability; the lecture shows filtering ingredients by type and returning ingredient lists.

Explore how Java logging evolved from bare System.out/err to frameworks like log4j and JUL, and how logging facades such as Apache Commons Logging and SLF4J shape cross-framework support.

Explore java.util.logging, the java logging framework built into the standard library. Create loggers, log at multiple levels, and configure file and console handlers and properties to control formatting and output.

Explore log4j, a Java logging framework, and how to use loggers, appenders, and per-package levels. Learn configuration options in xml, json, properties, or yaml, plus console and rolling file appenders.

Explore logback, the successor to log4j, configured via XML or groovy, using appenders, root and debug loggers, slf4j API, and pattern-based, parameterized logging.

Learn how a logging facade decouples code from the backend, using SLF4j as the front end to bridge to log4j2 and other implementations.

Explore the java commons logging project (jcl) as a facade bridging to log4j with yaml configuration, and note lack of parameterized messages and fatal level versus slf4j.

Wrap up this high-level java overview by directing learners to GitHub samples, Hibernate examples (annotations or XML), and the accompanying book for deeper, hands-on learning.