Technology | Hecklers in Development

Hecklers in Development
Code, coffee, & camaraderie. Collection, unordered. ;)

For this example, we’ll create a very simple RestController so we have something in our provider microservice to contact from a consumer service. Here is the entirety of the relevant code:

	package com.example.szproviderservice;

	import lombok.extern.java.Log;
	import org.springframework.boot.SpringApplication;
	import org.springframework.boot.autoconfigure.SpringBootApplication;
	import org.springframework.web.bind.annotation.GetMapping;
	import org.springframework.web.bind.annotation.RestController;

	@SpringBootApplication
	public class SzProviderServiceApplication {

	public static void main(String[] args) {
	SpringApplication.run(SzProviderServiceApplication.class, args);
	}
	}

	@Log
	@RestController
	class ProviderController {
	@GetMapping("/hi")
	public String sayHello() {
	log.info("Logging GET request to /hi");
	return "Hello there!";
	}
	}

view raw ProviderController hosted with

by GitHub

The only thing of particular note is the @Log statement. Lombok provides this capability to reduce the usual boilerplate code required to get a logger via LogFactory.

Creating a consumer service

For the purpose of this introduction, little changes between provider and consumer project configuration & code. Here are the exceptions:

Revisiting the Spring Initializr, we change the artifact name to sz-consumer-service, keeping the same dependencies
We add the following entries to our consumer microservice’s application.properties file:

spring.application.name=sz-consumer-service
server.port=8081

NOTE: We’re running the provider on port 8080 (Tomcat’s default port), so we change our consumer service’s port to 8081 to avoid conflict.

This is the code for our consumer:

	package com.example.szconsumerservice;

	import lombok.extern.java.Log;
	import org.springframework.boot.SpringApplication;
	import org.springframework.boot.autoconfigure.SpringBootApplication;
	import org.springframework.context.annotation.Bean;
	import org.springframework.web.bind.annotation.GetMapping;
	import org.springframework.web.bind.annotation.RestController;
	import org.springframework.web.client.RestOperations;
	import org.springframework.web.client.RestTemplate;

	@SpringBootApplication
	public class SzConsumerServiceApplication {
	@Bean
	RestOperations restOperations() {
	return new RestTemplate();
	}

	public static void main(String[] args) {
	SpringApplication.run(SzConsumerServiceApplication.class, args);
	}
	}

	@Log
	@RestController
	class ConsumerController {
	private final RestOperations restOperations;

	ConsumerController(RestOperations restOperations) {
	this.restOperations = restOperations;
	}

	@GetMapping("/greet")
	public String getGreeting() {
	log.info("Logging GET request to /greet for " + this.getClass().toString());
	return restOperations.getForObject("http://localhost:8080/hi", String.class);
	}
	}

view raw ConsumerController hosted with

by GitHub

The same note about Lombok’s @Log applies here as well, of course.

The results

Running the two applications, we can now access the consumer’s endpoint from httpie, cURL, or a browser:

	humbert :: ~ » http :8081/greet
	HTTP/1.1 200
	Content-Length: 12
	Content-Type: text/plain;charset=UTF-8
	Date: Tue, 27 Jun 2017 20:19:00 GMT

	Hello there!

	humbert :: ~ »

view raw sz-consumer-service GET hosted with

by GitHub

Doing so results in the following log entries from our consumer service:

2017-06-27 15:21:45.029  INFO [sz-consumer-service,6cb9e5c7261f9d64,6cb9e5c7261f9d64,false] 3272 --- [nio-8081-exec-8] c.e.s.ConsumerController                 : Logging GET request to /greet for class com.example.szconsumerservice.ConsumerController

view raw sz-consumer-service log entry hosted with

by GitHub

And our provider service:

2017-06-27 15:21:45.032  INFO [sz-provider-service,6cb9e5c7261f9d64,85714e4c9db87eaa,false] 3260 --- [nio-8080-exec-9] c.e.s.ProviderController                 : Logging GET request to /hi

