zoukankan      html  css  js  c++  java
  • Maven

    Maven讲义
    Maven概述
    Maven是什么
    Maven是一个由Apache基金会维护的项目构建工具
     
    项目构建是什么
    我们将项目的代码从源代码具体程序文件的过程称为代码构建。
    行为包括:编译、测试、运行、打包、部署的过程
     
    Eclipse项目构建
    Eclipse构建项目的过程图示:
     
     
     
    构建过程如下:
    1. 创建一个Web项目
    2. 在项目中编写好源代码和配置文件
    3. 对源代码编译生成class文件
    4. 通过Junit对代码单元测试
    5. 将项目通过Eclipse工具放在Tomcat运行
    6. 将项目导出war,放在Tomcat运行
     
    Maven构建项目
    通过Maven构建工具可以一条命令完成上面所有的操作:
     
     
    1. *clean,清除命令,作用清除已经编译的class文件和war文件
    2. *compile,编译命令,作用是将java文件编译成class文件
    3. *package,打包命令,作用将class文件打成war包
    4. test,测试命令,作用执行Junit工具(可以忽略)
    5. deploy,部署命令,将war包放在指定的tomcat(可以忽略)
    6. *运行Tomcat,通过命令tomcat7:run (要加入Maven工具的Tomcat7插件)
    7. *install,安装命令,一条命令包括了,clean complile package test
     
    使用Maven的好处
    1. 使用命令,一键快速编译部署
    2. 对项目的构建更加精细化,适合大型项目的构建
    3. Maven支持直接通过配置文件(POM)的配置下载依赖的包
    4. 各大开源社区强制使用Maven导包,意味着如果不学它,有很多的开源项目不好入门。
     
    Maven的安装
    Maven说明
    下载路径:http://maven.apache.org/download.cgi
    目录说说明:
     
    环境配置
    第一步:确定JAVA_HOME配置
    前提:如果要在CMD命令行运行Maven,必须要配置JAVA_HOME环境变量
    通过set命令
     
     
    如果没有配置JAVA_HOME环境会导致运行获得Java运行环境,异常如下:
     
     
     
    第二步:配置MAVEN_HOME环境变量
     
     
    第三步:指定Maven执行命令到当前目录
    配置执行目录到PATH环境变量,让命令可以在当前目录可以执行
    --变量Path变量
    --成功增加结果变量:%MAVEN_HOME%in
     
    第四步:测试配置,在CMD下键入mvn -h
    如果返回参数提示如下图,说明配置成功!
     
    第五步:配置Maven国内源
    由于默认Maven使用国外的源,会导致下载jar比较慢。
    配置Maven下conf文件夹的settings.xml文件
    <mirrors>
    <!-- mirror
    | Specifies a repository mirror site to use instead of a given repository. The repository that
    | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
    | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
    |
    <mirror>
    <id>mirrorId</id>
    <mirrorOf>repositoryId</mirrorOf>
    <name>Human Readable Name for this Mirror.</name>
    <url>http://my.repository.com/repo/path</url>
    </mirror>
    -->
     
    <mirror>
    <id>alimaven</id>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
    </mirror>
    </mirrors>
     
    入门配置
    需求:通过命令行,使用Maven项目创建一个Java项目,并且打包。
     
    第一步:创建项目
    使用mvn archetype:generate命令创建java项目
     
     
     
     
    第二步:设置坐标信息
    设置坐标信息,通过以下三个信息确定坐标。标记全球Maven项目的唯一性。
    groupId:组织ID
    artifactId:项目名
    package:包名
    --提示,创建成功
     
    第三步:编译项目
    使用命令 mvn compile
    --编译成功,生成target文件夹
    第四步:打包
    通过命令mvn package
    --打包成功,在target文件夹下会生成jar包
     
    --通过该入门示例,可以发现,使用Maven创建构建项目,是可以不依赖任何开发工具的。
     
    通过该入门示例,我们看到了我们需要学习的内容包括:Maven的命令仓库
     
    问题:默认Maven仓库在哪里?
    答:C:UsersYL.m2 ,在登录用户的个人文件夹里面的.m2文件夹就是仓库
     
    问题:有什么办法了解更多的mvn的命令呢?
    答:mvn下的命令都是一个插件,Maven工具内置的可以使用的插件都在其官方帮助文档找到说明。
    https://maven.apache.org/plugins/index.html
     
    Eclipse使用Maven
    配置Maven
    第一步:打开Eclipse首选项
    第二步:配置外部Maven
    配置指定外部的Maven
    --选择使用配置的外部的Maven
    第三步:【可选】查看默认本机仓库
     
     
    通过Maven创建普通项目
     
    第一步:创建一个Maven项目
     
    第二步:创建一个自定义的Maven项目
     
    第三步:设置项目构建信息
    GroupId:组编号
    ArtifactId:项目标识符(项目的项目名)
    注意:Maven是通过GroupId和ArtifactId来确定项目的唯一性,我们称为坐标。任何项目要发布到Maven的库中,必须要有一个全球唯一的坐标。
     
    Version:发布的版本号
    Packaging:打包方式。
    1. jar:以jar包方式打包,普通java项目
    2. war:以war包方式打包,是web项目
    3. pom:不打包,表示该项目是一个聚合项目。在多子项目的项目中,用于管理公用Maven构建属性
    Name:【可以忽略】就是一个项目的一个名称,实际实战中,一般跟ArtifactID一致。
    Description:【可以忽略】就是项目的描述
     
    --创建成功
     
    第四步:创建一个简单的HelloWorld类
    package cn.zj;
    public class HelloWorld {
     
    public static void main(String[] args) {
    System.out.println("HelloWorld");
    }
    }
     
    第五步:构建项目
    注意:
    1. Maven build:用于执行Maven的命令
    2. Maven Clean:等同执行 mvn clean
    3. Maven generate-source:等同 mvn build
    4. Maven Intall:等同 mvn install 。同时执行,清除、编译、测试、打包、并将包安装到maven仓库
    --构建成功
     
    通过Maven创建Web项目
    第一步:创建一个Maven项目
    --创建项目后,报错信息。提示没有web.xml
    解决方案:
    1. .通过<failOnMissingWebXml>标签忽略web.xml
    2. .创建一个web.xml文件
     
     
    第二步:创建web.xml
    1. 创建一个在src/main/webapp下创建WEB-INF文件夹
    1. 在WEB-INF文件下创建一个web.xml文件
    --通过xsd规则文件创建
    --创建成功后,报错消失。!!!!
     
    选中项目右键
    第三步:创建一个index.jsp
    发现,报错。原因是没有加入JSP依赖的ServletAPI以及JSP的类库。
     
    第四步:通过POM.xml加入依赖的类库
    --依赖的类库的jar的坐标取哪里找?
    答:可以在一下的公有仓库找。
    http://mvnrepository.com/
     
    http://search.maven.org/
    注意:以后我们开发出来的功能组件希望让别人通过Maven使用,也可以提交到这两个用于库
     
    <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.zj</groupId>
    <artifactId>maven-demo-02-web</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <!-- 增加web项目依赖的类库 -->
    <dependencies>
    <!-- servlet api -->
    <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.0.1</version>
    <scope>provided</scope>
    </dependency>
     
    <!-- jsp -->
    <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.2.1</version>
    <scope>provided</scope>
    </dependency>
    </dependencies>
    </project>
    注意事项,创建Maven项目是报异常,可以强制更新项目
    --右击项目-->选择Maven-->Update Project
    --强制更新
     
     
     
     
    第五步:通过Maven运行Tomcat启动项目
    -1.安装tomcat7的Maven插件
     
    所有的Maven工具内置插件都是有在https://maven.apache.org/plugins/index.html找到。
     
    --安装2.2 版本
    在pom.xml 配置配置tomcat插件
    <!-- 构建项目的相关环境 -->
    <build>
    <plugins>
    <!-- tomcat运行插件 -->
    <plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.2</version>
    </plugin>
    </plugins>
    </build>
    使用Tomcat插件运行Maven项目
    点击项目鼠标右键
    Maven下面Tomcat插件 项目细节配置
    Tomvat 默认项目上下文路径是项目名称,默认端口是 8080
    开发者可以手动配置插件信息
    <build>
    <!-- 插件 -->
    <plugins>
    <!-- tomcat 插件 -->
    <plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.2</version>
    <!-- 细节配置 -->
    <configuration>
    <!-- 上下文路径 -->
    <path>/maven</path>
    <!-- 端口配置 -->
    <port>80</port>
    </configuration>
    </plugin>
    </plugins>
    </build>
    修改jre 依赖版本
    Maven 默认依赖的jar版本是 1.5,开发者可以配置jre版本,有两种配置方式
     
    单独为某一个项目配置
    <build>
    <!-- 插件 -->
    <plugins>
    <!-- tomcat 插件 -->
    <plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.2</version>
    <!-- 细节配置 -->
    <configuration>
    <!-- 上下文路径 -->
    <path>/maven</path>
    <!-- 端口配置 -->
    <port>80</port>
    </configuration>
    </plugin>
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
    <!-- 源代码版本 -->
    <target>1.8</target>
    <!-- 编译后版本 -->
    <source>1.8</source>
    </configuration>
    </plugin>
    </plugins>
    </build>
    修改setting.xml配置文件
    可以修改 maven根/confg/setting.xml 在 <profiles> 标签中添加如下代码,使用此种方式全局生效
    以后创建的项目全部都是1.8版本
    <profile>
    <id>jdk-1.8</id>
    <activation>
    <activeByDefault>true</activeByDefault>
    <jdk>1.8</jdk>
    </activation>
    <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>
    </profile>
     
     
    通过Maven创建多个工程组成的项目
    需求:使用Maven项目创建一个ssm整合的项目。项目的每一层为一个工程。
     
    第一步:创建Maven项目
    注意:
    1. 表示层是WEB项目,其他的都是功能组件,所以使用普通的Jar项目
    2. Parent项目是一个聚合项目,主要用于维护统一的包依赖,统一的插件,统一构建项目(测试、编译、打包)
    创建parent-项目
    创建聚合项目的子模块项目
     
    最终效果
     
    第二步:Eclipse实现项目分组
    1. .将项目列表使用Working Sets显示
     
    1. .插件一个项目分组
     
    1. 设置项目组信息
    --分组后结果
     
    第三步:聚合项目后的效果
    --聚合所有需要构建的工程,可以实现统一构建项目。所谓的统一构建项目,就是统一的执行清除、测试、编译、打包等操作
    --在聚合项目ssm-parent通过 <modules>实现聚合所有的需要统一构建的项目
     
    --代码
    <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.zj</groupId>
    <artifactId>ssm-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <description>这是一个聚合项目,本身至于维护其它子项目的包关系插件等</description>
     
    <!-- 通过引入模块的形式,将项目的其他模块引入在一起 -->
    <modules>
    <module>ssm-mapper</module>
    <module>ssm-service</module>
    <module>ssm-pojo</module>
    <module>ssm-web</module>
    <module>ssm-util</module>
    </modules>
    </project>
     
    第四步:项目的继承
    注意:所谓的项目继承,就是一个项目已经在pom.xml声明的各种元素,继承的子工程的pom.xml也获得该父工程的pom.xml所有声明的元素。
     
    前提:以前如果每个工程需要使用Log4J和Junit,都要在各自的项目的pom.xml加入依赖。这样做他麻烦了。
    需求:在ssm-parent声明一次依赖Log4J和Junit,其他所有的子工程都可以使用。
     
    1. 在父包加入了依赖
     
    1. 在子项目继承父工程。也获得了父工程声明的元素
     
    第五步:依赖包的版本统一管理
    需求:实现所有项目依赖的类库的版本统一管理。
     
    答:可以通过属性的设置与版本锁定,使用依赖包的统一管理
    1. 父项目,设置属性与版本锁定
    <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.zj.parent</groupId>
    <artifactId>ssm-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <description>这是一个聚合项目,本身至于维护其它子项目的包关系插件等</description>
    <!-- 通过属性设置类库版本 -->
    <!-- 在properties标签声明的属性,可以在作用范围内的pom.xml里面使用${标签名}访问 -->
    <properties>
    <!-- 注意:pom里面的属性值,标签名是自定义的,随便写,只有符合xml标签规范 -->
    <log4j.version>1.2.17</log4j.version>
    <junit.version>4.12</junit.version>
    <springmvc.version>4.3.16.RELEASE</springmvc.version>
    </properties>
    <!-- 声明依赖 -->
    <dependencies>
    <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>${log4j.version}</version>
    <!-- 打包的时候需要一起进去 -->
    <scope>compile</scope>
    </dependency>
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>${junit.version}</version>
    <!-- Junit打包的时候是不能放在包里面的 -->
    <scope>test</scope>
    </dependency>
    </dependencies>
    <!-- 指定可以选择的依赖库的版本 -->
    <!-- 放在dependencyManagement标签里面的依赖库,并没有被使用,只是声明了,可选.版本锁定
    这个意味着,如果在作用范围内(本pom.xml以及子pom.xml)里面使用到dependencyManagement标签
    指定版本的类库,必须在在指定版本
    -->
    <dependencyManagement>
    <dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${springmvc.version}</version>
    </dependency>
    </dependencies>
    </dependencyManagement>
    <!-- 通过模块的方式,将所有统一构建的项目聚合起来 -->
    <modules>
    <module>ssm-web</module>
    <module>ssm-service</module>
    <module>ssm-mapper</module>
    <module>ssm-pojo</module>
    <module>ssm-utils</module>
    </modules>
    </project>
     
    1. 子项目,不需要再指定版本锁定的类库的版本
    <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.zj.controller</groupId>
    <artifactId>ssm-web</artifactId>
     
    <packaging>war</packaging>
     
    <!-- 继承ssm parent项目 -->
    <parent>
    <groupId>cn.zj.parent</groupId>
    <artifactId>ssm-parent</artifactId>
    <!-- 注意:如果一个多工程的项目,继承了统一的父项目,版本号以父项目为准 -->
    <version>0.0.1-SNAPSHOT</version>
     
    </parent>
     
     
    <dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
     
    </dependency>
    </dependencies>
     
    </project>
    依赖<scope>的范围
    Scope 声明依赖包在哪个阶段有效
    Compile(默认) spring,mybatis
    编译(compile)时需要 测试时需要,,运行时需要,打包时需要
    Provided jsp-api.jar servlet-api.jar
    编译(compile)时需要,测试(test)时也需要 ,运行时不需要,打包时不需要
    Runtime 数据库驱动包
    编译时不需要,测试时需要,,运行时需要,打包时需要
    Test junit.jar
    编译时不需要,测试时需要,运行时不需要,打包也不需要
     
    第六步:在ssm-web工程配置SpringMVC框架
    导入包依赖
    --在ssm-parent对依赖包版本锁定
    <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.zj.parent</groupId>
    <artifactId>ssm-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <description>这是一个聚合项目,本身至于维护其它子项目的包关系插件等</description>
    <!-- 通过属性设置类库版本 -->
    <!-- 在properties标签声明的属性,可以在作用范围内的pom.xml里面使用${标签名}访问 -->
    <properties>
    <!-- 注意:pom里面的属性值,标签名是自定义的,随便写,只有符合xml标签规范 -->
    <log4j.version>1.2.17</log4j.version>
    <junit.version>4.12</junit.version>
    <springmvc.version>4.3.16.RELEASE</springmvc.version>
    <servlet-api.version>3.0.1</servlet-api.version>
    <jsp.version>2.2.1</jsp.version>
    </properties>
    <!-- 声明依赖 -->
    <dependencies>
    <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>${log4j.version}</version>
    <!-- 打包的时候需要一起进去 -->
    <scope>compile</scope>
    </dependency>
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>${junit.version}</version>
    <!-- Junit打包的时候是不能放在包里面的 -->
    <scope>test</scope>
    </dependency>
    </dependencies>
    <!-- 指定可以选择的依赖库的版本 -->
    <!-- 放在dependencyManagement标签里面的依赖库,并没有被使用,只是声明了,可选.版本锁定 这个意味着,如果在作用范围内(本pom.xml以及子pom.xml)里面使用到dependencyManagement标签
    指定版本的类库,必须在在指定版本 -->
    <dependencyManagement>
    <dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${springmvc.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.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>${jsp.version}</version>
    <scope>provided</scope>
    </dependency>
    </dependencies>
    </dependencyManagement>
    <!-- 设置构建是的jdk的版本 -->
    <build>
    <!-- 插件就是Maven命令 -->
    <plugins>
    <!-- 修改编译插件的JDK版本 -->
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.5</version>
    <!-- 配置属性 -->
    <configuration>
    <!-- 源代码使用JDK1.8 -->
    <source>1.8</source>
    <!-- 生成的目标文件.class文件使用JDK1.8 -->
    <target>1.8</target>
    </configuration>
    </plugin>
    </plugins>
    </build>
    <!-- 通过模块的方式,将所有统一构建的项目聚合起来 -->
    <modules>
    <module>ssm-web</module>
    <module>ssm-service</module>
    <module>ssm-mapper</module>
    <module>ssm-pojo</module>
    <module>ssm-utils</module>
    </modules>
    </project>
     
    --在ssm-web的pom.xml导入依赖包
    <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.zj.controller</groupId>
    <artifactId>ssm-web</artifactId>
    <packaging>war</packaging>
    <!-- 继承ssm parent项目 -->
    <parent>
    <groupId>cn.zj.parent</groupId>
    <artifactId>ssm-parent</artifactId>
    <!-- 注意:如果一个多工程的项目,继承了统一的父项目,版本号以父项目为准 -->
    <version>0.0.1-SNAPSHOT</version>
    <!-- 指定父工厂的pom.xml相对本pom.xml的相对路径 -->
     
    </parent>
    <!-- 增加依赖包 -->
    <dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    </dependency>
    <!-- servlet api -->
    <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    </dependency>
    <!-- jsp -->
    <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    </dependency>
    </dependencies>
    <!-- 运行tocmat7插件 -->
    <build>
    <plugins>
     
    <plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.2</version>
    </plugin>
    </plugins>
    </build>
    </project>
     
     
    创建一个请求页面
    <%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <a href="${pageContext.request.contextPath }/user/add.do">add</a>
    </body>
    </html>
     
    编写web.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
    <!-- 配置SpringMVC的前端控制器(总控) -->
    <servlet>
    <servlet-name>MVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 读取Spring相关配置文件 -->
    <init-param>
    <param-name>contextConfigLocation</param-name>
    <!-- 因为spring相关配置文件可能有多个,所有使用*号通配符全部扫描 -->
    <param-value>classpath:applicationContext*.xml</param-value>
    </init-param>
    <!-- 初始化容器 -->
    <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
    <servlet-name>MVC</servlet-name>
    <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    </web-app>
     
    编写配置文件spring-mvc.xml
    <!-- 配置包扫描 -->
    <context:component-scan base-package="cn.zj.ssm"/>
    <!-- 开启注解驱动 -->
    <mvc:annotation-driven />
    <!-- 配置视图解析器 -->
    <bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- 配置视图跳转的前缀 -->
    <property name="prefix" value="/WEB-INF/views/" />
    <!-- 配置视图跳转的后缀 -->
    <property name="suffix" value=".jsp" />
    </bean>
     
    编写Controller组件类
    package cn.zj.controller;
    import org.springframework.context.annotation.Scope;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    @Controller
    @Scope(value="request")
    @RequestMapping(value="/user")
    public class StudentController {
     
    @RequestMapping(value="/add")
    public void add(){
    System.out.println("-增加用户-");
    }
    }
    第七步:在ssm-mapper工程配置Mybatis框架
    导入包依赖
    --ssm-mapper项目导入依赖
    <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.zj.mapper</groupId>
    <artifactId>ssm-mapper</artifactId>
    <parent>
    <groupId>cn.zj.parent</groupId>
    <artifactId>ssm-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
     
    </parent>
     
    <dependencies>
     
    <!-- jdbc driver -->
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    </dependency>
     
    <!-- mybatis -->
    <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    </dependency>
     
    <!-- ssm-mapper项目依赖ssm-pojo项目 -->
    <dependency>
    <groupId>cn.zj.pojo</groupId>
    <artifactId>ssm-pojo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    </dependency>
     
    <!-- dbcp -->
    <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
    </dependency>
     
    </dependencies>
     
    </project>
    创建操作映射注解
    --创建一个操作接口,编写一个插入数据的SQL语句
    package cn.zj.mapper;
    import org.apache.ibatis.annotations.Insert;
    import org.apache.ibatis.annotations.Options;
    import cn.zj.pojo.User;
    public interface StudentMapper {
     
    @Insert(value="INSERT INTO t_user (name, phone, email) VALUES (#{name}, #{phone}, #{email})")
    //操作后,实体对象需要ID,使用ID回填
    @Options(useGeneratedKeys=true,keyProperty="id",keyColumn="id")
    int insert(User user);
    }
     
    编写mybatis-config.xml配置文件
     
    在test/resources创建mybatis-config.xml配置文件
     
    --配置文件代码
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "mybatis-3-config.dtd" >
    <configuration>
    <environments default="mysql">
    <environment id="mysql">
    <transactionManager type="JDBC"></transactionManager>
    <dataSource type="POOLED">
    <property name="driver" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/sms"/>
    <property name="username" value="root"/>
    <property name="password" value="admin"/>
    </dataSource>
    </environment>
    </environments>
    <!-- 加载映射接口 -->
    <mappers>
    <mapper class="cn.zj.mapper.UserMapper"/>
    </mappers>
    </configuration>
     
    测试代码
    package cn.zj.test;
    import java.io.IOException;
    import java.io.Reader;
    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.Test;
    import cn.zj.mapper.UserMapper;
    import cn.zj.pojo.User;
    public class UserMapperTest {
     
    @Test
    public void insert(){
     
     
    try {
    //1.获得配置文件
    Reader reader = Resources.getResourceAsReader("mybaits-config.xml");
    //2.通过SqlSessionFactoryBuilder获得SqlSessionFactory对象
    SqlSessionFactoryBuilder build=new SqlSessionFactoryBuilder();
    //获得会话工厂
    SqlSessionFactory sessionFactory = build.build(reader);
    //获得会话
    SqlSession session = sessionFactory.openSession();
    //获得操作接口的动态对象
    UserMapper mapper = session.getMapper(UserMapper.class);
    User user=new User();
    user.setName("王五");
    int count = mapper.insert(user);
    System.out.println(count);
    //提交
    session.commit();
    session.close();
    System.out.println(user.getStuId());
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    }
    }
     
    第八步:整合SpringMVC与Mybatis
     
    配置支持支持${key}获得Properties文件值
    <!-- 读取db.properties数据库配置文件 -->
    <context:property-placeholder location="classpath:db.properties"/>
    <!-- 配置Druid连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
    init-method="init" destroy-method="close">
    <!-- setter方法注入属性值 -->
    <property name="driverClassName" value="${jdbc.driverClassName}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
    <!-- 最大连接数 -->
    <property name="maxActive" value="${jdbc.maxActive}" />
    </bean>
     
    整合Mybatis
    <!-- 配置MyBatis的 SqlSessionFactory对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 1. 注入数据源:连接池 -->
    <property name="dataSource" ref="dataSource"/>
     
    <!-- 2.使用包扫描配置别名 -->
    <property name="typeAliasesPackage" value="cn.zj.ssm.pojo"/>
     
    <!-- 3.引入MyBatis配置文件 mybatis-confg.xml -->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
     
    <!-- 4.配置映射文件 -->
    <property name="mapperLocations" value="classpath:cn/zj/ssm/dao/*Mapper.xml"></property>
    </bean>
    <!-- 使用包扫描配置Mapper接口对应的代理对象
    对应包下面的所有的接口全部会被创建代理对象, 默认都是 接口名的首字母小写 作为 名称 UserMapper->userMapper
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- 配置SqlSessionfactory的bean对应的名称(不是对象) -->
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
     
    <!-- 配置需要扫描创建代理对象的包 -->
    <property name="basePackage" value="cn.zj.ssm.dao"/>
    </bean>
     
    配置事物管理器
    <!-- 配置MyBatis事物管理器 -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 1. 注入数据源:连接池 -->
    <property name="dataSource" ref="dataSource"/>
    </bean>
     
     
    <!-- 配置事务 通知(增强) tx -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
    <!-- 配置事务方法 -->
    <tx:attributes>
    <tx:method name="find*" read-only="true"/>
    <tx:method name="get*" read-only="true"/>
    <tx:method name="query*" read-only="true"/>
    <tx:method name="select*" read-only="true"/>
    <tx:method name="list*" read-only="true"/>
    <!-- 需要事务的方法 -->
    <tx:method name="*"/>
    </tx:attributes>
    </tx:advice>
     
    <!-- 使用aop切事务 -->
    <aop:config>
    <!-- 配置切入点 -->
    <aop:pointcut expression="execution (* cn.zj.ssm.service..*.*(..))" id="pt"/>
     
    <!-- 配置切面 = 切入点+ 通知 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
    <!-- 织入: spring完成 -->
    </aop:config>
     
    常见问题
    问题1:已经下载到本地仓库的jar。Eclipse如何快速加入到Pom.xml文件里面
    答:进入POM.xml对应的标签位置,右击选择增加依赖或者插件。
    --选择增加的依赖
    --选择需要的依赖
     
     
    问题2:本地明明已经下载了对应的插件或者jar包。但Eclipse工具搜索不出来.
    答:原因是缓冲问题。可以清一下仓库索引,操作步骤
    --打开Maven仓库管理窗口
    --刷新索引缓存
     
    问题3:如何设置默认的JDK版本
    <!-- 设置构建是的jdk的版本 -->
    <build>
    <!-- 插件就是Maven命令 -->
    <plugins>
    <!-- 修改编译插件的JDK版本 -->
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.5</version>
    <!-- 配置属性 -->
    <configuration>
    <!-- 源代码使用JDK1.8 -->
    <source>1.8</source>
    <!-- 生成的目标文件.class文件使用JDK1.8 -->
    <target>1.8</target>
    </configuration>
    </plugin>
    </plugins>
    </build>
     
    问题4:设置打包安装跳过Junit的测试
    <!-- 跳过测试代码 -->
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.18.1</version>
    <configuration>
    <skipTests>true</skipTests>
    </configuration>
    </plugin>
     
     
    小结
    Maven是什么?
    Maven是一个项目构建工具
    1. 编译--测试-打包-安装 完全使用Maven即可完成
    2. Maven完全负责项目依赖包管理
    3. Maven内置集成Tomcat插件
     
    Maven相对手动构建项目优势
    1. Maven有依赖仓库,基本上拥有市面上所有的jar包
      1. 更加方便jar包版本管理
    2. 互联网各大开源的项目基本都是使用Maven项目构建
    3. 后面会讲解SpringBoot(必须使用Maven)
     
     
    目前项目构建工具除了 Maven,还有一个项目构建工具Gradle
  • 相关阅读:
    021-python基础-python介绍及课程简介
    020-python函数和常用模块-文件操作
    019-python函数和常用模块-内置函数
    018-python基础-三元运算和lambda表达式
    017-python函数和常用模块-函数式编程实现登陆和注册
    016-python函数和常用模块-函数定义和使用
    015-python基础-深浅拷贝
    014-python基础-set集合
    013-python基础-课堂练习
    012-python基础-数据运算
  • 原文地址:https://www.cnblogs.com/aknife/p/11041735.html
Copyright © 2011-2022 走看看