Struts2.3+Spring3.2的整合

最新推荐文章于 2020-10-21 00:30:15 发布
最新推荐文章于 2020-10-21 00:30:15 发布
阅读量1.5k 收藏
点赞数
分类专栏： J2EE

Struts2.3+Spring3.2的整合

2012-08-20 19:48

       这两天都是一直在鼓捣Struts2.3如何整合Spring3.2以及dao层到底选用什么以及如何整合。下面就把自己这两天的一些小成果分享出来也以便自己以后在实际项目中快速搭建。

首先是Struts2.3整合Spring3.2

1、新建一个web工程（这个就不说了）

2、添加Struts2.3

把Struts开发所需的jar复制到工程的lib文件中。开发struts必须包如下：

 

3、创建action类

声明：整个示例只有一个简单的用户登录。

本例中的action类名为 LoginAction，该类中的代码如下：

 

[java]  view plain copy
  1. package com.riyun.action;  
  2.   
  3. import com.opensymphony.xwork2.ActionSupport;  
  4. public class LoginAction extends ActionSupport{  
  5.       
  6.     private static final long serialVersionUID = 1L;  
  7.       
  8.           
  9.     private String userName;  
  10.     private String passWord;  
  11.       
  12.     public String getUserName() {  
  13.         return userName;  
  14.     }  
  15.     public String getPassWord() {  
  16.         return passWord;  
  17.     }  
  18.     public void setUserName(String userName) {  
  19.         this.userName = userName;  
  20.     }  
  21.     public void setPassWord(String passWord) {  
  22.         this.passWord = passWord;  
  23.     }  
  24.       
  25.       
  26.     public String   execute() throws Exception{  
  27.         if(userName.equals("riyun")&&passWord.equals("123")){  
  28.                return SUCCESS;  
  29.           }else{  
  30.                return ERROR;  
  31.             }  
[java]  view plain copy
  1. }  


至于该类为什么继承ActionSupport，相信网上讲述Struts1.X与Struts2.X的文章已经很多了，这里就不罗嗦了。

4、修改项目中的index.jsp代码，修改后的index.jsp代码如下：

 

[html]  view plain copy
  1. <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>  
  2. <%@taglib prefix="s" uri="/struts-tags" %>  
  3. <%  
  4. String path = request.getContextPath();  
  5. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";  
  6. %>  
  7.   
  8. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
  9. <html>  
  10.   <head>  
  11.     <base href="<%=basePath%>">  
  12.       
  13.     <title>My JSP 'index.jsp' starting page</title>  
  14.     <meta http-equiv="pragma" content="no-cache">  
  15.     <meta http-equiv="cache-control" content="no-cache">  
  16.     <meta http-equiv="expires" content="0">      
  17.     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">  
  18.     <meta http-equiv="description" content="This is my page">  
  19.     <!-- 
  20.     <link rel="stylesheet" type="text/css" href="styles.css"> 
  21.     -->  
  22.   </head>  
  23.     
  24.   <body>  
  25.     <s:form action="login">  
  26.         <s:textfield name="userName" label="用户名" key="user"></s:textfield>  
  27.         <s:password  name="passWord" label="密码" key="password"></s:password>  
  28.         <s:submit key="login" value="提交"></s:submit>  
  29.     </s:form>  
  30.   </body>  
  31. </html>  


[html]  view plain copy
  1.   

新建两个success.jsp、error.jsp页面。后面action处理结果跳转有用，如果登陆成功则跳转到success.jsp，反之则跳转到error.jsp！

5、 新建一个以struts.xml为名的xml文件

  文件中的代码如下：

 

[html]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2.   <!DOCTYPE struts PUBLIC  
  3.       "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
  4.       "http://struts.apache.org/dtds/struts-2.0.dtd">  
  5.   <struts>  
  6.      <!-- struts的action配置文件 -->  
  7.        
  8.      <!-- 所有的action都应该放在对应的package下 -->  
  9.      <package name="riyun" extends="struts-default">  
  10.         <action name="login" class="com.riyun.action.LoginAction">  
  11.             <!-- 定义逻辑视图和物理资源之间的映射 -->  
  12.             <result name="success">/success.jsp</result>  
  13.             <result name="error">/error.jsp</result>  
  14.         </action>  
  15.      </package>  
  16.   </struts>  


6、在web.xml中添加struts拦截器。

    Web.xml的代码如下：

 

[html]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee    
  4.   http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
  5.     
  6.     <!-- 定义struts2的核心filter -->  
  7.     <filter>  
  8.         <filter-name>struts2</filter-name>  
  9.         <filter-class>  
  10.             org.apache.struts2.dispatcher.FilterDispatcher              
  11.         </filter-class>  
  12.     </filter>  
  13.     <!-- 让struts定义的核心filter拦截所有请求 -->  
  14.     <filter-mapping>  
  15.         <filter-name>struts2</filter-name>  
  16.         <url-pattern>/*</url-pattern>  
  17.     </filter-mapping>  
  18.       
  19.     <!-- 项目欢迎界面 -->  
  20.     <welcome-file-list>  
  21.         <welcome-file>index.jsp</welcome-file>  
  22.     </welcome-file-list>  
  23.       
  24.  </web-app>  


至此Struts2.3整合成功，接下来继续整合Spring3.2。

7、导入所需spring的jar包如下;

对于Spring的jar包没有研究过，所以我这里把spring所有的jar都复制到了lib目录中去了。另外还需要导入struts2-spring-plugin-2.3.4.1.jar包。

8、在web-inf目录中新建一个applicationContext.xml为名的xml文件（该文件与web.xml是在同一级目录）

该applicationContext.xml文件中的代码如下：

 

[html]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"   
  3. "http://www.springframework.org/dtd/spring-beans.dtd">  
  4. <beans>  
  5.     <bean id="userDao" class="com.riyun.daoImpl.UserDaoImpl">  </bean>    
  6.     <bean id="login" class="com.riyun.action.LoginAction">    
  7.         <property name="userDao" ref="userDao" />    
  8.     </bean>    
  9. </beans>  


 

9、修改struts.xml文件，修改后的struts.xml文件中的代码如下

[html]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2.   <!DOCTYPE struts PUBLIC  
  3.       "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
  4.       "http://struts.apache.org/dtds/struts-2.0.dtd">  
  5.   <struts>  
  6.      <!-- struts的action配置文件 -->  
  7.      <!-- 将action托管给spring -->  
  8.      <constant name="struts.objectFactory" value="spring"></constant>    
  9.      <!-- 所有的action都应该放在对应的package下 -->  
  10.      <package name="riyun" extends="struts-default">  
  11.         <action name="login" class="com.riyun.action.LoginAction">  
  12.             <!-- 定义逻辑视图和物理资源之间的映射 -->  
  13.             <result name="success">/success.jsp</result>  
  14.             <result name="error">/error.jsp</result>  
  15.         </action>  
  16.      </package>  
  17.   </struts>  


 

10、修改web.xml文件，修改后的web.xml文件中的代码如下：

 

[html]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee    
  4.   http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
  5.     
  6.     <!-- 初始化 -->  
  7.      <context-param>  
  8.          <param-name>contextConfigLocation</param-name>  
  9.          <!-- 如果有多个文件，在文件之间用英文逗号隔开 -->  
  10.          <!-- <param-value>/WEB-INF/applicationContext.xml,/WEB-INF/applicationContext-db.xml  
  11.          </param-value> -->  
  12.          <param-value>/WEB-INF/applicationContext.xml</param-value>  
  13.      </context-param>  
  14.     <!-- 监听器 -->  
  15.     <!-- 配置spring监听器 -->    
  16.     <listener>    
  17.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>    
  18.     </listener>    
  19.      <!-- 定义struts2的核心filter -->  
  20.     <filter>  
  21.         <filter-name>struts2</filter-name>  
  22.         <filter-class>  
  23.             org.apache.struts2.dispatcher.FilterDispatcher              
  24.         </filter-class>  
  25.     </filter>  
  26.     <!-- 让struts定义的核心filter拦截所有请求 -->  
  27.     <filter-mapping>  
  28.         <filter-name>struts2</filter-name>  
  29.         <url-pattern>/*</url-pattern>  
  30.     </filter-mapping>  
  31.       
  32.     <!-- 项目欢迎界面 -->  
  33.     <welcome-file-list>  
  34.         <welcome-file>index.jsp</welcome-file>  
  35.     </welcome-file-list>  
  36.       
  37.  </web-app>  


 ok，到此为此Struts2.3整合Spring3.2就可以了。那实际项目中不可能不跟数据库打交道。常见的dao层用的是hibernate。但其实还有一些跟hibernate功能相似而且相对于hibernate来说配置更简单的dao层应用可以供我们选择。这里我就选用了JDBC。利用JDBC作为dao层的应用，每个dao层都要继承JDBCSupport类。

11、添加dao层，添加UserDao接口、添加UserDaoImpl实现接口类

UserDao接口的代码如下：

[java]  view plain copy
  1. package com.riyun.dao;  
  2.   
  3. public interface UserDao {  
  4.       
  5.     /*用户登录 
  6.      * pram:userName,passWord 
  7.      * return:boolean 
  8.      */  
  9.     public boolean login(String userName,String passWord);  
  10.   
  11. }  


