公告

34_mybatis

学习目标

能够了解什么是框架
掌握Mybatis框架开发快速入门
掌握Mybatis框架的基本CRUD操作
掌握SqlMapConfig.xml配置文件
掌握Mybatis的parameterType的配置
掌握Mybatis的resultType的配置

第一章-框架概述

知识点-框架概述

1.目标

能够了解什么是框架

2.路径

什么是框架
框架要解决的问题

3.讲解

3.1 什么是框架

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

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

一句话解释：框架其实就是一套模板，或者可重用的设计，套路。按照这种套路来写代码。尤其是在开发大型项目上，框架的作用体现得就更加淋漓尽致。小型项目，没有框架的用武之地。！

3.2 框架要解决的问题

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

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

代码是要分层，项目要分层，每一层的代码需要进行交互，对话。

4.小结

框架: 软件的半成品. 我们开发者使用框架开发, 更加的简单, 提高开发效率
学框架就是学套路，先把套路学会了，再去思考，这种套路（框架）背后的核心。
SSM框架

知识点-MyBatis框架概述

1.目标

能够了解什么是MyBatis

2.路径

jdbc 程序回顾
MyBatis框架概述

3.讲解

3.1jdbc 程序回顾

3.1.1程序回顾

注册驱动
获得连接
创建预编译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 name 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();
                }
            }
        }
    }

3.1.2 jdbc 问题分析

数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。
Sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大， sql 变动需要改变java 代码。
使用 preparedStatement 向占有位符号传参数存在硬编码，因为 sql 语句的 where 条件不一定，可能多也可能少，修改 sql 还要修改代码，系统不易维护。
对结果集解析存在硬编码（查询列名）， sql 变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成 pojo 对象解析比较方便

3.2MyBatis框架概述

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

mybatis 通过xml 或注解的方式将执行的各种statement 配置起来，并通过java 对象和statement 中sql的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql并将结果映射为 java 对象并返回。采用 ORM ( Object relational mapping)思想解决了实体和数据库映射的问题，对jdbc 进行了封装，屏蔽了jdbc api 底层访问细节，使我们不用与 jdbc api打交道，就可以完成对数据库的访问操作。

官网: http://www.mybatis.org/mybatis-3/

4.小结

MyBatis: 持久层的一个框架, 封装了JDBC. 操作数据库
为什么要学习MyBatis?
- JDBC那一套代码和DBUtils都有一些很明显的缺点, JDBC和DBUtils不适合做项目
- MyBatis是工作里面的主流的持久层框架, 使用几率特别大

第二章-Mybatis入门

案例-Mybatis快速入门

1.需求

使用MyBatis查询所有的用户, 封装到List集合

2.分析

创建Maven工程(java), 添加mybatis的依赖坐标
创建pojo （javabean）
创建UserDao接口
创建UserDao映射文件（xml配置文件）
创建MyBatis核心配置文件SqlMapConfig.xml （xml配置文件）
编写java代码测试

3.实现

3.1准备工作

数据库

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', '北京');

3.2.MyBatis快速入门

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

 <!--1. 添加依赖-->
    <dependencies>
        <!--MyBatis坐标-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>

        <!--lombok 依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
        </dependency>
    </dependencies>

3.2.2创建User实体类

User .java

package com.itheima.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int uid;
    private String username;
    private String sex;
    private Date birthday;
    private String address;
}

3.2.3创建 UserDao 接口

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

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

public interface UserDao {

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

3.2.4创建 UserDao.xml 映射文件

在resources 下面创建文件夹 com/itheima/dao 文件夹的名字需要与dao包的名字一样。

注意: 该文件要放在com/itheima/dao里面, 不要写成com.itheima.dao ，要使用 / 的方式创建

1544705827942

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

<!--
    这个文件其实就是我们dao的映射文件，通俗的讲，就是当我们要调用UserDao里面的findAll方法的时候
        要执行什么样的sql语句，要在这里做配置！

    1. 有接口，就有映射文件
    2. 映射文件是一个xml文件，要放在resource文件夹里面，需要为它创建一个目录
    3. 记住一下套路：
        a. xml的目录最好要和dao接口的包名路径一样！
        b. xml的目录创建的时候必须要使用 / 的形式，不能使用 . 的形式创建！
        c. xml里面的命名空间必须要写成dao接口的全路径！
        d. xml里面的语句的id值必须是dao接口的方法名字！
        e. resultType： 写的是方法的返回值类型，如果方法的返回值是集合类型，那么写的是集合中的元素类型。
        f. parameterType : 写的是参数的类型，参数是什么类型，就写什么类型，即是是集合，也写的是集合的类型。

-->
<mapper namespace="com.itheima.dao.UserDao">
    <!--在这里写方法对应的sql语句-->
    <select id="findAll"  resultType="com.itheima.bean.User">
        select * from t_user
    </select>
    
</mapper>

3.2.5创建 SqlMapConfig.xml 配置文件

它的作用：告诉mybatis去连接哪个数据库，告诉mybatis 项目有哪些映射文件（需要登记），起别名 ...

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

<!--
这个文件是mybatis的核心配置文件，它里面包含两部分内容： 连接数据库， 映射文件在哪里-->

<configuration>

