public class Person {

 private Integer id;
 private String name;
 
 public Person(){
  
 }
 
 public Person(String name) {
  this.name=name;
 }
 
   getter&&setter方法 
}


Person.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.bean">
 <class name="Person" table="person">
 
  <id name="id" type="integer">
   <generator class="native"></generator>
  </id>
  <property name="name" length="10" not-null="true">
  </property>
 </class>

</hibernate-mapping>

package cn.itcast.service;

import java.util.List;

import cn.itcast.bean.Person;

public interface IPersonService {

 /**
  * 保存人员信息
  * @param person
  */
 public abstract void save(Person person);

 /**
  * 更新信息
  * @param person
  */
 public abstract void update(Person person);

 /**
  * 获取人员
  * @param personId
  * @return
  */
 public abstract Person getPerson(Integer personId);

 /**
  * 删除人员信息
  * @param personId
  */
 public abstract void delete(Integer personId);

 /**
  * 获取人员列表
  * @return
  */
 public abstract List<Person> getPersons();

}

package cn.itcast.service.impl;

import java.util.List;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import cn.itcast.bean.Person;
import cn.itcast.service.IPersonService;

/**
 * 业务层，采用注解声明事务
 *
 * @author Administrator
 *
 */
@Transactional
public class PersonServiceBean implements IPersonService {

 @Resource
 private SessionFactory sessionFactory;

 public void save(Person person) {

  // 从spring 容器中得到正在管理的sessionFactory,persist方法用于保存实体

  sessionFactory.getCurrentSession().persist(person);

 }

 public void update(Person person) {
  sessionFactory.getCurrentSession().merge(person);
 }
@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)
 public Person getPerson(Integer personId) {
  return (Person) sessionFactory.getCurrentSession().get(Person.class,
    personId);
 }

 public void delete(Integer personId) {
  sessionFactory.getCurrentSession()
    .delete(
      sessionFactory.getCurrentSession().load(Person.class,
        personId));
 }
 @Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)
 @SuppressWarnings("unchecked")
 public List<Person> getPersons() {
  return sessionFactory.getCurrentSession().createQuery("from Person")
    .list();
 }

}

<?xml version="1.0" encoding="UTF-8"?>

<!--
 - Application context definition for JPetStore's business layer.
 - Contains bean references to the transaction manager and to the DAOs in
 - dataAccessContext-local/jta.xml (see web.xml's "contextConfigLocation").
-->
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

 <context:annotation-config />
 <!-- 配置数据源 -->
 <bean id="dataSource"
  class="org.apache.commons.dbcp.BasicDataSource"
  destroy-method="close">
  <property name="driverClassName"
   value="org.gjt.mm.mysql.Driver" />
  <property name="url"
   value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&amp;characterEncoding=UTF-8" />
  <property name="username" value="root" />
  <property name="password" value="" />
  <!-- 连接池启动时的初始值 -->
  <property name="initialSize" value="1" />
  <!-- 连接池的最大值 -->
  <property name="maxActive" value="500" />
  <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
  <property name="maxIdle" value="2" />
  <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
  <property name="minIdle" value="1" />
 </bean>

 <bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="dataSource" ref="dataSource" /><!-- 将datasource注入到sessionFactory -->
  <property name="mappingResources">
   <list>
    <value>cn/itcast/bean/Person.hbm.xml</value>
   </list>
  </property>
  <property name="hibernateProperties">
   <value>
    hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
    hibernate.hbm2ddl.auto=update hibernate.show_sql=false
    hibernate.format_sql=false
   </value>
  </property>
 </bean>

 <!--  通过事务管理 管理sessionFactory -->
 <bean id="txManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">

  <property name="sessionFactory" ref="sessionFactory" />
 </bean>

 <tx:annotation-driven transaction-manager="txManager" />
 <bean id="personServiceBean"
  class="cn.itcast.service.impl.PersonServiceBean">
 </bean>
</beans>

package junit;

import java.util.List;

import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.itcast.bean.Person;
import cn.itcast.service.IPersonService;

public class IPersonServiceTest {

 private static IPersonService ipersonservice;
 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
  try {
   ApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
   ipersonservice=(IPersonService)ctx.getBean("personServiceBean");
  } catch (RuntimeException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 @Test
 public void TestSave(){
  
  ipersonservice.save(new Person("小张"));
  System.out.println("保存成功");
 }

 @Test public void testGetPerson(){
  Person person=ipersonservice.getPerson(1);
  System.out.println(person.getName());
 }
 
 @Test public void testUpdate(){
  Person person=ipersonservice.getPerson(1);
  person.setName("小丽");
  ipersonservice.update(person);
 }
 
 @Test public void testGetPersons(){
  List<Person> persons=ipersonservice.getPersons();
  for(Person person : persons){
   System.out.println(person.getId()+"  :" +person.getName());
  }
 }
 
 @Test public void testDelete(){
  ipersonservice.delete(1);
 }
}

table :person
id  int
name varchar

@Aspect
public class LogPrint {
 @Pointcut("execution(* cn.itcast.service..*.*(..))")
 private void anyMethod() {}//声明一个切入点 
 @Before("anyMethod() && args(userName)")//定义前置通知
 public void doAccessCheck(String userName) {
 } 
 @AfterReturning(pointcut="anyMethod()",returning="revalue")//定义后置通知
 public void doReturnCheck(String revalue) {
 }
 @AfterThrowing(pointcut="anyMethod()", throwing="ex")//定义例外通知
    public void doExceptionAction(Exception ex) {
 }
 @After("anyMethod()")//定义最终通知
 public void doReleaseAction() {
 }
 @Around("anyMethod()")//环绕通知
 public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
  return pjp.proceed();
 }
}

基于基于XML配置方式声明切面


public class LogPrint {
 public void doAccessCheck() {}定义前置通知
 public void doReturnCheck() {}定义后置通知
    public void doExceptionAction() {}定义例外通知
 public void doReleaseAction() {}定义最终通知
 public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
  return pjp.proceed();环绕通知
 }
}


