Hi all,

I have been doing a lot of mental gymnastics lately, trying to wrap my brains 
around Fineract, stitching together a mental big picture by reading the source, 
API doc, log output.

I have learned the basics of Gradle, and Spring Framework. Now I can interpret 
the *.gradle build files which define the high-level logistics. Dependency 
Injection/IoC, and Spring Framework with all its numerous components was 
overwhelming at first, but after reading from Spring Framework Reference[1] I 
feel quite comfortable. You provide the bean definitions to the container and 
it creates those objects and manages their life cycles for you. It took some 
time to understand the subtle differences between @Configuration, @Component, 
@Service, @Repository, @Controller annotations.

[1] 
http://docs.spring.io/spring/docs/4.1.9.RELEASE/spring-framework-reference/htmlsingle/

I have multiple approaches:

I start with reading ServerApplication.java and try to reason about the control 
flow, reading about the Spring annotations that are encountered along the way. 
The startup log output helps in this. ServerApplication @imports 
DataSourceConfiguration (which uses @Autowired JDBCDriverConfig instance) which 
sets up the network connection to the MySQL database.
ServerApplication also @imports EmbeddedTomcatWithSSLConfiguration which sets 
up the embedded Tomcat ServletContainer instance. 
AbstractApplicationConfiguration pulls in all the XML bean definitions. And so 
on..

Another approach is to start with any ApiResource class, say 
ClientsApiResource, and trace the execution which happens in response to each 
of the supported requests.

Listing all the beans:
Pretty much all the classes annotated with @Component, @Service, @Repository, 
and methods annotated with @Bean and definitions in 
(resources/META-INF/spring/) XML files are objects managed by the Spring 
context. They are all the ApiResource's, RepositoryWrapper's, CommandHandler's, 
ServiceImpl's. They get instantiated according to their inter-dependencies.

Spring Security is used for securing the API endpoints with (Oauth/Basic auth) 
authentication.
Flyway updates the schemas of the databases by sequentially applying all the 
SQL scripts in resources/sql/migrations. It was nice to find out such a tool 
exists. This must eliminate lot of headache involved in reproducing and 
debugging bugs connected with evolving database schemas. Each class annotated 
with @Entity in the domain/ directories represents a table in the relational 
database.

We should have a product requirement page for Unified Payment Interface, where 
developers/users who already know UPI can add specific requirements. Should the 
page be created at
https://mifosforge.jira.com/wiki/display/MIFOSX/Product+requirements
or on Confluence wiki?

I was wondering whether Mobile Money Integration or Credit Bureau Integration 
is a similar/related task to UPI integration.

Soon I'll begin working on the UPI Java SDK.

Regards,
Aditya

Reply via email to