2. 程式人生 > >構建Maven多模組專案+SSM框架整合(一)

構建Maven多模組專案+SSM框架整合(一)

阿新 • • 發佈：2019-01-13
  1. Maven

Apache Maven is a software project management and comprehension tool.
Based on the concept of a project object model (POM), Maven can manage
a project’s build, reporting and documentation from a central piece of
information.

Maven就是一個不需要手動匯入依賴、專案打包和專案構建的工具
Maven中重要的兩個關鍵詞：繼承和聚合

。
繼承：作用就是避免配置重複，對於子專案來說應該關心父專案是怎麼樣配置的。
聚合：字面理解就是“聚在一起合作完成工作”，就是將子模組聚集起來完成相應的專案需求

  1. 為什麼要進行模組化開發？

在多人使用Maven協作開發專案時，尤其是稍微上點規模的專案，每個RD的工作都細分到具體功能和模組，有些模組甚至還要單獨部署。

我們假設有這樣一個商城專案，包括以下幾個模組：

商城前臺（shop）
管理後臺（admin）
資料庫互動模組（dao）
通用業務模組（service）
介面模組（api）
通用工具（util）
其中shop和admin需要單獨部署，dao、service、util你可能想要一些經驗豐富的人來維護，如果使用一個應用來管理的話，所有的功能和模組都會耦合在一起，所有人都可以隨意修改程式碼，這顯然不是我們所期望的。

而且使用一個應用來管理的話，任何一個點的程式碼有變更，整個專案就需要重新build，使用模組化開發的另一個好處是如果dao的程式碼被修改，只需要重新build dao模組就可以了。web模組可以build成war，dao、service、util等可以build成jar，只需要配置好依賴關係，就可以實現模組間的解耦合。這樣的設計才是遵循“高內聚，低耦合”設計原則的。
我們使用上面的例子進行演示，先進行合理的優化，我們希望dao和service作為通用的底層工具來使用，把它們合併成一個核心模組（core），build成core.jar，簡單的Maven模組化專案結構如下：

———- mall //頂級專案
|—— pom.xml //packaging = pom
|—— mall-util //通用工具
| |— pom.xml //packaging = jar
|—— mall-core //核心模組
| |— pom.xml //packaging = jar
|—— mall-web-api //介面模組
| |— pom.xml //packaging = war
|—— mall-web-admin//管理後臺
| |— pom.xml //packaging = war
|—— mall-web-shop//商城前臺
| |— pom.xml //packaging = war
這些模組中api、admin、shop均是可以單獨部署的web應用，相互之間沒有依賴關係，但都依賴於core模組，而core模組依賴於util模組。接下來我們按照上述確定的結構來搭建專案結構。

  1. 建立專案
    使用開發工具STS，其他工具也大同小異
    （1） new -> Maven project 選擇專案放置的地點 和勾選 create a simple project ，命名study
    這裡寫圖片描述
    注意：父專案要使用 pom 方式進行packaging， 有三種 預設是 jar ，還有一種是web專案的war
    這裡寫圖片描述

    （2）父專案建立好之後，開始建立子模組 new 一個 Maven module
    這裡寫圖片描述
    命名為study-dao,parent為 study
    這裡寫圖片描述
    選擇quickstart
    這裡寫圖片描述
    groupID 要和父專案一致，點選finish
    這裡寫圖片描述
    檢視一下study-dao的pom.xml
    這裡寫圖片描述
    檢視一下study的pom.xml
    這裡寫圖片描述

    （3）同上一樣的方式建立 study-service
    只是注意 study-service 模組需要引入 study-dao，在study-service模組的pom.xml 檔案中加上
    spring-context也需要用到，先加上

<dependencies>
        <dependency>
            <groupId>com.study</groupId>
            <artifactId>study-dao</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>

    </dependencies>

（4）建立 study-web 模組同上有一點不同，就是他是webapp ,需要打包成war
這裡寫圖片描述
剛建立的時候會有報錯，不要緊，加上 run server就可以
這裡寫圖片描述
這裡寫圖片描述

看一眼整個專案的目錄結構，整體架子搭建起來了
這裡寫圖片描述

study-web的pom.xml 新增依賴， 整合SSM框架