<bean id="orderservice" class="cn.itcast.service.OrderServiceBean"/>
<bean id="log" class="cn.itcast.service.LogPrint"/>
<aop:config>
  <aop:aspect id="myaop" ref="log">
   <aop:pointcut id="mycut" expression="execution(* cn.itcast.service..*.*(..))"/>
   <aop:before pointcut-ref="mycut" method="doAccessCheck"/>
   <aop:after-returning pointcut-ref="mycut" method="doReturnCheck "/>
   <aop:after-throwing pointcut-ref="mycut" method="doExceptionAction"/>
   <aop:after pointcut-ref="mycut" method=“doReleaseAction"/>
   <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>
  </aop:aspect>
</aop:config>
 

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

• 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
• Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
• Spring AOP： 通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
• Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写 的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
• Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
• Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
• Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

        Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。

 public abstract void Save();
 public Set<String> getSets() ;
 public List<String> getLists() ;
 public Properties getProperties() ;
 public Map<String, String> getMaps() ;

}

public class PersonServiceBean implements IPersonService {

 private IPersonDao iPersonDao;
 private Set<String> sets=new HashSet<String>();
 private List<String> lists=new ArrayList<String>();
 private Properties properties=new Properties();
 private Map<String,String> maps=new HashMap<String,String>();
 
 public PersonServiceBean(IPersonDao personDao, String name) {
  
  iPersonDao = personDao;
  this.name = name;
 }
 public void Save(){
  System.out.println(name);//输出name
  iPersonDao.add();
 }

 private String name;
 
 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public Map<String, String> getMaps() {
  return maps;
 }

 public void setMaps(Map<String, String> maps) {
  this.maps = maps;
 }

 public Properties getProperties() {
  return properties;
 }

 public void setProperties(Properties properties) {
  this.properties = properties;
 }

 public Set<String> getSets() {
  return sets;
 }

 public void setSets(Set<String> sets) {
  this.sets = sets;
 }

 public IPersonDao getIPersonDao() {
  return iPersonDao;
 }

 public void setIPersonDao(IPersonDao personDao) {
  iPersonDao = personDao;
 }

 
 public List<String> getLists() {
  return lists;
 }

 public void setLists(List<String> lists) {
  this.lists = lists;
 }
}



测试类：

