spring整合redis

最新推荐文章于 2024-03-17 17:09:58 发布
最新推荐文章于 2024-03-17 17:09:58 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hollboy/article/details/49357097
版权

前言：

因为项目中使用的是spring框架，直接第一反应使用spring-data-redis。当然对java来说还有很多备选方案，比如jdbc


正文：

1.spring 的配置文件：

<?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:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:annotation-config />

    <context:component-scan base-package="com.fatsnake"/>

    <!--引入redis配置文件-->
    <context:property-placeholder location="classpath*:/redis.properties" />

    <!-- Spring Data Redis 设置 -->
    <!-- redis 序列化策略 ，通常情况下key值采用String序列化策略， -->
    <!-- 如果不指定序列化策略，StringRedisTemplate的key和value都将采用String序列化策略； -->
    <bean id="stringRedisSerializer"
          class="org.springframework.data.redis.serializer.StringRedisSerializer" />

    <bean id="jdkRedisSerializer"
          class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />

    <!--单点Redis配置  -->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:hostName="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"
           p:poolConfig-ref="jedisPoolConfig"/>

    <!-- 对string操作的封装 -->
    <bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate"
          p:connectionFactory-ref="jedisConnectionFactory" />

    <!-- redis template definition p表示对该bean里面的属性进行注入，格式为p:属性名=注入的对象 效果与在bean里面使用<property>标签一样 -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
          p:connectionFactory-ref="jedisConnectionFactory"
          p:keySerializer-ref="stringRedisSerializer" p:hashKeySerializer-ref="stringRedisSerializer"
          p:valueSerializer-ref="jdkRedisSerializer" p:hashValueSerializer-ref="jdkRedisSerializer" />

    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"
          p:maxTotal="${redis.maxActive}"
          p:maxIdle="${redis.maxIdle}"
          p:maxWaitMillis="${redis.maxWait}"
          p:testOnBorrow="${redis.testOnBorrow}"
          p:testOnReturn="true"
           />
    <bean id="userDao" class="com.fatsnake.dao.UserDaoImpl" />

</beans>
2.redis资源配置文件 
redis.properties
<pre name="code" class="plain">#最大分配的对象数
redis.maxActive=3000
#最大能够保持idel状态的对象数
redis.maxIdle=3000
#当池内没有返回对象时，最大等待时间
redis.maxWait=100000
#当调用borrow Object方法时，是否进行有效性检查
redis.testOnBorrow=true

#IP
redis.host=127.0.0.1
#Port
redis.port=6379
#Password
redis.pass=


 

 

3.实体类
 

 

public class Company implements Serializable {

    private static final long serialVersionUID = -1267719235225203410L;

    private int id;

    private String companyName;

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public int getId() {
        return id;
    }

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

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }
}
 

 

 

 

public class Pet implements Serializable {

    private static final long serialVersionUID = -1267719235225203410L;

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    private int id;

    private String petName;

    public int getId() {
        return id;
    }

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

    public String getPetName() {
        return petName;
    }

    public void setPetName(String petName) {
        this.petName = petName;
    }
}

 

 

 

 

public class User implements Serializable {

    private static final long serialVersionUID = -1267719235225203410L;

    private String uid;

    private String address;

    private Company company;

    private List<Pet> petList;

    public List<Pet> getPetList() {
        return petList;
    }

    public void setPetList(List<Pet> petList) {
        this.petList = petList;
    }

    public Company getCompany() {
        return company;
    }

    public void setCompany(Company company) {
        this.company = company;
    }

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public String getUid() {
        return uid;
    }

    public void setUid(String uid) {
        this.uid = uid;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "uid='" + uid + '\'' +
                ", address='" + address + '\'' +
                ", company.id=" + company.getId() +
                ", company.companyName=" + company.getCompanyName() +
                '}';
    }
}
 

 备注： 

 

a.为什么要实现Serializable接口呢？
 

答：redis持久化的过程其实就是对数据进行序列化与反序列化的过程。
 

b.什么叫序列化呢？
 

答：
 

对象的序列化：把对象转换为字节序列的过程。
 

　　对象的反序列化：把字节序列恢复为对象的过程。
 

详情见：http://www.cnblogs.com/xdp-gacl/p/3777987.html
 

c.为什么要建这么多实体对象？
 

答：一个测试方法，把实际开发中的各种类型对象包含在内，一步搞定
 


 
 

4.操作类
 

 

public interface UserDao {
    /**
     */
    void save(User user);

    /**
     * @param uid
     * @return
     */
    User read(String uid);

    /**
     * @param uid
     */
    void delete(String uid);

    public void addOrUpdateUser(User user);

    public User loadUser(String userId);

    public void deleteUser(int userId);

    public void testList(String keyName,List<User> userList);

