一、maven基础知识回顾

1.1 maven介绍

maven 是一个项目管理工具，主要作用是在项目开发阶段对Java项目进行依赖管理和项目构建。

依赖管理：就是对jar包的管理。通过导入maven坐标，就相当于将仓库中的jar包导入了当前项目中。

项目构建：通过maven的一个命令就可以完成项目从清理、编译、测试、报告、打包，部署整个过程。
Maven 进阶(分模块构建&Maven私服)_java

1.2 maven的仓库类型

1.本地仓库

2.远程仓库

①maven中央仓库（地址：http://repo2.maven.org/maven2/）

②maven私服（公司局域网内的仓库，需要自己搭建）

③其他公共远程仓库（例如apache提供的远程仓库，地址：http://repo.maven.apache.org/maven2/）

1.3 maven常用命令

clean： 清理

compile：编译

test： 测试

package：打包

install： 安装

1.4 maven坐标书写规范

Maven 进阶(分模块构建&Maven私服)_mvc_02

1.5 maven的依赖范围

< scope > 标签

依赖范围 对于编译classpath有效 对于测试classpath有效 对于运行时classpath有效 例子
compile Y Y Y spring-core
test - Y - Junit
provided Y Y - servlet-api
runtime - Y Y JDBC驱动
system Y Y - 本地的，maven仓库之外的类库

二、maven的依赖传递

2.1 什么是依赖传递

在maven中，依赖是可以传递的，假设存在三个项目，分别是项目A，项目B以及项目C。假设C依赖B，B依赖A，那么我们可以根据maven项目依赖的特征不难推出项目C也依赖A。

Maven 进阶(分模块构建&Maven私服)_xml_03

​ Maven 进阶(分模块构建&Maven私服)_spring_04

通过上面的图可以看到，我们的web项目直接依赖了spring-webmvc，而spring-webmvc依赖了sping-aop、spring-beans等。最终的结果就是在我们的web项目中间接依赖了spring-aop、spring-beans等。

2.2 什么是依赖冲突

由于依赖传递现象的存在， spring-webmvc 依赖 spirng-beans-4.2.4，spring-aop 依赖 spring-beans-5.0.2，但是发现 spirng-beans-4.2.4 加入到了工程中，而我们希望 spring-beans-5.0.2 加入工程。这就造成了依赖冲突。

Maven 进阶(分模块构建&Maven私服)_maven_05

2.3 如何解决依赖冲突

1.使用maven提供的依赖调解原则

第一声明者优先原则
路径近者优先原则

2.排除依赖

3.锁定版本

2.4 依赖调节原则——第一声明者优先原则

在 pom 文件中定义依赖，以先声明的依赖为准。其实就是根据坐标导入的顺序来确定最终使用哪个传递过来的依赖。

Maven 进阶(分模块构建&Maven私服)_mvc_06

结论：通过上图可以看到，spring-aop和spring-webmvc都传递过来了spring-beans，但是因为spring-aop在前面，所以最终使用的spring-beans是由spring-aop传递过来的，而spring-webmvc传递过来的spring-beans则被忽略了。

2.5 排除依赖

可以使用exclusions标签将传递过来的依赖排除出去。

Maven 进阶(分模块构建&Maven私服)_java_07

2.6 版本锁定

采用直接锁定版本的方法确定依赖jar包的版本，版本锁定后则不考虑依赖的声明顺序或依赖的路径，以锁定的版本为准添加到工程中，此方法在企业开发中经常使用。

版本锁定的使用方式：

第一步：在dependencyManagement标签中锁定依赖的版本

第二步：在dependencies标签中声明需要导入的maven坐标

①在dependencyManagement标签中锁定依赖的版本
Maven 进阶(分模块构建&Maven私服)_java_08

②在dependencies标签中声明需要导入的maven坐标
Maven 进阶(分模块构建&Maven私服)_java_09

三、分模块构建maven工程

3.1 分模块构建maven工程分析

在现实生活中，汽车厂家进行汽车生产时，由于整个生产过程非常复杂和繁琐，工作量非常大，所以车场都会将整个汽车的部件分开生产，最终再将生产好的部件进行组装，形成一台完整的汽车。