public class SpringTest {

 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
 }
 @Test
 public void instanceSpring() {
  ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(
    "beans.xml");
  // ItcastClassPathXMLApplicationContext ctx=new
  // ItcastClassPathXMLApplicationContext("beans.xml");
  //  
  IPersonService ipersonService = (IPersonService) ctx
    .getBean("personService");
  //集合对象的遍历
  System.out.println("===========set==================");
  for (String value : ipersonService.getSets()) {
   
   System.out.println(value);
  }
  // ipersonService.Save();
  // ctx.close();
  // ctx.registerShutdownHook();
  System.out.println("===========List=================");
  for(String value:ipersonService.getLists()){
   
   System.out.println(value);
  }
  
  System.out.println("=========properties===============");
  for(Object value:ipersonService.getProperties().keySet()){
   System.out.println(value);
  }
  System.out.println("================maps==================");
  for(Object value:ipersonService.getMaps().keySet()){
   System.out.println(value);
  }
  //调用PersonServiceBean的sava方法，输出结果
  ipersonService.Save();
  
 }
}

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
 <bean id="personService"
  class="cn.itcast.service.impl.PersonServiceBean">
  <property name="IPersonDao" ref="personDaoBean"></property>

  <constructor-arg index="0" ref="personDaoBean"
   type="cn.itcast.dao.IPersonDao" />
  <constructor-arg index="1" type="java.lang.String"
   value="传智博客">
  </constructor-arg>

  <property name="sets">
   <set>
    <value>set1</value>
    <value>set2</value>
    <value>set3</value>
   </set>
  </property>

  <property name="lists">
   <list>
    <value>list1</value>
    <value>list2</value>
    <value>list3</value>
   </list>
  </property>

  <property name="properties">
   <props>
    <prop key="properties1">property1</prop>
    <prop key="properties2">property2</prop>
    <prop key="properties3">property3</prop>
   </props>
  </property>

  <property name="maps">
   <map>
    <entry key="key1" value="keyFirst"></entry>
    <entry key="key2" value="keySecond"></entry>
    <entry key="key3" value="keyThird"></entry>
   </map>
  </property>
 </bean>
 <bean id="personDaoBean" class="cn.itcast.dao.impl.PersonDaoBean"></bean>

 <!--
  <bean id="anotherPersonServiceBean"
  class="cn.itcast.service.impl.AnotherPersonServiceBean" >
  </bean>
 -->
</beans>


public class PersonDaoBean implements IPersonDao {
 public void add(){
  System.out.println("这是personDaoBean的Add()方法");
 }
}

/**
 * 实现的spring容器
 *
 * @author Administrator
 *
 */
public class ItcastClassPathXMLApplicationContext {

 private List<BeanDefinition> beanDefines = new ArrayList<BeanDefinition>();
 private Map<String, Object> sigletons = new HashMap<String, Object>();

 public ItcastClassPathXMLApplicationContext() {

 }

 public ItcastClassPathXMLApplicationContext(String filename) {
  // System.out.println("构造方法 ");
  this.readXml(filename);// 调用 读取配置文件 的方法
  this.instanceBeans();// 调用bean的实例化
  this.injectObject();// 注入对象
 }

 /**
  * 为bean对象的属性注入值
  */
 private void injectObject() {
  for (BeanDefinition beanDefinition : beanDefines) {
   Object bean = sigletons.get(beanDefinition.getId());
   if (bean != null) {
    // 取得属性描述 ，是一个数组
    try {
     PropertyDescriptor[] ps = Introspector.getBeanInfo(
       bean.getClass()).getPropertyDescriptors();
     for (PropertyDefinition propertyDefinition : beanDefinition
       .getPropertys()) {// 取所有属性
      for (PropertyDescriptor properdesc : ps) {
       if (propertyDefinition.getName().equals(
         properdesc.getName())) {
        Method setter = properdesc.getWriteMethod();// 获取属性的setter方法.
        // private
        if (setter != null) {
         Object value=null;
         if(propertyDefinition.getRef()!=null && !"".equals(propertyDefinition.getRef().trim())){
          value = sigletons
            .get(propertyDefinition
              .getRef());
          
         }else{
          //将配置文件里字符串类型转换为属性类型的值
          value=ConvertUtils.convert(propertyDefinition.getValue(), properdesc.getPropertyType());
          
         }
         setter.setAccessible(true);// 设置为可访问
         setter.invoke(bean, value);// 把引用对象注入到属性
         
        }
        break;
       }
      }
     }
    } catch (Exception e) {
     e.printStackTrace();
    }

   }
  }

 }

 /**
  * 完成bean的实例化
  */
 private void instanceBeans() {
  // System.out.println("bean实例化方法被调用");
  // 利用反射机制把bean实例化
  for (BeanDefinition beanDefinition : beanDefines) {
   try {
    // 判断BeanDefinition的实例获得的类名不为null和空串
    if (beanDefinition.getClassName() != null
      && !"".equals(beanDefinition.getClassName().trim()))
     sigletons.put(beanDefinition.getId(), Class.forName(
       beanDefinition.getClassName()).newInstance());
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }

  }

 }

