This document provides an overview of technologies and best practices for developing a web application using Spring Boot, Spring MVC, and other Spring technologies. It discusses setting up the project structure, implementing data access with Spring Data JPA and repositories, adding security, testing with Mockito and RestAssured, and documenting the API with Swagger.

1. WEB APPLICATION

2. Technologies
● Spring Boot
● Spring MVC
● Spring Data
● Spring Security
● Liquibase
● Maven
● Swagger
● Junit 4
● Mockito
● RestAssured
● Postgresql
● H2 – embeded for test

3. Create project
● http://start.spring.io/
or
● IDEA!!!

4. First launch
● Security
- user = user
- password – in launch log

5. Rest main principals
● Client-Server with one API. Client and Server
are two separated applications!!!
● Stateless – session on client side, all required
info in url.
● Client can put to cash information from server

6. Main rest request
● GET – doesn't change resource
● PUT – (create, replace, update)you can make it
many times without creating duplicates
● POST - (The POST operation is very generic
and no specific meaning can be attached to it)
create something new
● Delete – simple delete

7. First properties
● security.user.password=qwerty
●
● #DB connection properties
● spring.datasource.url=jdbc:postgresql://localhost:5432/test
● spring.datasource.username=postgres
● spring.datasource.password=qwerty
● spring.datasource.driverClassName=org.postgresql.Driver
● spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
● spring.jpa.show-sql=true
● spring.jpa.hibernate.ddl-auto=none

8. Repositories
● No more same jpql!
● No more DAO!
Methods from the box:
- save
- findOne
- exists
- findAll
- count
- delete
- deleteAll
https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repository-query-keywords

9. Old good @Entity
@Entity
public class Person{
@Id
@Column(name = "person_id", nullable = false)
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 30)
private String login;
@Column(nullable = false, length = 30)
private String password;
@Column(nullable = false, length = 30)
private String name;
@Column(nullable = false)
@Enumerated(EnumType.STRING)
private UserRoleEnum role;
}
public enum UserRoleEnum {
MODERATOR,
USER
}

10. First controller
● @RestController
● @RequestMapping("/api/person")
● public class PersonController {
●
● @RequestMapping(method = RequestMethod.GET)
● public List<Person> getPersons(){
● …...........................
● }
● }

11. Liquibase
<dependency>
<groupId>org.liquibase</groupId>
<artifactId>liquibase-core</artifactId>
<version>3.3.2</version>
</dependency>

12. Profile
● <profile>
● <id>rebuild-db</id>
● <build>
● <plugins>
● <plugin>
● <groupId>org.liquibase</groupId>
● <artifactId>liquibase-maven-plugin</artifactId>
● <version>3.3.2</version>
● <executions>
● <execution>
● <id>release-changelog</id>
● <phase>clean</phase>
● <goals>
● <goal>dropAll</goal>
●
<goal>update</goal>
● </goals>
● <configuration>
● <changeLogFile>${liquibase.createtables}</changeLogFile>
● <propertyFileWillOverride>true</propertyFileWillOverride>
● <propertyFile>src/main/resources/liquibase.properties</propertyFile>
● </configuration>
●
</execution>
● </executions>
● </plugin>
● </plugins>
● </build>
● </profile>

13. Integration tests
● public interface RestPublisher {
●
● <T> T doGet(Class<T> clazz, String resourceURL);
●
● <T> T doPost(String resourceURL, Object
requestBody, Class<T> clazz);
●
● }

14. Restassured
<dependency>
<groupId>com.jayway.restassured</groupId>
<artifactId>rest-assured</artifactId>
<version>2.1.0</version>
<scope>test</scope>
</dependency>
given().auth().basic(username,
password).when().get("/secured").then().statusCode(200);

15. RestPublisherImpl
public class RestPublisherImpl implements RestPublisher{
●
●
public static final String REQUEST_BODY_TYPE = "application/json";
●
private String serverUrl;
●
●
private RequestSpecification requestSpecification;
●
●
public RestPublisherImpl(String serverUrl, String login, String password) {
●
this.serverUrl = serverUrl;
●
requestSpecification = given().authentication().basic(login, password).contentType(ContentType.JSON);
●
●
}
●
●
public <T> T doGet(Class<T> clazz, String resourceURL) {
●
Response response = requestSpecification.get(serverUrl + resourceURL);
●
return response.as(clazz);
●
}
●
●
public <T> T doPost(String resourceURL, Object requestBody, Class<T> clazz) {
●
return requestSpecification.body(requestBody).post(resourceURL).as(clazz);
●
}
●
●
}

16. Embedded DB for tests
●
@TestPropertySource(locations="classpath:test.properties")
#DB connection properties
spring.datasource.url=jdbc:h2:mem:AZ;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=sa
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none
spring.datasource.initialize=true
liquibase.changeLog=classpath:changeset-test-data.xml

17. Integration with liqubase
● <dependency>
● <groupId>org.liquibase</groupId>
● <artifactId>liquibase-core</artifactId>
● <scope>test</scope>
● </dependency>

18. Swagger
@EnableSwagger2
@ComponentScan(basePackages = "com.illcko.demo.enjoyme.rest_controllers")
public class SwaggerConfig {
@Bean
public Docket swaggerSpringMvcPlugin() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo()).select().paths(regex("/api.*")).build();
}
private ApiInfo apiInfo() {
ApiInfo apiInfo = ApiInfo.DEFAULT;
return apiInfo;
}
}

19. Swagger dependencies
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.2.2</version>
</dependency>
<repository>
<id>spring-milestones</id>
<url>http://repo.spring.io/libs-milestone/</url>
</repository>

20. Quick Annotation Overview
@Api Marks a class as a Swagger resource.
● @ApiImplicitParam Represents a single parameter in an API Operation.
● @ApiImplicitParams A wrapper to allow a list of multiple ApiImplicitParam objects.
● @ApiModel Provides additional information about Swagger models.
● @ApiModelPropertyAdds and manipulates data of a model property.
● @ApiOperation Describes an operation or typically a HTTP method against a specific path.
● @ApiParam Adds additional meta-data for operation parameters.
● @ApiResponse Describes a possible response of an operation.
● @ApiResponses A wrapper to allow a list of multiple ApiResponse objects.
● @Authorization Declares an authorization scheme to be used on a resource or an operation.
● @AuthorizationScope Describes an OAuth2 authorization scope.
● @ResponseHeader Represents a header that can be provided as part of the response.

21. Unit tests - Mockito
● <dependency>
● <groupId>org.mockito</groupId>
● <artifactId>mockito-all</artifactId>
● <version>1.9.5</version>
● </dependency>

22. Use mocks and RestTest Utils
● @RunWith(MockitoJUnitRunner.class)
@Mock
● private PersonRepository personRepository;
●
ReflectionTestUtils.setField(personController,
"personRepository", personRepository);