当前位置： 移动技术网 > IT编程>开发语言>Java > Maven的使用

Maven的使用

2019年07月26日  | 移动技术网IT编程  | 我要评论

神虎飞鹰电视剧,罗通拜帅,白拿网

maven讲义

1. maven概述

 1.1. maven是什么

  maven是一个由apache基金会维护的项目构建工具。

 1.2. 项目构建是什么

　　我们将项目的代码从源代码到具体程序文件的过程称为代码构建。

　　行为包括：编译、测试、运行、打包、部署的过程

 

 1.3. eclipse项目构建

　　eclipse构建项目的过程图示：

　　 

 


构建过程如下：

1）创建一个web项目

2）在项目中编写好源代码和配置文件

3）对源代码编译生成class文件

4）通过junit对代码单元测试

5）将项目通过eclipse工具放在tomcat运行

6）将项目导出war，放在tomcat运行

 

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

 

 1.5. 使用maven的好处

1. 使用命令，一键快速编译部署

2. 对项目的构建更加精细化，适合大型项目的构建

3. maven支持直接通过配置文件（pom）的配置下载依赖的包

4. 各大开源社区强制使用maven导包，意味着如果不学它，有很多的开源项目不好入门。

 

2. maven的安装

 2.1. maven说明

下载路径：

目录说说明：

 


 2.2. 环境配置 

　　　2.2.1. 第一步：确定java_home配置

前提：如果要在cmd命令行运行maven，必须要配置java_home环境变量

通过set命令

　　　　

  

　　　　如果没有配置java_home环境会导致运行获得java运行环境，异常如下：


　　　　

 

  

 

 　　2.2.2. 第二步：配置maven_home环境变量

　　　　

 


　　2.2.3. 第三步：指定maven执行命令到当前目录 

配置执行目录到path环境变量，让命令可以在当前目录可以执行

--变量path变量

 

　　　　--成功增加结果变量：%maven_home%\bin

　　2.2.4. 第四步：测试配置，在cmd下键入mvn -h

　　　　如果返回参数提示如下图，说明配置成功！

　　　　

 


　　2.2.5. 第五步：配置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>

 

3. 入门配置

　　需求：通过命令行，使用maven项目创建一个java项目，并且打包。

 

 3.1. 第一步：创建项目

　　使用mvn archetype:generate命令创建java项目

 

 

 3.2. 第二步：设置坐标信息

设置坐标信息，通过以下三个信息确定坐标。标记全球maven项目的唯一性。

groupid:组织id

artifactid:项目名

package:包名

　　　　

　　　　--提示，创建成功

　　　　

 

 

 3.3. 第三步：编译项目

　　使用命令 mvn compile

　　

　　--编译成功，生成target文件夹

　　

 

 3.4. 第四步：打包

　　通过命令mvn package

　　

　　--打包成功，在target文件夹下会生成jar包

　　

 

　　--通过该入门示例，可以发现，使用maven创建构建项目，是可以不依赖任何开发工具的。

 

　　通过该入门示例，我们看到了我们需要学习的内容包括：maven的命令、仓库

 

问题：默认maven仓库在哪里？

答：c:\users\yl\.m2 ，在登录用户的个人文件夹里面的.m2文件夹就是仓库

问题：有什么办法了解更多的mvn的命令呢？

答：mvn下的命令都是一个插件，maven工具内置的可以使用的插件都在其官方帮助文档找到说明。

 

4. eclipse使用maven

 4.1. 配置maven

 　 4.1.1. 第一步：打开eclipse首选项

 　　

 


　　4.1.2. 第二步：配置外部maven

　　　　配置指定外部的maven

　　　　

　　　　--选择使用配置的外部的maven

　　　　

 

 　　4.1.3. 第三步：【可选】查看默认本机仓库

　　　　

 


  

 4.2. 通过maven创建普通项目

 

 　　4.2.1. 第一步：创建一个maven项目

　　

 


　　4.2.2. 第二步：创建一个自定义的maven项目 

　　

 


4.2.3. 第三步：设置项目构建信息 

groupid：组编号

artifactid：项目标识符（项目的项目名）

注意：maven是通过groupid和artifactid来确定项目的唯一性，我们称为坐标。任何项目要发布到maven的库中，必须要有一个全球唯一的坐标。

version：发布的版本号

packaging：打包方式。

（1）jar：以jar包方式打包，普通java项目

（2）war：以war包方式打包，是web项目

（3）pom：不打包，表示该项目是一个聚合项目。在多子项目的项目中，用于管理公用maven构建属性

name：【可以忽略】就是一个项目的一个名称，实际实战中，一般跟artifactid一致。

description：【可以忽略】就是项目的描述

　　

　　

 --创建成功

　　

 　　4.2.4. 第四步：创建一个简单的helloworld类

package cn.zj;

public class helloworld {

 

public static void main(string[] args) {

system.out.println("helloworld");

}

}

 

4.2.5. 第五步：构建项目

注意：

1. maven build：用于执行maven的命令

2. maven clean：等同执行 mvn clean

3. maven generate-source：等同 mvn build

4. maven intall:等同 mvn install 。同时执行，清除、编译、测试、打包、并将包安装到maven仓库

　　

