Given a class `Base` Is there a way to run some code before

Question

Given a class `Base` Is there a way to run some code before and after every method call on Base s subclasses

andylamax · Answer

```open class Base fun mustRun inline fun lt T gt withMustRun block gt T mustRun val res = block mustRun return res ``` and then you can now do things like ```class Child Base fun methodOne = withMustRun doStuff here ``` Wrapping every method using `withMustRun` will run `mustRun` before and after your code block

ephemient · Answer

you can t force force every child method to be wrapped

ephemient · Answer

there is another pattern ```open class Base final fun foo println before foo doFoo println after foo protected abstract fun doFoo class Child Base override fun doFoo ``` this prevents unrelated code from invoking `doFoo` directly only `foo` which wraps it

ephemient · Answer

depending on what you are trying to achieve there may be a better way

Stephan Schroeder · Answer

If you execute your program within the Spring framework you could use Aspect oriented programming to achieve this I think I ve only used annotations to target classes but it probably also works for subclasses somehow thinking face I ve used this once in a Kotlin project and it worked as expected <https www baeldung com spring aop advice tutorial>

Stephan Schroeder · Answer

You probably don t need Spring just the AspectJ lib that Spring uses itself <https www eclipse org aspectj > But it might be less convinient I ve never used it directly

ephemient · Answer

aspectj can do something like this although all the subclasses must be known or at least be in a known package otherwise you can t match all the pointcuts

Karlo Lozovina · Answer

thanks guys for the suggestions I ve tried them out but they call kind of fall short of everything I need to do Possibly AOP would work but that s a too big hammer for this usecase I like the approach of < andylamax> but then I m stuck with a single arity functions since there s no way to be polymorphic over the functions arity right Besides that I need the pre post blocks of code to execute without knowing what additional functions will be implemented in the subclasses

Matteo Mirk · Answer

Given your requirements AOP is the right tool for the job What scares you into thinking it s a too big hammer You just need Aspectj for your solution Alternatively you can use <https proxetta jodd org |proxetta> for a simpler code only API

Stephan Schroeder · Answer

no you re not stuck with a single arity since each lambda `withMustRun` will just have access to whatever parameters the invoking functions has without those parameters being explicitly provided to it So ```class SubBase Base fun methodOne a Int = withMustRun doStuff here with a fun methodTwo s1 String s2 String = withMustRun doStuff here with s1 amp s2 ``` will both work But since you you have to use `withMustRun` explicitly anyway I d declare it and `mustRun` top level and not as part of `Base`

Karlo Lozovina · Answer

< Stephan Schroeder> oooooooooohhhh right Silly me can t believe I didn t see that one laughing That might just be the trick I m trying to keep the dependencies and complexity to the absolute minimum here Would love to try out AOP but that ll be for another project