Spring最有用的地方就是IOC。虽然代码很简单，但实际上最有用。
IoC是什么？
Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。
我们在Biz的文件夹下面，创建一个类SpringContext.java
public class SpringContext{
private static ApplicationContext ctx;//静态变量
//get()方法
Public static ApplicationContext getCtx(){
return ctx;
}
static {
if(ctx == null){
ctx = new ClassPathXmlApplicationContext(“applicationContext.xml”);
}
}
这样，在使用spring调用对象时可以直接采用如下代码：
public void addBook(Tbook bk)throws Exception
{
IBookDao dao =(IBookDao) SpringContext.getCtx( ).getBean(“bookDao”);
//这里调用单例模式的方法就可以得到Context 对象
}
用静态工厂方式对Bean进行实例化（创建类的对象）
applicationContext.xml:
<?xml version="1.0" encoding="UTF-8"?>
<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.xsd">
<!-- 静态工厂得到bean实例 -->
<bean id="product" class="com.chinasofti.jingtai.StaticFactory"
factory-method="getProduct">
<!-- getProduct静态方法得到bean实例 -->
</bean>
</beans>
Product 产品类
public class Product {
public String getproducetname(){
return "xiaomi10";
}
}
StaticFactory 静态工厂类
public class StaticFactory {
//静态的方法 可以得到产品的对象
public static Product getProduct(){
return new Product();
}
}
Test 测试类
ApplicationContext app = new ClassPathXmlApplicationContext("com/chinasofti/util/applicationContext.xml");
Product product = (Product)app.getBean("product");
System.out.println(product.getproducetname());
用普通工厂方式对Bean进行实例化（创建类的对象）
applicationContext.xml:
<!-- 普通工厂得到bean实例 --> <bean id="putongFactory" class="com.chinasofti.putong.PutongFactory" > </bean> <bean id="product1" factory-bean="putongFactory" factory-method="getProduct"> </bean>
PutongFactory 普通工厂类
public class PutongFactory {
//非静态的方法得到另一个类的对象
public Product getProduct(){
return new Product();
}
}
用构造器方式对Bean进行实例化(且这个实例一出生就拥有值)
构造方法分为二种：
一种是无参的，一种是有参的
我们可以用利用构造方法给类中的属性赋值。
applicationContext.xml:
<bean id="dog" class="com.gouzao.Dog">
<constructor-arg index="0" value="小白"></constructor-arg>
</bean>
<!-- Dog dog =new Dog("aaaa") -->
<bean id="dog2" class="com.gouzao.Dog">
<constructor-arg index="0" value="小黑"></constructor-arg>
<constructor-arg index="1" value="3"></constructor-arg>
</bean>
<!-- Dog dog2=new Dog(aaaa,bbb) -->
<bean id="dog3" class="com.gouzao.Dog"></bean>
<!-- Dog dog =new Dog() -->
Dog
public class Dog {
String name;
int age;
public Dog(){
System.out.println("默认构造方法。。。。。");
}
public Dog(String str){
name=str;
System.out.println("自定义构造方法。。。。。str="+str+",age="+age);
}
public Dog(String str,int a){
name=str;
age=a;
System.out.println("自定义构造方法。。。。。str="+str+",age="+age);
}
public void jiao(){
System.out.println("wangwang!!!+str="+name+",age="+age);
}
}
bean的作用域
其实就是描述bean的取值范围，和bean的有效时间，是通过配置文件来设定的
<bean id="dog" class="com.chinasofti.beanManage.Dog" scope="singleton" lazy-init="false">
</bean>
不写scope代表是单例设计模式（单个实例即个对象）
注：
scope="xx"代表作用域
1）scope="singleton" 单例的无论拿多少个对象，构造方法只走一次,且对象的内存地址都是相同的
我这次调用是这个对象，下次在调用也是这个对象
2）scope="prototype" 每次都创建一个新的对象，构造方法走多次,且对象的内存地址都是不相同的
每次调用都是新的对象
bean的初始化时间
其实就是spring创建javabean的时间
1）scope="prototype" 创建javabean的时间，每次获取对象实例时，都会创建.getBean("dog");每次这步都会创建一个对象
2) scope="singleton" 根据bean标签的属性值来选择创建时间
scope="singleton" lazy-init="true" 单例的,且延迟创建对象.getBean("dog");这步才创建对象
scope="singleton" lazy-init="false" 单例的,非延迟创建对象，在类被容器加载时就创建了
注：如果不写lazy-init代表false,被容器加载时就创建。
定义多个配置文件
当配置文件有多个时，我们可以把它们整合在一个配置里面
applicationContext.xml:
applicationContext2.xml
<?xml version="1.0" encoding="UTF-8"?>
<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.xsd">
<import resource="/applicationContext2.xml"/>
</beans>