spring笔记一

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>