Key Points

1. Spring saves work but adds work - need to fit to use cases

2. JHipster is a development platform to generate, develop and deploy Spring Boot + Angular / React / Vue Web applications and Spring microservices.

3. JHipster is open-source

References

Key Concepts

Spring Training resources

https://www.udemy.com/course/microservices-with-spring-boot-and-spring-cloud/learn/lecture/8004660#overview

Spring Concepts

https://howtodoinjava.com/

Spring Framework

1. Spring 5 Tutorials
2. Spring Core Tutorials
3. Spring Boot Tutorials
4. Spring Batch Tutorials
5. Spring Cloud Tutorials
6. Spring AOP Tutorials
7. Spring MVC Tutorials
8. Spring Security Tutorials
9. Spring ORM Tutorials
10. Spring REST Tutorials
11. Spring WebFlux Tutorials

Spring Core

Dependency Injection, AOP, beans

1. Spring Bean Java Config Example
2. Spring Bean XML Config Example
3. Spring Bean Eager vs Lazy Initialization
4. Spring bean scopes

Spring Boot

https://howtodoinjava.com/spring-5-tutorial/

https://spring.io/blog/2013/08/06/spring-boot-simplifying-spring-for-everyone

We are pleased to announce the first milestone release of a new project called Spring Boot.

Spring Boot aims to make it easy to create Spring-powered, production-grade applications and services with minimum fuss. It takes an opinionated view of the Spring platform so that new and existing users can quickly get to the bits they need. You can use it to create stand-alone Java applications that can be started using ‘java -jar’ or more traditional WAR deployments. We also provide a command line tool that runs ‘spring scripts’.

The diagram below shows Spring Boot as a point of focus on the larger Spring ecosystem. It presents a small surface area for users to approach and extract value from the rest of Spring:

The primary goals of Spring Boot are:

• To provide a radically faster and widely accessible ‘getting started’ experience for all Spring development
• To be opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults
• To provide a range of non-functional features that are common to large classes of projects (e.g. embedded servers, security, metrics, health checks, externalized configuration)

Spring Boot does not generate code and there is absolutely no requirement for XML configuration.

Spring Scripts

Spring Boot ships with a small command line application that can be used to run ‘spring scripts’. Spring scripts are written in Groovy, which means that you have a familiar Java-like syntax, without so much boilerplate code. We are able to deduce a lot of information simply by looking at the way you have written your script. For example, here is a simple web application:

@Controller
class ThisWillActuallyRun {

    @RequestMapping("/")
    @ResponseBody
    String home() {
        return "Hello World!"
    }

}

When you run this application using ‘spring run webapp.groovy’ a number things are happening:

• Your script is enhanced with common ‘import’ statements to save you typing them
• We recognize the @ResponseBody annotation and download appropriate Spring JARs
• We automatically create the Spring @Configuration that you would otherwise need to write
• We start up an embedded servlet container and handle incoming requests on port 8080

The command line tool recognizes a number of different types of Spring Applications, including Web, Batch and Integration. There are a number of samples available in the GitHub repository.

Spring Boot with Java

You don’t need use the command line tool or write Groovy code to get the benefits of Spring Boot. We also have first class Java support. For example, here is the same application written in Java:

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;

@Controller
@EnableAutoConfiguration
public class SampleController {

    @RequestMapping("/")
    @ResponseBody
    String home() {
        return "Hello World!";
    }

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SampleController.class, args);
    }
}

Other than import statements, the main difference between this example and the earlier Groovy script is the main() method that calls SpringApplication and the @EnableAutoConfiguration annotation.

Obviously with Java you also need a build system to compile and package your code. We provide a number of convenient ‘starter’ POMs that you can use with Maven, Gradle or Ant+Ivy to

Getting Started with Spring Boot and Spring Cloud

https://www.udemy.com/course/microservices-with-spring-boot-and-spring-cloud

JUST - new CLI for Spring Boot

https://www.infoq.com/news/2023/01/just-spring-boot-cli/

JUST getting started docs

https://just.maciejwalkowiak.com/docs/getting-started/

Just, a command line tool requiring zero configuration, increases the Java development experience while building Spring Boot applications. Just automatically reloads the application when there is a change in source code, build files or Docker compose files. The project also supports the creation of (native) applications and (native) Docker images.

