精华内容
下载资源
问答
  • Maven拆分代码.zip

    2020-05-29 00:05:19
    <property name="url" value="jdbc:mysql:///maven"/> <!--配置生产SqlSession对象的工厂--> <!--扫描pojo包,给包下所有pojo对象起别名--> <!--扫描接口包路径,生成包下所有接口的代理对象,...
  • 使用maven拆分项目

    2018-02-24 18:15:00
    在开发环境中,有时需要专人负责专门的模块,其他模块不需接触,这就需要将项目拆分,如下   fund_demo项目具有三个模块,现将主业务core模块单独提出另建一个项目fund_core,拆分时需要注意相关类的路径在映射...

    在开发环境中,有时需要专人负责专门的模块,其他模块不需接触,这就需要将项目拆分,如下

        

    fund_demo项目具有三个模块,现将主业务core模块单独提出另建一个项目fund_core,拆分时需要注意相关类的路径在映射文件中要保持正确

        

     这就需要当运行fund_demo时也要调用fund_core项目,开发情况下可将fund_core项目作为依赖加入fund_demo,但打包时却不方便,这就需要用到maven来管理

    1. 同一工作空间下新建父项目fund_parent,并编辑pom.xml

        <groupId>cn.zang</groupId>
        <artifactId>fund_parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <!-- 打包方式为pom -->
        <packaging>pom</packaging>
    
        <!-- 引入子项目 -->
        <modules>
            <module>../fund_core</module>
            <module>../fund_demo</module>
        </modules>

    2. 编辑子项目的pom.xml

    fund_demo:声明父元素,引入fund_core的依赖

    <!--声明父元素-->
        <parent>
            <groupId>cn.zang</groupId>
            <artifactId>fund_parent</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <relativePath>../fund_parent</relativePath>
        </parent>
        
        <groupId>cn.zang</groupId>
        <artifactId>fund_demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <name>fund</name>
        <url>http://maven.apache.org</url>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
    
        <dependencies>
    <!--引入fund_core的依赖-->
            <dependency>
                <groupId>cn.zang</groupId>
                <artifactId>fund_core</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>    
      ······
       </dependencies>

    fund_core:声明父元素

    <!--声明父元素-->
        <parent>
            <groupId>cn.zang</groupId>
            <artifactId>fund_parent</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <relativePath>../fund_parent</relativePath>
        </parent>
        
        <groupId>cn.zang</groupId>
        <artifactId>fund_core</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>

    3. fund_parent项目编译发布

    call mvn clean compile
    call mvn eclipse:clean
    call mvn eclipse:eclipse -Dwtpversion=2.0 -DdownloadSources=true -DdownloadJavadocs=true
    pause

    4. 在项目中引入父项目时即可自动将两个子项目引入

     

    展开全文
  • maven拆分与聚合思想 ->传统工程基于SSM框架整合的项目,如果有好几个项目,需要在每个项目里都放置一套SSM框架的jar包。 ->基于maven的SSM框架整合的项目,如果有好几个这样的工程,我们都只需要一套jar...

    【两个重要概念】

    #1-> maven的拆分聚合思想

    ->传统工程基于SSM框架整合的项目,如果有好几个项目,需要在每个项目里都放置一套SSM框架的jar包。

    ->基于maven的SSM框架整合的项目,如果有好几个这样的工程,我们都只需要一套jar包,因为jar包都放置到仓库中,这一特性就是maven对jar包的依赖管理。

    关于代码可重用在开发维护中的重要性不言而喻。一份代码复制粘贴到不同地方,复制粘贴了几个地方,就要一次修改维护几个地方,而如果这份代码是可重用的,需要修改维护的话,只用修改一份即可。

    maven解决代码可重用便于维护的问题上是这样解决的:

    - maven把一个完整的项目,分成不同的独立模块,这些模块都有各自独立的坐标。哪个地方需要其中某个模块,就直接引用该模块的坐标即可。

    - 今后如果开发一个新项目,我们先考虑的问题不是dao、service、web如何编写,我们要考虑的是dao、service、web这些模块是否已经存在,如果存在直接引用。

    -这就是maven的拆分思想。

    -把拆分零散的模块聚合到一起组成一个完整的项目,这就是maven的聚合思想。

     

    #2-> 关于Project(工程)和Module(模块)的区别

    - Project不等同于完整的项目,Module也不等同于完整的项目,一个完整项目依据的标准是代码,如果代码完整能满足开发的功能需求,就可以说这是一个完整的项目,而这和此项目是Project和Module没有关系。

    - Project天生独立,只能使用自己内部资源,但后天可以与其他Project或Module建立关联关系。

    - Module天生不是独立的,模块是属于父工程的,模块一旦创建,所有父工程的资源都可以使用。

    父子工程之间,子模块继承(也叫依赖)父工程,可以使用父工程所有资源。而子模块之间原本是没有任何关系的,它们相互独立。

    - 子模块->继承->父工程 这种继承关系(一般都叫依赖,这里为了区分叫继承)是原本就存在的,不需要手动建立关联。

    - 子模块->依赖->子模块 这样平级之间的引用关系叫依赖,依赖不是原本存在的,需要后天手动建立关联。


    这里尝试将之前基于SSM+maven构建的一个demo工程【ssm_maven】改写成模块拆分与聚合的父子工程。

    关于之前这个demo工程构建的过程请参考:https://blog.csdn.net/coralime/article/details/105120266

    项目整体架构如下图所示


    项目详细构建过程-目录

    #1-> 新建基于maven的工程文件

    #2-> 创建父工程的子模块

    (1)创建子模块dao

    (2)创建子模块service

    (3)创建子模块web

    #3-> ssm_maven_parent->pom.xml

    #4-> 各个模块的代码填充

    #4.1-> ssm_dao

    #4.1.1-> main/java/ -> [package] com.yy.domain -> [pojo] User.java

     #4.1.2-> main/java/ -> [package] com.yy.dao -> [interface] UserDao.java (注意这里是接口文件)

    #4.1.3-> main/resources/ -> [Directory] com/yy/dao -> [xml] UserDao.xml 

    #4.1.4-> main/resources/spring -> [xml] applicationContext-dao.xml (Dao层的配置文件)

    #4.2-> ssm_service

    #4.2.1-> main/java/ -> [package] com.yy.service -> [interface] UserService.java (注意这里是接口文件)

    #4.2.2-> main/java/ -> [package] com.yy.service.impl -> [java] UserServiceImpl.java (接口的实现类文件)

     #4.2.3-> main/resources/spring -> [xml] applicationContext-service.xml (Service层的配置文件)

    #4.3-> ssm_web

    #4.3.1-> main/java/ -> [package] com.yy.controller -> [java] UserController.java 

    #4.3.2-> main/resources/ -> [xml] springmvc.xml

    #4.3.3-> main/resources/ -> [properties] log4j.properties

     #4.3.4-> main/webapp/WEB-INF/ -> [Directory] pages -> userInfo.jsp

    #4.3.5-> main/webapp/WEB-INF/ -> web.xml

     #4.3.6-> main/resources/ -> [xml] applicationContext.xml

    #5-> 父子工程的三种启动方式

    #5.1-> 父工程【ssm_maven_parent】下执行 mvn tomcat7:run

    #5.2-> 子模块【ssm_web】下执行 mvn tomcat7:run

    #5.3-> 本地安装的Tomcat启动


    #1-> 新建基于maven的工程文件

    【File】->【New】->【Project】->【ssm_maven_parent】

    这里不需要基于maven的骨架创建,直接创建一个基于maven的空工程即可。

    工程创建成功以后,父工程只需要保留一个pom.xml文件即可,可以把/src目录整个删除,只保留如下所示。因为父工程的主要职责就是帮忙管理jar包的。

    #2-> 创建父工程的子模块

    (1)创建子模块dao

    右键父工程【ssm_maven_parent】->【new】->【Module】->(empty)【ssm_dao】

    由于Dao层直接与数据库进行交互,直接建立基于maven的空模板即可。

    ssm_dao-pom.xml里多了一个<parent>标签

    <parent>
        <artifactId>ssm_maven_parent</artifactId>
        <groupId>com.yy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    
    <artifactId>ssm_dao</artifactId>

    ssm_maven_parent-pom.xml里多了一个<module>标签

    <modules>
        <module>ssm_dao</module>
    </modules>

    子模块ssm_dao的坐标是:<groupId>com.yy+<artifactId>ssm_dao+<version>1.0-SNAPSHOT。 

    (2)创建子模块service

    同上,右键父工程【ssm_maven_parent】->【new】->【Module】->(empty)【ssm_service】

    由于service层需要dao层的代码,需要在ssm_service-pom.xml中引入ssm_dao的坐标,建立依赖关系。

    <dependency>
        <groupId>com.yy</groupId>
        <artifactId>ssm_dao</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

    (3)创建子模块web

    右键父工程【ssm_maven_parent】->【new】->【Module】->(maven-archetype-webapp)【ssm_web】

    ssm_web-pom.xml 把自动生成的不需要的内容删除,注意保留模块坐标和打包方式。

    <parent>
        <artifactId>ssm_maven_parent</artifactId>
        <groupId>com.yy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    
    <artifactId>ssm_web</artifactId>
    <packaging>war</packaging>

    web层需要service层的代码,和上面一样,需要在ssm_web-pom.xml中引入ssm_service的坐标,建立依赖关系。

    <dependency>
        <groupId>com.yy</groupId>
        <artifactId>ssm_service</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

    #3-> ssm_maven_parent->pom.xml

    子模块可以直接使用父工程的所有资源,这里的三个子模块ssm_dao、ssm_service、ssm_web所需要的jar包都可以直接放在父工程下的pom.xml里面。

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.yy</groupId>
        <artifactId>ssm_maven_parent</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
    
        <modules>
            <module>ssm_dao</module>
            <module>ssm_service</module>
            <module>ssm_web</module>
        </modules>
    
        <!--复制一份之前的SSM框架的pom.xml-->
        <properties>
            <!--jdk版本控制-->
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.source>13</maven.compiler.source>
            <maven.compiler.target>13</maven.compiler.target>
    
            <!--  集中定义依赖版本号 -->
            <mybatis.version>3.5.4</mybatis.version>
            <mybatis.spring.version>2.0.4</mybatis.spring.version>
            <mysql.version>8.0.19</mysql.version>
            <!--        <druid.version>1.1.21</druid.version>--> <!--最新版有bug-->
            <druid.version>1.1.20</druid.version>
            <spring.version>5.2.4.RELEASE</spring.version>
            <jstl.version>1.2</jstl.version>
            <servlet-api.version>4.0.1</servlet-api.version>
            <jsp-api.version>2.0</jsp-api.version>
            <jackson.version>2.10.3</jackson.version>
            <slf4j.version>1.7.30</slf4j.version>
            <spring.security.version>5.3.0.RELEASE</spring.security.version>
        </properties>
    
        <!-- 锁定jar包版本 -->
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>${spring.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-web</artifactId>
                    <version>${spring.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-webmvc</artifactId>
                    <version>${spring.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-tx</artifactId>
                    <version>${spring.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-test</artifactId>
                    <version>${spring.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.mybatis</groupId>
                    <artifactId>mybatis</artifactId>
                    <version>${mybatis.version}</version>
                </dependency>
                <dependency>
                    <groupId>com.alibaba</groupId>
                    <artifactId>druid</artifactId>
                    <version>${druid.version}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <dependencies>
            <!-- MyBatis -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>${mybatis.spring.version}</version>
            </dependency>
            <!--分页-->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper</artifactId>
                <version>5.1.11</version>
            </dependency>
            <!-- MySql -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.19</version>
                <scope>runtime</scope>
            </dependency>
            <!-- 连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
    
            <dependency>
                <groupId>c3p0</groupId>
                <artifactId>c3p0</artifactId>
                <version>0.9.1.2</version>
                <scope>compile</scope>
            </dependency>
    
            <!-- Spring -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jms</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <!-- Spring security -->
            <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-web</artifactId>
                <version>${spring.security.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-config</artifactId>
                <version>${spring.security.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-core</artifactId>
                <version>${spring.security.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-taglibs</artifactId>
                <version>${spring.security.version}</version>
            </dependency>
    
            <!-- JSP相关 -->
            <dependency>
                <groupId>jstl</groupId>
                <artifactId>jstl</artifactId>
                <version>${jstl.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>${servlet-api.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jsp-api</artifactId>
                <version>${jsp-api.version}</version>
                <scope>provided</scope>
            </dependency>
    
            <!-- 日志 -->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>${slf4j.version}</version>
                <scope>test</scope>
            </dependency>
    
            <!-- SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder". -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-simple</artifactId>
                <version>1.6.6</version>
            </dependency>
    
            <!-- test -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.2</version>
                    <!--    <configuration>-->
                    <!--        <port>8080</port>-->
                    <!--    </configuration>-->
                </plugin>
            </plugins>
        </build>
    
    </project>

    #4-> 各个模块的代码填充

    具体代码在之前demo工程创建中写过一遍:https://blog.csdn.net/coralime/article/details/105120266

    #4.1-> ssm_dao

    #4.1.1-> main/java/ -> [package] com.yy.domain -> [pojo] User.java

    package com.yy.domain;
    
    public class User {
    
        private int user_id;
        private String username;
        private String birthdate;
    
        public User() {
        }
    
        public int getUser_id() {
            return user_id;
        }
    
        public void setUser_id(int user_id) {
            this.user_id = user_id;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getBirthdate() {
            return birthdate;
        }
    
        public void setBirthdate(String birthdate) {
            this.birthdate = birthdate;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "user_id=" + user_id +
                    ", username='" + username + '\'' +
                    ", birthdate='" + birthdate + '\'' +
                    '}';
        }
    }
    

     #4.1.2-> main/java/ -> [package] com.yy.dao -> [interface] UserDao.java (注意这里是接口文件)

    package com.yy.dao;
    import com.yy.domain.User;
    
    public interface UserDao {
        public User findAllById(int id);
    }
    

    #4.1.3-> main/resources/ -> [Directory] com/yy/dao -> [xml] UserDao.xml 

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.yy.dao.UserDao">
        <!-- <select id="findAllById" parameterType="int" resultType="com.yy.domain.User">-->
        <!-- 写别名也可以 但别名必须和你的com.yy.domain.User 可以忽略大小写
        但其他要保持一致 也就是 User 可以写User和user 其他不行 -->
        <select id="findAllById" parameterType="int" resultType="user">
            select * from user where user_id = #{id};
        </select>
    </mapper>

    #4.1.4-> main/resources/spring -> [xml] applicationContext-dao.xml (Dao层的配置文件)

    <?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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="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.xsd
    			    http://www.springframework.org/schema/aop
    			    http://www.springframework.org/schema/aop/spring-aop.xsd
    			    http://www.springframework.org/schema/tx
    			    http://www.springframework.org/schema/tx/spring-tx.xsd
    			    http://www.springframework.org/schema/mvc
    			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        <!--    DAO层配置文件开始    -->
        <!--配置数据连接池-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <!--MySQL6以后的新版本-->
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost/maven_db"/>
            <property name="username" value="root"/>
            <property name="password" value="1007"/>
          </bean>
    
        <!-- 配置生产SqlSession对象的工厂-->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            <!-- 扫描pojo包,给包下所有的pojo对象起别名 User->user此时user这个别名就可以直接使用了 -->
            <property name="typeAliasesPackage" value="com.yy.domain"/>
        </bean>
    
        <!-- 扫描接口包路径,生成包下所有接口的代理对象,并且放入spring容器中 -->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.yy.dao"/>
        </bean>
        <!--   DAO层配置文件结束   -->
    </beans>

    #4.2-> ssm_service

    #4.2.1-> main/java/ -> [package] com.yy.service -> [interface] UserService.java (注意这里是接口文件)

    package com.yy.service;
    
    import com.yy.domain.User;
    
    public interface UserService {
    
        public User findAllById(int id);
    
    }
    

    #4.2.2-> main/java/ -> [package] com.yy.service.impl -> [java] UserServiceImpl.java (接口的实现类文件)

    package com.yy.service.impl;
    
    import com.yy.dao.UserDao;
    import com.yy.domain.User;
    import com.yy.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserServiceImpl implements UserService {
    
        /* Filed Injection 变量注入警告 */
    //    @Autowired
    //    private UserDao userDao;
    
        /* spring推荐-构造器依赖注入 */
        private UserDao userDao;
        @Autowired
        public UserServiceImpl(UserDao userDao) {
            this.userDao = userDao;
        }
    
        /* setter方式注入 */
    //    private UserDao userDao;
    //    @Autowired
    //    public void setUserDao(UserDao userDao){
    //        this.userDao = userDao;
    //    }
    
        @Override
        public User findAllById(int id) {
            return userDao.findAllById(id);
        }
    }
    

     #4.2.3-> main/resources/spring -> [xml] applicationContext-service.xml (Service层的配置文件)

    <?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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="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.xsd
    			    http://www.springframework.org/schema/aop
    			    http://www.springframework.org/schema/aop/spring-aop.xsd
    			    http://www.springframework.org/schema/tx
    			    http://www.springframework.org/schema/tx/spring-tx.xsd
    			    http://www.springframework.org/schema/mvc
    			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        <!--   Service配置文件开始   -->
        <!--组件扫描配置-->
        <context:component-scan base-package="com.yy.service"/>
    
        <!--aop 面向切面编程,切面就是切入点和通知的组合-->
        <!--配置事务管理器-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
         </bean>
        <!--配置事务的通知-->
        <tx:advice id="transactionInterceptor">
            <tx:attributes>
                <tx:method name="save*" propagation="REQUIRED"/>
                <tx:method name="update*" propagation="REQUIRED"/>
                <tx:method name="delete*" propagation="REQUIRED"/>
                <tx:method name="find*" read-only="true"/>
                <tx:method name="*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
    
        <!--配置切面-->
        <aop:config>
            <aop:pointcut id="pointcut" expression="execution(* com.yy.service.impl.*.*(..))"/>
            <aop:advisor advice-ref="transactionInterceptor" pointcut-ref="pointcut"/>
        </aop:config>
        <!--   Service配置文件结束   -->
    </beans>

    #4.3-> ssm_web

    #4.3.1-> main/java/ -> [package] com.yy.controller -> [java] UserController.java 

    package com.yy.controller;
    
    import com.yy.domain.User;
    import com.yy.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    @Controller
    @RequestMapping("users")
    public class UserController {
    
        // 构造器依赖注入UserService
        private UserService userService;
        @Autowired
        public UserController(UserService userService) {
            this.userService = userService;
        }
    
        /* 最终访问地址:
         * http://localhost:8080/[project_name]/users/findUsers */
        @RequestMapping("findUsers")
        public String findUsers(Model model){
            User user = userService.findAllById(1);
            /* 查询到user之后需要放进model里面
             * 以key-value的方式注解,映射前端页面
             * key -> userInfo.jsp中EL表达式中的userinfo */
            model.addAttribute("userinfo",user);
            /* 具体跳转到哪一个页面的地址: /WEB-INF/pages/userInfo.jsp
             * 因为在springmvc.xml里的视图解析器中配置了[前缀]和[后缀]
             * 所以这里可以直接写页名就行 */
            return "userInfo";
        }
    }
    

    #4.3.2-> main/resources/ -> [xml] springmvc.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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="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.xsd
    			    http://www.springframework.org/schema/aop
    			    http://www.springframework.org/schema/aop/spring-aop.xsd
    			    http://www.springframework.org/schema/tx
    			    http://www.springframework.org/schema/tx/spring-tx.xsd
    			    http://www.springframework.org/schema/mvc
    			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        <!-- 组件扫描 -->
        <context:component-scan base-package="com.yy.controller"/>
    
        <!-- 处理器映射器 处理器适配器 -->
        <mvc:annotation-driven/>
    
        <!-- 视图解析器 -->
        <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <!-- 前缀-页面放在文件夹路径 /WEB-INF/pages/ 下 -->
            <property name="prefix" value="/WEB-INF/pages/"/>
            <!-- 后缀-页面以.jsp结尾 -->
            <property name="suffix" value=".jsp"/>
            <!-- 完整的路径:/WEB-INF/pages/xxx.jsp -->
        </bean>
    
        <!-- 释放静态资源 防止servlet的"/"拦截了所有资源,包括静态资源 -->
        <mvc:default-servlet-handler/>
    
    </beans>

    #4.3.3-> main/resources/ -> [properties] log4j.properties

    # Set root category priority to INFO and its only appender to CONSOLE.
    #log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
    log4j.rootCategory=debug, CONSOLE, LOGFILE
    
    # Set the enterprise logger category to FATAL and its only appender to CONSOLE.
    log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
    
    # CONSOLE is set to be a ConsoleAppender using a PatternLayout.
    log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
    log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
    log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
    
    # LOGFILE is set to be a File appender using a PatternLayout.
    log4j.appender.LOGFILE=org.apache.log4j.FileAppender
    log4j.appender.LOGFILE.File=d:\axis.log
    log4j.appender.LOGFILE.Append=true
    log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
    log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
    

     #4.3.4-> main/webapp/WEB-INF/ -> [Directory] pages -> userInfo.jsp

    <%--
      Created by IntelliJ IDEA.
      User: Coralime
      Date: 2020/3/22
      Time: 15:54
      To change this template use File | Settings | File Templates.
    --%>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
        <title>userInfo</title>
    </head>
    <body>
    <form>
        <table width="100%" border="1">
            <tr>
                <td>user_id</td>
                <td>${userinfo.user_id}</td>
            </tr>
            <tr>
                <td>username</td>
                <td>${userinfo.username}</td>
            </tr>
            <tr>
                <td>birthdate</td>
                <td>${userinfo.birthdate}</td>
            </tr>
        </table>
    </form>
    </body>
    </html>

    #4.3.5-> main/webapp/WEB-INF/ -> web.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
             version="4.0">
        <!-- 编码过滤器 -->
        <filter>
            <filter-name>encodingFilter</filter-name>
            <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
            <init-param>
                <!--private String encoding;-->
                <param-name>encoding</param-name>
                <param-value>UTF-8</param-value>
            </init-param>
            <init-param>
                <!--public void setForceEncoding(boolean forceEncoding)-->
                <param-name>forceEncoding</param-name>
                <param-value>true</param-value>
            </init-param>
        </filter>
        <filter-mapping>
            <filter-name>encodingFilter</filter-name>
            <!-- /* 所有地址全部拦截 -->
            <url-pattern>/*</url-pattern>
        </filter-mapping>
    
        <!-- 配置spring核心监听器 -->
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
        <!-- 重新指定spring配置文件的路径 -->
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </context-param>
    
        <!-- 配置springMVC的核心Servlet -->
        <servlet>
            <servlet-name>dispatcherServlet</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <!-- 配置springmvc.xml文件 -->
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:springmvc.xml</param-value>
            </init-param>
            <!-- 让这个文件首先加载,优先级最高 -->
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>dispatcherServlet</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
    </web-app>

    注意这里会报错,找不到applicationContext.xml

     #4.3.6-> main/resources/ -> [xml] 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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="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.xsd
    			    http://www.springframework.org/schema/aop
    			    http://www.springframework.org/schema/aop/spring-aop.xsd
    			    http://www.springframework.org/schema/tx
    			    http://www.springframework.org/schema/tx/spring-tx.xsd
    			    http://www.springframework.org/schema/mvc
    			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        <!--引入Dao和Service配置文件-->
        <import resource="classpath:spring/applicationContext-dao.xml"/>
        <import resource="classpath:spring/applicationContext-service.xml"/>
    </beans>

    #5-> 父子工程的三种启动方式

    #5.1-> 父工程【ssm_maven_parent】下执行 mvn tomcat7:run

    访问地址:http://localhost:8080/ssm_web/users/findUsers

    #5.2-> 子模块【ssm_web】下执行 mvn tomcat7:run

    因为这里的ssm_web包含了所有代码,是一个完整的项目,是可以直接运行的。

    但是第一次运行时会报错找不到ssm_service这个jar包

    原因是maven工程在启动的时候第一件事就是去本地仓库找pom.xml中引入的jar 包,启动【ssm_web】工程的时候,由于pom.xml里引入了【ssm_service】的坐标,但是仓库里没有这个jar包坐标所以报错了。 但之前直接启动父工程【ssm_maven_parent】的时候没有报错又是为什么呢?这是因为父工程的pom.xml里所有的jar包都在仓库里。

    解决办法就是把【ssm_service】这个包安装到仓库中即可。

    直接在父工程【ssm_maven_parent】下执行 mvn instaill 命令,可以将项目里所有jar包打包到仓库中。

    再去子模块【ssm_web】下执行 mvn tomcat7:run 成功。

    #5.3-> 本地安装的Tomcat启动

    展开全文
  • maven工程拆分与聚合的思想 工程和 模块的区别 工程不等于完整的项目,模块也不等于完整的项目,一个完整的项目看的是代码,代码完整就可以说是一个完整的项目 和此项目是工程和模块没有关系 区别: 工程天生只能使用...

    拆分和聚合的代码demo可点击链接下载:demo代码

    一、 maven工程拆分与聚合的思想

    在这里插入图片描述

    工程和 模块的区别

    工程不等于完整的项目,模块也不等于完整的项目,一个完整的项目看的是代码,代码完整就可以说是一个完整的项目

    和此项目是工程和模块没有关系

    区别:

    工程天生只能使用自己内部资源,工程天生是独立的.后天可以和其他工程或模块建立关联关系

    模块天生不是独立的,模块天生是属于父工程的,模块一旦创建,所有父工程资源都可以使用.

    联系:

    父子工程之间,子模块天生继承父工程,可以使用父工程所有资源.
    子模块之间天生是没有任何关系的.

    父子工程之间不用建立关系,继承关系是先天的,不需要手动建立。

    平级之间的引用叫依赖,依赖是后天建立的,不是天生的。

    在这里插入图片描述

    直接依赖和传递依赖

    直接依赖:dao直接依赖于parent,作用域是compile
    传递依赖:dao和junit是传递依赖,作用域是test

    在这里插入图片描述

    二、使用maven做构建ssm框架(传统聚合的项目)

    maven传统的web工程做一个数据查询操作

    (1)SSM框架下的dao层代码编写

    a. 先创建数据库对应的实体类,属性名和数据库的字段名要相对应

    b. 创建操作数据库的接口,并且定义抽象方法publicItemsfindById(Integerid);

    因为使用ssm框架,接口对应的是mybatis的持久层框架,则接口不用写实现类,让mybatis直接生成接口的代理对象即可

    c.在resources文件夹下创建和src目录结构相同的目录,并且创建接口的配置文件(XML),用于操作数据库——操作数据库定义一个mapper进行操作,如下:

    在这里插入图片描述
    d. 创建spring的配置文件,希望spring整合mybatis框架,则需要配置连接池连接数据库,配置生成sqlsession工厂,扫描包中接口的路径

    在这里插入图片描述
    e. 编写测试类,测试是否配置成功
    在这里插入图片描述

    (2)SSM框架下的service层代码编写

    公司实际开发中:自己写的类尽量使用注解,框架中的类使用配置文件、
    
    1. 创建service层的接口 (方法名此时和dao层的操作的方法名一致)
      在这里插入图片描述

    2. 为service层的接口添加实现类,并且把dao的操作对象进行注入,因为itemsdao是自己写的类,所以加上注解的方式交由spring的aop进行注入(原本没有值的,加上一个值)
      在这里插入图片描述

    3. 编写service层的配置文件,实现业务层处理业务逻辑和处理事务的功能配置,
      ①配置组件的扫描,(aop面向切面编程,切面就是切入点和通知的组合)
      ②配置事务管理器(想要控制事务,就要用到connection,用到connection就要用到连接池),
      ③配置事务的通知,
      ④配置切面(并且需要把切入点和通知类进行整合,变成切面)
      在这里插入图片描述

    4. 编写测试

    在这里插入图片描述

    (3)SSM框架下的web层代码编写

    1. 创建web层的控制类,需要在类上加上 @Controller @RequestMapping("/items") 即把对象交给容器管理并且加上全局路径,
      在这里插入图片描述

    2. 由于applicationContext.xml文件是用来配置spring框架的,而web层采用的是springmvc框架,所以建立一个springmvc.xml文件用于配置web层,并把springmvc.xml的配置文件导入我们需要的context、aop、mvc、tx等约束
      ① 配置组件扫描
      ②开启springmvc的注解支持(处理器映射器、处理器适配器)
      ③配置视图解析器
      ④释放静态资源
      在这里插入图片描述

    3. 在/WEN-INF/pages/目录下创建要跳转的视图文件 itemDetail.jsp
      在这里插入图片描述

    4. 为了把所有配置文件的资源一启动就交给servlet容器中,则需要配置web.xml
      ① 配置编码过滤器
      ② 配置spring文件扫描——配置spring核心监听器
      ③ springmvc的核心servlet

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    三、把传统聚合的项目进行拆分的具体步骤

    之前的项目把dao、service、web层都放在了一个项目中,现在进行拆分成模块并借助依赖的方式进行导入。
    在这里插入图片描述

    理解继承和聚合

    通常继承和聚合同时使用。

     何为继承?

    继承是为了消除重复,如果将 dao、 service、 web 分开创建独立的工程则每个工程的 pom.xml
    文件中的内容存在重复,比如:设置编译版本、锁定 spring 的版本的等,可以将这些重复的
    配置提取出来在父工程的 pom.xml 中定义。

     何为聚合?

    项目开发通常是分组分模块开发, 每个模块开发完成要运行整个工程需要将每个模块聚合在
    一起运行,比如: dao、 service、 web 三个工程最终会打一个独立的 war 运行。

    • 拆分之前的目录结构:
      在这里插入图片描述

    • 拆分之后的项目目录结构:
      在这里插入图片描述
      每个模块都需要 spring 或者 junit 的 jar,况且最终 package 打完包最后生成的项目中的jar 就是各个模块依赖的整合,所以我们可以把项目中所需的依赖都可以放到父工程中,模块中只留模块和模块之间的依赖。

    (1)dao层模块:

    在这里插入图片描述
    在这里插入图片描述
    dao中对spring的配置也只配置dao层的,不加入service的配置

    (2)service层模块:

    在这里插入图片描述
    在这里插入图片描述

    (3) Web 层模块:

    在这里插入图片描述
    在这里插入图片描述
    web层包含web层的页面资源等,并且导入对dao和service层的配置文件的扫描

    其中,web层的web.xml文件是对web层的配置文件,里面可以包含配置spring核心监听器和springmvc的核心servlet等

    展开全文
  • 本文主要讲述的是maven项目为什么要拆分和聚合工程(模块),以及如何拆分工程(模块)和聚合工程(模块)。 这里先简单给大家讲一下为什么有拆分和聚合。我们之前学了框架之后把ssm框架整合在一个工程或模块中,...

    前言

    该篇文章是上两篇maven入门博文的续集,读者可以选择先阅读前面的两篇再进行该篇的学习。本文主要讲述的是maven项目为什么要拆分和聚合工程(模块),以及如何拆分工程(模块)和聚合工程(模块)。

    这里先简单给大家讲一下为什么有拆分和聚合。我们之前学了框架之后把ssm框架整合在一个工程或模块中,那在下次如果有项目用到相同的代码时,我们又得重新复制粘贴出来,这样即浪费内存又降低了开发的效率。maven工具已经给我们提供了一个解决方案,就是将每个层分开做成模块,然后再将每个层打包放到私服上,这也就是所说的拆分。拆分的好处是,每个层的编写可以分给专门的团队,然后其他层的团队可以直接引用私服中的包,总结起来就是分工明确,方便维护,提高效率,降低内存空间。我们做项目时候再引用这些包的过程叫聚合,聚合之后就形成了一个完整项目。

    下面将演示如何用拆分和聚合思想搭建一个项目。

    一、创建父工程

    打开idea之后和之前创建maven项目一样,但是不同的是,这次可以选择site骨架来创建父工程

    这里写图片描述

    创建父工程之后,我们接着添加对应的三层模块。

    这里写图片描述

    父工程中要锁定各个依赖的版本,pom.xml如下所示:

    <?xml version="1.0" encoding="UTF-8"?>
    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>com.stevensam</groupId>
      <artifactId>maven_parent</artifactId>
      <version>1.0-SNAPSHOT</version>
      <modules>
        <module>maven_dao</module>
        <module>maven_service</module>
        <module>maven_web</module>
      </modules>
      <packaging>pom</packaging><!--父工程打包方式为pom-->
    
      <!-- 统一管理jar包版本 -->
      <properties>
        <spring.version>5.0.2.RELEASE</spring.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <shiro.version>1.2.3</shiro.version>
        <mysql.version>5.1.6</mysql.version>
        <mybatis.version>3.4.5</mybatis.version>
        <spring.security.version>5.0.1.RELEASE</spring.security.version>
      </properties>
    
      <!-- 锁定jar包版本 -->
      <dependencyManagement>
        <dependencies>
          <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
          </dependency>
          <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
          </dependency>
          <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
          </dependency>
          <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
          </dependency>
          <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
          </dependency>
          <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
          </dependency>
        </dependencies>
      </dependencyManagement>
    
      <!-- 项目依赖jar包 -->
      <dependencies>
        <!-- spring -->
        <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.6.8</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aop</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context-support</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-web</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-orm</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-beans</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-tx</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>${mysql.version}</version>
        </dependency>
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</version>
          <scope>provided</scope>
        </dependency>
        <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.0</version>
          <scope>provided</scope>
        </dependency>
        <dependency>
          <groupId>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
        </dependency>
        <!-- log start -->
        <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>${log4j.version}</version>
        </dependency>
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-api</artifactId>
          <version>${slf4j.version}</version>
        </dependency>
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-log4j12</artifactId>
          <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>${mybatis.version}</version>
        </dependency>
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis-spring</artifactId>
          <version>1.3.0</version>
        </dependency>
        <dependency>
          <groupId>c3p0</groupId>
          <artifactId>c3p0</artifactId>
          <version>0.9.1.2</version>
          <type>jar</type>
          <scope>compile</scope>
        </dependency>
        <dependency>
          <groupId>com.github.pagehelper</groupId>
          <artifactId>pagehelper</artifactId>
          <version>5.1.2</version>
        </dependency>
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-web</artifactId>
          <version>${spring.security.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-config</artifactId>
          <version>${spring.security.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-core</artifactId>
          <version>${spring.security.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-taglibs</artifactId>
          <version>${spring.security.version}</version>
        </dependency>
        <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.0.9</version>
        </dependency>
      </dependencies>
      <!-- 添加tomcat7插件 -->
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
          </plugin>
        </plugins>
      </build>
    </project>
    

    二、创建dao模块

    1.右键点击父工程,选择Module,不用骨架创建,输入模块名maven_dao,然后点下一步,完成即可。
    这里写图片描述

    2.创建dao模块之后,在main-java文件中创建该有的包,添加依赖

    这里写图片描述

    dao层中的pom.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>maven_parent</artifactId>
            <groupId>com.stevensam</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
        <artifactId>maven_dao</artifactId>
        <packaging>jar</packaging>
        <dependencies> <!-- Mybatis和mybatis与spring的整合 -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.3.1</version>
            </dependency>
            <!-- MySql驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.32</version>
            </dependency> <!-- druid数据库连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.0.9</version>
            </dependency>
        </dependencies>
    
    </project>
    

    2.1.dao包和pojo包

    dao层中的接口IStudentDao:

    @Repository
    public interface IStudentDao {
    
        /**
         * 查询所有的学生
         * @return
         */
        @Select("select * from student")
        List<Student> findAll() throws Exception;
    
        /**
         * 保存一个学生
         * @param student
         */
        @Insert("insert into student(sname,sex,birthday,cno) values(#{sname},#{sex},#{birthday},#{cno})")
        @Options(useGeneratedKeys = true,keyColumn = "sid",keyProperty = "sid")
        void saveStudent(Student student);
    

    2.2.在resources中将log4j.properties复制粘贴过来,创建jbdcConfig.properties和applicationContext-dao.xml

    jbdcConfig.properties:

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/web_test2
    jdbc.username=root
    jdbc.password=123
    

    applicationContext-dao.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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xsi:schemaLocation="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.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">
        <!-- 加载配置文件 -->
        <context:property-placeholder location="classpath:jdbcConfig.properties" />
        <!--配置连接池-->
        <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
            <property name="driverClassName" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>
        <!--配置sqlsession工厂-->
        <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
            <property name="dataSource" ref="dataSource"></property>
            <property name="typeAliasesPackage" value="com.stevensam.pojo"></property>
        </bean>
        <!--配置mybatis扫描包-->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="configurer">
            <property name="basePackage" value="com.stevensam.dao"></property>
        </bean>
    </beans>
    

    log4j.properties,值得注意的是,log4j.appender.LOGFILE.File表示日志的存放位置,可根据实际情况修改路径和文件名称。

    # Set root category priority to INFO and its only appender to CONSOLE.
    #log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
    log4j.rootCategory=debug, CONSOLE, LOGFILE
    
    # Set the enterprise logger category to FATAL and its only appender to CONSOLE.
    log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
    
    # CONSOLE is set to be a ConsoleAppender using a PatternLayout.
    log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
    log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
    log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
    
    # LOGFILE is set to be a File appender using a PatternLayout.
    log4j.appender.LOGFILE=org.apache.log4j.FileAppender
    log4j.appender.LOGFILE.File=f:/axis.log
    log4j.appender.LOGFILE.Append=true
    log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
    log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
    

    3.DaoTest测试类:

    package com.stevensam.test;
    
    import com.stevensam.dao.IStudentDao;
    import com.stevensam.pojo.Student;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import java.io.InputStream;
    import java.util.List;
    
    /**
     * author:seven lin
     * date:2018/9/921:21
     * description:dao测试类
     **/
    public class DaoTest {
        private IStudentDao iStudentDao;
    
        @Test
        public void test() throws Exception {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext-dao.xml");
            iStudentDao = applicationContext.getBean(IStudentDao.class);
            List<Student> studentList = iStudentDao.findAll();
            for (Student stu:studentList) {
                System.out.println(stu);
            }
        }
    }
    

    4.测试结果:

    dao测试结果

    三、创建service模块

    service层目录:

    service

    service层的pom文件:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>maven_parent</artifactId>
            <groupId>com.stevensam</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
        <artifactId>maven_service</artifactId>
        <packaging>jar</packaging>
    
        <dependencies>
            <dependency>
                <groupId>com.stevensam</groupId>
                <artifactId>maven_dao</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>
    </project>
    

    applicationContext-service文件:

    <?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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
        <!--引入dao的xml-->
        <import resource="applicationContext-dao.xml"></import>
        <!--配置包扫描-->
        <!--<context:component-scan base-package="com.stevensam">
            &lt;!&ndash;忽略控制层&ndash;&gt;
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter>
        </context:component-scan>-->
        <!--只扫描对应的层包,否则会有包冲突问题-->
        <context:component-scan base-package="com.stevensam.service.impl"></context:component-scan>
        <!--配置事务管理器-->
        <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
        <!--配置事务通知-->
        <tx:advice transaction-manager="transactionManager" id="interceptor">
            <tx:attributes>
                <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
                <tx:method name="*" isolation="DEFAULT" propagation="REQUIRED"></tx:method>
            </tx:attributes>
        </tx:advice>
        <!--配置事务aop-->
        <aop:config>
            <aop:pointcut id="tx" expression="execution(* com.stevensam.service.impl.*.*(..))"></aop:pointcut>
            <aop:advisor advice-ref="interceptor" pointcut-ref="tx"></aop:advisor>
        </aop:config>
    </beans>
    

    接口类和实现类:

    IStudentService:

    package com.stevensam.service;
    
    import com.stevensam.pojo.Student;
    
    import java.util.List;
    
    /**
     * author:seven lin
     * date:2018/9/1010:02
     * description:
     **/
    public interface IStudentService {
        /**
         * 查询所有的学生
         * @return
         */
        List<Student> findAll() throws Exception;
    
        /**
         * 保存一个学生
         * @param student
         */
        void saveStudent(Student student) throws Exception;
    
        /**
         * 更新学生信息
         * @param student
         */
        void updateStudent(Student student) throws Exception;
    
        /**
         * 根据学生的id删除学生信息
         * @param sid
         */
        void deleteById(Integer sid) throws Exception;
    }
    

    实现类StudentService:

    package com.stevensam.service.impl;
    
    import com.stevensam.dao.IStudentDao;
    import com.stevensam.pojo.Student;
    import com.stevensam.service.IStudentService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    
    /**
     * author:seven lin
     * date:2018/9/1010:09
     * description:
     **/
    @Service
    public class StudentService implements IStudentService {
        @Autowired
        private IStudentDao iStudentDao;
    
        public List<Student> findAll() throws Exception {
            return iStudentDao.findAll();
        }
    
        public void saveStudent(Student student) throws Exception {
            iStudentDao.saveStudent(student);
            int a=1/0;//测试事务
            iStudentDao.saveStudent(student);
        }
    
        public void updateStudent(Student student) throws Exception {
    
        }
    
        public void deleteById(Integer sid) throws Exception {
    
        }
    }
    

    测试类:

    import com.stevensam.pojo.Student;
    import com.stevensam.service.IStudentService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import java.util.List;
    
    /**
     * author:seven lin
     * date:2018/9/1010:11
     * description:service层测试类
     **/
    public class TestService {
        private IStudentService iStudentService;
        @Test
        public void test() throws Exception {
            ApplicationContext ac =new ClassPathXmlApplicationContext("classpath:applicationContext-service.xml");
            iStudentService = ac.getBean(IStudentService.class);
            List<Student> studentList = iStudentService.findAll();
            for(Student stu:studentList){
                System.out.println(stu);
            }
        }
    }
    

    测试结果:

    service测试结果

    四、创建web模块

    控制层目录:

    控制层

    pom.xml引进service层的依赖:(注意打包方式要设置为war方式,其他两层设置为jar方式)

    <dependencies>
        <dependency>
            <groupId>com.stevensam</groupId>
            <artifactId>maven_service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
    

    StudentController控制类:

    package com.stevensam.controller;
    
    import com.stevensam.pojo.Student;
    import com.stevensam.service.IStudentService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;
    
    import java.util.List;
    
    /**
     * author:seven lin
     * date:2018/9/1010:55
     * description:
     **/
    @Controller
    @RequestMapping("/student")
    public class StudentController {
        @Autowired
        private IStudentService iStudentService;
    
        @RequestMapping("/findAll")
        public ModelAndView findAll() throws Exception {
            List<Student> studentList = iStudentService.findAll();
            ModelAndView mv = new ModelAndView();
            mv.addObject("studentlist",studentList);
            mv.setViewName("list");
            return mv;
        }
    
        @RequestMapping("/saveStudent")
        public String saveStudent(Student student) throws Exception {
            iStudentService.saveStudent(student);
            return "redirect:/student/findAll";
        }
    
    
    }
    

    在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 xmlns="http://java.sun.com/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
              http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
             version="3.0">
      <!--配置前端控制器-->
      <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:sprignmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
      </servlet>
      <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
    
      <!--配置中文乱码过滤器-->
      <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
          <param-name>encoding</param-name>
          <param-value>UTF-8</param-value>
        </init-param>
      </filter>
      <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
      <!--配置spring监听器-->
      <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <!--配置类路径下的配置文件-->
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext-service.xml</param-value>
      </context-param>
      <!--配置状态码错误页面-->
      <error-page>
        <error-code>404</error-code>
        <location>/WEB-INF/pages/404.jsp</location>
      </error-page>
    
    </web-app>
    

    编写index.jsp:

    <%--
      Created by IntelliJ IDEA.
      User: soso
      Date: 2018/9/10
      Time: 15:28
      To change this template use File | Settings | File Templates.
    --%>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>主页</title>
    </head>
    <body>
        <a href="/student/findAll">查询所有学生</a>
        <form action="student/saveStudent" method="post">
            姓名:<input type="text" name="sname"/><br>
            性别:<select name="sex">
            <option>男</option>
            <option>女</option>
        </select><br>
            生日:<input type="date" name="birthday"/><br>
            班级编号:<select name="cno">
            <option>1</option>
            <option>2</option>
            <option>3</option>
        </select><br>
            <input type="submit" value="提交">
        </form>
    </body>
    </html>
    

    这里注意的是生日的格式为date,在前端传到后端的格式统统都为string,所以我们还需要配置一个自定义的类型转换器,StringtoDateConverter用于将字符串转换成日期格式,否则会出错。

    package com.stevensam.utils;
    
    import com.sun.tools.javac.util.StringUtils;
    import org.springframework.core.convert.converter.Converter;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /**
     * author:seven lin
     * date:2018/9/1014:46
     * description:
     **/
    public class StringtoDateConverter implements Converter<String,Date> {
        @Override
        public Date convert(String s) {
            //判断字符串是否符合规范
            if(s != null && !"".equals(s)){
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
                try {
                    Date date = dateFormat.parse(s);
                    return date;
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }else
                throw new RuntimeException();
            return null;
        }
    }
    

    为了提高用户的体验,如果出现了异常,我们将之前的异常都交由异常处理器处理,然后再转换到异常的页面error.jsp,当然内容很简单。

    先写一个自定义的异常类集成的是Exception,MyException:

    package com.stevensam.exception;
    
    /**
     * author:seven lin
     * date:2018/9/1011:16
     * description:
     **/
    public class MyException extends Exception {
    
        private String message;
    
        @Override
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
    
        public MyException(String message){
            this.message = message;
        }
    }
    

    再编写一个异常处理器类MyExceptionHandler:

    package com.stevensam.exception;
    
    import org.springframework.web.servlet.HandlerExceptionResolver;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    /**
     * author:seven lin
     * date:2018/9/1011:18
     * description:
     **/
    public class MyExceptionHandler implements HandlerExceptionResolver {
        @Override
        public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
    
            //先打印原异常信息在控制台上
            e.printStackTrace();
            //将该异常转换到一个异常界面上
            MyException myException = null;
            if(e instanceof MyException){
                myException = (MyException) e;
            }else{
                myException = new MyException("未知错误,请联系管理员!");
            }
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("message",myException.getMessage());
            modelAndView.setViewName("error");
            return modelAndView;
    
        }
    }
    

    根据以上的配置,最终编写控制层的配置文件sprignmvc.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"
           xsi:schemaLocation="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.xsd
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        <!--配置扫描包-->
        <!-- <context:component-scan base-package="com.stevensam">
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:include-filter>
        </context:component-scan>-->
        <context:component-scan base-package="com.stevensam.controller"></context:component-scan>
        <!--视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="viewResolver">
            <property name="prefix" value="/WEB-INF/pages/"></property>
            <property name="suffix" value=".jsp"></property>
        </bean>
        <!--过滤静态资源-->
        <!--<mvc:resources mapping="/js/**" location="/js/"></mvc:resources>
        <mvc:resources mapping="/css/**" location="/css/"></mvc:resources>
        <mvc:resources mapping="/images/**" location="/images/"></mvc:resources>-->
        <mvc:default-servlet-handler></mvc:default-servlet-handler>
    
        <!--配置字符串转日期转换器-->
        <bean class="org.springframework.context.support.ConversionServiceFactoryBean" id="service">
            <property name="converters">
                <set>
                    <bean class="com.stevensam.utils.StringtoDateConverter"></bean>
                </set>
            </property>
        </bean>
        <!--配置注解-->
        <mvc:annotation-driven conversion-service="service"></mvc:annotation-driven>
        <!--配置异常转换器-->
        <bean class="com.stevensam.exception.MyExceptionHandler" id="exceptionHandler"></bean>
    </beans>
    

    五、运行项目

    运行项目有三种方式:第一种是直接用父工程中的tomcat7:run命令运行,第二种是用我们自带的tomcat去运行,还有一种是运行web层中的tomcat7:run命令。

    1. 运行父工程

      运行父工程

    2. 运行自带tomcat

      需要先配置tomcat,然后再运行

      这里写图片描述

    3. 运行web层

      需要先在父工程中运行install命令,再进行web模块的tomcat7:run命令的执行。

      这里写图片描述

    4. 运行结果:

      这里写图片描述

      这里写图片描述

    六、上传到私服

    在上面的运行方式中,如果直接运行web模块,那么会出现找不到依赖service的错误,这是因为在运行的时候控制层会去本地仓库找jar包,找不到就去私服里面找,再找不到再去中央仓库找,中央仓库自然不会收录我们项目的jar包,所以会报错。在此背景下,我们开发完一个模块之后,将jar包上传公司的私服上,以便其他同事使用,那么接下来就是讲解上传私服的步骤。
    

    第一步: 需要在客户端即部署ssm_dao工程的电脑上配置 maven环境,并修改 settings.xml 文件,配置连接私服的用户和密码 。
    此用户名和密码用于私服校验,因为私服需要知道上传的账号和密码是否和私服中的账号和密码一致。

    <server>
        <id>releases</id><!--releases 连接发布版本项目仓库-->
        <username>admin</username>
        <password>admin123</password>
    </server>
    <server>
        <id>snapshots</id><!--snapshots 连接测试版本项目仓库-->
        <username>admin</username>
        <password>admin123</password>
    </server>
    

    第二步: 配置项目pom.xml
    配置私服仓库的地址,本公司的自己的jar包会上传到私服的宿主仓库,根据工程的版本号决定上传到哪个宿主仓库,如果版本为release则上传到私服的release仓库,如果版本为snapshot则上传到私服的snapshot仓库

    <distributionManagement> 
        <repository> 
            <id>releases</id>
            <url>http://localhost:8081/nexus/content/repositories/releases/</url> 
        </repository> 
        <snapshotRepository> 
            <id>snapshots</id> 
            <url>http://localhost:8081/nexus/content/repositories/snapshots/</url> 
        </snapshotRepository> 
    </distributionManagement>
    

    注意:pom.xml这里 和 settings.xml 配置 对应!

    第三步:测试
    将项目dao和service工程打成jar包发布到私服:
    1、首先启动nexus
    2、对maven_dao执行deploy命令,结果如下所示。maven_service工程也是一样的操作。

    这里写图片描述

    这里写图片描述

    注意事项:至于上传到私服的哪一个版本取决于项目中pom.xml中配置的版本,这里所有的版本都设定了1.0-SNAPSHOT,所以上传的是测试版本。

    七、配置从私服下载jar包

    上传完成之后,这个时候实际上还不能真正的运行成功。我们在本地仓库中删掉上传的service的jar包之后,再运行web模块,会失败,提示找不到该依赖。因为我们还没有配置从私服上下载jar包。配置的步骤如下:

    在客户端的setting.xml中配置私服的仓库,由于setting.xml中没有repositories的配置标签需要使用profile定义仓库。

    <profile> 
    		<!--profile的id--> 
    		<id>dev</id> 
    		<repositories> 
    			<repository> 
    				<!--仓库id,repositories可以配置多个仓库,保证id不重复--> 
    				<id>nexus</id>
    				<!--仓库地址,即nexus仓库组的地址--> 
    				<url>http://localhost:8081/nexus/content/groups/public/</url> 
    				<!--是否下载releases构件--> 
    				<releases> 
    					<enabled>true</enabled> 
    				</releases> 
    				<!--是否下载snapshots构件--> 
    				<snapshots> 
    					<enabled>true</enabled> 
    				</snapshots> 
    			</repository> 
    		</repositories> 
    		<pluginRepositories> 
    			<!-- 插件仓库,maven的运行依赖插件,也需要从私服下载插件 --> 
    			<pluginRepository> <!-- 插件仓库的id不允许重复,如果重复后边配置会覆盖前边 --> 
    				<id>public</id> 
    				<name>Public Repositories</name> 
    				<url>http://localhost:8081/nexus/content/groups/public/</url> 
    			</pluginRepository> 
    		</pluginRepositories> 
    	</profile>
    

    使用profile定义仓库需要激活才可生效:

    <activeProfiles>
        <activeProfile>dev</activeProfile> 
    </activeProfiles>
    

    删除掉本地仓库service层,再运行web模块即可看到从私服中下载的信息。

    展开全文
  • maven工程拆分的ssm框架(方便代码重用):父工程提供pom.xml文件,子工程包括ssm_web、ssm_service、ssm_dao三个子工程,其中ssm_web的pom.xml文件中导入ssm_service的依赖,ssm_service的pom.xml中导入ssm_dao的依赖.
  • 本篇目录结构开胃小菜入戏时刻注意雷区脱坑指南最后说两句 开胃小菜 今天我要狠狠diss Maven官方(真的各位,...长话短说, 其实就是eclipse使用maven多模块拆分的时候 遇到的的一堆坑. 入戏时刻 注意, 我上面提到两个关
  • _amaze! 转载于:https://www.cnblogs.com/luohaonan/p/11271062.html
  • Maven工程的拆分与聚合

    千次阅读 2018-08-13 14:33:39
    Maven工程的拆分与聚合 之前我们单独创建了一个Maven工程然后根据通过包的划分来分为 web层,service层,和dao层. 其实在一些大型项目中,我们可以通过模块来划分这个三个层 一个层对应一个单独的模块,然后一个人...
  • 多模块拆分的必要性 使用Java技术开发的工程项目,无论是数据处理系统还是Web网站,随着项目的不断发展,需求的不断细化与添加,工程项目中的代码越来越多,包结构也越来越复杂这时候工程的进展就会遇到各种问题: ...
  • maven工程拆分与聚合思想 jar包和自己写的代码没什么区别,自己写的代码也可以打包成jar包,只不过jar中是事先经过编译,已经是class文件 而我们的dao层,卖家和买家查询数据库用的都是dao层,这里就出现共用的东西...
  • 对于以上的模块化拆分后,那么是否还可以像原来一样打成一个可执行Jar包呢?答案是可以的。 1、只需要在每个子工程的Pom.xml中配置包名即可。 <!-- 子工程Jar包名称 --> <finalName>child-project ...
  • === maven拆分各层配置后,【pom.xml、Spring配置都按层拆分(dao/service/action)】,导致报错解决。 Spring配置拆分: =====错误信息:service创建失败。 ===老师:找不到service层Spring配置。 ...
  • 在不拆分项目的情况下,我们是通过扫mapper所在的路径,去实例化Dao的,然而当擦hi分过后,由于是连个项目,路径是找不到的,这种情况下,之前的dataSource和sqlSessionFactory以及包的路径, 我们需要做的是Dao层...
  • 转载地址:https://www.cnblogs.com/whgk/p/7121336.html
  • 首先maven拆分模块的启动方式有3种 1.直接使用父工程中的tomcat插件执行 2.使用idea配置tomcat,启动(需要本地安装tomcat) 3.通过web模块使用tomcat插件运行(问题就是出在这里)。因为模块没子模块的信息,需要使用...
  • 理解继承和聚合 通常继承和聚合同时使用。 何为继承? 继承是为了消除重复,如果将dao、service、web分开创建独立的工程则每个工程的pom.xml文件中的内容存在重复,比如:设置编译版本、锁定spring的版本的等,...
  • 对现在已有maven ssh项目进行拆分拆分思路:将dao层的代码已经配置文件全体提取出来到一个表现上独立的工程中。同样service、action拆分。 ssh-parent: 父工程 ssh-dao:(子模块) ssh-service ssh-web 拆分...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,783
精华内容 7,513
关键字:

maven拆分