    public void testhash(String h,Map<String,User> userMap);

}
 

 

 

 

public class UserDaoImpl implements UserDao {

    @Autowired
    private RedisTemplate<Serializable, Serializable> redisTemplate;

    @Override
    public void save(final User user) {
        redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection)
                    throws DataAccessException {
                connection.set(
                        redisTemplate.getStringSerializer().serialize(
                                "user.uid." + user.getUid()),
                        redisTemplate.getStringSerializer().serialize(
                                user.getAddress()));

                return null;
            }
        });
    }

    @Override
    public User read(final String uid) {
        return redisTemplate.execute(new RedisCallback<User>() {
            @Override
            public User doInRedis(RedisConnection connection)
                    throws DataAccessException {
                byte[] key = redisTemplate.getStringSerializer().serialize(
                        "user.uid." + uid);
                if (connection.exists(key)) {
                    byte[] value = connection.get(key);
                    String address = redisTemplate.getStringSerializer()
                            .deserialize(value);
                    User user = new User();
                    user.setAddress(address);
                    user.setUid(uid);
                    return user;
                }
                return null;
            }
        });
    }

    @Override
    public void delete(final String uid) {
        redisTemplate.execute(new RedisCallback<Object>() {
            public Object doInRedis(RedisConnection connection) {
                connection.del(redisTemplate.getStringSerializer().serialize(
                        "user.uid." + uid));
                return null;
            }
        });
    }

    @Override
    public void addOrUpdateUser(User user) {
        redisTemplate.opsForValue().set("user.uid." + user.getUid(), user);
    }

    @Override
    public User loadUser(String userId) {
        return (User) redisTemplate.opsForValue().get("user.uid." + userId);
    }

    @Override
    public void deleteUser(int userId) {
        redisTemplate.delete("user.uid." + userId);
    }


    public void testList(String keyName,List<User>userList) {
        ListOperations opsForList = redisTemplate.opsForList();

        redisTemplate.delete(keyName);

        for(User user:userList){
            opsForList.leftPush(keyName, user);
        }

        //opsForList.leftPushAll(keyName, "wangwu", "zhaoliu", "qianqi");

        Long size = opsForList.size(keyName);
        System.out.println("size:" + size);

        for (long i = 0; i < size; i++) {
            Object value = opsForList.index(keyName,i);
            System.out.println("i:"+i+",value:"+value.toString());
        }

        Object leftPop = opsForList.leftPop(keyName);
        System.out.println("after pop size:"+opsForList.size(keyName));
    }

    ///
    public void testhash(String h,Map<String,User> userMap) {
        HashOperations ops = redisTemplate.opsForHash();
        ops. putAll(h, userMap);

        Map<String,User>getUserMap = ops.entries(h);

        for (Map.Entry<String, User> entry : getUserMap.entrySet()) {
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        }
    }
 

 

 

5.测试类
 

此处测试了，保存字符串、对象、list、map和对象中含有list等，多种在实际开发中遇到的数据类型。
 

 

public class UserDaoTest {

    private ApplicationContext app;
    private UserDao userDao;

    @Before
    public void before() throws Exception {
        app = new ClassPathXmlApplicationContext("spring-config.xml");
        userDao = (UserDao) app.getBean("userDao");
    }

    @Test
    public void crud() {
        // -------------- Create ---------------
        String uid = "u123456";
        String address1 = "上海";
        User user = new User();
        user.setAddress(address1);
        user.setUid(uid);
        userDao.save(user);

//        // ---------------Read ---------------
//        user = userDao.read(uid);
//
//        assertEquals(address1, user.getAddress());
//
//        // --------------Update ------------
//        String address2 = "北京";
//        user.setAddress(address2);
//        userDao.save(user);
//
//        user = userDao.read(uid);
//
//        assertEquals(address2, user.getAddress());
//
//        // --------------Delete ------------
//        userDao.delete(uid);
//        user = userDao.read(uid);
//        assertNull(user);
//
//
//        List<User>uerList = new ArrayList<User>();
//        for(int i=0;i<10;i++){
//            // -------------- Create ---------------
//            uid = "u123456"+i;
//            address1 = "上海"+i;
//            user = new User();
//            user.setAddress(address1);
//            user.setUid(uid);
//            uerList.add(user);
//        }


//        Company company1 = new Company();
//        company1.setId(123);
//        company1.setCompanyName("张三");
//        user.setCompany(company1);
//
//        System.out.println(user);
//        userDao.addOrUpdateUser(user);
//        user = userDao.loadUser(user.getUid());
//        System.out.println(user);
//        userDao.delete(user.getUid());
//        user = userDao.loadUser(user.getUid());
//        System.out.println(user);

        // 保存 list
//        List<User>userList = new ArrayList<User>();
//        User newUser = null;
//        Company newCompany = null;
//        for(int i = 0;i < 4;i++){
//            newUser = new User();
//            newUser.setUid("Uid"+i);
//            newUser.setAddress(i+"号街");
//
//            newCompany = new Company();
//            newCompany.setId(i);
//            newCompany.setCompanyName("公司"+i);
//            newUser.setCompany(newCompany);
//
//            userList.add(newUser);
//        }
//
//        userDao.testList("AllUser",userList);

        Map<String,User> userMap = new HashMap<String, User>();
        User newUser = null;
        Company newCompany = null;
        for(int i = 0;i < 4;i++){
            newUser = new User();
            newUser.setUid("Uid"+i);
            newUser.setAddress(i+"号街");

            newCompany = new Company();
            newCompany.setId(i);
            newCompany.setCompanyName("公司"+i);
            newUser.setCompany(newCompany);

            Pet pet = new Pet();
            List<Pet>petList = new ArrayList<Pet>();
            Pet newPet = null;
            for(int j = 0;j<4;j++){
                newPet = new Pet();
                newPet.setId(i);
                newPet.setPetName("PetName:"+i);
                petList.add(newPet);
            }
            newUser.setPetList(petList);

            userMap.put(String.valueOf(i), newUser);
        }

        userDao.testhash("userMap",userMap);
    }
 6.差点忘了jar包，此处用的maven搭建 

 

 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.springapp</groupId>
    <artifactId>springRedis</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>springRedis</name>

