初识MAVEN+MyBatis

文章目录

Maven

一个Java项目需要：

首先，我们需要确定引入哪些依赖包。例如，如果我们需要用到commons logging，我们就必须把commons logging的jar包放入classpath。如果我们还需要log4j，就需要把log4j相关的jar包都放到classpath中。这些就是依赖包的管理。
我们要确定项目的目录结构。例如，src目录存放Java源码，resources目录存放配置文件，bin目录存放编译生成的.class文件
还需要配置环境，例如JDK的版本，编译打包的流程，当前代码的版本号。
除了使用Eclipse这样的IDE进行编译外，我们还必须能通过命令行工具进行编译，才能够让项目在一个独立的服务器上编译、测试、部署

概述

了解

一个Java项目的一套配置不难，但是非常繁琐耗时。Maven就是来干这些事的。他是专门为Java项目打造的一个项目管理工具，可以对 Java 项目进行构建、依赖管理。主要功能：

提供了一套标准化的项目结构；
提供了一套标准化的构建流程（编译，测试，打包，发布……）；
提供了一套依赖管理机制。

Maven工程的项目结构

a-maven-project
├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   └── resources
│   └── test
│       ├── java
│       └── resources
└── target

项目的根目录a-maven-project是项目名，它有一个项目描述文件pom.xml，
存放Java源码的目录是src/main/java，
存放资源文件的目录是src/main/resources，
存放测试源码的目录是src/test/java，
存放测试资源的目录是src/test/resources，
所有编译、打包生成的文件都放在target目录里

使用

pom.xml

我的第一个Maven项目的pom文件内容

<?xml version="1.0" encoding="UTF-8"?>
<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>org.example</groupId>
    <artifactId>prjmybatisdemo1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.7</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.3</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.7</version>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <!-- 自动生成代码 主要配置这里 -->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.5</version>
                <configuration>
                    <configurationFile>
                        src/main/resources/generatorConfig.xml
                    </configurationFile>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

groupId 类似于Java的包名
artifactId类似于Java的类名，通常是项目名称， vision版本号，这三样构成唯一标识
<properties>...</properties>：这个里面是jdk的版本
<dependencies>...</dependencies> 全是引入的第三方包库，他们也是由前面三个变量确定的，在Maven中央仓库和阿里云镜像都能找到对应的依赖
- 某个jar包一旦被Maven下载过，即可永久地安全缓存在本地。
  
  注：只有以-SNAPSHOT结尾的版本号会被Maven视为开发版本，开发版本每次都会重复下载，这种SNAPSHOT版本只能用于内部私有的Maven repo，公开发布的版本不允许出现SNAPSHOT。
<build>...</build>：这个是 project 的子元素
- resources：一些配置文件的配置 idea不能编译MyBatis编译的和java远源码在一起的xml文件，所以用了这个属性
- plugin：插件的配置，这里找的自动生成实体类和dao接口以及映射文件的插件，需要一个配置文件后面上

Maven的依赖关系

Maven定义了几种依赖关系，分别是compile、test、runtime和provided：

scope	说明	示例
compile	编译时需要用到该jar包（默认）	commons-logging
test	编译Test时需要用到该jar包	junit
runtime	编译时不需要，但运行时需要用到	mysql
provided	编译时需要用到，但运行时由JDK或某个服务器提供	servlet-api

其中，默认的compile是最常用的，Maven会把这种类型的依赖直接放入classpath。
test依赖表示仅在测试时使用，正常运行时并不需要。最常用的test依赖就是JUnit：

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

runtime依赖表示编译时不需要，但运行时需要。最典型的runtime依赖是JDBC驱动，例如MySQL驱动：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.48</version>
    <scope>runtime</scope>
</dependency>

provided依赖表示编译时需要，但运行时不需要。最典型的provided依赖是Servlet API，编译的时候需要，但是运行时，Servlet服务器内置了相关的jar，所以运行期不需要：

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

命令行编译

在命令中，进入到pom.xml所在目录，输入以下命令：

$ mvn clean package

安装和idea的配置使用

其它学习。

MyBatis

简介

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

ORM框架：
- ORM（Object Relational Mapping）框架采用元数据来描述对象与关系映射的细节，元数据一般采用XML格式，并且存放在专门的对象一映射文件中。简单理解为一种框架的格式
- 当前ORM框架主要有五种：Hibernate(Nhibernate)，iBATIS，mybatis，EclipseLink，JFinal。

初步使用

需要将对应的jar包放到 classpath 中就可以了，如果采用 Maven 则只需加入对应的依赖。

数据库的配置文件：jdbc.properties

driver = com.mysql.cj.jdbc.Driver
url = jdbc:mysql://127.0.0.1:3306/eshop?serverTimezone=UTC
username = root
password = 123

MyBatis的配置文件：MyBatis.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>
    <!-- 导入数据库配置文件 与下面的要对应 或者直接填入对应信息 不用数据库配置文件 -->
    <properties resource="jdbc.properties"></properties>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- mapper映射文件的位置 -->
    <mappers>
        <mapper resource="com/gpb/mapper/GoodsMapper.xml"/>
        <mapper resource="com/gpb/mapper/UserInfoMapper.xml"/>
    </mappers>
</configuration>

手写 mapper.xml 文件

项目结构：

前提数据库的信息，数据，实体类的准备

package com.gpb.mapper;

import java.util.List;
import com.gpb.bean.Goods;

/** * @author bigdata7 */
public interface GoodsMapper {
        
	public Goods selectGoods(int id);
	public List<Goods> findAll();
	public List<Goods> findByName(String goodsName);
	public int insertGoods(Goods goods);
	public int updateGoods(Goods goods);
	public int delById(int id);
}

