Zach Cochran
by Zach Cochran
3 min read



Still working my way through the tutorial. Lots of new concepts for me today, so I didn’t push through as much as I had hoped. But at least I learned a lot! Lots of juicy stuff like introducing me to singletons as well as basic dependency injection. Woo~

Just like the past few days, this is going to be more note dumping.

More Controller Stuff (mapping to method call)

  • We need to create a base class so that we can create some dummy data until we have access to the database (covering later)
  • We start by making a new class (Topic in this example)
  • Create class variables and then create getters and setters for each of them
    • Intellij can do this automatically for you! Go to Code -> Generate -> Getters and setters, and then select all of the variables for which they should be created.
  • Spring is going to automatically convert the object that we are returning into the correct JSON format for us. There’s nothing we need to do
  • In our example with sample data, we can do the following to initialize a bunch of dummy data to be returned
public List<Topic> getAllTopics() {
   return Arrays.asList(
           new Topic("spring", "Spring Framework", "Spring Framework Description"),
           new Topic("java", "Core Java", "Core Java Description"),
           new Topic("javascript", "JavaScript", "JavaScript Description")
  • The returned json keys will be equal to the class variables used in the main data class (Topic in this case)
    • Values will be what we passed in

Business Services

  • Just a normal Java class
  • In spring, business services are typically singletons
  • Class is marked using the @Service annotation in Spring
  • You can then make reference to this class by using dependency injection by using the @Autowired annotation.

Notes on Singletons

  • Notes coming from one of Derek’s videos.
  • Singletons are essentially a class that can only ever be instantiated once
  • If you try to create a second object using that class, it will error out as only one can be created
  • This is useful if you have a resource that should be shared amongst things and you don’t want multiple instances being created
  • Essentially it will check to see if the resource already exists. If it does, the resource is returned. If it doesn’t, it will be created, stored, and returned.

Lazy Instantiation

  • The way of only creating the instance if it is needed. If it’s not needed, it will never be created.
public class Singleton {
    private static Singleton firstInstance = null;
    private Singleton() { }

    public static Singleton getInstance() {
        if (firstInstance == null) {
            firstInstance = new Singleton();

Variables in Path

  • In order to support resources with variables in them, there’s two additional things that you need to do
  • The first is when defining the resource path. You’ll need to place the variable inside of {} brackets with the variable name inside to tell spring that it’s a variable
  • The next comes an annotation when defining the input to the method. You need to provide a @PathVariable inside of the input field to tell Spring how to map the variable in the path to the variables in the method.
  • If your variables match (path and method), then you only need the @PathVariable annotation.
  • If the variables don’t match, you’ll need to do @PathVariable("name")
   public Topic getTopic(@PathVariable("id") String id) {
       return topicService.getTopic(id);

Handling Post Requests

  • Extra annotation changes needed in order to change the specific method supported on a path
    • Note that you can actually break out the request logic based on method type (meaning having multiple methods for the same route)
  • Need to define supported method as well as specify route as a value parameter:
   @RequestMapping(value = "/topics", method = RequestMethod.POST)
  • In order for us to get the request body, we need another annotation called @RequestBody which will tell spring to grab the request body at that path:
@RequestMapping(value = "/topics", method = RequestMethod.POST)
   public void addTopic(@RequestBody Topic topic) {
  • Evidently you don’t even need to do the method type with RequestMapping as there’s actually an annotation for each of the types (if you’re only supporting one)
    • @GetMapping, @PostMapping, @PutMapping, @DeleteMapping all exist and will specify the method for you!