1

I'm trying to extend a library that uses generics in entities and entities manager, so I have the following:

public class MyEntity extends ParentEntity extends BaseEntity

and

public class MyEntityManager extends ParentEntityManager extends BaseEntityManager<ParentEntity, ParentEntityDao>

Now my problem is, I'm using another class of the library to update the entity, and the method I need to call expects:

public <ENT extends BaseEntity> void update (Class<ENT> entityClass, BaseEntityManager<ENT> entityManager)

So when I try to call the method with MyEntity and MyEntityManager, it fails because my EntityManager extends from the BaseEntityManager with ParentEntity as parameter, not MyEntity, so they don't match.

I would say that the cleanest way to solve this would be to copy the utility class that has the update method and extend it in my project, but I would like to make it generic so I can pass it EntityManagers that use any children class of ParentEntity, but I've been trying for a while and I cannot find the solution.

I tried changing the method signature to this:

public <ENT extends BaseEntity> void update (Class<ENT> entityClass, BaseEntityManager<? extends ENT> entityManager)

but I'm still getting a compiler exception...

EDIT: Modifying ParentEntityManager, BaseEntityManager or ParentEntity is not possible, since there are too many dependencies to those classes

Improve this question

3 Answers 3

Reset to default
2

Since it doesn't appear you can easily fix the problem I would use a work around. You can use type erasure.

update((Class) MyEntity.class, myEntityManager);

This will compile with a warning. The warning is valid IMHO as your class structure isn't entirely logical ;) You can suppress this warning if you want.

What I do is; the container class returns the type of object it contains/manages.

class BaseEntityManager<E> {
    private final Class<E> typeManaged;
    public Class<E> typeManaged() { return typeManaged; }
}

// remove duplicate class parameter
public <ENT extends BaseEntity> void update (BaseEntityManager<ENT> entityManager)

The manager know what type it manages and the update() method can ask it by calling typeManaged(). This avoid having to give a matching type or for this type to be checked.

The problem you have is that 

MyEntityManager extends BaseEntityManager<ParentEntity>

Which mean the class you have to provide is ParentEntity.class not MyEntity.class.

It appears the real solution is that you need to change

MyEntityManager extends BaseEntityManager<MyEntity>

This would be more logical IMHO and fix your problem.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

I thought of that, the problem is that if MyEntityManager extends from BaseEntityManager<MyEntity> then it wouldn't extend from MyParentEntityManager, so I would have to reimplement all the methods in that class in mine not to lose that functionality. And also having two separate managers that don't extend each other even if the manage an entity and its extended class doesn't seem very clean design to me
If you use an interface EntityManager<Managed> you should have this problem. Interfaces allow multiple inheritance. This is part of the reason it can be better to use interfaces than classes.
See my EDIT for an alternative.
Peter your solution would solve the problem if all the classes were in my project, unfortunately it's a library, so if I cannot modify the BaseEntityManager without modifying all the library's default managers (and there are around 50)
Thanks Peter, that worked! And I agree the structure is not the most appropriate, but being a library I was trying to be the less invasive as possible, so if I change the library don't have to redo a lot.
1

You need to call the update method with ParentEntity.class and a MyEntityManager, e.g.

update(ParentEntity.class, new MyEntityManager());

because your MyEntityManager is a BaseEntityManager<ParentEntity>.

If this is not what you want (because for example update creates new objects of entityClass and you want them to be MyEntity instances), you need to change the signature of the update method and introduce wildcards:

public <ENT extends BaseEntity> void update (Class<? extends ENT> entityClass, BaseEntityManager<ENT> entityManager)

Now you can call it with MyEntity.class and a MyEntityManager.

Improve this answer

6 Comments

Using the first option I get an hibernate exception when it tries to update the object: org.hibernate.WrongClassException: Object with id: null was not of the specified subclass
Copy and change the utility class to modify the update method, then is the entityManager.merge inside which gives me a compilation error: The method merge(capture#3-of ? extends ENT) in the type BaseMdmManager<capture#3-of ? extends ENT> is not applicable for the arguments (ENT)
The message of the hibernate exception suggests that the problem might be something else here: "Object with id: null" seems like that something was null which shouldn't be?
In order to help with the problem with merge and BaseMdmManager, we would need to see the signatures for these classes and methods.
BaseMdmManager is BaseEntityManager, I changed the name in the description to make it clearer. And the merge method, the only thing it does is to call the merge in the dao, which finally is a getEm().merge(entity)
|
0

I think if you look replace the Manager with Container then the problem becomes apparent: MyEntityManager manages all sorts of super ParentEntity classes, while the update method wants one catering specifically to the subclass.

Does the following work for you? It compiles but lint complains

class BaseEntity {} 

class BaseEntityManager<ENT extends BaseEntity> {} 

class ParentEntity extends BaseEntity {}

class ParentEntityManager extends BaseEntityManager<ParentEntity> {} 

class MyEntityManager extends ParentEntityManager { public void update(ParentEntity e) {}} 

class MyEntity extends ParentEntity {}

class XEntityManager<ENT extends ParentEntity> extends BaseEntityManager<ENT>
{
    MyEntityManager _delegate;
    XEntityManager(MyEntityManager m)
    {
        _delegate = m;
    }

    public void update(ENT e)
    {
        _delegate.update(e);
    }
}



class Foo {
    public <ENT extends BaseEntity> void update (Class<ENT> entityClass, BaseEntityManager<ENT> entityManager) {} 

    void bar(MyEntity e, MyEntityManager m)
    {
        update(MyEntity.class, new XEntityManager(m));
    }

}
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.