<?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.gpb.mapper.GoodsMapper">
  <select id="selectGoods" parameterType="int" resultType="com.gpb.bean.Goods">
    select * from goods where id = #{id}
  </select>
  <select id="findAll" resultType="com.gpb.bean.Goods">
  	select * from goods
  </select>
  <select id="findByName" parameterType="java.lang.String" resultType="com.gpb.bean.Goods">
  <!-- 直接拼接sql的话用'%${value}%' 固定写法 不能防止sql注入 不安全 -->
  	select * from goods where goodsName like "%"#{goodsName}"%"
  </select>
  <insert id="insertGoods" parameterType="com.gpb.bean.Goods"> 
      <!-- order：after 和 before 插入前插入后 sql查询最后插入的id 会自增 这里我们插入数据不管id 注意固定写法 -->
  	<selectKey order="AFTER" keyProperty="id" resultType="java.lang.Integer">
  		select last_insert_id()
  	</selectKey>
  		insert into goods(id, goodsName, price, memo, pic, createTime) values (#{id}, #{goodsName}, #{price}, #{memo}, #{pic}, #{createTime})
  </insert>
  <update id="updateGoods" parameterType="com.gpb.bean.Goods">
  	update goods set goodsName=#{goodsName}, price=#{price},memo=#{memo},pic=#{pic},createTime=#{createTime} where id =#{id}
  </update>
  <delete id="delById" parameterType="int">
  	delete from goods where id=#{id}
  </delete>
</mapper>

namespace：标识区分作用，这里是dao接口的名称，这里的mapper.xml文件相当于我们之前写的到层的dao接口的实现类，这里需要我们去写一个dao接口和这个mapper.xml映射文件关联到一起。
select,insert, update, delete ：对应数据库的四种操作，里面是对应的sql语句
- id：相当于方法名要和 dao层的方法名对应
- parameterType：参数类型，或者说sql语句的占位符的参数类型
- resultType：返回值的类型
- #{...}：相当于sql语句的占位符？
-

去测试类做测试

创建测试类

package test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import com.gpb.bean.Goods;
import com.gpb.mapper.GoodsMapper;
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.Before;
import org.junit.Test;


public class GoodsMapperTest {
        
	/** * 创建sql工厂全局 * 读取配置文件 * 是接口需要new builder */
	SqlSessionFactory sqlSessionFactory = null;
	/** * before：junit的注解：在测试之前干的事 * 1.加载mybitas配置文件读取【通过ibatis的Resources的getRe...方法去获取输入流】 * 2.SqlSessionFactory 这是一个接口 通过new 它的构建器调用构建方法传递读到的输入流配置参数去实例化sql会话工厂 */
	@Before
	public void setUp() {
        
		String xmlFile = "MyBatis-Config.xml";
		try {
        
			InputStream config = Resources.getResourceAsStream(xmlFile);
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(config);
		} catch (IOException e) {
        
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
    /** * test注解：junit的一个测试单元 以方法为驱动的 可以直接运行 * 1.通过sql会话工厂对象去打开并创建一个sql会话 * 2.这个会话去调用getMapper方法，用反射的方式去实例化接口 * 3.用接口的实例化对象去调用相应的方法 * 4.使用完一次会话之后关闭会话【后面可以使用连接池】 */
	@Test
	public void findAll() {
        
		SqlSession sqlSession = sqlSessionFactory.openSession();
		GoodsMapper goodsMapper = sqlSession.getMapper(GoodsMapper.class);
		List<Goods> list = goodsMapper.findAll();
		System.out.println(list);
		sqlSession.close();
	}
}

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>

    <!-- 1、属性：例如jdbc.properties -->
    <properties resource="jdbc.properties"></properties>

    <!-- 2、设置：定义全局性设置，例如开启二级缓存 -->
    <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>

    <!-- 3、类型名称：为一些类定义别名 -->
    <typeAliases>
        <typeAlias type="com.panshenlian.pojo.User" alias="user"></typeAlias>
    </typeAliases>

    <!-- 4、类型处理器：定义Java类型与数据库中的数据类型之间的转换关系 -->
    <typeHandlers></typeHandlers>

    <!-- 5、对象工厂 -->
    <objectFactory type=""></objectFactory>

    <!-- 6、插件：mybatis的插件，支持自定义插件 -->
    <plugins>
        <plugin interceptor=""></plugin>
    </plugins>

    <!-- 7、环境：配置mybatis的环境 -->
    <environments default="development">
        <!-- 环境变量：支持多套环境变量，例如开发环境、生产环境 -->
        <environment id="development">
            <!-- 事务管理器：默认JDBC -->
            <transactionManager type="JDBC" />
            <!-- 数据源：使用连接池，并加载mysql驱动连接数据库 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
                <property name="username" value="root" />
                <property name="password" value="123456" />
            </dataSource>
        </environment>
    </environments>

    <!-- 8、数据库厂商标识 -->
    <databaseIdProvider type=""></databaseIdProvider>

    <!-- 9、映射器：指定映射文件或者映射类 -->
    <mappers>
        <mapper resource="UserMapper.xml" />
    </mappers>
</configuration>

注意：MyBatis的配置文件的顺序是固定的千万要注意

知乎老哥的文章

me" value=“root” />

<!-- 8、数据库厂商标识 -->
<databaseIdProvider type=""></databaseIdProvider>

<!-- 9、映射器：指定映射文件或者映射类 -->
<mappers>
    <mapper resource="UserMapper.xml" />
</mappers>

```