{"id":166,"date":"2016-02-01T23:50:13","date_gmt":"2016-02-01T23:50:13","guid":{"rendered":"http:\/\/kaizen-koka.com\/?p=166"},"modified":"2018-03-21T14:13:41","modified_gmt":"2018-03-21T14:13:41","slug":"spring-ioc-configuration","status":"publish","type":"post","link":"https:\/\/kaizen-koka.com\/?p=166","title":{"rendered":"Spring IOC & Configuration"},"content":{"rendered":"

\n\tWorking Example: https:\/\/github.com\/teachkoka\/spring-ioc-xml-b8<\/a>\n<\/p>\n

\n\tSpring IOC Container:<\/strong>
\n\t  <\/span><\/span>It is a process whereby objects define their dependencies, that is, the other objects they work with, only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse, hence the name Inversion of Control (IoC), of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes, or a mechanism such as the Service Locator pattern.
\n\t <\/span><\/span>\n<\/p>\n

\n\tA bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. Otherwise, a bean is simply one of many objects in your application. Beans, and the dependencies among them, are reflected in the configuration metadata used by a container.<\/span><\/span>\n<\/p>\n

\n\t    **In simple terms, passing required parameters to classes through xml configuration.<\/span><\/span>\n<\/p>\n

\n\tDependency Injection nothing but Inversion of Control (IoC) because the normal control sequence would be the object finds the objects it depends on by itself and then calls them. Here, this is reversed: The dependencies are handed to the object when it's created<\/span><\/span>\n<\/p>\n

\n\tThe interface org.springframework.context.ApplicationContext<\/code> represents the Spring IoC container and is responsible for instantiating, configuring, and assembling the aforementioned beans. The container gets its instructions on what objects to instantiate, configure, and assemble by reading configuration metadata. <\/span><\/span>\n<\/p>\n

\n\t org.springframework.beans
\n\t org.springframework.context<\/span><\/span>\n<\/p>\n

\n\t2 Types of IOC Containers:<\/strong>
\n\t  .Core Container: Bean Factory
\n\t  .J2EE Container: Application Context  <\/span><\/span>\n<\/p>\n

\n\tContainer responsibilities:<\/strong>
\n\t1)Create instances
\n\t2)Dependency Injection
\n\t3)LifeCycle Management<\/span><\/span>\n<\/p>\n

\n\tBean Factory(Core) container :<\/strong>
\n\t   .At the time of container startup – Loads the spring xml file and parse the xml file wellformed or not and validates the tags using sax parser .
\n\t   .Creates the instance of the bean when the user request for the bean.
\n\t    By default all the beans configured in are singleton.
\n\t   <\/span><\/span>\n<\/p>\n

