Java Web / Spring集成Berkeley DB java edition(je)内存数据库

最新推荐文章于 2019-07-15 09:28:16 发布
最新推荐文章于 2019-07-15 09:28:16 发布
阅读量3k 收藏
点赞数
文章标签： 事务 内存数据库 web 数据库 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cesul/article/details/29600831
版权

一、概述


本文介绍在java web工程中使用Berkeley DB JE作为内存数据库来存取数据。当业务逻辑不太复杂时，通常可以代替在关系型数据库中设计复杂的sql和表结构。

当数据量不太夸张（BDB）时，这种方案的优点，除了BDB自身的种种优点外还有：

1，代码简单，易于维护。且数据持久化存储在指定目录中。

2，存取高效，经实际项目（高并发）测试，附带附加的计算返回均为毫秒级别。

3，易于扩展，支持任意java对象的增删查改。

4，可实现的接口丰富，支持交叉、关联查询等。

5，事务支持。

6，支持一级、二级索引


二、最佳实践



最佳实践：存取Car数据。

如上图，主要存取过程主要由4各类完成，其中：

1，BDBEnvironment.java: 封装BDB自身的Environment类，EnvironmentConfig类。指定数据存放的目录。

/**
 * BDB环境包装器
 * @author craig
 *
 */
public class BDBEnvironment {

	private Environment env;
	private StoreConfig storeConfig;
	private String envHome;
	
	public BDBEnvironment(String envHome){
		System.out.println("envHome:" + envHome);
		this.envHome = envHome;
		init();
	}
	
	public BDBEnvironment(String envHome, boolean deleteFolderContents){
		System.out.println("envHome:" + envHome);
		this.envHome = envHome;
		if(deleteFolderContents) {
			JFileUtils.deleteFolderContents(new File(envHome));
		}
		init();
	}
	
	public void init() {
		
		EnvironmentConfig myEnvConfig = new EnvironmentConfig();
        myEnvConfig.setReadOnly(false);
        myEnvConfig.setTransactional(true);
        myEnvConfig.setAllowCreate(true);
        
        storeConfig = new StoreConfig();
        storeConfig.setReadOnly(false);
        storeConfig.setAllowCreate(true);
        storeConfig.setTransactional(true);
        env = new Environment(new File(envHome), myEnvConfig);
		
	}
	
	public Environment getEnv() {
		return env;
	}
	public void setEnv(Environment env) {
		this.env = env;
	}
	public StoreConfig getStoreConfig() {
		return storeConfig;
	}
	public void setStoreConfig(StoreConfig storeConfig) {
		this.storeConfig = storeConfig;
	}
}

2，AbstracStore.java: 数据库io抽象类，增删查改的各个操作的公用方法，提交事务、关闭数据库等。

public abstract class AbstractStore {

	protected final int MAX_RETRY = 5; //  Used for while loop and deadlock retries
	protected EntityStore store;
	//protected Transaction txn;
	
	//放需要commit和clean的Transaction
	ConcurrentHashMap<EntityCursor<? extends Object>, Transaction> cursorTransactionMap 
		= new ConcurrentHashMap<EntityCursor<? extends Object>, Transaction>();
	
	//-----Construction Method------
	public AbstractStore(BDBEnvironment env){
		store = new EntityStore(env.getEnv(), "EntityStore", env.getStoreConfig());
	}
	
	public void clean(){
		store.getEnvironment().cleanLog();
	}
	