 /**
  * 读取配置文件信息
  *
  * @param filename
  */
 private void readXml(String filename) {
  // System.out.println("读取xml文件的方法被调用了");

  SAXReader saxReader = new SAXReader();// 创建读取器
  Document document = null;
  try {
   URL xmlpath = this.getClass().getClassLoader()
     .getResource(filename);//取得当前xml文件在本地的位置
   
   document = saxReader.read(xmlpath);// 读取路径
   Map<String, String> nsMap = new HashMap<String, String>();
   nsMap.put("ns", "http://www.springframework.org/schema/beans");// 加入命名空间
   XPath xsub = document.createXPath("//ns:beans/ns:bean");// 创建beans/bean查询路径
   xsub.setNamespaceURIs(nsMap);// 设置命名空间
   List<Element> beans = xsub.selectNodes(document);// 获取文档下所有bean节点
   for (Element element : beans) {
    String id = element.attributeValue("id");// 获取id属性值
    String clazz = element.attributeValue("class");// 获取class属性值
    BeanDefinition beanDefine = new BeanDefinition(id, clazz);
    XPath propertysub = element.createXPath("ns:property");// 船舰查询路径

    propertysub.setNamespaceURIs(nsMap);// 设置命名空间
    List<Element> propertys = propertysub.selectNodes(element);// 查找节点
    for (Element property : propertys) {
     String propertyName = property.attributeValue("name");// 取得property的name值
     String propertyref = property.attributeValue("ref");// 取得property的ref值
     String propertyValue = property.attributeValue("value");// 取得property的value值

     PropertyDefinition propertyDefinition = new PropertyDefinition(
       propertyName, propertyref,propertyValue);
     beanDefine.getPropertys().add(propertyDefinition);// 将属性对象加入到bean中
    }

    beanDefines.add(beanDefine);
   }
  } catch (Exception e) {
   e.printStackTrace();

  }

 }

 /**
  * 获取bean 实例
  *
  * @param beanName
  * @return
  */
 public Object getBean(String beanName) {

  
  return this.sigletons.get(beanName);
 }

}

public class SpringTest {

 @BeforeClass
 public static void setUpBeforeClass() throws Exception {

 }
 @Test
 public void instanceSpring() {
//  ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(
//    "beans.xml");
  ItcastClassPathXMLApplicationContext ctx=new ItcastClassPathXMLApplicationContext("beans.xml");
//  
  IPersonService ipersonService = (IPersonService)ctx
    .getBean("personService");
  ipersonService.Save();
 // ctx.close();
  // ctx.registerShutdownHook();

 }
}


public class PropertyDefinition {
 private String name;
 private String ref;
 private String value;
 public PropertyDefinition(String name, String ref,String value) {
  
  this.name = name;
  this.ref = ref;
  this.value=value;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getRef() {
  return ref;
 }
 public void setRef(String ref) {
  this.ref = ref;
}
其他略。

out:
Itcast
15
这是personDaoBean的Add()方法

 public abstract void Save();

}

public class PersonDaoBean implements IPersonDao {

 
 public void add(){
  System.out.println("这是personDaoBean的Add()方法");
 }
}

public class PersonServiceBean implements IPersonService {

 private IPersonDao iPersonDao;
 
 public IPersonDao getIPersonDao() {
  return iPersonDao;
 }

 public void setIPersonDao(IPersonDao personDao) {
  iPersonDao = personDao;
 }

 public void Save(){
  iPersonDao.add();
 }
 
 
}

public void instanceSpring() {
  ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(
    "beans.xml");
  IPersonService ipersonService = (IPersonService) ctx
    .getBean("personService");
  ipersonService.Save();
  ctx.close();
  // ctx.registerShutdownHook();

 }

 public void init(){
  
  System.out.println("我是初始化函数");
 }
 
 public PersonServiceBean(){
  System.out.println("我是构造函数");
 }
 public void Save(){
  System.out.println("save方法");
 }
 
 public void cleanup(){
  System.out.println("cleanup方法");
 }
}


<bean id="personService"
  class="cn.itcast.service.impl.PersonServiceBean"
   init-method="init" destroy-method="cleanup"/>

