spring-remoting入门（http-invoker,hessian,burlap）

最新推荐文章于 2024-08-29 19:22:50 发布
最新推荐文章于 2024-08-29 19:22:50 发布
阅读量4.3k 收藏 6
点赞数 1
分类专栏： spring 文章标签： spring remoting
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ppt0501/article/details/46606745
版权

这里简单介绍一下sping remoting的三种实现，http-invoker，hessian，burlap，spring对hessian，burlap做好很好的封装，很容易使用，下面介绍一下他们的配置

一、服务器端配置（applicationContext.xml）：

<pre name="code" class="html"><?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:p="http://www.springframework.org/schema/p"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/mvc
		http://www.springframework.org/schema/mvc/spring-mvc.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context.xsd">
		
	<context:component-scan base-package="com.plateno.service" />
	
	<bean id="beanNameUrlHandlerMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
	<!-- 类似rmi方式，采用java序列化，数据量较大 -->
	<bean name="/httpInvokerService" class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">
		<property name="service" ref="remoteService"/>
		<property name="serviceInterface" value="com.plateno.platform.service.RemoteService"/>
	</bean>
	<!-- 采用hessian序列化，数据量最小 -->
	<bean name="/hessianService" class="org.springframework.remoting.caucho.HessianServiceExporter">
		<property name="service" ref="remoteService"/>
		<property name="serviceInterface" value="com.plateno.platform.service.RemoteService"/>
	</bean> 
	<!-- xml传输数据，数据量比httpinvoker方式小 -->
	<bean name="/burlapService" class="org.springframework.remoting.caucho.BurlapServiceExporter">
		<property name="service" ref="remoteService"/>
		<property name="serviceInterface" value="com.plateno.platform.service.RemoteService"/>
	</bean>  
	
	<mvc:interceptors>
		<mvc:interceptor>
			<mvc:mapping path="/**"/>
			<bean class="com.plateno.interceptor.CommonInterceptor"/>
		</mvc:interceptor>
	</mvc:interceptors>
	
</beans>


 二、服务器端配置（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"
	xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">
	
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:applicationContext.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<servlet>
		<servlet-name>springmvc</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring-mvc.xml</param-value>
		</init-param>
	</servlet>
	
	<servlet-mapping>
		<servlet-name>springmvc</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	
</web-app>
三、写一个service，再写一个serviceImpl就ok了。 

 


 
 

四、客户端配置：
 

 

<pre name="code" class="html"><bean id="httpInvokerProxyFactoryBean" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
		<property name="serviceUrl" value="http://localhost:9999/server/httpInvokerService"/>
		<property name="serviceInterface" value="com.plateno.platform.service.RemoteService"/>
	</bean> 
	
	<bean id="hessianProxyFactoryBean" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">
		<property name="serviceUrl" value="http://localhost:9999/server/hessianService"/>
		<property name="serviceInterface" value="com.plateno.platform.service.RemoteService"/>
	</bean>
	
	<bean id="burlapProxyFactoryBean" class="org.springframework.remoting.caucho.BurlapProxyFactoryBean">
		<property name="serviceUrl" value="http://localhost:9999/server/burlapService"/>
		<property name="serviceInterface" value="com.plateno.platform.service.RemoteService"/>
	</bean>
 

 

 

 五、测试类： 

 

 

@Autowired
	private RemoteService remoteService;
	@RequestMapping(value="/test")
	public ModelAndView test(@RequestParam(value="name", required=false) String name) {
		UserDTO dto = remoteService.getUser("hello");
		System.out.println(dto);
		Map<String, Object> model = new HashMap<String, Object>();
		return new ModelAndView("test/hello", model);
	}
 

 

 

加载@@@@@@@@
 

如果按照上面的方式，每发布一个接口，就得往xml文件写配置，很麻烦，下面来介绍工程自动发布接口，程序员像在一个工程写代码一个，写接口，写实现，客户端调用就ok了
 

1、给定包名，扫描包名下面的类（接口）参照spring实现：
 

 

package com.plateno.util;

import java.util.ArrayList;
import java.util.List;

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;


public class ClassPathScanning extends ClassPathScanningCandidateComponentProvider {