	/**
	 * entity cursor used after getEntityCursor() and operations.
	 * 
	 * **/
	public void cursorCommitAndClean(EntityCursor<? extends Object> cursor){
		
		Transaction txn = cursorTransactionMap.get(cursor); //取到txn
		cursorTransactionMap.remove(cursor);
		
		boolean retry = true;
		int retry_count = 0;
    	cursor.close();
    	cursor = null;
        while (retry) {
			try {
				try {

					//txn.commit();
					txn.commit();
					txn = null;
				} catch (DatabaseException e) {
					System.err.println("Error on txn commit: " + e.toString());
				}
				retry = false;
			} catch (LockConflictException de) {
				System.out.println("BDB: Deadlock");
				// retry if necessary
				if (retry_count < MAX_RETRY) {
					retry = true;
					retry_count++;
				} else {
					System.err.println("BDB: Out of retries[commit entityCursor]. Giving up.");
					retry = false;
				}
			} catch (DatabaseException e) {
				retry = false;   // abort and don't retry
				System.err.println("BDB exception: " + e.toString());
				e.printStackTrace();
			} finally {
		        if (cursor != null) {
		            cursor.close();
		        }
				if (txn != null) {
					try {
						txn.abort();
					} catch (Exception e) {
						System.err.println("Error aborting transaction: " + e.toString());
						e.printStackTrace();
					}
				}
			}
		}
	}
	
    // Close the store and environment
    public void close() {
    	System.out.println("close dataBase.");
        if (store != null ) {
            try {
                store.close();
            } catch (DatabaseException e) {
                System.err.println("closeEnv: store: " + e.toString());
                e.printStackTrace();
            }
        }
        if (store.getEnvironment() != null ) {
            try {
            	store.getEnvironment().cleanLog();
            
            	store.getEnvironment().close();
            } catch (DatabaseException e) {
                System.err.println("closeEnv: " + e.toString());
                e.printStackTrace();
            }
        }
    }
	
    public EntityStore getStore() {
		return store;
	}
    public void setStore(EntityStore store) {
		this.store = store;
	}
    
}

上述两个类是基础核心类。


3，CarScore.java: 需要持久化存储的java对象，即POJO类、元数据。

@Entity
public class CarScore {

	@PrimaryKey
	private String carId;
	private String name;  //车型名
	private String model;  //车型code
	
	private Long price;  //车价(按车价差公式计算结果降权即可，不作为硬性索引条件)
	
	@SecondaryKey(relate = Relationship.MANY_TO_ONE) private String brand;   //品牌
	@SecondaryKey(relate = Relationship.MANY_TO_ONE) private String series;  //车系
	private Integer year;  //年限(上牌年份)
	@SecondaryKey(relate = Relationship.MANY_TO_ONE) private String carType;  //车形
	@SecondaryKey(relate = Relationship.MANY_TO_ONE) private String color;	//颜色
	@SecondaryKey(relate = Relationship.MANY_TO_ONE) private String capacity;  //排量
	@SecondaryKey(relate = Relationship.MANY_TO_ONE) private Long miles;   //里程
	@SecondaryKey(relate = Relationship.MANY_TO_ONE) private String geerbox;  //变速箱
	@SecondaryKey(relate = Relationship.MANY_TO_ONE) private String country;  //国别
	
	//
	private String status;  //状态
	private String level;  //车辆等级
	private String upShelfDate;  //第一次上架时间
	private String licenseDate;  //上牌时间
	private Double score;
	
	public CarScore(){}
	
	//getter & setter method....
}


4，CarScoreStore.java: 数据库操作（增删查改）的操作类。需要继承AbstractStore.java

public class CarScoreStore extends AbstractStore {

	public PrimaryIndex<String, CarScore> carScoreById;
	public SecondaryIndex<String, String, CarScore> carScoreByBrand;
	public SecondaryIndex<String, String, CarScore> carScoreBySeries;

	public SecondaryIndex<String, String, CarScore> carScoreByType;
	//public SecondaryIndex<String, String, CarScore> carScoreByYear;
	
	
	//-----Construction Method------
	public CarScoreStore(BDBEnvironment env) {
		
		super(env);
		
		carScoreById = store.getPrimaryIndex(String.class, CarScore.class); ///primary key
    	carScoreByBrand = store.getSecondaryIndex(carScoreById, String.class, "brand");
    	carScoreBySeries = store.getSecondaryIndex(carScoreById, String.class, "series");

    	carScoreByType = store.getSecondaryIndex(carScoreById, String.class, "carType");
    	//carScoreByYear = store.getSecondaryIndex(carScoreById, String.class, "year");
	}

