I want to develop my springboot configuration module.
For example, I want to the behaviors of serialization and deserializion consistent in the Spring ConverterSPI and JsonHttpMessageConverter/XmlHttpMessageConverter.
So,i try to register all converters in Spring ConverterSPI to global configuration JsonHttpMessageConverter/XmlHttpMessageConverter provides.
And decide whether to open by configuration.
For this spring-boot configuration module, I don't want to rely on the spring-boot version.
Otherwise, the actual spring-boot project needs to exclusion the transitive dependencies spring boot when introducing this module.
How to achieve this goal?
Related
I have a Spring Boot RESTful microservice that a customer would like to nest inside their Spring Boot application.
Could someone tell me whether this is possible?
I was hoping this would be as simple as adding a dependency on my application in the customers maven pom file and then excluding the tomcat dependency since the customer already uses the embedded tomcat.
Thanks,
Ben
Since they already use Spring Boot to start their app, you can simply mark all Spring Boot dependencies as provided in your Maven POM, this would exclude it from the JAR as well as embedded Tomcat and all related dependencies. Also make sure you don't build your JAR as a Spring Boot executable (should be the default if you're not using the spring-boot-maven-plugin).
On the customer side, they would need to include your JAR as a dependency, and possibly add a scanBasePackages property to their #SpringBootApplication, to auto-discover your application classes, if they don't reside in a package under the one that #springBootApplication is on. Also, they'll need to be mindful of any URI collisions between your app and theirs, as the two will be sharing the same environment.
I want to create a jar file that I can add to a classpath and will basically "plug-in" to an existing spring boot application. I need it to be able to have annotations of Component, ConfigurationProperties, and all the fun things that spring boot gives you, but I want it "thin" and it will be a jar file used as part of a full spring boot web application.
I need the jar file to be externally configurable. Property files will be different for different deployments. So having a working #Configuration annotation is critical.
I look at spring-boot-starter-parent, and that has jetty, tomcat, hibernate stuff and is a huge jar file. I don't want that.
Is there a "thin" parent?
Is spring boot simply not what I want here? And I should just use a regular spring project and set my "Main" spring boot web app to do component scans to configure the jar file?
It sounds like you are trying to define your own Spring Boot Starter. That's the real power that Spring Boot gives you, the ability to include a dependency and have it auto-configure itself.
By packaging your jar the right way, Spring Boot will detect that there are configurations, components, and property files automatically. I've used this in the past for the case where I want all of my applications to log a specific way, or enforce a certain format for my REST endpoints.
The documentation gives a very thorough overview of the steps you'll need to take. But essentially, you are going to package your jar like any other (with your #Bean, #Component, #Service, and #Configuration classes in it), and provide a property file pointing to the configurations:
// Example spring.factories file
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.mycorp.libx.autoconfigure.LibXAutoConfiguration,\
com.mycorp.libx.autoconfigure.LibXWebAutoConfiguration
Also check out the set of #ConditionalOn... annotations, they can really help with controlling what beans become active based on properties being defined, profiles being active, or dependencies being loaded.
I am trying to make a filedownload endpoint for my ftp server. I see that there is a Spring boot integration starter module for Spring boot but this module doesen't contain classes like DefaultFtpSessionFactory . I've read on the web that there are other modules available like Spring integration http and Spring integration ftp. However, these are not spring boot modules. Is it save to include those modules in my POM anyway? Or shoulden't I use Spring boot starter integration in the first place?
I see in this example: https://blog.pavelsklenar.com/spring-integration-sftp-upload-example/ That the author is using spring boot next to Spring Integration 4.3.8 regular Spring. He does say those are managed by Spring boot but i'm not exactly sure what he means by that.
Can anyone tell me what modules I should include if I want to make the download function? Thanks
Since it's unlikely that an application would require all Spring Integration modules (ftp, sftp, http, mqtt, ... etc), the starter only includes the core and java dsl jars on the classpath (in Spring Integration 5.0, the DSL is built in so boot 2.0 only includes the core jar).
Otherwise, you'd end up with many jars on the classpath that you don't need.
So, yes, you have to manually add the dependencies you need...
<dependency>
<groupId>org.springframework.integration</groupId>
<artifactId>spring-integration-ftp</artifactId>
</dependency>
Note that you don't need a <version/> - boot will manage that for you and bring in the right version corresponding to the core.
The modules themselves will bring in any additional transitive dependencies they need. So you just need to add the top level module(s) to your pom.
I know a way to see XML based configuration dependency graph (Spring Tool Suite) but that does not work for annotations such as #Autowired and application separated in maven modules. Is there any way we can see that at project level or module level?
The beans dependency graph feature in Spring IDE doesn't support non-XML-based Spring definitions.
There is a "live beans graph" feature that visualizes all the beans in a running Spring application. Maybe that helps in your case.
We have a fairly involved web application written using spring-mvc with a maven build system and would like to harness all the power of Grails for the front end.
So the Grails app will essentially call into the spring-mvc app's service layer to access its business logic and data.
I need some guidance with my architectural approach to this integration at a high level.
From my understanding, I will need to;
- add my spring-mvc app as a compile dependency in my BuildConfig.groovy.
- Expose the service layer objects as service beans in my conf/spring/resources.groovy and inject them into my controllers
Questions:
My spring-mvc app has lots of dependencies of its own (which it obviously has to have) which are causing lots of dependency errors. Should I be setting "transitive=false" in my config and calling all of these in my Grails app?
How should the datasource get configured? I guess I have to integrate the applicationContext of my spring-mvc app by calling it from my Grails applicationContext and hope it all bootstraps nicely?
So the Grails app will essentially call into the spring-mvc app's service layer to access its business logic and data
Can you be a bit more specific about which components of the Spring MVC you want to use from Grails, is it just the services and datasource?
I will need to add my spring-mvc app as a compile dependency in my BuildConfig.groovy
yes
Expose the service layer objects as service beans in my conf/spring/resources.groovy
Although you could make the Spring beans known to your Grails app by defining them individually in resources.groovy, this is unnecessary because you've already defined them in an Spring XML file (presumably) in the Spring MVC project.
Instead you can use the importBeans method of the BeanBuilder to import the Spring beans defined in this XML file into the Grails app. Once you've added the Spring MVC project as a dependency of your Grails app, the Spring XML file should be on your classpath, so all you need to do is add the following to resources.groovy
beans = {
importBeans('classpath:/path/to/file/applicationContext-services.xml')
}
How should the datasource get configured?
A Spring bean named dataSource defines the datasource that a Grails app uses. In a standard Grails app, this bean is created based on the configuration in DataSource.groovy. If your Spring MVC app defines a bean with this name, then this should be used instead after making the changes above. To be sure that Grails is using the datasource from your Spring MVC app rather than whatever is in DataSource.groovy, I guess you could delete the contents of the latter.