2020：0618 --- Maven(高级)

maven高级应用

1. maven基础回顾
2. maven传统的web工程做一个数据查询操作
3. maven工程拆分与聚合的思想。
4. 把第二阶段web工程修改成maven拆分与聚合的形式
5. 私服【远程仓库】
6. 如何安装地三方jar包。
    把第三方jar包安装到本地仓库，把第三方jar包安装到私服。
    
    我们本地仓库中的jar不仅仅是一个jar包，它还遵循特定的目录结构。即jar包坐
标的三要素：GroupId, ArtifactId, version。jar包必须遵循这三个要素，我们才能
通过坐标找到jar包。
    当第三方的公司给了我们一个jar包，但是这个公司却没有给我们jar包在中央仓库
具体的下载地址（或者中央仓库没有收录这个jar包）。我们如果开发中用到这个jar包
，那么必须要让本地仓库也有这个jar包。这个时候，绝对不能手动复制粘贴的方式放
到本地仓库，要通过jar包安装的方式放到本地仓库。

1. Maven基础知识回顾

    Maven是一个项目管理工具
    
    1.依赖管理：
        maven对项目中的jar包的管理过程。传统工程我们直接把jar包放置在项目中。
        maven工程里，jar包放置在仓库中，项目中只用放置jar包的坐标。
        项目编译/运行时，会通过坐标找到jar包。
        
        1.1 仓库的种类：
    
            1.本地仓库
            2.远程仓库（私服）
            3.中央仓库
                maven安装好后，就自动连接着中央仓库。
            
        1.2 仓库之间的关系：
            当我们启动一个maven工程后，maven工程会通过pom文件中的jar包坐标去本地仓库
        找对应的jar包。
            默认情况下，如果本地仓库没有jar包，maven会自动去中央仓库下载jar包到
        本地仓库。
            在公司中如果本地没有对应jar包，会从私服下载jar包。如果私服也没有，
        可以从中央仓库下载或者从本地上传。
        
    2.一键构建：
        maven自身集成了tomcat插件，可以对项目进行编译，测试，打包，安装，发布等操作。
        
        我们以前用的是本地安装的tomcat来对项目进行构建部署。所以一键构建功能并不是我
        们必须的。我们用本地的tomcat也可以构建部署项目。
        
        2.1 maven自身集成的tomcat插件在构建项目的时候，其实是通过命令来执行的。
            这几个命令：
                1.clean：清理以前的构建信息
                2.compile：对src/main/java目录下的代码编译。
                3.test：编译测试代码
                4.package：把包打在了本地编译目录。target目录下
                5.install：把包安装到本地仓库
                6.deploy：会把我们本地做好的项目，直接打包上传到私服。
                
        2.2 maven三套生命周期
            1.clean:一个命令就是一套生命周期---清理生命周期。
            
            2.complie,test,package,install,deploy：一套默认的生命周期。
            
            3.站点生命周期

1.1 Maven解决jar包冲突：

    1.maven导入jar的规则：
        1.直接依赖：项目中直接导入的jar包，就是该项目的直接依赖包。
         （pom直接导入的坐标）
        2.传递依赖：项目中没有直接导入的jar包，可以通过项目直接依赖
          jar包传递到项目中去。
          
    2.jar包冲突：
        直接依赖的jar下会有多个它所需的依赖包，我们称为传递依赖包。
        如果两个直接依赖下都有同一个传递依赖，但是版本却不一样。或者
    直接依赖的Ajar包下有一个传递依赖的Bjar包，同时我们又直接依赖了Bjar包，
    但是版本不一样。
        这时候就会发生jar包冲突问题。到底导入哪个传递依赖呢？
        
    
    3. 解决jar包冲突的三种规则
    
        3.1 解决jar包冲突的规则一：
            第一声明优先原则：哪个jar包的坐标在靠上的位置，这个jar包就是先声明的，
        先声明的jar包坐标下的依赖包，就是我们导入的，进入项目中。
        
        3.1 解决jar包冲突的规则二：直接依赖路径比传递依赖路径近
            当某个jar包即存在直接依赖也存在传递依赖。路径近者优先原则，直接
        依赖路径比传递依赖路径近，那么最终项目进入的jar包会是路径近的直接依赖包。
        
        3.3 解决jar包冲突的规则三：【推荐使用】
            直接排除法：直接排除某个直接依赖包下的传递依赖包。
            当我们要排除某个jar包下依赖包时，在配置<exclusions/>时，内部可以
        不写版本号，因为要排除的依赖包使用的版本和直接依赖的jar包版本一样。

1.2 实际工作中导包时：

    一般也是需要某个技术时，特定导入个别的包。然后判断其下传递依赖是否产生冲突。
    
    我们从此处来看一些依赖关系：

    看一下新导入进来的A包下有哪几个传递依赖包，看一下我们项目中原来是否有这个
