Spring Basics - JamesDansie/data-structures-and-algorithms GitHub Wiki

Spring Basics

Author: James Dansie

This is the basics of using Spring annotations for routing and data storage repos.

Spring Annotations - Summary of [1]

Annotations are used to assign web requests to Spring Controller methods. by Path (the value= is the path);

@RequestMapping(value = "/ex/foos", method = RequestMethod.GET)
@ResponseBody
public String getFoosBySimplePath() {
    return "Get some Foos";
}

by HTTP Method;

@RequestMapping(value = "/ex/foos", method = POST)
@ResponseBody
public String postFoos() {
    return "Post some Foos";
}

Even more requests, but now with headers!

@RequestMapping(value = "/ex/foos", headers = "key=val", method = GET)
@ResponseBody
public String getFoosWithHeader() {
    return "Get some Foos with Header";
}
Or multiple headers;
```Java
@RequestMapping(
  value = "/ex/foos", 
  headers = { "key1=val1", "key2=val2" }, method = GET)
@ResponseBody
public String getFoosWithHeaders() {
    return "Get some Foos with Header";
}

We can also have multiple path variables;

@RequestMapping(value = "/ex/foos/{fooid}/bar/{barid}", method = GET)
@ResponseBody
public String getFoosBySimplePathWithPathVariables
  (@PathVariable long fooid, @PathVariable long barid) {
    return "Get a specific Bar with id=" + barid + 
      " from a Foo with id=" + fooid;
}

There are a bunch more junk, but lets get to the good stuff! Get, Post, Put, Delete! Woo ya!

@GetMapping("/{id}")
public ResponseEntity<?> getBazz(@PathVariable String id){
    return new ResponseEntity<>(new Bazz(id, "Bazz"+id), HttpStatus.OK);
}
 
@PostMapping
public ResponseEntity<?> newBazz(@RequestParam("name") String name){
    return new ResponseEntity<>(new Bazz("5", name), HttpStatus.OK);
}
 
@PutMapping("/{id}")
public ResponseEntity<?> updateBazz(
  @PathVariable String id,
  @RequestParam("name") String name) {
    return new ResponseEntity<>(new Bazz(id, name), HttpStatus.OK);
}
 
@DeleteMapping("/{id}")
public ResponseEntity<?> deleteBazz(@PathVariable String id){
    return new ResponseEntity<>(new Bazz(id), HttpStatus.OK);
}

Storage - summary of [2]

Each spring data repo extends the generic repository interface, but with some extra functionality.

CrudRepo

The crud interface is as follows;

public interface CrudRepository<T, ID extends Serializable>
  extends Repository<T, ID> {
 
    <S extends T> S save(S entity);
 
    T findOne(ID primaryKey);
 
    Iterable<T> findAll();
 
    Long count();
 
    void delete(T entity);
 
    boolean exists(ID primaryKey);
}

This provides the functionality of; save, findOne, findAll, count, delete, and exists.

Paging and Sorting

The paging and sorting repo extends the crud repo, but with the extra methods of page size, current page number, and sorting. This allows us to easily sort pages based on data in the class. It can be implemented with;

public interface PagingAndSortingRepository<T, ID extends Serializable> 
  extends CrudRepository<T, ID> {
 
    Iterable<T> findAll(Sort sort);
 
    Page<T> findAll(Pageable pageable);
}

JPA Repo

The extends the paging and sorting repo, so it has all the functions of the previous two methods. In addition, it also has; find all, save, flush, save and flush, and delete in batch. It can be implemented with;

public interface JpaRepository<T, ID extends Serializable> extends
  PagingAndSortingRepository<T, ID> {
 
    List<T> findAll();
 
    List<T> findAll(Sort sort);
 
    List<T> save(Iterable<? extends T> entities);
 
    void flush();
 
    T saveAndFlush(T entity);
 
    void deleteInBatch(Iterable<T> entities);
}

References

  1. Request Mapping - https://www.baeldung.com/spring-requestmapping
  2. Repo stuff - https://www.baeldung.com/spring-data-repositories
⚠️ **GitHub.com Fallback** ⚠️