	//-------Operation Method--------

	
	/**
     *  add a record
     * 
     * **/
    public void put(CarScore entity) {

		boolean retry = true;
		int retry_count = 0;
		
        while (retry) {
        	Transaction txn = store.getEnvironment().beginTransaction(null, null);
			carScoreById.put(txn, entity);
			try {
				try {
					txn.commit();
					txn = null;
				} catch (DatabaseException e) {
					System.err.println("Error on txn commit: " + e.toString());
				}
				retry = false;
			} catch (LockConflictException de) {
				System.out.println("BDB: Deadlock");
				
				if (retry_count < MAX_RETRY) {  // retry if necessary
					retry = true;
					retry_count++;
				} else {
					System.err.println("BDB: Out of retries[put]. Giving up.");
					retry = false;
				}
			} catch (DatabaseException e) {
				retry = false;  // abort and don't retry
				System.err.println("BDB exception: " + e.toString());
				e.printStackTrace();
			} finally {
				if (txn != null) {
					try {
						txn.abort();
					} catch (Exception e) {
						System.err.println("Error aborting transaction: " + e.toString());
						e.printStackTrace();
					}
				}
			}
		}
    }
	
	/**
     *  add a record
     * 
     * **/
    public void delete(String carId) {

		boolean retry = true;
		int retry_count = 0;
		
        while (retry) {
        	Transaction txn = store.getEnvironment().beginTransaction(null, null);
			carScoreById.delete(txn, carId);
			try {
				try {
					txn.commit();
					txn = null;
				} catch (DatabaseException e) {
					System.err.println("Error on txn commit: " + e.toString());
				}
				retry = false;
			} catch (LockConflictException de) {
				System.out.println("BDB: Deadlock");
				
				if (retry_count < MAX_RETRY) {  // retry if necessary
					retry = true;
					retry_count++;
				} else {
					System.err.println("BDB: Out of retries[put]. Giving up.");
					retry = false;
				}
			} catch (DatabaseException e) {
				retry = false;  // abort and don't retry
				System.err.println("BDB exception: " + e.toString());
				e.printStackTrace();
			} finally {
				if (txn != null) {
					try {
						txn.abort();
					} catch (Exception e) {
						System.err.println("Error aborting transaction: " + e.toString());
						e.printStackTrace();
					}
				}
			}
		}
    }

    
	/**
	 * search BDBItem by id
	 * 
	 * **/
	public CarScore get(String carId){
		
		boolean retry = true;
		int retry_count = 0;
		TransactionConfig txnConfig = new TransactionConfig();
	    txnConfig.setReadCommitted(true);
	    CarScore carScore = null;
        while (retry) {
        	
        	Transaction txn = store.getEnvironment().beginTransaction(null, txnConfig);
    		carScore = carScoreById.get(txn, carId, LockMode.READ_COMMITTED);
			try {
				try {
					txn.commit();
					txn = null;
				} catch (DatabaseException e) {
					System.err.println("Error on txn commit: " + e.toString());
				}
				retry = false;
			} catch (LockConflictException de) {
				System.out.println("BDB: Deadlock");
				// retry if necessary
				if (retry_count < MAX_RETRY) {
					retry = true;
					retry_count++;
				} else {
					System.err.println("BDB: Out of retries[get]. Giving up.");
					retry = false;
				}
			} catch (DatabaseException e) {
				
				retry = false;   // abort and don't retry
				System.err.println("BDB exception: " + e.toString());
				e.printStackTrace();
			} finally {
				if (txn != null) {
					try {
						txn.abort();
					} catch (Exception e) {
						System.err.println("Error aborting transaction: " + e.toString());
						e.printStackTrace();
					}
				}
			}
		}
		return carScore;
	}
    