<?xml version="1.0"?>
<project
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
    xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.study</groupId>
        <artifactId>study</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.study</groupId>
    <artifactId>study-web</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>study-web Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <properties>
        <spring.version>4.3.12.RELEASE</spring.version>
        <servlet.version>3.1.0</servlet.version>
        <commons-codec>1.10</commons-codec>
        <mybatis.version>3.4.4</mybatis.version>
        <mybatis-spring>1.3.0</mybatis-spring>
        <c3p0>0.9.5.2</c3p0>
        <commons-logging>1.1</commons-logging>
        <mysql-connector-java>5.1.41</mysql-connector-java>
        <mybatis-generator-core>1.3.2</mybatis-generator-core>
        <pagehelper>5.0.0</pagehelper>
        <jackson>2.9.0</jackson>
        <jstl>1.2</jstl>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.study</groupId>
            <artifactId>study-dao</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>com.study</groupId>
            <artifactId>study-service</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- MD5加密 -->
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>${commons-codec}</version>
        </dependency>

        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>

        <!-- mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${mybatis-spring}</version>
        </dependency>

        <!-- spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring-tx -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring-orm -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- commons logging -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>${commons-logging}</version>
        </dependency>

        <!-- c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0}</version>
        </dependency>

        <!-- mysql-connector -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connector-java}</version>
        </dependency>

        <!-- mybatis generator -->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>${mybatis-generator-core}</version>
        </dependency>

        <!-- pagehelper -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>${pagehelper}</version>
        </dependency>

        <!-- jackson -->
        <!-- <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> 
            <version>2.8.9</version> </dependency> -->


        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson}</version>
        </dependency>



        <!-- jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl}</version>
        </dependency>


        <!-- jsp api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>
    <build>
        <finalName>study-web</finalName>
    </build>
</project>

（5）study-web 的web.xml 的配置

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!-- 以下3項引數與log4j的配置相關 -->  

    <context-param>  
        <param-name>log4jConfigLocation</param-name>  
        <param-value>classpath:log4j.properties</param-value>  
    </context-param>  

    <context-param>  
        <param-name>log4jRefreshInterval</param-name>  
        <param-value>60000</param-value>  
    </context-param>  
    <listener>  
        <listener-class>  
            org.springframework.web.util.Log4jConfigListener  
        </listener-class>  
    </listener>  
<!-- end -->  

<!--    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener> -->

    <!-- SpringMVC -->
    <servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml;classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

</web-app>

log4j.properties的配置

log4j.rootLogger=INFO,Console,File  
#\u5B9A\u4E49\u65E5\u5FD7\u8F93\u51FA\u76EE\u7684\u5730\u4E3A\u63A7\u5236\u53F0  
log4j.appender.Console=org.apache.log4j.ConsoleAppender  
log4j.appender.Console.Target=System.out  
#\u53EF\u4EE5\u7075\u6D3B\u5730\u6307\u5B9A\u65E5\u5FD7\u8F93\u51FA\u683C\u5F0F\uFF0C\u4E0B\u9762\u4E00\u884C\u662F\u6307\u5B9A\u5177\u4F53\u7684\u683C\u5F0F  
log4j.appender.Console.layout = org.apache.log4j.PatternLayout  
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n  

#\u6587\u4EF6\u5927\u5C0F\u5230\u8FBE\u6307\u5B9A\u5C3A\u5BF8\u7684\u65F6\u5019\u4EA7\u751F\u4E00\u4E2A\u65B0\u7684\u6587\u4EF6  
log4j.appender.File = org.apache.log4j.RollingFileAppender  
#\u6307\u5B9A\u8F93\u51FA\u76EE\u5F55  
log4j.appender.File.File = logs/study.log  
#\u5B9A\u4E49\u6587\u4EF6\u6700\u5927\u5927\u5C0F  
log4j.appender.File.MaxFileSize = 10MB  
# \u8F93\u51FA\u6240\u4EE5\u65E5\u5FD7\uFF0C\u5982\u679C\u6362\u6210DEBUG\u8868\u793A\u8F93\u51FADEBUG\u4EE5\u4E0A\u7EA7\u522B\u65E5\u5FD7  
log4j.appender.File.Threshold = ALL  
log4j.appender.File.layout = org.apache.log4j.PatternLayout  
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

     <mvc:annotation-driven/>
    <!-- 載入配置檔案 -->
    <context:property-placeholder location="classpath:mysql.properties" />

    <!-- 配置c3p0資料來源 -->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <property name="driverClass" value="${driverClass}"></property>
        <property name="jdbcUrl" value="${url}"></property>
        <property name="user" value="${user}"></property>
        <property name="password" value="${password}"></property>
    </bean>

    <!-- sqlSessionFactory -->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis.xml"></property>
        <property name="mapperLocations" value="classpath:com/study/demo/mapping/*.xml"></property>
    </bean>

    <!-- mapper掃描 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        <property name="basePackage" value="com.study.demo.dao"></property>
    </bean>

    <!-- 事務配置 -->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
       <property name="dataSource" ref="dataSource"></property>
    </bean>

    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
                        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd    
                        http://www.springframework.org/schema/context    
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd    
                        http://www.springframework.org/schema/mvc    
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd ">


    <!--避免IE執行AJAX時，返回JSON出現下載檔案 -->
    <bean id="mappingJacksonHttpMessageConverter"
        class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>text/html;charset=UTF-8</value>
            </list>
        </property>
    </bean>
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean
                class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"
                p:supportedMediaTypes="*/*" />
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!-- 啟動SpringMVC的註解功能，完成請求和註解POJO的對映 -->
    <bean
        class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJacksonHttpMessageConverter" /> <!-- JSON轉換器 -->
            </list>
        </property>
    </bean>


    <!-- 過濾靜態資源訪問 -->
    <mvc:resources mapping="/resources/**" location="/resources/" />

    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 自行新增的 -->
        <property name="viewClass"
            value="org.springframework.web.servlet.view.JstlView" />
        <!-- 這裡的配置我的理解是自動給後面action的方法return的字串加上字首和字尾，變成一個 可用的url地址 -->
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <!-- 配置檔案上傳，如果沒有使用檔案上傳可以不用配置，當然如果不配，那麼配置檔案中也不必引入上傳元件包 resolveLazily屬性啟用是為了推遲檔案解析，以便捕獲檔案大小異常 -->
    <!-- <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> 
        預設編碼 <property name="defaultEncoding" value="utf-8" /> 檔案大小最大值 <property 
        name="maxUploadSize" value="10485760000" /> 記憶體中的最大值 <property name="maxInMemorySize" 
        value="40960" /> resolveLazily屬性啟用是為了推遲檔案解析，以便捕獲檔案大小異常 <property name="resolveLazily" 
        value="true" /> </bean> -->

    <!--啟用最新的註解器、對映器 -->
    <mvc:annotation-driven />
    <context:component-scan base-package="com.study.demo.dao" />
    <!--掃描Service註解類 -->
    <context:component-scan base-package="com.study.demo.service.impl" />

    <!-- 自動掃描該包，使SpringMVC認為包下用了@controller註解的類是控制器 -->
    <context:component-scan base-package="com.web.controller" />


    <!--啟動對AspectJ註解的支援，proxy-target-class等於true是強制使用cglib代理 -->
    <aop:aspectj-autoproxy proxy-target-class="true" />
    <context:annotation-config />


