程序博客网 > 德国瑞好地暖管 知乎

问我

来源：互联网 发布：德国瑞好地暖管 知乎 编辑：程序博客网 时间：2024/04/29 06:39

Spring提供了许多内置事务管理器实现，常用的有以下几种：  

  • DataSourceTransactionManager ：位于org.springframework.jdbc.datasource包中，数据源事务管理器，提供对单个javax.sql.DataSource事务管理，用于Spring JDBC抽象框架、iBATIS框架的事务管理；
  • HibernateTransactionManager ：位于org.springframework.orm.hibernate3或者hibernate4包中，提供对单个org.hibernate.SessionFactory事务支持，用于集成Hibernate框架时的事务管理；该事务管理器只支持Hibernate3+版本，且Spring3.0+版本只支持Hibernate 3.2+版本；
  • JtaTransactionManager ：位于org.springframework.transaction.jta包中，提供对分布式事务管理的支持，并将事务管理委托给Java EE应用服务器事务管理器；

Spring不仅提供这些事务管理器，还提供对如JMS事务管理的管理器  
两个不依赖于应用服务器的开源JTA事务实现组件 ：JOTM和Atomikos Transactions Essentials 
具体用法参考 http://jinnianshilongnian.iteye.com/blog/1439900 
这篇博客讲解了对于JDBC和JTA分别用PlatformTransactionManager实现和使用TransactionTemplate实现编程式事务管理：http://jinnianshilongnian.iteye.com/blog/1441271 
编程式实现事务  
Spring提供两种编程式事务支持：直接使用PlatformTransactionManager实现和使用TransactionTemplate模板类，用于支持逻辑事务管理。 
如果采用编程式事务推荐使用TransactionTemplate模板类。 

Spring框架支持事务管理的核心是事务管理器抽象，对于不同的数据访问框架（如Hibernate）通过实现策略接口PlatformTransactionManager，从而能支持各种数据访问框架的事务管理，PlatformTransactionManager接口定义如下：

[java] view plain copyprint?

  1. public   interface  PlatformTransactionManager {  
  2.         //返回一个已经激活的事务或创建一个新的事务   
  3.        TransactionStatus getTransaction(TransactionDefinition definition)   
  4.                                            throws  TransactionException;  
  5.         void  commit(TransactionStatus status) throws  TransactionException;  
  6.         void  rollback(TransactionStatus status) throws  TransactionException;  
  7. }   
public interface PlatformTransactionManager {       //返回一个已经激活的事务或创建一个新的事务       TransactionStatus getTransaction(TransactionDefinition definition)                                           throws TransactionException;       void commit(TransactionStatus status) throws TransactionException;       void rollback(TransactionStatus status) throws TransactionException;}

关于TransactionDefinition接口和TransactionStatus接口： 
http://jinnianshilongnian.iteye.com/blog/1439900 

Spring声明式事务  
在日常开发中，用的最多的就是声明式事务了，下面将介绍SpringJdbc的声明式事务的配置方法：

[html] view plain copyprint?