view raw sz-provider-service log entry hosted with

by GitHub

Examining our log entries for both services (above), we see that Spring Cloud Sleuth has placed our spring.application.name (as designated in each service’s application.properties), the appropriate trace id, and the span id specific to this hop within the logged information.

Summary

Of course, Sleuth captures much more data and allows for extensive customization (including enabling additional elements you specify to be captured, adjusting sampling rates, & more), and Zipkin remains a topic for another day. But this post should have provided a quick springboard (!) into using Spring Cloud Sleuth for better insight into your microservices-based system of systems.

Happy Sleuthing!

Like this post? Follow me on Twitter for more! And be sure to check out the Related Posts below.

Additional information

Github repo with code with code from this post

Distributed Tracing with Spring Cloud Sleuth and Spring Cloud Zipkin

Tags: Dapper, java, Sleuth, span, Spring, Spring Boot, Spring Cloud, Spring Cloud Sleuth, Spring Framework, trace, tracing, Zipkin

Jun

21.

T4SD (Tips 4 Spring Devs): How to get Spring Boot REST endpoints to speak XML

2 Comments

Category: Java, Spring

Many of us use JSON almost exclusively now, which is generally a good thing. But what happens when you need to “speak XML” with your Spring Boot REST endpoints?

XML support in Spring Boot’s REST endpoints is not enabled by default, but adding it isn’t difficult at all. Simply add the following dependency to your POM (or similar entry to your Gradle build file, if that’s the way you roll) and rebuild:

	<dependency>
	<groupId>com.fasterxml.jackson.dataformat</groupId>
	<artifactId>jackson-dataformat-xml</artifactId>
	</dependency>

view raw JacksonXMLdep hosted with

by GitHub

Now, to test our results. To do so, I’m using the excellent httpie, with its shortcut that allows the omission of the hostname for localhost.

JSON

	humbert :: ~ » http :8080
	HTTP/1.1 200
	Content-Type: application/json;charset=UTF-8
	Date: Wed, 21 Jun 2017 07:42:27 GMT
	Transfer-Encoding: chunked

	{
	"myKey": "myValue"
	}

view raw Something endpoint: JSON hosted with

by GitHub

XML

	humbert :: ~ » http :8080 'Accept:application/xml'
	HTTP/1.1 200
	Content-Type: application/xml;charset=UTF-8
	Date: Wed, 21 Jun 2017 07:42:36 GMT
	Transfer-Encoding: chunked

	<Map><myKey>myValue</myKey></Map>

view raw Something endpoint: XML hosted with

by GitHub

Note that no changes are required to your code, as Spring Boot assesses your classpath and adds XML support via auto-configuration. Simple and painless!

Thanks for reading, be sure to follow me on Twitter for future tips!

Keep coding,

Mark

Tags: dataformat, endpoint, Jackson, jackson-dataformat-xml, JSON, REST, Spring, Spring Boot, T4SD, Tips 4 Spring Devs, XML

Jun

08.

Spring Tip: Request header filtering in @RequestMapping

1 Comment

Category: Java, Life in General, Spring

Just a quick tip for the Spring fans out there…

I was leading a workshop yesterday and this question arose: Is it possible to filter requests by header content using Spring’s various request mapping (@RequestMapping, @GetMapping, @PostMapping, et al) annotations?

Not only is it possible, it’s easy, and the implementation is concise & clean! Let’s take a look.

The code

Here is a simple example that filters based upon the content-type of the header:

	@RestController
	class MapFilterController {

	@GetMapping(value = "/test", headers = "content-type=text/*")
	public String getTestText() {
	return "This is a test, using text.";
	}

	@GetMapping(value = "/test", headers = "content-type=application/json")
	public Map<String, String> getTestJson() {
	return Collections.singletonMap("testKey", "testValue");
	}

	}

view raw RequestHeaderFilterExample hosted with

by GitHub

To test this, simply visit the Spring Initializr, create a simple Spring Boot app with a single dependency (Web), download & unzip it, and add the code above using your favorite IDE. Then build & run it (of course)!

