Spring - Yash-777/MyWorld GitHub Wiki

URL ^{javasript read URL}

URL

The Hypertext Transfer Protocol (HTTP) is designed to enable communications between clients and servers.

HTTP works as a request-response protocol between a client and server.

Example: A client (browser) sends an HTTP request to the server; then the server returns a response to the client. The response contains status information about the request and may also contain the requested content.

HTTP Methods: GET, POST, PUT, HEAD, DELETE, PATCH, OPTIONS, CONNECT, TRACE

GET vs POST vs PUT w3schools.com

HTTP Request Response ^wiki

HTTP requests are sent by a client to the server. The server sends back a response. The response could be HTML, or JSON, or whatever the server decides to send.

The HTTP/1.0 specification defined the GET, HEAD and POST methods and the HTTP/1.1 specification added five new methods: OPTIONS, PUT, DELETE, TRACE and CONNECT.

Status Code: provides meta information required in the response.

HTTP response status codes ^mozilla.org

HTTP response status codes indicate whether a specific HTTP request has been successfully completed. Responses are grouped in five classes:

• Informational responses (100 – 199)
• Successful responses (200 – 299)
• Redirection messages (300 – 399)
• Client error responses (400 – 499)
• Server error responses (500 – 599)

@RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
public ResponseEntity<User> getUser(@PathVariable Long id) {
    return Optional
            .ofNullable( userRepository.findOne(id) )
            .map( user -> ResponseEntity.ok().body(user) )          //200 OK
            .orElseGet( () -> ResponseEntity.notFound().build() );  //404 Not found
}

URL: https://www.nullpointer.at/orders/<@PathParam>/?queryParamName=<@QueryParm>

Jersey (JAX-RS) (javax.ws.rs.) @PathParam @QueryParam

PathParam  E.g. a class annotated with: @Path("widgets/{id}") can have methods annotated whose arguments are annotated with @PathParam("id").
QueryParam E.g. if the parameter name is "a b" then the value of the annotation is "a b", not "a+b" or "a%20b".

@Get
@Path("/orders/{id}")
public String getOrder(@PathParam("id") final String id, @QueryParam("queryParamName") int i) {
  return "Order ID: " + id;
}

Spring RESTFul(org.springframework.web.bind.annotation.) @PathVariable, @RequestParam

The @PathVariable annotation is used for data passed in the URI (e.g. RESTful web services) while @RequestParam is used to extract the data found in query parameters.

//@RequestMapping(value = "/orders/{id}", method = RequestMethod.GET)
@GetMapping("/orders/{id}")
@ResponseBody
public String getOrder(@PathVariable final String id, @RequestParam("queryParamName") int i) {
  return "Order ID: " + id;
}

See

• Spring Boot: Prevent decoding for @RequestParam
• Spring @RequestParam vs @PathVariable Annotations

There are basically two types of IOC Containers in Spring:

1. BeanFactory Container: BeanFactory is like a factory class that contains a collection of beans. It instantiates the bean whenever asked for by clients.
2. ApplicationContext Container: The ApplicationContext interface is built on top of the BeanFactory interface.

There are five types of spring bean scopes:

• singleton - only one instance of the spring bean will be created for the spring container. This is the default spring bean scope. While using this scope, make sure bean doesn’t have shared instance variables otherwise it might lead to data inconsistency issues.
• prototype – A new instance will be created every time the bean is requested from the spring container.
• request – This is same as prototype scope, however it’s meant to be used for web applications. A new instance of the bean will be created for each HTTP request.
• session – A new bean will be created for each HTTP session by the container.
• global-session – This is used to create global session beans for Portlet applications.

Spring IOC Object creation
 * SingleTon
 * prototype
bean.getBean(); // T1 thread, hold object for 1min
bean.getBean(); // T2 thread check object same for single ton & new object for prototype.

Spring Boot DevTools helps you to increase the productivity of the developer. So, you don't require to redeploy your application every time you make the changes. It allows the developer to reload changes without the need of restarting of the server.

Spring Boot support the main three embedded containers:

1. Tomcat
2. Jetty
3. Undertow. By default, it uses Tomcat as an embedded container.

ambiguity problem - NoUniqueBeanDefinitionException

Interface Car {                   |  @Component                             |  @Configuration                
                              |  @Qualifier("tataCar")                  |  public class Config {
}                             |  public class Tata implements Car {     |   
class Tata implements Car {      |      //...                              |      @Bean
                              |  }                                      |      public Car tatCar() {
}                             |                                         |          return new Tata();
class Maruthi implements Car {   |  @Component                             |      }
                              |  @Qualifier("maruthiCar")               |   
}                             |  public class Maruthi implements Car {  |      @Bean
                              |      //...                              |      @Primary
                              |  }                                      |      public Car maruthiCar() {
                              |                                         |          return new Maruthi();
                              |                                         |      }
                              |                                         |  }
																	    | 
@Component
public class CarsService {
     
    @Autowired
    private Car car; // Spring finds multiple beans of the same type
}

If more than one bean of the same type is available in the container, the framework will throw NoUniqueBeanDefinitionException

If we try to load CarsService into our context, the Spring framework will throw a NoUniqueBeanDefinitionException. This is because Spring doesn't know which bean to inject. To avoid this problem, there are several solutions;

@Qualifier, @Primary Annotation

It's worth noting that if both the @Qualifier and @Primary annotations are present, then the @Qualifier annotation will have precedence. Basically, @Primary defines a default, while @Qualifier is very specific.

Autowiring by Name

Another way to decide between multiple beans when autowiring, is by using the name of the field to inject. This is the default in case there are no other hints for Spring.

@Component
public class CarsService {
     
    @Autowired
    private Car tata; // Spring injects tata since the field name is matched to the value that we used in the @Component annotation for that bean.
}