Maciej Walkowiak, Freelance Architect & Developer, released Just exactly eleven months after the first commit. Just itself is a Spring Boot application compiled to a native binary which uses: picocli to create a rich command line application; Testcontainers to run containers in JUnit tests; Sentry for error monitoring; and JReleaser to release the project.

Just uses Spring Boot Devtools which reloads the application after the source code is changed and a build is triggered. On top of Spring Boot Devtools, Just automatically detects source code changes and compiles those changes. Furthermore, whenever the pom.xml or build.gradle change, the application is stopped, the build file refreshed and the application is started again. Unlike Spring Boot Devtools, Just also starts infrastructure services such as databases and services defined via Docker Compose whenever the run sub-command is executed. Just automatically detects the applications build configuration and uses it whenever a just command is executed. It supports Maven and Gradle, but also their respective wrappers and the Maven Daemon. Just execute the run sub-command once and it takes care of the changes in the application.

Comparable to the run sub-command, the build sub-command is translated to the proper Maven or Gradle command with the correct build goal:

just build [--quick] [--skip-test] <buildTarget>

The quick option skips tests, document generation and checks such as formatting and static analysis. Just offers several buildTarget options to create a (native) application or a (native) Docker image: jar, native, image and native-image.

Based on the project's configuration, the format sub-command formats the codebase following the rules of the default settings, Spring Java Format or Spotless configuration.

A running process may be killed with the kill sub-command. By default, the process running on port 8080 is killed. Optionally, a port may be specified with the -p argument and the kill sub-command may be forced by supplying the -9 argument.

Just can be run from the command line or from IntelliJ IDEA by adding a run configuration by executing the init idea sub-command. Alternatively, the run configuration may be added manually by opening the configuration via the Run menu option and clicking on Edit Configurations. Now add a Shell Script and specify the name. The Execute option should be set to Shell Script and the Script Text to just run. After unchecking the Execute in the terminal option, the configuration can be applied. Now the Run menu option shows the name of the new shell script which can be used to start Just.

Just may be installed on MacOs with Homebrew:

brew install maciejwalkowiak/brew/just

Or on Windows with Scoop:

scoop bucket add maciejwalkowiak https://github.com/maciejwalkowiak/scoop-just.git
scoop install just

Alternatively, the application may be installed manually on macOS, Windows or Linux, for example via the Linux command:

curl -Lo just.zip https://github.com/maciejwalkowiak/just/releases/latest/download/just-0.12.0-linux-x86_64.zip && unzip just.zip && chmod +x just && sudo mv just /usr/local/bin/just && just help

The help sub-command may be used to verify the installation.

Just is not an open source project. The GitHub repository contains the binaries, release notes and issue tracker, but not the source code. Currently, the project is still in alpha status and available for free. Each release has a built-in expiration date, after which the application may be purchased or the latest release may be installed.

Spring Getting Started Guides - go here for specific framework tutorials

https://spring.io/guides

Go from Restful Web Services ( REST API ) to Microservices - Java , Spring Boot , Spring Cloud , Docker and Kubernetes

Spring Web apps

1. Spring @GetMapping and @PostMapping Example
2. Spring DispatcherServlet Tutorial
3. Spring 5 MVC + Hibernate 5 Example

Spring WebFlux REST api framework

Tutorial Spring Boot WebFlux REST api

https://howtodoinjava.com/spring-webflux/spring-webflux-tutorial/

The reactive-stack web framework, Spring WebFlux, has been added Spring 5.0. It is fully non-blocking, supports reactive streams back pressure, and runs on such servers as Netty, Undertow, and Servlet 3.1+ containers. In this spring webflux tutorial, we will learn the basic concepts behind reactive programming, webflux apis and a fully functional hello world example.

Reactive programming is a programming paradigm that promotes an asynchronous, non-blocking, event-driven approach to data processing. Reactive programming involves modeling data and events as observable data streams and implementing data processing routines to react to the changes in those streams.

Synchronous Request Processing

Asynchronous Request Processing

non-blocking request processing means threads are not in wait states

All incoming requests come with a event handler and call back information. Request thread delegates the incoming requests to a thread pool (generally small number of threads) which delegate the request to it’s handler function and immediately start processing other incoming requests from request thread.

When the handler function is complete, one of thread from pool collect the response and pass it to the call back function.

Reactive Programming