</beans>

mysql.properties

driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&amp;characterEncoding=utf-8
user=root
password=123456

mybatis.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
 PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="lazyLoadingEnabled" value="true" />
    </settings>

</configuration>

（5）實現一個簡單邏輯，使專案能執行起來
study-dao 模組 單表的簡單CRUD，不多說
這裡寫圖片描述

study-service 模組 實現邏輯部分
這裡寫圖片描述

study-web 模組，寫一個Controller，測試下
這裡寫圖片描述

ok,都寫完了，我們就可以開始執行 study-web專案了，同平常執行非模組的的專案一樣，右擊study-web專案名，選擇run as -> run on server， 選擇Tomcat，開始執行
隨後訪問http://localhost:8080/study-web/aa，得到預期結果
這裡寫圖片描述

相關推薦

構建Maven多模組專案+SSM框架整合(一)

Maven Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model

Spring MVC 學習總結（十一）——IDEA+Maven+多模組實現SSM框架整合

一、SSM概要 與SSH（Struts/Spring/Hibernate/）一樣，Spring+SpringMVC+MyBatis也有一個簡稱SSM，Spring實現業務物件管理，Spring MVC負責請求的轉發和檢視管理, MyBatis作為資料物件持久化引擎。這樣搭配的優點是：輕量、自由度高、Spri

Springboot整合dubbo構建maven多模組專案（四）

在中，我們配置了一個dubbo專案，包含三個模組springboot-dubbo-api、springboot-dubbo-server和springboot-dubbo-client，並且在springboot-dubbo-server和springboot-dubbo-c

Springboot整合dubbo構建maven多模組專案（一）- 專案建立和pom.xml中jar包配置

       以前一直用Spring作為容器構建專案，但是看到Spring官網一直在推Springboot，最重要的是Springboot確實避免自己尋找多個jar包（大多數情況下，可能自己都不記得該引入哪些jar包）和jar包之間衝突的問題，同時省掉了在整合其他框架時候

STS(Eclipse)構建Maven多模組專案（水平結構和樹形結構）

在配置完Java開發環境和MAVEN後，我們來建立專案 STS（Eclipse）下載 請到官網http://spring.io/tools/sts/all/ 下載STS最新版 然後放到G盤，然後解壓到當前 G:\sts-bundle\

Intellij 構建maven多模組專案(二)

拿了一個，黑馬程式培訓專案，來講! 淘淘商城。 1. 父工程，下面，兩個子工程。 2.manager，聚合工程，聚合工程下面新增，5個子模組。 3.為什麼要使用，聚合工程？這個就要自己去學maven相關。   使用不使用聚合，關聯依賴和繼承都是要自己手動去關聯的。

Intellij 構建maven多模組專案(一)

