[Java知识库]Maven & MyBatis

Maven相关的概念

maven 资源仓库：https://mvnrepository.com/

mybatis (教程)中文网：https://mybatis.net.cn/

什么是Maven

Maven是项目进行模型抽象，充分运用的面向对象的思想，Maven可以通过一小段描述信息来管理项目的构建，报告和文档的软件项目管理工具。Maven 除了以程序构建能力为特色之外，还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目。

说白了: ==Maven是由Apache开发的一个工具。==用来管理java项目(依赖(jar)管理, 项目构建, 分模块开发 ).

Maven的作用

依赖管理: maven对项目的第三方构件（jar包）进行统一管理。向工程中加入jar包不要手工从其它地方拷贝，通过maven定义jar包的坐标，自动从maven仓库中去下载到工程中。

项目构建: maven提供一套对项目生命周期管理的标准，开发人员、和测试人员统一使用maven进行项目构建。项目生命周期管理：编译、测试、打包、部署、运行。

maven对工程分模块构建，提高开发效率。 (后面Maven高级会涉及)

Maven的好处

使用普通方式构建项目

使用Maven构建项目

小结

Maven是Apache开发的一个项目管理工具. 用来管理java项目的

Maven的作用

• 依赖(jar)管理

• 项目构建

• 分模块开发(后面再讲)

Maven仓库和坐标

Maven的仓库

Maven的坐标

Maven的一个核心的作用就是管理项目的依赖，引入我们所需的各种jar包等。为了能自动化的解析任何一个Java构件，Maven必须将这些Jar包或者其他资源进行唯一标识，这是管理项目的依赖的基础，也就是我们要说的坐标。包括我们自己开发的项目，也是要通过坐标进行唯一标识的，这样才能才其它项目中进行依赖引用。坐标的定义元素如下：

• groupId:项目组织唯一的标识符，实际对应JAVA的包的结构 (一般写公司的组织名称 eg:com.execise,com.alibaba)
• artifactId: 项目的名称
• version：定义项目的当前版本

例如：要引入druid，只需要在pom.xml配置文件中配置引入druid的坐标即可：

<!--druid连接池-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>    
  <version>1.0.9</version>  
</dependency>

小结

仓库(本地仓库,中央仓库,远程仓库(私服))

• 先从本地仓库找

  • 如果有, 就直接获得使用

  • 如果没有, 从中央仓库找, 自动的下载到本地仓库

通过坐标从仓库里面找到对应的jar使用

<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>    
  <version>1.0.9</version>  
</dependency>

Maven的安装

下载Maven

官网链接：http://maven.apache.org/

安装Maven

将Maven压缩包解压，即安装完毕

Maven目录介绍

配置环境变量

进入环境变量

配置MAVEN_HOME和Path

配置本地仓库

将软件文件夹中的Repository解压

配置本地仓库

在maven的安装目录中conf/ settings.xml文件，在这里配置本地仓库

示例代码:

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
 <localRepository>E:/source/04_Maven/repository_pinyougou</localRepository>

配置国内镜像

默认情况下，maven会去它自己的仓库（中央仓库）里面下载jar包，由于仓库在国外，所以下载会比较慢。一般会配置成国内的镜像，比如：阿里云的镜像

在setting.xml文件中的标签中追加以下内容即可

<mirror>
    <id>alimaven</id>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

测试Maven安装成功

打开cmd本地控制台，输入mvn -version

小结

注意事项

• Maven安装包 和仓库 都需要解压到一个没有中文和空格的目录下(建议解压到不同的目录)

• 配置

  • MAVEN_HOME 配置到Maven的解压目录

  • Path 配置到bin目录

• 在apache-maven-3.3.9\conf\settings.xml配置本地仓库

IDEA集成Maven

配置Maven

配置参数(创建工程不需要联网,解决创建慢的问题) -DarchetypeCatalog=internal

配置默认Maven环境

每次创建Maven工程的时候，总是需要重新选择Maven配置信息，那是因为默认的Maven环境不是我们当前的maven环境，所以需要配置。配置流程如下图：

选择默认的配置

进入配置

配置参数(创建工程不需要联网,解决创建慢的问题) -DarchetypeCatalog=internal

重启IDEA, 就可以生效了

小结

配置默认Maven环境 目的: 为了下次创建的时候 不需要再选择Maven了, 使用的就是这个默认环境的

配置三块

• maven_home

• Maven的配置文件

• 本地仓库的路径

加了一个优先不依赖网络创建项目

使用IDEA创建Maven工程

创建java工程

java工程目录结构

需要main/java文件夹变成 源码的目录(存放java源码)

需要test/java文件夹变成 测试源码的目录(存放单元测试)

