spring的i o c简单回顾

╰+攻爆jí腚メ 2021-12-23 16:33 200阅读 0赞

1.springIOC是一个创建对象的容器，他负责将我们需要的对象帮我们创建出来，创建时间是：当我们从上下文环境中读取此对象时就会帮我们创建，严格意义上来讲它是一种编程思想不是一种技术。

2.依赖注入：对象中有引用其他对象，但只是声明(依赖)，并没有创建，创建是交给spring的IOC容器去帮我们做的，当我们调用此对象时spring就会创建好给我们(注入)。

1）构造器id注入：

package x.y;
    
    public class ThingOne {
    
        public ThingOne(ThingTwo thingTwo, ThingThree thingThree) {
            // ...
        }
    }
    
    <beans>
        <bean id="beanOne" class="x.y.ThingOne">
            <constructor-arg ref="beanTwo"/>
            <constructor-arg ref="beanThree"/>
        </bean>
    
        <bean id="beanTwo" class="x.y.ThingTwo"/>
    
        <bean id="beanThree" class="x.y.ThingThree"/>
    </beans>

2)构造器参数类型注入：

package examples;
    
    public class ExampleBean {
    
        // Number of years to calculate the Ultimate Answer
        private int years;
    
        // The Answer to Life, the Universe, and Everything
        private String ultimateAnswer;
    
        public ExampleBean(int years, String ultimateAnswer) {
            this.years = years;
            this.ultimateAnswer = ultimateAnswer;
        }
    }
    
    <bean id="exampleBean" class="examples.ExampleBean">
        <constructor-arg type="int" value="7500000"/>
        <constructor-arg type="java.lang.String" value="42"/>
    </bean>

3）按照带参构造器，参数下标注入：

4）按照构造器参数名称注入：

1）通过set方法给成员赋值：

public class ExampleBean {
    
        private AnotherBean beanOne;
    
        private YetAnotherBean beanTwo;
    
        private int i;
    
        public void setBeanOne(AnotherBean beanOne) {
            this.beanOne = beanOne;
        }
    
        public void setBeanTwo(YetAnotherBean beanTwo) {
            this.beanTwo = beanTwo;
        }
    
        public void setIntegerProperty(int i) {
            this.i = i;
        }
    }
    
    <bean id="exampleBean" class="examples.ExampleBean">
        
        <property name="beanOne">
            <ref bean="anotherExampleBean"/>
        </property>
    
        
        <property name="beanTwo" ref="yetAnotherBean"/>
        <property name="integerProperty" value="1"/>
    </bean>

1）通过静态工厂方式创建对象：

public class ExampleBean {
    
        // a private constructor
        private ExampleBean(...) {
            ...
        }
    
        // a static factory method; the arguments to this method can be
        // considered the dependencies of the bean that is returned,
        // regardless of how those arguments are actually used.
        public static ExampleBean createInstance (
            AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {
    
            ExampleBean eb = new ExampleBean (...);
            // some other operations...
            return eb;
        }
    }
    
    
    <bean id="exampleBean" class="examples.ExampleBean" factory-method="createInstance">
        <constructor-arg ref="anotherExampleBean"/>
        <constructor-arg ref="yetAnotherBean"/>
        <constructor-arg value="1"/>
    </bean>

2）.通过动态工厂方式创建对象：

//和静态工厂方式一样，不过没有被调用的方法上static而已，这里是创建了一个apache包下的一个类
    <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
        <property name="username" value="root"/>
        <property name="password" value="masterkaoli"/>
    </bean>

1）通过命名空间 p标签创建：实际是用set方法去创建的：

2）通过命名空间的 “c” 标签去创建：实际是通过构造器去创建的（对应的无参和带参的）：

1）map:

public class SomeClass { 　　private Map<String, Float> accounts; 　　public void setAccounts(Map<String, Float> accounts) { 　　　　this.accounts = accounts; 　　} }
    
    <beans>
        <bean id="something" class="x.y.SomeClass">
            <property name="accounts">
                <map>
                    <entry key="one" value="9.99"/>
                    <entry key="two" value="2.75"/>
                    <entry key="six" value="3.99"/>
                </map>
            </property>
        </bean>
    </beans>

1)property:

<beans>
        <bean id="parent" abstract="true" class="example.ComplexObject">
            <property name="adminEmails">
                <props>
                    <prop key="administrator">administrator@example.com</prop>
                    <prop key="support">support@example.com</prop>
                </props>
            </property>
        </bean>
        <bean id="child" parent="parent">
            <property name="adminEmails">
                
                <props merge="true">
                    <prop key="sales">sales@example.com</prop>
                    <prop key="support">support@example.co.uk</prop>
                </props>
            </property>
        </bean>
    <beans>

1)list, set, map, property:

<bean id="moreComplexObject" class="example.ComplexObject">
        
        <property name="adminEmails">
            <props>
                <prop key="administrator">administrator@example.org</prop>
                <prop key="support">support@example.org</prop>
                <prop key="development">development@example.org</prop>
            </props>
        </property>
        
        <property name="someList">
            <list>
                <value>a list element followed by a reference</value>
                <ref bean="myDataSource" />
            </list>
        </property>
        
        <property name="someMap">
            <map>
                <entry key="an entry" value="just some string"/>
                <entry key ="a ref" value-ref="myDataSource"/>
            </map>
        </property>
        
        <property name="someSet">
            <set>
                <value>just some string</value>
                <ref bean="myDataSource" />
            </set>
        </property>
    </bean>

转载于:https://www.cnblogs.com/li-yan-long/p/10527703.html