Develop Reference

Understanding an Axon library's Java Idiom involving Interface method and Lambda expression for configuration of TokenStore

I have a question on Java Syntax on lambda expressions and the java.util.function.Function Object. Also probably Spring Dependency Injection. It is an idiom that I don't know and I hope somebody can explain it to me. I know (probably only the basics) about that idiom of generic#FunctionalInterface(s) and "implementations" through lambda expressions. This use-case seems similar, but still different.
In the example, the Function<T,R>-Object is the Type of a parameter of a method of a configuration class with a parameter name. The argument is the lambda expression config -> tokenStore.
But please look at the information provided below. Here are my questions.
What config is passed as the argument? There is no "config" symbol there. So I guess it is injected by the Spring IoC Container.
And what it obviously returns is the symbol tokenStore that is bound to an org.axonframework.eventhandling.tokenstore.TokenStore Instance created by theJpaTokenStore#build method. There is no connection to the config argument. Or is there?
To sum it up: Just "Why?" Why are you passing a lambda expression where there is no obvious (to me) connection between the argument and the return value and why are you passing a Function-placeholder to an Interface-method - how do you call it... the head of the method? Ultimately: What is that doing because to someone like me who obviously doesn't know the idiom it looks like the answer is: nothing ?
So, there is this example on how to configure a TokenStore from the Axon Framework and I would like to understand how it works:
public class AxonConfig {
// ...
public void registerTokenStore(EventProcessingConfigurer processingConfigurer) {
TokenStore tokenStore = JpaTokenStore.builder()
// …
.build();
processingConfigurer.registerTokenStore(config -> tokenStore);
}
}
source: https://docs.axoniq.io/reference-guide/axon-framework/events/event-processors/streaming#token-store
And here is the source code for the EventProcessingConfigurer#registerTokenStore (GitHub) method.
public interface EventProcessingConfigurer {
// ...
EventProcessingConfigurer registerTokenStore(Function<Configuration, TokenStore> tokenStore);
// ...
}
Incidentally, can I pass in an argument for the code block to tell the forum software which language it is?

Let me provide you some insights here, #vonSpots!
Question 1
The config symbol stands for the input parameter of the Function. You can name it whatever you like. Note the type of the configuration method, which expects a Function<Configuration, TokenStore>. The first generic in there describes the input parameter of the Function, thus a Configuration instance. The second generic describes the return value of the Function, which should be a TokenStore instance.
By using Java's lambda notation of [input] -> [output], ending up with something called config seems feasible given the input type. The component in charge of providing that config instance, is the framework itself.
You can see this within Axon Framework's configuration module. Lastly, it's worthwhile to note that Axon Framework does not necessitate the use of Spring at all. So, setting the config instance is not originating from Spring.
Question 2
In the provided sample, there's no connection between the input and the output. However, Axon Framework defaults to providing the entire Configuration object so that the user is able to retrieve Axon components from it to construct other infrastructure components.
An example of where this would be useful with the JpaTokenStore, is when you need to set the Serializer. Axon Framework will set the Serializer up within the Configuration. Hence, you can retrieve it from Axon's configuration to construct your component.
Question 3
Because Axon Framework does its own wiring of all components. You can integrate it with Spring if you like, but it does not rely on it at all. Thus, in the face of a "pure" Java configuration, you need to have some collecting component, the Configuration, to retrieve everything from. You could almost see it as the Application Context from Spring.
Furthermore, Axon Framework chooses to have users register lambdas instead of concrete objects to ensure components are constructed and wired in the right order.
Axon Framework has many moving components, with objects like the CommandBus, EventProcessors, TokenStores, and DeadlineManager, not forgetting to mention the Message Handling Components users wire into it themselves. By having end users provide a lambda, the framework can decide when to invoke the lambda.
This allows the framework to ensure all required components are in place before a, in your sample, TrackingEventProcessor can utilize the TokenStore.

Design a custom annotation to invoke a method in a jar

I'm a bit new to annotations in Java. Is it possible to design a custom annotation which when used in a class automatically invokes a method present inside another Class. TIA.

The answer is "sort of": annotations by themselves do nothing (except "compile time" annotations that affect the compile process).
Meaning: just attaching an annotation to something doesn't magically cause a method to be called at some arbitrary point in time.
This works differently: you have some sort of framework - and at some point you ask the framework to process an object, class, ... And then the framework might check for the presence of certain annotations to "do" something based on that check.
Thus: it is possible to implement custom annotations, and it is also possible to make some "framework" react to the presence of that annotation.
In case you find this answer too generic - well, it can't be more precise/specific than the question ...

Trying to implement answer (SO) about AOP spring to logging in REST API - some doubts

