spring simpleJdbcTemplate 事务

 

 

 

这个是别人写的，觉得受用，所以存下来。。。。

 

Spring的JDBC框架能够承担资源管理和异常处理的工作,从而简化我们的JDBC代码,
让我们只需编写从数据库读写数据所必需的代 码。Spring把数据访问的样板代码隐藏到模板类之下,
结合Spring的事务管理,可以大大简化我们的代码.
Spring提供了 3个模板类：
JdbcTemplate：Spring里最基本的JDBC模板，利用JDBC和简单的索引参数查询提供对数据库的简单访问。
NamedParameterJdbcTemplate： 能够在执行查询时把值绑定到SQL里的命名参数，而不是使用索引参数。
SimpleJdbcTemplate：利用Java 5的特性，比如自动装箱、通用（generic）和可变参数列表来简化JDBC模板的使用。
具体使用哪个模板基本上取决于个人喜好。
使 用Spring的JdbcTemplate来实现简单的增删改查,首先建立测试数据表person
create table person(
id int not null primary key auto_increment,
name varchar(20) not null
)
导入依赖的jar包,由于测试中数据源使用的是dbcp数据源,需要以下jar包支持:
commons-logging.jar
commons-pool.jar
commons-dbcp.jar
同时还必须导入数据库驱动jar包:mysql-connector-java-3.1.8- bin.jar
建立实体bean
Person.java

 package  com.royzhou.jdbc;

 public   class  PersonBean {
     private   int  id;
     private  String name;

     public  PersonBean() {
     }

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

     public  PersonBean( int  id, String name) {
         this .id = id;
         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;
     }

     public  String toString() {
         return   this .id +  ":"  +  this .name;
     }
 }

package com.royzhou.jdbc;public class PersonBean {	private int id;	private String name;	public PersonBean() {	}		public PersonBean(String name) {		this.name = name;	}		public PersonBean(int id, String name) {		this.id = id;		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;	}		public String toString() {		return this.id + ":" + this.name;	}}

接口类:
PersonService.java

 package  com.royzhou.jdbc;

 import  java.util.List;

 public   interface  PersonService {

     public   void  addPerson(PersonBean person);

     public   void  updatePerson(PersonBean person);

     public   void  deletePerson( int  id);

     public  PersonBean queryPerson( int  id);

     public  List<PersonBean> queryPersons();
 }

package com.royzhou.jdbc;import java.util.List;public interface PersonService {		public void addPerson(PersonBean person);		public void updatePerson(PersonBean person);		public void deletePerson(int id);		public PersonBean queryPerson(int id);		public List<PersonBean> queryPersons();}

实现类:
PersonServiceImpl.java

 package  com.royzhou.jdbc;

 import  java.util.List;

 import  javax.sql.DataSource;
 import  java.sql.Types;

 import  org.springframework.jdbc.core.JdbcTemplate;

 public   class  PersonServiceImpl  implements  PersonService {

     private  JdbcTemplate jdbcTemplate;

     /**
      * 通 过Spring容器注入datasource
      * 实 例化JdbcTemplate,该类为主要操作数据库的类
      * @param ds
      */
     public   void  setDataSource(DataSource ds) {
         this .jdbcTemplate =  new  JdbcTemplate(ds);
     }

     public   void  addPerson(PersonBean person) {
         /**
          * 第 一个参数为执行sql
          * 第 二个参数为参数数据
          * 第 三个参数为参数类型
          */
         jdbcTemplate.update("insert into person values(null,?)" ,  new  Object[]{person.getName()},  new   int []{Types.VARCHAR});
     }

     public   void  deletePerson( int  id) {
         jdbcTemplate.update("delete from person where id = ?" ,  new  Object[]{id},  new   int []{Types.INTEGER});
     }

     public  PersonBean queryPerson( int  id) {
         /**
          * new PersonRowMapper() 是一个实现RowMapper接口的类,
          * 执 行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
          */
         PersonBean pb = (PersonBean) jdbcTemplate.queryForObject("select id,name from person where id = ?" ,  new  Object[]{id},  new  PersonRowMapper());
         return  pb;
     }

     @SuppressWarnings ( "unchecked" )
     public  List<PersonBean> queryPersons() {
         List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person" ,  new  PersonRowMapper());
         return  pbs;
     }

     public   void  updatePerson(PersonBean person) {
         jdbcTemplate.update("update person set name = ? where id = ?" ,  new  Object[]{person.getName(), person.getId()},  new   int []{Types.VARCHAR, Types.INTEGER});
     }
 }