	/**
	 * entity cursor
	 * 
	 * **/
	public EntityCursor<CarScore> entityCursorGet(){

		Transaction txn = store.getEnvironment().beginTransaction(null, null);
	    CursorConfig cconfig = new CursorConfig();
	    cconfig.setReadCommitted(true);
	    return carScoreById.entities(txn, cconfig);
	}
	
	/**
	 * key cursor
	 * 
	 * **/
	public EntityCursor<String> keyCursorGet(){

		Transaction txn = store.getEnvironment().beginTransaction(null, null);
	    CursorConfig cconfig = new CursorConfig();
	    cconfig.setReadCommitted(true);
	    
	    //放入map
	    EntityCursor<String> e = carScoreById.keys(txn, cconfig);
	    cursorTransactionMap.put(e, txn);
	    
	    return e;
	}
	
	
	
	/**
	 * 根据brand来找
	 * @param tag
	 * @return
	 */
	public EntityCursor<CarScore> findByBrand(String brand){
		EntityIndex<String, CarScore> e = carScoreByBrand.subIndex(brand);
		Transaction txn = store.getEnvironment().beginTransaction(null, null);
		CursorConfig cconfig = new CursorConfig();
		cconfig.setReadCommitted(true);
		
		//放入map
	    EntityCursor<CarScore> ec = e.entities(txn, cconfig);
	    cursorTransactionMap.put(ec, txn);
		
		return ec;
	}
	
	/**
	 * 根据brand来找
	 * @param tag
	 * @return
	 */
	public EntityCursor<CarScore> findBySeries(String series) {
		EntityIndex<String, CarScore> e = carScoreBySeries.subIndex(series);
		Transaction txn = store.getEnvironment().beginTransaction(null, null);
		CursorConfig cconfig = new CursorConfig();
		cconfig.setReadCommitted(true);
		
		//放入map
	    EntityCursor<CarScore> ec = e.entities(txn, cconfig);
	    cursorTransactionMap.put(ec, txn);
		
		return ec;
	}
	

	
	/**
	 * 取到所有tag
	 * @return
	 */
	public EntityCursor<String> getAllTags() {
		Transaction txn = store.getEnvironment().beginTransaction(null, null);
		CursorConfig cconfig = new CursorConfig();
		cconfig.setReadCommitted(true);
		
		
		//放入map
	    EntityCursor<String> ec = carScoreByBrand.keys(txn, cconfig);
	    cursorTransactionMap.put(ec, txn);
	    
		return ec;
	}

    public long getAllCount(){
    	return carScoreById.count();
    }
    

	//----------------------EntityJoin------------------------
	/**
	 * 统一二级索引查询：join搜索
	 * @param type
	 * @param year
	 * @return
	 */
	public ForwardCursor<CarScore> getJoinEntity(String brand, String series, String type, String year) {
		
		Transaction txn = store.getEnvironment().beginTransaction(null, null);
		CursorConfig cconfig = new CursorConfig();
		cconfig.setReadCommitted(true);
		
		EntityJoin<String, CarScore> join = new EntityJoin<String, CarScore>(carScoreById);
		if(brand != null){
			join.addCondition(carScoreByBrand, brand);
		}
		if(series != null){
			join.addCondition(carScoreBySeries, series);
		}
		if(type != null) {
			join.addCondition(carScoreByType, type);
		}
		
		return join.entities(txn, cconfig);
	}
	
	
}

上述两个类视具体业务而定。

最后，需要在beans/xml中做bean的配置：

	<!-- rec数据 BDB相关包装器 -->
	<bean id="BDBEnvironment" class="BDB.BDBEnvironment" scope="singleton">
		<constructor-arg name="envHome" value="${global.base}${BDBDir.carScore}"/>
		<constructor-arg name="deleteFolderContents" value="true"/>
	</bean>
	<bean id="carScoreStore" class="BDB.CarScoreStore" scope="singleton" destroy-method="close">
		<constructor-arg name="env" ref="BDBEnvironment"/>
	</bean>

