Changeset 3666

Show
Ignore:
Timestamp:
04/03/08 13:16:08 (4 years ago)
Author:
michael
Message:

Remove context injection and rejig Entity Router? to be a bit more robust + upgrade to Restlet 1.1-M2. Refs #6, spent 6

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/ivy.xml

    r3621 r3666  
    88  </configurations> 
    99  <dependencies> 
    10     <dependency org="org.restlet" name="org.restlet" rev="1.1-SNAPSHOT" conf="compile->default"/> 
    11     <dependency org="com.noelios.restlet" name="com.noelios.restlet.ext.simple" rev="1.1-SNAPSHOT" conf="test->default"/> 
    12     <dependency org="com.noelios.restlet" name="com.noelios.restlet.ext.net" rev="1.1-SNAPSHOT" conf="test->default"/> 
     10    <dependency org="org.restlet" name="org.restlet" rev="1.1-M2" conf="compile->default"/> 
     11    <dependency org="com.noelios.restlet" name="com.noelios.restlet.ext.simple" rev="1.1-M2" conf="test->default"/> 
     12    <dependency org="com.noelios.restlet" name="com.noelios.restlet.ext.net" rev="1.1-M2" conf="test->default"/> 
    1313    <dependency org="javax.persistence" name="persistence-api" rev="1.0" conf="compile->default"/> 
    1414    <dependency org="junit" name="junit" rev="3.8.1" conf="test->default"/> 

  • trunk/src/main/java/org/sarugo/restlet/jpa/EntityFinder.java

    r3640 r3666  
    1717package org.sarugo.restlet.jpa; 
    1818 
     19import java.lang.reflect.Constructor; 
    1920import java.lang.reflect.Field; 
    2021import java.lang.reflect.InvocationTargetException; 
    2122import java.lang.reflect.Method; 
    22 import java.util.ArrayList; 
    2323import java.util.Collections; 
    24 import java.util.List; 
    2524import java.util.Map; 
    2625import java.util.logging.Level; 
    …… 
    2827import javax.persistence.Id; 
    2928 
     29import org.restlet.Finder; 
    3030import org.restlet.Handler; 
    3131import org.restlet.data.Reference; 
    …… 
    4343 *  
    4444 */ 
    45 public class EntityFinder extends ContextInjectingFinder { 
     45public class EntityFinder extends Finder { 
    4646 
    4747    private final Class<? extends Object> entityClass; 
    …… 
    5454 
    5555    private final Method getIdAttributesMethod; 
    56  
    57     private final List<Field> finderFields; 
    5856 
    5957    private String idAttribute; 
    …… 
    7169    @SuppressWarnings("unchecked") 
    7270    public EntityFinder(EntityRouter router, Class<? extends Resource> resource) { 
    73         super(router); 
     71        super(router.getContext(), resource); 
    7472        this.idAttribute = "id"; 
    7573        EntityResource erAnnotation = resource 
    …… 
    9896        } 
    9997        this.getIdAttributesMethod = m; 
    100         this.finderFields = new ArrayList<Field>(); 
    101         setTargetClass(resource); 
    10298    } 
    10399 
    …… 
    105101    protected Handler createTarget(Class<? extends Handler> targetClass, 
    106102            Request request, Response response) { 
    107         Handler handler = super.createTarget(targetClass, request, response); 
    108         if (handler != null) { 
    109             for (Field f : finderFields) { 
    110                 try { 
    111                     f.set(handler, this); 
    112                 } catch (IllegalArgumentException e) { 
    113                     getLogger().log(Level.WARNING, 
    114                             "Error while injecting EntityFinder", e); 
    115                 } catch (IllegalAccessException e) { 
    116                     getLogger().log(Level.WARNING, 
    117                             "Error while injecting EntityFinder", e); 
    118                 } 
    119             } 
     103        Handler handler = null; 
     104        try { 
     105            Constructor<? extends Handler> constructor = targetClass 
     106                    .getConstructor(EntityFinder.class); 
     107            handler = constructor.newInstance(this); 
     108            handler.init(getContext(), request, response); 
     109        } catch (NoSuchMethodException e) { 
     110            // ignore and fall through to default 
     111        } catch (InvocationTargetException e) { 
     112            if (e.getCause() instanceof Error) { 
     113                throw (Error) e.getCause(); 
     114            } else if (e.getCause() instanceof RuntimeException) { 
     115                throw (RuntimeException) e.getCause(); 
     116            } else { 
     117                getLogger().log(Level.WARNING, 
     118                        "Exception while instantiating the target handler.", e); 
     119            } 
     120        } catch (Exception e) { 
     121            getLogger().log(Level.WARNING, 
     122                    "Exception while instantiating the target handler.", e); 
     123        } 
     124        if (handler == null) { 
     125            handler = super.createTarget(targetClass, request, response); 
    120126        } 
    121127        return handler; 
    122     } 
    123  
    124     @Override 
    125     public boolean hasContextFields() { 
    126         return super.hasContextFields() || !finderFields.isEmpty(); 
    127     } 
    128  
    129     @Override 
    130     public void setTargetClass(Class<? extends Handler> targetClass) { 
    131         super.setTargetClass(targetClass); 
    132         finderFields.clear(); 
    133         Class<?> target = targetClass; 
    134         while (target != null) { 
    135             for (Field field : target.getDeclaredFields()) { 
    136                 if (field.isAnnotationPresent(InjectContext.class) 
    137                         && field.getType().isAssignableFrom(EntityFinder.class)) { 
    138                     field.setAccessible(true); 
    139                     finderFields.add(field); 
    140                 } 
    141             } 
    142             target = target.getSuperclass(); 
    143         } 
    144128    } 
    145129 

  • trunk/src/main/java/org/sarugo/restlet/jpa/EntityRouter.java

    r3640 r3666  
    1717package org.sarugo.restlet.jpa; 
    1818 
     19import java.util.ArrayList; 
    1920import java.util.HashMap; 
     21import java.util.List; 
    2022import java.util.Map; 
     23import java.util.logging.Level; 
    2124 
    2225import javax.persistence.EntityManager; 
    2326import javax.persistence.EntityManagerFactory; 
    2427 
    25 import org.restlet.Context; 
    2628import org.restlet.Filter; 
    2729import org.restlet.Restlet; 
    …… 
    3335import org.restlet.data.Response; 
    3436import org.restlet.resource.Resource; 
     37import org.restlet.util.Template; 
    3538 
    3639/** 
    …… 
    4750public class EntityRouter extends Router { 
    4851 
    49     private final EntityManagerFactory entityManagerFactory; 
    50  
    51     private final ThreadLocal<EntityManager> entityManager; 
     52    private class EntityRoute extends Route { 
     53 
     54        private final EntityFinder finder; 
     55 
     56        public EntityRoute(String urlPattern, EntityFinder finder, 
     57                Restlet restlet) { 
     58            super(EntityRouter.this, urlPattern, restlet); 
     59            this.finder = finder; 
     60        } 
     61 
     62        public EntityFinder getFinder() { 
     63            return finder; 
     64        } 
     65 
     66    } 
     67 
     68    private final EntityRouter parent; 
    5269 
    5370    private final Map<Class, EntityRoute> entities; 
    5471 
    55     private final EntityRoute parent; 
     72    private final List<EntityRouter> children; 
    5673 
    5774    private Reference baseRef; 
     75 
     76    private Template defaultRouteTemplate; 
    5877 
    5978    /** 
    …… 
    6887     *            The entity manager factory. 
    6988     */ 
    70     public EntityRouter(Context context, 
    71             EntityManagerFactory entityManagerFactory) { 
    72         super(context); 
    73         this.entityManagerFactory = entityManagerFactory; 
    74         this.entityManager = new ThreadLocal<EntityManager>(); 
     89    EntityRouter(PersistenceApplication application) { 
     90        super(application.getContext()); 
     91        this.parent = null; 
    7592        this.entities = new HashMap<Class, EntityRoute>(); 
    76         this.parent = null; 
     93        this.children = new ArrayList<EntityRouter>(); 
    7794        this.baseRef = null; 
    7895    } 
    7996 
    80     public EntityRouter(EntityRoute parent) { 
     97    public EntityRouter(EntityRouter parent) { 
    8198        super(parent.getContext()); 
    8299        this.parent = parent; 
    83         this.entityManagerFactory = parent.getRouter().entityManagerFactory; 
    84         this.entityManager = parent.getRouter().entityManager; 
    85100        this.entities = new HashMap<Class, EntityRoute>(); 
     101        this.children = new ArrayList<EntityRouter>(); 
    86102        this.baseRef = null; 
    87103    } 
    88104 
    89     public EntityRouter(EntityRouter root) { 
    90         super(root.getContext()); 
    91         this.parent = null; 
    92         this.entityManagerFactory = root.entityManagerFactory; 
    93         this.entityManager = root.entityManager; 
     105    public EntityRouter(EntityRouter parent, Class<? extends Resource> resource) { 
     106        super(parent.getContext()); 
     107        this.parent = parent; 
    94108        this.entities = new HashMap<Class, EntityRoute>(); 
     109        this.children = new ArrayList<EntityRouter>(); 
    95110        this.baseRef = null; 
    96     } 
    97  
    98     /** 
    99      * Get the {@link EntityManagerFactory} associated with this router. 
    100      */ 
    101     public EntityManagerFactory getEntityManagerFactory() { 
    102         return entityManagerFactory; 
    103     } 
    104  
    105     /** 
    106      * Get a thread-local {@link EntityManager}. Typically during request 
    107      * processing an {@link EntityManager} is created and a transaction begun 
    108      * before passing control to an {@link EntityFinder}. During processing 
    109      * (which is always in the same thread), the {@link EntityFinder} can call 
    110      * this method to get the {@link EntityManager} associated with the request. 
    111      * After request processing is complete, the transaction is completed and 
    112      * the {@link EntityManager} closed and cleared from the thread-local. 
    113      */ 
    114     public EntityManager getEntityManager() { 
    115         EntityManager em = entityManager.get(); 
    116         if (em == null) { 
    117             em = getEntityManagerFactory().createEntityManager(); 
    118             entityManager.set(em); 
    119         } 
    120         return em; 
    121     } 
    122  
    123     /** Clears the thread-local {@link EntityManager}. */ 
    124     public void clearEntityManager() { 
    125         entityManager.set(null); 
     111        attachDefault(resource); 
    126112    } 
    127113 
    …… 
    136122    public String getEntityURL(Object entity) { 
    137123        if (isChild()) { 
    138             return getParent().getRouter().getEntityURL(entity); 
     124            return getParent().getEntityURL(entity); 
    139125        } else { 
    140126            return doGetEntityURL(entity); 
    …… 
    151137                Map<String, Object> attributes = route.getFinder() 
    152138                        .getIdAttributes(entity); 
    153                 String entityUrl = route.getTemplate().format(attributes); 
     139                String entityUrl = null; 
     140                // format the entity's URL 
     141                if (route == getDefaultRoute()) { 
     142                    entityUrl = defaultRouteTemplate.format(attributes); 
     143                } else { 
     144                    entityUrl = route.getTemplate().format(attributes); 
     145                } 
     146                // find the parent URL 
     147                String parentUrl = ""; 
    154148                if (isChild()) { 
     149                    // add the router's URL template if we have no default route 
     150                    if (getDefaultRoute() == null) { 
     151                        parentUrl = defaultRouteTemplate.format(attributes); 
     152                    } 
    155153                    @SuppressWarnings("unchecked") 
    156154                    Object parentEntity = route.getFinder().getParentEntity( 
    157155                            entity); 
    158156                    if (parentEntity != null) { 
    159                         String parentUrl = getParent().getRouter() 
    160                                 .doGetEntityURL(parentEntity); 
    161                         if (parentUrl != null) { 
    162                             url = parentUrl + entityUrl; 
     157                        String parentEntityUrl = getParent().doGetEntityURL( 
     158                                parentEntity); 
     159                        if (parentEntityUrl == null) { 
     160                            getLogger() 
     161                                    .log( 
     162                                            Level.SEVERE, 
     163                                            "Misconfigured router - unable to locate URL for parent {0} of entity {1}.", 
     164                                            new Object[] { parentEntity, entity }); 
     165                        } else { 
     166                            parentUrl = parentEntityUrl + parentUrl; 
    163167                        } 
    164                     } 
    165                 } else { 
    166                     if (baseRef != null && entityUrl != null) { 
    167                         url = baseRef.toString(false, false) + entityUrl; 
    168168                    } else { 
    169                         url = entityUrl; 
    170                     } 
    171                 } 
     169                        EntityRouter parent = getParent(); 
     170                        while (parent != null) { 
     171                            if (parent.isChild()) { 
     172                                parentUrl = parent.defaultRouteTemplate 
     173                                        .format(attributes) 
     174                                        + parentUrl; 
     175                            } else if (parent.getBaseRef() != null) { 
     176                                parentUrl = parent.getBaseRef().toString(false, 
     177                                        false) 
     178                                        + parentUrl; 
     179                            } 
     180                            parent = parent.getParent(); 
     181                        } 
     182                    } 
     183                } else if (baseRef != null) { 
     184                    parentUrl = baseRef.toString(false, false); 
     185                } 
     186                url = parentUrl + entityUrl; 
    172187            } else { 
    173188                // otherwise check if our children can map the entity 
    174                 for (EntityRoute parent : entities.values()) { 
    175                     url = parent.getChildRouter().doGetEntityURL(entity); 
     189                for (EntityRouter child : children) { 
     190                    url = child.doGetEntityURL(entity); 
    176191                    if (url != null) { 
    177192                        break; 
    …… 
    205220    public Object getEntity(Request request) { 
    206221        if (isChild()) { 
    207             return getParent().getRouter().getEntity(request); 
     222            return getParent().getEntity(request); 
    208223        } else { 
    209             return doGetEntity(request); 
    210         } 
    211     } 
    212  
    213     private Object doGetEntity(Request request) { 
    214         Object entity = null; 
    215         if (!isChild()) { 
    216224            if (baseRef != null 
    217225                    && request.getResourceRef().toString(true, false) 
    …… 
    219227                request.getResourceRef().setBaseRef(baseRef); 
    220228            } 
    221         } 
     229            return doGetEntity(request); 
     230        } 
     231    } 
     232 
     233    private Object doGetEntity(Request request) { 
     234        Object entity = null; 
    222235        Route next = (Route) getNext(request, new Response(request)); 
    223         if (next != null && next instanceof EntityRoute) { 
    224             EntityRoute route = ((EntityRoute) next); 
    225             String remainingPart = request.getResourceRef().getRemainingPart(); 
    226             int matchedLength = route.getTemplate().parse(remainingPart, 
    227                     request); 
    228             if (matchedLength != -1) { 
    229                 // Update the remaining part 
    230                 String matchedPart = remainingPart.substring(0, matchedLength); 
    231                 Reference baseRef = request.getResourceRef().getBaseRef(); 
    232  
    233                 if (baseRef == null) { 
    234                     baseRef = new Reference(matchedPart); 
    235                 } else { 
    236                     baseRef = new Reference(baseRef.toString(false, false) 
    237                             + matchedPart); 
    238                 } 
    239  
    240                 request.getResourceRef().setBaseRef(baseRef); 
    241  
    242                 entity = route.getChildRouter().doGetEntity(request); 
    243                 if (entity == null) { 
     236        if (next != null) { 
     237            if (next instanceof EntityRoute) { 
     238                // matching route is an entity 
     239                EntityRoute route = ((EntityRoute) next); 
     240                String remainingPart = request.getResourceRef() 
     241                        .getRemainingPart(); 
     242                int matchedLength = route.getTemplate().parse(remainingPart, 
     243                        request); 
     244                if (matchedLength != -1) { 
     245                    // Update the remaining part 
     246                    String matchedPart = remainingPart.substring(0, 
     247                            matchedLength); 
     248                    Reference baseRef = request.getResourceRef().getBaseRef(); 
     249                    if (baseRef == null) { 
     250                        baseRef = new Reference(matchedPart); 
     251                    } else { 
     252                        baseRef = new Reference(baseRef.toString(false, false) 
     253                                + matchedPart); 
     254                    } 
     255                    request.getResourceRef().setBaseRef(baseRef); 
    244256                    entity = route.getFinder().getEntity(request); 
     257                } 
     258            } else { 
     259                // check if matching route is another router 
     260                Restlet target = next.getNext(); 
     261                while (target != null) { 
     262                    if (target instanceof EntityRouter) { 
     263                        break; 
     264                    } else if (target instanceof Filter) { 
     265                        target = ((Filter) target).getNext(); 
     266                    } else { 
     267                        target = null; 
     268                    } 
     269                } 
     270                if (target != null) { 
     271                    String remainingPart = request.getResourceRef() 
     272                            .getRemainingPart(); 
     273                    int matchedLength = next.getTemplate().parse(remainingPart, 
     274                            request); 
     275                    if (matchedLength != -1) { 
     276                        // Update the remaining part 
     277                        String matchedPart = remainingPart.substring(0, 
     278                                matchedLength); 
     279                        Reference baseRef = request.getResourceRef() 
     280                                .getBaseRef(); 
     281                        if (baseRef == null) { 
     282                            baseRef = new Reference(matchedPart); 
     283                        } else { 
     284                            baseRef = new Reference(baseRef.toString(false, 
     285                                    false) 
     286                                    + matchedPart); 
     287                        } 
     288                        request.getResourceRef().setBaseRef(baseRef); 
     289                        entity = ((EntityRouter) target).doGetEntity(request); 
     290                    } 
    245291                } 
    246292            } 
    …… 
    268314            return attach(uriPattern, new EntityFinder(this, targetClass)); 
    269315        } else { 
    270             ContextInjectingFinder finder = new ContextInjectingFinder(this, 
    271                     targetClass); 
    272             if (finder.hasContextFields()) { 
    273                 return attach(uriPattern, finder); 
    274             } else { 
    275                 return super.attach(uriPattern, targetClass); 
    276             } 
     316            return super.attach(uriPattern, targetClass); 
    277317        } 
    278318    } 
    …… 
    284324            if (next instanceof EntityFinder) { 
    285325                EntityFinder finder = (EntityFinder) next; 
    286                 EntityRoute route = new EntityRoute(this, uriPattern, target); 
     326                EntityRoute route = new EntityRoute(uriPattern, finder, target); 
    287327                if (!entities.containsKey(finder.getEntityClass())) { 
    288328                    entities.put(finder.getEntityClass(), route); 
    …… 
    291331                } 
    292332                getRoutes().add(route); 
     333                return route; 
     334            } else if (next instanceof EntityRouter) { 
     335                EntityRouter router = (EntityRouter) next; 
     336                Route route = super.attach(uriPattern, target); 
     337                router.setDefaultRouteTemplate(route.getTemplate()); 
     338                children.add(router); 
    293339                return route; 
    294340            } else if (next instanceof Filter) { 
    …… 
    301347    } 
    302348 
    303     public EntityRoute getParent() { 
     349    @Override 
     350    public final Route attachDefault( 
     351            Class<? extends Resource> defaultTargetClass) { 
     352        if (defaultTargetClass.isAnnotationPresent(EntityResource.class)) { 
     353            return attachDefault(new EntityFinder(this, defaultTargetClass)); 
     354        } else { 
     355            return super.attachDefault(defaultTargetClass); 
     356        } 
     357    } 
     358 
     359    @Override 
     360    public final Route attachDefault(Restlet defaultTarget) { 
     361        Restlet next = defaultTarget; 
     362        while (next != null) { 
     363            if (next instanceof EntityFinder) { 
     364                EntityFinder finder = (EntityFinder) next; 
     365                EntityRoute route = new EntityRoute("", finder, defaultTarget); 
     366                if (!entities.containsKey(finder.getEntityClass())) { 
     367                    entities.put(finder.getEntityClass(), route); 
     368                } 
     369                setDefaultRoute(route); 
     370                return route; 
     371            } else if (next instanceof EntityRouter) { 
     372                children.add((EntityRouter) next); 
     373                return super.attachDefault(defaultTarget); 
     374            } else if (next instanceof Filter) { 
     375                next = ((Filter) next).getNext(); 
     376            } else { 
     377                next = null; 
     378            } 
     379        } 
     380        return super.attachDefault(defaultTarget); 
     381    } 
     382 
     383    public EntityRouter getParent() { 
    304384        return parent; 
    305385    } 
    …… 
    322402    } 
    323403 
     404    public void setDefaultRouteTemplate(Template template) { 
     405        defaultRouteTemplate = template; 
     406        Route route = getDefaultRoute(); 
     407        if (route != null && route instanceof EntityRoute) { 
     408            ((EntityRoute) route).getFinder().setIdAttribute( 
     409                    template.getVariableNames().get(0)); 
     410        } 
     411    } 
     412 
    324413} 

  • trunk/src/main/java/org/sarugo/restlet/jpa/TransactionFilter.java

    r3604 r3666  
    66import javax.persistence.EntityTransaction; 
    77 
     8import org.restlet.Application; 
     9import org.restlet.Context; 
    810import org.restlet.Filter; 
     11import org.restlet.Restlet; 
    912import org.restlet.data.Request; 
    1013import org.restlet.data.Response; 
    …… 
    1215 
    1316/** 
    14  * Provides transation services to an {@link EntityRouter} by: 
     17 * Provides transation services to a {@link PersistenceApplication} by: 
    1518 * <ol> 
    1619 * <li>Creating an {@link EntityManager} and beginning a transaction.</li> 
    17  * <li>Sending the request to the {@link #getNext() next} restlet (by default 
    18  * the {@link EntityRouter}).</li> 
     20 * <li>Sending the request to the {@link #getNext() next} restlet.</li> 
    1921 * <li>Commiting (or rolling-back) the transaction and clearing the 
    2022 * {@link EntityManager}.</li> 
    …… 
    2325public class TransactionFilter extends Filter { 
    2426 
    25     private EntityRouter router; 
     27    public TransactionFilter() { 
     28        super(); 
     29    } 
     30 
     31    public TransactionFilter(Context context) { 
     32        super(context); 
     33    } 
     34 
     35    public TransactionFilter(Context context, Restlet next) { 
     36        super(context, next); 
     37    } 
    2638 
    2739    public TransactionFilter(EntityRouter router) { 
    28         super(router.getContext()); 
    29         this.router = router; 
    30         setNext(router); 
     40        super(router.getContext(), router); 
    3141    } 
    3242 
    3343    @Override 
    34     public void doHandle(Request request, Response response) { 
    35         EntityTransaction t = router.getEntityManager().getTransaction(); 
     44    public int doHandle(Request request, Response response) { 
     45        int result = CONTINUE; 
     46        PersistenceApplication app = (PersistenceApplication) request 
     47                .getAttributes().get(Application.KEY); 
     48        EntityTransaction t = app.getEntityManager().getTransaction(); 
    3649        t.begin(); 
    3750        try { 
    38             super.doHandle(request, response); 
     51            result = super.doHandle(request, response); 
    3952            if (t.isActive() && !t.getRollbackOnly()) { 
    40                 router.getEntityManager().flush(); 
     53                app.getEntityManager().flush(); 
    4154                t.commit(); 
    4255            } 
    …… 
    4962                t.rollback(); 
    5063            } 
    51             router.clearEntityManager(); 
     64            app.clearEntityManager(); 
    5265        } 
     66        return result; 
    5367    } 
    5468 

  • trunk/src/main/java/org/sarugo/restlet/jpa/resource/EntityInstance.java

    r3640 r3666  
    2828import org.sarugo.restlet.jpa.EntityHelper; 
    2929import org.sarugo.restlet.jpa.EntityRouter; 
    30 import org.sarugo.restlet.jpa.InjectContext; 
     30import org.sarugo.restlet.jpa.PersistenceApplication; 
    3131 
    3232/** 
    …… 
    3737public class EntityInstance<E> extends Resource { 
    3838 
    39     @InjectContext 
    40     private EntityRouter router; 
    41      
    42     @InjectContext 
    43     private EntityFinder finder; 
     39    protected E entity; 
    4440 
    45     protected E entity; 
     41    private final EntityFinder finder; 
     42 
     43    public EntityInstance(EntityFinder finder) { 
     44        this.finder = finder; 
     45    } 
    4646 
    4747    /** 
    …… 
    7171        Object id = getId(request.getAttributes()); 
    7272        if (id != null) { 
    73             entity = (E) router.getEntityManager() 
    74                     .find(finder.getEntityClass(), id); 
     73            entity = (E) getEntityManager().find(finder.getEntityClass(), id); 
    7574        } 
    7675    } 
    …… 
    102101    } 
    103102 
     103    /** The {@link PersistenceApplication}. */ 
     104    public final PersistenceApplication getApplication() { 
     105        return (PersistenceApplication) super.getApplication(); 
     106    } 
     107 
    104108    /** The root {@link EntityRouter} that created this resource. */ 
    105109    protected final EntityRouter getRouter() { 
    106         return router; 
     110        return getApplication().getEntityRouter(); 
    107111    } 
    108      
     112 
    109113    /** The {@link EntityFinder} that created this resource. */ 
    110114    protected final EntityFinder getFinder() { 
    …… 
    113117 
    114118    /** 
    115      * Helper that calls {@link EntityRouter#getEntityManager()} on 
    116      * {@link #getRouter()}. 
     119     * Helper that calls {@link PersistenceApplication#getEntityManager()} on 
     120     * {@link #getApplication()}. 
    117121     */ 
    118122    public final EntityManager getEntityManager() { 
    119         return getRouter().getEntityManager(); 
     123        return getApplication().getEntityManager(); 
    120124    } 
    121125 

  • trunk/src/main/java/org/sarugo/restlet/jpa/resource/EntityList.java

    r3639 r3666  
    1414import org.restlet.resource.Resource; 
    1515import org.sarugo.restlet.jpa.EntityRouter; 
    16 import org.sarugo.restlet.jpa.InjectContext; 
     16import org.sarugo.restlet.jpa.PersistenceApplication; 
    1717 
    1818public class EntityList<E> extends Resource { 
    19  
    20     @InjectContext 
    21     private EntityRouter router; 
    2219 
    2320    private String queryName; 
    …… 
    5047            } 
    5148        } 
    52         Query q = getQuery(); 
     49        Query q = getJPAQuery(); 
    5350        if (searchString != null && searchString.length() > 0) { 
    5451            try { 
    …… 
    6764    } 
    6865 
    69     protected Query getQuery() { 
     66    protected Query getJPAQuery() { 
    7067        Query q = null; 
    7168        if (queryName != null && queryName.length() > 0) { 
    …… 
    7976    } 
    8077 
     78    /** The {@link PersistenceApplication}. */ 
     79    public final PersistenceApplication getApplication() { 
     80        return (PersistenceApplication) getApplication(); 
     81    } 
     82 
    8183    /** The root {@link EntityRouter} that created this resource. */ 
    8284    protected final EntityRouter getRouter() { 
    83         return router; 
     85        return getApplication().getEntityRouter(); 
    8486    } 
    8587 
    8688    /** 
    87      * Helper that calls {@link EntityRouter#getEntityManager()} on 
    88      * {@link #getRouter()}. 
     89     * Helper that calls {@link PersistenceApplication#getEntityManager()} on 
     90     * {@link #getApplication()}. 
    8991     */ 
    9092    public final EntityManager getEntityManager() { 
    91         return getRouter().getEntityManager(); 
     93        return getApplication().getEntityManager(); 
    9294    } 
    9395 

  • trunk/src/test/java/org/sarugo/restlet/jpa/URLMappingTests.java

    r3639 r3666  
    55import junit.framework.TestCase; 
    66 
    7 import org.restlet.Context; 
     7import org.restlet.Route; 
    88import org.sarugo.restlet.jpa.resource.EntityInstance; 
    99 
    1010public class URLMappingTests extends TestCase { 
     11 
     12    PersistenceApplication app; 
    1113 
    1214    EntityRouter router; 
    …… 
    1921    public static class FooResource extends EntityInstance<FooEntity> { 
    2022 
     23        public FooResource(EntityFinder finder) { 
     24            super(finder); 
     25        } 
     26 
    2127    } 
    2228 
    2329    @EntityResource(entity = BarEntity.class) 
    2430    public static class BarResource extends EntityInstance<BarEntity> { 
     31 
     32        public BarResource(EntityFinder finder) { 
     33            super(finder); 
     34        } 
    2535 
    2636        public static Object getParentEntity(BarEntity bar) { 
    …… 
    3141 
    3242    protected void setUp() throws Exception { 
    33         router = new EntityRouter(new Context(), Persistence 
     43        app = new PersistenceApplication(Persistence 
    3444                .createEntityManagerFactory("test")); 
    35         EntityRoute fooRoute = (EntityRoute) router.attach("/foo/{fooId}", 
    36                 FooResource.class); 
    37         fooRoute.getChildRouter().attach("/bar/{barId}", BarResource.class); 
     45        router = app.getEntityRouter(); 
     46        EntityRouter testRouter = new EntityRouter(router); 
     47        router.attach("/test", testRouter); 
     48        EntityRouter fooRouter = new EntityRouter(testRouter, FooResource.class); 
     49        testRouter.attach("/foo/{fooId}", fooRouter); 
     50        fooRouter.attach("/bar/{barId}", BarResource.class); 
    3851        foo = new FooEntity(); 
    3952        foo.name = "This is the foo"; 
    …… 
    4154        bar.name = "This is the bar"; 
    4255        bar.foo = foo; 
    43         router.getEntityManager().getTransaction().begin(); 
    44         router.getEntityManager().persist(foo); 
    45         router.getEntityManager().persist(bar); 
    46         router.getEntityManager().flush(); 
    47         router.getEntityManager().getTransaction().commit(); 
    48         router.clearEntityManager(); 
     56        app.getEntityManager().getTransaction().begin(); 
     57        app.getEntityManager().persist(foo); 
     58        app.getEntityManager().persist(bar); 
     59        app.getEntityManager().flush(); 
     60        app.getEntityManager().getTransaction().commit(); 
     61        app.clearEntityManager(); 
    4962    } 
    5063 
    5164    public void testGetEntityURL() { 
    52         assertEquals("/foo/" + foo.id, router.getEntityURL(foo)); 
    53         assertEquals("/foo/" + foo.id + "/bar/" + bar.id, router 
     65        assertEquals("/test/foo/" + foo.id, router.getEntityURL(foo)); 
     66        assertEquals("/test/foo/" + foo.id + "/bar/" + bar.id, router 
    5467                .getEntityURL(bar)); 
    55         EntityRoute barRoute = (EntityRoute) router.attach("/bar/{barId}", 
    56                 BarResource.class); 
     68        Route barRoute = router.attach("/bar/{barId}", BarResource.class); 
    5769        assertEquals("/bar/" + bar.id, router.getEntityURL(bar)); 
    5870        router.attach("/baz/{barId}", barRoute.getNext()); 
    …… 
    6476 
    6577    public void testGetEntity() { 
    66         FooEntity foundFoo = (FooEntity) router.getEntity("/foo/" + foo.id); 
     78        FooEntity foundFoo = (FooEntity) router.getEntity("/test/foo/" + foo.id); 
    6779        assertEquals(foo.id, foundFoo.id); 
    68         foundFoo = (FooEntity) router.getEntity("/foo/" + foo.id + 120485); 
     80        foundFoo = (FooEntity) router.getEntity("/test/foo/" + foo.id + 120485); 
    6981        assertNull(foundFoo); 
    70         foundFoo = (FooEntity) router.getEntity("/fool/" + foo.id); 
     82        foundFoo = (FooEntity) router.getEntity("/test/fool/" + foo.id); 
    7183        assertNull(foundFoo); 
    72         BarEntity foundBar = (BarEntity) router.getEntity("/foo/" + foo.id 
     84        BarEntity foundBar = (BarEntity) router.getEntity("/test/foo/" + foo.id 
    7385                + "/bar/" + bar.id); 
    7486        assertEquals(bar.id, foundBar.id); 
    75         EntityRoute barRoute = (EntityRoute) router.attach("/bar/{barId}", 
    76                 BarResource.class); 
     87        Route barRoute = router.attach("/bar/{barId}", BarResource.class); 
    7788        foundBar = (BarEntity) router.getEntity("/bar/" + bar.id); 
    7889        assertEquals(bar.id, foundBar.id);