@Test public void instanceSpring(){
  ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
  IPersonService ipersonService=(IPersonService)ctx.getBean("personService");
 ctx.close();

.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“ ...>

.prototype
 每次从容器获取bean都是新的对象。
 
.request
.session
.global session

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
  PersionSevice ps=(PersionSevice)ctx.getBean("persionServiceBean");
  PersionSevice ps2=(PersionSevice)ctx.getBean("persionServiceBean");
  System.out.println(ps==ps2);

 输出:true

可见spring容器默认的bean的产生方式是单例

改

 <bean id="persionServiceBean" class="cn.com.xinli.service.impl.PersionServiceBean" scope="prototype"></bean> 

这时候输出：false ,显然ps与ps2就不一样。

1.使用类构造器实例化
<bean id=“orderService" class="cn.itcast.OrderServiceBean"/>

2.使用静态工厂方法实例化
<bean id="persionServiceBean2" class="cn.com.xinli.service.impl.PersionServiceBeanFactory" factory-method="createPersionServiceBean"/>

public class PersionServiceBeanFactory
{
 public static PersionServiceBean createPersionServiceBean()
 {
  return new PersionServiceBean();
 }
}

例子:

(1).首先写工厂类.他其中包含产生我们的业务bean的方法

Java代码

1. package cn.com.xinli.service.impl;   
2.   
3.   
4. public class PersionServiceBeanFactory   
5. {   
6.     public static PersionServiceBean createPersionServiceBean()   
7.     {   
8.         return new PersionServiceBean();   
9.     }   
10. }  

package cn.com.xinli.service.impl;
public class PersionServiceBeanFactory
{
public static PersionServiceBean createPersionServiceBean()
{
return new PersionServiceBean();
}
}

(2).改写beans.xml :包含工厂类类名和产生业务bean的方法名字

 <bean id="persionServiceBean2" class="cn.com.xinli.service.impl.PersionServiceBeanFactory" factory-method="createPersionServiceBean"/>

 (3) 测试

Java代码

1. ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");   
2.         PersionSevice ps=(PersionSevice)ctx.getBean("persionServiceBean2");   
3.                                                         
4.         ps.save();  

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
PersionSevice ps=(PersionSevice)ctx.getBean("persionServiceBean2");
ps.save();

 (4) 结果

2009-05-24 14:34:00,781  INFO (PersionServiceBean.java:12) - 我是save()方法!

3.使用实例工厂方法实例化:

<bean id="PersionServiceBeanFactory" class="cn.com.xinli.service.impl.PersionServiceBeanFactory"></bean>
    <bean id="persionServiceBean3" factory-bean="PersionServiceBeanFactory" factory-method="createPersionServiceBean2"></bean>

public  PersionServiceBean createPersionServiceBean2()
 {
  return new PersionServiceBean();
 }

例子:

(1). 首先写工厂类.他其中包含产生我们的业务bean的方法 ,在已有代码的基础上

Java代码

1. package cn.com.xinli.service.impl;   
2.   
3.   
4. public class PersionServiceBeanFactory   
5. {   
6.     public static PersionServiceBean createPersionServiceBean()   
7.     {   
8.         return new PersionServiceBean();   
9.     }   
10.        
11.     <SPAN style="COLOR: #ff0000">public  PersionServiceBean createPersionServiceBean2()   
12.     {   
13.         return new PersionServiceBean();   
14.     }</SPAN>   
15.        
16. }  

package cn.com.xinli.service.impl;
public class PersionServiceBeanFactory
{
public static PersionServiceBean createPersionServiceBean()
{
return new PersionServiceBean();
}
public  PersionServiceBean createPersionServiceBean2()
{
return new PersionServiceBean();
}
}

(2).改写beans.xml :写两个bean,一个是工厂bean,一个是利用工厂bean产生业务bean的bean.

Xml代码

1. <bean id="PersionServiceBeanFactory" class="cn.com.xinli.service.impl.PersionServiceBeanFactory"></bean>  
2.     <bean id="persionServiceBean3" factory-bean="PersionServiceBeanFactory" factory-method="createPersionServiceBean2"></bean>  

<bean id="PersionServiceBeanFactory" class="cn.com.xinli.service.impl.PersionServiceBeanFactory"></bean>
<bean id="persionServiceBean3" factory-bean="PersionServiceBeanFactory" factory-method="createPersionServiceBean2"></bean>

 (3) 测试

Java代码

1. ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");   
2.         PersionSevice ps=(PersionSevice)ctx.getBean("persionServiceBean3");   
3.                                                         
4.         ps.save();  

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
PersionSevice ps=(PersionSevice)ctx.getBean("persionServiceBean3");
ps.save();

 (4) 结果

2009-05-24 14:49:17,812  INFO (PersionServiceBean.java:12) - 我是save()方法!

 (5) 注意,其实方式2和方式3的区别就在 工厂类中是如何产生业务bean的,方式2是static方式,方式3不是