	private List<String> classNameSet = new ArrayList<String>(20);
	private List<Class<?>> clzSet = new ArrayList<Class<?>>(20);
	public ClassPathScanning(boolean useDefaultFilters) {
		super(useDefaultFilters);
	}
	static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
	private String resourcePattern = DEFAULT_RESOURCE_PATTERN;
	private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
	private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);
	
	public void getClassFromPackage(String basePackage) {
		try {
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + "/" + this.resourcePattern;
			Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
			for(Resource r : resources) {
				if(r.isReadable()) {
					MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(r);
					ClassMetadata classMetadata = metadataReader.getClassMetadata();
					if(!classMetadata.isIndependent()) {
						continue;
					}
					String className = classMetadata.getClassName();
					int index = className.lastIndexOf(".");
					if(index > 0) {
						String name = className.substring(index+1);
						name = name.substring(0, 1).toLowerCase() + name.substring(1);
						classNameSet.add(name);
						clzSet.add(Class.forName(className));
					}
				}
			}
		} catch(Exception e) {
			e.printStackTrace();
		}
	}

	public List<String> getClassNameSet() {
		return classNameSet;
	}

	public List<Class<?>> getClzSet() {
		return clzSet;
	}
	
}

 

 2、服务端发布接口： 

 

 

package com.plateno.util;

import java.util.List;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.remoting.caucho.BurlapServiceExporter;
import org.springframework.remoting.caucho.HessianServiceExporter;
import org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter;

public class BeanFactoryProxyServer implements BeanFactoryPostProcessor,ApplicationContextAware {

	private ApplicationContext applicationContext;
	private ConfigurableListableBeanFactory beanFactory;
	private String basePackage = "com.plateno.platform.service";
	@Override
	public void postProcessBeanFactory(
			ConfigurableListableBeanFactory beanFactory) throws BeansException {
		this.beanFactory = beanFactory;
//		httpInvoker();
//		hessian();
		burlap();
	}
	
	private void httpInvoker() {
		ClassPathScanning scann = new ClassPathScanning(true);
		scann.getClassFromPackage(basePackage);
		List<String> classNameSet = scann.getClassNameSet();
		List<Class<?>> clzSet = scann.getClzSet();
		for(int i=0; i<classNameSet.size(); i++) {
			Class<?> clz = clzSet.get(i);
			String className = classNameSet.get(i);
			HttpInvokerServiceExporter exporter = new HttpInvokerServiceExporter();
			exporter.setService(this.applicationContext.getBean(className));
			exporter.setServiceInterface(clz);
			exporter.afterPropertiesSet();
			beanFactory.registerSingleton("/" + className, exporter);
		}
		
	}
	private void hessian() {
		ClassPathScanning scann = new ClassPathScanning(true);
		scann.getClassFromPackage(basePackage);
		List<String> classNameSet = scann.getClassNameSet();
		List<Class<?>> clzSet = scann.getClzSet();
		for(int i=0; i<classNameSet.size(); i++) {
			Class<?> clz = clzSet.get(i);
			String className = classNameSet.get(i);
			HessianServiceExporter exporter = new HessianServiceExporter();
			exporter.setService(this.applicationContext.getBean(className));
			exporter.setServiceInterface(clz);
			exporter.afterPropertiesSet();
			beanFactory.registerSingleton("/" + className, exporter);
		}
	}
	private void burlap() {
		ClassPathScanning scann = new ClassPathScanning(true);
		scann.getClassFromPackage(basePackage);
		List<String> classNameSet = scann.getClassNameSet();
		List<Class<?>> clzSet = scann.getClzSet();
		for(int i=0; i<classNameSet.size(); i++) {
			Class<?> clz = clzSet.get(i);
			String className = classNameSet.get(i);
			BurlapServiceExporter exporter = new BurlapServiceExporter();
			exporter.setService(this.applicationContext.getBean(className));
			exporter.setServiceInterface(clz);
			exporter.afterPropertiesSet();
			beanFactory.registerSingleton("/" + className, exporter);
		}
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		this.applicationContext = applicationContext;
		
	}
}

 

 3、客户端配置： 

 

 