    <!--
        1. 数据库的连接
            environments ： 用于配置环境，它里面可以定义多个环境，使用  environment来定义
                到底是用哪一个环境，取决于 default属性写的是哪个  environment的id值
               environment : 用于定义环境，
                    id :声明一个标识，唯一标识
                transactionManager ： 事务管理员
                dataSource ：用不用连接池
    -->
    <environments default="dev">
        <environment id="dev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_day01"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--2. 映射文件在哪里？-->
    <mappers>
        <mapper resource="com/itheima/dao/UserDao.xml"/>
    </mappers>

</configuration>

3.2.6 测试

package com.itheima.test;

import com.itheima.bean.User;
import com.itheima.dao.UserDao;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestUserDao {

    //查询所有
    @Test
    public void testFindAll() throws IOException {

        //1. 读取SQLMapConfig文件，读取成一个输入流
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2. 构建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        //3. 使用输入流来构建SqlSessionFactory
        SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(is);

        //4. 问SqlSessionFactory要SqlSession
        SqlSession session = sessionFactory.openSession();

        //5. 问SqlSession要UserDao的代理对象
        UserDao dao = session.getMapper(UserDao.class);

        //6. 有了代理对象，就可以调用findAll方法
        List<User> list = dao.findAll();
        System.out.println("list = " + list);

        //7. 关闭SqlSession
        session.close();
    }
}

4.小结

4.1步骤

创建Maven工程导入坐标
创建pojo
创建Dao接口
创建Dao的映射文件
创建MyBatis核心配置文件SqlMapConfig.xml
编写Java代码

4.2注意事项

Dao的映射文件的路径

知识点-Mapper动态代理方式规范

1.目标

掌握Mapper动态代理方式规范

2.路径

入门案例回顾
规范

3.讲解

3.1入门案例回顾

3.1.1 创建接口


public interface UserDao {

    List<User> findAll();

}

3.1.2 创建映射文件

定义mapper映射文件UserDao.xml，需要修改namespace的值为 UserDao接口全限定名。将UserDao.xml放在resource的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">

<!--
    这个文件其实就是我们dao的映射文件，通俗的讲，就是当我们要调用UserDao里面的findAll方法的时候
        要执行什么样的sql语句，要在这里做配置！

    1. 有接口，就有映射文件
    2. 映射文件是一个xml文件，要放在resource文件夹里面，需要为它创建一个目录
    3. 记住一下套路：
        a. xml的目录最好要和dao接口的包名路径一样！
        b. xml的目录创建的时候必须要使用 / 的形式，不能使用 . 的形式创建！
        c. xml里面的命名空间必须要写成dao接口的全路径！
        d. xml里面的语句的id值必须是dao接口的方法名字！
        e. resultType： 写的是方法的返回值类型，如果方法的返回值是集合类型，那么写的是集合中的元素类型。
        f. parameterType : 写的是参数的类型，参数是什么类型，就写什么类型，即是是集合，也写的是集合的类型。

-->
<mapper namespace="com.itheima.dao.UserDao">
    <!--在这里写方法对应的sql语句-->
    <select id="findAll"  resultType="com.itheima.bean.User">
        select * from t_user
    </select>
    
</mapper>

3.2.3 测试

package com.itheima.test;

import com.itheima.bean.User;
import com.itheima.dao.UserDao;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestUserDao {

    //查询所有
    @Test
    public void testFindAll() throws IOException {

        //1. 读取SQLMapConfig文件，读取成一个输入流
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2. 构建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        //3. 使用输入流来构建SqlSessionFactory
        SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(is);

        //4. 问SqlSessionFactory要SqlSession
        SqlSession session = sessionFactory.openSession();

        //5. 问SqlSession要UserDao的代理对象
        UserDao dao = session.getMapper(UserDao.class);

        //6. 有了代理对象，就可以调用findAll方法
        List<User> list = dao.findAll();
        System.out.println("list = " + list);

        //7. 关闭SqlSession
        session.close();
    }
}

3.2规范

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

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

否则出错： Type interface com.itheima.dao.UserDao is not known to the MapperRegistry.

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

Invalid bound statement (not found): com.itheima.dao.UserDao.findAll

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)接口的路径在同一层目录

7,创建xml目录的时候，要使用 / 的方式创建，不要使用 . 的方式创建，否则报错！

4.小结

我们使用MyBatis 遵循这些规范

第三章-MyBatis进阶【重点】

案例-使用Mybatis完成CRUD【重点】

1.需求

使用Mybatis完成CRUD

2.分析

在Dao接口定义方法
在Dao映射文件配置

3.实现

3.1新增用户

3.1.1实现步骤

UserDao中添加新增方法

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

public interface UserDao {

    /**
     * 添加
     * @param user
     * @return 影响的行数
     */
    int add(User user);
}

在 UserDao.xml 文件中加入新增配置

