Javaのcom.db4oクラス

        <！ - juan_zhai - > 
        <依存> 
            <groupIdを> com.db4o </ groupIdを> 
            <たartifactId> com.db4o </たartifactId> 
            <バージョン> 7.7.67 </バージョン> 
        </依存関係> 
        <依存> 
            <groupIdを> com.db4o </ groupIdを> 
            <たartifactId> com.db4o.nativequery </たartifactId> 
            <バージョン> 7.7.67 </バージョン> 
        </依存関係>

パッケージorg.rx.repository.db4o; 

輸入lombok.Data; 

インポートしたjava.io.Serializable;
輸入java.util.Date;
輸入java.util.UUID; 

@data 
パブリック 抽象 クラス DataObjectの実装Serializableを{
     プライベートUUID ID。
    プライベート日CREATETIME、modifyTime。
    プライベート ブールは、isDeleted。
}

パッケージorg.rx.repository.db4o; 

輸入org.rx.core.dto.common.PagedResponse。
輸入org.rx.core.dto.common.PagingRequest; 

輸入はjava.util.List;
輸入java.util.UUID;
輸入java.util.function.Function。
輸入java.util.function.Predicate; 

パブリック インターフェース IRepository <Tが延びているのDataObject> { 
    T、保存（Tモデル）。

    Tは、（UUID ID）を削除します。

    Tシングル（UUID ID）。

    Tシングル（述語 <T> 状態）

    長い数（述語<T> の条件）。

    リスト<T>リスト（述語<T> 状態）

    <TK>リスト<T>一覧（述語<T>の条件、機能<T、TK> keySelector）; 

    <TK>リスト<T> listDescending（述語<T>条件、機能<T、TK> keySelector）。

    <TK> PagedResponse <T>ページ（述語<T>条件、機能<T、TK> keySelector、PagingRequest pagingParam）。

    <TK> PagedResponse <T> pageDescending（述語<T>条件、機能<T、TK> keySelector、PagingRequest pagingParam）。
}

パッケージorg.rx.repository.db4o.impl; 

輸入com.db4o.Db4o;
輸入com.db4o.ObjectContainer;
輸入com.db4o.ObjectSet;
輸入com.db4o.config.Configuration。
輸入lombok.SneakyThrows。
輸入org.rx.api.dto.common.PagedResponse。
輸入org.rx.api.dto.common.PagingRequest;
輸入org.rx.beans.BeanMapper;
輸入org.rx.beans.DateTime;
輸入org.rx.common.App;
輸入org.rx.common.InvalidOperationException。
輸入org.rx.common.NQuery;
輸入org.rx.repository.db4o.IRepository。
輸入org.rx.repository.db4o.DataObject;
輸入org.springframework.stereotype.Component; 

輸入はjava.util.ArrayList;
輸入はjava.util.Comparator;
輸入はjava.util.List;
輸入java.util.UUID;
輸入java.util.function.Function。
輸入java.util.function.Predicate; 

輸入 静的org.rx.common.Contract.require。