參考： IntelliJ IDEA 構建maven多模組工程專案 來自 <https://blog.csdn.net/sinat_34344123/article/details/79080601> idea--8.新建maven父子專案 來自 <https:/

【超詳細demo編寫過程】idea中使用maven多模組結合ssm框架+mysql

寫這篇文章的原因      這段時間自己也正是在學習這塊，網上找了很多都沒有詳細的例子，然後基礎還不夠紮實的原因，花了不少時間才最後跑起來，所以寫這篇文章，希望能夠幫到入門的兄弟們，希望可以少走一些彎路，當然也有可能看這篇文章的時候就已經走上了彎路（開個玩笑）。同時也希望有大

springboot的maven多模組專案架構微服務搭建--跳過springmvc單一專案直接構建多模組並衍化為微服務專案

　　總想對微服務架構做一個小小的總結，不知如何下手，最近覺得還是從搭建微服務的過程來入手，對於springboot的maven專案從構建多模組架構進而衍化為常用的微服務架構來做個記錄吧。 　　首先，建立多個springboot專案，專案結構如圖： 　　　　　　裁剪後如右側 　　建立完成後，先解釋一下：s

IntelliJ IDEA 構建maven多模組工程專案(詳細多圖)

食用前須知 本文以a b c 三個模組為例來搭建專案,以達到通俗易懂的初衷 模組a —– 基模組,就是人們常說的parent 模組b —– 其他模組都需要使用的一些工具,比如時間工具,json工具等 模組c —– 專案主要的內容,一般為

springboot + dubbo + zookeeper 註冊中心 + maven多模組專案框架搭建具體操作

1. 專案搭建前瞭解： Maven多模組專案可以解決專案中出現多個相同的jar包和service介面以及實體類物件的問題，可以將相同的提取成一個專案來維護管理，然後其他需要用到則只要引用jar包即可使用。 2. 將springboot + dubbo + zookeeper專案進行拆分： 生

ssm+maven多模組專案搭建

不多說了，spring+springMVC+mybatis+maven的多模組web專案（使用的是idea）1，使用idea建立一個多模組的maven專案2，專案的maven和Tomcat配置這裡就不多說了。專案結構先看一下：3，pom.xml檔案,新增自己需要的吧，就是一些

SpringBoot+Maven 多模組專案的構建、執行、打包實戰

專案使用的工具: IntelliJ IDEA JDK 1.8 apache-maven-3.3.9 專案的目錄: 主專案 springboot-multi 子模組 entity、dao、service、web 一、使用IDEA建立一個Spring

《Maven實戰》讀書筆記--(1)使用intellij idea搭建並配置maven多模組專案

本文使用intellij idea搭建Maven3多模組專案，並進行配置相關配置，以實現專案的構建打包。 專案結構 multi-module-project是我們的專案名稱，其中包含多個模組： mmp-dal模組：資料訪問層，提供對原始資料（主要指資料庫）的操作

SpringBoot建立maven多模組專案

SpringBoot建立maven多模組專案 專案結構     該專案名稱為springboot-maven-multi，由springboot-maven-multi、user-dao、user-domain、user-service、user-web個模組組成，其中spring

Maven 多模組專案

本篇 介紹瞭如果構建一個Maven的多模組專案，一些問題的解決辦法。 簡單理解 Maven的多模組，其實可以簡單的理解為，有多個POM表構成，由一個父表POM組織起來，形成了Maven的多模組模式。 例如 在一個簡單的ssm專案中，有service層，dao層，con

構建Maven多模組

構建Maven多模組 背景介紹  在學習《Spring-Cloud微服務架構》中，曾看到Maven多模組，一時來了興趣便進行研究。我比較喜歡用IDEA，所以這裡用IDEA來介紹了。 學習之旅 按照圖中步驟一步步來 然後一直next

springboot的maven多模組專案架構微服務搭建——依賴方式的多模組演化為微服務專案

在上一篇依賴方式多模組的基礎上對專案進行改造。主要改造user-service專案，service要配置mapper。mybatis及資料庫相關的東西，後面的介面消費方user就不再需要了 注意：以下程式碼是在不同場所的機器上寫的，資料庫什麼的會有不同，結構也會有不同，最終的程式碼會以其中一個傳遞到本人gi

利用intellijidea建立maven多模組專案

本文通過一個例子來介紹利用maven來構建一個多模組的jave專案。開發工具：intellij idea。 一、專案結構 multi-module-PRoject是主工程，裡面包含兩個模組（Module）： web-app是應用層，用於介面展示，依賴於web-s

Maven多模組專案管理小結

題記 最近剛完成一個用Maven構建的Web專案，看了一些Maven方面的書，比如《maven實戰》，但還是對Maven多模組專案理解得不清晰，所以花了一點時間好好研究了下，現分享如下。 問題 下面是一個簡略的專案結構圖 Parent `------ childA(B