  1. < context:component-scan   base-package = "com.chou.spring.jdbc" />  
  2.   
  3. <!-- 配置数据源 -->       
  4. < bean   id ="dataSource"   class = "com.mchange.v2.c3p0.ComboPooledDataSource"   destroy-method= "close" >   
  5.      <!-- Connection Info -->   
  6.      < property   name= "driverClass"   value = "${db.driverClass}"   />   
  7.      < property   name= "jdbcUrl"   value ="${db.url}"   />   
  8.      < property   name= "user"   value ="${db.username}"   />   
  9.      < property   name= "password"   value ="${db.password}"   />   
  10.           
  11.      <!-- Connection Pooling Info -->   
  12.      < property   name= "initialPoolSize"   value = "1"   />   
  13.      < property   name= "minPoolSize"   value = "1"   />   
  14.      < property   name= "maxPoolSize"   value = "15"   />   
  15.      < property   name= "maxIdleTime"   value = "1800"   />   
  16.      < property   name= "maxStatements"   value = "0"   />   
  17. </ bean >   
  18.       
  19. < bean   id ="jdbcTemplateDao"   class = "com.chou.spring.jdbc.dao.JdbcTemplateDao"   >   
  20.      < property   name= "dataSource"   ref ="dataSource"   />   
  21. </ bean >   
  22.       
  23. <!-- JDBC事务管理器 -->   
  24. < bean   id ="jdbctTxManager"   class = "org.springframework.jdbc.datasource.DataSourceTransactionManager" >  
  25.      < property   name= "dataSource"   ref ="dataSource"   />   
  26. </ bean >   
  27.       
  28. < tx:advice   id = "txAdvice"   transaction-manager = "jdbctTxManager" >   
  29.      < tx:attributes >   
  30.          < tx:method   name= "domain*" />   
  31.      </ tx:attributes >   
  32. </ tx:advice >   
  33.       
  34. < aop:config   proxy-target-class= "true" >   
  35.      < aop:advisor   advice-ref= "txAdvice"    
  36.      pointcut = "execution(* com.chou.spring.jdbc.service.JdbcTemplateService.*(..))"/>   
  37. </ aop:config >    
<context:component-scan base-package="com.chou.spring.jdbc"/><!-- 配置数据源 -->    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  <!-- Connection Info -->  <property name="driverClass" value="${db.driverClass}" />  <property name="jdbcUrl" value="${db.url}" />  <property name="user" value="${db.username}" />  <property name="password" value="${db.password}" />      <!-- Connection Pooling Info -->  <property name="initialPoolSize" value="1" />  <property name="minPoolSize" value="1" />  <property name="maxPoolSize" value="15" />  <property name="maxIdleTime" value="1800" />  <property name="maxStatements" value="0" /></bean>  <bean id="jdbcTemplateDao" class="com.chou.spring.jdbc.dao.JdbcTemplateDao" >  <property name="dataSource" ref="dataSource" /></bean>  <!-- JDBC事务管理器 --><bean id="jdbctTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  <property name="dataSource" ref="dataSource" /></bean>  <tx:advice id="txAdvice" transaction-manager="jdbctTxManager">  <tx:attributes>    <tx:method name="domain*"/>  </tx:attributes></tx:advice>  <aop:config proxy-target-class="true">  <aop:advisor advice-ref="txAdvice"   pointcut="execution(* com.chou.spring.jdbc.service.JdbcTemplateService.*(..))"/></aop:config>

[java] view plain copyprint?

  1. public   class  JdbcTemplateDao extends  JdbcDaoSupport{  
  2.   
  3.      public   void  save() {  
  4.         String insertSql =  "insert into tab_item values(?,?,?)";  
  5.         Assert.isTrue(getJdbcTemplate().update(insertSql,  new Object[]{ 6 ,  "HP" , "PT540" }) ==  1 ,  "插入失败");  
  6.     }  
  7.       
  8.      public   void  delete() {  
  9.         String deleteSql =  "delete tab_item where id = ?";  
  10.         Assert.isTrue(getJdbcTemplate().update(deleteSql,  new Object[]{ 6 }) ==  1 , "删除失败" );  
  11.     }  
  12.       
  13.      public   void  update() {  
  14.         String updateSql =  "update tab_item set itemno = ?, itemname = ? where id = ?";  
  15.         Assert.isTrue(getJdbcTemplate().update(updateSql,  new Object[]{ "HP" ,  "PT555" ,  6 }) ==  1 ,  "修改失败" );  
  16.     }  
  17. }   
public class JdbcTemplateDao extends JdbcDaoSupport{  public void save() {    String insertSql = "insert into tab_item values(?,?,?)";    Assert.isTrue(getJdbcTemplate().update(insertSql, new Object[]{6, "HP", "PT540"}) == 1, "插入失败");  }    public void delete() {    String deleteSql = "delete tab_item where id = ?";    Assert.isTrue(getJdbcTemplate().update(deleteSql, new Object[]{6}) == 1, "删除失败");  }    public void update() {    String updateSql = "update tab_item set itemno = ?, itemname = ? where id = ?";    Assert.isTrue(getJdbcTemplate().update(updateSql, new Object[]{"HP", "PT555", 6}) == 1, "修改失败");  }}

[java] view plain copyprint?