Maven 进阶(分模块构建&Maven私服)_mvc_10

Maven 进阶(分模块构建&Maven私服)_spring_11

3.2 maven工程的继承

在Java语言中，类之间是可以继承的，通过继承，子类就可以引用父类中非private的属性和方法。同样，在maven工程之间也可以继承，子工程继承父工程后，就可以使用在父工程中引入的依赖。继承的目的是为了消除重复代码。

Maven 进阶(分模块构建&Maven私服)_spring_12

3.3 maven工程的聚合

在maven工程的pom.xml文件中可以使用< modules>标签将其他maven工程聚合到一起，聚合的目的是为了进行统一操作。

例如拆分后的maven工程有多个，如果要进行打包，就需要针对每个工程分别执行打包命令，操作起来非常繁琐。这时就可以使用
< modules>标签将这些工程统一聚合到maven工程中，需要打包的时候，只需要在此工程中执行一次打包命令，其下被聚合的工程就都会被打包了。

Maven 进阶(分模块构建&Maven私服)_java_13

3.4 分模块构建maven工程具体实现

Maven 进阶(分模块构建&Maven私服)_java_14
①父工程ssm_parent构建

父工程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>cn.kinggm520</groupId>
    <artifactId>ssm_parent</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>ssm_dao</module>
        <module>ssm_service</module>
        <module>ssm_web</module>
    </modules>


    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.0.5.RELEASE</spring.version>
        <springmvc.version>5.0.5.RELEASE</springmvc.version>
        <mybatis.version>3.4.5</mybatis.version>
    </properties>

    <!--锁定jar版本-->
    <dependencyManagement>
        <dependencies>
            <!-- Mybatis -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <!-- springMVC -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${springmvc.version}</version>
            </dependency>
            <!-- spring -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</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-aop</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-expression</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-aspects</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-test</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-tx</artifactId>
                <version>${spring.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>


    <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>
        <!-- springMVC核心-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <!-- spring相关 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--分页助手-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.2</version>
        </dependency>

        <dependency>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
            <version>1.0</version>
        </dependency>

        <!--解析Json-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.0</version>
        </dependency>

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

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </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>

② 2.1子工程ssm_dao构建

Maven 进阶(分模块构建&Maven私服)_spring_15

2.2 配置ssm_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>ssm_parent</artifactId>
        <groupId>cn.kinggm520</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ssm_dao</artifactId>

</project>

2.3 创建DAO接口和Mapper映射文件

RoleMapper

package cn.kinggm520.dao;

import cn.kinggm520.domain.Role;

import java.util.List;

/**
 * 作者: kinggm Email:731586355@qq.com
 * 时间:  2020-03-26 11:34
 */
public interface RoleMapper {

//    查询所有角色
    List<Role> findAll() throws Exception;

//    添加角色
    void save(Role role) throws Exception;

    //删除角色
    void delRole(Long roleId) throws Exception;

//    查询当前用户的所有角色
    List<Role> findRoleByUserId(Long userId) throws Exception;
}


package cn.kinggm520.dao;

import cn.kinggm520.domain.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * 作者: kinggm Email:731586355@qq.com
 * 时间:  2020-03-26 17:18
 */
public interface UserMapper {


    //    用户登录
    User login(User user);

    //    查询所有
    List<User> findAll() throws Exception;

    //    删除用户
    void delUser(Long userId) throws Exception;

    //    删除用户角色关系
    void delUserRoleRel(Long userId) throws Exception;

    //    添加用户
    Long save(User user) throws Exception;

    //    添加用户角色关系
    void saveUserRoleRel(@Param("userId") Long userId, @Param("roleId") Long roleId) throws Exception;


}

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"
       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">



    <!--加载jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置数据源对象-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <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>



    <!--整合Mybatis-->
    <!--创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:SqlMapConfig.xml"/>
    </bean>

    <!--引入映射配置文件-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.kinggm520.dao"/>
    </bean>

</beans>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_studyspring
jdbc.username=root
jdbc.password=123456

SqlMapConfig.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>


    <!--统一设置别名 别名就是类名不区分大小写-->
    <typeAliases>
       <package name="cn.kinggm520.domain"/>
    </typeAliases>

<!--配置分页助手插件-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!--选择数据库方言-->
            <property name="helperDialect" value="mysql"/>
            <!--reasonable：默认值是false
               true:自动处理首页和尾页，如果是第一页，再点上一页还是第一页不需要在前端去做是否为首页的判断
               如果是尾页，再点下一页还是最后一页，也不需要在前端做是否为尾页的判断
                -->
            <property name="reasonable" value="true"/>
        </plugin>
    </plugins>


</configuration>

映射文件：
Maven 进阶(分模块构建&Maven私服)_xml_16
RoleMapper.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="cn.kinggm520.dao.RoleMapper">

    <!--查询所有角色-->
    <select id="findAll" resultType="role">
        select *  from sys_role
    </select>


    <!--添加角色-->
    <insert id="save" parameterType="role">
        insert into sys_role values(null,#{roleName},#{roleDesc})
    </insert>

    <!--删除角色-->
    <delete id="delRole" parameterType="long" >
        delete from sys_role where id =#{id}
    </delete>


    <!--通过userId查找对应角色信息-->
    <select id="findRoleByUserId" parameterType="long" resultType="role">
        SELECT r.`roleName` FROM sys_user_role ur,sys_role r WHERE ur.`roleId`=r.`id`  AND ur.`userId`=#{id}
    </select>

</mapper>

UserMapper.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="cn.kinggm520.dao.UserMapper">

    <!--登录-->
    <select id="login" parameterType="user" resultType="user">
        select * from sys_user where username=#{username} and password=#{password}
    </select>

    <!--查询用户列表-->
    <select id="findAll" resultType="user">
        select * from sys_user
    </select>

    <!--删除用户-->
    <delete id="delUser" parameterType="long">
        delete from sys_user where id =#{userId}
    </delete>

    <!--删除用户角色关系-->
    <delete id="delUserRoleRel" parameterType="long">
        delete from sys_user_role where userId = #{userId}
    </delete>


    <!--添加用户-->
    <insert id="save" parameterType="user">
        <!-- 保存成功以后, 获取字段为id的值,赋给User对象的id属性 -->
        <selectKey keyProperty="id" keyColumn="id" resultType="Long" order="AFTER">
            select last_insert_id()
        </selectKey>
        insert into sys_user values(NULL ,#{username},#{email},#{password},#{phoneNum})
    </insert>


    <!--添加用户角色关系-->
    <insert id="saveUserRoleRel" parameterType="long">
        insert into sys_user_role VALUES (#{userId},#{roleId})
    </insert>
</mapper>

③子工程ssm_service构建

Maven 进阶(分模块构建&Maven私服)_java_17

​ 第一步：创建ssm_service工程

​ 第二步：配置ssm_service工程的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>ssm_parent</artifactId>
        <groupId>cn.kinggm520</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ssm_service</artifactId>

    <dependencies>

        <dependency>
            <groupId>cn.kinggm520</groupId>
            <artifactId>ssm_dao</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

</project>

​ 第三步：创建Service接口和实现类

RoleService

package cn.kinggm520.service;

import cn.kinggm520.domain.Role;

import java.util.List;

/**
 * 作者: kinggm Email:731586355@qq.com
 * 时间:  2020-03-26 11:32
 */

public interface RoleService {

    //    查询所有角色
    List<Role> findAll() throws Exception;


    //    添加角色
    void save(Role role) throws Exception;

    //删除角色
    void delRole(Long roleId) throws Exception;

    //    查询当前用户的所有角色
    List<Role> findRoleByUserId(Long userId) throws Exception;
}



package com.itheima.ssm.service;

import com.itheima.ssm.dao.ItemMapper;
import com.itheima.ssm.pojo.Item;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class ItemServiceImpl implements ItemService {
    @Autowired
    private ItemMapper itemMapper;

    public Item findById(int id) {
        return itemMapper.findById(id);
    }
}

UserService

package cn.kinggm520.service;

import cn.kinggm520.domain.User;
import com.github.pagehelper.PageInfo;

import java.util.List;

/**
 * 作者: kinggm Email:731586355@qq.com
 * 时间:  2020-03-26 17:19
 */
public interface UserService {

    //    用户登录
    User login(User user);

//    查询所有
    List<User> findAll() throws Exception;

    //    分页查询
    PageInfo<User> findByPage(int pageNum, int pageSize) throws Exception;

    //    删除用户
    void delUser(Long userId) throws Exception;

//    添加用户
    void save(User user, Long[] roleIds) throws Exception;

}

创建实现类：

RoleServiceImpl

package cn.kinggm520.service.impl;

import cn.kinggm520.dao.RoleMapper;
import cn.kinggm520.domain.Role;
import cn.kinggm520.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 作者: kinggm Email:731586355@qq.com
 * 时间:  2020-03-26 11:33
 */
@Service
public class RoleServiceImpl implements RoleService {

    @Autowired
    private RoleMapper roleMapper;
    //    查询所有角色
    public List<Role> findAll() throws Exception {
        return roleMapper.findAll();
    }


    //    添加角色
    public void save(Role role) throws Exception {
         roleMapper.save(role);
    }

//    删除角色
    public void delRole(Long roleId) throws Exception {
        roleMapper.delRole(roleId);
    }

    public List<Role> findRoleByUserId(Long userId) throws Exception {
        return null;
    }


}

UserServiceImpl

package cn.kinggm520.service.impl;

import cn.kinggm520.dao.RoleMapper;
import cn.kinggm520.dao.UserMapper;
import cn.kinggm520.domain.Role;
import cn.kinggm520.domain.User;
import cn.kinggm520.service.UserService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 作者: kinggm Email:731586355@qq.com
 * 时间:  2020-03-26 17:19
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RoleMapper roleMapper;


    //    用户登录
    public User login(User user) {
        return userMapper.login(user);
    }

    //    查询用户列表
    public List<User> findAll() throws Exception {
        List<User> userList = userMapper.findAll();
        for (User user : userList) {
            List<Role> roleList = roleMapper.findRoleByUserId(user.getId());
            user.setRoles(roleList);
        }
        return userList;
    }

//    分页
    public PageInfo<User> findByPage(int pageNum, int pageSize) throws Exception {

        // 分页助手
        PageHelper.startPage(pageNum, pageSize);
        List<User> users = findAll();
        // 分页信息对象
        PageInfo<User> pb = new PageInfo<User>(users);
        return pb;
    }


    //    删除用户
    public void delUser(Long userId) throws Exception {
//       先删除用户角色关系
        userMapper.delUserRoleRel(userId);
//        再删除用户
        userMapper.delUser(userId);
    }


    //    添加用户
    public void save(User user, Long[] roleIds) throws Exception {
        userMapper.save(user);
        for (Long roleId : roleIds) {
            userMapper.saveUserRoleRel(user.getId(), roleId);
        }
    }


}

第四步：创建spring配置文件applicationContext-service.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/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">

<!--导入dao配置文件-->
    <import resource="classpath:applicationContext-dao.xml"/>

    <!--Spring 配置包注解扫描-->
    <context:component-scan base-package="cn.kinggm520.service"/>


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

    <!--配置事务管理-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add*" read-only="false"/>
            <tx:method name="save*" read-only="false"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="update*" read-only="false"/>
            <tx:method name="delete*" read-only="false"/>

        </tx:attributes>
    </tx:advice>

    <!--配置织入-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* cn.kinggm520.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
    </aop:config>


</beans>

④子工程ssm_web构建

Maven 进阶(分模块构建&Maven私服)_xml_18
​ 第一步：创建ssm_web工程，注意打包方式为war

​ 第二步：配置ssm_web工程的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>ssm_parent</artifactId>
        <groupId>cn.kinggm520</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ssm_web</artifactId>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>cn.kinggm520</groupId>
            <artifactId>ssm_service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

​ 第三步：创建Controller
RoleController

package cn.kinggm520.controller;

import cn.kinggm520.domain.Role;
import cn.kinggm520.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.List;

/**
 * 作者: kinggm Email:731586355@qq.com
 * 时间:  2020-03-26 11:29
 */

@RequestMapping("/role")
@Controller
public class RoleController {

    @Autowired
    private RoleService roleService;

//       查询所有角色
    @RequestMapping("/list")
    public ModelAndView list(ModelAndView modelAndView) throws Exception {

        List<Role> roleList =  roleService.findAll();

        modelAndView.addObject("roleList",roleList);

        modelAndView.setViewName("role-list");

        return modelAndView;

    }

    //    添加角色
    @RequestMapping("/save")
    public String save(Role role) throws Exception {
        roleService.save(role);
        return "redirect:/role/list";
    }


    //删除角色
    @RequestMapping(value = "/del/{roleId}")
    public String del(@PathVariable(value = "roleId") Long roleId) throws Exception {
        roleService.delRole(roleId);
        return "redirect:/role/list";
    }


}

UserController

package cn.kinggm520.controller;

import cn.kinggm520.domain.Role;
import cn.kinggm520.domain.User;
import cn.kinggm520.service.RoleService;
import cn.kinggm520.service.UserService;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.List;

/**
 * 作者: kinggm Email:731586355@qq.com
 * 时间:  2020-03-26 17:17
 */

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;
    @Autowired
    private RoleService roleService;


    //    登录
    @RequestMapping("/login")
    public String login(User user, HttpSession session, HttpServletRequest request, HttpServletResponse response, String remember) throws ServletException, IOException {
        User currentUser = userService.login(user);
        if (currentUser != null) {
            if("remember_me".equals(remember)){
                Cookie cookie = new Cookie("user_cookie",user.getUsername()+"&"+user.getPassword());
                cookie.setPath(request.getContextPath());
                cookie.setMaxAge(24*3600*7);
                response.addCookie(cookie);
            }
            session.setAttribute("user", currentUser);
            return "redirect:/index.jsp";
        }
        request.setAttribute("user", user);
        request.setAttribute("errorMsg", "用户名或密码错误！");
        return "forward:/login.jsp";

    }


//    跳转到主页
    @RequestMapping("/main")
    public String main(){
        return "redirect:/pages/main.jsp";
    }


    //    用户列表展示
    @RequestMapping("/list")
    public ModelAndView list(ModelAndView modelAndView,
                            @RequestParam(name = "pageNum",defaultValue = "1") Integer pageNum,
                            @RequestParam(name = "pageSize",defaultValue = "3") Integer pageSize) throws Exception {

        // 分页助手
        PageInfo<User> pb = userService.findByPage(pageNum, pageSize);

        List<User> userList = userService.findAll();
        modelAndView.addObject("pb", pb);
        modelAndView.setViewName("user-list");
        return modelAndView;

    }

    //    删除用户
    @RequestMapping("/del/{userId}")
    public String del(@PathVariable(value = "userId") Long userId) throws Exception {
        userService.delUser(userId);
        return "redirect:/user/list";
    }

    //    异步获取角色信息
    @RequestMapping("/getRoleList")
    @ResponseBody
    public List<Role> saveUI() throws Exception {
        List<Role> roleList = roleService.findAll();
        return roleList;
    }




    //    添加用户
    @RequestMapping("/save")
    public String save(User user, Long[] roleIds) throws Exception {
        userService.save(user, roleIds);
        return "redirect:/user/list";
    }


    //    退出
    @RequestMapping("/quit")
    public String quit(HttpServletRequest request, HttpServletResponse response) {
        HttpSession session = request.getSession();
        session.removeAttribute("user");
        Cookie cookie = new Cookie("user_cookie",null);
        cookie.setPath(request.getContextPath());
        cookie.setMaxAge(0);
        response.addCookie(cookie);
        return "redirect:/login.jsp";
    }

}

第四步创建拦截器：

package cn.kinggm520.interceptor;

import cn.kinggm520.domain.User;
import cn.kinggm520.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * 作者: kinggm Email:731586355@qq.com
 * 时间:  2020-03-26 17:12
 */
@Component
public class MyInterceptor implements HandlerInterceptor {

    @Autowired
    private UserService userService;

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 访问静态资源不拦截
        if (handler instanceof DefaultServletHttpRequestHandler) {
            return true;
        }

        HttpSession session = request.getSession();

        //  如果勾选的记住密码 就把cookie里的用户信息设置到session
        Cookie[] cookies = request.getCookies();
        String username;
        String password;
        if (cookies != null) {
            for (Cookie cookie : cookies) {
                if ("user_cookie".equals(cookie.getName())) {
                    username = cookie.getValue().split("&")[0];
                    password = cookie.getValue().split("&")[1];
                    User user = new User();
                    user.setUsername(username);
                    user.setPassword(password);
                    session.setAttribute("user",userService.login(user));
                }
            }
        }



        User  user = (User) session.getAttribute("user");
        if (user == null) {
//            用户未登录 重定向到登录页面
            System.out.println(request.getContextPath());

            response.sendRedirect(request.getContextPath() + "/login.jsp");
            return false;
        }



        //        登录了 放行
        return true;
    }


}

第五步 配置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="3.1">

    <!--解决乱码的过滤器-->
    <filter>
        <filter-name>CharacterEncodingFilter</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>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


    <!--全局的初始化参数-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!--Spring的监听器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>



    <!--SpringMVC的前端控制器-->
    <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:spring-mvc.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>

​ 第六步：创建spring-mvc配置文件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:mvc="http://www.springframework.org/schema/mvc"
       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/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
">
    <!--注解包扫描-->
    <context:component-scan base-package="cn.kinggm520.controller"/>


    <!--mvc 注解驱动 方便解析json-->
    <mvc:annotation-driven/>

    <!--静态资源权限开放-->
    <mvc:default-servlet-handler/>

    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>




    <!--配置简单映射异常处理器-->
   <!-- <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="defaultErrorView" value="error"/>
    </bean>-->

    <!--配置权限拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--配置对哪些资源执行拦截操作-->
            <mvc:mapping path="/**"/>
            <!--配置哪些资源排除拦截操作-->
            <mvc:exclude-mapping path="/user/login"/>
            <bean class="cn.kinggm520.interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

创建applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="classpath:applicationContext-service.xml"/>

</beans>

项目整体结构如下：

1）ssm_parent为父工程，其余工程为子工程，都继承父工程ssm_parent

2）ssm_parent工程将其子工程都进行了聚合

3）子工程之间存在依赖关系，比如ssm_dao依赖，ssm_service依赖ssm_dao、ssm_web依赖ssm_service

四、 maven私服

4.1 私服说明

maven仓库分为本地仓库和远程仓库，而远程仓库又分为maven中央仓库、其他远程仓库和私服（私有服务器）。其中，中央仓库是由maven官方提供的，而私服就需要我们自己搭建了。

maven私服就是公司局域网内的maven远程仓库，每个员工的电脑上安装maven软件并且连接maven私服，程序员可以将自己开发的项目打成jar并发布到私服，其它项目组成员就可以从私服下载所依赖的jar。私服还充当一个代理服务器的角色，当私服上没有jar包时会从maven中央仓库自动下载。

nexus 是一个maven仓库管理器（其实就是一个软件），nexus可以充当maven私服，同时nexus还提供强大的仓库管理、构件搜索等功能。

4.2 搭建maven私服

①下载nexus

https://help.sonatype.com/repomanager2/download/download-archives—repository-manager-oss

②安装nexus

将下载的压缩包进行解压，进入bin目录

Maven 进阶(分模块构建&Maven私服)_spring_19

打开cmd窗口并进入上面bin目录下，执行nexus.bat install命令安装服务（注意需要以管理员身份运行cmd命令）

Maven 进阶(分模块构建&Maven私服)_mvc_20

③启动nexus

经过前面命令已经完成nexus的安装，可以通过如下两种方式启动nexus服务：

在Windows系统服务中启动nexus

Maven 进阶(分模块构建&Maven私服)_maven_21

在命令行执行nexus.bat start命令启动nexus

④访问nexus

启动nexus服务后，访问http://localhost:8081/nexus

点击右上角LogIn按钮，进行登录。使用默认用户名admin和密码admin123登录系统

登录成功后点击左侧菜单Repositories可以看到nexus内置的仓库列表（如下图）

Maven 进阶(分模块构建&Maven私服)_maven_22
nexus仓库类型

通过前面的仓库列表可以看到，nexus默认内置了很多仓库，这些仓库可以划分为4种类型，每种类型的仓库用于存放特定的jar包，具体说明如下：

①hosted，宿主仓库，部署自己的jar到这个类型的仓库，包括Releases和Snapshots两部分，Releases为公司内部发布版本仓库、 Snapshots为公司内部测试版本仓库

②proxy，代理仓库，用于代理远程的公共仓库，如maven中央仓库，用户连接私服，私服自动去中央仓库下载jar包或者插件

③group，仓库组，用来合并多个hosted/proxy仓库，通常我们配置自己的maven连接仓库组

④virtual(虚拟)：兼容Maven1版本的jar或者插件

Maven 进阶(分模块构建&Maven私服)_spring_23
nexus仓库类型与安装目录对应关系

Maven 进阶(分模块构建&Maven私服)_spring_24

4.3 将项目发布到maven私服

maven私服是搭建在公司局域网内的maven仓库，公司内的所有开发团队都可以使用。例如技术研发团队开发了一个基础组件，就可以将这个基础组件打成jar包发布到私服，其他团队成员就可以从私服下载这个jar包到本地仓库并在项目中使用。

将项目发布到maven私服操作步骤如下：

  1. 配置maven的settings.xml文件
<server>
<id>releases</id>
<username>admin</username>   
<password>admin123</password>
</server>
<server>
<id>snapshots</id>
<username>admin</username>
<password>admin123</password>
</server>

​ 注意：一定要在idea工具中引入的maven的settings.xml文件中配置

  1. 配置项目的pom.xml文件
<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>
  1. 执行deploy命令

Maven 进阶(分模块构建&Maven私服)_spring_25

4.4 从私服下载jar到本地仓库

前面我们已经完成了将本地项目打成jar包发布到maven私服，下面我们就需要从maven私服下载jar包到本地仓库。

具体操作步骤如下：

在maven的settings.xml文件中配置下载模板

<profile>
	<id>dev</id>
		<repositories>
		<repository>
			<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>public</id>
		<name>Public Repositories</name>
		<url>
		http://localhost:8081/nexus/content/groups/public/</url>
		</pluginRepository>
		</pluginRepositories>
</profile>

在maven的settings.xml文件中配置激活下载模板

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

五、 将第三方jar安装到本地仓库和maven私服

在maven工程的pom.xml文件中配置某个jar包的坐标后，如果本地的maven仓库不存在这个jar包，maven工具会自动到配置的maven私服下载，如果私服中也不存在，maven私服就会从maven中央仓库进行下载。

但是并不是所有的jar包都可以从中央仓库下载到，比如常用的Oracle数据库驱动的jar包在中央仓库就不存在。此时需要到Oracle的官网下载驱动jar包，然后将此jar包通过maven命令安装到我们本地的maven仓库或者maven私服中，这样在maven项目中就可以使用maven坐标引用到此jar包了。

5.1 将第三方jar安装到本地仓库

①下载Oracle的jar包（略）

②mvn install命令进行安装

​ mvn install:install-file -Dfile=ojdbc14-10.2.0.4.0.jar -DgroupId=com.oracle -DartifactId=ojdbc14 –

​ Dversion=10.2.0.4.0 -Dpackaging=jar

③查看本地maven仓库，确认安装是否成功

Maven 进阶(分模块构建&Maven私服)_spring_26

5.2 将第三方jar安装到maven私服

①下载Oracle的jar包（略）

②在maven的settings.xml配置文件中配置第三方仓库的server信息

<server>
  <id>thirdparty</id>
  <username>admin</username>
  <password>admin123</password>
</server>

③执行mvn deploy命令进行安装

​ mvn deploy:deploy-file -Dfile=ojdbc14-10.2.0.4.0.jar -DgroupId=com.oracle -DartifactId=ojdbc14 –

​ Dversion=10.2.0.4.0 -Dpackaging=jar –

​ Durl=http://localhost:8081/nexus/content/repositories/thirdparty/ -DrepositoryId=thirdparty