Spring-bean(一)

　　配置形式：基于xml文件的方式；基于注解的方式

　　Bean的配置方式：通过全类名（反射），通过工厂方法（静态工厂方法&实例工厂方法），FactoryBean

　　依赖注入的方式：属性注入，构造器注入

一   属性注入

1. Person.java

 1 public class Person{
 2     String name;
 3
 4     public void setName(String name) {
 5         this.name = name;
 6     }
 7     public void hello() {
 8         System.out.println("hello" + name);
 9     }
10
11     public Person(String name) {
12         super();
13         this.name = name;
14     }
15     @Override
16     public String toString() {
17         return "Person[name=" + name + "]";
18     }
19
20 }

Main.java

1  public class Main {
2       public static void main(String[] args) {
3           Person person= new Person();
4           person.setName("wenxl");
5           person.hello();
6     }
7 }        

要调用person.hello（），需要先实例化一个Person对象，而在引入spring后，只需要在ApplicationContext.xml中定义一个bean,则在main方法中，只需要通过ByType或ByName方式，即可获得Person对象。配置如下,其中property属性是为person设置初始值，name为对应的成员变量，value为对应值

ApplicationContext.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5
 6     <!-- 属性注入 -->
 7     <bean id="person" class="com.text.Person">
 8         <property name="name" value="wenxl"></property>
 9     </bean>
10
11 </beans>

 1 public class Main {
 2     public static void main(String[] args) {
 3         //1. 创建spring的ioc容器对象
 4         //applicationContext代表ioc容器
 5         //ClassPathXmlApplicationContext代表ac接口的实现类，用于加载配置
 6         ApplicationContext atx = new ClassPathXmlApplicationContext("ApplicationContext.xml");
 7
 8         //2. 从ioc容器中获取bean实例
 9
10         //利用类型返回ioc容器中的bean，但要求ioc容器中只有一个该类型的bean
11         Person person = atx.getBean(Person.class);
12         //根据id获取ioc容器中的bean
13         Person person2 = (Person) atx.getBean("person");
14
15         person.hello();
16         person2.hello();
17     }
18 }

二   构造器注入

引入Car类

public class Car {
    String name;
    int speed;
    int price;
    public void setName(String name) {
        this.name = name;
    }
    public void setSpeed(int speed) {
        this.speed = speed;
    }
    public void setPrice(int price) {
        this.price = price;
    }

    public Car(String name, int speed, int price) {
        this.name = name;
        this.speed = speed;
        this.price = price;
    }
}

如下，则将按照name，speed，price的顺序，分别设置值Baoma，123,123

1 <bean id="car" class="com.text.Car">
2     <constructor-arg value="Baoma"></constructor-arg>
3     <constructor-arg value="123"></constructor-arg>
4     <constructor-arg value="123"></constructor-arg>
5 </bean>

当然，也可以自行设置顺序

1 <bean id="car" class="com.text.Car">
2     <constructor-arg index="0" value="Baoma"></constructor-arg>
3     <constructor-arg index="1" value="123"></constructor-arg>
4     <constructor-arg index="2" value="123"></constructor-arg>
5 </bean>

还可以采用type来表示对应的数据类型进而相互匹配，如将price改为double类型，则

1 <bean id="car" class="com.text.Car">
2     <constructor-arg type="java.lang.String" value="Baoma"></constructor-arg>
3     <constructor-arg type="int" value="123"></constructor-arg>
4     <constructor-arg type="double" value="123"></constructor-arg>
5 </bean>

当包含<等特殊字符时，可用CDATA包裹。

1 <bean id="car" class="com.text.Car">
2     <constructor-arg type="java.lang.String" >
3         <value><![CDATA[<audi>]]></value>
4     </constructor-arg>
5     <constructor-arg type="int" value="123"></constructor-arg>
6     <constructor-arg type="double" value="123"></constructor-arg>
7 </bean>

当需要在bean中引用另外一个bean时，采用ref或内部bean（不可被外部引用），在person类中，增加一个car对象

 1     <bean id="person" class="com.text.Person">
 2         <property name="name" value="Tom"></property>
 3         <!--
 4         <property name="car">
 5             <ref bean="car" />
 6         </property>
 7         -->
 8         <!--
 9         <property name="car" ref="car"></property>
10          -->
11         <property name="car">
12             <bean class="com.text.Car">
13                 <constructor-arg value="Ford"></constructor-arg>
14                 <constructor-arg value="50"></constructor-arg>
15                 <constructor-arg value="5000" type="double"></constructor-arg>
16             </bean>
17         </property>
18     </bean>

级联属性

1     <bean id="person" class="com.text.Person">
2         <constructor-arg value="lili"></constructor-arg>
3         <constructor-arg ref="car"></constructor-arg>
4         <property name="car.price" value="10000"></property>
5     </bean>

当Person类中新增的为List<car>，此时，property改为

1 <property name="car">
2     <list>
3         <ref bean="car" />
4         <ref bean="car2"/>
5     </list>
6 </property>

当Person类中新增的为Map<String, car>,则property改为

1 <property name="car">
2     <map>
3        <entry key="aa" value-ref="car" ></entry>
4        <entry key="bb" value-ref="car2"></entry>
5     </map>
6 </property>

使用props和prop子节点来为properties属性赋值

引入DataSource类

 1 public class DataSource {
 2     Properties properties;
 3
 4     public Properties getProperties() {
 5         return properties;
 6     }
 7
 8     public void setProperties(Properties properties) {
 9         this.properties = properties;
10     }
11
12     @Override
13     public String toString() {
14         return "DataSource [properties=" + properties + "]";
15     }
16
17 }

 1     <bean id="dataSource" class="com.text.DataSource">
 2         <property name="properties">
 3             <props>
 4                 <prop key="user">root</prop>
 5                 <prop key="password">123456</prop>
 6                 <prop key="jdbcUrl">jdbc:mysql:///test</prop>
 7                 <prop key="driverClass">com.mysql.jdbc.Driver</prop>
 8             </props>
 9         </property>
10     </bean>