package com.plateno.util;

import java.util.List;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.remoting.caucho.BurlapProxyFactoryBean;
import org.springframework.remoting.caucho.HessianProxyFactoryBean;
import org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean;

public class BeanFactoryProxyClient implements BeanFactoryPostProcessor {

	private ConfigurableListableBeanFactory beanFactory;
	private String basePackage = "com.plateno.platform.service";
	private String baseUrl = "http://localhost:9999/server/";
	@Override
	public void postProcessBeanFactory(
			ConfigurableListableBeanFactory beanFactory) throws BeansException {
		this.beanFactory = beanFactory;
//		httpInvoker();
//		hessian();
		burlap();
	}
	private void httpInvoker() {
		ClassPathScanning scann = new ClassPathScanning(true);
		scann.getClassFromPackage(basePackage);
		List<String> classNameSet = scann.getClassNameSet();
		List<Class<?>> clzSet = scann.getClzSet();
		for(int i=0; i<classNameSet.size(); i++) {
			Class<?> clz = clzSet.get(i);
			String className = classNameSet.get(i);
			HttpInvokerProxyFactoryBean factoryBean = new HttpInvokerProxyFactoryBean();
			factoryBean.setServiceInterface(clz);
			factoryBean.setServiceUrl(baseUrl + className);
			factoryBean.afterPropertiesSet();
			beanFactory.registerSingleton(className, factoryBean.getObject());
		}
	}
	private void hessian() {
		ClassPathScanning scann = new ClassPathScanning(true);
		scann.getClassFromPackage(basePackage);
		List<String> classNameSet = scann.getClassNameSet();
		List<Class<?>> clzSet = scann.getClzSet();
		for(int i=0; i<classNameSet.size(); i++) {
			Class<?> clz = clzSet.get(i);
			String className = classNameSet.get(i);
			HessianProxyFactoryBean factoryBean = new HessianProxyFactoryBean();
			factoryBean.setServiceInterface(clz);
			factoryBean.setServiceUrl(baseUrl + className);
			factoryBean.afterPropertiesSet();
			beanFactory.registerSingleton(className, factoryBean.getObject());
		}
	}
	private void burlap() {
		ClassPathScanning scann = new ClassPathScanning(true);
		scann.getClassFromPackage(basePackage);
		List<String> classNameSet = scann.getClassNameSet();
		List<Class<?>> clzSet = scann.getClzSet();
		for(int i=0; i<classNameSet.size(); i++) {
			Class<?> clz = clzSet.get(i);
			String className = classNameSet.get(i);
			BurlapProxyFactoryBean factoryBean = new BurlapProxyFactoryBean();
			factoryBean.setServiceInterface(clz);
			factoryBean.setServiceUrl(baseUrl + className);
			factoryBean.afterPropertiesSet();
			beanFactory.registerSingleton(className, factoryBean.getObject());
		}
	}

}

 

 4、把服务端跟客户端配置在spring配置文件，然后程序就能用了，简化了很多。 


                

        

        

    

  


    

      

        

            

              
                
                  ppt0501
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Spring远程服务编程框架 Spring Remoting——Hessian远程服务调用过程

				
			

			

				

					weixin_44048532的博客
				

				

					01-18
					
					572
					
				

			

		

		

			
				
Remoting实际上是一种企业分布式计算的组件。在同一服务器（Java虚拟机）内进行调用的服务（或类）并不需要把自己暴露为一种远程服务； 但是，如果你需要与一个外部程序(在不同的服务器上或在一个不同的组织中)进行通讯的话，那么，必须把它实现为一个远程服务。Spring框架为把业务类 暴露为远程服务提供了一种独特而灵活的方式。

Spring Remoting架构的核心是服务对象，这些对象其实是一...

			
		

	



                

            
              



	

		

			

				
					
Spring远程服务----HttpInvoker实现远程调用

				
			

			

				

					梦悠哉的博客
				

				

					05-13
					
					1416
					
				

			

		

		

			
				
