zoukankan html css js c++ java

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

Maven构建项目

通过Maven构建工具可以一条命令完成上面所有的操作：

*clean，清除命令，作用清除已经编译的class文件和war文件
*compile，编译命令,作用是将java文件编译成class文件
*package，打包命令，作用将class文件打成war包
test，测试命令，作用执行Junit工具（可以忽略）
deploy，部署命令，将war包放在指定的tomcat（可以忽略）
*运行Tomcat，通过命令tomcat7:run （要加入Maven工具的Tomcat7插件）
*install，安装命令，一条命令包括了,clean complile package test

用Maven的好处

使用命令，一键快速编译部署
对项目的构建更加精细化，适合大型项目的构建
Maven支持直接通过配置文件（POM）的配置下载依赖的包
各大开源社区强制使用Maven导包，意味着如果不学它，有很多的开源项目不好入门。

Maven的安装

Maven说明

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

目录说说明：

环境配置

第一步：确定JAVA_HOME配置

前提：如果要在CMD命令行运行Maven，必须要配置JAVA_HOME环境变量

通过set命令

第二步：配置MAVEN_HOME环境变量

1.1.1. 第五步：配置Maven国内源

由于默认Maven使用国外的源，会导致下载jar比较慢。

配置Maven下conf文件夹的settings.xml文件中加下面红色代码

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

<id>mirrorId</id>

<mirrorOf>repositoryId</mirrorOf>

<name>Human Readable Name for this Mirror.</name>

<url>http://my.repository.com/repo/path</url>

</mirror>

-->

<id>alimaven</id>

<name>aliyun maven</name>

<url>http://maven.aliyun.com/nexus/content/groups/public/</url>

<mirrorOf>central</mirrorOf>

</mirror>

</mirrors>

第二步：设置坐标信息

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

groupId:组织ID

artifactId:项目名

package:包名

第三步：编译项目

使用命令 mvn compile

第四步：打包

通过命令mvn package

--通过该入门示例，可以发现，使用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项目

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

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

}

第五步：构建项目

注意：

Maven build：用于执行Maven的命令
Maven Clean：等同执行 mvn clean
Maven generate-source：等同 mvn build

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

通过Maven创建Web项目

第一步：创建一个Maven项目

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

解决方案：

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

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

第二步：创建web.xml

创建一个在src/main/webapp下创建WEB-INF文件夹

1.1.1. 第四步：通过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找到。

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

1. 修改jre 依赖版本

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

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

<build>

<groupId>org.apache.tomcat.maven</groupId>

<artifactId>tomcat7-maven-plugin</artifactId>

<path>/maven</path>

</configuration>

</plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>

</configuration>

</plugin>

</plugins>

</build>

1.1. 修改setting.xml配置文件

可以修改 maven根/confg/setting.xml 在 <profiles> 标签中添加如下代码,使用此种方式全局生效

以后创建的项目全部都是1.8版本

</activation>

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

注意：

表示层是WEB项目，其他的都是功能组件，所以使用普通的Jar项目
Parent项目是一个聚合项目，主要用于维护统一的包依赖，统一的插件，统一构建项目（测试、编译、打包）

创建parent-项目

第二步：Eclipse实现项目分组

(1) .将项目列表使用Working Sets显示

设置项目组信息

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

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

<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）父项目，设置属性与版本锁定

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

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

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

导入包依赖

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

编写配置文件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
@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>
      
      <!-- druid->
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
      </dependency>
      
  </dependencies>

  
</project>

配置文件代码

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

问题3：如何设置默认的JDK版本

查看全文

相关阅读:
Yarn
easyui
eclipse-android
js-小技能そうですか
 sql server 时间处理
 上传文件
 时间 & 时间戳之间转换
 JDIC
Spring 定时器
 映射

原文地址：https://www.cnblogs.com/406070989senlin/p/11182085.html

Maven

1. Maven概述

1.1. Maven是什么

1.2. 项目构建是什么

1.3. Eclipse项目构建

Maven构建项目

用Maven的好处

Maven的安装

Maven说明

环境配置

第一步：确定JAVA_HOME配置

第二步：配置MAVEN_HOME环境变量

1.1.1. 第五步：配置Maven国内源

第二步：设置坐标信息

第三步：编译项目

第四步：打包

Eclipse使用Maven

配置Maven

第一步：打开Eclipse首选项

第二步：配置外部Maven

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

第一步：创建一个Maven项目

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

通过Maven创建Web项目

第一步：创建一个Maven项目

第二步：创建web.xml

1.1.1. 第四步：通过POM.xml加入依赖的类库

第五步：通过Maven运行Tomcat启动项目

使用Tomcat插件运行Maven项目

Maven下面Tomcat插件 项目细节配置

1. 修改jre 依赖版本

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

1.1. 修改setting.xml配置文件

通过Maven创建多个工程组成的项目

第一步：创建Maven项目

创建parent-项目

第二步：Eclipse实现项目分组

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

第四步：项目的继承

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

依赖<scope>的范围

第六步：在ssm-web工程配置SpringMVC框架

导入包依赖

创建一个请求页面

编写web.xml

编写配置文件spring-mvc.xml

编写配置文件spring-mvc.xml

在ssm-mapper工程配置Mybatis框架

导入包依赖

配置支持支持${key}获得Properties文件值

整合Mybatis

Maven下面Tomcat插件项目细节配置