{"id":3444,"date":"2019-05-25T05:42:39","date_gmt":"2019-05-25T05:42:39","guid":{"rendered":"http:\/\/codethataint.com\/blog\/?p=3444"},"modified":"2019-05-29T14:37:24","modified_gmt":"2019-05-29T14:37:24","slug":"core-spring-refresher","status":"publish","type":"post","link":"https:\/\/codethataint.com\/blog\/core-spring-refresher\/","title":{"rendered":"How, When, Why and What is Autowiring"},"content":{"rendered":"

Why we need Dependency Injection?<\/strong>
\nIts to overcome monotony behavior. If you are asking for Apple(from Apple.java) you would be served apple object. If you are asking for Mango(from Mango.java) you would be served mango object. Now in case, you are having Fruit and now you are asking Fruit(from Fruit.java) you would be served either apple or mango. Lets take a simple example as below<\/p>\n

    \n
  1. I have a banking application where I have Account Interface with calculateIntereest Method<\/li>\n
  2. I have different account types like SavingsAccount, PersonalLoanAccount and vehicleLoanAccount, HousingLoanAccount<\/li>\n
  3. I have a Customer class where he would own a particular account type which wont be known until runtime<\/li>\n<\/ol>\n

    Accounts.java<\/strong><\/p>\n

    \r\npackage com.mugil.core;\r\n\r\npublic interface Accounts \r\n{\r\n public Integer calculateInterest();\r\n}\r\n<\/pre>\n
    SavingsAccount.java<\/strong><\/p>\n
    \r\npackage com.mugil.core;\r\n\r\npublic class SavingsAccount implements Accounts \r\n{\r\n public Integer calculateInterest() \r\n {\r\n  return 8;\r\n }\r\n}\r\n<\/pre>\n
    Customer.java<\/strong><\/p>\n
    \r\npackage com.mugil.core;\r\n\r\npublic class Customer {\r\n Accounts accountType;\r\n\r\n public Customer(Accounts paccountType) {\r\n  this.accountType = paccountType;\r\n }\r\n\r\n public Accounts getAccountType() {\r\n  return accountType;\r\n }\r\n\r\n public void setAccountType(Accounts accountType) {\r\n  this.accountType = accountType;\r\n }\r\n}\r\n<\/pre>\n
    GetInterestFactory.java<\/strong><\/p>\n
    \r\npackage com.mugil.core;\r\n\r\npublic class GetInterestFactory {\r\n Accounts objAccount = null;\r\n\r\n public static void main(String[] args) {\r\n  GetInterestFactory objGetInterest = new GetInterestFactory();\r\n  objGetInterest.showInterestRate();\r\n }\r\n\r\n public void showInterestRate() {\r\n  String strAccType = "Savings";\r\n\r\n  switch (strAccType) {\r\n   case "Savings":\r\n    this.objAccount = new SavingsAccount();\r\n    break;\r\n   case "Vehicle":\r\n    this.objAccount = new VehicleLoanAccount();\r\n    break;\r\n   default:\r\n    this.objAccount = new SavingsAccount();\r\n    break;\r\n  }\r\n\r\n  System.out.println("Interest Rate - " + this.objAccount.calculateInterest());\r\n }\r\n}\r\n<\/pre>\n
    Output<\/strong><\/p>\n
    \r\nInterest Rate - 8\r\n<\/pre>\n
      \n
    1. In the above java code we decide the Account Type only when the switch case is executed<\/li>\n
    2. Until then the account type is kept as generic value using interface<\/li>\n<\/ol>\n
      Now what spring does is the same code can be rewritten to  determine the Account Type during runtime in setters and constructors as below<\/p>\n
      Dependency Injection without Spring using Java Constructor<\/strong><\/p>\n
        \n
      1. I have created a new class VehicleLoanAccount.java which has a different interest rate<\/li>\n
      2. Now I am going to decide the account type in the Person.java in its constructor as below<\/li>\n<\/ol>\n
        VehicleLoanAccount.java<\/strong><\/p>\n
        \r\npackage com.mugil.core;\r\n\r\npublic class VehicleLoanAccount implements Accounts {\r\n public Integer calculateInterest() {\r\n  return 11;\r\n }\r\n\r\n}\r\n<\/pre>\n
        Dependency Injection without Spring using Java Constructor<\/em>
        \nGetInterestConsWithoutSpring .java<\/strong><\/p>\n
        \r\npackage com.mugil.core;\r\n\r\npublic class GetInterestConsWithoutSpring {\r\n public static void main(String[] args) {\r\n  Customer objPerson = new Customer(new SavingsAccount());\r\n  System.out.println("Interest Rate - " + objPerson.getAccountType().calculateInterest());\r\n }\r\n}\r\n<\/pre>\n
        Output<\/strong><\/p>\n
        \r\nInterest Rate - 11\r\n<\/pre>\n
        Dependency Injection without Spring using Java Setter<\/strong><\/p>\n
          \n
        1. Now I am going to decide the account type in the GetInterest.java in its setter method <\/li>\n
        2. I would be passing the value of the actual type inside the setter at runtime to decide the account type<\/li>\n
        3. The Only thing which I have changed in the addition of new constructor to the Customer Class<\/li>\n
        4. Setter method would be passed with specific account type during runtime<\/li>\n<\/ol>\n
          Customer.java<\/strong><\/p>\n
          \r\npackage com.mugil.core;\r\n\r\npublic class Customer {\r\n Accounts accountType;\r\n\r\n public Customer(Accounts paccountType) {\r\n  this.accountType = paccountType;\r\n }\r\n\r\n public Customer() {}\r\n\r\n public Accounts getAccountType() {\r\n  return accountType;\r\n }\r\n\r\n public void setAccountType(Accounts accountType) {\r\n  this.accountType = accountType;\r\n }\r\n}\r\n<\/pre>\n
          Dependency Injection without Spring using Setter Method<\/em>
          \nGetInterestSettWithoutSpring .java<\/strong><\/p>\n
          \r\npackage com.mugil.core;\r\n\r\npublic class GetInterestSettWithoutSpring {\r\n public static void main(String[] args) {\r\n  Customer customer = new Customer();\r\n  customer.setAccountType(new SavingsAccount());\r\n  System.out.println("Interest Rate - " + customer.getAccountType().calculateInterest());\r\n }\r\n}\r\n<\/pre>\n
          Output<\/strong><\/p>\n
          \r\nInterest Rate - 8\r\n<\/pre>\n
          Ways of Bean Injection using Spring<\/strong>
          \nIn Spring we can let the container create the bean in two ways<\/p>\n
            \n
          1. Bean definition in XML<\/li>\n
          2. Bean definition using @Component<\/li>\n
          3. Bean definition using Java<\/li>\n<\/ol>\n
            Bean definition in XML<\/strong>
            \nbeans.xml<\/em><\/p>\n
            \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txmlns:context="http:\/\/www.springframework.org\/schema\/context"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\n\thttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-2.5.xsd\r\n\thttp:\/\/www.springframework.org\/schema\/context\r\n\thttp:\/\/www.springframework.org\/schema\/context\/spring-context-2.5.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="constructor">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean  id="savingsType" class="com.mugil.core.SavingsAccount"\/>\r\n\t<bean  id="vehicleLoanAccount" class="com.mugil.core.VehicleLoanAccount"\/>\t\t\r\n<\/beans>\r\n<\/pre>\n
            \ncontext:component-scan used for detecting bean<\/em>
            \nBean definition using @Component<\/strong>
            \nbeans.xml<\/em><\/p>\n
            \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txmlns:context="http:\/\/www.springframework.org\/schema\/context"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\n\thttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-2.5.xsd\r\n\thttp:\/\/www.springframework.org\/schema\/context\r\n\thttp:\/\/www.springframework.org\/schema\/context\/spring-context-2.5.xsd">\r\n\t<context:annotation-config \/>\r\n\t<context:component-scan base-package="com.mugil.core"><\/context:component-scan>\t\t\t\r\n<\/beans>\r\n<\/pre>\n
            @Component marking bean<\/em>
            \nCustomer.java<\/strong><\/p>\n
            \r\npackage com.mugil.core;\r\n\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.beans.factory.annotation.Qualifier;\r\n\r\n@Component\r\npublic class Customer \r\n{\r\n\r\n @Autowired\r\n @Qualifier("savings")\r\n Accounts accountType;\r\n.\r\n.\r\n.\r\n}\r\n<\/pre>\n
            @Component marking bean<\/em>
            \nSavingsAccount.java<\/strong><\/p>\n
            \r\npackage com.mugil.core;\r\n\r\nimport org.springframework.beans.factory.annotation.Qualifier;\r\nimport org.springframework.stereotype.Component;\r\n\r\n@Component\r\n@Qualifier("savings")\r\npublic class SavingsAccount implements Accounts\r\n{\t\r\n\tpublic Integer calculateInterest() \r\n\t{\r\n\t\treturn 9;\r\n\t}\r\n}\r\n<\/pre>\n
            \nBean definition using Java<\/strong><\/p>\n
            Ways of Bean Injection using Spring<\/strong>
            \nNow, what if we do the same thing from XML and using annotations. Spring offers 3 ways by which dependency injection could be done<\/p>\n
              \n
            1. XML\n
                \n
              1. Constructor<\/a><\/li>\n
              2. Setter<\/a><\/li>\n
              3. Autowiring\n
                  \n
                1. byType<\/a>\n    <\/li>\n
                2. byName<\/a><\/li>\n
                3. Constructor<\/a><\/li>\n
                4. No<\/a><\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
                5. Annotation Based\n
                    \n
                  1. byType<\/a>\n    <\/li>\n
                  2. byName<\/a><\/li>\n<\/ol>\n<\/li>\n
                  3. Java Based<\/li>\n<\/ol>\n
                    Constructor Based – Dependency Injection using XML<\/a><\/strong><\/p>\n
                      \n
                    1. In the below code beans are loaded when the application is deployed and the JVM starts<\/li>\n
                    2. The beans are uniquely identified using their IDS, in our case it is customer<\/li>\n
                    3. The parameter for constructor is defined inside constructor-arg in XML<\/li>\n<\/ol>\n
                      Beans.xml<\/strong><\/p>\n
                      \r\n<?xml version="1.0" encoding="UTF-8"?>\r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans" xmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance" xsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n   <bean id="customer" class="com.mugil.core.Customer">\r\n      <constructor-arg>\r\n         <bean id="savingAccount" class="com.mugil.core.SavingsAccount" \/>\r\n      <\/constructor-arg>\r\n   <\/bean>\r\n<\/beans>\r\n<\/pre>\n
                      GetInterestConsWithSpring.xml<\/strong><\/p>\n
                      \r\npackage com.mugil.core;\r\n\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.support.ClassPathXmlApplicationContext;\r\n\r\npublic class GetInterestConsWithSpring {\r\n public static void main(String[] args) {\r\n  ApplicationContext context = new ClassPathXmlApplicationContext("SpringBeans.xml");\r\n\r\n  Customer customer = (Customer) context.getBean("customer");\r\n\r\n  System.out.println("Interest Rate - " + customer.getAccountType().calculateInterest());\r\n }\r\n}\r\n<\/pre>\n
                      Output<\/strong><\/p>\n
                      \r\nInterest Rate - 8\r\n<\/pre>\n
                      Setter Based – Dependency Injection using XML<\/a><\/strong><\/p>\n
                        \n
                      1. For setter injection the only things we need to change is XML<\/li>\n
                      2. XML should be modified to take value by setter rather than constructor as before using property tag<\/li>\n<\/ol>\n
                        Beans.xml<\/strong><\/p>\n
                        \r\n<?xml version="1.0" encoding="UTF-8"?>\r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans" xmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance" xsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n   <bean id="customer" class="com.mugil.core.Customer">\r\n      <property name="accountType" ref="savingAccount" \/>\r\n   <\/bean>\r\n   <bean id="savingAccount" class="com.mugil.core.SavingsAccount" \/>\r\n<\/beans>\r\n<\/pre>\n
                        GetInterestSettWithSpring.xml<\/strong><\/p>\n
                        \r\npackage com.mugil.core;\r\n\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.support.ClassPathXmlApplicationContext;\r\n\r\npublic class GetInterestSettWithSpring {\r\n public static void main(String[] args) {\r\n  ApplicationContext context = new ClassPathXmlApplicationContext(\r\n   "SpringBeans.xml");\r\n\r\n  Customer customer = (Customer) context.getBean("customer");\r\n\r\n  System.out.println("Interest Rate - " + customer.getAccountType().calculateInterest());\r\n }\r\n}\r\n<\/pre>\n
                        Output<\/strong><\/p>\n
                        \r\nInterest Rate - 8\r\n<\/pre>\n
                        Autowiring byName<\/a><\/strong><\/p>\n
                          \n
                        1. In autoWiring byName the Name of the Instance Varable(accountType) and the ID of the bean in XML should be same<\/li>\n
                        2. If there is no bean matching the name is found it will throw NullPointerException<\/li>\n<\/ol>\n
                          Customer.java<\/strong><\/p>\n
                          \r\npackage com.mugil.core;\r\n\r\npublic class Customer {\r\n Accounts accountType;\r\n\r\n public Customer(Accounts paccountType) {\r\n  this.accountType = paccountType;\r\n }\r\n\r\n public Customer() {}\r\n\r\n public Accounts getAccountType() {\r\n  return accountType;\r\n }\r\n\r\n public void setAccountType(Accounts accountType) {\r\n  this.accountType = accountType;\r\n }\r\n}\r\n<\/pre>\n
                          Beans.xml<\/strong><\/p>\n
                          \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\nhttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="byName">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean id="accountType" class="com.mugil.core.SavingsAccount"\/>\r\n\t<bean id="vehicleLoanAccount" class="com.mugil.core.VehicleLoanAccount"\/>\r\n<\/beans>\r\n<\/pre>\n
                          Output<\/strong><\/p>\n
                          \r\nInterest Rate - 9\r\n<\/pre>\n
                          What if Bean of Correct Name is notdefined in XML? Inour case it is account Type<\/strong>
                          \nBeans.xml<\/strong><\/p>\n
                          \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\nhttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="byName">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean id="savingAccount" class="com.mugil.core.SavingsAccount"\/>\r\n\t<bean id="vehicleLoanAccount" class="com.mugil.core.VehicleLoanAccount"\/>\r\n<\/beans>\r\n<\/pre>\n
                          Output<\/strong><\/p>\n
                          \r\nException in thread \"main\" java.lang.NullPointerException\r\n\tat com.mugil.core.GetInterestConstAutoWiringXML.main(GetInterestConstAutoWiringXML.java:13)\r\n<\/pre>\n
                          Autowiring byType<\/a><\/strong><\/p>\n
                            \n
                          1. In autoWiring is byType then there should be at least  one bean defined for the matching type, in our case it is Accounts<\/li>\n
                          2. If there is no bean defined of the type then it will throw null pointer exception<\/li>\n
                          3. If there is more than one matching bean of the same type is found it will throw No unique bean of type<\/li>\n<\/ol>\n
                            Beans.xml<\/strong><\/p>\n
                            \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\nhttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="byType">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean id="savingsType" class="com.mugil.core.SavingsAccount"\/>\r\n<\/beans>\r\n<\/pre>\n
                            Output<\/strong><\/p>\n
                            \r\nInterest Rate - 9\r\n<\/pre>\n
                            What if No bean of right Type is defined in XML or More than one bean of same type defined?<\/strong>
                            \nBeans.xml<\/strong>
                            \nNo bean of right Type is defined in XML<\/p>\n
                            \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\nhttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="byType">\t\t\t\t\r\n\t<\/bean>\r\n<\/beans>\r\n<\/pre>\n
                            Output<\/strong><\/p>\n
                            \r\nException in thread \"main\" java.lang.NullPointerException\r\n\tat com.mugil.core.GetInterestConstAutoWiringXML.main(GetInterestConstAutoWiringXML.java:13)\r\n<\/pre>\n
                            Beans.xml<\/strong>
                            \nMore than one bean of same type defined<\/p>\n
                            \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\nhttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="byType">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean id="savingsType" class="com.mugil.core.SavingsAccount"\/>\r\n\t<bean id="vehicleLoanAccount" class="com.mugil.core.VehicleLoanAccount"\/>\r\n<\/beans>\r\n<\/pre>\n
                            Output<\/strong><\/p>\n
                            \r\nException in thread \"main\" org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'customer' defined in class path resource [SpringBeans.xml]: Unsatisfied dependency expressed through bean property 'accountType': : No unique bean of type [com.mugil.core.Accounts] is defined: expected single matching bean but found 2: [accountType, vehicleLoanAccount]; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [com.mugil.core.Accounts] is defined: expected single matching bean but found 2: [accountType, vehicleLoanAccount]\r\n<\/pre>\n
                            Autowiring Contructor<\/a><\/strong><\/p>\n
                              \n
                            1. In autoWiring using Constructor spring tries to find bean using type.In our case it is Account type<\/li>\n
                            2. If there is no bean defined of the type then spring will not guess and it will throw null pointer exception<\/li>\n
                            3. If there is more than one matching bean then spring will not guess and it will throw null pointer exception<\/li>\n
                            4. If there is more than one constructor spring wont guess the bean and it will throw null pointer exception<\/li>\n<\/ol>\n
                              Beans.xml<\/strong><\/p>\n
                              \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\nhttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="constructor">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean id="savingsType" class="com.mugil.core.SavingsAccount"\/>\r\n<\/beans>\r\n<\/pre>\n
                              Output<\/strong><\/p>\n
                              \r\nInterest Rate - 9\r\n<\/pre>\n
                              Beans.xml<\/strong>
                              \nTwo bean of same type in constructor injection <\/p>\n
                              \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\nhttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="constructor">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean id="savingsType" class="com.mugil.core.SavingsAccount"\/>\r\n<bean id="vehicleLoanAccount" class="com.mugil.core.VehicleLoanAccount"\/>\r\n<\/beans>\r\n<\/pre>\n
                              Beans.xml<\/strong>
                              \nNo bean of matching type in constructor injection <\/p>\n
                              \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\nhttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="constructor">\t\t\t\t\r\n\t<\/bean>\r\n<\/beans>\r\n<\/pre>\n
                              Output<\/strong><\/p>\n
                              \r\nException in thread \"main\" java.lang.NullPointerException\r\n\tat com.mugil.core.GetInterestConstAutoWiringXML.main(GetInterestConstAutoWiringXML.java:13)\r\n<\/pre>\n
                              Autowiring using autodetect<\/a><\/strong>
                              \nWhen the bean is configured to autowire by autodetect spring will attempt to autowire by constructor first.If no suitable constructor to bean is found then spring will attempt to autowire byType.
                              \nBeans.xml<\/strong><\/p>\n
                              \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\nhttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd">\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="autodetect">\t\t\t\t\r\n\t<\/bean>\r\n<\/beans>\r\n<\/pre>\n
                              Annotation Based – byType<\/a><\/strong><\/p>\n
                                \n
                              1. In Annotation based autowiring the beans would be injected by xml and would be available in container<\/li>\n
                              2. context:annotation-config is used to activate annotations in beans already registered in the application context (no matter if they were defined with XML or by package scanning)<\/li>\n
                              3. Now by using @Autowired tag we inject the bean as dependency where it is required.It is used either over variable in class or over setter or over constructor<\/li>\n
                              4. The default @Autowired decides the bean based on its type.If more than one bean if found it will throw no unique bean found exception.If no bean found it will throw nullpointer exception<\/li>\n
                              5. Incase of more than one bean of same type, we can narrow down the selection by using @Qualifier annotation and converting to byName @Autowiring<\/li>\n<\/ol>\n
                                Beans.xml<\/strong><\/p>\n
                                \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txmlns:context="http:\/\/www.springframework.org\/schema\/context"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\n\thttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-2.5.xsd\r\n\thttp:\/\/www.springframework.org\/schema\/context\r\n\thttp:\/\/www.springframework.org\/schema\/context\/spring-context-2.5.xsd">\r\n\r\n\t<context:annotation-config \/>\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="constructor">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean id="savingsType" class="com.mugil.core.SavingsAccount"\/>\t\r\n<\/beans>\r\n<\/pre>\n
                                Customer.java<\/strong><\/p>\n
                                \r\npackage com.mugil.core;\r\n\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\n\r\npublic class Customer \r\n{\r\n @Autowired\r\n private Accounts accountType;\r\n\r\n public Customer(Accounts paccountType) {\r\n  this.accountType = paccountType;\r\n }\r\n\r\n public Customer() {}\r\n\r\n public Accounts getAccountType() {\r\n  return accountType;\r\n }\r\n \r\n public void setAccountType(Accounts accountType) {\r\n  this.accountType = accountType;\r\n }\r\n}\r\n<\/pre>\n
                                Annotation Based – byName<\/a><\/strong><\/p>\n
                                  \n
                                1. In the below code we have two bean of same type<\/li>\n
                                2. Using @autowired would try to find bean byType.Since there are two beans it would throw no unique bean found exception<\/li>\n
                                3. Now we need to use @Qualifier passing the name (or) id of the bean as parameter<\/li>\n
                                4. Incase only Id of bean is there then same would be taken for name, If Name is there then name of bean would be given preference, incase no bean matches name then Id would be given preference<\/li>\n<\/ol>\n
                                  Beans.xml<\/strong><\/p>\n
                                  \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txmlns:context="http:\/\/www.springframework.org\/schema\/context"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\n\thttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-2.5.xsd\r\n\thttp:\/\/www.springframework.org\/schema\/context\r\n\thttp:\/\/www.springframework.org\/schema\/context\/spring-context-2.5.xsd">\r\n\r\n\t<context:annotation-config \/>\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="constructor">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean name="savings" id="savingsType" class="com.mugil.core.SavingsAccount"\/>\r\n\t<bean name="vehicle" id="vehicleLoanAccount" class="com.mugil.core.VehicleLoanAccount"\/>\t\t\r\n<\/beans>\r\n<\/pre>\n
                                  Customer.java<\/strong><\/p>\n
                                  \r\npackage com.mugil.core;\r\n\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.beans.factory.annotation.Qualifier;\r\n\r\npublic class Customer \r\n{\r\n\r\n @Autowired\r\n @Qualifier("savings")\r\n Accounts accountType;\r\n.\r\n.\r\n.\r\n}\r\n<\/pre>\n
                                  The below code will work by taking bean id into consideration despite the name doesn’t match.
                                  \nCustomer.java<\/strong><\/p>\n
                                  \r\npackage com.mugil.core;\r\n\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.beans.factory.annotation.Qualifier;\r\n\r\npublic class Customer \r\n{\r\n\r\n @Autowired\r\n @Qualifier("savingsType")\r\n Accounts accountType;\r\n.\r\n.\r\n.\r\n}\r\n<\/pre>\n
                                  What if there are two bean with the Same Name?<\/strong>
                                  \nIt will not throw exception during compilation but during runtime it will throw bean name already in use exception
                                  \nOutput<\/strong><\/p>\n
                                  \r\nException in thread \"main\" org.springframework.beans.factory.parsing.BeanDefinitionParsingException: Configuration problem: Bean name 'savings' is already used in this file\r\nOffending resource: class path resource [SpringBeans.xml]\r\n<\/pre>\n
                                  What if there are two bean with the Same ID?<\/strong><\/p>\n
                                    \n
                                  1. Eclipse will complain for violating ID should be unique and you are violating<\/li>\n
                                  2. If you build the code still builds but when you run will endup with  Caused by: org.xml.sax.SAXParseException; lineNumber: 13; columnNumber: 69; cvc-id.2: There are multiple occurrences of ID value ‘savingsType’<\/li>\n<\/ol>\n
                                    Beans.xml<\/strong><\/p>\n
                                    \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txmlns:context="http:\/\/www.springframework.org\/schema\/context"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\n\thttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-2.5.xsd\r\n\thttp:\/\/www.springframework.org\/schema\/context\r\n\thttp:\/\/www.springframework.org\/schema\/context\/spring-context-2.5.xsd">\r\n\r\n\t<context:annotation-config \/>\r\n\t<bean id="customer" class="com.mugil.core.Customer" autowire="constructor">\t\t\t\t\r\n\t<\/bean>\r\n\t<bean id="savingsType" class="com.mugil.core.SavingsAccount"\/>\r\n\t<bean id="savingsType" class="com.mugil.core.VehicleLoanAccount"\/>\t\t\r\n<\/beans>\r\n<\/pre>\n
                                    Using @Component Scan to detect and load beans<\/strong><\/p>\n
                                      \n
                                    1. We can make spring to detect beans on its own by using @component annotation rather then defining in XML with bean tags<\/li>\n
                                    2. Using context:component-scan with base package pointed to beans package will load the bean marked with @component annotation<\/li>\n
                                    3. If there is bean of one type then it would work fine during autowiring, if there is more than one bean of same type then we should uniquely identify the bean using @qualifier annotation<\/li>\n
                                    4. @qualifier annotation should be used both in the place where the bean is referred and also in the place where it is defined.In our case it is Customer.java and SavingsAccount.java<\/li>\n<\/ol>\n
                                      Beans.xml<\/strong><\/p>\n
                                      \r\n<beans xmlns="http:\/\/www.springframework.org\/schema\/beans"\r\n\txmlns:xsi="http:\/\/www.w3.org\/2001\/XMLSchema-instance"\r\n\txmlns:context="http:\/\/www.springframework.org\/schema\/context"\r\n\txsi:schemaLocation="http:\/\/www.springframework.org\/schema\/beans\r\n\thttp:\/\/www.springframework.org\/schema\/beans\/spring-beans-2.5.xsd\r\n\thttp:\/\/www.springframework.org\/schema\/context\r\n\thttp:\/\/www.springframework.org\/schema\/context\/spring-context-2.5.xsd">\r\n\t<context:annotation-config \/>\r\n        <context:component-scan base-package="com.mugil.core"><\/context:component-scan>\t\r\n<\/beans>\r\n<\/pre>\n
                                      Customer.java<\/strong><\/p>\n
                                      \r\npackage com.mugil.core;\r\n\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.beans.factory.annotation.Qualifier;\r\n\r\n@Component\r\npublic class Customer \r\n{\r\n\r\n @Autowired\r\n @Qualifier("savings")\r\n Accounts accountType;\r\n.\r\n.\r\n.\r\n}\r\n<\/pre>\n
                                      SavingsAccount.java<\/strong><\/p>\n
                                      \r\npackage com.mugil.core;\r\n\r\nimport org.springframework.beans.factory.annotation.Qualifier;\r\nimport org.springframework.stereotype.Component;\r\n\r\n@Component\r\n@Qualifier("savings")\r\npublic class SavingsAccount implements Accounts\r\n{\t\r\n\tpublic Integer calculateInterest() \r\n\t{\r\n\t\treturn 9;\r\n\t}\r\n}\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
                                      Why we need Dependency Injection? Its to overcome monotony behavior. If you are asking for Apple(from Apple.java) you would be served apple object. If you are asking for Mango(from Mango.java) you would be served mango object. Now in case, you are having Fruit and now you are asking Fruit(from Fruit.java) you would be served either… 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":[188],"tags":[],"class_list":["post-3444","post","type-post","status-publish","format-standard","hentry","category-spring"],"_links":{"self":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/3444","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=3444"}],"version-history":[{"count":41,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/3444\/revisions"}],"predecessor-version":[{"id":3486,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/3444\/revisions\/3486"}],"wp:attachment":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/media?parent=3444"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/categories?post=3444"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/tags?post=3444"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}