1.简介
Spring的之前两篇远程服务调用方式，RMI服务使用的是Java标准的对象私有序列化机制，但很难穿越防火墙，而Hessian和Burlap服务是基于HTTP的服务，所以不受防火墙限制，但采用了私有的对象序列化机制。那么有没有一种服务可以总和了
2.介绍
3.测试
4.参考文档

...

			
		

	



              


  
              

                


	

		

			

				
					
Spring remoting简单例子

				
			

			

				

					mxsfengg
				

				

					11-23
					
					165
					
				

			

		

		

			
				
Spring目前提供了对RMI、HttpInvoker、Hessian、Burlap及WebService等Remoting技术的集成。Spring屏蔽了这些实现技术的差异，用户只需开发简单的Java对象(Plain Old Java Objects，POJO)然后按照Spring规定的格式进行配置文件的编写即可。
6.2.1  Hessian使用演示
【例6.1】在Spring中使用Hess...

			
		

	





	

		

			

				
					
记Spring HTTP Invoker远程调用的使用（二）基于Servlet方式，配置servlet映射url-pattern实现

					
最新发布

				
			

			

				

					u011529483的博客
				

				

					08-29
					
					953
					
				

			

		

		

			
				
记Spring HTTP Invoker远程调用的使用（二）基于Servlet方式，配置servlet映射url-pattern实现
基于Servlet方式，由org.springframework.web.context.support.HttpRequestHandlerServlet去拦截url- pattern匹配的请求，查找对应的bean配置（本文通过applicationContext-servers.xml文件管理服务端bean）。


			
		

	



		

			
		



	

		

			

				
					
通过Spring.net发布Remoting

				
			

			

				

					weixin_34013044的博客
				

				

					05-26
					
					108
					
				

			

		

		

			
				
   Spring.Services程序集中提供了对Remoting的支持，使用Spring.net可以方便的发布和使用Remoting服务。

1.Remoting发布（服务端）
（1）首先在config文件中注册通道：
&lt;system.runtime.remoting&gt;
    &lt;application&gt;
      &lt;channels&gt;
  ...

			
		

	





	

		

			

				
					
Java远程通讯可选技术及原理 

				
			

			

				

					Android-Java
				

				

					03-06
					
					250
					
				

			

		

		

			
				
在分布式服务框架中，一个最基础的问题就是远程服务是怎么通讯的，在Java领域中有很多可实现远程通讯的技术，例如：RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS等，这些名词之间到底是些什么关系呢，它们背后到底是基于什么原理实现的呢，了解这些是实现分布式服务框架的基础知识，而如果在性能上有高的要求的话，那深入了解这些技术背后的机制就是必须的了，在这篇blog中我们将来...

			
		

	





	

		

			

				
					
spring-remoting调用的介绍

				
			

			

				

					lsblsb的专栏
				

				

					10-13
					
					1412
					
				

			

		

		

			
				
Spring目前提供了对RMI、HttpInvoker、Hessian、Burlap及WebService等Remoting技术的集成。Spring屏蔽了这些实现技术的差异，用户只需开发简单的Java对象(Plain Old Java Objects，POJO)然后按照Spring规定的格式进行配置文件的编写即可。

			
		

	





	

		

			

				
					
spring remoting

				
			

			

				

					04-03
				

			

		

		

			
				
Spring Remoting提供了多种远程调用协议的抽象，如RMI、Hessian、 Burlap、HTTP Invoker和JMS等，允许开发者根据项目需求选择最适合的方案。  1. RMI（Remote Method Invocation）：RMI是Java平台上的标准远程调用...

			
		

	





	

		

			

				
					
spring2.5 -3.0 hibernate3.3 jar包说明

				
			

			

				

					02-23
				

			

		

		

			
				
 支持远程调用功能，例如EJB、JMS、RMI、Hessian、Burlap、HttpInvoker、JAX-RPC等。  10. **spring-support.jar**   提供了一些额外的功能支持，如缓存管理、定时任务、邮件服务等。  11. **spring-web.jar**   ...

			
		

	





	

		

			

				
					
Spring 2.5-3.0与Hibernate 3.3集成详解

				
			

			

				

					
				

			

		

		

			
				
