Cucumber

Hamcrest

spring-test

Junit

EasyMock

PowerMock

@EntityScan and spring.jpa.* properties can be used to customize Spring Data JPA.

Any kind of Hibernate property can be passed to Spring Data JPA like spring.jpa.properties.xxx.

Spring Data JPA is the only implementation for relational databases.

Scanning of JPA Entities can not be customized, the whole classpath is scanned.

Embedded Databases (H2, HSQLDB, Derby) are not re-created during the startup.

Add @PathVariable(“id”) String accountId argument to the update() handler method.

Add @PathVariable long accountId argument to the update() handler method.

Add @RequestParam long accountId argument to the update() handler method.

Add @RequestParam(“id”) String accountId argument to the update() handler method.

RESTful applications use a stateless architecture.

RESTful application use HTTP headers and status codes as a contract with the clients.

RESTful applications cannot use caching.

RESTful application servers keep track of the client state.

RESTful applications favor tight coupling between the clients and the servers.

Annotate the callback method with @PostDestroy.

Annotate the callback method with @PreDestroy.

Add the @Lazy annotation to the bean configuration.

Configure the bean instance to use prototype scope.

Mocking a Spring Bean requires annotating it with @MockBean annotation.

If a Spring Bean already exists in the web slice test spring context, it cannot be mocked.

Mocks cannot be used in a Spring Boot web slice test.

Mocking a Spring Bean requires annotating it with @Mock annotation.

It is a meta-annotation on the @SpringBootApplication composed annotation.

It enables auto-configuration of the ApplicationContext by attempting to guess necessary beans.

It is meta-annotation on the @SpringBootConfiguration composed annotation.

It has the same effect regardless of the package of the class that is annotated with it.

It ensures auto-configuration is applied before user-defined beans have been registered.

REST is a Protocol.

REST is Stateful.

REST is Reliable.

REST is Interoperable.

REST is Relative.

If there is only one constructor the @Autowired annotation is not required.

Constructor injection only allows one value to be injected.

Constructor injection is preferred over field injection to support unit testing.

Construction injection can be used with multiple constructors without @Autowired annotation.

Field injection is preferred over constructor injection from a unit testing standpoint.

Repository

Messaging

Web

Container

Client

clientServiceImpl (starting with lowercase “c”)

clientServiceImpl (starting with uppercase “C”)

clientService (starting with lowercase “c”)

ClientService (starting with uppercase “C”)

@Value must be used for environment variables, as @ConfigurationProperties cannot access the environment.

@Value supports relaxed binding of properties, but not property binding through SpEL.

@ConfigurationProperties is preferable over @Value when type-safety during property binding is a concern.

@ConfigurationProperties only bind properties from .properties files, not from .yml files.

@ConfigurationProperties supports relaxed binding of properties, but not property binding through SpEL.

encodedPassword{id}, where {id} is an identifier used to look up which PasswordEncoder should be used.

{id}encodedPassword, where {id} is an identifier used to look up which PasswordEncoder should be used.

{timestamp}encodedPassword, where {timestamp} is the time when the password was encoded.

{id}{salt}encodedPassword, where {id} is an identifier used to look up which PasswordEncoder should be used and {salt} a randomly generated salt.

The last status in a sorted list of HealthIndicators is used to derive the final system health.

The status with the least severity is used as the top-level status.

Custom status values can be created.

The built-in status values are DOWN, OUT_OF_SERVICE, UNKNOWN, and UP in decreasing order of severity.

The severity order cannot be changed due to security reasons.

The URLs can be specified via configuration (using authorizeRequests () and request matchers), with the most specific rule first and the least specific last.

Spring Security can obtain URLs from Spring MVC controllers, the Spring Security configuration just needs a reference to the controller to be protected.

The URLs are specified in a special properties file, used by Spring Security.

The URLs can be specified via configuration (using authorizeRequests () and request matchers), with the least specific rule first and the most specific last.

Allow access to a method based on user identity.

Allow access to a method based on the returned object.

Allow access to a method based on HTTP method.

Allow access to a method based on request URL.

Allow access to a method based on roles.

To get a logging level of a package called account.web, you can access the /actuator/loggers/account.web endpoint.

An application restart is required to change the logging level of the package.

In order to use the loggers endpoint, a logger implementation dependency needs to be added.

The logging levels of a package that can be accessed via the loggers endpoint include configuredLevel and effectiveLevel.

public Customer getsingle(Long id);

public Customer findFirstOrderDateMax();

public Customer findByEmail(String email);

public Customer findFirstByOrderDateBetween(Date d1, Date d2);

public Customer findCustomerByName(String name);

It auto-configures a MockMvc.

It will only scan for @Controller beans in the source code.

It is used for testing Spring MVC components such as @Controller with a running server.

Typically it is used in combination with @MockBean when there is a dependency bean to be mocked.

It is typically used with @ExtendWith(MockitoExtension.class) in JUnit 5.

Used to designate the location of the application.properties file in a Spring Boot application.

Used to easily look up and return a single property value from some external property file.

Used to designate the file directory of the application.properties file in a Spring Boot application.

Used to add a set of name/value pairs to the Spring Environment from an external source.