Spring实例化Bean的三种方式

Spring实例化Bean的三种方式分别是：

1，xml配置使用bean的类构造器

<bean id="personService" class="cn.service.impl.PersonServiceBean"></bean>

2，xml配置+factory类，使用静态工厂方法实例化

<bean id="personService2" class="cn.service.impl.PersonServiceBeanFactory"  factory-method="createPersonServiceBean"/>

3，xml配置+factory类，使用实例工厂方法实例化

<bean id="personServiceFactory" class="cn.service.impl.PersonServiceBeanFactory"/>

<bean id="personService3" factory-bean="personServiceFactory" factory-method="createPersonServiceBean2"/>

三种Spring实例化Bean方法的用处，

第一种方法，通过bean的缺省构造函数创建，当各个bean的业务逻辑相互比较独立的时候或者和外界关联较少的时候可以使用。

第二种方法，利用静态factory方法创建，可以统一管理各个bean的创建，如各个bean在创建之前需要相同的初始化处理，则可用这个factory方法险进行统一的处理等等。

第三种方法，利用实例化factory方法创建，即将factory方法也作为了业务bean来控制。

Bean的作用域：

1，默认：singleton（单例，每次getBean()都是相同的Bean）

<bean id="bean1" class="cn.transaction.Bean1"></bean>

2，prototype：（每次getBean()都会获得新的Bean）

<bean id="bean1" class="cn.transaction.Bean1" scope="prototype"></bean>

Bean的生命周期：

1，默认：singleton 在容器实例化的时候就会实例化；

1.1，更该实例化时间：

<bean id="bean1" class="cn.transaction.Bean1" lazy-init="true"></bean>

如果要为所有的Bean延迟初始化：

在beans中配置该属性

1.2，配置初始化方法：

<bean id="bean1" class="cn.transaction.Bean1" lazy-init="true" init-method="init"></bean>

1.3，配置销毁方法

<bean id="bean1" class="cn.transaction.Bean1" lazy-init="true" init-method="init" destroy-method="destroy"></bean>

1.4，bean在什么时候被销毁

默认既然是在spring容器初始化时创建Bean，所以是Bean是在spring容器关闭的时候销毁。

2，prototype：在调用getBean()的时候进行实例化；

-----------------------------------------------------------------------------------------------------------------

spring学习，理解控制反转和spring在项目中可以带来的好处

    Spring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP)的容器框架.它的主要目得是简化企业开发.
1  首先要理解控制反转的概念，如下面的程序
    public class PersonServiceBean {
     private PersonDao personDao = new PersonDaoBean();
 
      public void save(Person person){
            personDao.save(person);
     }
}

 PersonDao 就是依赖对象的类，PersonDaoBean 是在应用内部创建及维护的。所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转

  2把依赖对象交给外部容器负责创建，那么PersonServiceBean 类可以改成如下：
public class PersonServiceBean {
     private PersonDao personDao ;
    //通过构造器参数，让容器把创建好的依赖对象注入进PersonServiceBean，当然也可以使用setter方法进行注入。
     public PersonServiceBean(PersonDao personDao){
         this.personDao=personDao;
     } 
      public void save(Person person){
            personDao.save(person);
     }
}

所谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到组件中。

3.黎老师对spring在项目中可以带来下面的好处进行了总结。
   1）降低组件之间的耦合度,实现软件各层之间的解耦。
      Controller——>Service——>DAO
  2）可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。
3）容器提供单例模式支持，开发人员不再需要自己编写实现代码。
4）容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。
5）容器提供的众多辅作类，使用这些类能够加快应用的开发，如： JdbcTemplate、 HibernateTemplate。
6）Spring对于主流的应用框架提供了集成支持，如：集成Hibernate、JPA、Struts等，这样更便于应用的开发。

 7)  使用spring容器可以提供的服务：事务管理服务，JMS服务，Spring Core核心服务，持久化服务等。
8)如果使用Spring, 我们就不再需要手工控制事务，例如在Hibernate中控制事务的语句 session.beginTransaction(); session.getTransaction().commit();