The term, “reactive,” refers to programming models that are built around reacting to changes. It is build around publisher-subscriber pattern (observer pattern). In reactive style of programming, we make a request for resource and start performing other things. When the data is available, we get the notification along with data inform of call back function. In callback function, we handle the response as per application/user needs.

One important thing to remember is back pressure. In non-blocking code, it becomes important to control the rate of events so that a fast producer does not overwhelm its destination.

Reactive web programming is great for applications that have streaming data, and clients that consume it and stream it to their users. It is not great for developing traditional CRUD applications.  

Java Reactive Streams API

The new Reactive Streams API was created by engineers from Netflix, Pivotal, Lightbend, RedHat, Twitter, and Oracle, among others and is now part of Java 9. It defines four interfaces:

• Publisher: Emits a sequence of events to subscribers according to the demand received from its subscribers. A publisher can serve multiple subscribers.

  It has a single method:

  Publisher.java

  public interface Publisher<T> {     public void subscribe(Subscriber<? super T> s); }

• Subscriber: Receives and processes events emitted by a Publisher. Please note that no notifications will be received until Subscription#request(long) is called to signal the demand.

  It has four methods to handle various kind of responses received.

  Subscriber.java

  public interface Subscriber<T> {     public void onSubscribe(Subscription s);     public void onNext(T t);     public void onError(Throwable t);     public void onComplete(); }

• Subscription: Defines a one-to-one relationship between a Publisher and a Subscriber. It can only be used once by a single Subscriber. It is used to both signal desire for data and cancel demand (and allow resource cleanup).
  Subscription.java

  public interface Subscription<T> {     public void request(long n);     public void cancel(); }

• Processor: Represents a processing stage consisting of both a Subscriber and a Publisher and obeys the contracts of both.
  Processor.java

  public interface Processor<T, R> extends Subscriber<T>, Publisher<R> { }

Two popular implementations of reactive streams are RxJava (https://github.com/ReactiveX/RxJava) and Project Reactor (https://projectreactor.io/).

Reactive API questions

1. how does publisher manage notifications to multiple subscribers as response rates vary?

Spring WebFlux framework for reactive applications

Spring WebFlux is parallel version of Spring MVC and supports fully non-blocking reactive streams. It support the back pressure concept and uses Netty as inbuilt server to run reactive applications. If you are familiar with Spring MVC programming style, you can easily work on webflux also.

Spring webflux uses project reactor as reactive library. Reactor is a Reactive Streams library and, therefore, all of its operators support non-blocking back pressure. It is developed in close collaboration with Spring.

Spring WebFlux heavily uses two publishers :

• Mono: Returns 0 or 1 element.

  Mono<String> mono = Mono.just("Alex"); Mono<String> mono = Mono.empty();

• Flux: Returns 0…N elements. A Flux can be endless, meaning that it can keep emitting elements forever. Also it can return a sequence of elements and then send a completion notification when it has returned all of its elements.

  Flux<String> flux = Flux.just("A", "B", "C"); Flux<String> flux = Flux.fromArray(new String[]{"A", "B", "C"}); Flux<String> flux = Flux.fromIterable(Arrays.asList("A", "B", "C"));   //To subscribe call method   flux.subscribe();

In Spring WebFlux, we call reactive apis/functions that return monos and fluxes and your controllers will return monos and fluxes. When you invoke an API that returns a mono or a flux, it will return immediately. The results of the function call will be delivered to you through the mono or flux when they become available.

To build a truly non-blocking application, we must aim to create/use all of it’s components as non-blocking i.e. client, controller, middle services and even the database. If one of them is blocking the requests, our aim will be defeated.

Spring Boot WebFlux Example

In this Spring boot 2 application, I am creating employee management system. I chosen it because, while learning, you can compare it with traditional MVC style application. To make it fully non-blocking, I am using mongodb as back-end database.

https://howtodoinjava.com/spring-webflux/spring-webflux-tutorial/

Spring Security

Spring Security. Spring Security is a framework that enables a programmer to impose security restrictions to Spring-framework–based Web applications through JEE components. In short, it is a library that can be used, extended to customize as per the programmer's needs.

https://spring.io/projects/spring-security

1. Security Java Config – @EnableWebSecurity Example
2. Login Form Example
3. Spring CORS Configuration

springsecurity-v5-181008152249.pdf

Spring_Boot_Security_Cheat_Sheet.pdf

Guides

Spring Security - Lambda DSL

https://spring.io/blog/2019/11/21/spring-security-lambda-dsl

The release of Spring Security 5.2 includes enhancements to the DSL, which allow HTTP security to be configured using lambdas.

It is important to note that the prior configuration style is still valid and supported. The addition of lambdas is intended to provide more flexibility, but their usage is optional.

You may have seen this style of configuration in the Spring Security documentation or samples.
Let us take a look at how a lambda configuration of HTTP security compares to the previous configuration style.

Configuration using lambdas

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests(authorizeRequests ->
                authorizeRequests
                    .antMatchers("/blog/**").permitAll()
                    .anyRequest().authenticated()
            )
            .formLogin(formLogin ->
                formLogin
                    .loginPage("/login")
                    .permitAll()
            )
            .rememberMe(withDefaults());
    }
}

