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

...

https://s3.amazonaws.com/baeldung.com/Persistence+with+Spring.pdf?__s=dks6vftyyy
n6rnaspucsspring-Persistence+with+Spring.pdf

...

Spring Persistence Overview

...

https://s3.amazonaws.com/baeldung.com/Building+a+REST+API+with+Spring.pdf?
__s=dks6vftyyyn6rnaspucs

...

spring-REST-Building+a+REST+API+with+Spring.pdf

...

Build Spring REST services

...

Spring-Framework-Cookbook.pdf

...

Spring Cookbook

...

Simple Aspects using Annotations in Grails _ Man Builds Website.pdf

...

Grails and Spring Aspect

...

spring-6-.io-A Java 17 and Jakarta EE 9 baseline for Spring Framework 6.pdf

spring-6-.io-A Java 17 and Jakarta EE 9 baseline for Spring Framework 6

...

https://stackify.com/spring-boot-level-up/

https://drive.google.com/open?id=1_NfWcLnIABOD0KQ8khcktS3qn_rfblHM

...

https://www.baeldung.com/spring-vs-spring-boot

https://drive.google.com/open?id=1dGQuibfgkwxlKoGkXUYLfGldLF_HLiyO

...

https://www.springboottutorial.com/spring-boot-vs-spring-mvc-vs-spring

https://drive.google.com/open?id=1T1BODw5dkSWlfpZnmRlN6YyCQzn_kXhM

...

https://developer.okta.com/blog/2021/05/12/spring-boot-r2dbc

R2DBC and Spring for Non-Blocking Database Access pdf

...

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

...

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:

Image Added

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://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/www.infoq.com/news/2023/01/just-spring-boot-cli/

JUST getting started docs

https://springjust.maciejwalkowiak.iocom/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:

Image Removed

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-clouddocs/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

...

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

...

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:

...

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());
}

...

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/20202022/0106/0617/simple-crud-angularreact-9and-spring-boot-2spring-boot-crud-angular-raible-

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 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.

Spring Boot 2.2 was released in September 2019 and focuses on performance improvements and reduced memory usage. It adds Java 13 support, RSocket support, and the ability to group health indicators. Grouping indicators can be useful if you’re deploying to Kubernetes and want different groups for "liveness" and "readiness" probes.

In this post, I’ll show you how to build a CRUD application with Angular 9 and Spring Boot 2.2. Along the way, I’ll do my best to weave in security tips and how to make your apps more secure.

• 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.

...

• Add a JPA domain model

...

• Spring Security + OIDC
• Create an OIDC app in Okta
• Use Auth0 for OIDC

...

 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

...