UserDaoImpl实现接口类的代码如下：

 

[java]  view plain copy
  1. package com.riyun.daoImpl;  
  2.   
  3. import java.util.Map;  
  4.   
  5.   
  6. import org.springframework.dao.EmptyResultDataAccessException;  
  7. import org.springframework.jdbc.core.support.JdbcDaoSupport;  
  8.   
  9. import com.riyun.dao.UserDao;  
  10.   
  11. public class UserDaoImpl extends JdbcDaoSupport implements UserDao{  
  12.   
  13.     //用户登录  
  14.     public boolean login(String userName, String passWord) {  
  15.         // TODO Auto-generated method stub  
  16.         String sql="select job,ename from emp where ename=?";  
  17.         Map map=this.getJdbcTemplate().queryForMap(sql, new Object[] {userName});  
  18.         try{  
  19.             String pass=(String) map.get("job");  
  20.             if(passWord.equals(pass)){            
  21.                 return true;  
  22.             }else{  
  23.                 return false;  
  24.             }  
  25.         }catch(EmptyResultDataAccessException e){  
  26.             e.printStackTrace();  
  27.             return false;  
  28.         }         
  29.     }  
  30. }  

12、修改LoginAction类的代码，修改后的代码如下：


 

[java]  view plain copy
  1. package com.riyun.action;  
  2.   
  3. import org.apache.log4j.Logger;  
  4.   
  5. import com.opensymphony.xwork2.ActionSupport;  
  6. import com.riyun.dao.UserDao;  
  7.   
  8. public class LoginAction extends ActionSupport{  
  9.       
  10.     private static final long serialVersionUID = 1L;  
  11.       
  12.           
  13.     private UserDao userDao;  
  14.     private String userName;  
  15.     private String passWord;  
  16.       
  17.     public UserDao getUserDao() {  
  18.         return userDao;  
  19.     }  
  20.     public void setUserDao(UserDao userDao) {  
  21.         this.userDao = userDao;  
  22.     }  
  23.   
  24.     public String getUserName() {  
  25.         return userName;  
  26.     }  
  27.     public String getPassWord() {  
  28.         return passWord;  
  29.     }  
  30.     public void setUserName(String userName) {  
  31.         this.userName = userName;  
  32.     }  
  33.     public void setPassWord(String passWord) {  
  34.         this.passWord = passWord;  
  35.     }  
  36.       
  37.       
  38.     public String   execute() throws Exception{  
  39.         if(userDao.login(userName, passWord)){  
  40.             return SUCCESS;  
  41.         }else{  
  42.             return ERROR;  
  43.         }  
  44.     }  
  45.       
  46. }  