在spring的Controller中，我们实际注入的就是carScoreStore。 

@Autowired private CarScoreStore carStore;

1，不涉及游标（Cursor）的普通的查询、删除等，直接调用。

2，涉及游标的方法，需要在调用后显示调用:

<pre name="code" class="java">EntityCursor<CarScore> e = carStore.findByBrand(toBrand);
//......
carStore.cursorCommitAndClean(e);

 

 

暂时写到这。:)
 


 
 


 

                

        

        

    




    

      

        

            

              
                
                  cesul
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
BerkeleyDB_java_jar包

				
			

			

				

					11-23
				

			

		

		

			
				
使用BerkeleyDB数据库，java语言开发需要的jar包资源，7.5.11版本

			
		

	



                

              
                



	

		

			

				
					
Berkeley DB Java Edition (JE)

				
			

			

				

					07-18
				

			

		

		

			
				
Berkeley DB Java Edition (JE) 官方7.5.11下载版本。 相关介绍 https://blog.csdn.net/hadues/article/details/80854288

			
		

	



                


  
              

                


	

		

			

				
					
Java嵌入式数据库berkeleyDB(一)

				
			

			

				

					wwk168的专栏
				

				

					02-03
					
					1036
					
				

			

		

		

			
				
官方主页http://www.oracle.com/technology/software/products/berkeley-db/je/index.html下载地址：http://download.oracle.com/berkeley-db/je-3.3.62.ziphttp://download.oracle.com/berkeley-db/je-3.3.62.tar.gz

			
		

	





	

		

			

				
					
Berkeley DB  增删改查

				
			

			

				

					想吃大盘鸡
				

				

					07-12
					
					2275
					
				

			

		

		

			
				
BerkeleydbDao

			
		

	



		

			
		



	

		

			

				
					
BerkeleyDB初识demo

				
			

			

				

					anzy/pine的博客
				

				

					08-20
					
					698
					
				

			

		

		

			
				
直接上代码，添加jar可直接运行。


package com.anzy.splider.bdb;

import java.io.File;

import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseEntry;
import com.

			
		

	





	

		

			

				
					
4.Think in Berkeley Database Java Edition 之增删改查实战指南

				
			

			

				

					极客星云-CSDN博客
				

				

					07-18
					
					933
					
				

			

		

		

			
				
本篇博文对之前所学做一个总结

			
		

	





	

		

			

				
					
BDB 入门篇 第1章 Berkeley DB Java Edition简介

				
			

			

				

					极客星云-CSDN博客
				

				

					06-26
					
					3277
					
				

			

		

		

			
				
目录



1. Introduction to Berkeley DB Java Edition



1.1 Features(特点)



1.1.1 DPL Features (DPL 特点)



1.1.2 Base API Features (底层API特点)



1.1.3 Which API Should You Use? (你应该使用那种API?)



1.2 The JE...

			
		

	





	

		

			

				
					
Java嵌入式NoSQL数据库之Berkeley DB Java Edition

				
			

			

				

					04-19
				

			

		

		

			
				
NULL 博文链接：https://rensanning.iteye.com/blog/1872481

			
		

	





	

		

			

				
					
Java-Edition-BerkeleyDB-3.1.0.zip_BerkeleyDB

				
			

			

				

					09-21
				

			

		

		

			
				
Java-Edition-BerkeleyDB-3.1.0，国外的开源数据库，供大家参考

			
		

	





	

		

			

				
					
Berkeley DB Java Edition 4.1.10.zip

				
			

			

				

					08-23
				

			

		

		

			
				
Berkeley DB Java Edition (JE)是一个完全用JAVA写的，它适合于管理海量的，简单的数据。    能够高效率的处理1到1百万条记录，制约JE数据库的往往是硬件系统,而不是JE本身。    多线程支持，JE使用超时的方式来处理...

			
		

	





	

		

			

				
					
springboot配置内存数据库H2教程详解

				
			

			

				

					08-30
				

			

		

		

			
				