Equivalent configuration without using lambdas

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/blog/**").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .rememberMe();
    }
}

Lambda DSL configuration tips

When comparing the two samples above, you will notice some key differences:

• In the Lambda DSL there is no need to chain configuration options using the .and() method. The HttpSecurity instance is automatically returned for further configuration after the call to the lambda method.
• withDefaults() enables a security feature using the defaults provided by Spring Security. This is a shortcut for the lambda expression it -> {}.

WebFlux Security

You may also configure WebFlux security using lambdas in a similar manner.
Below is an example configuration using lambdas.

@EnableWebFluxSecurity
public class SecurityConfig {

    @Bean
    SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
        http
            .authorizeExchange(exchanges ->
                exchanges
                    .pathMatchers("/blog/**").permitAll()
                    .anyExchange().authenticated()
            )
            .httpBasic(withDefaults())
            .formLogin(formLogin ->
                formLogin
                    .loginPage("/login")
            );
        return http.build();
    }
}

Goals of the Lambda DSL

The Lambda DSL was created to accomplish to following goals:

• Automatic indentation makes the configuration more readable.
• The is no need to chain configuration options using .and().
• The Spring Security DSL has a similar configuration style to other Spring DSLs such as Spring Integration and Spring Cloud Gateway.

Spring Security without the WebSecurityConfigurerAdapter

https://spring.io/blog/2022/02/21/spring-security-without-the-websecurityconfigureradapter

In Spring Security 5.7.0-M2 we deprecated the WebSecurityConfigurerAdapter, as we encourage users to move towards a component-based security configuration.

To assist with the transition to this new style of configuration, we have compiled a list of common use-cases and the suggested alternatives going forward.

In the examples below we follow best practice by using the Spring Security lambda DSL and the method HttpSecurity#authorizeHttpRequests to define our authorization rules. If you are new to the lambda DSL you can read about it in this blog post. If you would like to learn more about why we choose to use HttpSecurity#authorizeHttpRequests you can check out the reference documentation.

Spring Data

Spring REST services

https://spring.io/guides/gs/rest-service/

http://localhost:8080/greeting

{"id":1,"content":"Hello, World!"}

http://localhost:8080/greeting?name=User

{"id":1,"content":"Hello, User!"}

Build with Maven

{
    "id": 1,
    "content": "Hello, World!"
}

package hello;

public class Greeting {

    private final long id;
    private final String content;

    public Greeting(long id, String content) {
        this.id = id;
        this.content = content;
    }

    public long getId() {
        return id;
    }

    public String getContent() {
        return content;
    }
}

package hello;

import java.util.concurrent.atomic.AtomicLong;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    private static final String template = "Hello, %s!";
    private final AtomicLong counter = new AtomicLong();

    @RequestMapping("/greeting")
    public Greeting greeting(@RequestParam(value="name", defaultValue="World") String name) {
        return new Greeting(counter.incrementAndGet(),
                            String.format(template, name));
    }
}

package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

java -jar build/libs/gs-rest-service-0.1.0.jar

java -jar target/gs-rest-service-0.1.0.jar

{"id":1,"content":"Hello, World!"}

{"id":2,"content":"Hello, User!"}

Spring REST Tutorial

https://spring.io/guides/tutorials/rest/

package payroll;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Data
@Entity
class Employee {

  private @Id @GeneratedValue Long id;
  private String name;
  private String role;

  Employee() {}

  Employee(String name, String role) {
    this.name = name;
    this.role = role;
  }
}

package payroll;

import org.springframework.data.jpa.repository.JpaRepository;

interface EmployeeRepository extends JpaRepository<Employee, Long> {

}

package payroll;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class PayrollApplication {

  public static void main(String... args) {
    SpringApplication.run(PayrollApplication.class, args);
  }
}

package payroll;

import lombok.extern.slf4j.Slf4j;

import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@Slf4j
class LoadDatabase {

  @Bean
  CommandLineRunner initDatabase(EmployeeRepository repository) {
    return args -> {
      log.info("Preloading " + repository.save(new Employee("Bilbo Baggins", "burglar")));
      log.info("Preloading " + repository.save(new Employee("Frodo Baggins", "thief")));
    };
  }
}

...
2018-08-09 11:36:26.169  INFO 74611 --- [main] payroll.LoadDatabase : Preloading Employee(id=1, name=Bilbo Baggins, role=burglar)
2018-08-09 11:36:26.174  INFO 74611 --- [main] payroll.LoadDatabase : Preloading Employee(id=2, name=Frodo Baggins, role=thief)
...

package payroll;

import java.util.List;

import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
class EmployeeController {

  private final EmployeeRepository repository;

  EmployeeController(EmployeeRepository repository) {
    this.repository = repository;
  }

  // Aggregate root

  @GetMapping("/employees")
  List<Employee> all() {
    return repository.findAll();
  }

  @PostMapping("/employees")
  Employee newEmployee(@RequestBody Employee newEmployee) {
    return repository.save(newEmployee);
  }

  // Single item

  @GetMapping("/employees/{id}")
  Employee one(@PathVariable Long id) {

    return repository.findById(id)
      .orElseThrow(() -> new EmployeeNotFoundException(id));
  }

  @PutMapping("/employees/{id}")
  Employee replaceEmployee(@RequestBody Employee newEmployee, @PathVariable Long id) {

    return repository.findById(id)
      .map(employee -> {
        employee.setName(newEmployee.getName());
        employee.setRole(newEmployee.getRole());
        return repository.save(employee);
      })
      .orElseGet(() -> {
        newEmployee.setId(id);
        return repository.save(newEmployee);
      });
  }

  @DeleteMapping("/employees/{id}")
  void deleteEmployee(@PathVariable Long id) {
    repository.deleteById(id);
  }
}

package payroll;

class EmployeeNotFoundException extends RuntimeException {

  EmployeeNotFoundException(Long id) {
    super("Could not find employee " + id);
  }
}

package payroll;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;

@ControllerAdvice
class EmployeeNotFoundAdvice {

  @ResponseBody
  @ExceptionHandler(EmployeeNotFoundException.class)
  @ResponseStatus(HttpStatus.NOT_FOUND)
  String employeeNotFoundHandler(EmployeeNotFoundException ex) {
    return ex.getMessage();
  }
}

$ ./mvnw clean spring-boot:run

$ mvn clean spring-boot:run

$ curl -v localhost:8080/employees

*   Trying ::1...
* TCP_NODELAY set
* Connected to localhost (::1) port 8080 (#0)
> GET /employees HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.54.0
> Accept: */*
>
< HTTP/1.1 200
< Content-Type: application/json;charset=UTF-8
< Transfer-Encoding: chunked
< Date: Thu, 09 Aug 2018 17:58:00 GMT
<
* Connection #0 to host localhost left intact
[{"id":1,"name":"Bilbo Baggins","role":"burglar"},{"id":2,"name":"Frodo Baggins","role":"thief"}]

