you can set 'includeSystemScope' to true.

<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <configuration>
    <includeSystemScope>true</includeSystemScope>
  </configuration>
</plugin>

May be that could help

Copy    <dependency>
        <artifactId>com.google</artifactId>
        <groupId>Ab</groupId>
        <version>0.0.4.3</version>
        <scope>system</scope>
        <systemPath>${basedir}/lib/Ab.jar</systemPath>
    </dependency>

This way you can add any jar file as a maven dependency.

Add below tag in pom.xml. When adding below tag then it will include jars having scope = system.

<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
    <includeSystemScope>true</includeSystemScope>
</configuration>
</plugin>

Firstly you can put this code into pom file which project do you want to inject to another

For example this is DAO ' s pom file

<modelVersion>4.0.0</modelVersion>
<groupId>tr.com.project</groupId>
<artifactId>project-dao</artifactId>
<version>0.0.1-SNAPSHOT</version>

<properties>
    <java.version>1.8</java.version>
    <application.module.version>0.0.1-SNAPSHOT</application.module.version>
</properties>

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.1.1</version>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

And you can access into another project to this DAO You must put this code another project' pom

    <dependency>
        <groupId>tr.com.project</groupId>
        <artifactId>project.dao</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>

It looks like this is possible if the JAR files are copied before starting the Spring application. It feels hackish, but it works. Use at your own risk!

You need two classes, one for bootstrapping the external JARs, which will then start the second via a manually created PropertiesLauncher. The bootstrapping class can be a plain old regular Java class (but it can be a Spring Boot Application too) and only the second class needs to be a SpringBootApplication.

// BootstrapApplication.java
public class BootstrapApplication {
  public static void main(String[] args) {
    System.out.println("Please copy JAR files and press Enter ...");
    System.in.read();

    PropertiesLauncher.main(args);
  }
}

// Application.java
@SpringBootApplication
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

In the gradle file, we can switch back to the default JarLauncher, by removing the bootJar task manifest configuration and applying settings via the springBoot configuration block. mainClass will end up as Start-Class in the MANIFEST.MF file.

// build.gradle
springBoot {
    mainClass = 'com.example.customlauncher.BootstrapApplication'
}

In the properties file for the loader, a new property needs to be set, which points to the real application class. The settings in this file are only picked up by PropertiesLauncher and ignored by JarLauncher. In other words: JarLauncher delegates to Start-Class from the manifest file and PropertiesLauncher delegates to loader.main from its properties file.

# .../resources/loader.properties
loader.path=file:/path/to/dir
loader.main=com.example.customlauncher.Application

Spring (Boot) will first call the main method of BootstrapApplication, as specified in the MANIFEST.MF file (controlled via springBoot configuration block in the build.gradle file). In the implementation of this main method, a new PropertiesLauncher is created with the main class set to the "real" application (i.e. Application).

Executing the application is still done via the same invocation:

java -jar build/libs/customlauncher-0.0.1-SNAPSHOT.jar

Any JAR files added to /path/to/dir after the JVM has started, but before calling PropertiesLauncher#main in BootstrapApplication are then available in the classpath and application context as seen from Application.

Hi for this question that you have asked

so how we can create a common library folder so that all spring boot application shares the same dependencies from one location

In pom.xml add maven-dependency-plugin with goal as copy-dependencies and under this you can set the output directory for the common library folder

Example

<plugin>
    <artifactId>maven-dependency-plugin</artifactId>
        <executions>
            <execution>
                <phase>install</phase>
                <goals>
                    <goal>copy-dependencies</goal>
                </goals>
                <configuration>
                   <outputDirectory>${project.build.directory}/lib</outputDirectory>
                </configuration>
       </execution>
    </executions>
</plugin>

Now you can use the below, to create two jar, one jar with all dependencies(named as appname-exec.jar) included, another jar with only class files (appname.jar)

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <classifier>exec</classifier>
    </configuration>
</plugin>

Now you can use the jar only with class files (appname.jar), because the size will be much lower since it has no dependencies included.

There is one last step needs to be configured in order to work with the jar (appname.jar), is to add the class path entry that is the common location jar and to add your main class name inside tag.

<plugin>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
    <archive>
        <manifest>
            <addClasspath>true</addClasspath>
            <classpathPrefix>lib/</classpathPrefix>
            <mainClass>fully.qualified.MainClass</mainClass>
       </manifest>
    </archive>
   </configuration>
</plugin>

Now you can put these three together in you pom.xml under build section as per you project strucure.

For including a jar from a path into your Spring boot classpath see

External library folder for Spring Boot.

This means that you can safely manage your dependency in your pom by a repo (avoiding sytemPath dependencies).