13、修改applicationContext.xml文件，修改后的文件代码如下：

[html]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"   
  3. "http://www.springframework.org/dtd/spring-beans.dtd">  
  4. <beans>  
  5.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  destroy-method="close" dependency-check="none">  
  6.             <property name="driverClass">  
  7.                 <value>oracle.jdbc.driver.OracleDriver</value>  
  8.             </property>  
  9.             <property name="jdbcUrl">  
  10.                 <value>jdbc:oracle:thin:@localhost:1521:orcl</value>  
  11.             </property>  
  12.             <property name="user">  
  13.                 <value>scott</value>  
  14.             </property>  
  15.             <property name="password">  
  16.                 <value>123</value>  
  17.             </property>  
  18.             <!-- <property name="acquireIncrement">  
  19.                 <value>${c3p0.acquireIncrement}</value>  
  20.             </property>  
  21.             <property name="initialPoolSize">  
  22.                 <value>${c3p0.initialPoolSize}</value>  
  23.             </property>  
  24.             <property name="minPoolSize">  
  25.                 <value>${c3p0.minPoolSize}</value>  
  26.             </property>  
  27.             <property name="maxPoolSize">  
  28.                 <value>${c3p0.maxPoolSize}</value>  
  29.             </property>  
  30.             <property name="maxIdleTime">  
  31.                 <value>${c3p0.maxIdleTime}</value>  
  32.             </property>  
  33.             <property name="idleConnectionTestPeriod">  
  34.                 <value>${c3p0.idleConnectionTestPeriod}</value>  
  35.             </property>  
  36.             <property name="maxStatements">  
  37.                 <value>${c3p0.maxStatements}</value>  
  38.             </property>  
  39.             <property name="numHelperThreads">  
  40.                 <value>${c3p0.numHelperThreads}</value>  
  41.             </property>-->  
  42.     </bean>  
  43.     <bean id="transactionManager"  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  44.         <property name="dataSource">  
  45.             <ref local="dataSource" />  
  46.         </property>  
  47.     </bean>  
  48.     <bean id="txManager" abstract="true"  
  49.         class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
  50.         <property name="transactionManager" ref="transactionManager" />  
  51.         <property name="transactionAttributes">  
  52.             <props>  
  53.                 <prop key="add*">  
  54.                     PROPAGATION_REQUIRED,-DataAccessException  
  55.                 </prop>  
  56.                 <prop key="save*">  
  57.                     PROPAGATION_REQUIRED,-DataAccessException  
  58.                 </prop>  
  59.                 <prop key="edit*">  
  60.                     PROPAGATION_REQUIRED,-DataAccessException  
  61.                 </prop>  
  62.                 <prop key="update*">  
  63.                     PROPAGATION_REQUIRED,-DataAccessException  
  64.                 </prop>  
  65.                 <prop key="del*">  
  66.                     PROPAGATION_REQUIRED,-DataAccessException  
  67.                 </prop>  
  68.                 <prop key="handle*">  
  69.                     PROPAGATION_REQUIRED,-DataAccessException  
  70.                 </prop>  
  71.                 <prop key="notify*">  
  72.                     PROPAGATION_REQUIRED,-DataAccessException  
  73.                 </prop>  
  74.                 <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
  75.                 <prop key="query*">PROPAGATION_REQUIRED,readOnly,-DataAccessException</prop>  
  76.                 <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  77.                 <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>  
  78.             </props>  
  79.         </property>  
  80.     </bean>  
  81.       
  82.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
  83.         <constructor-arg ref="dataSource" />  
  84.     </bean>  
  85.     <bean id="userDao" class="com.riyun.daoImpl.UserDaoImpl">    
  86.           <property name="jdbcTemplate" ref="jdbcTemplate"></property>  
  87.     </bean>    
  88.     <bean id="login" class="com.riyun.action.LoginAction">    
  89.         <property name="userDao" ref="userDao" />    
  90.     </bean>    
  91. </beans>  

