( en | de | ru )

 

  2. user
  3. @gresch
  4. persistence

bookmarks  24

  •  

    Neo4j is a graph database. It is an embedded, disk-based, fully transactional Java persistence engine that stores data structured in graphs rather than in tables. A graph (mathematical lingo for a network) is a flexible data structure that allows a more agile and rapid style of development. You can think of Neo4j as a high-performance graph engine with all the features of a mature and robust database. The programmer works with an object-oriented, flexible network structure rather than with strict and static tables — yet enjoys all the benefits of a fully transactional, enterprise-strength database. Neo4j is released under a dual free software/commercial license model (which basically means that it’s “open source” but if you’re interested in using it in commercially, then you must buy a commercial license). Neo4j has been in commercial development for 8 years and in production for over 5 years. It is a mature and robust graph database that provides: * an intuitive graph-oriented model for data representation. Instead of static and rigid tables, rows and columns, you work with a flexible graph network consisting of nodes, relationships and properties. * a disk-based, native storage manager completely optimized for storing graph structures for maximum performance and scalability. * massive scalability. Neo4j can handle graphs of several billion nodes/relationships/properties on a single machine and can be sharded to scale out across multiple machines. * a powerful traversal framework for high-speed traversals in the node space. * a small footprint. Neo4j is a single <500k jar with one dependency (the Java Transaction API). * a simple and convenient object-oriented API. * optional layers to expose Neo4j as an RDF store, i.e. easily inject / extract data as RDF, express meta model semantics using OWL and query the node space using SPARQL. When it comes to scalability numbers, remember that several triples are usually mapped to a single node. (currently being developed under the umbrella of the OpenMetadir project)
    15 years ago by @gresch
     
      databasedevelopgraphjavanosqlpersistencesoftware
      (0)
      copydelete
       
       
    •  

      Very interesting approach! "Apache Empire-db is an Open Source relational data persistence component which allows database vendor independent dynamic query definition as well as safe and simple data retrieval and updating. Compared to most other solutions like e.g. Hibernate, TopLink, iBATIS or JPA implementations, Empire-db takes a considerably different approach, with a special focus on compile-time safety, reduced redundancies and improved developer productivity."
      16 years ago by @gresch
       
        hibernatedbsoftwareormpersistencejavaapachedevelopdatabasemetadata
        (0)
        copydelete
         
         
      •  

        Joda-Time provides a complete quality alternative to the JDK date and time classes. At some point however, many projects need to persist these classes to a database. One popular tool for achieving this is Hibernate. To ease the integration of Joda-Time and Hibernate, this sub-project was setup. It aims to provide the classes necessary to persist Joda-Time objects.
        16 years ago by @gresch
         
          calendardatedevelopframeworkshibernatejavapersistencesoftwaretime
          (0)
          copydelete
           
           
        •  

          ***No, no, no - needs HibernateDaoSupport! Bad! *** Another promising GenericDao framework: "Generic DAO (a.k.a generic-dao OR gendao) is a Java package which allows a developer to skip writing DAOs for their persistence objects when they are using Spring and JDBC or Hibernate. It is a lightweight ORM package without the loss of control or increase in complexity which is experienced with some of the heavier weight ORM packages. It is designed to make it easier and faster for developers to write their DAOs without having to rewrite the same old boring save/delete/etc functions over and over for each persistent type but also not having to have implementation dependencies in their DAO interfaces. It also allows for good control over which persistent objects are usable within the DAO and is easy to extend so you can add your own DAO methods. Configuration is easily handled via spring configuration but can also be handled programmatically, however, since the package depends on the spring framework you are best off using it with spring. Generic DAO allows a developer to write their persistent objects as POJOs with no dependencies. It supports an approach between the anemic domain model (or service/manager model) methodology and the use of a rich domain model (or heavy DDD). The use of simple POJOs as persistent objects makes it easy to swap around storage mechanisms while allowing the developer to use their model objects throughout their application and even expose them for use by other applications. The package includes functionality for all the basic ORM CRUD type methods along with search methods and batch methods. The JDBC part of the package includes support for caching all the DAO methods (which could also be used with the hibernate part but hibernate has its own caching so you should probably use that). It also includes interceptor points for before and after all read and write methods. For simpler use cases, you can write your POJOs, make them persistent, create your DDL and not have to write a single line of DAO code. The package is built on and depends on the spring framework."
          16 years ago by @gresch
           
            daodevelopgenerichibernatejavajdbc/orm/jdopersistencesoftwarespring
            (0)
            copydelete
             
             
          •  

            Java toolkit which makes DAO manager creating easier. It produced DAO compatible with JPA specification. It has implemented CRUD operations and some features (active, hidden, default, etc.). It also extends standard API for criteria (like Hibernate ones).
            16 years ago by @gresch
             
              daodevelopgenericgooglehibernatejavapersistencesoftware
              (0)
              copydelete
               
               
            •  

              Hattori is a Java framework that simplifies Data Transfer Object population in n-tier web applications by using Java 5 annotations. The framework is meant to be used at service layer and presentation layer. Given a domain object graph, a DTO object model subset is populated by Hattori which becomes available for modification which will could be later taken to the original domain object graph. Normally, the DTOs are populated at the service layer and sent to the presentation layer for that modification. The population process is done by evaluating each Data Transfer Object annotated with the ObjectPopulation annotation, identifying operations to be executed on each one using one of these options: implicit rules, annotation rules or your own specific per-object defined java code.
              16 years ago by @gresch
               
                annotationsdbdevelopdtojavajava_eepersistencesoftware
                (0)
                copydelete
                 
                 
              •  

                The main motivation for Super Csv is to be the best, fastest and most programmer friendly free CSV package for Java. Super Csv's unique features raises the bar and sets a new standard for CSV packages. Super Csv is designed around solid Object-oriented principles, and thus aims to leverage your Object-oriented code, making it easier to write and maintain. If you are unsure about what the CSV format is, please read my specification which covers my understanding of the concept: The CSV format specification. Super Csv offers the following features not found together in other CSV packages * The ability to read/write POJO beans, Maps and String lists. * Automatic "CSV encoding" of output on a per need basis. Thus when you write special characters such as , or " Super CSV ensure the content is properly escaped (according to my CSV specification). * The ability to easily convert input/output to integers, dates, big decimals, trimming strings, etc... * The ability to easily verify data conforms to some specification, such as number ranges, string sizes, uniqueness and even optional columns. * The ability to read/write data from anywhere in any encoding. As long as you provide a Reader or a Writer. * Support for Windows, MAC and Linux line breaks. * Configurable separation character, space character and end of line character (for writing files to different platforms) * Operates on streams rather than filenames, enabling you to read/write CSV files e.g. over a network connection. * Supporting partial reading and writing of objects, maps and arrays with easy setting of default values. * Supporting on-the-fly generation implementations of bean interfaces when using the BeanReader When combined, these features enables you to express clear and robust code for handling CSV files.
                16 years ago by @gresch
                 
                  csvdevelopframeworksjavapersistencesoftware
                  (0)
                  copydelete
                   
                   
                •  

                  CSVObjects is a free and open source Java based framework for transparently parsing and unmarshalling Comma Separated Value (CSV) files and records into Plain Old Java Objects without the need to code the parsing logic manually. The CSVObjects parsing library relies on declarative mapping of CSV fields and data types to Java Bean attributes, via a mapping XML file. This is similar to the manner in which Hibernate provides a relational table mapping for Java Beans. Also, the framework provides convenience Xdoclet support for specifying the CSV to Java mapping in the Java source code itself by using Javadoc markup, thereby reducing the burden on the developer to manually maintain separate configuration files. The Framework is built upon Stephen Ostermiller's excellent CSV reader/parser classes.
                  16 years ago by @gresch
                   
                    csvdevelopframeworksjavapersistencesoftware
                    (0)
                    copydelete
                     
                     
                  •  

                    The DataNucleus project provides products for the management of application data in a Java environment. Our aim is to provide good quality open source products to handle data in all of its forms, wherever it is stored. This goes from persistence of data into heterogeneous datastores, to providing methods of retrieval using a range of query languages, and eventually on to the analysis of data and tools for managing data quality. Your use of DataNucleus products will mean that you don't need to take significant time in learning the oddities of particular datastores, or query languages and instead use a single common interface for all of your data, and instead your team can concentrate their application development time on adding business logic and let DataNucleus take care of data management issues.
                    16 years ago by @gresch
                     
                      dbdevelopjava_eepersistencesoftware
                      (0)
                      copydelete
                       
                       
                    •  

                      The Eclipse Persistence Services Project (EclipseLink) project's goal is to provide a complete persistence framework that is both comprehensive and universal. It will run in any Java environment and read and write objects to virtually any type of data source, including relational databases, XML, or EIS systems. EclipseLink will focus on providing leading edge support, including advanced feature extensions, for the dominant persistence standards for each target data source; Java Persistence API (JPA) for relational databases, Java Architecture for XML Binding (JAXB) for XML, J2EE Connector Architecture (JCA) for EIS and other types of legacy systems, and Service Data Objects (SDO).
                      17 years ago by @gresch
                       
                        dbdevelopeclipsejavajava_eejpaoracleosgipersistencesdosoftwarespringframework
                        (0)
                        copydelete
                         
                         
                      •  

                        PathProxy is a design pattern for persisting complex relationships without cluttering up your database. In this article JavaWorld contributor Matthew Tyson introduces his PathProxy pattern and walks you through an example application implementation based on Spring, JSF, and JPA/Hibernate.
                        17 years ago by @gresch
                         
                          articledevelophibernatejavajava_eepatternspersistencesoftwarespring
                          (0)
                          copydelete
                           
                           
                        •  

                          The goal of Autofetch is reduce the modularity penalty and programmer burden of specifying associations which should be loaded with an object query. These specifications are sometimes are called fetch profiles, prefetch directives, or joins. These specifications are an important performance optimization because they reduce the number of round-trips to a persistence store whether that be a relational database, object database, or flat file. Autofetch is a library which integrates with object persistence tools and automatically handles prefetching data. Using dynamic program profiling, Autofetch determines the right prefetch directives for each query a program executes.
                          17 years ago by @gresch
                           
                            dbdevelopmenthibernatejavajava_eepersistencesoftware
                            (0)
                            copydelete
                             
                             
                          •  

                            What is Ebean? Ebean is a Object Relational Mapping Persistence Layer written in Java (Open Source LGPL license). * Providing the features of EJB3's JPA (and more) * No container required * JPA compatible ORM mapping (@Entity, @OneToMany, ...) Why use Ebean? Ebean provides a simpler approach to Object Relational Mapping. It does this by not requiring session objects such as JPA EntityManager, JDO PersistenceManager, Hibernate Session, Toplink ClientSession.
                            17 years ago by @gresch
                             
                              dbdevelopejbjavajava_eejpapersistencesoftware
                              (0)
                              copydelete
                               
                               
                            •  

                              As also described in the Hibernate book from King and Bauer: "With the adoption of Java™ 5 generics, the idea of a generic typesafe Data Access Object (DAO) implementation has become feasible. In this article, system architect Per Mellqvist presents a generic DAO implementation class based on Hibernate. He then shows you how to use Spring AOP introductions to add a typesafe interface to the class for query execution."
                              17 years ago by @gresch
                               
                                daodevelopgenericshibernatejavajava_eepatternpersistencesoftwarespringframework
                                (0)
                                copydelete
                                 
                                 
                              •  

                                jLynx is a simple, lite, hi-performance layer over the JDBC API. Persist and retrieve POJO and Map objects directly. Designed for developer productivity. Simpler, easy to learn, easy to configure as compared to Hibernate, JPA, etc. jLynx generates JavaBean objects based on your database schema. For example if you have 24 tables and views in your database, jLynx will create 24 objects with properties that map to the field names in each table. The jLynx Generator creates the objects and compiles them. You can also use the generated source instead if you prefer to customize the objects. Using the API to persist objects is trivial. jLynx Framework implements the Relational interface, which has all necessary methods to persist objects and fetch entire collections of objects. jLynx leverages the strengths of SQL and the strengths of Java without having to write/maintain J2EE code. It is truly the best of both worlds.
                                17 years ago by @gresch
                                 
                                  dbdevelopframeworkjavajdbcpersistenceserversoftwaresql
                                  (0)
                                  copydelete
                                   
                                   
                                •  

                                  HiberObjects is an Eclipse plugin for object oriented design of classes and unit tests for Java Persistence API or Hibernate. PropertyChange support and DTO's for Google Web Toolkit (GWT) can also be generated.
                                  17 years ago by @gresch
                                   
                                    computingdevelopeclipsehibernateidejavapersistencepluginsoftwaretools
                                    (0)
                                    copydelete
                                     
                                     
                                  •  

                                    About XStream XStream is a simple library to serialize objects to XML and back again. Features * Ease of use. A high level facade is supplied that simplifies common use cases. * No mappings required. Most objects can be serialized without need for specifying mappings. * Performance. Speed and low memory footprint are a crucial part of the design, making it suitable for large object graphs or systems with high message throughput. * Clean XML. No information is duplicated that can be obtained via reflection. This results in XML that is easier to read for humans and more compact than native Java serialization. * Requires no modifications to objects. Serializes internal fields, including private and final. Supports non-public and inner classes. Classes are not required to have default constructor. * Full object graph support. Duplicate references encountered in the object-model will be maintained. Supports circular references. * Integrates with other XML APIs. By implementing an interface, XStream can serialize directly to/from any tree structure (not just XML). * Customizable conversion strategies. Strategies can be registered allowing customization of how particular types are represented as XML. * Error messages. When an exception occurs due to malformed XML, detailed diagnostics are provided to help isolate and fix the problem. * Alternative output format. The modular design allows other output formats. XStream ships currently with JSON support and morphing.
                                    18 years ago by @gresch
                                     
                                      codehausframeworkjavapersistencesoftwarexml
                                      (0)
                                      copydelete
                                       
                                       
                                    •  

                                      JPOX is a free and fully compliant implementation of the JDO1, JDO2 specifications, providing transparent persistence of Java objects. It supports persistence to all of the major RDBMS on the market today, persistence to the DB4O object datastore, supporting all of the main Object-Relational Mapping (ORM) patterns demanded by today's applications, allows querying using either JDOQL, SQL, or JPQL, and comes with its own byte-code enhancer. JPOX is available under the Open Source Apache 2 license, allowing access to not just a top quality Java persistence implementation but also to the source code, allowing you to contribute to the success story of the principal standards-compliant Open Source persistence implementation in the world today.
                                      18 years ago by @gresch
                                       
                                        db40javadevelopjdodbframeworkssoftwarepersistence
                                        (0)
                                        copydelete
                                         
                                         
                                      •  

                                        OpenXava is a framework to develop easily business applications with XML and Java. Its virtue resides in the fact that the heart of our applications is XML instead of Java. For example, if you want a J2EE application that works with Teachers you only need
                                        18 years ago by @gresch
                                         
                                          javaweb2.0developframeworksjava_eexmlpersistence
                                          (0)
                                          copydelete
                                           
                                           
                                        •  

                                          Java Bean Library (beanlib) is a utilities library for use with JavaBean. Java Bean Library for Hibernate (beanlib-hibernate) is particularly handy when used with Hibernate. It allows developers to easily reuse the same pojo classes for both persistence i
                                          19 years ago by @gresch
                                           
                                            javadevelopframeworkspersistence
                                            (0)
                                            copydelete
                                             
                                             

                                          publications  

                                            No matching posts.
                                          • ⟨⟨
                                          • ⟨
                                          • ⟩
                                          • ⟩⟩