手机号码：Request.ServerVariables("HTTP_X_UP_CALLING_LINE_ID")
手机型号：request.ServerVariables("HTTP_User-Agent")

补充：
手机号码，要看当地的运营商了
有三种方法获得（联通的）
1．加密的手机号码：被加密的手机号码，与手机号码一一对应。
中国联通WAP平台向CP Server（主域或IP地址）传送加密手机号码，CP Server获取该加密手机号码的方法为：在每次用户发送的请求http header中取“deviceid”。
2．公开的手机号码：中国联通WAP平台向CP Server（主域或IP地址）传送公开的手机号码，CP Server获取该公开手机号码的方法为：在每次用户发送的请求http header中取“x-up-calling-line-id”。
以上要和联通进行申请

3、你可以试这样的方法获得手机号码： Mobile = request.ServerVariables("HTTP_X_UP_subno")
Mobile =mid(FromMobile,3,11) ？？
asp?lp=27&id=1782582>http://www.blueidea.com/bbs/NewsDetail.asp?lp=27&id=1782582
声明：第三种方法不保险

头文件参考：
答7：
POST /default.asp HTTP/1.0
Host: 211.94.121.3:81
content-type: text/plain
accept-language: zh
accept-charset: ISO-8859-1, UTF-8; Q=0.8, ISO-10646-UCS-2; Q=0.6
profile: http://nds.nokia.com/uaprof/N7210r100.xml
user-agent: Nokia7210/1.0 (3.09) Profile/MIDP-1.0 Configuration/CLDC-1.0
x-wap.tod-coded: Thu, 01 Jan 1970 00:00:00 GMT
accept: */*
content-length: 1
Cookie: ASPSESSIONIDGGGQGAPU=KFHHMHPCHJFPKPEPBEDFHCJL
via: WTP/1.1 wapgw2 (Nokia WAP Gateway 3.1/CD1/3.1.43), HTTP/1.1 httpproxy2[0A0000C3] (Traffic-Server/4.0.9 [uSc ])
X-Network-info: GPRS,10.15.96.127,13810027XXX,211.139.172.70,unsecured
X-Forwarded-For: 10.15.96.127
X-Up-Calling-Line-ID: 13810027XXX
X-Source-ID: 211.139.172.70
X-Nokia-CONNECTION_MODE: CLESS
X-Nokia-BEARER: GPRS
X-Nokia-gateway-id: NAWG/3.1/Build43
Client-ip: 192.168.0.6
Connection: keep-alive

package cn.itcast.bean;

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

package cn.itcast.service;

import java.util.List;

import cn.itcast.bean.Person;

public interface IPersonService {

 public void save(Person person);
 
 public void update(Person person);
 
 public void delete(int personId);
 
 public Person getPerson(int personId);
 
 public List<Person> getPersons();
}

package cn.itcast.service.impl;

import java.util.List;

import javax.annotation.Resource;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Transactional
public class PersonServiceImpl implements IPersonService {

 private JdbcTemplate jdbcTemplete;

 // private DataSource datasource;
@Resource
 public void setDatasource(DataSource datasource) {
  this.jdbcTemplete = new JdbcTemplate(datasource);
 }

 public void delete(int personId) {
  this.jdbcTemplete
    .update("delete from  person where id=?",
      new Object[] { personId },
      new int[] { java.sql.Types.INTEGER });

 }

 public Person getPerson(int personId) {
  return (Person) this.jdbcTemplete.queryForObject(
    "select * from person where id=?", new Object[] { personId },
    new int[] { java.sql.Types.INTEGER }, new PersonRowMapper());

 }

 @SuppressWarnings("unchecked")
 public List<Person> getPersons() {

  return (List<Person>) this.jdbcTemplete.query("select * from person",
    new PersonRowMapper());

 }

 public void save(Person person) {
  System.out.println(person.getName());

  this.jdbcTemplete.update("insert into person(name) values(?)",
    new Object[] { person.getName() },
    new int[] { java.sql.Types.VARCHAR });

 }

 public void update(Person person) {
  this.jdbcTemplete.update("update person set name=? where id=?",
    new Object[] { person.getName(), person.getId() }, new int[] {
      java.sql.Types.VARCHAR, java.sql.Types.INTEGER });

 }

}

package cn.itcast.bean;

public class Person {

 private int id;
 
 private String name;

 public Person() {
  
 }

 public Person(String name) {
 
  this.name = name;
 }

 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getName() {
  return name;
 }

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

package cn.itcast.service.impl;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

import cn.itcast.bean.Person;

public class PersonRowMapper implements RowMapper {

 public Object mapRow(ResultSet rs, int index) throws SQLException {
  cn.itcast.bean.Person person=new Person(rs.getString("name"));
  person.setId(rs.getInt("id"));
  
  return person;
 }

}

<?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">
 <aop:aspectj-autoproxy proxy-target-class="true"/>

 
 <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="txManager"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource" />
 </bean>

 <tx:annotation-driven transaction-manager="txManager" />

 <bean id="personServiceImpl"
  class="cn.itcast.service.impl.PersonServiceImpl">
  <property name="datasource" ref="dataSource" />
 </bean>

</beans>

package junit.test;

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 TestSpringAndJdbc {

 public static IPersonService iPersonService;
 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
  ApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
  iPersonService=(IPersonService)ctx.getBean("personServiceImpl");
 }
 @Test
 public void TestSave(){
  for(int i=1;i<5;i++){
   iPersonService.save(new Person("传智博客"+i));
  }
  
 }
 @Test
 public void TestFindPerson(){
  
  iPersonService.getPerson(1);
  System.out.println(iPersonService.getPerson(1).getName());
 }
 
 @Test
 public void TestUpdate(){
  Person person=iPersonService.getPerson(1);//通过id取得person对象
  person.setName("张三");//设置名字
  iPersonService.update(person);//更新
 }
 
 @Test
 public void TestDelete(){
  Person person=iPersonService.getPerson(2);
  iPersonService.delete(person.getId());
 }

 @Test
 public void testFindAllPeron(){
  List<Person> list=iPersonService.getPersons();
  for(Person person:list){
   System.out.println(person.getId()+"  "+person.getName());
  }
 }
}

@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 interface IPersonService {

 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()方法