$ curl -v localhost:8080/employees/99

*   Trying ::1...
* TCP_NODELAY set
* Connected to localhost (::1) port 8080 (#0)
> GET /employees/99 HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.54.0
> Accept: */*
>
< HTTP/1.1 404
< Content-Type: text/plain;charset=UTF-8
< Content-Length: 26
< Date: Thu, 09 Aug 2018 18:00:56 GMT
<
* Connection #0 to host localhost left intact
Could not find employee 99

$ curl -X POST localhost:8080/employees -H 'Content-type:application/json' -d '{"name": "Samwise Gamgee", "role": "gardener"}'

{"id":3,"name":"Samwise Gamgee","role":"gardener"}

$ curl -X PUT localhost:8080/employees/3 -H 'Content-type:application/json' -d '{"name": "Samwise Gamgee", "role": "ring bearer"}'

{"id":3,"name":"Samwise Gamgee","role":"ring bearer"}

$ curl -X DELETE localhost:8080/employees/3
$ curl localhost:8080/employees/3
Could not find employee 3

I am getting frustrated by the number of people calling any HTTP-based interface a REST API. Today’s example is the SocialSite REST API. That is RPC. It screams RPC. There is so much coupling on display that it should be given an X rating.

What needs to be done to make the REST architectural style clear on the notion that hypertext is a constraint? In other words, if the engine of application state (and hence the API) is not being driven by hypertext, then it cannot be RESTful and cannot be a REST API. Period. Is there some broken manual somewhere that needs to be fixed?

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>

@GetMapping("/employees/{id}")
Resource<Employee> one(@PathVariable Long id) {

  Employee employee = repository.findById(id)
    .orElseThrow(() -> new EmployeeNotFoundException(id));

  return new Resource<>(employee,
    linkTo(methodOn(EmployeeController.class).one(id)).withSelfRel(),
    linkTo(methodOn(EmployeeController.class).all()).withRel("employees"));
}

{
  "id": 1,
  "name": "Bilbo Baggins",
  "role": "burglar",
  "_links": {
    "self": {
      "href": "http://localhost:8080/employees/1"
    },
    "employees": {
      "href": "http://localhost:8080/employees"
    }
  }
}

@GetMapping("/employees")
Resources<Resource<Employee>> all() {

  List<Resource<Employee>> employees = repository.findAll().stream()
    .map(employee -> new Resource<>(employee,
      linkTo(methodOn(EmployeeController.class).one(employee.getId())).withSelfRel(),
      linkTo(methodOn(EmployeeController.class).all()).withRel("employees")))
    .collect(Collectors.toList());

  return new Resources<>(employees,
    linkTo(methodOn(EmployeeController.class).all()).withSelfRel());
}

Tutorial - Spring Boot CRUD with Angular 9

https://developer.okta.com/blog/2020/01/06/crud-angular-9-spring-boot-2

spring-boot-crud-angular-raible-developer.okta.com-Build a CRUD App with Angular 9 and Spring Boot 22.pdf

Angular 9’s most prominent new feature is Ivy. Ivy is Angular’s new compiler and renderer. The renderer is the engine that takes your components and templates and translates them into instructions that manipulate the DOM. Ivy is an internal component, so you don’t interact with it directly. However, it can have a significant impact on your code, yielding much smaller JavaScript bundles and increasing performance.

• What’s New In Angular 9?
• What’s New in Spring Boot 2.2?
• Create an Angular 9 App
• Add Angular Authentication using OpenID Connect
• Create a Spring Boot 2.2 App
  • Secure Spring Boot with Spring Security, OAuth 2.0, and OIDC
  • Spring Boot as an OAuth 2.0 Resource Server
• Add a Notes REST API with Spring Data REST
  • Add a CORS Filter for Angular
• Add a Notes CRUD Feature in Angular
  • Fix the Note Edit Feature
• Lock Down Spring Boot with Recommended Security Practices
• Learn More about Angular, Spring Boot, and Kotlin

Angular 9 Spring Boot 2.2 Video Tutorial

Tutorial - Simple CRUD services with React, Spring Boot and JHipster

https://developer.okta.com/blog/2022/06/17/simple-crud-react-and-spring-boot

jhipster-crud-developer.oktacom-Use React and Spring Boot to Build a Simple CRUD App.pdf link

jhipster-crud-developer.okta.com-Use React and Spring Boot to Build a Simple CRUD App.pdf file

React was designed to make it painless to create interactive UIs. Its state management is efficient and only updates components when your data changes. Component logic is written in JavaScript, meaning you can keep state out of the DOM and create encapsulated components.

Developers like CRUD (create, read, update, and delete) apps because they show a lot of the base functionality you need when creating an app. Once you have the basics of CRUD completed in an app, most of the client-server plumbing is finished, and you can move on to implementing the necessary business logic.

Today, I’ll show you how to create a basic CRUD app with Spring Boot and React. In this tutorial, I’ll use the OAuth 2.0 Authorization Code flow and package the React app in the Spring Boot app for production. At the same time, I’ll show you how to keep React’s productive workflow for developing locally.

You will need Java 17 and Node 16 installed to complete this tutorial.

• Create an API app with Spring Boot
  • Add a JPA domain model
• Create a React UI with Create React App
• Call your Spring Boot API and display the results
• Build a React GroupList component
• Add a React GroupEdit component
• Add authentication with Okta
  • Spring Security + OIDC
  • Create an OIDC app in Okta
  • Use Auth0 for OIDC
• Configure Spring Security for React and user identity
• Modify React to handle CSRF and be identity-aware
• Configure Maven to build and package React with Spring Boot
• Learn more about Spring Boot and React

Building Microservices Architectural Applications using Spring Boot.pdf on Spring Cloud  link

help you to understand the theoretical concepts of Microservices and how it practically used for spring boot. The following points will consider in this article — Part 01 ->

Testing Spring Boot Applications: Best Practices and Frameworks..  medium

medium.com-Testing Spring Boot Applications Best Practices.pdf.  link

medium.com-Testing Spring Boot Applications Best Practices.pdf. file

Testing is an integral part of software development. It ensures that your Spring Boot applications work as expected and continue to do so as they evolve. In this article, we’ll explore how to test Spring Boot applications using best practices and tools.

Why Testing Matters

Testing is crucial for several reasons:

1. Reliability: It ensures your application performs correctly and reliably.
2. Bug Detection: It helps identify and fix issues early in development.
3. Refactoring: It allows for code refactoring with confidence so existing functionality won’t break.
4. Documentation: Well-written tests serve as living documentation for your code.

Types of Testing

Spring Boot applications can be tested at various levels, including:

1. Unit Testing: Testing individual components, such as classes or methods, in isolation.
2. Integration Testing: Verifying that different components or services work correctly together.
3. Functional Testing: Testing the application’s functionality from the user’s perspective.
4. End-to-End Testing: Testing the entire application, including its external dependencies, in a production-like environment.

Spring Cloud

Spring Cloud Webinar notes

Spring Cloud Webinar notes gdoc  link

https://docs.google.com/document/d/1t402nm0BzAtweNZBwonuh7j91dzyaeAmT7w7-ZOoNWM/edit?usp=sharing

java-spring-notes-v1.docx

https://spring.io/projects/spring-cloud

Spring Cloud provides tools for developers to quickly build some of the common patterns in distributed systems (e.g. configuration management, service discovery, circuit breakers, intelligent routing, micro-proxy, control bus, one-time tokens, global locks, leadership election, distributed sessions, cluster state). Coordination of distributed systems leads to boiler plate patterns, and using Spring Cloud developers can quickly stand up services and applications that implement those patterns. They will work well in any distributed environment, including the developer’s own laptop, bare metal data centres, and managed platforms such as Cloud Foundry.

Features

Spring Cloud projects list

Spring Cloud Message Broker

https://spring.io/projects/spring-cloud-bus

links nodes of a distributed system with a lightweight message broker. This can then be used to broadcast state changes (e.g. configuration changes) or other management instructions. AMQP and Kafka broker implementations are included with the project. Alternatively, any Spring Cloud Stream binder found on the classpath will work out of the box as a transport.

Spring Cloud Data Stream with message, Kafka services

https://developer.okta.com/blog/2020/04/15/spring-cloud-stream

spring-cloud-stream-for-messaging-developer.okta.com-A Quick Guide to Spring Cloud Stream.pdf

Build Mobile Apps with Angular, Ionic 4, and Spring Boot

https://developer.okta.com/blog/2019/06/24/ionic-4-angular-spring-boot-jhipster

JHipster is an application generator, and platform, for building Java apps with JavaScript frontends.

see Grails Angular profile as an option.

Potential Value Opportunities

Potential Challenges

Candidate Solutions

Okta - Identity Management - Java, Node.js, more

https://dev-896837.okta.com/login/login.htm

dev login

quickstart panel - learn Okta

https://support.okta.com/help/s/

IT Administrator

Add users into Okta

Add another Okta admin

Assign apps to users

Developer

Create an API token

Sign in to your single page-app

Publish your app on Okta (OIN)

Documentation

Read our reference guides about how to use Okta

IT Administrator

Release notesProduct documentationGlossary

Developer

API release notes

API documentation

Partner integration documentation

Keycloak - an Open Source Identity and Access Management solution

https://github.com/keycloak/keycloak

Step-by-step guide for Example

sample code block

Recommended Next Steps

Related articles