The output

Using httpie (which is quickly becoming my favorite CLI HTTP client), we can verify our results:

Request content type of text/plain

	>> http :8080/test content-type:text/plain

	HTTP/1.1 200
	Content-Length: 27
	Content-Type: text/plain;charset=UTF-8
	Date: Thu, 08 Jun 2017 15:46:30 GMT
	X-Application-Context: application

	This is a test, using text.

view raw RequestHeaderFilterTestTextPlain hosted with

by GitHub

Request content type of application/json

	http --json :8080/test

	HTTP/1.1 200
	Content-Type: application/json;charset=UTF-8
	Date: Thu, 08 Jun 2017 15:47:22 GMT
	Transfer-Encoding: chunked
	X-Application-Context: application

	{
	"testKey": "testValue"
	}

view raw RequestHeaderFilterTestApplicationJson hosted with

by GitHub

NOTE: The above examples use httpie “shorthand”, which assumes localhost when the base URL is omitted.

That’s all for now, but stay tuned (or follow me on Twitter) for more quick (or more lengthy) Spring tips!

Cheers,
Mark

Click here for additional information

Tags: content type, filtering, GetMapping, java, request header, request header filtering, RequestMapping, Spring, Spring Boot

Jun

05.

Spring Tip: Spring Boot Actuator /actuator endpoint

No Comments

Category: Java, Spring

Just a quick tip for the Spring fans out there…

If you’ve decided to try out Spring Boot Actuator – and if you haven’t you really should! – you may have run into one of two interesting hitches that are easily resolved:

You are unable to access any of the various Actuator endpoints (/beans, /env, et al)
You can access those endpoints and yet are unable to access /actuator, the primary (navigable) Actuator endpoint

Unable to access any Actuator endpoints

In the case of point #1 above, you may see this in your logs:

s.b.a.e.m.MvcEndpointSecurityInterceptor : Full authentication is required to access actuator endpoints. Consider adding Spring Security or set ‘management.security.enabled’ to false.

For testing, it’s adequate and acceptable to simply add the suggested entry to your app’s application.properties file:

management.security.enabled=false

This is far less likely to be a suitable solution for production apps, though. Enabling Spring Security properly to secure access to your application is a far more production-ready option.

Unable to access /actuator

If you can load successfully the various Spring Boot Actuator endpoints but get a 404 error on /actuator, the primary (navigable) Actuator endpoint, you are hitting a different (yet also easily resolved) snag. The hint is in how I phrased the difficulty: the primary (navigable) Actuator endpoint.

In order to access /actuator, which uses hypermedia to provide a navigable structure of links to Actuator endpoints, you must include HATEOAS (spring-boot-starter-hateoas) on your classpath. Adding this to your POM will fix that nicely:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>

That’s all for now, but stay tuned (or follow me on Twitter) for more quick or lengthy Spring tips!

Cheers,
Mark

Click here for more information about Spring Boot Actuator.

Tags: Actuator, HATEOAS, java, management.security.enabled, security, Spring, Spring Boot, Spring Boot Actuator, Spring Security

	dependencies {
	compile('org.springframework.cloud:spring-cloud-starter-sleuth')
	compile('org.springframework.boot:spring-boot-starter-web')
	compileOnly('org.projectlombok:lombok')
	testCompile('org.springframework.boot:spring-boot-starter-test')
	}

Categories

Related Posts:

Distributed tracing: a (very) high-level overview

Minimum Viable Product

Creating a provider service

Creating a consumer service

The results

Summary

Additional information

Related Posts:

JSON

XML

Related Posts:

The code

The output

Request content type of text/plain

Request content type of application/json

Related Posts:

Unable to access any Actuator endpoints

Unable to access /actuator

Related Posts:

	<dependencies>
	<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-sleuth</artifactId>
	</dependency>
	<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	</dependency>
	<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-test</artifactId>
	<scope>test</scope>
	</dependency>
	</dependencies>