java学习之路----spring探索1----了解IOC的小例子

前面已经模拟了spring的IOC功能，现在来真正的使用spring

前面具有源码，下面都是基于前面的源码的： http://blog.csdn.net/javastudyr/article/details/17055743

 1.建立一个项目

2.导包（我用的是3.2.3的包）

3.最好建立一个library

               步骤如下：Window--->preferences--->搜索框输入us，看到有个User Libraries---->new-->输入名字--->添加jar包----->选择项目---->右键bulid path--->add library--->user Library--->选择你的library

4.删除自己写的spring ，我们用spring的，引入spring的包

5.修改test  

public   class  UserServiceTest {

       @Test

       public   void  testAddUser()  throws  Exception{

          BeanFactory beans=  new  ClassPathXmlApplicationContext( "beans.xml"  ); //我们在这儿要告诉spring我们的配置文件在那

          

          UserService service=(UserService)beans.getBean( "userService"  );

          User user=  new  User();

          service.addUser(user);

     

     }

}

运行结果：

save user

6.注入的方式有哪些

               有三种，只需要掌握一种set注入就OK

                                   setter注入（掌握它）

                                   构造方法注入

                                   接口注入

7. id和name 区别

<?  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-3.0.xsd"  >

       < bean  id= "u"   class =  "com.test.dao.impl.UserDAOImpl"  >

       </ bean  >

       < bean  id =  "userService"   class  = "com.test.service.UserService"  >

                <!-- <property name="userDAO" bean="u" />修改为下面的样子 -->

            <  property   name =  "userDAO"   ref  =  "u"   />

          

       </ bean  >

</  beans >    

       

可以把红色标注的id="u"改为name="u"

<  bean   name  =  "u"   class  =  "com.test.dao.impl.UserDAOImpl"  >        

运行一下结果一样，它们有什么区别喃？

它们没什么大的区别，一般就是name里面可以包含特殊字符

8.简单的属性注入：

          我们一般不会用，只有在ssh框架整合的时候，spring会用到。

看个例子：

           <  bean   id =  "dataSource"   class  = "com.mchange.v2.c3p0.ComboPooledDataSource"

            destroy-method  = "close"  >

            < property name= "driverClass" value ="com.mysql.jdbc.Driver" /> 

         </  bean  >

红色部分就是简单属性注入（初始化属性的值）

9.bean的范围（scope）

默认的情况下是scope=sington（单例模式）

我们来验证一下：

public   class  UserServiceTest {

       @Test

       public   void  testAddUser()  throws  Exception{

          ApplicationContext beans=  new  ClassPathXmlApplicationContext( "beans.xml"  ); //我们在这儿要告诉spring我们的配置文件在那

          

          UserService service=(UserService)beans.getBean( "userService"  );

          UserService service1=(UserService)beans.getBean( "userService"  );//实例化两个UserService实例

          

          System.  out  .println(service==service1);//比较是否相等

          

          User user=  new  User();

          service.addUser(user);

     

     }

}

结果：

true

save user

证明是一个对象，那就是单例模式。（所以默认是单例）

一般它还有一个值叫prototype(原型)

我们来修改下配置文件

<  bean   id  =  "userService"   class  =  "com.test.service.UserService"   scope = "prototype" >

我们在来试试

同样用上面的测试代码

     结果：

false

save user

这里补充一下：

         prototype原型，就是指每创建一个对象我都是用原型来创建一个，都是新的。。

10.自动装配（autowire）

          

          默认是no(就是不自动装配);

           一般我们会用有两种：byName（按名字装配）,byType（类型装配）

 我们先来修改一下代码：

           public   class  UserDAOImpl  implements  UserDAO{

     

       private   int   daoId  ;

     

     

       public   int  getDaoId() {

            return   daoId  ;

     }

       public   void  setDaoId(  int  daoId) {

            this  . daoId  = daoId;

     }

       @Override

       public   void  save(User u) {

          

          System.  out  .println( "save user"  +  this .  daoId );

     }

}

增加一个Id来辨别不同的dao

修改beans

<?  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-3.0.xsd"  >

       < bean  name =  "userDAO"   class  = "com.test.dao.impl.UserDAOImpl"  >

            <  property   name =  "daoId"   value  =  "1" ></  property  >               

       </ bean  >

       < bean  name =  "userDAO2"   class  = "com.test.dao.impl.UserDAOImpl"  >

                <!-- 简单属性注入 -->

            <  property   name =  "daoId"   value  =  "2" ></  property  >     

       </ bean  >

       < bean  id =  "userService"   class  = "com.test.service.UserService"  >

                <!-- <property name="userDAO" bean="u" />修改为下面的样子 -->

          <!--    < property   name =  "userDAO"   ref  =  "userDAO"   />注释掉   -->

       </ bean  >

</  beans >

          

运行一下代码：（测试默认值）

结果：抛出空指针异常，说明没有注入，那么默认值是no

下面我们来测试byName

 < bean  id =  "userService"   class  = "com.test.service.UserService"  autowire = "byName" >

我们在来测试一下

结果：

save user1

OK，注入成功，掉了名字userDAO,默认名字就是这个

下面我们来测试byType

< bean id = "userService" class = "com.test.service.UserService" autowire = "byType">

结果：

抛出异常，说找到了两个，一个是userDAO,一个是userDAO2

  这是因为它通过类型（UserDAO来找UserDAOImpl 自然就有两个）。

修改beans

<?  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-3.0.xsd"  >

       < bean  name =  "userDAO"   class  = "com.test.dao.impl.UserDAOImpl"  >

            <  property   name =  "daoId"   value  =  "1" ></  property  >               

       </ bean  >

     

       < bean  id =  "userService"   class  = "com.test.service.UserService"  autowire =  "byType" >

                <!-- <property name="userDAO" bean="u" />修改为下面的样子 -->

             <!--    < property   name =  "userDAO"   ref  =  "userDAO"   />注释掉   -->

       </ bean  >

</  beans >

删除userDAO2

结果：

save user1

补充：一般我们不会用自动装配，一般还是用自己手动装配

11.生命周期

<  bean   id  =  "userService"   class  =  "com.test.service.UserService" lazy-init="true" >

一般情况下，当我们把applicationContext  实例化的时候，配置文件（容器）就全部这些初始化了，如果加上这个属性，就是我们需要才初始化

          lazy-init  第一次加载的容器的时候不初始化，等到我们需要用到的时候才来初始化

     一般我们用到不多。

     下面介绍一个init-method 和 destory-method

     例子：

     修改代码：

public   class  UserService {

       //private UserDAO userDao=new UserDAOImpl();原来是这样的

     

       private  UserDAO  userDAO ;  //现在是这样，通过配置文件来实例化

     

       private void init(){

          System. out .println("init" );

     }

     

       public  UserDAO getUserDAO() {

            return   userDAO  ;

     }

       public   void  setUserDAO(UserDAO userDAO) {

            this  . userDAO  = userDAO;

     }

       public   void  addUser(User user ){

            userDAO .save(user);

          

     };

}

<  bean   id =  "userService"   class  = "com.test.service.UserService"  init-method= "init"  >

                <!-- <property name="userDAO" bean="u" />修改为下面的样子 -->

             <  property   name =  "userDAO"   ref   =   "userDAO"  />

       </ bean  >

          

          

结果：

init

save user1

就是初始化的时候会去调用init-method这个方法。。