Spring Framework创建对象时间、初始化与销毁、IOC与DI结合的真正意义……

恍恍惚惚大二一年又过去了，马上要进入大三了，第一篇博客是刚上大二时候写的，到现在怎么感觉博客质量倒不如从前了，一直忙碌，却感觉没有忙出什么成效来，更博也少了，也只是贴上些代码，文字的描述更少了，感觉自己变得敷衍了，看来是应该反思反思这一年都干了什么。好吧，废话也不多说了，先贴上这篇最近学习spring的一点总结吧

1.什么是Spring，Spring是用来干嘛的?

Spring是一个非常活跃的开源框架；它是一个基于Core来构架多层JavaEE系统的框架,它的主要目地是简化企业开发.

Spring以一种非侵入式的方式来管理你的代码，Spring提倡”最少侵入”，这也就意味着你可以适当的时候安装或卸载Spring

 Spring就是一个容器

2.Spring的配置文件 

     默认情况下是applicationContext.xml文件。可以建立很多xml文件，工程中一般都是这样配置的。

3.Spring创建对象的时间

a.(在默认的情况下,启动Spring容器的时候创建对象)

好处:因为是在Spring容器启动的时候就创建对象,所以只要配置文件书写错误，在一开始的时候(web容器启动)就能发现错误

    b.懒加载lazy-init=”true” (在context.getBean时才要创建该对象)

   

<bean id=”” class=”” lazy-init=”true”></bean> 

 

 

 

4.怎么证明Spring容器是单例的还是多例的

 

  a.我们可以写一个小例子，看地址，在Spring容器中的对象默认是单例的，因为对象是单例的，所以只要在类上声明一个属性，该属性中含有数据，那么该属性是全局的（这么做是很危险的），如下图

   <bean id="helloWorld" class="com.zkx.spring.scope.HelloWorld"></bean>

测试:

@Test
public void testScope_Default(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");

HelloWorld helloWorld2 = (HelloWorld)context.getBean("helloWorld");

System.out.println(helloWorld);

System.out.println(helloWorld2);

}

 

 

结果 com.zkx.spring.scope.HelloWorld@43763e0b

  com.zkx.spring.scope.HelloWorld@43763e0b

 证明了Spring容器中的对象默认是单例的

 

 

  b.如果说scope为”prototype”的时候,spring容器产生的对象就是多实例，无论lazy-init为什么值，都是在context.getBean时才要创建对象

  <bean id="helloWorld2" class="com.zkx.spring.scope.HelloWorld"

   scope="prototype"></bean>

 

测试结果是2个不同的地址，这里就不上测试代码了

 

注:在web开发中，通常把Srvice层和Dao层放进Spring容器中，整成单例的，这样你在浏览器输入一个url，一千次访问，一万次访问，Action调用Service,Service调用Dao，那么也只会产生一个Srvice层的对象和一个Dao层的对象，那么JVM销毁这些对象的压力大大减轻

 

5.什么是IOC?

IOC：Inversion of Control 控制反转

IOC即Spring的控制反转：把对象的创建、初始化、销毁等工作交给spring容器来做。由spring容器控制对象的生命周期。

 

 

6.Spring的初始化和销毁

在applicationContext.xml文件中,加上下面的代码

<bean id="helloWorld" class="com.zkx.spring.initdestroy.HelloWorld"

init-method="init"

destroy-method="destroy"></bean>

初始化方：init-method

销毁方法 ：destroy-method

 

public class HelloWorld {

public HelloWorld(){

System.out.println("aaaa");

}

public void hello(){

System.out.println("hello world");

}

public void init(){

System.out.println("init");

}

public void destroy(){

System.out.println("destroy");

}

}

 

 

 

@Test

public void testInitDestroy(){

ApplicationContext context = 

new ClassPathXmlApplicationContext("applicationContext.xml");

HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");

helloWorld.hello();
ClassPathXmlApplicationContext applicationContext = (ClassPathXmlApplicationContext) context;
applicationContext.close();//spring容器关闭

}

 

 

测试结果:

aaa

Init

Helloworld

destory

Spring容器关闭时,调用销毁方法,如果spring容器没有执行close方法，则不执行销毁方法,如果spring容器执行了close方法，在执行该方法之前要执行销毁方法；在构造方法之后，立刻执行init方法(destroy用途不是很大,init方法用途很多)

7.Spring的执行流程

 

 

8.DI?

DI:Dependency Injection 依赖注入

 依赖注入简单的说就是给属性赋值，有2种注入的方法:

 a.使用构造器注入

使用xml的注入方式

   通过参数的顺序

<constructor-arg index="0">

      <value>张三</value>

</constructor-arg>

<constructor-arg index="1">

       <value>56</value>

 </constructor-arg> 

 

 

  通过参数的类型

<constructor-arg type="java.lang.Integer">

              <value>56</value>

       </constructor-arg>

       <constructor-arg type="java.lang.String">

              <value>张三</value>

</constructor-arg>

 

 

b.使用属性set方法进行注入

使用xml的注入方式：

   简单Bean的注入

简单Bean包括两种类型：包装类型和String

<bean id="personService"   class="com.zkx.bean.impl.PersonServiceImpl">
<!-- 基本类型,string类型 -->
<property name="age" value="20"></property>
            <property name="name" value="张无忌"></property>    
</bean>
        <!--  引用其他Bean -->
               <bean id="person" class="com.zkx.bean.Person" />
               <bean id="personService"  class="com.zkx.bean.impl.PersonServiceImpl">
            <property name="person" ref="person" />

</bean>

 

 

 

 

 

9.IOC和DI结合的真正意义

 a.不完全的面向接口编程(客户端还得关心这个接口是由哪个类实现的)

如下图就是不完全的面向接口编程(WordDoment等类实现了Document接口，具体类的实现我就不列出来了)，包括我以前那篇关于面向接口编程的博客，也是不完全的面向接口编程

@Test

public void testDocument_NOSpring(){

//为不完全的面向接口编程

Document document = new WordDocument();

DocumentManager documentManager = new DocumentManager();

documentManager.setDocument(document);

documentManager.readDocument();

documentManager.writeDocument();

}

 

 

   b把documentManager,wordDocument,excelDocument,pdfDocument放入到spring容器中

  

   

<bean id="documentManager" class="com.zkx.spring.iocdi.document.DocumentManager">

   <property name="document">

   <ref bean="wordDocument"/>

   </property>

   </bean>

   <bean id="wordDocument" class="com.zkx.spring.iocdi.document.WordDocument"></bean>

   <bean id="excelDocument" class="com.zkx.spring.iocdi.document.ExcelDocument"></bean>

   <bean id="pdfDocument" class="com.zkx.spring.iocdi.document.PDFDocument"></bean>

 

 

 

Java代码端的测试

@Test

public void testDocument_Spring(){

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

DocumentManager documentManager = (DocumentManager)context.getBean("documentManager");

documentManager.writeDocument();

documentManager.readDocument();

}

 

 

没有出现一个WordDocment等，也就是说java代码这头，只需要完全面向接口编程就行了，只需要关心Docment的API实现什么样的功能，至于说这个Docment具体是谁，我不关心

这就是IOC和DI结合的真正意义:

Java代码端完全的面向接口编程(现在很多容器都有这功能，都是模仿Spring的)