spring xml文件配置redisson spring xml配置bean

目录：

--配置方法：通过全类名（反射）。

--IOC容器BeanFactory和ApplicationContext概述。

--依赖注入的方式：属性注入和构造器注入。

--引用Bean注入

 

在xml中配置Bean的节点写法：

<bean id="helloWorld" class="com.xia.entity.HelloWorld">
        <property name="name" value="Spring"></property>
</bean>

id：表示容器中bean，id唯一。

class:bean的全类名，通过反射的方法在IOC容器中创建Bean，所有要求Bean中必须有无参的构造器。

 

ApplicationContext：

ApplicationContext在初始化上下文时就实例化了所有单例的Bean。

　　--主要实现类：

1.ClassPathXmlApplicationContext:从类路径下加载配置文件。
2.FileSystemXmlApplicationContext：从文件系统中加载配置文件。

 

获取bean对象：

　在SpringIOC容器读取Bean配置创建的Bean实例之前，必须对它进行实例化，只有在容器实例化后，才可以从IOC容器中获得Bean对象的实例并使用。

BeanFactory：IOC容器的基本实现；

ApplicationContext：提供了更多的高级特性，是BeanFactory的子接口，

几乎所有的应用场合都直接使用ApplicationContext而非底层的BeanFactory，无论使用什么方式，配置都想同。

//1.创建spring的IOC容器对象。
		//ApplicationContext 代表IOC容器
		//ClassPathXmlApplicationContext:从类路径下加载配置文件。
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");

//2.从IOC容器中获得Bean对象的实例。
		//利用id定位到IOC容器中的Bean。
HelloWorld h1 = (HelloWorld) ac.getBean("helloWorld");

		//利用类型注入
		HelloWorld h2 = ac.getBean("helloWorld",HelloWorld.class);

//3.输出对象属性
		System.out.println(h2.getName());

 

依赖注入的方式：

　　spring支持3种依赖注入的方式：

--属性注入：通过setter方法进行注入Bean的属性值或依赖的对象。

--构造器注入

--工厂注入（很少使用）

 

实例：

HelloWorld类：

private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HelloWorld(String name) {
        super();
        this.name = name;
    }

    public HelloWorld() {
        super();
        // TODO Auto-generated constructor stub
    }

属性 注入：

<bean id="helloWorld" class="com.xia.entity.HelloWorld">
        <property name="name" value="Spring"></property>
    </bean>

 　　使用<property>元素，使用name属性指定Bean的属性名称，value属性指定属性值。

　属性注入是最长见的注入方式。

 

构造工作方法注入：

<bean id="helloWorld" class="com.xia.entity.HelloWorld">
        <constructor-arg value="name" index="0" type="java.lang.String"></constructor-arg>
　　　　//...
    </bean>

可以指定参数的位置和参数的类型，已区分重载的构造器。

细节：

字面值：可用字符串表示的值，可以通过<value>元素标签或者value属性进行注入。基本数据类型以及封装类，String等类型都可以采取字面值注入的方式。

如果字面值中包含特殊字符，可以用<![CDATA[]]>把字面值包裹起来。

例如：

<bean id="helloWorld" class="com.xia.entity.HelloWorld">
        <property name="name">
            <value><![CDATA[<Shanghai^>]]></value>
        </property>
    </bean>

 

引用其他的Bean：

例子：Person类和Car类，人拥有车。

Person：

 

package com.xia.entity;

public class Person {
    private String name;
    private int age;
    private Car car;
    
    
    
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", car=" + car.toString() + "]";
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    
}

 

Car：

package com.xia.entity;

public class Car {
    private String cname;
    private double price;
    public Car(String cname, double price) {
        super();
        this.cname = cname;
        this.price = price;
    }
    
    public Car() {
        super();
    }
    
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }

　　　　@Override
　　　　public String toString() {
　　　　　　　return "Car [cname=" + cname + ", price=" + price + "]";
　　　　}

}

配置IOC容器：

<bean id="personBean" class="com.xia.entity.Person">
        <property name="name" value="张三"></property>
        <property name="age">
            <value>18</value>
        </property>
        <property name="car" ref="carBean"></property>
    </bean>
    
    <bean id="carBean" class="com.xia.entity.Car">
        <constructor-arg index="0" name="cname" type="java.lang.String" value="宝马"></constructor-arg>
        <constructor-arg index="1" name="price">
            <value>1000000</value>
        </constructor-arg>
    </bean>

测试：

package com.xia.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.xia.entity.Car;
import com.xia.entity.Person;

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Car car = ac.getBean(Car.class);
        System.out.println(car.toString());
        Person p = (Person) ac.getBean("personBean");
        System.out.println(p.toString());
    }
}

输出结果：

Car [cname=宝马, price=1000000.0]
Person [name=张三, age=18, car=Car [cname=宝马, price=1000000.0]]