\r\n    Resource resource = new ClassPathResource("beans.xml");\r\n    BeanFactory factory = new XmlBeanFactory(resource);<\/pre>\n
\n\tApplication context(J2EE) container :<\/strong>
\n\t  .At the time of container startup – Loads the spring xml file and parse the xml file well-formed or not and validates the tags using sax parser.
\n\t  .Creates the instance of all the beans, with singleton scopes, at the time of application start-up. If bean scope is prototype, at the time of each request bean insatnce will be created.
\n\t  .By default all the beans configured are singleton.<\/span><\/span> <\/span><\/span>\n<\/p>\n
\r\n ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");<\/pre>\n
\n\tDependency Injection can be achieved either through setter method or construtors.
\n\tUsing dependency injection we can inject any datatype
\n\t1. primitive injection
\n\t2. reference injection
\n\tPoints to remember <\/strong>: 
\n\t .IOC container designed to load in such a way that it will load private construtor classes as well. 
\n\t .One setter method will take only one input parameter.<\/span><\/span>\n<\/p>\n
\n\t–primitive<\/strong><\/span><\/span>\n<\/p>\n
\r\n<bean id="" class="" scope="">\r\n          <property name="" value=""\/>\r\n      <\/bean><\/pre>\n
\n\t–List (Arraylist) <\/strong><\/span><\/span>\n<\/p>\n
\r\n<bean id="" class="" scope="">\r\n          <property name="">\r\n            <set>\r\n               <value> <\/value>\r\n               <value> <\/value>\r\n            <\/set>\r\n          <\/property>\r\n      <\/bean>  <\/pre>\n
\n\t–Map (LinkedHashMap) <\/strong><\/span><\/span>\n<\/p>\n
\r\n  <bean id="" class="" scope="">\r\n          <property name="">\r\n            <map>\r\n               <entry key="" value=""\/>\r\n               <entry key="" value=""\/>\r\n            <\/map>\r\n          <\/property>\r\n   <\/bean>\r\n<\/pre>\n
\n\t–property<\/span><\/span><\/strong>\n<\/p>\n
\n\txmlns:util   xmlns:util="http:\/\/www.springframework.org\/schema\/util"
\n\txsi:schemaLocation       http:\/\/www.springframework.org\/schema\/util http:\/\/www.springframework.org\/schema\/util\/spring-util-3.0.xsd">
\n\t    <bean id="t" class="com.bellinfo.corejava.Test">
\n\t        <property name="driver">
\n\t          <util:properties location="classpath:drivers.properties"\/>
\n\t        <\/property>
\n\t    <\/bean><\/span><\/span>\n<\/p>\n
\n\t.Constructor :<\/span><\/span><\/strong>
\n\t    <\/span><\/span>\n<\/p>\n
\r\n<bean id="" class="">\r\n        <constructor-arg name ="" value="" \/>\r\n        <constructor-arg name =""  value=""\/>\r\n     <\/bean>\r\n\r\n     <bean id="" class="">\r\n        <constructor-arg value="" index=""\/>\r\n        <constructor-arg value="" index=""\/>\r\n     <\/bean>\r\n\r\n     <bean id="" class="">\r\n        <constructor-arg value="" index="0" type="java.lang.String"\/>\r\n        <constructor-arg value="" index="1" type="int"\/>\r\n     <\/bean><\/pre>\n
\n\t Since you can mix constructor-based and setter-based DI, it is a good rule of thumb to use constructors for mandatory dependencies and setter methods or configuration methods for optional dependencies.<\/strong> <\/span><\/span>\n<\/p>\n
\n\t
\n\tTo make setter dependency injection mandatory, using dependency-check. By default, its 'none' (simple – for primitive, objects – for objects, all- for all kind)
\n\t@Required  –<\/strong>> RequiredAnnotationBeanPostProcessor
\n\tdepends-on<\/strong> – If class A is depending on class B then<\/span><\/span>\n<\/p>\n
\r\n    <bean id="a" class="A" depends-on="b">\r\n    <bean id="b" class="B"><\/pre>\n
\n\tp-namespace  – property
\n\tc-namespace  – constructor
\n\t—————
\n\txmlns:p="http:\/\/www.springframework.org\/schema\/p"
\n\txmlns:c="http:\/\/www.springframework.org\/schema\/p"<\/span><\/span>
\n\t \n<\/p>\n
\n\tBy default, ApplicationContext implementations eagerly create and configure all singleton beans as part of the initialization process. Generally, this pre-instantiation is desirable, because errors in the configuration or surrounding environment are discovered immediately, as opposed to hours or even days later. When this behavior is not desirable, you can prevent pre-instantiation of a singleton bean by marking the bean definition as lazy-initialized. A lazy-initialized bean tells the IoC container to create a bean instance when it is first requested, rather than at startup.<\/span><\/span>\n<\/p>\n
\n\tIn XML, this behavior is controlled by the lazy-init attribute on the <bean\/> element; for example:<\/span><\/span>\n<\/p>\n
\n\t<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true"\/>
\n\t<bean name="not.lazy" class="com.foo.AnotherBean"\/>
\n\tWhen the preceding configuration is consumed by an ApplicationContext, the bean named lazy is not eagerly pre-instantiated when the ApplicationContext is starting up, whereas the not.lazy bean is eagerly pre-instantiated.<\/span><\/span>\n<\/p>\n
\n\tHowever, when a lazy-initialized bean is a dependency of a singleton bean that is not lazy-initialized, the ApplicationContext creates the lazy-initialized bean at startup, because it must satisfy the singleton’s dependencies. The lazy-initialized bean is injected into a singleton bean elsewhere that is not lazy-initialized.<\/span><\/span>\n<\/p>\n
\n\tAutowiring : <\/strong>
\n\t .Injecting dependency automatically
\n\t .Can be applied only to secondary datatypes
\n\tIt can be done through 
\n\t .byType
\n\t .byName
\n\t .constructor
\n\t .autodetect
\n\t .no (default)<\/span><\/span>
\n\t \n<\/p>\n
\r\n  <bean id="t1" class="com.bellinfo.corejava.Test" autowire="byName">\r\n  <bean id="t1" class="com.bellinfo.corejava.Test" autowire="byType">\r\n  <bean id="t1" class="com.bellinfo.corejava.Test" autowire="constructor">\r\n  <bean id="t1" class="com.bellinfo.corejava.Test" autowire="default">\r\n  <bean id="t1" class="com.bellinfo.corejava.Test" autowire="no">\r\n<\/pre>\n
\n\t–<\/strong>byType, byName, autodectect – for settertype dependecy injection
\n\t–<\/strong>constructor, autodetect  – for constructor dependency
\n\t–<\/strong>byType ambiguity can be resolved through autowire-candidate="false"
\n\t–<\/strong>If you want to apply for all the beans that are there in the xml file then use default-autowire="byType" at root-element 
\n\t      <beans default-autowire="byType"><\/beans><\/strong>
\n\t–<\/strong>byName, you don't encounter any ambiguity
\n\t–<\/strong>constructor, internally it use byType mechanism  
\n\t–<\/strong>autoDetect
\n\t    .<\/strong>if default constructor, parameter constructors and setter Injection then it will choose default constructor for instance creation and setter Injection for dependency Injection.
\n\t    .<\/strong>if parameter constructors and setter Injection then it will choose default constructor for both instance creation and injection.
\n\t                <\/span><\/span>\n<\/p>\n
\n\t@Autowired<\/strong>( uses byType), to resolve ambiguity use @Qualifier<\/strong>(value="id");
\n\tIn order to activate autowired annotation, <\/span><\/span>\n<\/p>\n
\r\n     <context:annotation-config\/><\/pre>\n
\n\tSpring reduces the configuration of creating the objects of classes by auto-scanning & stereotype annotations
\n\t1 Singleton<\/strong>  -(Default) Scopes a single bean definition to a single object instance per Spring IoC container.
\n\tprototype – Scopes a single bean definition to any number of object instances.
\n\t2.Request<\/strong> Scopes – A single bean definition to the lifecycle of a single HTTP request; that is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.
\n\t3.Session<\/strong> Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
\n\t4.GlobalSession<\/strong> Scopes a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a Portlet context. Only valid in the context of a web-aware Spring ApplicationContext.
\n\t5.Application Scopes<\/strong> – a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.  <\/span><\/span>\n<\/p>\n
\n\tIs Java Singleton different from Spring Singleton?<\/strong>
\n\tYES, YES, YES
\n\tJava considers something a singleton if it cannot create more than one instance of that class within a given class loader, whereas Spring would consider something a singleton if it cannot create more than one instance of a class within a given container\/context.<\/span><\/span>\n<\/p>\n
\n\t
\n\t4 stereotype annotations<\/strong>
\n\t1)@Controller  (on Spring MVC for Controller)
\n\t2)@Repository  (on DAO classes)
\n\t3)@Service (on business logic classes)
\n\t4)@Component  (non MVC classes, for any utility class)<\/span><\/span>\n<\/p>\n
\n\tin order to auto-scan all the classes, you can use<\/span><\/span>
\n\t    <context:component-scan base-package="com.bellinfo"\/>    
\n\t    
\n\t– static<\/strong> dependency injection can achieved through MethodInvokingFactoryBean<\/strong>
\n\tfor Sun created singleton classes or others – we need to use factory methods like getInstance() to create an objects
\n\tfactory-method ="getInsatnce()"<\/span><\/span>\n<\/p>\n
\r\n<bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">\r\n        <property name="staticMethod" value="com.bellinfo.corejava.Netflix.setFruits"\/>\r\n        <property name="arguments">\r\n            <list>\r\n                <value>apple<\/value>\r\n            <\/list>\r\n        <\/property>\r\n <\/bean><\/pre>\n
\n\tExamples of singleton classess,
\n\tSessionFactory
\n\tResourceBundle<\/span><\/span>\n<\/p>\n
\n\tIf you want to create an instance from Factory bean instance, then <\/span><\/span>\n<\/p>\n
\r\n<bean id="sf" class="SessionFactory"\/>\r\n<bean id="s" factory-bean="sf" class="Session" factory-method="openSession"\/><\/pre>\n
\n\tLifecycle methods: <\/strong><\/span><\/span> <\/strong>By IOC container we can maintain simple pojo classes life cycle.
\n\t-In order to achieve this, we need to use ConfigurableApplicationContext(also J2EE) Container.
\n\t-Bean life cycle can be achieved in 3 ways
\n\t   Programatic approach
\n\t      -implement InitializingBean, DisposableBean 
\n\t   Declarative\/xml configuration approach
\n\t      -init-method=""
\n\t      -destroy-method=""
\n\t   Annotation approach: to activate inject DI -CommonAnnotationBeanPostProcessor
\n\t      @PostConstruct
\n\t      @PreDestroy<\/span><\/span>\n<\/p>\n
\n\t–<\/strong>Default life cycle for entire configuration then at root element configure 
\n\tdefault-destroy-method="" default-init-method=""<\/span><\/span>\n<\/p>\n
\n\tLookUp methods: <\/strong>A method which required an implementation is called lookup method.
\n\t  Spring internally generates proxyclass and return that object.<\/span><\/span>\n<\/p>\n
\n\t \n<\/p>\n
\n\tmethod replacer :
\n\t -by implements MethodReplacer
\n\t – <bean> <replaced-method name="{methodName}" replacer="new implemented class ref"\/>  <\/bean><\/span><\/span>\n<\/p>\n
\n\t 
\n\tJDK also provides support for annotations,
\n\t@Resource(byName)  -(same as @Autowired)
\n\t@Inject(first byName – if not matches byType) – (same as @Autowired)<\/span><\/span>\n<\/p>\n
\n\tJ2EE also support stereotype annotations
\n\t@Named <\/span><\/span>\n<\/p>\n
\n\tProperties files data in to classes<\/strong>:
\n\t   Properties dependencies injection using expression<\/span><\/span>\n<\/p>\n
\r\n<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">\r\n    <property name="Location" value="resources\/drivers.properties"><\/property>\r\n <\/bean>\r\n \r\n <bean id="c" class="beans.DB">\r\n   <property name="driver" value=${driver}>\r\n   <\/property>\r\n <\/bean><\/pre>\n
\n\tI18N
\n\t-provides language support
\n\t– All property file should end with corresponding language (like _en, _te)
\n\t– Support 200+ languages
\n\tImplementation Steps:
\n\t1) 
\n\t<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource;">
\n\t      <property name="basename" value="resources\/filename"\/>
\n\t<\/bean>
\n\t2)
\n\t<%@page import ="java.util.Locale"%>\n<\/p>\n
\n\t<% 
\n\tString lang = request.getHeader("accept-language");
\n\tLocale locale= new Locale(lang);
\n\tApplicationContext ap = new ClassPathXmlApplicationContext("spring-config.xml");
\n\tString value = ap.getMessage("label", null, locale);
\n\t%>
\n\t<form action="\/hello">
\n\t<%=value%>: <input type="text" name="name"\/>
\n\t<input type="submit" value="submit"\/>
\n\t<\/form>\n<\/p>\n
\n\thttp:\/\/vikku.info\/indian-language-unicode-converter\/telugu-unicode-converter.html\n<\/p>\n
\n\tL10N – validation support and business project\n<\/p>\n
\n\tListeners :
\n\t1) Implement ApplicationListners<>
\n\t     These are the four different events avaliable at Spring
\n\t        ContextStartedEvent
\n\t        ContextStoppedEvent
\n\t        ContextRefreshEvent
\n\t        ContextCloseEvent
\n\t2)Configure your classes in spring config file
\n\t3)Use Configurable application Context\n<\/p>\n
\n\t
\n\t <\/p>\n","protected":false},"excerpt":{"rendered":"
Working Example: https:\/\/github.com\/teachkoka\/spring-ioc-xml-b8 Spring IOC Container:   It is a process whereby objects define their dependencies, that is, the other objects they work with, only through constructor arguments, arguments to a factory […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[9,2],"tags":[],"class_list":["post-166","post","type-post","status-publish","format-standard","hentry","category-advance","category-technology"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p70lnf-2G","jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=\/wp\/v2\/posts\/166","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=166"}],"version-history":[{"count":14,"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=\/wp\/v2\/posts\/166\/revisions"}],"predecessor-version":[{"id":505,"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=\/wp\/v2\/posts\/166\/revisions\/505"}],"wp:attachment":[{"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=166"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=166"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kaizen-koka.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=166"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}