Overview
This is a fast-paced course for C# coders who are converting to Java / JEE application development. By the end of the course, delegates will be able to program using all the features of Java 8, enhance their development with the most modern Java features and build server-side infrastructure using both JEE specifications (such as JAX-RS and JPA) and popular open source frameworks (such as Spring Boot and JOOQ). There is also a strong focus on continuous testing and deployment via Agile tools such as Gradle, JUnit and Mockito.
Each topic in the course is introduced in terms of the corresponding .NET technology, enabling delegates to leverage their existing skills and make the transition rapidly. The amount of Java language training included depends on the core previous experience of the delegates. Please note that topics listed below are representative of a typical delivery, but can be tailored based on the projects the delegates will be moving to. For example, Hibernate might be substituted for JPA, JEE CDI for Spring Core and JAX-RS for Spring MVC. By default, the course uses IntelliJ but alternatives, such as the Eclipse IDE, can be supported if required.
Outline
Fundamental Concepts of Java / JEE
- Making sense of the distinction between JSE and JEE
- Comparing Bytecode to Intermediate Language
- Comparing the Java Virtual Machine to the CLR
- Comparing Java Archives to .NET Assemblies
- The role of JEE Containers and the JEE Architecture
- Microservices and Cloud Computing in JEE and .NET
- The importance of open source frameworks to JEE
Building Java / JEE Applications using IntelliJ (or Eclipse)
- How IntelliJ is built around SWT, OSGi and plugins
- Working with perspectives, views, editors and actions
- Writing standalone programs and simple JEE components
- Making the most of the support for code generation
- Refactoring and Unit Testing your code within IntelliJ
- An overview of writing your own refactoring plug-ins
Converting to Java (Part 1)
- The core Java syntax and type system
- The package hierarchy and classpath
- Similarities in selection and iteration
- Similarities when working with arrays
- Comparing the Java and .NET object models
- Class declarations in Java verses in C#
- Key differences in the use of interfaces
Converting to Java (Part 2)
- Properties as accessors and the JavaBean conventions
- The typesafe enum pattern and its integration into Java
- Using inner classes rather than delegates for event handling
- The theory of compiler checked exceptions and proper usage
- Non-reified generics, type erasure and bounded wildcards
- Creating and decorating your code with annotations
- Using compiler plugins to extend the language
Converting to Java (Part 3)
- Making basic use of the standard collections
- Working with the newer thread safe collections
- Functional programming in Java 8 versus .NET LINQ
- Declaring and working with lambdas and method refs
- Using the streams API as your 'functional toolkit'
- Idioms for getting maximum performance from streams
- Using streams outside of the standard collections
- Using parallel streams for simplified concurrency
An Overview of the Key Java Libraries
- Investigating types using the reflection library
- Performing file I/O, basic networking and multicasting
- Writing concurrent code using executors and futures
- Working with localised dates and times in Java 8
Building Standard JEE Web Applications
- Deploying WARs and EARs into a JEE Container
- Writing Servlets and using the Servlets API
- Creating control-based UIs via JSF and Facelets
- Injecting dependencies via annotations like @Resource
Using the Java Persistence API (JPA)
- How the JPA evolved from tools like Hibernate and Toplink
- The concept of a Persistence Unit and its role in JEE Design
- Creating basic entity classes and building Persistence Units
- Using annotations to define embedded types and many-to-one links
- Using annotations to map collections of basic types and entities
- How entities move between the transient, persistent and detached states
- Using the EntityManager API to more entities between states
- Writing parameterised queries via JPA-QL and CriteriaBuilder objects
- Combining JPA with Generics to create a universal DAO base class
Dependency Injection In Spring
- Declaring Spring beans via @Component and @Service
- Dependency injection by type using @Autowired
- Injecting by name using @Autowired and @Qualifier
- Specifying the scope of a bean and lifecycle methods
- Customising dependency injection via Spring EL
Building MicroServices via Spring MVC and Boot
- Declaring RESTful services via Spring MVC
- Associating methods with HTTP verbs and MIME types
- Marshalling content to and from XML and JSON
- Customising the response and handling errors
- Accessing the services via an Angular UI
- Injecting services into the REST controllers
- Simplifying database access via Spring Data JPA
- Deploying the application via Spring Boot
- Unit and integration testing the application
Additional JEE Specs and Frameworks
- JAX-RS as a standardised alternative to Spring MVC
- JOOQ as a simpler, more performant alternative to JPA
- Writing SOAPy Web Services via JAX-WS and JAXB
- Using JMS to interact with Messaging Servers
- The JTA and managing transactions in JEE
Requirements
- Delegates must be proficient C# or VB .NET developers, ideally with several years commercial programming experience