import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
It helps us to modify the message i.e response object before it is written to the Response body.
boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType)
The MethodParameterargument helps us to check from which class and method the Request is coming and return the boolean value. Based on it the BeforeBodyRead Method is Called.
T beforeBodyWrite(@Nullable T body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response)
@RestControllerAdvice public class DemoControllerAdvice implements ResponseBodyAdvice<Map<String, String>> { @Override public boolean supports( MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) { String className = returnType.getContainingClass().toString(); String methodName = returnType.getMethod().toString(); if (className.contains("DemoController_") && methodName.contains("ResponseModification")) { return true; } return false; } @Override public Map<String, String> beforeBodyWrite( Map<String, String> body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) { body.put("body_data", "Age of the Person is 25 years"); return body; } }
@ControllerAdvicepublic class ResponseBodyInterceptor implements ResponseBodyAdvice<Object> { @Override public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) { return true; } @Override public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) { ... return body; } }
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdviceAdapter;@ControllerAdvicepublic class RequestBodyInterceptor extends RequestBodyAdviceAdapter {@AutowiredHttpServletRequest request;@Overridepublic Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {...return super.afterBodyRead(body, inputMessage, parameter, targetType, converterType);}@Overridepublic boolean supports(MethodParameter methodParameter, Type targetType,Class<? extends HttpMessageConverter<?>> converterType) {return true;}}
import org.springframework.cloud.gateway.filter.GatewayFilterChain;import org.springframework.cloud.gateway.filter.GlobalFilter;import org.springframework.core.Ordered;import org.springframework.core.io.buffer.DataBuffer;import org.springframework.http.HttpStatus;import org.springframework.http.server.reactive.ServerHttpResponse;import org.springframework.web.server.ServerWebExchange;import reactor.core.publisher.Mono;import java.nio.charset.StandardCharsets;public class PostGlobalFilter implements GlobalFilter, Ordered {...@Overridepublic int getOrder() {return 0;}}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
return chain.filter(exchange).then(Mono.fromRunnable(()->{
ServerHttpResponse response = exchange.getResponse();
HttpStatus responseStatus = response.getStatusCode();
if(responseStatus.equals(HttpStatus.BAD_REQUEST)){
String newResponseBody =
"<body>\n" +
"<h1 style=\"color:red;text-align:center\">Bad Request </h1>\n" +
"<p>If you are seeing this page it means response body is modified.</p>\n" +
"</body>";
DataBuffer dataBuffer = response.bufferFactory()
.wrap(newResponseBody.getBytes(StandardCharsets.UTF_8));
response.getHeaders().setContentLength(newResponseBody.length());
response.writeWith(Mono.just(dataBuffer)).subscribe();
exchange.mutate().response(response).build();
}
}));
}Spring Boot provides profiles that help to create environment-specific configurations and stereotypes in the applications.
In spring boot 3.0.x onwards all the deprecated methods of 2.7.x have been removed. spring.profiles.include one of them that has been removed from spring boot. Instead of spring.profiles.include, spring boot has introduced spring.profiles.group in spring 2.4.x onwards. you have to make multiple groups based on profiles like spring.profiles.group.{env}={profile1},{profile2} in application.properties file.
spring.profiles={env} is also removed, use spring.config.activate.on-profile={env}.
spring.profiles.group.dev=common
spring.profiles.group.prod=commonProfile Groups is another feature added in Boot 2.4. using this feature you can have multiple profiles activated under one group of profiles.spring.profiles.group.development[0]=devdbspring.profiles.group.development[1]=devkafkaThe application can now be started using --spring.profiles.active=development to active the development, devdb and devkafka profiles in one hit.
In spring boot 2.4.x spring.profiles.include marked as deprecated which will be removed in spring boot 3.0.0To support the previous configuration, you can add the below line in application.properties.spring.config.use-legacy-processing=true
spring.profiles.include=common
spring.profiles.active=devjava -jar -Dspring.profiles.active=dev application.jar
# or
java -jar application.jar --spring.profiles.active=devjava -Dspring.profiles.active=dev,container -jar build/libs/dockeriser-0.0.1-SNAPSHOT.jarexport spring_profiles_active=dev
@Autowired
private ConfigurableEnvironment env;
...
env.setActiveProfiles("dev");
spring.profiles.active=dev,localspring:
profiles:
active: devIf you prefer to have only one configuration (application.yml) file in your project, then you can separate each profile configuration using three dashes.If you see in the above example, there are three sections, which are separated by three dashes. First section is for common properties which are enabled for all the spring profiles. Second section is for integration-test spring profile and third one is for prod profile.
import org.springframework.dao.DataAccessException;
Zipkin is a distributed instrumentation and monitoring tool that will allow us to collect service information and perform searches on it. With the aim of finding problems in the latency of them, mainly through evaluating how long it has taken the execution of those services.
By default, our services will try to send trace messages to localhost:9411. If OpenZipkin runs at a different address, you need to specify it in the settings of each service:
spring: zipkin: base-url: http://<host>:<port>
spring.zipkin.sender.type=rabbitspring.zipkin.rabbitmq.queue=zipkin....
http://localhost:9411/
docker run -d -p 9411:9411 openzipkin/zipkin
version: "3.1" services: zipkin: image: openzipkin/zipkin:2 ports: - "9411:9411"
version: "3.9"
services:
microservices_postgresql:
image: postgres:latest
container_name: microservices_postgresql
expose:
- "5432"
ports:
- "5432:5432"
restart: always
environment:
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=postgres
- POSTGRES_DB=bank_accounts
- POSTGRES_HOST=5432
command: -p 5432
volumes:
- ./docker_data/microservices_pgdata:/var/lib/postgresql/data
networks: [ "microservices" ]
redis:
image: redis:latest
container_name: microservices_redis
ports:
- "6379:6379"
restart: always
networks: [ "microservices" ]
prometheus:
image: prom/prometheus:latest
container_name: prometheus
ports:
- "9090:9090"
command:
- --config.file=/etc/prometheus/prometheus.yml
volumes:
- ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro
networks: [ "microservices" ]
node_exporter:
container_name: microservices_node_exporter
restart: always
image: prom/node-exporter
ports:
- '9101:9100'
networks: [ "microservices" ]
grafana:
container_name: microservices_grafana
restart: always
image: grafana/grafana
ports:
- '3000:3000'
networks: [ "microservices" ]
zipkin:
image: openzipkin/zipkin:latest
restart: always
container_name: microservices_zipkin
ports:
- "9411:9411"
networks: [ "microservices" ]
networks:
microservices:
name: microservices