  1. /**  
  2.  *   
  3.  * @author Chou  
  4.  * @since 2012-9-9  
  5.  * 把事务定义在Service层是为了避免报错：  
  6.  * 一般很多人在final DAO里加入事务那是有警告的，  
  7.  * 而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，  
  8.  * 通过修改其字节码生成子类并继承你写的类,然后在你的基础上加事物管理,  
  9.  * 而JdbcDaoSupport中的setDataSource是final的他继承不了  
  10.  * 当然你可以无视它，也没有问题。  
  11.  */   
  12. @Service   
  13. public   class  JdbcTemplateService {  
  14.       
  15.      @Autowired   
  16.      private  JdbcTemplateDao jdbcTemplateDao;  
  17.       
  18.      public   void  domain(){  
  19.         jdbcTemplateDao.save();  
  20.          int  i =  2 /0 ; //这里出错了，事务就会回滚，之前的save就无效了   
  21.         jdbcTemplateDao.update();  
  22.         jdbcTemplateDao.delete();  
  23.     }  
  24. }  
  25.   
  26. //main方法   
  27. String[] configLocations =  new  String[] { "applicationContext.xml" };    
  28. ApplicationContext ctx =  new  ClassPathXmlApplicationContext(configLocations);  
  29. JdbcTemplateService j = ctx.getBean(JdbcTemplateService. class);  
  30. j.domain();   
/** *  * @author Chou * @since 2012-9-9 * 把事务定义在Service层是为了避免报错： * All calls to this method via a proxy will be routed directly to the proxy. * 这是是事务转移问题，你如果在控制层加入事务就不会有提示了，也没有警告， * 一般很多人在final DAO里加入事务那是有警告的， * 如果配置文件定义了AOP获取代理对象是proxy-target-class="true"即采用CGLIB方式 * 而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来， * 通过修改其字节码生成子类并继承你写的类,然后在你的基础上加事物管理, * 而JdbcDaoSupport中的setDataSource是final的他继承不了 * 当然你可以无视它，也没有问题。 */@Servicepublic class JdbcTemplateService {    @Autowired  private JdbcTemplateDao jdbcTemplateDao;    public void domain(){    jdbcTemplateDao.save();    int i = 2/0;//这里出错了，事务就会回滚，之前的save就无效了    jdbcTemplateDao.update();    jdbcTemplateDao.delete();  }}//main方法String[] configLocations = new String[] {"applicationContext.xml"};  ApplicationContext ctx = new ClassPathXmlApplicationContext(configLocations);JdbcTemplateService j = ctx.getBean(JdbcTemplateService.class);j.domain();


<tx:advice/>配置详解  

[html] view plain copyprint?

  1. < tx:advice   id = "……"   transaction-manager = "……" >   
  2. < tx:attributes >   
  3.          < tx:method   name= "*"   
  4.                             propagation = "REQUIRED"   
  5.                             isolation = "DEFAULT"   
  6.                             timeout = "-1"  
  7.                             read-only = "true"   
  8.                             no-rollback-for =""    
  9.                             rollback-for = "java.lang.Exception" />   
  10.      </ tx:attributes >   
  11. </ tx:advice >   
  12.   
  13. <!-- 最常用的配置 -->   
  14. < tx:advice   id = "txAdvice"   transaction-manager = "txManager" >   
  15. < tx:attributes >   
  16.             < tx:method   name = "save*"   propagation= "REQUIRED"   />   
  17.             < tx:method   name = "add*"   propagation= "REQUIRED"   />   
  18.             < tx:method   name = "create*"   propagation= "REQUIRED"   />   
  19.             < tx:method   name = "insert*"   propagation= "REQUIRED"   />   
  20.             < tx:method   name = "update*"   propagation= "REQUIRED"   />   
  21.             < tx:method   name = "merge*"   propagation= "REQUIRED"   />   
  22.             < tx:method   name = "del*"   propagation= "REQUIRED"   />   
  23.             < tx:method   name = "remove*"   propagation= "REQUIRED"   />   
  24.             < tx:method   name = "put*"   propagation= "REQUIRED"   />   
  25.             < tx:method   name = "get*"   propagation= "SUPPORTS"   read-only = "true"   />   
  26.             < tx:method   name = "count*"   propagation= "SUPPORTS"   read-only = "true"   />   
  27.             < tx:method   name = "find*"   propagation= "SUPPORTS"   read-only = "true"   />   
  28.             < tx:method   name = "list*"   propagation= "SUPPORTS"   read-only = "true"   />   
  29.             < tx:method   name = "*"   propagation= "SUPPORTS"   read-only = "true"   />   
  30.             < tx:method   name = "batchSaveOrUpdate"   propagation = "REQUIRES_NEW"   />   
  31.         </ tx:attributes >   
  32. </ tx:advice >   
  33. < aop:config >   
  34.         < aop:pointcut   id= "txPointcut"   expression = "execution(* cn.javass..service.*.*(..))"   />   
  35.         < aop:advisor   advice-ref= "txAdvice"   pointcut-ref = "txPointcut"   />   
  36. </ aop:config >    
<tx:advice id="……" transaction-manager="……"><tx:attributes>        <tx:method name="*"                           propagation="REQUIRED"                           isolation="DEFAULT"                           timeout="-1"                           read-only="true"                           no-rollback-for=""                            rollback-for="java.lang.Exception"/>    </tx:attributes></tx:advice><!-- 最常用的配置 --><tx:advice id="txAdvice" transaction-manager="txManager"><tx:attributes>           <tx:method name="save*" propagation="REQUIRED" />           <tx:method name="add*" propagation="REQUIRED" />           <tx:method name="create*" propagation="REQUIRED" />           <tx:method name="insert*" propagation="REQUIRED" />           <tx:method name="update*" propagation="REQUIRED" />           <tx:method name="merge*" propagation="REQUIRED" />           <tx:method name="del*" propagation="REQUIRED" />           <tx:method name="remove*" propagation="REQUIRED" />           <tx:method name="put*" propagation="REQUIRED" />           <tx:method name="get*" propagation="SUPPORTS" read-only="true" />           <tx:method name="count*" propagation="SUPPORTS" read-only="true" />           <tx:method name="find*" propagation="SUPPORTS" read-only="true" />           <tx:method name="list*" propagation="SUPPORTS" read-only="true" />           <tx:method name="*" propagation="SUPPORTS" read-only="true" />           <tx:method name="batchSaveOrUpdate" propagation="REQUIRES_NEW" />       </tx:attributes></tx:advice><aop:config>       <aop:pointcut id="txPointcut" expression="execution(* cn.javass..service.*.*(..))" />       <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" /></aop:config>


XML形式的事务配置<tx:method >的属性详解  

属性
类型
默认值
说明
propagationPropagation枚举REQUIRED事务传播属性isolationisolation枚举DEFAULT(所用数据库默认级别)事务隔离级别readOnlybooleanfalse是否才用优化的只读事务timeoutint-1超时(秒)rollbackForClass[]{}需要回滚的异常类rollbackForClassNameString[]{}需要回滚的异常类名noRollbackForClass[]{}不需要回滚的异常类noRollbackForClassNameString[]{}不需要回滚的异常类名


readOnly  
事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务。如果值为true就会告诉Spring我这个方法里面没有insert或者update，你只需要提供只读的数据库Connection就行了，这种执行效率会比read-write的Connection高，所以这是一个最优化提示 。在一些情况下，一些事务策略能够起到显著的最优化效果，例如在使用Object/Relational映射工具（如：Hibernate或TopLink）时避免dirty checking（试图“刷新”）。 
timeout  
在属性中还有定义“timeout”值的选项，指定事务超时为几秒。一般不会使用这个属性。在JTA中，这将被简单地传递到J2EE服务器的事务协调程序，并据此得到相应的解释。 
Isolation Level(事务隔离等级)的5个枚举值  
为什么事务要有Isolation Level这个属性？先回顾下数据库事务的知识： 
第一类丢失更新(lost update) ：在完全未隔离事务的情况下，两个事物更新同一条数据资源，某一事物异常终止，回滚造成第一个完成的更新也同时丢失。 
第二类丢失更新(second lost updates) ：是不可重复读的特殊情况，如果两个事务都读取同一行，然后两个都进行写操作，并提交，第一个事务所做的改变就会丢失。 
脏读(dirty read) ：如果第二个事务查询到第一个事务还未提交的更新数据，形成脏读。因为第一个事务你还不知道是否提交，所以数据不一定是正确的。 
虚读(phantom read) ：一个事务执行两次查询，第二次结果集包含第一次中没有或者某些行已被删除，造成两次结果不一致，只是另一个事务在这两次查询中间插入或者删除了数据造成的。 
不可重复读(unrepeated read) ：一个事务两次读取同一行数据，结果得到不同状态结果，如中间正好另一个事务更新了该数据，两次结果相异，不可信任。 
具体关于事务机制可以看我以前的博客： http://zhou137520.iteye.com/admin/blogs/1638574 
当遇到以上这些情况时我们可以设置isolation下面这些枚举值： 
DEFAULT ：采用数据库默认隔离级别 
SERIALIZABLE ：最严格的级别，事务串行执行，资源消耗最大； 
REPEATABLE_READ ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。 
READ_COMMITTED :大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。 
READ_UNCOMMITTED ：保证了读取过程中不会读取到非法数据。隔离级别在于处理多事务的并发问题。 
关于propagation属性的7个传播行为  
REQUIRED ：指定当前方法必需在事务环境中运行，如果当前有事务环境就加入当前正在执行的事务环境，如果当前没有事务，就新建一个事务。这是默认值。 
SUPPORTS ：指定当前方法加入当前事务环境，如果当前没有事务，就以非事务方式执行。 
MANDATORY ：指定当前方法必须加入当前事务环境，如果当前没有事务，就抛出异常。 
REQUIRES_NEW ：指定当前方法总是会为自己发起一个新的事务，如果发现当前方法已运行在一个事务中,则原有事务被挂起,我自己创建一个属于自己的事务,直我自己这个方法commit结束,原先的事务才会恢复执行。 
NOT_SUPPORTED ：指定当前方法以非事务方式执行操作，如果当前存在事务，就把当前事务挂起，等我以非事务的状态运行完，再继续原来的事务。 
NEVER ：指定当前方法绝对不能在事务范围内执行，如果方法在某个事务范围内执行，容器就抛异常，只有没关联到事务，才正常执行。 
NESTED ：指定当前方法执行时，如果已经有一个事务存在,则运行在这个嵌套的事务中.如果当前环境没有运行的事务，就新建一个事务，并与父事务相互独立，这个事务拥有多个可以回滚的保证点。就是指我自己内部事务回滚不会对外部事务造成影响，只对DataSourceTransactionManager事务管理器起效。 
注解形式@Transactional实现事务管理  
注意@Transactional只能被应用到public方法上 ，对于其它非public的方法，如果标记了@Transactional也不会报错,但方法没有事务功能。 
默认情况下，一个有事务的方法，遇到RuntiomeException时会回滚 。遇到受检查的异常是不会回滚的，要想所有异常都回滚，要加上属性rollbackFor={Exception.class}

[html] view plain copyprint?

  1. <!-- 事务管理器配置 -->   
  2. < bean   id ="txManager"       class = "org.springframework.orm.hibernate3.HibernateTransactionManager" >  
  3.      < property   name= "sessionFactory"   ref = "sessionFactory"   />   
  4. </ bean >   
  5.   
  6. <!-- 使用annotation定义事务 -->   
  7. < tx:annotation-driven   transaction-manager= "txManager"   proxy-target-class= "true"   />   
<!-- 事务管理器配置 --><bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  <property name="sessionFactory" ref="sessionFactory" /></bean><!-- 使用annotation定义事务 --><tx:annotation-driven transaction-manager="txManager" proxy-target-class="true" />


transaction-manager ：指定事务管理器名字，默认为transactionManager，当使用其他名字时需要明确指定； 
proxy-target-class ：默认false表示使用JDK代理，如果为true将使用CGLIB代理 
order ：定义事务通知顺序，默认Ordered.LOWEST_PRECEDENCE，表示将顺序决定权交给AOP来处理。 
建议只在实现类或实现类的方法上使用@Transactional ，而不要在接口上使用，这是因为如果使用JDK代理机制是没问题，因为其使用基于接口的代理；而使用使用CGLIB代理机制时就会遇到问题，因为其使用基于类的代理而不是接口，这是因为接口上的@Transactional注解是“不能继承的”。 
http://jinnianshilongnian.iteye.com/blog/1508018这篇博客讲解了基于JDK动态代理和CGLIB动态代理的实现Spring注解管理事务（@Trasactional）到底有什么区别。  

[java] view plain copyprint?

  1. @Transactional //放在这里表示所有方法都加入事务管理   
  2. public   class  AnnotationUserServiceImpl implements  IUserService {  
  3.      private  IUserDao userDao;  
  4.      private  IAddressService addressService;  
  5.       
  6.      @Transactional (propagation=Propagation.REQUIRED, isolation=Isolation.READ_COMMITTED)  
  7.      public   void  save(UserModel user) {  
  8.         userDao.save(user);  
  9.         user.getAddress().setUserId(user.getId());  
  10.         addressService.save(user.getAddress());  
  11.     }  
  12.   
  13.      @Transactional (propagation=Propagation.REQUIRED, readOnly=true ,  
  14.                    isolation=Isolation.READ_COMMITTED)  
  15.      public   int  countAll() {  
  16.          return  userDao.countAll();  
  17.     }  
  18.      //setter...   
  19. }   
@Transactional//放在这里表示所有方法都加入事务管理public class AnnotationUserServiceImpl implements IUserService {    private IUserDao userDao;    private IAddressService addressService;        @Transactional(propagation=Propagation.REQUIRED, isolation=Isolation.READ_COMMITTED)    public void save(UserModel user) {        userDao.save(user);        user.getAddress().setUserId(user.getId());        addressService.save(user.getAddress());    }    @Transactional(propagation=Propagation.REQUIRED, readOnly=true,                   isolation=Isolation.READ_COMMITTED)    public int countAll() {        return userDao.countAll();    }    //setter...}
总结

        编程式事务是不推荐的，即使有很少事务操作，Spring发展到现在，没有理由使用编程式事务，只有在为了深入理解Spring事务管理才需要学习编程式事务使用。 
       推荐使用声明式事务，而且强烈推荐使用<tx:tags>方式的声明式事务，因为其是无侵入代码的，可以配置模板化的事务属性并运用到多个项目中。 
       而@Transaction注解事务，不过如果一个项目模块太多，service方法太多导致每个方法都要手动去加注解，是不是很麻烦，也容易出错。如果一个项目结构清晰，分层明确，那么标签形式的配置将是最直观和方便的办法。 
       总之，能保证项目正常工作的事务配置就是最好的。
0 0
德国瑞好地暖管 知乎 德国瑞好地暖管 知乎
原创粉丝点击
热门IT博客
python和java哪个好python和java哪个好
everyonepiano软件下载everyonepiano软件下载
cctv7观军事知天下视频
知乎 win10 杀毒软件
mac怎么玩最终幻想
android 数据流量
制作书籍的软件
python字符串转数字
微软软件销售好做吗
精简版windows
apache linux ab 工具
网络女歌手三个字名字
架空网络地板
被广电禁播的网络剧
淘宝水果属于什么类目
在哪里可以买淘宝号
炒黄金白银软件
手机淘宝店铺在哪里
react.js .百度百科
下周重要经济数据
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 淘宝客地址 淘宝客 团购 淘宝客新手入门教程 淘宝客新手入门教程2018 淘宝客怎么拿到商家的优惠券 淘宝客网站怎么推广 怎么加入淘宝客推广 淘宝客是什么意思啊 淘宝课 淘宝现在好做吗 淘宝客源码程序 淘客推广联盟 商品怎么加入淘宝客 如何成为一名淘宝客 如何成为一个淘宝客 淘宝直通车和淘宝客 淘宝旅游 我的淘宝卖家 网购别就知道淘宝 有淘宝账号就能贷款 有淘宝账号就可以贷款 手机淘宝打开就闪退 淘宝货没到就确认收货怎么办 淘宝刚买的东西就降价了 淘宝是什么 淘宝是谁的 淘宝 店铺 淘宝专卖店 淘宝新手开店教程 淘宝开店铺要钱吗 开淘宝店铺卖什么好 淘宝开网店卖什么好 好的淘宝店铺 淘宝优质店铺 三界淘宝店txt下载 三界淘宝店txt 仙界淘宝店 万界淘宝店txt下载 万界淘宝店苏尘 淘宝旗舰店都是正品吗 天庭淘宝店紫煌

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里