Firstly I tell that I am newbie at spring (on the whole, also AOP). At this moment I have working rest api.
I am trying to use this thread:
Spring Boot - How to log all requests and responses with exceptions in single place?
I am using spring boot and only annotations configuration. I tried to follow this tutorial, however I have simple problems, I ask you for your help ( I tried to read more about AOP, but I would rather implement concrete example and then try to dig deeper ).
1. <aop:aspectj-autoproxy/> Is it possible to express it using only annotations ?
2.
#Retention(RetentionPolicy.RUNTIME)
#Target({ElementType.METHOD,ElementType.TYPE})
public #interface EnableLogging {
ActionType actionType();
}
Where this fragment should resiude ? I tried to conclude and some place, but no effect.
3. What about turning on Aspect ? What does it mean ? For example, what does it mean this line:
#AfterReturning(pointcut = "execution(#co.xyz.aspect.EnableLogging * *(..)) && #annotation(enableLogging) && args(reqArg, reqArg1,..)", returning = "result")
Thanks in advance, answers to this question should help me get better aop.

Haskell, why don't you ask your question in a comment under the answer you are referring to instead of in a new question? Anyway, as for your questions:
Yes, you can replace <aop:aspectj-autoproxy/> by #EnableAspectJAutoProxy, see Spring AOP manual, chapter 11.2.1.
This "fragment" is not a fragment but a full Java annotation declaration. Maybe you want to learn some Java basics before trying complicated stuff like Spring AOP?
Please read the full Spring AOP chapter in order to get a basic understanding of Spring AOP. As for the AspectJ language as such or the meaning of terms such as joinpoint, pointcut, advice, you should read an AspectJ primer. This code snippet expresses the following:
#AfterReturning: The advice method should always run after an intercepted method specified by the following pointcut has returned without an exception.
pointcut: an expression describing where to weave in the subsequent advice code into your original code.
execution(#co.xyz.aspect.EnableLogging * *(..)): whenever a method annotated by #EnableLogging is executed, no matter how many and which types of parameters and not matter which return type it has.
#annotation(enableLogging) binds the method annotation to an advice parameter so you can easily access it from the advice.
args(reqArg, reqArg1,..) binds the first two parameters of the intercepted method to advice parameters so you can easily access those, too.
returning = "result" binds the intercepted method's return value to another advice parameter so you can easily access that one from the advice as well.

Java annoations

I used a lot annotations in java but I never wrote one. I read though several guides and I am really confused.
They are using annotations like meta information eg names, age etc. That is really confusing because I want to do something different
http://www.developer.com/java/other/article.php/3556176/An-Introduction-to-Java-Annotations.htm
I want to control the function calls.
for example
#Permission(user)
public static void account(){
...
}
So my functions only gets called if the user has the permission, otherwise the user should be redirected to the login page.
I could not find any information, maybe I am using the wrong keyword?
I hope you can clear things up,
Thanks.

You can do that, but with a lot of extra code. Intercepting method calls is part of AOP (aspect oriented programming). You need to make proxies of you target objects, and in the invocation handler parse the annotation.
Luckily, you don't have to do that - since you have a webapp, just use spring/spring-mvc/spring-security. Spring gives you an AOP framework that you can use to define aspects handling your permission logic

Not sure how you can do this by yourself but if you are using Spring they have something that may help
http://static.springsource.org/spring-security/site/docs/3.0.7.RELEASE/reference/el-access.html
I use it my current project and it works well

Something like that should really be done in the function itself (or in some other part of the program). Note that annotations provide data about a program that is not part of the program itself (see this reference).

I think what you are after is an AOP advisor which is run before your method. See here: http://java-questions.com/spring_aop.html
As an alternative to Spring, you could use AspectJ: http://www.andrewewhite.net/wordpress/2010/03/17/aspectj-annotation-tutorial/

Check if the method is invoked

I am trying to create a logging OSGi bundle, which would be able to log input, output, exception (if any) parameters of all the methods which are marked with specific annotation.
I have tried to set up the Spring AOP logging in OSGi but I was unsuccessful.
All I need to know is how to determine when the method is being called? For example I have scanned all methods in a class which are annotated with my annotation and I have those methods in array or list.
For example there are three methods: getStatus, getDetails, getSomething. And the user invokes getDetails method, so how should I know when this method is invoked?

Detecting method calls requires you to instrument your code. If you want to do this at runtime this requires byte-code manipulation (which is what Spring AOP does, as far as I know). Alternatively you could instrument your code at compile-time using a custom preprocessing step that generates the instrumented Java-code, but I don't know if that is much easier.
I guess your best bet is to try and Spring AOP working.