    <properties>
        <spring.version>4.1.1.RELEASE</spring.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>


        <!--添加对redis的依赖包-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.5.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.6.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!-- Hack：确保commons-logging的jar包不被引入，否则将和jcl-over-slf4j冲突 -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- slf4j的实现：logback，用来取代log4j。更快、更强！ -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>0.9.24</version>
            <scope>runtime</scope>
        </dependency>

    </dependencies>

    <build>
        <finalName>springRedis</finalName>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <includes>
                        <include>**/*Tests.java</include>
                    </includes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
 

 

 

总结:
 

   spring-data-redis 使用起来很像jdbctemplate

                

        

        

    

  


    

      

        

            

              
                
                  進擊的胖蛇
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
redis设置hostname_spring + redis 实现数据的缓存

				
			

			

				

					weixin_39574868的博客
				

				

					01-22
					
					586
					
				

			

		

		

			
				
1、实现目标　　通过redis缓存数据。（目的不是加快查询的速度，而是减少数据库的负担）　　2、所需jar包　　注意：jdies和commons-pool两个jar的版本是有对应关系的，注意引入jar包是要配对使用，否则将会报错。因为commons-pooljar的目录根据版本的变化，目录结构会变。前面的版本是org.apache.pool，而后面的版本是org.apache.pool2redis...

			
		

	



                

              
                



	

		

			

				
					
spring boot +redis 连接池配置 及运用

				
			

			

				

					浪丶荡
				

				

					03-07
					
					1160
					
				

			

		

		

			
				
连接池参数，正式环境配置在yml文件中
package cn.com.suntree.utils.myself;

import lombok.extern.log4j.Log4j2;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.annotation.Cachin...

			
		

	



                


  
              

                


	

		

			

				
					
Redis缓存对象相关

				
			

			

				

					PzzZ的博客
				

				

					01-06
					
					1446
					
				

			

		

		

			
				
1、想要使用redis先获得连接池对象，及JedisPool 
然后在配置生成连接池对象需要的参数咯 
（1）你可以写一个参数实体类，再写一个bean注入到spring

@Component
@ConfigurationProperties(prefix="redis")//这个在properties的配置文件里噢，框架是springboot，表示前缀是redis的，参数名称得对应。
publi

			
		

	





	

		

			

				
					
springboot集成redis缓存池pool的问题

				
			

			

				

					选择大于努力吗？
				

				

					12-23
					
					538
					
				

			

		

		

			
				
错误提示：


redis.clients.jedis.exceptions.JedisConnectionException: Could not get a resource from the pool


Caused by: redis.clients.jedis.exceptions.JedisDataException: ERR Client sent AUTH, but no pas...

			
		

	



		

			
		



	

		

			

				
					
2-11 附：文档的基本操作 - 查询

				
			

			

				

					村西头的俏寡妇
				

				

					01-14
					
					1385
					
				

			

		

		

			
				

			
		

	





	

		

			

				
					
Spring集成Redis及常见应用

					
最新发布

				
			

			

				

					花木凋零成兰的博客
				

				

					03-17
					
					1246
					
				

			

		

		

			
				
Spring 整合 Redis

			
		

	





	

		

			

				
					
Spring集成Redis应用

				
			

			

				

					weixin_45300957的博客
				

				

					04-13
					
					1190
					
				

			

		

		

			
				
Redis简介Redis(Remote Dictionary Server)是一个基于内存开源的键值存储系统，具有高性能、高可靠性、支持多种数据结构等特点。Redis支持主从复制、持久化、Lua脚本等功能，可以应用于许多场景，如缓存、消息队列、计数器、分布式锁等。并且Redis具有以下几个特点：高性能：Redis采用了基于内存的存储机制，将数据存在内存中以达到快速读写的目的。此外，Redis还采用了多种提高性能的技术，如快速网络IO，异步IO等。

			
		

	





	

		

			

				
					
Spring整合Redis

				
			

			

				

					Junnix的博客
				

				

					04-01
					
					1976
					
				

			

		

		

			
				
Spring整合Redis
一：注入依赖
<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.0.0</version>
        </dependency>

二：基本操作
1.普通连接只需要创建一个对象即可：


			
		

	





	

		

			

				
					
Spring集成Redis

				
			

			

				

					KangJinXuan的博客
				

				

					08-04
					
					2047
					
				

			

		

		

			
				
Spring集成Redis。

			
		

	





	

		

			

				
					
spring 集成redis

				
			

			

				

					03-14
				

			

		

		

			
				
接下来，我们将深入探讨如何在Spring项目中集成Redis。  首先，我们要准备集成Redis所需的依赖。在描述中提到了`spring-data-redis.jar`和`jedis.jar`，这两个是关键组件。`spring-data-redis`是Spring Data项目的一...

			
		

	





	

		

			

				
					
spring集成redis源码

				
			

			

				

					06-05
				

			

		

		

			
				
spring和redis集成有很多方式，看到网上很多都是使用redistemplate自己去做redis 的一些操作，但是对于我们开发来说，肯定是使用越方便越好，于是乎就有了spring的对redis或者memcahe这些换成框架的封装，只需要引入...

			
		

	





	

		

			

				
					
Jedis cluster客户端使用

				
			

			

				

					韬晦潜胖蛇的专栏
				

				

					10-26
					
					6681
					
				

			

		

		

			
				
前言：
由于spring-data-redis不支持，redis集群的操作。所以更换客户端，使用Jedis cluster。
正文：


一.序言

     前面搭建了个3个msater-slave 的本地集群测试，这里用java 的客户端 进行一些简单测试，看看集群是否生效。

     redis client 推荐：http://redis.io/clients

 

			
		

	





	

		

			

				
					
reids客户端 redis-cli用法

				
			

			

				

					韬晦潜胖蛇的专栏
				

				

					10-26
					
					4732
					
				

			

		

		

			
				
连接：redis-cli -h machine -p port -n db
转的：每次都搜，还是扔在这



Redis提供了丰富的命令（command）对数据库和各种数据类型进行操作，这些command可以在Linux终端使用。在编程时，比如使用Redis
 的Java语言包，这些命令都有对应的方法。下面将Redis提供的命令做一总结。

官网命令列表：http://redis.

			
		

	





	

		

			

				
					
linux下redis集群安装

				
			

			

				

					韬晦潜胖蛇的专栏
				

				

					10-26
					
					1713
					
				

			

		

		

			
				
一、编译安装redis


tar -xzvf redis-3.0.4.tar.gz

cd redis-3.0.4

make

make PREFIX=/usr/local/redis install

cp –r src /usr/local/redis

mkdir /usr/local/redis/data





二、复制配置文件到/usr/local/redis


			
		

	





	

		

			

				
					
redis可视化客户端

				
			

			

				

					韬晦潜胖蛇的专栏
				

				

					10-22
					
					1486
					
				

			

		

		

			
				
前言：
早上为了查看redis数据，使用自带的命令行，有点厌恶了！ 故搜索了下可视化客户端


正文：
常见的几种
http://database.51cto.com/art/201505/477692.htm



个人推荐  Redis Desktop Manager
下载地址：
http://redisdesktop.com/download  
使用说明
htt

			
		

	





	

		

			

				
					
mac 下安装 redis

				
			

			

				

					韬晦潜胖蛇的专栏
				

				

					10-14
					
					1433
					
				

			

		

		

			
				
1、下载
http://www.redis.io去下载最新版本的Redis安装文件


2、解压、打开终端

sudo tar -zxf redis-2.8.7.tar.gz
3、修改文件加名、编译

mv redis-2.8.7 redis
cd redis/

sudo make
sudo make test
sudo make install
ps：
若此处提

			
		

	





	

		

			

				
					
Spring整合Redis实现高效数据缓存

				
			

			

				

					
				

			

		

		

			
				
Spring整合Redis提供了一种高效的方法来存储和检索数据，避免了每次请求都直接查询数据库。Redis作为一个内存中的数据结构存储系统，具有异常快速的响应速度，每秒可以处理大量的集合和记录操作，使其成为缓存的理想...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值