传递依赖。如果有的话，我们要用<exclusion/>排除掉这个传递依赖。

1.3 锁定jar包版本。

    任何XML配置文件，里面能写什么，完全取决于上面的约束。（约束不用记）

    1.方便以后修改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>
    ```
    
    2. 为什么要jar包锁定。
    
        maven工程是可以分父子依赖关系的凡是依赖别的项目后，拿到的别的项目的依赖包，
    都属于传递依赖。比如当前A项目被B项目依赖，那么我们A项目中的所有jar包都会传递到
    B项目中。
        B项目的开发者，如果再在B项目中导入一套SSM框架的jar包，对于B项目是直接依赖。
    那么直接依赖的jar包就会把我们A项目传递过去的jar包覆盖掉。
        为了防止以上情况出现，我们可以把A项目中主要的jar包的坐标锁住，那么依赖该
    项目的B项目中，即便有同名的直接依赖jar包，也无法覆盖A项目的jar包。B项目如果
    想用A项目，那么就必须我们A项目的这套jar包。不能在导入同名的直接依赖。
    
        怎么锁住jar包版本：
        除了起到一个锁定jar版本的作用之外，没有导入进来真正的jar包。
        所以锁jar包时，可不能从<dependency/>剪切出来放到<dependencyManagement/>，
    复制进去。
    
    3. 怎么锁住jar包版本：
       除了起到一个锁定jar版本的作用之外，没有导入进来真正的jar包。
       所以锁jar包时，可不能从<dependency/>剪切出来放到<dependencyManagement/>，
    应该复制进去。
        ```
          <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>
        ```

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

2.1 配置环境

    1.创建数据库，建表：导入外部SQL

    2.创建MavenWeb项目
    
    3.补齐web.xml文件头

    ```
    <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">
    ```
    
    4.导入相关SSM依赖，且解决了依赖冲突

    ```
    <!--三大框架所有依赖，且解决了依赖冲突-->
      <!-- 统一管理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>
    ```
    
    5.补全Maven目录结构

    6.因为导入了log4j的依赖，我们将日志配置文件放到resources目录下

# 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

2.2 dao层代码和配置编写

    1. 创建实体类：Items
        
       属性名和数据库表中列一一对应。
    
    2. 创建dao接口：ItemsDao
        
        定义案例方法：findById
        ```
        public interface ItemsDao {
            public Items findById(Integer id);
        }
        ```
    
    3. Mybatis配置文件 
    
        因为我们要整合Mybatis，所以不用写dao的实体类。让mybatis帮我们生成接口的
    代理对象。
    
        1.在resources目录下创建一个跟接口在同一个包路径下的Mapper映射文件：
        ItemsDao.xml
        
        2.导入约束：mapper头部声明
          写dao映射
        ```
        <?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.itheima.dao.ItemsDao">
            <select id="findById" parameterType="int" resultType="Items">
                select * from items where id = #{id}
            </select>
        </mapper>
        ```
        
            现在这个dao的映射文件也写完了，按理说还要写一个主配置文件SqlMapperConfig
        将mapper映射文件交给主配置文件来管理。
            但是我们现在是spring和mybatis做整合的，所以不用再创建mybatis主配置文件。
        而是将原来要放到主配置文件中的信息，都交给Spring容器来管理。
        
    
    4. 在resources目录下创建Spring配置文件:applicationContext.xml
    
        1. 导入约束：
```
<?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">
</beans>
```

        2.dao层配置的编写
        
            1.配置连接池

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:8080/maven2"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

            2.配置一个生产SqlSession对象的SqlSessionFactory工厂
                我们不能在spring配置文件中直接生产qlSession，因为我们希望它每一次
            操作都是新的SqlSession。
                SqlSession是线程不安全的，不能线程共享。
                
                *配置typeAliasesPackage属性：扫描指定的pojo包，给包下所有pojo
            对象起别名。
                自动扫描包路径，给包下面的实体类都会注册别名，并且类名就是别名，
            不再区分大小写。
            
                配置好后dao的映射配置文件就可以在使用pojo类时用别名了。

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource"></property>
  <property name="typeAliasesPackage" value="com.itheima.domain"></property>
</bean>

            3.
                有了操作数据库的对象SqlSession，调用getMapper方法后就可以生成
            dao的代理对象。
                
                我们要将生成的代理放到IOC容器中：
            所以扫描接口包路径：生成包下的所有接口的代理对象，并且放到spring容器中。

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定生成哪些接口的代理对象-->
        <property name="basePackage" value="com.itheima.dao"></property>
    </bean>

2.3 service层代码和配置编写

    1. ItemsService接口：

        public interface ItemsService {
            public Items findById(Integer id);
        }

    2. ItemsServiceImpl
    
        @Service标注在ItemsServiceImpl实现类上，是因为ItemsService接口不能实例化
    所以也不能交个Spring实例化。

        @Service
        public class ItemsServiceImpl implements ItemsService {
        
            @Autowired
            private ItemsDao itemsDao;
        
            public Items findById(Integer id) {
                return itemsDao.findById(id);
            }
        }

    3. Service层的Spring配置。
      applicationContext.xml

    <!--2.service层配置开始：声明式事务-->
    <!--2.1 组件扫描配置 : @Service
        因为Controller交给MVC管理，所以具体到到com.itheima.service.
    -->
    <context:component-scan base-package="com.itheima.service.impl"></context:component-scan>
    
    <!--2.2配置事务管理器-->
    <!--AOP是面向切面编程，切面就是切入点和通知的组合
        我们的事务管理器就是增强类，即里面有通知（开启事务，提交事务，回滚...）
        
        transactionManager这个通知类是框架提供的一个通用的通知类，如果我们想要加
        一些自定义的东西，还需要自行配置。
    -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--控制事务肯定用到coon-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <!--2.2.1 配置事务的通知-->
    <tx:advice id="ad">
        <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:attributes>
    </tx:advice>
    
    <!--2.3 配置切面：切入点和通知的组合-->
    <aop:config>
        <!--配置通用的切入点表达式
            public Items/void com.itheima.service.impl.ItemsServiceImpl.findById(Integer id)
        -->
        <aop:pointcut id="pointcut" expression="execution(* com.itheima.service.impl.*.*(..))"/>
        
        <!--2.4通知类配置好了，切入点也配置好了，把他两整和到一起，配置切面-->
        <aop:advisor advice-ref="ad" pointcut-ref="pointcut"></aop:advisor>
    </aop:config>
    <!--service层配结束：配置好了Spring的声明式事务-->

2.4 web层代码和配置编写

    1. 控制器类

        @Controller
        @RequestMapping("/items")
        public class ItemsController {
        
            @Autowired
            private ItemsService itemsService;
        
            /**
             * 因为要向页面传值：参数Model
             * @param model
             * @return
             */
            @RequestMapping("/findDetail")
            public String findDetaild(Model model){
                Items item = itemsService.findById(1);
        
                //放到Model方便页面取
                model.addAttribute("item",item);
        
                //跳转到对应页面：根据视图解析器来拼接前缀和后缀。
                return "itemDetail";
            }
        }

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

    <!--1.配置组件扫描:为了@Controller能起作用-->
    <context:component-scan base-package="com.itheima.controller"></context:component-scan>

    <!--2.处理器映射器，处理器适配器-->
    <mvc:annotation-driven></mvc:annotation-driven>

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

    <!--4.不拦截静态资源
        将来凡是碰到静态资源，就会交给default-servlet-handler默认的HttpServlet来处理，而不是
        DispatcherServlet处理。
    -->
    <mvc:default-servlet-handler></mvc:default-servlet-handler>

    <!---->

</beans>

    3. 创建Controller中方法要跳转的页面：/WEB-INF/pages/itemDetail.jsp

    4.我们要把这些所有的配置文件的资源放到Servlet容器中
      配置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容器中-->

    <!--1.编码过滤器-->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <!--CharacterEncodingFilter类中有setEncoding属性-->
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
            <!--使用上面的编码：CharacterEncodingFilter类中的setForceEncoding属性-->
        <init-param>
            <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>

    <!--2.配置spring核心监听器：用于加载Spring配置文件。
        默认只能监听WEB-INF/applicationContext.xml这样一个配置文件
        但是我们这个配置文件当前并不在该路径下，所以重新指定Spring配置文件路径
    -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--2.1重新指定Spring配置文件路径
        contextConfigLocation是ContextLoaderListener父类的一个属性
        ContextLoaderListener加载时，会查找名为contextConfigLocation的参数。
    -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!--3.SpringMVC的核心Servlet-->
    <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: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>

3. maven工程拆分与聚合的思想。

    对于刚才整合的SSM项目，我们来分析一下：
    
    类比订单操作：
        买家：买家要看到订单，必须要查询数据库，dao层的任务。
        卖家：卖家要看到订单，必须要查询数据，dao层的任务。
        
    dao层的查询操作在双方调用时都是一样的，那么就可以考虑把它抽取出来。
    一份代码可重用：修改的话，只需修改这一份代码即可。
    一份代码复制黏贴到不同项目：每个项目都要修改。
    
    
Maven的拆分思想：    
    Maven解决代码可重用和便于维护问题上是怎么解决的呢？
        Maven把一个完整的项目，分成不同的独立模块，这些模块都有各自独立的坐标。
    哪个地方需要用到某个模块，就直接引用模块即可。
        今后如果公司开发一个新的项目，我们首先考虑的不是dao,service,domain...
    如何编写。而是这些模块是否已经存在，如果存在就直接引用。
        这就是Maven的拆分思想
        
Maven的聚合思想：

    我们可以把拆分零散的模块聚合到一起编写一个完整的项目，这就是Maven的聚合思想。