Nutz DAO lazy loading entities associated with the object

Apr 23 posted in Java (RSS), comments.

Advertisements

Previously been using Hibernate, accustomed to the lazy loading of related entities. Recently used Nutz, which did not provide support for lazy loading, and thus be expanded about their own code to support lazy loading Dao. So users do not need to concern for data capture from the dao object associated with a question, call the POPO's getter method can automatically load related entities. The following specific program in order as follows:
1. Define a method called LinkFieldGetterIntercepter interceptor: the getter for the call to POJO automatically load related objects.
2. From the definition of a EntityHolder: reloadEntity entity created when the proxy class, add the definition in Article 1 of the interceptor. And using entity mappings in the cache proxy class in the entity.
3. From the definition of a org.nutz.dao.entity.Borning: easy when the ResultSet into a POJO, POJO to create the proxy class instance, not the original POJO class entity.
4. Since the definition of a EntityMaker: make analytical method entity setBorning (...) is defined in section 3 Borning object.

Here I use JPA as the POJO's annotation, extended the relevant code, if used directly Nutz annotation should be easier to achieve. Method is the same.
1. LinkFieldGetterIntercepter:

public class LinkFieldGetterIntercepter extends AbstractMethodInterceptor {
        private Dao dao;
        private Link link;

        public LinkFieldGetterIntercepter(Dao dao, Link link) {
                this.dao = dao;
                this.link = link;
        }

        public Object afterInvoke(Object obj, Object returnObj, Method method, Object... args) {
                //  You can determine whether to returnObj  null, To determine whether it needs to load the associated entity, after loading the associated entities writeback  obj The associated fields  
                if (link.isOne()) {
......
                } else if (link.isMany()) {

......
                } else if (link.isManyMany()) {

......
                }
                Mirrors.setValue(obj, link.getOwnField().getName(), returnObj);
                return returnObj;
        }
}

2. EntityHolder

public class DemsyEntityHolder {
        private Dao dao;// Dao  Object  
        private EntityMaker maker;
        private Map<Class<?>, Entity<?>> mappings;// <AOP The proxy class, an entity  >
        private Map<Class, Class> agentClassMap;// < The entity classes, AOP proxy class  >

        public DemsyEntityHolder(DemsyNutDao dao) {
                this.dao = dao;
                this.maker = dao.getEntityMaker();
                mappings = new HashMap<Class<?>, Entity<?>>();
                agentClassMap = new HashMap<Class, Class>();
        }

        public <T> Entity<T> getEntity(Class<T> classOfT) {
                //  Converted to AOP proxy class  
                if (!Mirrors.isAgent(classOfT)) {
                        classOfT = agentClassMap.get(classOfT);
                }
                if (classOfT == null) {
                        return null;
                }

                return (Entity<T>) mappings.get(classOfT);
        }

        @SuppressWarnings("unchecked")
        public <T> Entity<T> reloadEntity(Class<T> classOfT, boolean autoCreateTable) {
                JPAEntity<?> entity = (JPAEntity<?>) maker.make(null, null, classOfT);

                //  Cached entity  
                mappings.put(agentClass(entity), entity);

                return (Entity<T>) entity;
        }

        //  Create a proxy class  
        private Class agentClass(JPAEntity entity) {
                Class cls = entity.getType();
                if (Mirrors.isAgent(cls)) {
                        return cls;
                }

                ClassAgent classAgent = new AsmClassAgent();
                List<Link> links = entity.getLinks(null);
                if (links != null) {
                        for (Link link : links) {
                                String fieldName = link.getOwnField().getName();
                                fieldName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                                classAgent.addInterceptor(MethodMatcherFactory.matcher("get" + fieldName),
                                                new LinkFieldGetterIntercepter(dao, link));
                        }
                }
                Class agentClass = classAgent.define(new DefaultClassDefiner(), cls);

                entity.setAgentMirror(Mirror.me(agentClass));

                this.agentClassMap.put(cls, agentClass);

                return agentClass;
        }

        public int count() {
                return mappings.size();
        }
}

3 Borning:

class DemsyBorning implements Borning {
        JPAEntity entity;

        DemsyBorning(JPAEntity entity) {
                this.entity = entity;
        }

        /**
         *  Create an instance of the entity agent  
         * 
         * @return
         * @throws Exception
         */
        public Object create() throws Exception {
                // Create an instance of the proxy class, instead of the original instance of the class  
                return entity.getAgentMirror().born();
        }

        public Object born(ResultSet rs, FieldMatcher fm) throws Exception {
                Object obj = create();
                Iterator<EntityField> it = entity.fields().iterator();
                while (it.hasNext()) {
                        EntityField ef = it.next();
                        if (null == fm || fm.match(ef.getField().getName()))
                                ef.fillValue(obj, rs);
                }
                return obj;
        }
}

4 EntityMaker:

......
public Entity<?> make(DatabaseMeta db, Connection conn, Class<?> type) {
......
                // Borning
                entity.setBorning(new DemsyBorning(entity));
......