package com.royzhou.jdbc;import java.util.List;import javax.sql.DataSource;import java.sql.Types;import org.springframework.jdbc.core.JdbcTemplate;public class PersonServiceImpl implements PersonService {	private JdbcTemplate jdbcTemplate;		/**	 * 通过Spring容器注入datasource	 * 实例化JdbcTemplate,该类为主要操作数据库的类	 * @param ds	 */	public void setDataSource(DataSource ds) {		this.jdbcTemplate = new JdbcTemplate(ds);	}		public void addPerson(PersonBean person) {		/**		 * 第一个参数为执行sql		 * 第二个参数为参数数据		 * 第三个参数为参数类型		 */		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});	}	public void deletePerson(int id) {		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});	}	public PersonBean queryPerson(int id) {		/**		 * new PersonRowMapper()是一个实现RowMapper接口的类,		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回		 */		PersonBean pb = (PersonBean) jdbcTemplate.queryForObject("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());		return pb;	}	@SuppressWarnings("unchecked")	public List<PersonBean> queryPersons() {		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());		return pbs;	}	public void updatePerson(PersonBean person) {		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});	}}

PersonRowMapper.java

 package  com.royzhou.jdbc;

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

 import  org.springframework.jdbc.core.RowMapper;

 public   class  PersonRowMapper  implements  RowMapper {
     //默认已经执行rs.next(),可以直接取数据
     public  Object mapRow(ResultSet rs,  int  index)  throws  SQLException {
         PersonBean pb = new  PersonBean(rs.getInt( "id" ),rs.getString( "name" ));
         return  pb;
     }
 }

package com.royzhou.jdbc;import java.sql.ResultSet;import java.sql.SQLException;import org.springframework.jdbc.core.RowMapper;public class PersonRowMapper implements RowMapper {	//默认已经执行rs.next(),可以直接取数据	public Object mapRow(ResultSet rs, int index) throws SQLException {		PersonBean pb = new PersonBean(rs.getInt("id"),rs.getString("name"));		return pb;	}}

我们需要在bean.xml中配置DataSource,并且将datasource注入到我们的业务类中

 <? xml   version = "1.0"   encoding = "UTF-8" ?>
 < 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"
        xsi:schemaLocation ="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

      < context:property-placeholder   location = "classpath:jdbc.properties" />
      < bean   id = "dataSource"   class = "org.apache.commons.dbcp.BasicDataSource"   destroy-method = "close" >
         < property   name = "driverClassName"   value = "${driverClassName}" />
         < property   name = "url"   value = "${url}" />
         < property   name = "username"   value = "${username}" />
         < property   name = "password"   value = "${password}" />
          <!-- 连接池启动时的初始值 -->
          < property   name = "initialSize"   value = "${initialSize}" />
          <!-- 连接池的最大值 -->
          < property   name = "maxActive"   value = "${maxActive}" />
          <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到 maxIdle为止 -->
          < property   name = "maxIdle"   value = "${maxIdle}" />
          <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申 请 -->
          < property   name = "minIdle"   value = "${minIdle}" />
      </ bean >

 </ 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"       xmlns:context="http://www.springframework.org/schema/context"        xmlns:aop="http://www.springframework.org/schema/aop"       xsi:schemaLocation="http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">	 <context:property-placeholder location="classpath:jdbc.properties"/>	 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">	    <property name="driverClassName" value="${driverClassName}"/>	    <property name="url" value="${url}"/>	    <property name="username" value="${username}"/>	    <property name="password" value="${password}"/>	     <!-- 连接池启动时的初始值 -->		 <property name="initialSize" value="${initialSize}"/>		 <!-- 连接池的最大值 -->		 <property name="maxActive" value="${maxActive}"/>		 <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->		 <property name="maxIdle" value="${maxIdle}"/>		 <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->		 <property name="minIdle" value="${minIdle}"/>	 </bean>	</beans>

jdbc.properties

 driverClassName=org.gjt.mm.mysql.Driver
 url=jdbc:mysql://localhost:3306/royzhou?useUnicode=true&characterEncoding=UTF-8
 username=root
 password=123456
 initialSize=1
 maxActive=500
 maxIdle=2
 minIdle=1

driverClassName=org.gjt.mm.mysql.Driverurl=jdbc:mysql://localhost:3306/royzhou?useUnicode=true&characterEncoding=UTF-8username=rootpassword=123456initialSize=1maxActive=500maxIdle=2minIdle=1

编 写我们的测试类:TestJdbcTemplate.java

 package  com.royzhou.jdbc;

 import  org.springframework.context.ApplicationContext;
 import  org.springframework.context.support.ClassPathXmlApplicationContext;

 public   class  TestJdbcTemplate {
     public   static   void  main(String[] args) {
         ApplicationContext ctx = new  ClassPathXmlApplicationContext( "bean.xml" );
         PersonService ps = (PersonService)ctx.getBean("personService" );
         ps.addPerson(new  PersonBean( "royzhou" ));
         PersonBean pb = ps.queryPerson(1 );
         System.out.println(pb);
         pb.setName("haha" );
         ps.updatePerson(pb);
         pb = ps.queryPerson(1 );
         System.out.println(pb);
         ps.deletePerson(1 );
         pb = ps.queryPerson(1 );
         System.out.println(pb);
     }
 }

package com.royzhou.jdbc;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestJdbcTemplate {	public static void main(String[] args) {		ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");		PersonService ps = (PersonService)ctx.getBean("personService");		ps.addPerson(new PersonBean("royzhou"));		PersonBean pb = ps.queryPerson(1);		System.out.println(pb);		pb.setName("haha");		ps.updatePerson(pb);		pb = ps.queryPerson(1);		System.out.println(pb);		ps.deletePerson(1);		pb = ps.queryPerson(1);		System.out.println(pb);	}}

上面代码先插入一条记录,然后修改,之后删除,运行之后出现异常,异常信息:
EmptyResultDataAccessException: Incorrect result size: expected 1, actual 0

难道Spring的 queryForObject在查找不到记录的时候会抛出异常,看了一下Spring的源代码 发现确实如此:

 public  Object queryForObject(String sql, Object[] args,  int [] argTypes, RowMapper rowMapper)  throws  DataAccessException {
         List results = (List) query(sql, args, argTypes, new  RowMapperResultSetExtractor(rowMapper,  1 ));
         return  DataAccessUtils.requiredUniqueResult(results);
     }

     public  Object queryForObject(String sql, Object[] args, RowMapper rowMapper)  throws  DataAccessException {
         List results = (List) query(sql, args, new  RowMapperResultSetExtractor(rowMapper,  1 ));
         return  DataAccessUtils.requiredUniqueResult(results);
     }

     public  Object queryForObject(String sql, RowMapper rowMapper)  throws  DataAccessException {
         List results = query(sql, rowMapper);
         return  DataAccessUtils.requiredUniqueResult(results);
     }

     public   static  Object requiredUniqueResult(Collection results)  throws  IncorrectResultSizeDataAccessException {
         int  size = (results !=  null  ? results.size() :  0 );
         if  (size ==  0 ) {
             throw   new  EmptyResultDataAccessException( 1 );  // 问题在这里
         }
         if  (!CollectionUtils.hasUniqueObject(results)) {
             throw   new  IncorrectResultSizeDataAccessException( 1 , size);
         }
         return  results.iterator().next();
     }

public Object queryForObject(String sql, Object[] args, int[] argTypes, RowMapper rowMapper) throws DataAccessException {		List results = (List) query(sql, args, argTypes, new RowMapperResultSetExtractor(rowMapper, 1));		return DataAccessUtils.requiredUniqueResult(results);	}	public Object queryForObject(String sql, Object[] args, RowMapper rowMapper) throws DataAccessException {		List results = (List) query(sql, args, new RowMapperResultSetExtractor(rowMapper, 1));		return DataAccessUtils.requiredUniqueResult(results);	}	public Object queryForObject(String sql, RowMapper rowMapper) throws DataAccessException {		List results = query(sql, rowMapper);		return DataAccessUtils.requiredUniqueResult(results);	}	public static Object requiredUniqueResult(Collection results) throws IncorrectResultSizeDataAccessException {		int size = (results != null ? results.size() : 0);		if (size == 0) {			throw new EmptyResultDataAccessException(1); // 问题在这里		}		if (!CollectionUtils.hasUniqueObject(results)) {		    throw new IncorrectResultSizeDataAccessException(1, size);		}		return results.iterator().next();	}

发现当查找不到记录 是,requiredUniqueResult方法做了判断,抛出异 常, 想不明白为什么Spring要在这里做这样的判断,为啥不返回null????

重新修改 PersonServiceImple类,把queryPerson方法改为使用列表查询的方式再去根据index取
PersonServiceImpl.java

 package  com.royzhou.jdbc;

 import  java.util.List;

 import  javax.sql.DataSource;
 import  java.sql.Types;

 import  org.springframework.jdbc.core.JdbcTemplate;

 public   class  PersonServiceImpl  implements  PersonService {

     private  JdbcTemplate jdbcTemplate;

     /**
      * 通 过Spring容器注入datasource
      * 实 例化JdbcTemplate,该类为主要操作数据库的类
      * @param ds
      */
     public   void  setDataSource(DataSource ds) {
         this .jdbcTemplate =  new  JdbcTemplate(ds);
     }

     public   void  addPerson(PersonBean person) {
         /**
          * 第 一个参数为执行sql
          * 第 二个参数为参数数据
          * 第 三个参数为参数类型
          */
         jdbcTemplate.update("insert into person values(null,?)" ,  new  Object[]{person.getName()},  new   int []{Types.VARCHAR});
     }

     public   void  deletePerson( int  id) {
         jdbcTemplate.update("delete from person where id = ?" ,  new  Object[]{id},  new   int []{Types.INTEGER});
     }

     @SuppressWarnings ( "unchecked" )
     public  PersonBean queryPerson( int  id) {
         /**
          * new PersonRowMapper() 是一个实现RowMapper接口的类,
          * 执 行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
          */
         List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?" ,  new  Object[]{id},  new  PersonRowMapper());
         PersonBean pb = null ;
         if (pbs.size()> 0 ) {
             pb = pbs.get(0 );
         }
         return  pb;
     }

     @SuppressWarnings ( "unchecked" )
     public  List<PersonBean> queryPersons() {
         List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person" ,  new  PersonRowMapper());
         return  pbs;
     }

     public   void  updatePerson(PersonBean person) {
         jdbcTemplate.update("update person set name = ? where id = ?" ,  new  Object[]{person.getName(), person.getId()},  new   int []{Types.VARCHAR, Types.INTEGER});
     }
 }

package com.royzhou.jdbc;import java.util.List;import javax.sql.DataSource;import java.sql.Types;import org.springframework.jdbc.core.JdbcTemplate;public class PersonServiceImpl implements PersonService {	private JdbcTemplate jdbcTemplate;		/**	 * 通过Spring容器注入datasource	 * 实例化JdbcTemplate,该类为主要操作数据库的类	 * @param ds	 */	public void setDataSource(DataSource ds) {		this.jdbcTemplate = new JdbcTemplate(ds);	}		public void addPerson(PersonBean person) {		/**		 * 第一个参数为执行sql		 * 第二个参数为参数数据		 * 第三个参数为参数类型		 */		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});	}	public void deletePerson(int id) {		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});	}	@SuppressWarnings("unchecked")	public PersonBean queryPerson(int id) {		/**		 * new PersonRowMapper()是一个实现RowMapper接口的类,		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回		 */		List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());		PersonBean pb = null;		if(pbs.size()>0) {			pb = pbs.get(0);		}		return pb;	}	@SuppressWarnings("unchecked")	public List<PersonBean> queryPersons() {		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());		return pbs;	}	public void updatePerson(PersonBean person) {		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});	}}