创建resources目录, 变成资源的目录

编写Hello World！

小结

JavaSe工程的骨架

项目的结构

不使用骨架创建工程

第一步

第二步

第三步

第四步

Maven的常用命令

clean命令

清除编译产生的target文件夹内容，可以配合相应命令一起使用，如mvn clean

compile命令

该命令可以对src/main/java目录的下的代码进行编译

test命令

测试命令,或执行src/test/java/下所有junit的测试用例

在test/java目录下创建测试类DemoTest

执行test命令测试

控制台显示测试结果

package命令

mvn package，打包项目

• 如果是JavaSe的项目,打包成jar包

• 如果是JavaWeb的项目,打包成war包

打包后的项目会在target目录下找到

install命令

mvn install，作用：把项目打包后将打出来的包安装在本地仓库 ， 仓库里面一般放的是jar包，一般打包出来就是打出来一个jar包，然后把这个jar包放到仓库里面管理起来。

安装完毕后，在本地仓库中可以找到execise_javase_demo的信息

小结

命令作用

• clean 用来清除编译后的文件(target文件夹里面的)【一般清缓存】

• compile 编译

• test 执行单元测试

• package 打包 (javaSe–>jar, javaweb–>war)

• install 把项目打包之后安装到本地仓库

生命周期

• 当我们执行了install 也会执行compile test package

依赖管理

导入依赖

? 导入依赖坐标，无需手动导入jar包就可以引入jar。在pom.xml中使用标签引入依赖。

? 做项目/工作里面 都有整套的依赖的, 不需要背诵的.

? 去Maven官网找, 赋值,粘贴. http://mvnrepository.com/

导入junit的依赖

导入junit坐标依赖

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

进行单元测试

import org.junit.Test;

public class DemoTest {
    @Test
    public void test1(){
        System.out.println("test running...");
    }
}

导入servlet的依赖

创建Servlet，但是发现报错，原因是没有导入Servlet的坐标依赖

导入Servlet的坐标依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

原有报错的Servlet恢复正常

依赖范围

• compile 编译、测试、运行，A在编译时依赖B，并且在测试和运行时也依赖

  例如：strus-core、spring-beans, C3P0,Druid。打到war包或jar包

• provided 编译、和测试有效，A在编译和测试时需要B

  例如：servlet-api就是编译和测试有用，在运行时不用（tomcat容器已提供）

  不会打到war

• runtime：测试运行有效,

  例如：jdbc驱动包 ，在开发代码中针对java的jdbc接口开发，编译不用

  在运行和测试时需要通过jdbc驱动包（mysql驱动）连接数据库，需要的

  会打到war

• test：只是测试有效，只在单元测试类中用

  例如：junit

  不会打到war

• 按照依赖强度，由强到弱来排序：(理解)

  compile> provided> runtime> test

小结

坐标不需要背, 做项目时候/工作开发 都有整套的坐标. 如果是导入一些特定, 可以查阅网站,直接拷贝

作用范围

• compile 编译、测试、打包运行部署 有效 【默认】

• provided 编译, 测试 有效. 打包运行部署 无效

• runtime 测试、打包运行部署 有效 编译无效

• test 只是测试有效，只在单元测试类中用

Servlet,JSP 这类jar 需要加上provided , 因为部署到Tomcat里面. tomcat里面有, 如果没有加上provided , 可能会导致jar 冲突

单元测试的 建议加上test

框架概述

什么是框架

框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。

简而言之，框架是软件(系统)的半成品，框架封装了很多的细节，使开发者可以使用简单的方式实现功能,大大提高开发效率。

开发好比表演节目, 开发者好比演员, 框架好比舞台.

框架要解决的问题

框架要解决的最重要的一个问题是技术整合的问题，在 J2EE 的 框架中，有着各种各样的技术，不同的软件企业需要从J2EE 中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技术的风险性将会直接对应用造成冲击。而应用是软件企业的核心，是竞争力的关键所在，因此应该将应用自身的设计和具体的实现技术解耦。这样，软件企业的研发将集中在应用的设计上，而不是具体的技术实现，技术实现是应用的底层支撑，它不应该直接对应用产生影响。

? 框架一般处在低层应用平台（如 J2EE）和高层业务逻辑之间的中间层。

小结

框架: 软件的半产品. 我们开发者使用框架开发, 更加的简单, 提高开发效率

MyBatis框架概述

jdbc 程序回顾

注册驱动

获得连接

创建预编译sql语句对象

设置参数, 执行

处理结果

释放资源