9）使用Spring，不再需要我们处理复杂的事务传播行为。

     经常有人分不清spring属于轻量级框架,还是重量框架?有些人认为一个项目超过10M就是重量级的，这种划分很明显是错误的，因为有可能它包含了大部分的图片，而只含有很少的代码。其实划分一个应用是否属于轻量级还是重量级,主要看它使用了多少服务.使用的服务越多,容器要为普通java对象做的工作就越多,必然会影响到应用的发布时间或者运行性能.
对于spring容器，它提供了很多服务，但这些服务并不是默认为应用打开的，应用需要某种服务，还需要指明使用该服务，如果应用使用的服务很少，如:只使用了spring核心服务，那么我们可以认为此时应用属于轻量级的，如果应用使用了spring提供的大部分服务，这时应用就属于重量级。目前EJB容器就因为它默认为应用提供了EJB规范中所有的功能，所以它属于重量级。

---------------------------------------------------------------------------------------------------------------------

实例化bean的方式及Bean的作用域

使用Spring需要的jar
   可以到http://www.springsource.org/download下载spring，然后进行解压缩，在解压目录中找到下面jar文件，拷贝到类路径下

dist/spring.jar
lib/jakarta-commons/commons-logging.jar
如果使用了切面编程(AOP),还需要下列jar文件
lib/aspectj/aspectjweaver.jar和aspectjrt.jar
lib/cglib/cglib-nodep-2.1_3.jar
如果使用了JSR-250中的注解,如@Resource/@PostConstruct/@PreDestroy,还需要下列jar文件
lib/j2ee/common-annotations.jar

    该配置模版可以从spring的参考手册或spring的例子中得到。配置文件的取名可以任意，文件可以存放在任何目录下，但考虑到通用性，一般放在类路径下。

实例化Spring容器常用的两种方式：

方法一:
在类路径下寻找配置文件来实例化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});

方法二:
在文件系统路径下寻找配置文件来实例化容器
ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{“d://beans.xml“});

       一般使用第一种方式，Spring的配置文件可以指定多个，可以通过String数组

传入。
      当spring容器启动后，因为spring容器可以管理bean对象的创建，销毁等生命

周期，所以我们只需从容器直接获取Bean对象就行，而不用编写一句代码来创建

bean对象。从容器获取bean对象的代码如下：
ApplicationContext ctx = new ClassPathXmlApplicationContext(“beans.xml”);
OrderService service = (OrderService)ctx.getBean("personService");

     三种实例化bean的方式：
1.使用类构造器实例化
<bean id=“orderService" class="cn.itcast.OrderServiceBean"/>
2.使用静态工厂方法实例化
<bean id="personService" class="cn.itcast.service.OrderFactory" factory-method="createOrder"/>
public class OrderFactory {
 public static OrderServiceBean createOrder(){
  return new OrderServiceBean();
 }
}
3.使用实例工厂方法实例化:
<bean id="personServiceFactory" class="cn.itcast.service.OrderFactory"/>
<bean id="personService" factory-bean="personServiceFactory" factory-method="createOrder"/>
public class OrderFactory {
 public OrderServiceBean createOrder(){
  return new OrderServiceBean();
 }
}

Bean的作用域
  .singleton （单例）
   在每个Spring IoC容器中一个bean定义只有一个对象实例。默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。如：
 <bean id="xxx" class="cn.itcast.OrderServiceBean" lazy-init="true"/>
如果想对所有bean都应用延迟初始化，可以在根节点beans设置default-lazy-init=“true“，如下：
<beans default-lazy-init="true“ ...>
实际应用中不把这个属性设置为true.
.prototype (原型)
 每次从容器获取bean都是新的对象。每次调用getBean方法，都获取新的实例。
 调用调用getBean方法时 bean才实例化
.request 
.session 
.global session
在配置文件中指定Bean的初始化方法和销毁方法
<bean id="xxx" class="cn.itcast.OrderServiceBean" init-method="init" destroy-method="close"/>
Bean实例化后 ，就会执行init方法， Spring容器通过反射机制来调用。
AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
ctx.close();//正常关闭spring容器。