再次运行测试类,输出:
1:royzhou
1:haha
null

得到预期的结果.

从上面代码可以看出,使用Spring提供的JDBCTemplate类很大程度减少了我们的代码量,
比起以前我们写JDBC操作, 需要先获取Connection,然后是PreparedStatement,再到Result,
使用Spring JDBCTemplate写出来的代码看起来更加简洁,开发效率也比较快.

在数据库的操作中,事务是一个重要的概念,举个例子:

大概每个人都有转账的经历。当我们从A帐户向B帐户转100元后，银行的系统会从A帐户上扣除100而在B帐户上加100，这是一般的正常现 象。
但是一旦系统出错了怎么办呢，这里我们假设可能会发生两种情况：
（1）A帐户上少了100元，但是B帐户却没有多100元。
（2）B 帐户多了100元钱，但是A帐户上却没有被扣钱。
这种错误一旦发生就等于出了大事，那么再假如一下，你要转账的是1亿呢？
所以上面的 两种情况分别是你和银行不愿意看到的，因为谁都不希望出错。那么有没有什么方法保证一旦A帐户上没有被扣钱而B帐户上也没有被加钱；
或者A帐户 扣了100元而B帐户准确无误的加上100元呢。也就是说要么转账顺利的成功进行，要么不转账呢？可以，这就是数据库事务机制所要起到 的作用和做的事情。