@Component 
パブリック クラス Db4oRepository <T 延びのDataObject> 実装 IRepository <T> {
     プライベート文字列DBPATH。
    プライベートコンフィギュレーションの設定。

    @SneakyThrows 
    パブリックDb4oRepository（）{ 
        DBPATH = App.readSetting（ "app.repository.dbFile" ）。
        もし（DBPATH == nullの）{
             スロー 新しい（ "app.repository.dbFileが空である"と、InvalidOperationExceptionが）。
        } 
        文字列DIR = DBPATH。
        int型私はdir.lastIndexOf（ "/"を= ）。
        もし（！I = -1 ）{ 
            DIR = dir.substring（0 、I）。
        } 
        App.createDirectory（DIR）。

        設定 =Db4o.newConfiguration（）; 
    } 

    保護 <R> R呼び出し（関数<ObjectContainer、R> FUNC）{
         リターン NQuery.of（呼び出し（（機能<ObjectContainer、R> []）新しい機能[] {} FUNC））firstOrDefault（）。
    } 

    保護 同期 <R>リストの<R>を呼び出し（関数<ObjectContainer、R> ... funcList）{ 
        （funcList）を必要とします。

        一覧 <R>結果= 新しい ArrayListを<> （）;
//         ObjectContainer DB = Db4o.openFile（設定、DBPATH）。
        ObjectContainer DB = App.getOrStore（ "Db4oRepository-threadDb"、K - > Db4o.openFile（設定、
        試す{
             ため（ファンクション<ObjectContainer、R> 関数：funcList）{ 
                result.add（function.apply（DB））。
            } 
            db.commit（）。
        } キャッチ（例外e）{ 
            db.rollback（）。
            スロー電子を。
        } 
//         最後に{
 //             db.close（）。
//         } 
        リターン結果; 
    } 

    パブリックTは、{（Tモデル）を保存
        （モデル）を必要とします。
        もし（！（モデルのinstanceof のDataObject））{
             スロー 新しいを例外：IllegalArgumentException（ "モデルがDataObjectのではありません" ）; 
        } 

        戻り > - （DB呼び出し{ 
            T dataObj =シングル（P - > p.getId（）（model.getId（）））に等しい;
             もし！（dataObj = NULL ）{ 
                dataObj = BeanMapper.getInstance（）マップ（モデル、dataObj、BeanMapper.Flags.NonCheckMatch | BeanMapper.Flags.SkipNull）; 
            } 他{ 
                dataObj = モデル; 
            } 
            もし（dataObj.getId（）== NULL ）{ 
                dataObj.setId（UUID.randomUUID（））。
            } 
            であれば（dataObj.getCreateTime（）==NULL ）{ 
                dataObj.setCreateTime（DateTime.now（））。
            } 
            dataObj.setModifyTime（DateTime.now（））。
            db.store（dataObj）。
            返すdataObjを。
        }）; 
    } 

    @Override 
    公共T削除（UUID ID）{ 
        Tモデル = 単一（ID）。
        もし（モデル== NULL ）{
             戻り ヌル。
        } 
        model.setDeleted（真）。
        リターン（モデル）を保存。
    } 

    @Override 
    公衆Tシングル（UUID ID）{
         戻り単一（P - > p.getId（）に等しい（ID））。
    } 

    @Override 
    公共 T単一（述語<T> 条件）{
         リターンNQuery.of（リスト（条件））firstOrDefault（）。
    } 

    @Override 
    公共 長カウント（述語<T> 条件）{
         リターンのExecuteReader（条件、NULL、偽）.count（）; 
    } 

    @Override 
    パブリックリスト<T>リスト（述語<T> 条件）{
         戻りリスト（状態、ヌル）;
    }
 
    @Override 
    公共 <TK>リスト<T>リスト（述語<T>条件、機能<T、TK> keySelector）{
         リターンのExecuteReader（条件、keySelector、偽）.toList（）; 
    } 

    @Override 
    公共 <TK>リスト<T> listDescending（述語<T>条件、機能<T、TK> keySelector）{
         リターンのExecuteReader（条件、keySelector、真）.toList（）; 
    } 

    @Override 
    公共 <TK> PagedResponse <T>ページ（述語<T>条件、機能<T、TK> keySelector、PagingRequest pagingParam）{ 
        （pagingParam）を必要とします。
<T> = NQUERYのExecuteReader（条件、keySelector、偽）。
        リターンpagingParam.page（NQUERY）。
    } 

    @Override 
    公共 <TK> PagedResponse <T> pageDescending（述語<T>条件、機能<T、TK> keySelector、PagingRequest pagingParam）{ 
        （pagingParam）を必要とします。

        NQUERY <T> = NQUERYのExecuteReader（条件、keySelector、真）。
        リターンpagingParam.page（NQUERY）。
    } 

    プライベート <TK> NQUERY <T>のExecuteReader（述語<T>条件、機能<T、TK> keySelector、ブールisDescending）{ 
        （条件）を必要とします。

        com.db4o.query.Predicate <T>述語= 新しい com.db4o.query.Predicate <T> （）{
             パブリック ブールマッチ（T候補）{
                 リターン candidate.isDeleted（）&&！condition.test（候補）。
            } 
        }。
        戻り呼び出し（DB - > { 
            objectSetと <T> objectSetと;
             もし（keySelector == NULL ）{ 
                objectSetと = db.query（述語）; 
            } 他{ 
                コンパレータ <T>コンパレータ=getComparator（keySelector）。
                もし（isDescending）{ 
                    コンパレータ = comparator.reversed（）。
                } 
                objectSetと = db.query（述語、コンパレータ）; 
            } 
            戻りNQuery.of（objectSetとします）。
        }）; 
    } 

    プライベート <TK>比較<T> getComparator（機能<T、TK> keySelector）{
         場合（keySelector == NULL ）{
             リターン（コンパレータ）Comparator.naturalOrder（）; 
        } 

        戻りNQuery.getComparator（keySelector）を、
    } 
}