首页 > > 程序设计 > Java技术 >

Maven的使用

2019-08-16 11:14:22来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

Maven的使用

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

下载路径：http://maven.apache.org/download.cgi

目录说说明：

 


 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工具内置的可以使用的插件都在其官方帮助文档找到说明。

https://maven.apache.org/plugins/index.html

 

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的坐标取哪里找？

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

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、

　

 


　　　　--强制更新

　　　　

 

 　　4.3.5. 第五步：通过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>

 　　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>

 

 


原文链接:https://www.cnblogs.com/gaojinshun/p/11252438.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：HttpClent工具类

下一篇：springCloud 搭建Eureka

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签