至此整个例子ok了。
在dao层连接数据库的时候还需要导入各个数据库所必须的jar包以及c3p0-0.9.1.2.jar这样的包。

总结：整合过程中 碰到许许多多的问题，相信大家看我这篇文章也会碰到许许多多不一样的问题，但是有问题不可怕，我们要做的就是分析问题的原因。我在整合过程碰到最多的问题就是classnotfound类的问题，其实这类的问题就是没有导入相关jar包导致的错误或者jar冲突导致的。

fishineye
关注
专栏目录
spring+struts整合
金豆呀的博客
04-04 1596
一、整合中遇到的问题 1.struts与spring整合要用到struts2-spring-plugin包，它作用就是不让struts自己创建Action，而是让spring创建管理Action对象。 但是我在加了这个Jar包后，发现它自带了低版本的spring包，使用exclusion标签排除了问题Jar包，下面链接是具体操作： https://blog.csdn.net/weix...
Struts2.3 + Spring3.2 整合
z_vv11的专栏
03-30 614
首先是Struts2.3整合Spring3.2 1、新建一个web工程（这个就不说了） 2、添加Struts2.3 把Struts开发所需的jar复制到工程的lib文件中。开发struts必须包如下：   3、创建action类 声明：整个示例只有一个简单的用户登录。 本例中的action类名为 LoginAction，该类中的代码如下：
Spring+Struts集成(第二种方案)
潛龍，勿用
03-30 2467
在上一篇文章中我们了解到了第一种Spring跟Struts集成的方案,但此集成方案的不足是WEB层中知道Spring的相关内容,因为需要去主动的查找对象:BeanFactory.方案二便是通过依赖注入的方式来进行.通过Spring提供ActionProxy进行代理.去获取BeanFactory,找到Path的名称,然后找到path路径下的Action,然后完成注入.           方案二
spring+struts
大白菜
07-16 225
struts jar spring-core 5 spring-web 支持包 spring-web-3.2.5.RELEASE.jar struts-spring-plugin-2.3.4.1.jar struts框架action对象的创建，交给spring 配置 struts.xml action路径 bean.x...
Struts2.3 + Spring3.2 + Hibernate4.1 + HTML5 + CSS3 开发示例
01-23
Struts2.3 + Spring3.2 + Hibernate4.1 + HTML5 + CSS3开发示例代码。 其中包括如下文件： 介绍文档 Struts2.3 + Spring3.2 + Hibernate4.1 + HTML5 + CSS3开发示例.docx Eclipse工程文件 SSH2.zip Zip包是Eclipse...
Struts2.3与Spring3.2整合教程：入门示例与验证功能
"Struts2.3与Spring3.2的整合教程" 在现代Web应用开发中，Struts2.3和Spring3.2是两个强大的开源框架，它们各自在Web MVC架构中扮演着关键角色。Struts2作为Apache的知名Web应用程序框架，提供了MVC模式的支持，...
Struts2.3.16.1+Hibernate3.6.10+Spring3.2.8整合
05-17
Struts2.3.16.1+Hibernate3.6.10+Spring3.2.8整合 能够运行，没有任何问题 另外附带applicationContext.xml、struts.xml、hibernate.cfg.xml
SSH所需的jar包，精简完全，struts2.3+hibernate3.6+spring3.2。
06-29
Struts2.3版本引入了许多新特性，例如改进的类型转换、更灵活的配置以及对RESTful风格的支持。 Spring框架是Java企业级应用开发的基石，它提供了依赖注入（DI）和面向切面编程（AOP）等核心特性。Spring允许开发者...
Spring+Struts2
CXY_ZPH的博客
02-21 370
Spring 整合Struts2 整合步骤: 1.导包 -导入Struts2的开发包 -导入Spring开发包 -导入Spring整合Struts2的开发包 2.配置web.xml .配置Struts2的前端控制器. .配置listener,用于在tomcat启动时自动加载Spring Spring已经提供专门用于加载容器的工具类 3.配置applicationContext.XML,开启注解...
spring+struts2
qq_40099321的博客
10-17 187
1导包(struts2+spring的jar包) 2写web.xml xml version="1.0"encoding="UTF-8"?> web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLoca
Spring 和 Struts 集成
王如霜
04-08 382
第一种 Struts2负责流程，Spring负责对象的创建；Action由Struts2框架负责创建；Service由Spring框架负责创建 1.web.xml &lt;servlet&gt; &lt;servlet-name&gt;action&lt;/servlet-name&gt; &lt;servlet-class&gt;org.apache.struts.act...
Spring与struts整合
陌心的博客
10-31 271
今天介绍Spring与struts的整合 web项目，整合目的是为了解决web每次加载都需要加载配置文件引起的消耗时间的问题，整合之后我们运行服务器后会自动加载xml文件，减少时间的浪费。 废话不多说首先第一步先导入Jar包 下面是web.xml的配置 <?xml version="1.0" encoding="UTF-8"?> <web-...
八、框架整合（一） - Spring 与 Struts整合
weixin_45602227的博客
10-21 436
一、spring 与 struts整合 Spring，负责对象对象创建 Struts， 用Action处理请求 Spring与Struts框架整合， 关键点：让struts框架action对象的创建，交给spring完成！ 配置struts的核心过滤器，拦截请求资源。 配置spring的监听器，初始化IOC容器。 1.1 引入jar文件 1. 引入struts.jar 相关jar文件 2. 引入spring-core 相关jar文件
Spring与Struts框架整合
bighuan的博客
05-05 521
一,概述 1)Spring:负责对象创建及处理对象依赖关系 2)Struts:用Action处理请求 3)Spring与Struts整合的关键点:将Struts框架Action的创建交给Spring完成 4)SSH整合关键点: Spring与Struts:Action对象交给Spring创建 Spring与Hibernate:SessionFactory对象交给Spring创建 二,
Spring整合Struts
中间体的地盘
03-03 1378
6.4  Spring整合Struts虽然Spring也提供了自己的MVC组件，但一来Spring的MVC组件过于繁琐，二     来Struts的拥护者实在太多。因此，很多项目都会选择使用Spring整合Struts框架。而且Spring确实可以无缝整合Struts框架，二者结合成一个更实际的J2EE开发平台。6.4.1  利用Struts的PlugIn来启动Spring容器使用S
Spring+Struts+Hibernate理解
Judy-命中注定与众不同
12-15 787
前言这次小编学习了spring+struts+Hibernate的框架，但是小编有点蒙，因为好像对他们不是太理解，所以在开始之前小编先做一个简单的总结，为了以后更好的发展做铺垫SpringWhere springspring框架的产生是因为javaEE中EJB开发的负责性而产生的，所以会有很多东西与EJB非常类似，但是他唯一没有的就是规范，因为他的民间流行的一种产品，但是现在的EJB已经借鉴了spr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值