public static void main(String[] args) {
     Connection connection = null;
     PreparedStatement preparedStatement = null;
     ResultSet resultSet = null;
     try {
         //1.加载数据库驱动
         Class.forName("com.mysql.jdbc.Driver");
         //2.通过驱动管理类获取数据库链接
         connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "123456"); 
         //3.定义 sql 语句 ?表示占位符
         String sql = "select * from user where username = ?";
         //4.获取预处理 statement
         preparedStatement = connection.prepareStatement(sql);
         //5.设置参数，第一个参数为 sql 语句中参数的序号（从 1 开始），第二个参数为设置的参数值
         preparedStatement.setString(1, "王五");
         //6.向数据库发出 sql 执行查询，查询出结果集
         resultSet = preparedStatement.executeQuery();
         //7.遍历查询结果集
         while (resultSet.next()) {
             System.out.println(resultSet.getString("id") + "
                     "+resultSet.getString(" username"));
         }
     } catch (Exception e) {
         e.printStackTrace();
     } finally {
//8.释放资源
         if (resultSet != null) {
             try {
                 resultSet.close();
             } catch (SQLException e) {
                 e.printStackTrace();
             }
         }
         if (preparedStatement != null) {
             try {
                 preparedStatement.close();
             } catch (SQLException e) {
                 e.printStackTrace();
             }
         }
         if (connection != null) {
             try {
                 connection.close();
             } catch (SQLException e) {
                 e.printStackTrace();
             }
         }
     }
 }

jdbc 问题分析

1. 数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

2. Sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大， sql 变动需要改变java 代码。

3. 使用 preparedStatement 向占有位符号传参数存在硬编码，因为 sql 语句的 where 条件不一定，可能多也可能少，修改 sql 还要修改代码，系统不易维护。

4. 对结果集解析存在硬编码（查询列名）， sql 变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成 pojo 对象解析比较方便

MyBatis框架概述

mybatis 是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。

mybatis 通过xml 或注解的方式将要执行的各种statement 配置起来，并通过java 对象和statement 中sql的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql并将结果映射为 java 对象并返回。

? 采用 ORM 思想解决了实体和数据库映射的问题，对jdbc 进行了封装，屏蔽了jdbc api 底层访问细节，使我们不用与 jdbc api打交道，就可以完成对数据库的持久化操作。

官网链接： http://www.mybatis.org/mybatis-3/

小结

MyBatis: 持久层的一个框架, 封装了JDBC. 操作数据库

为什么要学习MyBatis?

• JDBC和DBUtils都有一些很明显的缺点, JDBC和DBUtils不适合做项目

• MyBatis是工作里面的主流的持久层框架, 使用几率特别大

Mybatis入门

1. 创建Maven工程(jar), 添加坐标
2. 创建pojo
3. 创建UserDao接口
4. 创建UserDao映射文件
5. 创建MyBatis核心配置文件SqlMapConfig.xml
6. 编写java代码测试

数据库

CREATE DATABASE mybatis_day01;
USE mybatis_day01;
CREATE TABLE t_user(
		uid int PRIMARY KEY auto_increment,
		username varchar(40),
	 	sex varchar(10),
		birthday date,
		address varchar(40)
);

INSERT INTO `t_user` VALUES (null, 'zs', '男', '2018-08-08', '北京');
INSERT INTO `t_user` VALUES (null, 'ls', '女', '2018-08-30', '武汉');
INSERT INTO `t_user` VALUES (null, 'ww', '男', '2018-08-08', '北京');

MyBatis快速入门

创建Maven工程(jar)导入坐标

  <dependencies>
    <!--MyBatis坐标-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.5</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>
  	<!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

创建User实体类

User .java

public class User implements Serializable{
    private int uid; //用户id
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
	
}

创建 UserDao 接口

UserDao 接口就是我们的持久层接口（也可以写成 UserMapper) .我们就写成UserDao ,具体代码如下：

public interface UserDao {
    public List<User> findAll();
}

创建 UserDao.xml 映射文件

注意: 该文件要放在com/execise/dao里面, 不要写成com.execise.dao

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace属性: 接口类的全限定名-->
<mapper namespace="com.execise.dao.UserDao">
    <!--select标签: 查询
        id属性: 方法名
        resultType属性: 写方法返回值类型(如果是list,直接写实体类的全限定名)
        标签体: sql语句
    -->
    <select id="findAll" resultType="com.execise.bean.User">
        select * from t_user;
    </select>
</mapper>