<?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.itheima.dao.UserDao">


    <!--添加用户: 增删改操作不用写返回的类型，mybatis会自动返回影响的行数-->
    <insert id="add" parameterType="com.itheima.bean.User">
        insert into t_user values(null , #{username} , #{sex} ,#{birthday} , #{address})
    </insert>
</mapper>

添加测试类中的测试方法

package com.itheima.test;

import com.itheima.bean.User;
import com.itheima.dao.UserDao;
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 java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;

public class TestUserDao {

    @Test
    public void testAdd() throws IOException {

        //1. 读取SqlMapConfig文件
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2. 构建SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        //3. 构建SqlSessionFactory
        SqlSessionFactory factory = builder.build(is);

        //4. 构建SqlSession
        SqlSession session = factory.openSession();

        //5. 问SqlSession要dao的代理
        UserDao userDao = session.getMapper(UserDao.class);

        //6. 调用方法
        User user = new User();
        user.setUsername("zhangsan");
        user.setSex("男");
        user.setBirthday(new Date());
        user.setAddress("深圳");
        userDao.add(user);

        //7. 提交事务： mybatis没有默认提交事务 ,它把setAutoCommit(false), 所以对于增删改操作，要记得提交事务
        session.commit();

        //8. 关闭SqlSession
        session.close();
    }
}

3.1.2新增用户 id 的返回值

有时候我们存在一些场景，把一条数据存储到数据库了之后，需要马上得到这条记录的id值。因为这条数据是我们自己创建赶出来的，它的id是多少，我们是不知道的，只有这条记录已经存在于数据库里面了，才知道它的id值。
什么情况下|场景下，我们需要在插入完这条记录之后，立即就需要得到这条记录的id呢？

当我们往A表里面添加一条记录之后，需要继续往B表里面添加一条记录，但是A表和B表形成了一种主外键关系。B表里面的外键就是A表里面的主键，所以往B表里面添加记录，必须要先知道A表的这条记录的主键

新增用户后，同时还要返回当前新增用户的 id 值，因为 id 是由数据库的自动增长来实现的，所以就相当于我们要在新增后将自动增长 auto_increment 的值返回。

方式一标签SelectKey获取主键

属性	描述
keyProperty	selectKey 语句结果应该被设置的目标属性。
resultType	结果的类型。MyBatis 通常可以算出来,但是写上也没有问题。MyBatis 允许任何简单类型用作主键的类型,包括字符串。
order	这可以被设置为 BEFORE 或 AFTER。如果设置为 BEFORE,那么它会首先选择主键,设置 keyProperty 然后执行插入语句。如果设置为 AFTER,那么先执行插入语句,然后是 selectKey 元素-这和如 Oracle 数据库相似,可以在插入语句中嵌入序列调用。

UserDao.java

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

public interface UserDao {
    /**
     * 添加： 获取主键id，使用selectKey去获取
     * @param user
     * @return
     */
    int add02(User user);
}

UserDao.xml

<?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.itheima.dao.UserDao">


    <!--添加用户：并且获取id主键返回-->
    <insert id="add02" parameterType="com.itheima.bean.User">
         insert into t_user values(null , #{username} , #{sex} ,#{birthday} , #{address})

         <!--
            获取主键 alt + shift + 方向上下 移动快捷键
                selectKey: 主要使用来获取主键id
                    keyProperty : 用参数user里面的什么属性来接收主键值
                    resultType:  接收主键的属性是什么类型
                    order: 只能写两个值： before | after
                        BEFORE：  先执行获取id的操作，再去执行添加数据的操作
                        AFTER : 先执行添加的操作，再去执行获取id的操作。

                        SELECT LAST_INSERT_ID() : 获取id的语句
         -->
         <selectKey keyProperty="uid" resultType="int" order="AFTER">
                SELECT LAST_INSERT_ID()
         </selectKey>
    </insert>
</mapper>

方式二：属性配置

在isnert标签里面直接使用属性keyProperty 和 useGeneratedKeys来设置获取主键id值。

UserDao.java

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

public interface UserDao {
    /**
     * 添加： 获取主键id，使用属性的写法来获取
     * @param user
     * @return
     */
    int add03(User user);
}

UserDao.xml

<?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.itheima.dao.UserDao">

    <!--
        添加用户，获取id主键返回
            keyProperty ：表示，使用参数user对象里面的什么属性来接收主键id
            useGeneratedKeys: 表示，是否使用数据库自增创建创建出来的主键id值，还是由mybatis自己搞出来的id值。
                true: 使用数据库创建给出来的id值
                false: 不是用数据库创建出来的id值，由mybatis给出来。
     -->
    <insert id="add03" parameterType="com.itheima.bean.User" keyProperty="uid" useGeneratedKeys="true">
        insert into t_user values(null , #{username} , #{sex} ,#{birthday} , #{address})
    </insert>
</mapper>

3.1.3新增用户 id 的返回值(字符串类型)

主键不一定是int类型... 主键也可以是字符串类型。只有到以后做项目，有数据库合并，数据库集群的时候。

字符串类型的主键通常就是UUID生成的一串32个字符的字符串。数据库合并！

User.java

package com.itheima.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private String myId;
    private int uid;
    private String username;
    private String sex;
    private Date birthday;
    private String address;
}

UserDao.java

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

public interface UserDao {

    /**
     * 添加： 获取主键id 使用selectKey标签来获取，主键是字符串类型。
     * @param user
     * @return
     */
    int add04(User user);
}

UserDao.xml

<?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.itheima.dao.UserDao">


    <!--添加用户，获取id主键返回，但是主键是字符串类型的主键-->
    <insert id="add04" parameterType="com.itheima.bean.User" >
        insert into t_user values(null , #{username} , #{sex} ,#{birthday} , #{address})

        <selectKey keyProperty="myId" resultType="String" order="BEFORE">
            select uuid()
        </selectKey>
    </insert>
</mapper>

3.2修改用户

UserDao中添加修改方法

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

public interface UserDao {

    //=======================修改=======================

    /**
     * 根据id来查询用户
     * @param id
     * @return
     */
    User findById(int id);

    /**
     * 修改用户
     * @param user
     * @return
     */
    int update(User user);
}

在 UserDao.xml 文件中加入新增配置

<?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.itheima.dao.UserDao">

    <!--=========================更新===========================-->

    <!--根据id来查询用户-->
    <select id="findById" parameterType="int" resultType="com.itheima.bean.User">
        select * from t_user where uid = #{id}
    </select>

    <!--更新用户-->
    <update id="update" parameterType="com.itheima.bean.User">
        update t_user set username = #{username} , sex = #{sex} , birthday=#{birthday} , address= #{address} where uid = #{uid}
    </update>
</mapper>

添加测试类中的测试方法

   //修改用户
    @Test
    public void testUpdate() throws IOException {

        //1. 读取SqlMapConfig文件
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2. 构建SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        //3. 构建SqlSessionFactory
        SqlSessionFactory factory = builder.build(is);

        //4. 构建SqlSession
        SqlSession session = factory.openSession();

        //5. 问SqlSession要dao的代理
        UserDao userDao = session.getMapper(UserDao.class);

        //6. 调用方法
        User user = userDao.findById(7);

        //修改数据
        user.setUsername("lisi");

        userDao.update(user);

        //7. 提交事务： mybatis没有默认提交事务 ,它把setAutoCommit(false), 所以对于增删改操作，要记得提交事务
        session.commit();

        //8. 关闭SqlSession
        session.close();
    }

3.3删除用户

UserDao中添加删除方法

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

public interface UserDao {

    /**
     * 删除用户
     * @param id
     * @return
     */
    int delete(int id);
}

在 UserDao.xml 文件中加入新增配置

<?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.itheima.dao.UserDao">

	<!--删除用户-->
    <delete id="delete" parameterType="int">
        delete from t_user where uid = #{id}
    </delete>

</mapper>

添加测试类中的测试方法


    //删除用户
    @Test
    public void testDelete() throws IOException {

        //1. 读取SqlMapConfig文件
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2. 构建SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        //3. 构建SqlSessionFactory
        SqlSessionFactory factory = builder.build(is);

        //4. 构建SqlSession
        SqlSession session = factory.openSession();

        //5. 问SqlSession要dao的代理
        UserDao userDao = session.getMapper(UserDao.class);

        //6. 调用方法
        userDao.delete(7);

        //7. 提交事务： mybatis没有默认提交事务 ,它把setAutoCommit(false), 所以对于增删改操作，要记得提交事务
        session.commit();

        //8. 关闭SqlSession
        session.close();
    }

3.4模糊查询

3.4.1 方式一

UserDao 中添加根据姓氏来查询用户的方法


package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

public interface UserDao {

	/**
     * 模糊查询，根据姓氏来查询用户
     * @param name
     * @return
     */
    List<User> findByUsername(String name);

}

在 UserDao.xml 文件中加入新增配置

<?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.itheima.dao.UserDao">

    <!--1. 从外面传递进来 % 的写法-->
    <select id="findByUsername" parameterType="string" resultType="com.itheima.bean.User">
        select * from t_user where username like #{name}
    </select>
</mapper>

添加测试类中的测试方法

在外面拼接 % ，然后再传递数据进来

//模糊查询： 从外面传递进去 %
    @Test
    public void testFindByUsername() throws IOException {

        //1. 读取SqlMapConfig文件
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2. 构建SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        //3. 构建SqlSessionFactory
        SqlSessionFactory factory = builder.build(is);

        //4. 构建SqlSession
        SqlSession session = factory.openSession();

        //5. 问SqlSession要dao的代理
        UserDao userDao = session.getMapper(UserDao.class);

        //6. 调用方法
        List<User> list = userDao.findByUsername("zhang%");
        System.out.println("list = " + list);

        //8. 关闭SqlSession
        session.close();
    }

3.4.2 方式二

UserDao 中添加新增方法

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

public interface UserDao {

/**
     * 模糊查询，根据姓氏来查询用户
     * @param name
     * @return
     */
    List<User> findByUsername02(String name);

    /**
     * 模糊查询，根据姓氏来查询用户
     * @param name
     * @return
     */
    List<User> findByUsername03(String name);

    /**
     * 模糊查询，根据姓氏来查询用户
     * @param name
     * @return
     */
    List<User> findByUsername04(String name);
}

在 UserDao.xml 文件中加入新增配置

<?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.itheima.dao.UserDao">

    <!--2. 在语句里面追加 % , 外面不传递进来 % ， 使用#{}取参数的值 -->
    <select id="findByUsername02" parameterType="string" resultType="com.itheima.bean.User">
        select * from t_user where username like #{name}"%"
    </select>

    <!--3. 在语句里面追加 % , 外面不传递进来 % , 使用${}取参数的值-->
    <select id="findByUsername03" parameterType="string" resultType="com.itheima.bean.User">
        select * from t_user where username like '${value}%'
    </select>

    <!--4. 在语句里面追加 % , 外面不传递进来 % , 使用#{}取参数的值-->
    <select id="findByUsername04" parameterType="string" resultType="com.itheima.bean.User">
        <!--select * from t_user where username like concat("%" , #{name} , "%")-->
        select * from t_user where username like concat( #{name} , "%")
    </select>

</mapper>

3.4.3 #{}与${}的区别【面试】

{}
- 可以防止sql注入
- 会对sql语句进行预编译|解析，传递什么参数进来，仅仅是顶替占位#{}而已。
- 一般使用的都是这个#{}
- {} 背后会自动的拼接上 ' '
- ${}
- 不能防止sql注入
- 不会对sql语句进行预先编译，传递什么参数进来，不会仅仅认为这数据，会和sql语句做拼接之后再解析SQL语句 ' or '1=1'
- 一般比较少用这个，能使用#{}就先使用这个#{}
- ${} 不会拼接上 ' ' 所以有时候，我们需要做一些order by 这样的列名指定，需要的是准确的列名，而不是 '列名'
- 如果只有一个简单参数的话，那么名字只能用${} 里面只能写value，不能使用其他的名字

一般来说，只要 #{} 能用的，基本都用它，只要它不能用的时候，再想想这个 ${}

3.5.SqlSessionFactory工具类的抽取

步骤:

创建SqlSessionFactoryUtils
定义一个getSqlSession()方法获得sqlSession
定义释放资源方法
保证SqlSessionFactory只有一个(静态代码块)

实现

package com.itheima.utils;

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 java.io.IOException;
import java.io.InputStream;

/*
    这是专门用来提供Session的工具类
        1. 对外提供一个方法，用于获取SqlSession
        2. 对外提供一个方法，用于提交事务以及关闭SqlSession
        3. 对外提供一个方法，用于关闭SqlSession
 */
public class SqlSessionFactoryUtil {

    private static SqlSessionFactory factory = null;

    //使用静态代码块确保工厂只有一个！
    static{
        try {
            //1. 读取SqlMapConfig文件
            InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");

            //2. 构建SqlSessionFactoryBuilder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //3. 构建SqlSessionFactory
            factory = builder.build(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 获取sqlsession
     * @return
     */
    public static SqlSession getSession(){
        //4. 构建SqlSession
        return  factory.openSession();
    }


    /**
     * 提交事务并且关闭sqlsession
     * @param session
     */
    public static void commitAndClose(SqlSession session){
        session.commit();
        session.close();
    }

    /**
     * 关闭sqlsession
     * @param session
     */
    public static void close(SqlSession session){
        session.close();
    }
}

4.小结

4.1增删改查

增加

<insert id="" parameterType="" resultType="" keyProperty="" useGeneratedKeys="true">
	sql语句
</insert>

更新

<update id="" parameterType="" resultType="" >
	sql语句
</update>

删除

<delete id="" parameterType="" resultType="" >
	sql语句
</delete>

查询

<select id="" parameterType="" resultType="" >
	sql语句
</select>

4.2#和$区别

#{}表示一个占位符号
- 通过#{}可以实现 preparedStatement 向占位符中设置值,自动进行 java 类型和数据库类型转换
- #{}可以有效防止 sql 注入
- #{}可以接收简单类型值或 pojo 属性值
- 如果 parameterType 传输单个简单类型值(String,基本类型)， #{} 括号中可以是 value 或其它名称。
${}表示拼接 sql 串
- 通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换.
- ${}不能防止 sql 注入
- ${}可以接收简单类型值或 pojo 属性值
- 如果 parameterType 传输单个简单类型值.${}括号中只能是 value

知识点-parameterType深入

1.目标

掌握Mybatis的参数深入(parameterType)

2.路径

传递简单类型
传递 pojo 对象
传递 pojo 包装对象类型

3.讲解

3.1传递简单类型

基本的类型,字符串

直接写#{任意字段}或者${value}

package com.itheima.dao;

import com.itheima.bean.QueryVo;
import com.itheima.bean.User;
import org.apache.ibatis.annotations.Param;

/*
    演练的是： parameterType
 */
public interface UserDao {

    /**
     * 根据用户名来查询用户 ： 传递简单的参数
     * @param username
     * @return
     */
    User findByUsername(String username);
}

映射文件

<?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.itheima.dao.UserDao">



    <!--
        传递简单的参数
            1. 如果方法的参数是一个简单的类型（基本数据类型和字符串） ，parameterType就直接写它的类型即可
            2. 不需要写完整的全路径，可以直接写全小写名字，因为mybatis给这种类型起了别名了。
            3. 当传递进来的是简单的参数，那么取值的时候，可以使用#{参数名} | ${任意值} |  ${value} 来取值
     -->
    <select id="findByUsername" parameterType="string" resultType="com.itheima.bean.User">
        select * from t_user where username = #{username}
    </select>
</mapper>

3.2传递 pojo 对象

Mybatis 使用 ognl 表达式解析对象字段的值， #{}或者${}括号中的值为 pojo 属性名称。

package com.itheima.dao;

import com.itheima.bean.QueryVo;
import com.itheima.bean.User;
import org.apache.ibatis.annotations.Param;

/*
    演练的是： parameterType
 */
public interface UserDao {


    /**
     * 根据用户名来查询用户 ： 传递简单的参数
     * @param user
     * @return
     */
    User findByUsername2(User user);
}

映射文件


<?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.itheima.dao.UserDao">


<!--
        传递对象的参数
        1. 如果方法的参数是对象类型，那么parameterType就直接写它的类型即可(全路径 | 别名)
        2. 取对象中的某个属性的值，那么可以使用 #{属性名} | ${属性名} 即可取值，千万不要写成#{参数名.属性名}
    -->
    <select id="findByUsername2" parameterType="com.itheima.bean.User" resultType="com.itheima.bean.User">
        select * from t_user where username = #{username}
    </select>
</mapper>

3.3传递 pojo 包装对象类型

包装对象类型，就是：对象里面的属性是一个对象。

开发中通过 pojo 传递查询条件，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。Pojo 类中包含 pojo。

京东查询的例子:

1539830569011

需求：根据用户名查询用户信息，查询条件放到 QueryVo 的 user 属性中。

QueryVo

package com.itheima.bean;

import lombok.Data;

/*
    查询对象
 */
@Data
public class QueryVo {
    private User user;
}

UserDao接口

package com.itheima.dao;

import com.itheima.bean.QueryVo;
import com.itheima.bean.User;
import org.apache.ibatis.annotations.Param;


	/**
     * 根据用户名来查询用户 ： 传递简单的参数
     * @param qv
     * @return
     */
    User findByUsername3(QueryVo qv);
}

UserDao.xml文件

<?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.itheima.dao.UserDao">
<!--
        传递对象包含对象的参数
            1. 去参数的时候，使用#{对象属性名.子属性即可} ：  #{user.username}
            2. 如果内部的子属性还是一个对象，那么接着继续往下 . 即可
     -->
    <select id="findByUsername3" parameterType="com.itheima.bean.QueryVo" resultType="com.itheima.bean.User">
        select * from t_user where username = #{user.username}
    </select>
</mapper>

3.4 传递多个参数

在方法的参数上打上注解@param

如果方法有传递多个参数的必要，那么通常有四种写法来实现：

使用#{0} , #{1} , #{2} ... 来获取指定位置的参数。 0 表示第一个参数，1表示第二个参数。阅读性差。

使用注解@param来给参数起名字。然后在xml里面使用#{参数的别名}取值

可以使用一个Map集合来封装这些数据，然后传递map集合进去。直接写 #

可以使用一个javaBean来包装这些数据，然后传递javabean的对象进去。直接写 #

UserDao

package com.itheima.dao;

import com.itheima.bean.QueryVo;
import com.itheima.bean.User;
import org.apache.ibatis.annotations.Param;

/*
    演练的是： parameterType
 */
public interface UserDao {

    /**
     * 按照用户名和性别来查询用户
     * @param username
     * @param sex
     * @return
     */
    User findByUsernameAndSex(@Param("username") String  username , @Param("sex") String sex);
}

Usredao.xml

<?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.itheima.dao.UserDao">

    <!--
        传递多个参数
            1. 当传递多个参数的时候，需要给参数加上注解 @param("别名") 起别名。
            2. 在映射文件中使用 #{别名} 来取参数的值。
    -->
    <select id="findByUsernameAndSex" parameterType="string" resultType="com.itheima.bean.User">
        select * from t_user where username = #{username} and sex = #{sex}
    </select>


</mapper>

4.小结

传递简单类型

#{任意字段}或者${value}

传递pojo对象类型

#{javaBean属性名}或者${javaBean属性名}

传递的包装的pojo

#{属性名.属性名} 或者${属性名.属性名}

传递多个参数

#{别名}

知识点-resultType深入

1.目标

掌握Mybatis的参数深入(resultType)

2.路径

输出简单类型
输出pojo对象
输出pojo列表
resultMap结果类型

3.讲解

3.1输出简单类型

直接写对应的Java类型. eg: 返回int

UserDao02.java

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

/*
    演练resultType
 */
public interface UserDao02 {

    /**
     * 返回简单的数据
     * @return
     */
    long findCount();
}

UserDao02.xml

<?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.itheima.dao.UserDao02">


    <!--返回简单的类型：
        1. 如果返回简单的类型，那么resultType只要写这个类型即可 ： 简写的别名即可-->
    <select id="findCount" resultType="long">
        select count(*) from t_user
    </select>
</mapper>

3.2 输出pojo对象

直接写当前pojo类的全限定名 eg: 返回User

UserDao02.java

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

/*
    演练resultType
 */
public interface UserDao02 {


    /**
     * 返回对象的数据
     * @param uid
     * @return
     */
    User findByUid(int uid);
}

UserDao02.xml

<?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.itheima.dao.UserDao02">

    <!--
        返回对象类型：
            1. 如果返回的是一个对象的类型，那么resultType就写这个对象的类型即可：
                可以写全路径名，也可以写别名!
    -->
    <select id="findByUid" parameterType="int" resultType="com.itheima.bean.User">
        select * from t_user where uid = #{uid}
    </select>
</mapper>

3.3 输出pojo列表

直接写当前pojo类的全限定名 eg: 返回 List list;

UserDao02.java

package com.itheima.dao;

import com.itheima.bean.User;

import java.util.List;

/*
    演练resultType
 */
public interface UserDao02 {


    /**
     * 返回集合数据
     * @return
     */
    List<User> findAll();
}

UserDao02.xml

<?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.itheima.dao.UserDao02">

  <!--  返回集合类型：
        1. 如果返回的是一个集合的类型，那么resultType写的是集合里面的元素类型
                可以写全路径名，也可以写别名!-->
    <select id="findAll" resultType="com.itheima.bean.User">
        select * from t_user
    </select>
</mapper>

3.4 resultMap结果类型

resultType可以指定pojo将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。

如果sql查询列名和javaBean的属性名不一致，那么数据就不能封装到对象的属性身上，要解决这个问题，有两种办法：

a. 把查询出来的列名，给它起别名，让这个别名和我们的JavaBean的属性名一样即可！

b. 使用resultMap来做列和属性的映射设置！

user03

package com.itheima.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User03 {
    private int uid;
    private String username1;
    private String sex2;
    private Date birthday3;
    private String address4;
}

方式一：给列名起别名

UserDao03.java

package com.itheima.dao;

import com.itheima.bean.User;
import com.itheima.bean.User03;

import java.util.List;

/*
    演练resultMap
 */
public interface UserDao03 {

    /**
     * 根据uid来查询用户
     * @param uid
     * @return
     */
    User03 findByUid(int uid);
}

UserDao03.xml

<?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.itheima.dao.UserDao03">


    <!--根据用户id来查询用户， 列的名字和对象中的属性名不一致，给列起别名 ,别名就以对象的属性名来取即可-->
    <select id="findByUid" parameterType="int" resultType="com.itheima.bean.User03">
        select uid , username  username1 , sex  sex2 , birthday  birthday3, address  address4 from t_user where uid= #{uid}
    </select>
</mapper>

方式二：使用resultMap

UserDao03.java

package com.itheima.dao;

import com.itheima.bean.User;
import com.itheima.bean.User03;

import java.util.List;

/*
    演练resultMap
 */
public interface UserDao03 {

   

    /**
     * 根据uid来查询用户
     * @param uid
     * @return
     */
    User03 findByUid2(int uid);
}

UserDao03.xml

<?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.itheima.dao.UserDao03">

    <!--
        定义映射关系： 表和对象的映射（列和属性的映射）
           resultMap : 用于定义映射关系
                id: 唯一标识值
                type : 要和哪个JavaBean映射

              id标签： 专门是给主键列做映射的
              result标签： 专门是给普通列做映射的
                    column :列名
                    property: 属性名
              如果列的名字和属性的名字已经是一样了，那么可以省略它的映射配置！
    -->
    <resultMap id="user03Map" type="com.itheima.bean.User03">
        <id column="uid" property="uid"/>
        <result column="username" property="username1"/>
        <result column="sex" property="sex2"/>
        <result column="birthday" property="birthday3"/>
        <result column="address" property="address4"/>
    </resultMap>

    <select id="findByUid2" parameterType="int" resultMap="user03Map">
        select * from t_user where uid = #{uid}
    </select>

</mapper>

4.小结

输出简单类型直接写 java类型名 eg: int
输出pojo对象直接写 pojo类型名 eg: User
输出pojo列表类型写 列表里面的泛型的类型 eg: List 写User
ResultMap
- 解决查询出来的结果的列名和javaBean属性不一致的请求

第四章-日志【了解】

知识点-日志的使用

1.目标

我们在使用MyBatis的时候, 其实MyBatis框架会打印一些必要的日志信息, 在开发阶段这些日志信息对我们分析问题,理解代码的执行是特别有帮助的; 包括项目上线之后,我们也可以收集项目的错误日志到文件里面去; 所以我们采用专门的日志系统来处理.

2.步骤

导入坐标
拷贝日志配置文件到项目

3.讲解

导入坐标

<!-- log start -->
<!-- 日志的具体实现  -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.12</version>
</dependency>

<!--  接口  -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.6.6</version>
</dependency>

<!-- 中间的转化jar包 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.6.6</version>
</dependency>

拷贝log4j.properties到resources目录

在resources文件夹下，创建一个文件 log4j.properties **这个名字是固定的！ **

##设置日志记录到控制台的方式
log4j.appender.std=org.apache.log4j.ConsoleAppender
log4j.appender.std.Target=System.err
log4j.appender.std.layout=org.apache.log4j.PatternLayout
log4j.appender.std.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n

##设置日志记录到文件的方式
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=mylog.txt
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

##日志输出的级别，以及配置记录方案
log4j.rootLogger= debug,std,file

级别:error > warn > info>debug>trace

4.小结

日志系统就是一个工具
- 拷贝坐标
- 拷贝log4j.properties到项目
配置文件一般的配置
- 开发阶段: log4j.rootLogger= debug,std,file
- 上线之后: log4j.rootLogger= error ,file

总结

mybatis是什么？

其实是一个作用于dao层的框架，提高我们的开发效率。

入门：

	1. 导入依赖
	2. 创建JavaBean
	3. 创建Dao
	4. 创建Dao的映射文件
	5. 创建核心配置文件：SqlMapConfig.xml
	6. 单元测试

细节（套路）：

	1. 映射文件的路径必须要和Dao文件的路径一致
	2. 映射文件的路径必须使用 / 来创建
	3. 映射文件的名字，要和Dao文件名字一致
	4. 映射文件的命名空间，必须要写Dao的全路径地址
	5. 映射文件中的语句块的id值必须是Dao的方法名
	6. parameterType写参数的类型
	7. resultType 写返回值类型
	8. 映射文件需要在核心配置文件里面登记

crud:
新增：

新增的时候，获取id的返回值：
	1. 使用<selectKey>来获取id值
		<selectKey keyProperty="uid" resultType="int" order="AFTER">
			select last_insert_id()
		</selectKey>
	2. 使用属性的写法来获取id值
		<insert id="" keyProperty="uid" useGeneratorKey="true">

删除:   <delete id="">
修改：  <update id= "">
查询：  <select id="">

#{} 和 ${}
	1. #{}可以防止SQL注入，${}不可以
	2. #{}的sql语句会进行预编译，使用？来占位
	3. 取简单的数据 #{任意值} , ${value}来取值

模糊查询：
	只需要记住 concat("%", #{参数} , "%")

parameterType:

	1. 简单参数
	2. 对象参数
	3. 对象包含对象
	4. 多个参数
		取别名 @param("别名")  ===> 使用#{别名取值}

resultType:

1. 简单数据
2. 对象数据
3. 集合数据
4. resultMap

posted on 2022-04-23 16:54 ofanimon 阅读(41) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

学习目标

第一章-框架概述

知识点-框架概述

1.目标

2.路径

3.讲解

3.1 什么是框架

3.2 框架要解决的问题

4.小结

知识点-MyBatis框架概述

1.目标

2.路径

3.讲解

3.1jdbc 程序回顾

3.1.1程序回顾

3.1.2 jdbc 问题分析

3.2MyBatis框架概述

4.小结

第二章-Mybatis入门

案例-Mybatis快速入门

1.需求

2.分析

3.实现

3.1准备工作

3.2.MyBatis快速入门

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

3.2.2创建User实体类

3.2.3创建 UserDao 接口

3.2.4创建 UserDao.xml 映射文件

3.2.5创建 SqlMapConfig.xml 配置文件

3.2.6 测试

4.小结

4.1步骤

4.2注意事项

知识点-Mapper动态代理方式规范

1.目标

2.路径

3.讲解

3.1入门案例回顾

3.1.1 创建接口

3.1.2 创建映射文件

3.2.3 测试

3.2规范

4.小结

第三章-MyBatis进阶【重点】

案例-使用Mybatis完成CRUD【重点】

1.需求

2.分析

3.实现

3.1新增用户

3.1.1实现步骤

3.1.2新增用户 id 的返回值

3.1.3新增用户 id 的返回值(字符串类型)

3.2修改用户

3.3删除用户

3.4模糊查询

3.4.1 方式一

3.4.2 方式二

3.4.3 #{}与${}的区别【面试】

{}

{} 背后会自动的拼接上 ' '

3.5.SqlSessionFactory工具类的抽取

4.小结

4.1增删改查

4.2#和$区别

知识点-parameterType深入

1.目标

2.路径

3.讲解

3.1传递简单类型

3.2传递 pojo 对象

3.3传递 pojo 包装对象类型

3.4 传递多个参数

4.小结

知识点-resultType深入

1.目标

2.路径

3.讲解

3.1输出简单类型

3.2 输出pojo对象

方式一：给列名起别名

方式二：使用resultMap