9. spring-remoting.jar：提供了远程调用支持，包括EJB、JMS、各种远程协议（如RMI、Hessian、Burlap、HTTP Invoker和JAX-RPC）的实现，方便分布式系统间的通信。  10. spring-support.jar：包含了一些额外的支持库...

			
		

	





	

		

			

				
					
spring:remoting

				
			

			

				

					taxuexunmei414923794的专栏
				

				

					12-05
					
					1093
					
				

			

		

		

			
				
参考：http://static.springsource.org/spring/docs/3.1.2.RELEASE/spring-framework-reference/html/remoting.html
1.bean

package cmei.spring.integration.remote.dto;

import java.io.Serializable;

public c

			
		

	





	

		

			

				
					
spring-remoting.jar

				
			

			

				

					10-10
				

			

		

		

			
				
spring-remoting.jar
spring-remoting.jar

			
		

	





	

		

			

				
					
Http Invoker的Spring Remoting支持

				
			

			

				

					最佳 Java 编程
				

				

					05-09
					
					219
					
				

			

		

		

			
				
Spring HTTP Invoker是Java到Java远程处理的重要解决方案。 该技术使用标准的Java序列化机制通过HTTP公开服务，并且可以被视为替代解决方案，而不是Hessian和Burlap中的自定义序列化。 而且，它仅由Spring提供，因此客户端和服务器应用程序都必须基于Spring。  Spring通过HttpInvokerProxyFactoryBean和HttpInvo...

			
		

	





	

		

			

				
					
6.Spring Remoting (-)

				
			

			

				

					最初感动
				

				

					07-05
					
					148
					
				

			

		

		

			
				
Spring Remoting (-)
 
	1.	使用Http 调用：首先在配置文件中定义所要暴露的接口，如下代码：
	接收：
	
 
 &lt;bean name="contactExporter"
		class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter"&gt;
		&lt;pr...

			
		

	





	

		

			

				
					
在Spring中使用Hessian Remoting技术。

				
			

			

				

					Zfrong繁荣的IT技术、IT项目、解决方案专栏Blog-上海
				

				

					12-27
					
					5884
					
				

			

		

		

			
				
Spring目前提供了对RMI、HttpInvoker、Hessian、Burlap及WebService等Remoting技术的集成。Spring屏蔽了这些实现技术的差异，用户只需开发简单的Java对象(Plain Old Java Objects，POJO)然后按照Spring规定的格式进行配置文件的编写即可。6.2.1  Hessian使用演示【例6.1】在Spring中使用

			
		

	





	

		

			

				
					
Spring Remoting了解与使用

				
			

			

				

					juce的专栏
				

				

					04-28
					
					1662
					
				

			

		

		

			
				
HttpInvokerServiceExporter只是spring remoting的一种，还有HessianServiceExporter，BurlapServiceExporter
下面一个例子以HttpInvokerServiceExporter为例的综合应用 
也可以参考http://www.javaeye.com/topic/417767这个帖子 

1.JettyDaemon

			
		

	





	

		

			

				
					
Spring-remoting使用心得1－RMI

				
			

			

				

					zcjl的专栏
				

				

					03-02
					
					4180
					
				

			

		

		

			
				
看了《J2EE without EJB》的remote章节，忍不住写点代码试试，看看Spring的实现到底多巧妙。1.先测试RMI服务的发布，测试代码如下：//MyService.java: remote interface for RMIpackage test.spring.remote.rmi;public interface MyService extends java.rmi.R

			
		

	





	

		

			

				
					
Spring-remoting实现rmi调用及集群化方法

				
			

			

				

					BuquTianya的专栏
				

				

					03-04
					
					2893
					
				

			

		

		

			
				
rmi远程过程调用，以及rmi集群化的方式、均衡原理。

			
		

	





	

		

			

				
					
remoting java_[java]spring几种remoting调用的测试结果：

				
			

			

				

					weixin_36145482的博客
				

				

					02-16
					
					134
					
				

			

		

		

			
				
1000 loop test:testDirectAccountService:10 ---direct java calltestDirectAccountServiceR:20testAccountService:40 ---factory.getBean(xxx)testAccountServiceR:40testRMIAccountService:7711 ---normal o...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值