创建 SqlMapConfig.xml 配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--配置连接数据库的环境 default:指定使用哪一个环境-->
    <environments default="a">
        <environment id="development">
            <!--配置事务,MyBatis事务用的是jdbc-->
            <transactionManager type="JDBC"/>
            <!--配置连接池, POOLED:使用连接池(mybatis内置的); UNPOOLED:不使用连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_day01?characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
        <environment id="a">
            <!--配置事务,MyBatis事务用的是jdbc-->
            <transactionManager type="JDBC"/>
            <!--配置连接池, POOLED:使用连接池(mybatis内置的); UNPOOLED:不使用连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_day02?characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <!--引入映射文件; resource属性: 映射文件的路径-->
        <mapper resource="com/execise/dao/UserDao.xml"/>
    </mappers>
</configuration>

测试

public class DbTest {
    @Test
    public void fun01() throws Exception {
        //1. 读取SqlMapConfig.xml获得输入流
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(is);
        //3. 获得SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //4.获得UserDao代理对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        //5.调用方法
        List<User> list = userDao.findAll();
        System.out.println(list);
        //6.释放资源
        sqlSession.close();
    }
}

小结

步骤

1. 创建Maven工程 导入坐标

2. 创建pojo

3. 创建Dao接口

4. 创建Dao的映射文件

5. 创建MyBatis核心配置文件SqlMapConfig.xml

6. 编写Java代码

注意事项

Dao的映射文件的路径

Mapper动态代理方式规范

Mapper.xml(映射文件)

定义mapper映射文件UserDao.xml，需要修改namespace的值为 UserDao接口全限定名。将UserDao.xml放在classpath的xxx.xxx.dao目录下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.execise.dao.UserDao">
    <select id="findAll" resultType="User">
        SELECT *FROM t_user
    </select>
</mapper>

Mapper.java(dao接口)

public interface UserDao {

    /**
     * 查询所有的用户
     * @return
     */
    List<User> findAll();

}

测试

public class DbTest {

      @Test
    public void fun01() throws Exception {
        SqlSession sqlSession = SqlSessionFactoryUtils.openSession();
        //4.获得UserDao代理对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        //5.调用方法
        List<User> list = userDao.findAll();
        System.out.println(list);
        //6.释放资源
        sqlSession.close();
    }

}

Mapper接口开发需要遵循以下规范：

1. Mapper.xml文件中的namespace必须和mapper(Dao)接口的全限定名相同。

2. Mapper.xml文件中select,update等的标签id的值必须和mapper(Dao)接口的方法名相同

3. Mapper.xml文件中select,update等的标签的parameterType必须和mapper(Dao)接口的方法的形参类型对应

4. Mapper.xml文件中select,update等的标签的resultType必须和mapper(Dao)接口的方法的返回值类型对应

5. Mapper.xml文件的文件名尽量和mapper(Dao)接口的名字一样

6. Mapper.xml文件的路径尽量和mapper(Dao)接口的路径在同一层目录

核心配置文件详解

核心配置文件的顺序

properties（引入外部properties文件）

settings（全局配置参数）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境集合属性对象）

? environment（环境子属性对象）

? transactionManager（事务管理）

? dataSource（数据源）

mappers（映射器）

properties

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis_day01?characterEncoding=utf-8
jdbc.user=root
jdbc.password=123456

引入到核心配置文件

<configuration>
   <properties resource="jdbc.properties">
    </properties>
    <!--数据源配置-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="UNPOOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    ....
</configuration>

typeAliases（类型别名）

定义单个别名

• 核心配置文件

	 <typeAliases>
	      <typeAlias type="com.execise.bean.User" alias="user"></typeAlias>
	 </typeAliases>

• 修改UserDao.xml

	<select id="findAll" resultType="user">
	    SELECT  * FROM  user
	</select>

批量定义别名

使用package定义的别名：就是pojo的类名，大小写都可以

• 核心配置文件

	<typeAliases>
	    <package name="com.execise.bean"/>
	</typeAliases>

• 修改UserDao.xml

	<select id="findAll" resultType="user">
	         SELECT  * FROM  user
	</select>

Mapper

方式一:引入映射文件路径

	 <mappers>
	     <mapper resource="com/execise/dao/UserDao.xml"/>
	 </mappers>

方式二:扫描接口

注: 此方式只能用作:代理开发模式,原始dao方式不能使用.

• 配置单个接口

	<mappers>
	 	<mapper class="com.execise.dao.UserDao"></mapper>
	</mappers>

• 批量配置

	<mappers>
	   <package name="com.execise.dao"></package>
	</mappers>

小结

核心配置文件的顺序

properties 引入properties文件的

• 创建properties文件

• 使用 <properties resource="文件的路径"/>

• 使用 ${key}

typeAliases（类型别名） 在Dao映射文件里面 直接写类(pojo)的名字, 不需要写类全限定名了

<typeAliases>
    <package name="com.execise.bean"/>
</typeAliases>

Mapper 引入Dao映射文件的

<mappers>
   <package name="com.execise.dao"></package>
</mappers>