基本的代码结构

1 IOC包下

基本的spring创建对象

将类添加到配置文件中，由容器创建。

Source code

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
5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
6. <!--
7.     把HelloWorld这个类纳入spring容器
8.         id为bean的唯一标识
9.              正规的写法：
10.              类的第一个字母变成小写，其余不变
11.         class为类的全名
12. -->
13. <bean id="helloWorld" class="cn.itcast.spring0401.ioc.HelloWorld"></bean>
14. </beans>

helloworld类

Source code

1. package cn.itcast.spring0401.ioc;
2.  
3. public class HelloWorld {
4.     public void say(){
5.         System.out.println("hello");
6.     }
7. }

测试类

这就是控制反转

Source code

1. package cn.itcast.spring0401.ioc;
2.  
3. import org.junit.Test;
4. import org.springframework.context.ApplicationContext;
5. import org.springframework.context.support.ClassPathXmlApplicationContext;
6.  
7. /**
8. * 控制反转
9. * @author Administrator
10. *
11. */
12. public class IOCTest {
13.     /**
14.      * 启动spring容器
15.      *         创建spring容器对象就相当于启动spring容器
16.      * spring容器做的工作：
17.      * * 创建对象
18.      */
19.     @Test
20.     public void testHelloWorld(){
21.         ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/ioc/applicationContext.xml");
22.         HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
23.         helloWorld.say();
24.     }
25. }

2 alias包，别名

配置文件，可以给类起别名

Source code

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
5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
6. <bean id="helloWorld" class="cn.itcast.spring0401.alias.HelloWorld"></bean>
7. <!--
8.     name与bean中的id对应
9.     alias 名字
10. -->
11. <alias alias="狗蛋" name="helloWorld"/>
12. <alias alias="王三麻子" name="helloWorld"/>
13. </beans>

测试方法

Source code

1. package cn.itcast.spring0401.alias;
2.  
3. import org.junit.Test;
4. import org.springframework.context.ApplicationContext;
5. import org.springframework.context.support.ClassPathXmlApplicationContext;
6.  
7. public class AliasTest {
8.     @Test
9.     public void test(){
10.         ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/alias/applicationContext.xml");
11.  
12.         HelloWorld helloWorld = (HelloWorld)context.getBean("王三麻子");
13.  
14.         helloWorld.say();
15.     }
16. }

输出结果还是一样的。

3 createbean  创建对象的几种方法

* 利用默认的构造函数
* 利用静态工厂方法
* 利用实例工厂方法

配置文件

Source code

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
5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
6. <bean id="helloWorld" class="cn.itcast.spring0401.createbean.HelloWorld"></bean>
7. <!--
8.  
9. -->
10. <bean id="helloWorld1" class="cn.itcast.spring0401.createbean.HelloWorldFactory" factory-method="createBean"></bean>
11. </beans>

工厂类

Source code

1. package cn.itcast.spring0401.createbean;
2.  
3. public class HelloWorldFactory {
4.     /**
5.      * 工厂方法
6.      * @return
7.      */
8.     public static HelloWorld createBean(){
9.         return new HelloWorld();
10.     }
11. }

helloworld

Source code

1. package cn.itcast.spring0401.createbean;
2.  
3. public class HelloWorld {
4.     public void say(){
5.         System.out.println("hello");
6.     }
7.  
8.     public HelloWorld(){
9.         System.out.println("new helloworld");
10.     }
11. }

测试类

Source code

1. package cn.itcast.spring0401.createbean;
2.  
3. import org.junit.Test;
4. import org.springframework.context.ApplicationContext;
5. import org.springframework.context.support.ClassPathXmlApplicationContext;
6.  
7. public class CreateBeanTest {
8.     /**
9.      * 在HelloWorld中写如下代码
10.      *         public HelloWorld(){
11.                 System.out.println("new helloworld");
12.             }
13.             输出为："new helloworld"
14.         说明
15.          * spring容器默认调用类的默认的构造器来创建对象的
16.          * 如果在HelloWorld中，没有默认的构造器，则spring在创建helloWorld对象时，会报错
17.          因为找不到默认的构造器
18.      */
19.     @Test
20.     public void testConstructor(){
21.         ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/createbean/applicationContext.xml");
22.  
23.         HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
24.         helloWorld.say();
25.     }
26.     /**
27.      * spring容器做的事情：
28.      * * spring容器调用了工厂类的工厂方法
29.      * * 真正创建对象new HelloWorld()是由程序员来完成的
30.      */
31.     @Test
32.     public void testFactory(){
33.         ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/createbean/applicationContext.xml");
34.  
35.         HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld1");
36.         helloWorld.say();
37.     }
38. }

4init包，创建对象的时机

默认情况下，在spring启动的时候，创建纳入spring容器中所有的bean
在spring容器启动的时候，可以检查错误
但是如果bean的属性中有数据，会过早的加载到内存中，所以如果bean中有数据
应该把数据的对象的声明放在方法中
* 如果在spring的配置文件中，有lazy-init为true，则context.getBean(“beanId”)时
才要创建对象
缺点：在spring容器启动的时候，是检验不出错误的

配置文件

Source code

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
5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
6. <bean id="helloWorld" class="cn.itcast.spring0401.init.HelloWorl" lazy-init="true"></bean>
7. </beans>

helloworld

Source code