Spring对事务的管理有丰富的支持,Spring提供了编程式配置事务和声明式配置事务:

声 明式事务有以下两种方式
一种是使用Annotation注解的方式(官方推荐)
一种是基于Xml的方式

采用任何 一种方式我们都需要在我们的bean.xml中添加事务支持:

Xml代 码 <embed type="application/x-shockwave-flash" width="14" height="15" src="http://www.iteye.com/javascripts/syntaxhighlighter/clipboard_new.swf" flashvars="clipboard=%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22UTF-8%22%3F%3E%0A%3Cbeans%20xmlns%3D%22http%3A%2F%2Fwww.springframework.org%2Fschema%2Fbeans%22%0A%09xmlns%3Axsi%3D%22http%3A%2F%2Fwww.w3.org%2F2001%2FXMLSchema-instance%22%0A%09xmlns%3Acontext%3D%22http%3A%2F%2Fwww.springframework.org%2Fschema%2Fcontext%22%0A%09xmlns%3Aaop%3D%22http%3A%2F%2Fwww.springframework.org%2Fschema%2Faop%22%0A%09xmlns%3Atx%3D%22http%3A%2F%2Fwww.springframework.org%2Fschema%2Ftx%22%0A%09xsi%3AschemaLocation%3D%22http%3A%2F%2Fwww.springframework.org%2Fschema%2Fbeans%0A%20%20%20%20%20%20%20%20%20%20%20http%3A%2F%2Fwww.springframework.org%2Fschema%2Fbeans%2Fspring-beans-2.5.xsd%0A%20%20%20%20%20%20%20%20%20%20%20http%3A%2F%2Fwww.springframework.org%2Fschema%2Fcontext%20http%3A%2F%2Fwww.springframework.org%2Fschema%2Fcontext%2Fspring-context-2.5.xsd%0A%20%20%20%20%20%20%20%20%20%20%20http%3A%2F%2Fwww.springframework.org%2Fschema%2Faop%20http%3A%2F%2Fwww.springframework.org%2Fschema%2Faop%2Fspring-aop-2.5.xsd%0A%20%20%20%20%20%20%20%20%20%20%20http%3A%2F%2Fwww.springframework.org%2Fschema%2Ftx%20http%3A%2F%2Fwww.springframework.org%2Fschema%2Ftx%2Fspring-tx-2.5.xsd%22%3E%0A%0A%09%3Ccontext%3Aproperty-placeholder%20location%3D%22classpath%3Ajdbc.properties%22%20%2F%3E%0A%09%3Cbean%20id%3D%22dataSource%22%0A%09%09class%3D%22org.apache.commons.dbcp.BasicDataSource%22%0A%09%09destroy-method%3D%22close%22%3E%0A%09%09%3Cproperty%20name%3D%22driverClassName%22%20value%3D%22%24%7BdriverClassName%7D%22%20%2F%3E%0A%09%09%3Cproperty%20name%3D%22url%22%20value%3D%22%24%7Burl%7D%22%20%2F%3E%0A%09%09%3Cproperty%20name%3D%22username%22%20value%3D%22%24%7Bu

分享到：

• 2010-02-04 09:13
• 浏览 951
• 评论(0)
• 分类:企业架构
• 相关推荐

评论

发表评论

您还没有登录,请您登录后再发表评论

lxpmsn123

• 浏览: 951 次
• 性别:
• 来自: 山东
• 

最近访客 更多访客>>

文章分类

• 全部博客 (1)

社区版块

• 我的资讯 (0)
• 我的论坛 (0)
• 我的问答 (0)

存档分类

• 2010-02 (1)
• 更多存档...

最新评论