主要介绍了springboot配置内存数据库H2的详细教程,需要的朋友可以参考下

			
		

	





	

		

			

				
					
Berkeley DB的java版本

				
			

			

				

					01-13
				

			

		

		

			
				
Berkeley DB的java版本.zip

			
		

	





	

		

			

				
					
Berkeley DB Java Edition数据结构的研究与应用.pdf

				
			

			

				

					08-07
				

			

		

		

			
				
#资源达人分享计划#

			
		

	





	

		

			

				
					
BerkeleyDB .je 在作为存储时的简单使用

				
			

			

				

					u012516914的专栏
				

				

					05-23
					
					1115
					
				

			

		

		

			
				
最近在研究BDB时发现速度特别快（菲关系型数据库）下面w

			
		

	





	

		

			

				
					
BDB 事务篇 第5章  备份和还原 Berkeley DB, Java Edition应用程序

				
			

			

				

					极客星云-CSDN博客
				

				

					07-17
					
					1025
					
				

			

		

		

			
				
Backing up and Restoring Berkeley DB, Java Edition Applications （备份和还原Berkeley DB,Java Edition 应用程序）

从根本上说，您通过将JE日志文件复制到安全存储位置来备份数据库。要从备份还原数据库，请将这些文件复制到磁盘上的相应目录，然后重新启动JE应用程序。

请注意，如果您使用子目录存储JE日志文件，则备...

			
		

	





	

		

			

				
					
[转]Berkeley DB 数据库的优缺点

				
			

			

				

					威尔软件
				

				

					07-12
					
					669
					
				

			

		

		

			
				
Berkeley DB 数据库的优缺点来源：http://www.nowboy.com/main/archives/52BDB官方网站：http://www.sleepycat.com/
Sleepycat软件公司出品的Berkeley DB是一种在特定的数据管理应用程序中广泛使用的数据库系统,在世界范围内有超过两亿的用户支持.许多世界知名的厂商,像Amazon, AOL, British Te...

			
		

	





	

		

			

				
					
Berkeley DB Java Edition 使用手册

					
热门推荐

				
			

			

				

					muyannian的专栏
				

				

					08-03
					
					1万+
					
				

			

		

		

			
				
Berkeley DB Java Edition使用说明    头一次看英文文档，翻译的不是十分准确，而且还有错误，还请大家多多谅解。一、             简介       Berkeley DB Java Edition (JE)是一个完全用JAVA写的，它适合于管理海量的，简单的数据。l         能够高效率的处理1到1百万条记录，制约JE数据库的往往是硬件系

			
		

	





	

		

			

				
					
Spring Boot对内嵌数据库的支持

				
			

			

				

					xiaolyuh的专栏
				

				

					07-15
					
					5299
					
				

			

		

		

			
				
开发应用时使用内存数据库是很实用的。很方便的一点是，内存数据库不需要提供持久化存储。 你不需要在应用启动时做初始化数据库动作， 也不需要在应用结束时去删除数据。

Spring Boot可以自动配置的内嵌数据库包括H2,HSQL和Derby。你不需要提供任何连接URLs， 只需要简单的添加你想使用的内嵌数据库依赖。

示例：典型的POM依赖如下：


<dependency>
    ...

			
		

	





	

		

			

				
					
BerkeleyDB java的简单使用

				
			

			

				

					xh199110的专栏
				

				

					10-18
					
					2001
					
				

			

		

		

			
				
关于BerkeleyDB的有点和好处，列在下面

JE offers the following major features:



Large database support. JE databases efficiently scale from one to millions of records. The size of your JE databases are like

			
		

	





	

		

			

				
					
Berkeley DB如何安装

					
最新发布

				
			

			

				

					04-28
				

			

		

		

			
				
Berkeley DB是一个高效的嵌入式数据库，它可以在多个操作系统和编程语言上使用。以下是在Linux系统上安装Berkeley DB的步骤：  1. 下载Berkeley DB的安装包，可以从官方网站上下载：...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值