{"id":3094,"date":"2019-02-25T12:15:53","date_gmt":"2019-02-25T12:15:53","guid":{"rendered":"http:\/\/codethataint.com\/blog\/?p=3094"},"modified":"2024-10-07T14:41:21","modified_gmt":"2024-10-07T14:41:21","slug":"spring-annotations-interview-questions","status":"publish","type":"post","link":"https:\/\/codethataint.com\/blog\/spring-annotations-interview-questions\/","title":{"rendered":"Spring annotations interview questions"},"content":{"rendered":"

What are different ways to create Bean in Spring Boot?<\/strong><\/p>\n

    \n
  1. Using @Component<\/strong> over class – To create app specific bean<\/li>\n
  2. Using @Configuration<\/strong> over class and @Bean<\/strong> over method – To create bean from third party class added as JAR dependency. You cannot add component in added JAR class files.<\/li>\n<\/ol>\n

    What is Dependency Injection?<\/strong>
    \nDependency injection is basically providing the objects that an object needs (its dependencies) instead of having it construct them itself. <\/p>\n

    What are Types of Dependency Injection?<\/strong><\/p>\n

      \n
    1. Constructor Injection<\/strong> – Dependency provided as parameter to constructor. This ensures Object is fully initialized upon creation and promoting immutability<\/li>\n
    2. Setter Injection<\/strong> – Setter injection is having independent setter for each class attributes and calling setter method while initializing. Setter Injection allow more flexibility by allowing dependencies to be set or changed after object creation.<\/li>\n
    3. Field Injection<\/strong> – Field injection is old method of injecting dependencies by specifying the @Autowired over field name. It works based on Java reflection and it is not recommended as it makes code more difficult to test<\/li>\n<\/ol>\n

      What are Stereotype Annotations?<\/strong><\/p>\n

      Stereotype <\/em>– idea of a particular type of person or thing. <\/p><\/blockquote>\n

      Spring comes with 4 Stereotype annotations as below.<\/p>\n

      @Component<\/strong> is a generic stereotype for any Spring-managed component. @Repository, @Service, @Controller<\/strong> are specializations of @Component for more specific use cases (in the persistence, service, and presentation layers, respectively).
      \n\"\"<\/p>\n

        \n
      1. @Component<\/strong> general-purpose stereotype annotation indicating that the class is a spring component.<\/li>\n
      2. @Controller<\/strong> @Controller annotation indicates that a particular class serves the role of a controller. The dispatcher scans the classes annotated with @Controller and detects methods annotated with @RequestMapping annotations within them. We can use @RequestMapping on\/in only those methods whose classes are annotated with @Controller<\/li>\n
      3. @Repository<\/strong><\/li>\n

        stereotype for persistence layer. @Repository\u2019s job is to catch platform specific exceptions and re-throw them as one of Spring\u2019s unified unchecked exception. By masking the platform specific exception to spring unified exception it helps 1.Providing higher level of Abstraction for User 2.By throwing unchecked exception it prevents user from adding unnecessary boiler plate for exception handling by means of try catch blocks<\/p>\n

      4. @Service<\/strong> – @Service beans hold the business logic and call methods in the repository layer.<\/li>\n<\/ol>\n

        Note :<\/strong> Spring may add special functionalities for @Service, @Controller and @Repository based on their layering conventions.<\/em><\/p>\n

        How it is internally is all 3 are marked with @Component.@CompnentScan only scans @Component and does not look for @Controller, @Service and @Repository in general. They are scanned because they themselves are annotated with @Component. <\/p>\n

        \r\n@Component\r\npublic @interface Service {\r\n    \u2026.\r\n}\r\n\r\n@Component\r\npublic @interface Repository {\r\n    \u2026.\r\n}\r\n\r\n@Component\r\npublic @interface Controller {\r\n    \u2026\r\n}\r\n<\/pre>\n
        What happens when more than one bean of same type is found? What would be workaround?<\/strong>
        \nApplication would fail to start with error message Require Single bean but N beans found<\/em>. <\/p>\n
        This could be addressed in two ways<\/p>\n
          \n
        1. Using @Qualifier<\/strong> annotation<\/li>\n
        2. Using @Primary<\/strong> annotation<\/li>\n<\/ol>\n
          @Qualifier<\/strong> annotation takes bean Id as value to uniquely identify a bean.<\/p>\n
          StudentController.java<\/strong><\/p>\n
          public class StudentController{\r\n .\r\n @Autowired\r\n public StudentController(@Qualifier("student") Person person){\r\n .\r\n }\r\n}\r\n<\/pre>\n
          Student.java<\/strong><\/p>\n
          @Component\r\npublic class Student implements Person{\r\n.\r\n}\r\n<\/pre>\n
          @Primary<\/strong> annotation works by giving first preference to bean which is marked with @Primary annotation. If two beans are marked with @Primary annotation then Spring boot throws an error. If both @Primary and @Qualifier annotation is used, then @Qualifier annotation takes preference.<\/p>\n
          @Primary vs @Qualifier Which one takes precedence?<\/strong>
          \n@Qualifier takes precedence over @Primary annotation. <\/p>\n
          What does @Lazy annotation do?<\/strong>
          \nUnlike the bean which are marked with @Component are loaded at startup when the app start, @Lazy annotation does the bean loading only when it is needed.<\/p>\n
          This can be Configured globally as well by specifying in application.properties as below. If your application has lot of components and because of this the app takes long time to start then its better to use this.<\/p>\n
          application.properties<\/strong><\/p>\n
          \r\nspring.main.lazy-initialization=true\r\n<\/pre>\n
          Note:<\/strong> If you use @Lazy annotation along with @Restcontroller it may lead to timeout issues.<\/em><\/p>\n
          \"\"<\/p>\n
          Report.java<\/strong><\/p>\n
          \r\npublic interface Report {\r\n    String generateReport();\r\n}\r\n<\/pre>\n
          PDFReport.java<\/strong><\/p>\n
          \r\n@Primary\r\n@Component\r\npublic class PDFReport implements Report{\r\n    public PDFReport() {\r\n        System.out.println("Loaded PDFReport");\r\n    }\r\n\r\n    @Override\r\n    public String generateReport() {\r\n        return "PDF Report";\r\n    }\r\n}\r\n<\/pre>\n
          excelReport.java<\/strong><\/p>\n
          \r\n@Component\r\npublic class excelReport implements Report{\r\n    public excelReport() {\r\n        System.out.println("Loading Excel Report");\r\n    }\r\n\r\n    @Override\r\n    public String generateReport() {\r\n        return "Excel Report";\r\n    }\r\n}\r\n<\/pre>\n
          textReport.java<\/strong><\/p>\n
          \r\n@Component\r\n@Lazy\r\npublic class textReport implements Report{\r\n    public textReport() {\r\n        System.out.println("Loading textReport Report");\r\n    }\r\n    @Override\r\n    public String generateReport() {\r\n        return "Text Report";\r\n    }\r\n}\r\n<\/pre>\n
          GenerateReport.java<\/strong><\/p>\n
          \r\n@RestController\r\npublic class GenerateReport {\r\n    private Report report;\r\n\r\n    public GenerateReport(@Qualifier("excelReport") Report report){\r\n        this.report = report;\r\n    }\r\n\r\n    @GetMapping("\/generateReport")\r\n    public String generateReport(){\r\n        return "Printing report in "+ report.generateReport() + " format";\r\n    }\r\n}\r\n<\/pre>\n
          Excel Report format would be printed as @Qualifier would take precedence
          \nOutput in Browser(http:\/\/localhost:8080\/generateReport)<\/strong><\/p>\n
          \r\nLoading Excel Report\r\nLoaded PDFReport\r\n\r\nPrinting report in Excel Report format\r\n<\/pre>\n
          What are different Bean Scopes?<\/strong>
          \nSingleton<\/strong> – Only one bean for Container, served same bean for every access
          \nPrototype<\/strong> – New bean for every access
          \nRequest<\/strong> – New bean for every request
          \nSession<\/strong> – Only one bean for Session
          \nApplication<\/strong> – Only one bean for Application
          \nWebsocket<\/strong> – <\/p>\n
          @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)<\/p><\/blockquote>\n
          Checking Object based on Bean Scope – Singleton<\/strong>
          \nexcelReport bean with Singleton scope returning same bean every access<\/em>
          \nexcelReport.java<\/strong><\/p>\n
          \r\n@Component\r\npublic class excelReport implements Report{\r\n.\r\n.\r\n}\r\n<\/pre>\n
          GenerateReport.java<\/strong><\/p>\n
          \r\n@RestController\r\npublic class GenerateReport {\r\n    private Report report1;\r\n    private Report report2;\r\n\r\n    public GenerateReport(@Qualifier("excelReport") Report report1, @Qualifier("excelReport") Report report2){\r\n        this.report1 = report1;\r\n        this.report2 = report2;\r\n    }\r\n\r\n    @GetMapping("\/checkBean")\r\n    public String checkBean(){\r\n        if(report1 == report2){\r\n            return "Bean are Same";\r\n        }else{\r\n            return  "Bean are Different";\r\n        }\r\n    }\r\n}\r\n<\/pre>\n
          Output(http:\/\/localhost:8080\/checkBean)<\/strong><\/p>\n
          \r\nBean are Same\r\n<\/pre>\n
          Checking Object based on Bean Scope – Prototype<\/strong>
          \npdfReport bean with Prototype scope returning different bean on every access<\/em>
          \nPDFReport.java<\/strong><\/p>\n
          \r\n@Primary\r\n@Component\r\n@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)\r\npublic class PDFReport implements Report{\r\n  .\r\n  .\r\n}\r\n<\/pre>\n
          GenerateReport.java<\/strong><\/p>\n
          \r\n@RestController\r\npublic class GenerateReport {\r\n    private Report report1;\r\n    private Report report2;\r\n\r\n    public GenerateReport(Report report1, Report report2){\r\n        this.report1 = report1;\r\n        this.report2 = report2;\r\n    }\r\n\r\n    @GetMapping("\/checkBean")\r\n    public String checkBean(){\r\n        if(report1 == report2){\r\n            return "Bean are Same";\r\n        }else{\r\n            return  "Bean are Different";\r\n        }\r\n    }\r\n}\r\n<\/pre>\n
          Output(http:\/\/localhost:8080\/checkBean)<\/strong><\/p>\n
          \r\nBean are Different\r\n<\/pre>\n
          How to inject bean created using new Operator or Injecting Spring beans into non-managed objects<\/strong>
          \nObjects for 3rd party JAR are created using @Configuration at class level and using @Bean at method level. This is one other way to create bean other than @Component as
          \nwe wont be able to change the source of 3rd party class files.<\/p>\n
            \n
          1. Using @Configuration and @Bean annotation<\/li>\n
          2. Using @Configurable refer here<\/a><\/li>\n
          3. using AutowireCapableBeanFactory<\/li>\n<\/ol>\n
            Let take the below code<\/p>\n
            \r\npublic class MyBean \r\n{\r\n    @Autowired \r\n    private AnotherBean anotherBean;\r\n}\r\n\r\nMyBean obj = new MyBean();\r\n<\/pre>\n
            I have a class doStuff in which the obj of MyBean created using new operator needs to be injected. To do this use AutowireCapableBeanFactory and call autowireBean method with beanFactory reference.<\/p>\n
            \r\nprivate @Autowired AutowireCapableBeanFactory beanFactory;\r\n\r\npublic void doStuff() {\r\n   MyBean obj = new MyBean();\r\n   beanFactory.autowireBean(obj);\r\n   \/\/obj will now have its dependencies autowired.\r\n}\r\n<\/pre>\n
            What is the Difference between @Inject and @Autowired in Spring Framework? <\/strong>
            \n@Inject specified in javax.inject.Inject annotations is part of the Java CDI (Contexts and Dependency Injection) standard introduced in Java EE 6 (JSR-299). Spring has chosen to support using @Inject synonymously with their own @Autowired annotation.@Autowired is Spring’s own (legacy) annotation. @Inject is part of a new Java technology called CDI that defines a standard for dependency injection similar to Spring. In a Spring application, the two annotations work the same way as Spring has decided to support some JSR-299 annotations in addition to their own.<\/p>\n
            Use of the Following in Spring Framework? <\/strong>
            \n@RequestMapping<\/strong> – All incoming requests are handled by the Dispatcher Servlet and it routes them through the Spring framework. When the Dispatcher Servlet receives a web request, it determines which controllers should handle the incoming request. Dispatcher Servlet initially scans all the classes that are annotated with the @Controller annotation. The dispatching process depends on the various @RequestMapping annotations declared in a controller class and its handler methods.The @RequestMapping annotation is used to map the web request onto a handler class (i.e. Controller) or a handler method and it can be used at the Method Level or the Class Level.<\/p>\n
            Example<\/em> – for the URL http:\/\/localhost:8080\/ProjectName\/countryController\/countries<\/p>\n
            \r\n@Controller\r\n@RequestMapping(value = "\/countryController")\r\npublic class CountryController {\r\n \r\n @RequestMapping(value = "\/countries", method = RequestMethod.GET, headers = "Accept=application\/json")\r\n public List getCountries() {\r\n    \/\/ Some Business Logic\r\n } \r\n<\/pre>\n\n\n\n\n\n\n\n
            Annotations<\/th>\nEquivalent<\/th>\n<\/tr>\n
            @GetMapping   <\/td>\n@RequestMapping(method = RequestMethod.GET)<\/td>\n<\/tr>\n
            @PostMapping  <\/td>\n@RequestMapping(method = RequestMethod.POST)<\/td>\n<\/tr>\n
            @PutMapping   <\/td>\n@RequestMapping(method = RequestMethod.PUT)<\/td>\n<\/tr>\n
            @DeleteMapping<\/td>\n@RequestMapping(method = RequestMethod.DELETE)<\/td>\n<\/tr>\n
            @PatchMapping <\/td>\n@RequestMapping(method = RequestMethod.PATCH) <\/td>\n<\/tr>\n<\/table>\n
            @RequestParam<\/strong> – By using RequestParam we can get parameters to the method<\/p>\n
            \r\n@RequestMapping(value = "\/display", method = RequestMethod.GET)\r\npublic String showEmployeeForm(@RequestParam("empId") String empId) {\r\n        \/\/ Some Business Logic\r\n}\r\n<\/pre>\n
            @Pathvariable<\/strong> – @PathVariable is to obtain some placeholder from the URI
            \nIf empId and empName as parameters to the method showEmployeeForm() by using the @PathVariable annotation. For e.g.: \/employee\/display\/101\/Mux
            \nempId = 101
            \nempName = Mux<\/p>\n
            \r\n@Controller\r\n@RequestMapping(value = "\/employee")\r\npublic class EmployeeController {\r\n    @RequestMapping(value = "\/display\/{empId}\/{empName}")\r\n    public ModelAndView showEmployeeForm(@PathVariable String empId, @PathVariable String empName) {\r\n                \/\/ Some Business Logic\r\n    } \r\n}\r\n<\/pre>\n
            What is the Difference between @RequestParam vs @PathVariable? <\/strong>
            \n@RequestParam annotation has following attributes<\/p>\n
            \r\nhttp:\/\/localhost:8080\/springmvc\/hello\/101?param1=10¶m2=20\r\n<\/pre>\n
            \r\npublic String getDetails(\r\n    @RequestParam(value="param1", required=true) String strParam1,\r\n        @RequestParam(value="param2", required=false,  defaultValue = "John") String strParam2){\r\n...\r\n}\r\n\r\n<\/pre>\n
            @PathVariable is always considered required and cannot be null whereas @RequestParam could be null<\/strong> <\/p>\n
            @RequestParam annotation can specify default values if a query parameter is not present or empty by using a default Value attribute, provided the required attribute is false. . If a corresponding path segment is missing, Spring will result in a 404 Not Found error. <\/p>\n\n\n\n\n\n
            defaultValue<\/td>\nThis is the default value as a fallback mechanism if request is not having the value or it is empty. i.e param1<\/em> <\/td>\n<\/tr>\n
            name <\/td>\nName of the parameter to bind i.e param1<\/em> <\/td>\n<\/tr>\n
            required    <\/td>\nWhether the parameter is mandatory or not. If it is true, failing to send that parameter will fail. i.e false<\/em> <\/td>\n<\/tr>\n
            value       <\/td>\nThis is an alias for the name attribute  i.e param1<\/em>                                                              <\/td>\n<\/tr>\n<\/table>\n
            @PathVariable is to obtain some placeholder from the URI (Spring call it an URI Template)  and @RequestParam is to obtain an parameter from the URI as well.@PathVariable annotation has only one attribute value for binding the request URI template. It is allowed to use the multiple @PathVariable annotation in the single method. But, ensure that no more than one method has the same pattern.Annotation which indicates that a method parameter should be bound to a name-value pair within a path segment. Supported for RequestMapping annotated handler methods.<\/p>\n
            \r\nlocalhost:8080\/person\/Tom;age=25;height=175 and Controller:\r\n<\/pre>\n
            \r\n@GetMapping("\/person\/{name}")\r\n@ResponseBody\r\npublic String person(\r\n    @PathVariable("name") String name, \r\n    @MatrixVariable("age") int age,\r\n    @MatrixVariable("height") int height) {\r\n\r\n    \/\/ ...\r\n}\r\n<\/pre>\n
            How Spring will decide bean if there are multiple implementation of Same Instance?<\/strong><\/p>\n
            In such case it would fail at start telling expected 1 bean but found n bean <\/p><\/blockquote>\n
            We can use @Qualifier<\/strong> annotation where we can decide the bean to be loaded based on the beanId. beanId is always the component name with camel casing<\/p>\n
            \r\npublic class GenerateReport {\r\n    private Report report1;\r\n    private Report report2;\r\n\r\n    public GenerateReport(@Qualifier("excelReport") Report report1, Report report2){\r\n        this.report1 = report1;\r\n        this.report2 = report2;\r\n    }\r\n}\r\n<\/pre>\n
            What BeanLife cycle methods are available?<\/strong><\/p>\n
            @PostConstruct and @PreDestroy<\/p>\n
            \r\n@Component\r\npublic class excelReport implements Report{\r\n    public excelReport() {\r\n        System.out.println("Loading Excel Report");\r\n    }\r\n\r\n    @Override\r\n    public String generateReport() {\r\n        return "Excel Report";\r\n    }\r\n\r\n    @PreDestroy\r\n    public void doCleanUpStuff(){\r\n        System.out.println("Disposing ExcelReport....: Prints when Server Stops");\r\n    }\r\n\r\n    @PostConstruct\r\n    public void doStartUpStuff(){\r\n        System.out.println("Completed Initialization ExcelReport...: Prints when Server Starts");\r\n    }\r\n}\r\n<\/pre>\n
            Output – When Server Starts<\/strong><\/p>\n
            \r\nCompleted Initialization ExcelReport...: Prints when Server Starts\r\n<\/pre>\n
            Output – When Server Stops<\/strong><\/p>\n
            \r\nDisposing ExcelReport....: Prints when Server Stops\r\n<\/pre>\n
            What is use of @RequestBody and @ResponseBody?<\/strong><\/p>\n
              \n
            1. @RequestBody and @ResponseBody used in controller to implement smart object serialization and deserialization. They help you avoid boilerplate code by extracting the logic of message conversion and making it an aspect. Other than that they help you support multiple formats for a single REST resource without duplication of code.\n<\/li>\n
            2. If you annotate a method with @ResponseBody, spring will try to convert its return value and write it to the http response automatically. <\/li>\n
            3. If you annotate a methods parameter with @RequestBody, spring will try to convert the content of the incoming request body to your parameter object on the fly.<\/li>\n<\/ol>\n
              What is @Transactional used for?<\/strong>
              \nWhen Spring loads your bean definitions, and has been configured to look for @Transactional annotations, it will create these proxy objects around your actual bean. These proxy objects are instances of classes that are auto-generated at runtime. The default behaviour of these proxy objects when a method is invoked is just to invoke the same method on the “target” bean (i.e. your bean).
              \nRefere here<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
              What are different ways to create Bean in Spring Boot? Using @Component over class – To create app specific bean Using @Configuration over class and @Bean over method – To create bean from third party class added as JAR dependency. You cannot add component in added JAR class files. What is Dependency Injection? Dependency injection… Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[368,192],"tags":[],"class_list":["post-3094","post","type-post","status-publish","format-standard","hentry","category-last-minute","category-interview"],"_links":{"self":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/3094","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/comments?post=3094"}],"version-history":[{"count":5,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/3094\/revisions"}],"predecessor-version":[{"id":5194,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/3094\/revisions\/5194"}],"wp:attachment":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/media?parent=3094"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/categories?post=3094"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/tags?post=3094"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}