1. package cn.itcast.spring0401.init;
2.  
3. import java.util.ArrayList;
4. import java.util.List;
5.  
6. public class HelloWorld {
7.  
8.     public List<String> sList = new ArrayList<String>();
9.     public void say(){
10.         System.out.println("hello");
11.     }
12.  
13.     public HelloWorld(){
14.         System.out.println("aaa");
15.     }
16. }

测试

Source code

1. package cn.itcast.spring0401.init;
2.  
3. import org.junit.Test;
4. import org.springframework.context.ApplicationContext;
5. import org.springframework.context.support.ClassPathXmlApplicationContext;
6.  
7. public class InitTest {
8.     /**
9.      * * 在默认情况下，spring容器启动的时候，就把所有的纳入spring容器的bean创建对象
10.      * 缺点：
11.      *     如果一个对象中有属性，比如这个属性为集合，在创建这个对象的过程中，集合中有数据
12.      * 这样采用默认的启动形式，就会导致数据过早的加载到内存中
13.      * * 可以在spring的配置文件中：
14.      * <bean id="helloWorld" class=".." lazy-init="true">
15.      * 延迟bean的创建时间，在context.getBean时才要创建bean的对象
16.      * 如果spring的配置文件书写错误，如果所有的spring的bean都采用lazy-init="true"这种形式
17.      则在启动web服务器的时候，发现不了spring容器的错误，这样是不利于排错的
18.      */
19.     @Test
20.     public void test(){
21.         ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/init/applicationContext.xml");
22.  
23.         HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
24.  
25.         helloWorld.say();
26.     }
27. }

5scope 对象作用范围，单例多里

在配置文件中，scope为
“singleton”
* 默认值
* spring产生的bean只有一个实例
* 处于单例模式的bean的创建、初始化、销毁都是受spring容器管理的
* 在容器关闭的时候执行销毁工作
“prototype”
* 多例
* spring容器负责该bean的创建、初始化，但是销毁工作程序员做
* 无论该bean的lazy-init为什么值，都在context.getBean时创建对象
* 如果该bean中有资源对象，手动关闭

配置

Source code

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
5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
6. <!--
7.     scope
8.      决定bean的范围
9.      singleton 单例 默认
10.      prototype 原型 多例
11. -->
12. <bean id="helloWorld" class="cn.itcast.spring0401.scope.HelloWorld" scope="singleton"></bean>
13. </beans>

测试

Source code

1. package cn.itcast.spring0401.scope;
2.  
3. import org.junit.Test;
4. import org.springframework.context.ApplicationContext;
5. import org.springframework.context.support.ClassPathXmlApplicationContext;
6.  
7. public class ScopeTest {
8.     /**
9.      * 由spring容器产生的bean默认是单例模式
10.      * 在spring的配置文件中：
11.      *      scope:
12.      * singleton 默认的形式
13.      * 如果写默认的形式，一个集合或者一个数据出现在了类的属性中，这个数据将成为全局的数据(共享数据)，应该
14.      * 注意并发问题
15.      * 当spring容器中的bean是多例，则不管配置文件中的lazy-init为default、false还是true，在
16.      * context.getBean时才要为bean创建对象
17.      */
18.     @Test
19.     public void test(){
20.         ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/scope/applicationContext.xml");
21.  
22.         HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
23.         helloWorld.s.add("aaa");
24.         helloWorld.s.add("bb");
25.         HelloWorld helloWorld1 = (HelloWorld)context.getBean("helloWorld");
26.         helloWorld1.s.add("cc");
27.         System.out.println(helloWorld.s.size());
28.     }
29. }

6initdestory

对象的初始化，销毁

配置文件

Source code

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
5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
6. <!--
7.     init-method
8.      对象的初始化方法
9.     destroy-method
10.      对象的销毁方法
11. -->
12. <bean id="helloWorld" class="cn.itcast.spring0401.initdestroy.HelloWorld" init-method="init" destroy-method="destroy" scope="prototype"></bean>
13. </beans>

测试

Source code

1. package cn.itcast.spring0401.initdestroy;
2.  
3. import org.junit.Test;
4. import org.springframework.context.ApplicationContext;
5. import org.springframework.context.support.ClassPathXmlApplicationContext;
6.  
7. public class InitDestroyTest {
8.     /**
9.      * 在spring的配置文件中
10.      *     init-method="init"
11.      * 说明在创建完该对象后，立刻执行init方法，用来进行初始化
12.      * destroy-method="destroy"
13.      * * 当该bean为单例模式，才能调用该方法
14.      * destroy方法在容器销毁的时候被调用
15.      * * 当该bean为多例时，spring容器不负责他的销毁工作
16.      * * 如果该bean为多例时，当不用该bean时，应该手动销毁资源文件
17.      */
18.     @Test
19.     public void test(){
20.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring0401/initdestroy/applicationContext.xml");
21.  
22.         HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
23.  
24.         helloWorld.say();
25.  
26.         context.destroy();//销毁spring容器
27.     }
28. }

hello

Source code

1. package cn.itcast.spring0401.initdestroy;
2.  
3. import java.util.ArrayList;
4. import java.util.List;
5.  
6. public class HelloWorld {
7.  
8.     public void say(){
9.         System.out.println("hello");
10.     }
11.  
12.     public void init(){
13.         System.out.println("init");
14.     }
15.