I wanted to use the Java 8 feature of default methods in interfaces, to automatically set a create and lastModified date in my entities.
I found the tip to implement a method annotated with #PrePersist #PreUpdate and set the values in there.
But the method isn't triggered, when saving an instance of a class implementing the interface.
I tried it by adding another method to the class which called the method in the interface and this worked.
My question now is, if this is intended behavior, that #PrePersist #PreUpdate don't work in interfaces.
Thanks already.
We can read in the documentation of JPA that
/**
* Is used to specify callback methods for the corresponding
* lifecycle event. This annotation may be applied to methods
* of an entity class, a mapped superclass, or a callback
* listener class.
*
* #since Java Persistence 1.0
*/
#Target({METHOD})
#Retention(RUNTIME)
public #interface PrePersist {
}
"of an entity class, a mapped superclass, or a callback" Where interface is none of these.
Interfaces cannot be applied to alter entities structure nor lifecycle. I do not know your specific situation but you might wanna consider Template Method pattern or reconsider your classes' hierachy.
Related
I am following this documentation: https://docs.typo3.org/m/typo3/book-extbasefluid/10.4/en-us/5-Domain/2-implementing-the-domain-model.html
The 'Organization' model defines setters and a method "addContact"
/**
* Adds a contact to the organization
*
* #param Person The contact to be added
* #return void
*/
public function addContact(Person $contact)
{
$this->contacts->attach($contact);
}
I created an extbase model myself, which requires records from an objectstorage. But i figured it out, that I could render records from an objectstorage in fluid, without defining "add{property}" and "set{property} methods. What are the purpose of these methods? When and where are they called?
Setter methods (and adder for ObjectStorages) are not needed by the framework. I'd recommend not adding them if you do not have the use case of setting a value programmatically.
Generally speaking you should not add code that you dont need.
Extbase itself will use reflection to gather and set properties that match database columns.
Setters are for fields that have a representation in the database.
You can add more properties to the models which are i.e. calculated or get the values somewhere else from that don't have setter methods.
Those properties you can access in fluid templates as long as they have also a declaration in the model.
Concerning the method addContact that's one property with probably 4 methods:
getContact (is singular but can have several)
setContact (is singular but can have several)
addContact (adds one contact to the $contact)
removeContact (removes one contact from the $contact)
So this property is still connected / related to the database, just that it's a foreign table as it's foreign model too.
$contact in your case is likely of type \TYPO3\CMS\Extbase\Persistence\ObjectStorage which is like an array iterable but just as object.
I have app wide component (contains only Singletons), which is accesible by static method App.getComponent();. My component contains method void inject(MainActivity activity) and it works fine. I also have void inject(TaskRepo repo), but this one does not work. In TaskRepoImpl() I invoke: App.getComponent().inject(this);, but it does not injects anything. I'm sure that I annotated public members with #Inject.
Injecting with methods like TaskRepo repo = App.getComponent().taskRepo(); works fine. So why does Dagger ignores these members?
In short, you need the method to be void inject(TaskRepoImpl impl); you can't just accept TaskRepo. Your case is described in the Component docs under "A note about covariance".
Dagger is a compile-time framework: at compile time Dagger will take a look at your Component and write implementations based on the methods on your Component (and its Modules). Some of those methods might be members injection methods (same link as above), which are single-arg methods that set #Inject fields and call #Inject methods for the instance you pass in. These are typically void methods named inject, but they can be named anything, and they might also return the instance they inject (for chaining).
The trick is, Dagger can only anticipate the fields and methods on the specific type you define, not its subclasses: if you create a members-injection method void inject(Foo foo), then only Foo's fields and methods count, even if Foo's subclass Bar has #Inject-annotated methods. Even if your Dagger graph knows about both Foo and Bar, it would not know about other Foo subclasses, and would not necessarily be prepared to inject them (because all of that happens at compile time). This is also not a problem for "provision methods" (zero-arg factories/getters on Components) because as long as Dagger knows how to create a particular concrete type for a binding, it can inject that concrete type and simply return the reference as its supertype or interface.
Therefore, switching the injection to the actual implementation class avoids this problem, because Dagger can inspect the implementation class TaskRepoImpl at compile time and ensure it has the bindings that TaskRepoImpl defines in its #Inject-annotated methods and fields.
#Component(modules = {...}) public interface YourComponent {
/**
* Only injects the fields and methods on TaskRepo, which might do
* nothing--especially if TaskRepo is just an interface.
*/
void inject(TaskRepo taskRepo);
/**
* Injects the fields and methods on TaskRepoImpl, TaskRepo, and
* any other superclasses or interfaces.
*/
void inject(TaskRepoImpl taskRepoImpl);
/**
* Gets a TaskRepo implementation. If you've bound TaskRepo to TaskRepoImpl,
* Dagger _can_ inject all of TaskRepoImpl's fields, because it knows at
* compile time that there's a TaskRepoImpl instance to inject.
*/
TaskRepo taskRepo();
}
As a side note, constructor injection allows you to better-encapsulate your classes by using final fields and avoiding partially-constructed (constructed but not injected) instances. I recommend using constructor injection where possible, and recommend strongly against using field injection and constructor injection separately for the same type. (You're probably not doing this other than to debug your case, but I'm leaving the note here for future readers as well.)
I am new to Dagger (version 2.16 on Android) and based on my reading so far, I understand that for a component, there should be a provider (#Provides or #Binds) encapsulated in a module (#Module). Going through a lot of samples, I see code which has some objects which are not offered in any Module, nor are they being instantiated using new.
It is also my understanding that in order to access the dependencies in a module, a consumer class needs to inject itself in the component graph (components usually offer a method to inject classes). The code examples are not doing this either.
Here's some code demonstrating both my concerns. RecipePresenter is not being provided in any module, but still RecipeActivity is using it.
A possible explanation I could think of is that #Inject, in addition to requesting the dependency also adds/injects the requesting class (RecipePresenter in the linked code) into the component graph. But assuming there are multiple components/subcomponents, which component does the class using #Inject constructor gets attached to? If my understanding is correct, why do activities and fragments have to inject themselves manually in the component - shouldn't they be auto-injected if they declare a variable annotated with #Inject?
RecipePresenter has an #Inject-annotated constructor, which allows it to be provided. The #Inject annotation on the recipePresenter field within RecipeActivity does not help, just the #Inject-annotated constructor.
class RecipePresenter #Inject constructor(
private val useCase: RecipeUseCase,
private val res: StringRetriever) :
RecipeUseCase.Callback {
From the Dagger User's Guide:
Use #Inject to annotate the constructor that Dagger should use to create instances of a class. When a new instance is requested, Dagger will obtain the required parameters values and invoke this constructor.
If the class with the #Inject-annotated constructor also has a defined scope, then the binding will only affect components with the same scope annotation: An #ActivityScope class wouldn't be accessible from a #Singleton component, for instance. If the class has no scope defined, then the binding could appear on any and all components where it is needed, which is fine: The implementation is always the same, defined by the constructor itself.
#Inject has different meanings based on what it's annotating:
When you annotate a field with #Inject, it indicates that the DI system should set that field based on values from the DI system when it injects that object.
When you annotate a method with #Inject, it indicates that the DI system should call that method with parameters based on values from the DI system when it injects that object.
When you annotate a constructor with #Inject, it indicates that the DI system is allowed to call that constructor in order to create that object (which triggers the field and method injection above). In that sense it does act like a built-in Provider.
In Dagger specifically, #Provides methods take precedence over #Inject constructors (if they both exist for the same class), and unlike in the JSR-330 spec Dagger requires an #Inject-annotated constructor even when no other constructors are present. From the Dagger User's Guide:
If your class has #Inject-annotated fields but no #Inject-annotated constructor, Dagger will inject those fields if requested, but will not create new instances. Add a no-argument constructor with the #Inject annotation to indicate that Dagger may create instances as well.
Classes that lack #Inject annotations cannot be constructed by Dagger.
Finally, to answer your question about why activities and fragments need to inject themselves: Android is allowed to reflectively create Activity/Fragment/View objects without Dagger's help or participation. This means that nothing triggers the field and method injection described above, until you call a members-injection method on the component that instructs Dagger to populate those fields and call those methods. Consequently, you should never see an #Inject-annotated constructor on Application, Activity, Service, Fragment, View, ContentProvider, and BroadcastReceiver subclasses in Android: Android will ignore the #Inject annotation, so you might as well take control over injection yourself, manually or through dagger.android.
I have a JAX-RS web service that was generated by Netbeans. There are non-abstract facade classes for the service's endpoints. The persistence context is being injected into the non-abstract facade. Everything is working well and I see my data being returned to Fiddler.
We are using DTOs and I am implementing an assembler pattern. So, in the non-abstract facade's constructor, I am creating an instance of the assembler, and am passing the facade's entity manager instance into it. Unfortunately, it seems that the injection of the persistence context has not happened before the facade's constructor has been called, so I cannot pass the entity manager instance into the assembler for its to use in mapping operations. Kind of a chicken-before-the-end situation... I cannot figure out how to make this work... Is there some kind of post-constructor method that I can override and perform the initialization of the assembler and pass in the entity manager to it? I'd really appreciate your help and suggestions.
Thank you for your time and ideas,
Mike
Use method marked with #PostConstruct annotation. Like this:
#PostConstruct
private void init() {
// I'm called after all injections have been resolved
// initialize some object variables here
...
}
In that method you can use both, object fields initialized in the constructor and passed by injection.
I have a class with the following structure.
Is it "legal" in Dagger to #Inject beans in field variables and constructors at the same time, as I have done below? If no - I have a MyActivityModule and MyApplicationModule, how can I get the dependencies from MyApplicationModule and add them to the constructor I use in the provideWhatEvery in the MyActivityModule ?
#Inject SmsFormatter mSmsFormatter;
#Inject SmsGuardiansUtils smsGuardiansUtils;
#Inject BipperMediaPlayer bipperMediaPlayer;
#Inject MixPanelUtils mMixpanelUtils;
#Inject
public ImHereController(View view, Context context, AlarmModel alarmModel, ActionBarListener actionBarListener,
FragmentController fragmentController){
super(view, context, alarmModel, actionBarListener, fragmentController);
}
You can inject fields and constructors as you have. The constructor parameters will be resolved first and injected upon construction, and after that the fields will be injected.
The other parts of your question are unclear - it doesn't matter whether you add dependencies by field injection or constructor injection - if you wanted to add them all with constructor injection you could.
The only time you must use field injection is where you have an object whose instantiation you cannot control, and therefore dagger cannot itself instantiate (like Activity and Application subtypes.)
All that said, I would not use both without some compelling reason - constructor injection is more semantically clear and you can make the instance variables final. Alternately, field injection is more terse, and possibly more readable in cases. I would pick one, and not both.