　　　　--构建成功

　　　　

 

 

 4.3. 通过maven创建web项目

 　　4.3.1. 第一步：创建一个maven项目

　　

　　--创建项目后，报错信息。提示没有web.xml


解决方案：

（1）.通过<failonmissingwebxml>标签忽略web.xml

（2）.创建一个web.xml文件


　　　　

 

  

 　　4.3.2. 第二步：创建web.xml

 　　1. 创建一个在src/main/webapp下创建web-inf文件夹

 　　

 


 　　2. 在web-inf文件下创建一个web.xml文件 　　

 　　--通过xsd规则文件创建

　　　　

 


 　　--创建成功后，报错消失。！！！！

 

 　　选中项目右键

 　　

 

 

 　　4.3.3. 第三步：创建一个index.jsp

　　　　

 


 　　发现，报错。原因是没有加入jsp依赖的servletapi以及jsp的类库。

 　　4.3.4. 第四步：通过pom.xml加入依赖的类库

--依赖的类库的jar的坐标取哪里找？

答：可以在一下的公有仓库找。

 

注意：以后我们开发出来的功能组件希望让别人通过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、

　

 


　　　　--强制更新

　　　　

 

 　　4.3.5. 第五步：通过maven运行tomcat启动项目

　　　　-1.安装tomcat7的maven插件

　　　　所有的maven工具内置插件都是有在https://maven.apache.org/plugins/找到。


　　　　

 

 

　　　　--安装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>

 　　4.3.6. 使用tomcat插件运行maven项目

　　　　点击项目鼠标右键

　　　　

 


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

5. 修改jre 依赖版本

　　maven 默认依赖的jar版本是 1.5，开发者可以配置jre版本，有两种配置方式

 

 5.1. 单独为某一个项目配置

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

 

 5.2. 修改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>

 

 

6. 通过maven创建多个工程组成的项目

　　需求：使用maven项目创建一个ssm整合的项目。项目的每一层为一个工程。

 

 6.1. 第一步：创建maven项目

注意：

1. 表示层是web项目，其他的都是功能组件，所以使用普通的jar项目

2. parent项目是一个聚合项目，主要用于维护统一的包依赖，统一的插件，统一构建项目（测试、编译、打包）

 　　6.1.1. 创建parent-项目

　　

 

 　　6.1.2. 创建聚合项目的子模块项目


　　　　

 

 

 　　6.1.3. 最终效果

　　

 


 6.2. 第二步：eclipse实现项目分组 

(1) .将项目列表使用working sets显示


　　

 

 

(2) .插件一个项目分组


　　

 

 

（3）设置项目组信息

　　

 


　　　　--分组后结果

　　

 


 6.3. 第三步：聚合项目后的效果 

--聚合所有需要构建的工程，可以实现统一构建项目。所谓的统一构建项目，就是统一的执行清除、测试、编译、打包等操作

--在聚合项目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>

 

 6.4. 第四步：项目的继承

注意：所谓的项目继承，就是一个项目已经在pom.xml声明的各种元素，继承的子工程的pom.xml也获得该父工程的pom.xml所有声明的元素。

 

前提：以前如果每个工程需要使用log4j和junit，都要在各自的项目的pom.xml加入依赖。这样做他麻烦了。

需求：在ssm-parent声明一次依赖log4j和junit，其他所有的子工程都可以使用。

 

（1）在父包加入了依赖

 


（2）在子项目继承父工程。也获得了父工程声明的元素 

 

 6.5. 第五步：依赖包的版本统一管理 

需求：实现所有项目依赖的类库的版本统一管理。

 

答：可以通过属性的设置与版本锁定，使用依赖包的统一管理

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

 

（2）子项目，不需要再指定版本锁定的类库的版本

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

 　　6.5.1. 依赖<scope>的范围

　　　　scope 声明依赖包在哪个阶段有效

compile(默认)  spring,mybatis

编译（compile）时需要 测试时需要，，运行时需要，打包时需要

provided  jsp-api.jar   servlet-api.jar

编译（compile）时需要，测试（test）时也需要 ，运行时不需要，打包时不需要

 

runtime   数据库驱动包

编译时不需要，测试时需要，，运行时需要，打包时需要

test  junit.jar

编译时不需要，测试时需要，运行时不需要，打包也不需要

 

 

 6.6. 第六步：在ssm-web工程配置springmvc框架

 　　6.6.1. 导入包依赖

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

 

 

 　　6.6.2. 创建一个请求页面

<%@ 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>

 

 　　6.6.3. 编写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>

 

 　　6.6.4. 编写配置文件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>

 

 

 　　6.6.5. 编写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("-增加用户-");

}

 

}

 

 6.7. 第七步：在ssm-mapper工程配置mybatis框架

 　　6.7.1. 导入包依赖

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

 　　6.7.2. 创建操作映射注解

　　　　--创建一个操作接口，编写一个插入数据的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);

 

}

 

 　　6.7.3. 编写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>

 

 

 　　6.7.4. 测试代码

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();

}

}

}

 

 

 6.8. 第八步：整合springmvc与mybatis

 

 　　6.8.1. 配置支持支持${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>

 

 　　6.8.2. 整合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>

 

 　　6.8.3. 配置事物管理器

<!-- 配置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>

 

7. 常见问题

问题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>

 

 

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网