将Spring Boot集成到独立的现有Spring Jar中

Question

I have problems integrating spring boot into my existing spring project. There are tree questions I have, but before I come to these, let me explain my current architecture:

Current project

I have two projects. The first one is called myProject.toolkit and has only a main class in witch I implemented an endless do-while loop. This loop creates a ProcessBuilder in order to start a new process. And when this process terminates it checks whether or whether not this exit was wanted or not. If so, it terminates. If not, it starts the same process again (not very beautiful, but I am still learning and maybe I have an better idea in the future).
The second project is called myProject.dependencies and this is the program that will be started from the toolkit inside the loop. This is also the real project because the toolkit only has the purpose to monitor over it.

Both projects are maven projects that are compiled to standalone jar files using aspectJ.
myProject.dependencies has sprint boot, hibernate and jpa. Everything is working fine with my MySQL database. I can create Services, that will use Repositories in order to persistant Entities.

For this I created a class called JpaConfig that has all the needed configurations in it because xml files didn't work. It looks shortened like this:

@EnableScheduling
@EnableAsync
@EnableTransactionManagement(mode = AdviceMode.ASPECTJ)
@ComponentScan(basePackages = {"myProject"})
@Configuration
@EnableJpaRepositories
public class JpaConfig { 

    @Bean
    public InstrumentationLoadTimeWeaver loadTimeWeaver(){
        return new InstrumentationLoadTimeWeaver();
    }

    @Bean
    public DataSource dataSource(){
        // creates, configures and returnes a "BoneCPDataSource" Object
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(){
        // creates, configures and returnes a "LocalContainerEntityManagerFactoryBean" Object
    }

    @Bean
    public JpaTransactionManager transactionManager(){
        // creates, configures and returnes a "JpaTransactionManager" Object
    }

}

In my main class of the myProject.dependencies project I call one magic line in order to get spring working:

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(JpaConfig.class);

With this line the configuration gets loaded and I can use hibernate, jpa and spring with all its functionality.

integrating spring boot

Now I want to add spring boot to the project because I need a REST API. And because I read that spring boot can run without a tomcat or glassfish and also within a jar and not a war, I thought this is the perfect architecture for me.

So I read some articles in order to verify this and on the point that I found out spring boot brings an own integrated tomcat, I tried to implement it in my existing project.

I added the following dependencies to my pom.xml :

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>1.4.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId> 
        <artifactId>spring-boot-starter-tomcat</artifactId> 
        <version>1.4.1.RELEASE</version>
        <!--<scope>provided</scope>-->
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
        <version>1.4.1.RELEASE</version>
    </dependency>

And because I could not set a parent pom (I already have a parent set and multiple parents are not possible in maven), I also added this to my pom without understanding it, but since these lines are also in org.springframework.boot:spring-boot-starter-parent:1.4.1.RELEASE and everyone told me to rely on this configuration, I added it:

    <pluginManagement>
        <plugins>
            <!-- Apply more sensible defaults for user projects -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>2.19.1</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>integration-test</goal>
                            <goal>verify</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>${start-class}</mainClass>
                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <includes>
                        <include>**/*Tests.java</include>
                        <include>**/*Test.java</include>
                    </includes>
                    <excludes>
                        <exclude>**/Abstract*.java</exclude>
                    </excludes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                    <archive>
                        <manifest>
                            <mainClass>${start-class}</mainClass>
                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <mainClass>${start-class}</mainClass>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <delimiters>
                        <delimiter>${resource.delimiter}</delimiter>
                    </delimiters>
                    <useDefaultDelimiters>false</useDefaultDelimiters>
                </configuration>
            </plugin>
            <plugin>
                <groupId>pl.project13.maven</groupId>
                <artifactId>git-commit-id-plugin</artifactId>
                <version>2.1.11</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>revision</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <verbose>true</verbose>
                    <dateFormat>yyyy-MM-dd'T'HH:mm:ssZ</dateFormat>
                    <generateGitPropertiesFile>true</generateGitPropertiesFile>
                    <generateGitPropertiesFilename>${project.build.outputDirectory}/git.properties</generateGitPropertiesFilename>
                </configuration>
            </plugin>
            <!-- Support our own plugin -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>1.4.1.RELEASE</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <mainClass>${start-class}</mainClass>
                </configuration>
            </plugin>
            <!-- Support shade packaging (if the user does not want to use our plugin) -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.4.3</version>
                <dependencies>
                    <dependency>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-maven-plugin</artifactId>
                        <version>1.4.0.BUILD-SNAPSHOT</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <keepDependenciesWithProvidedScope>true</keepDependenciesWithProvidedScope>
                    <createDependencyReducedPom>true</createDependencyReducedPom>
                    <filters>
                        <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                                <exclude>META-INF/*.SF</exclude>
                                <exclude>META-INF/*.DSA</exclude>
                                <exclude>META-INF/*.RSA</exclude>
                            </excludes>
                        </filter>
                    </filters>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>META-INF/spring.handlers</resource>
                                </transformer>
                                <transformer implementation="org.springframework.boot.maven.PropertiesMergingResourceTransformer">
                                    <resource>META-INF/spring.factories</resource>
                                </transformer>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>META-INF/spring.schemas</resource>
                                </transformer>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>${start-class}</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </pluginManagement>

1. Do I need all this plugins? And a pluginManagement inside a pom without heredity ... unnecessary? What do I need from it?

After finishing the pom.xml I modified the main class and added a second line to it:

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(JpaConfig.class);
ApplicationContext ctx = SpringApplication.run(SpringBootApp.class, args);

2. There are now two contexts. It can start, yes, but I am not sure if this is useful. I do not want to configure everything twice. So how can I modify my JpaConfig Class in order to also configure spring boot. And going on: how can I modify my two lines in my main class in order to make the configuration only once? Maybe use SpringApplication.run and give it the JpaConfig Class? But the constructor is not allowing this.

3. When I start this current project with all the modifications, independently that maybe hibernate and/or jpa and/or spring annotations are searched and bild twice, I get this error:

   org.springframework.beans.factory.BeanDefinitionStoreException: Failed to process import candidates for configuration class [myProject.dependency.spring.javaOnly.springBoot.SpringBootApp]; nested exception is java.lang.IllegalArgumentException: No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct. // ... Caused by: java.lang.IllegalArgumentException: No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.

I am not quite sure what this is telling me because I created a spring.factories in META-INF and when I compile it, there are even two spring.factories inside the META-INF folder. The one I created myself and one created by the compiler. And regardless of whether I have two or only one spring.factories inside the META-INF folder, the error still is the same.
But maybe this one will fix itself when the other two questions are solved. So thank you so much for your time and patience for this long post and my maybe stupid questions. But I hope you understand that I am still learning and trying my best to improve and these problems are unsolvable for me since a few days. So thanks for any hint or/and help.

Answer 1

My suggestion is integarte your existing spring project to spring boot project as spring boot built with the full spring based infrastructure, especially the auto-configuration.

And

1. Only the spring-boot-maven-plugin plugin is need for the standard spring boot project - doc

2. Do not need AnnotationConfigApplicationContext here, The SpringApplication class provides a convenient way to bootstrap a Spring application that will be started from a main() method. In many situations you can just delegate to the static SpringApplication.run method

   ApplicationContext ctx = SpringApplication.run(SpringBootApp.class, args);

3. Spring boot recommend that you locate your main application class ( SpringBootApp ) in a root package above other classes. Spring boot will apply the @ComponentScan with the default root package here, so it will load your JpaConfig defaultly, and @ComponentScan(basePackages = {"myProject"}) is not necessary here, but this is dependent on the package definition in your project.
4. META-INF/spring.factories is used to register all the auto-configuration classes, if you do not need your customized auto-configurtion class, you can delete this file or just level this file empty.

Good journey.