SpringBoot + Gradle 多模块项目 构建、运行、打包

墨蓝 2022-05-30 12:11 1146阅读 0赞

工具： IDEA

一、在IDEA中使用工具创建SpringBoot + Gradle的父工程

  1.    new -> project -> Spring Initializr  -> type选项选中Gradle Project(其他视情况填写)
  3.    父工程 : demo-springboot-gradle

二、在父工程下新建两个模块 web、dao

  1.    右键单击父工程 new -> module -> Spring Initializr -> type选项选中Gradle Project(其他视情况填写)
  3.    创建module的最后一步要注意，子模块最好在父工程的目录下，避免不必要的麻烦
  5.    ![20180312122211423][]

三、删除dao子模块下的所有.java文件 、 删除父工程src文件

四、在dao子模块下创建两个类，用于测试Student 和 StudentService

  1. public class Student {
  3.     private Integer id;
  4.     private String name;
  6.     public Integer getId() {
  7.         return id;
  8.     }
  10.     public void setId(Integer id) {
  11.         this.id = id;
  12.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  21. }
  23. @Component
  24. public class StudentService {
  26.     public Student query(){
  27.         Student student = new Student();
  28.         student.setId(1);
  29.         student.setName("嘿");
  30.         return student;
  31.     }
  33. }

五、在web子模块下创建一个接口类StudentController

  1. @RestController
  2. public class StudentController {
  4.     @Autowired
  5.     private StudentService studentService;
  7.     @GetMapping("/hello")
  8.     public Student hello(){
  9.         return studentService.query();
  10.     }
  11. }

六、dao子模块的bulid.gradle

  1. group 'com.zeke'
  2. version '1.0-SNAPSHOT'
  4. apply plugin: 'java'
  6. sourceCompatibility = 1.8
  8. repositories {
  9.     mavenCentral()
  10. }
  12. dependencies {
  13.     testCompile group: 'junit', name: 'junit', version: '4.12'
  14. }

七、web子模块的bulid.gradle

  1. buildscript {
  2.     ext {
  3.         springBootVersion = '1.5.3.RELEASE'
  4.     }
  5.     repositories {
  6.         mavenCentral()
  7.     }
  8.     dependencies {
  9.         classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
  10.     }
  11. }
  13. apply plugin: 'java'
  14. apply plugin: 'idea'
  15. apply plugin: 'org.springframework.boot'
  16. apply plugin: 'war'
  18. version = '0.0.1-SNAPSHOT'
  19. sourceCompatibility = 1.8
  21. repositories {
  22.     mavenCentral()
  23. }
  25. configurations {
  26.     providedRuntime
  27. }
  29. dependencies {
  30.     compile('org.springframework.boot:spring-boot-starter-thymeleaf')
  31.     compile('org.springframework.boot:spring-boot-starter-web')
  32. //    providedRuntime('org.springframework.boot:spring-boot-starter-tomcat')
  33.     testCompile('org.springframework.boot:spring-boot-starter-test')
  34. }

八、父工程bulid.gradle

  1. allprojects {
  2.     apply plugin: 'java'
  3.     group 'com.zeke'
  4.     version = '1.0'
  5.     sourceCompatibility = 1.8
  6.     targetCompatibility = 1.8
  7. }
  10. subprojects {
  11.     ext {
  12. //        slf4jVersion = '1.7.7'
  13.         springVersion = '4.3.8.RELEASE'
  14.         hibernateVersion = '4.3.1.Final'
  15.     }
  16.     [compileJava, compileTestJava, javadoc]*.options*.encoding = 'UTF-8'
  17.     repositories {
  18.         mavenCentral()
  19.     }
  20.     configurations {
  21.         //compile.exclude module: 'commons-logging'
  22.         all*.exclude module: 'commons-logging'
  23.     }
  24.     dependencies {
  25.         compile(
  26.                 'redis.clients:jedis:2.9.0',
  27.                 'org.slf4j:slf4j-api:1.7.25',
  28.                 'ch.qos.logback:logback-core:1.1.11',
  29.                 'ch.qos.logback:logback-classic:1.1.11',
  31. //                "org.slf4j:jcl-over-slf4j:${slf4jVersion}",
  32. //                "org.slf4j:slf4j-log4j12:${slf4jVersion}",
  33.                 "org.springframework:spring-context:$springVersion",
  34. //                "org.springframework:spring-orm:$springVersion",
  35. //                "org.springframework:spring-tx:$springVersion",
  36. //                "org.springframework.data:spring-data-jpa:1.5.2.RELEASE",
  37. //                "org.hibernate:hibernate-entitymanager:$hibernateVersion",
  38. //                "c3p0:c3p0:0.9.1.2",
  39.                 "mysql:mysql-connector-java:5.1.35",
  40. //                "commons-fileupload:commons-fileupload:1.3.1",
  41.                 "com.fasterxml.jackson.core:jackson-databind:2.3.1"
  42.         )
  43.         testCompile(
  44.                 "org.springframework:spring-test:$springVersion",
  45.                 "junit:junit:4.12"
  46.         )
  47.     }
  48. }
  50. project(':dao') {
  52. }
  53. project(':web') {
  54.     apply plugin: "war"
  55.     dependencies {
  56.         compile project(":dao")
  57.         compile(
  58.                 'org.springframework.boot:spring-boot-starter-thymeleaf',
  59.                 'org.springframework.boot:spring-boot-starter-web'
  60.         )
  61.         testCompile(
  62.                 'org.springframework.boot:spring-boot-starter-test'
  63.         )
  64. //        providedCompile(
  65. //                "javax.servlet:javax.servlet-api:3.1.0",
  66. //                "javax.servlet.jsp:jsp-api:2.2.1-b03",
  67. //                "javax.servlet.jsp.jstl:javax.servlet.jsp.jstl-api:1.2.1"
  68. //        )
  69.     }
  70.     processResources{
  71.         /* 从'$projectDir/src/main/java'目录下复制文件到'WEB-INF/classes'目录下覆盖原有同名文件*/
  72.         from("$projectDir/src/main/java")
  73.     }
  75.     /*自定义任务用于将当前子项目的java类打成jar包,此jar包不包含resources下的文件*/
  76.     def jarArchiveName="${project.name}-${version}.jar"
  77.     task jarWithoutResources(type: Jar) {
  78.         from sourceSets.main.output.classesDir
  79.         archiveName jarArchiveName
  80.     }
  82.     /*重写war任务:*/
  83.     war {
  84.         dependsOn jarWithoutResources
  85.         /* classpath排除sourceSets.main.output.classesDir目录,加入jarWithoutResources打出来的jar包 */
  86.         classpath = classpath.minus(files(sourceSets.main.output.classesDir)).plus(files("$buildDir/$libsDirName/$jarArchiveName"))
  87.     }
  88.     /*打印编译运行类路径*/
  89.     task jarPath << {
  90.         println configurations.compile.asPath
  91.     }
  92. }
  94. /*从子项目拷贝War任务生成的压缩包到根项目的build/explodedDist目录*/
  95. task explodedDist(type: Copy) {
  96.     into "$buildDir/explodedDist"
  97.     subprojects {
  98.         from tasks.withType(War)
  99.     }
  100. }

九、启动web子模块的application启动类，访问localhost:8080/hello

十、打包：

  1.         在父工程目录下输入命令 gradle build  
  4.    取出 web子模块下 build -> libs -> web-1.0.jar 
  6.     java -jar 执行即可访问

发表评论

表情：
评论列表 （有 0 条评论，1146人围观）

还没有评论，来说两句吧...

相关阅读

    相关 springboot多模块项目打包

    springboot多模块项目打包 今天在项目开发中，项目经理说实现以下APP和web端单独打包功能实现。因为app和web端是单独的modules，这样的话，app的代

    悠悠悠悠/ 0 赞/ 108 阅读