SolitudeAlma
SolitudeAlma

Java学习笔记之Mybatis

1. Mybatis

1.1 MyBatis介绍

Java学习笔记之Mybatis_第1张图片

  • MyBatis 是一款优秀的持久层框架
  • MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
  • MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 实体类 【Plain Old Java Objects,普通的老式Java对象】映射成数据库中的记录。
  • MyBatis 本是apache的一个开源项目ibatis, 2010年这个项目由apache 迁移到了google code，并且改名为MyBatis 。
  • 2013年11月迁移到Github .
  • Mybatis官方文档 : http://www.mybatis.org/mybatis-3/zh/index.html
  • GitHub : https://github.com/mybatis/mybatis-3

如何获取Mybatis

  • maven仓库

<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatisartifactId>
    <version>3.5.7version>
dependency>
  • Github：https://github.com/mybatis/mybatis-3/releases
  • 中文文档：http://www.mybatis.org/mybatis-3/zh/index.html

1.2 持久化

持久化是将程序数据在持久状态和瞬时状态间转换的机制。

  • 即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。
  • JDBC就是一种持久化机制。文件IO也是一种持久化机制。
  • 在生活中 : 将鲜肉冷藏，吃的时候再解冻的方法也是。将水果做成罐头的方法也是。

为什么需要持久化服务呢？那是由于内存本身的缺陷引起的

  • 内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的是，人们还无法保证内存永不掉电。
  • 内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。所以即使对象不需要永久保存，也会因为内存的容量限制不能一直呆在内存中，需要持久化来缓存到外存。

1.3 持久层

什么是持久层？

  • 完成持久化工作的代码块。 ----> dao层 【DAO (Data Access Object) 数据访问对象】
  • 大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，而持久化的实现过程则大多通过各种关系数据库来完成。
  • 不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专注于数据持久化逻辑的实现.
  • 与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。【说白了就是用来操作数据库存在的！】

1.4 为什么需要Mybatis

  • Mybatis就是帮助程序猿将数据存入数据库中 , 和从数据库中取数据 .
  • 传统的jdbc操作 , 有很多重复代码块 .比如 : 数据取出时的封装 , 数据库的建立连接等等… , 通过框架可以减少重复代码,提高开发效率 .
  • MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射
  • 所有的事情，不用Mybatis依旧可以做到，只是用了它，所有实现会更加简单！技术没有高低之分，只有使用这个技术的人有高低之别
  • MyBatis的优点
    • 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件就可以了，易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
    • 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
    • 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
    • 提供xml标签，支持编写动态sql。
    • …
  • 最重要的一点，使用的人多！公司需要！

2. 第一个Mybatis程序

思路流程：搭建环境–>导入Mybatis—>编写代码—>测试

2.1 搭建环境

搭建数据库

CREATE DATABASE `mybatis` CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;

USE `mybatis`;

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
`id` INT(20) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`pwd` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4;

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES (1,'SolitudeAlma','123456'),(2,'张三','abcdef'),(3,'李四','987654');

新建项目

  1. 新建一个普通的maven项目（无模板）
  2. 删除src目录，让工程变为一个父工程
  3. 导入依赖

<dependencies>
  
  
  <dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatisartifactId>
    <version>3.5.7version>
  dependency>
  
  
  <dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>8.0.24version>
  dependency>
  
  <dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.13.2version>
    <scope>testscope>
  dependency>
dependencies>

2.2 创建一个模块

这样子项目就不需要重复添加依赖

  1. 编写MyBatis核心配置文件

查看帮助文档


DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8&"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            dataSource>
        environment>
    environments>
configuration>
  1. 编写MyBatis工具类
package com.SolitudeAlma.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 javax.annotation.Resource;
import java.io.IOException;
import java.io.InputStream;

/**
 * sqlSessionFactory ---> sqlSession
 * @author SolitudeAlma
 * @date 2021/8/13
 */
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。SqlSession 提供了在数据库执行 SQL
     * 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的SQL语句。 sqlSession相当于jdbc中的
     * prepareStatement对象
     * @return SqlSessionFactory
     */
    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession();
    }
}

2.3 编写代码

  • 实体类
package com.SolitudeAlma.pojo;

/**
 * @author SolitudeAlma
 * @date 2021/8/14
 * @description 实体类
 */
public class User {
    private int id;
    private String name;
    private String pwd;

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}
  • Dao接口
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public interface UserDao {
    /**
     * 查询所有用户信息
     * @return User
     */
    List<User> getUserList();
}
  • 接口实现类

用xml代替UserDaoImpl实现类


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.SolitudeAlma.dao.UserDao">
    
    <select id="getUserList" resultType="com.SolitudeAlma.pojo.User">
        select * from user;
    select>
mapper>

2.4 测试

注意点：org.apache.ibatis.binding.BindingException: Type interface com.SolitudeAlma.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么？
核心配置文件中注册mapper​


<mappers>
    <mapper resource="com/SolitudeAlma/dao/UserMapper.xml"/>
mappers>

Could not find resource com/SolitudeAlma/dao/UserMapper.xml
JavaWeb中提到过，项目构建时，java目录下的非java文件不会被生成到target目录，所以我们需要在父项目的pom.xml中build标签下加入rusource标签，把我们的xml等配置文件也生成到target


<build>
  <resources>
    <resource>
      <directory>src/main/resourcesdirectory>
      <includes>
        <include>**/*.propertiesinclude>
        <include>**/*.xmlinclude>
      includes>
      <filtering>falsefiltering>
    resource>
    <resource>
      <directory>src/main/javadirectory>
      <includes>
        <include>**/*.propertiesinclude>
        <include>**/*.xmlinclude>
      includes>
      <filtering>falsefiltering>
    resource>
  resources>
build>
  • junit测试
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * junit测试类
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public class UserDaoTest {
    @Test
    public void test() {

        //获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一:getMapper
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();

        //方式二:不推荐使用
        //List userList = sqlSession.selectList("com.SolitudeAlma.dao.UserDao.getUserList");
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭SqlSession
        sqlSession.close();
    }
}

可能遇到的问题：

  1. 配置文件没有注册
  2. 绑定接口错误
  3. 方法名不对
  4. 返回类型不对
  5. maven导出资源

namespace

  1. 将上面案例中的UserDao接口改名为UserMapper；
  2. 将UserMapper.xml中的namespace改为为UserDao的路径 .
  3. 再次测试

结论：
配置文件中namespace中的名称为对应Mapper接口或者Dao接口的完整包名,必须一致！

3. CRUD操作

3.1 SELECT

  • select标签是mybatis中最常用的标签之一
  • select语句有很多属性可以详细配置每一条SQL语句
    • SQL语句返回值类型。【完整的类名或者别名】
    • 传入SQL语句的参数类型 。【万能的Map，可以多尝试使用】
    • 命名空间中唯一的标识符
    • 接口中的方法名与映射文件中的SQL语句ID 一一对应
    • id：namespace对应接口的方法名
    • parameterType：参数类型
    • resultType：SQL语句返回结果的类型

需求：根据id查询用户

  1. 在UserDao中添加对应方法
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public interface UserDao {
    /**
     * 查询所有用户信息
     * @return List 用户信息集合
     */
    List<User> getUserList();

    /**
     * 根据id查询用户信息
     * @param id 用户唯一标识
     * @return User 单个用户的信息
     */
    User getUserById(int id);
}
  1. 在UserMapper.xml中添加Select语句
<select id="getUserById" resultType="com.SolitudeAlma.pojo.User" parameterType="int">
  select * from user where id = #{id};
select>
  1. 测试类中测试
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * junit测试类
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public class UserDaoTest {
    @Test
    public void test() {

        //获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一:getMapper
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();

        //方式二:不推荐使用
        //List userList = sqlSession.selectList("com.SolitudeAlma.dao.UserDao.getUserList");
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭SqlSession
        sqlSession.close();
    }

    @Test
    public  void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        User userInfo = mapper.getUserById(1);
        System.out.println(userInfo);
        sqlSession.close();
    }
}

3.2 INSERT

一般使用insert标签进行插入操作，它的配置和select标签差不多！
需求：给数据库增加一个用户

  1. 在UserDao接口中添加对应的方法
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public interface UserDao {
    /**
     * 查询所有用户信息
     * @return List 用户信息集合
     */
    List<User> getUserList();

    /**
     * 根据id查询用户信息
     * @param id 用户唯一标识
     * @return User 单个用户的信息
     */
    User getUserById(int id);

    /**
     * 插入一个用户信息
     * @param user 用户信息类
     * @return SQL查询结果，成功影响几条数据
     */
    int insertOne(User user);   
}
  1. 在UserMapper.xml中添加insert语句

<insert id="insertOne" parameterType="com.SolitudeAlma.pojo.User" >
  insert into user (id, name, pwd) values (#{id}, #{name}, #{pwd});
insert>

3.测试

package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * junit测试类
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public class UserDaoTest {
    @Test
    public void test() {

        //获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一:getMapper
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();

        //方式二:不推荐使用
        //List userList = sqlSession.selectList("com.SolitudeAlma.dao.UserDao.getUserList");
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭SqlSession
        sqlSession.close();
    }

    @Test
    public  void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        User userInfo = mapper.getUserById(1);
        System.out.println(userInfo);
        sqlSession.close();
    }

    @Test
    public  void insertOne() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        int result = mapper.insertOne(new User(4, "小明", "1212"));
        System.out.println(result);
        //如果不加上这句提交事务，我们会发现虽然输出了1，但是还是没有插入成功，那是因为我们的工
        //具类中的openSession方法没有传参数，默认手动提交事务，而mysql是自动提交事务的，所以我
       	//只要设置参数为true就行了，false和不传参都是手动提交。这样相对比较安全
        sqlSession.commit();
        sqlSession.close();
    }
}

注意点：增、删、改操作需要提交事务！

3.3 UPDATE

一般使用update标签进行更新操作，它的配置和select标签差不多！
需求：修改用户的信息

  1. 同理，编写接口方法
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public interface UserDao {
    /**
     * 查询所有用户信息
     * @return List 用户信息集合
     */
    List<User> getUserList();

    /**
     * 根据id查询用户信息
     * @param id 用户唯一标识
     * @return User 单个用户的信息
     */
    User getUserById(int id);

    /**
     * 插入一个用户信息
     * @param user 用户信息类
     * @return SQL查询结果，成功影响几条数据
     */
    int insertOne(User user);

    /**
     * 修改一个用户的信息
     * @param user 用户信息类
     * @return SQL查询结果，成功影响几条数据
     */
    int updateOne(User user);
}
  1. 编写对应的配置文件SQL
<update id="updateOne" parameterType="com.SolitudeAlma.pojo.User">
  update user set name = #{name}, pwd = #{pwd} where id = #{id};
update>
  1. 测试
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * junit测试类
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public class UserDaoTest {
    @Test
    public void test() {

        //获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一:getMapper
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();

        //方式二:不推荐使用
        //List userList = sqlSession.selectList("com.SolitudeAlma.dao.UserDao.getUserList");
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭SqlSession
        sqlSession.close();
    }

    @Test
    public  void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        User userInfo = mapper.getUserById(1);
        System.out.println(userInfo);
        sqlSession.close();
    }

    @Test
    public  void insertOne() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        int result = mapper.insertOne(new User(4, "小明", "1212"));
        System.out.println(result);
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public  void updateOne() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        int result = mapper.updateOne(new User(4, "废物", "12121"));
        System.out.println(result);
        sqlSession.commit();
        sqlSession.close();
    }
}

3.4 DELETE

一般使用delete标签进行删除操作，它的配置和select标签差不多！
需求：根据id删除一个用户

  1. 同理，编写接口方法
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public interface UserDao {
    /**
     * 查询所有用户信息
     * @return List 用户信息集合
     */
    List<User> getUserList();

    /**
     * 根据id查询用户信息
     * @param id 用户唯一标识
     * @return User 单个用户的信息
     */
    User getUserById(int id);

    /**
     * 插入一个用户信息
     * @param user 用户信息类
     * @return SQL查询结果，成功影响几条数据
     */
    int insertOne(User user);

    /**
     * 修改一个用户的信息
     * @param user 用户信息类
     * @return SQL查询结果，成功影响几条数据
     */
    int updateOne(User user);

    /**
     * 删除一个用户的信息
     * @param id 用户唯一标识
     * @return SQL查询结果，成功影响几条数据
     */
    int deleteById(int id);
}
  1. 编写对应的配置文件SQL
<delete id="deleteById" parameterType="int">
  delete from user where id = #{id};
delete>
  1. 测试
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * junit测试类
 * @author SolitudeAlma
 * @date 2021/8/14
 */
public class UserDaoTest {
    @Test
    public void test() {

        //获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一:getMapper
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();

        //方式二:不推荐使用
        //List userList = sqlSession.selectList("com.SolitudeAlma.dao.UserDao.getUserList");
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭SqlSession
        sqlSession.close();
    }

    @Test
    public  void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        User userInfo = mapper.getUserById(1);
        System.out.println(userInfo);
        sqlSession.close();
    }

    @Test
    public  void insertOne() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        int result = mapper.insertOne(new User(4, "小明", "1212"));
        System.out.println(result);
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public  void updateOne() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        int result = mapper.updateOne(new User(4, "废物", "12121"));
        System.out.println(result);
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public  void deleteOne() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        int result = mapper.deleteById(4);
        System.out.println(result);
        sqlSession.commit();
        sqlSession.close();
    }
}

小结：

  • 所有的增删改操作都需要提交事务！（默认手动提交）
  • 接口所有的普通参数，尽量都写上@Param参数，尤其是多个参数时，必须写上！
  • 有时候根据业务的需求，可以考虑使用map传递参数！
  • 为了规范操作，在SQL的配置文件中，我们尽量将Parameter参数和resultType都写上！

3.5 LIKE

模糊查询like语句该怎么写?
第1种：在Java代码中添加sql通配符。

string wildcardname = "%smi%";
List<name> names = mapper.selectlike(wildcardname);

<select id="selectlike">
select * from foo where bar like #{value}
</select>

第2种：在sql语句中拼接通配符，会引起sql注入

string wildcardname = "smi";
List<name> names = mapper.selectlike(wildcardname);

<select id="selectlike">
    select * from foo where bar like "%"${value}"%"
</select>

在mybatis配置文件中：

  1. ${}:表示拼接sql串，将接收到参数的内容不加任何修饰拼接在sql中，可能引发sql注入。
  2. #{ }是预编译处理，MyBatis在处理#{ }时，它会将sql中的#{ }替换为？，然后调用PreparedStatement的set方法来赋值，传入字符串后，会在值两边加上单引号，使用占位符的方式提高效率，可以防止sql注入。

不推荐使用${}，能用#{}就用#{}，也可以使用MySQL函数concat连接字符串。
固定的值可以用${}，因为本来就是拼接字符串，但动态的不能

https://www.cnblogs.com/xiao-lin-unit/p/13644004.html
https://blog.csdn.net/Mr_Qiao93/article/details/109168291
https://blog.csdn.net/weixin_42452395/article/details/113869915

3.6 其他

sql语句需要的参数很多时，可以考虑使用map而不是用类。
map可以随意定义key的名字，灵活性高，而类需要定义属性，set、get方法等，修改名字得修改属性名，麻烦

大致用法：

/**
* 插入过个用户信息
* @param map 用户信息集合
* @return SQL查询结果，成功影响几条数据
*/
int insertMany(Map<String, Object> map);


<insert id="insertMany" parameterType="map" >
  insert into user (id, name, pwd) values (#{userId}, #{userName}, #{password});
insert>

@Test
public  void insertMany() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    Map <String, Object> map = new HashMap<>();
    map.put("userId", 5);
    map.put("userName", "小红");
    map.put("password", "23333");
    int result = mapper.insertMany(map);
    System.out.println(result);
    sqlSession.commit();
    sqlSession.close();
}

4. 配置解析

4.1 核心配置文件

  • mybatis-config.xml 系统核心配置文件
  • MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
  • 能配置的内容如下：
configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）
<!-- 注意元素节点的顺序！顺序不对会报错 -->

可以阅读 mybatis-config.xml 上面的dtd的头文件

4.2 environment

<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC">
      <property name="..." value="..."/>
    transactionManager>
    <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>
  • 配置MyBatis的多套运行环境，将SQL映射到多个不同的数据库上，必须指定其中一个为默认运行环境（通过default指定）
  • 子元素节点：environment
    • dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。
    • 数据源是必须配置的。
    • 有三种内建的数据源类型 type="[UNPOOLED|POOLED|JNDI]"​
    • UNPOOLED：这种数据源的实现只是每次被请求时打开和关闭连接。
    • POOLED：这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来 , 这是一种使得并发 Web 应用快速响应请求的流行处理方式。
    • JNDI：这个数据源的实现是为了能在如 Spring 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。
    • 数据源也有很多第三方的实现，比如dbcp，c3p0，druid等等…
    • 详情：查看官方文档
    • 这两种事务管理器类型都不需要设置任何属性。
    • 具体的一套环境，通过设置id进行区别，id保证唯一！
    • 子元素节点：transactionManager - [ 事务管理器 ]

<transactionManager type="[ JDBC | MANAGED ]"/>
  • 子元素节点：数据源（dataSource）

4.3 properties

数据库这些属性都是可外部配置且可动态替换的，既可以在典型的 Java 属性文件中配置，亦可通过 properties 元素的子元素来传递。具体看官方文档

我们来优化配置文件

第一步 ; 在资源目录下新建一个db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
user=root
password=xxx

第二步 : 将文件导入properties 配置文件


DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    
    
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="xxx"/>
    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>
    
    <mappers>
        <mapper resource="com/SolitudeAlma/dao/UserMapper.xml"/>
    mappers>
configuration>

注意：严格按照标签顺序来写
更多操作，可以查看官方文档

  • 配置文件优先级问题（相同属性优先使用外部配置）
  • 新特性：使用占位符

4.4 typeAliases

类型别名是为 Java 类型设置一个短的名字。它只和 XML 配置有关，存在的意义仅在于用来减少类完全限定名的冗余。


<typeAliases>
  <typeAlias type="com.SolitudeAlma.pojo.User" alias="User"/>
typeAliases>

当这样配置时，User可以用在任何使用com.SolitudeAlma.pojo.User的地方。

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如:

<typeAliases>
  
  <package name="com.SolitudeAlma.pojo"/>
typeAliases>

每一个在com.SolitudeAlma.pojo包中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。
大小写都可以识别，但是用小写的话就知道你是用了扫描包这个方法
若有注解，则别名为其注解值。见下面的例子：

@Alias("user")
public class User {
  ...
}

实体类比较少的时候用第一钟方法，比较多的时候直接扫描包
第一种方法可以自定义别名，第二种不行，但可以用注解实现自定义​

去官网查看一下Mybatis默认的一些类型别名（基本数据类型和引用类型等等）

4.5 setting

  • 设置（settings）相关 => 查看帮助文档（需要记住下面三个）
    • 懒加载
    • 日志实现
    • 缓存开启关闭
  • 一个配置完整的 settings 元素的示例如下：
<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
settings>

4.6 mappers

mappers

  • 映射器 : 定义映射SQL语句文件
  • 既然 MyBatis 的行为其他元素已经配置完了，我们现在就要定义 SQL 映射语句了。但是首先我们需要告诉 MyBatis 到哪里去找到这些语句。Java 在自动查找这方面没有提供一个很好的方法，所以最佳的方式是告诉 MyBatis 到哪里去找映射文件。你可以使用相对于类路径的资源引用， 或完全限定资源定位符（包括 file:/// 的 URL），或类名和包名等。映射器是MyBatis中最核心的组件之一，在MyBatis 3之前，只支持xml映射器，即：所有的SQL语句都必须在xml文件中配置。而从MyBatis 3开始，还支持接口映射器，这种映射器方式允许以Java代码的方式注解定义SQL语句，非常简洁。

引入资源方式


<mappers>
 <mapper resource="com/SolitudeAlma/dao/UserMapper.xml"/>
mappers>


<mappers>
 <mapper url="file:///var/mappers/AuthorMapper.xml"/>
mappers>


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


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

Mapper配置文件


DOCTYPE mapper
       PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.mapper.UserMapper">
   
mapper>
  • namespace中文意思：命名空间，作用如下：
    • namespace的命名必须跟某个接口同名
    • 接口中的方法与映射文件中sql语句id应该一一对应
    1. namespace和子元素的id联合保证唯一 , 区别不同的mapper
    2. 绑定DAO接口
    3. namespace命名规则 : 包名+类名

MyBatis 的真正强大在于它的映射语句，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 为聚焦于 SQL 而构建，以尽可能地为你减少麻烦。

4.7 其他配置

typeHandlers类型处理器

  • 无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。
  • 你可以重写类型处理器或创建你自己的类型处理器来处理不支持的或非标准的类型。【了解即可】

objectFactory对象工厂

  • MyBatis 每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。
  • 默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过有参构造方法来实例化。
  • 如果想覆盖对象工厂的默认行为，则可以通过创建自己的对象工厂来实现。【了解即可】

plugins插件

  • mybatis-generator-core
  • mybatis-plus
  • 通用mapper

4.8 生命周期和作用域

作用域（Scope）和生命周期
理解我们目前已经讨论过的不同作用域和生命周期类是至关重要的，因为错误的使用会导致非常严重的并发问题。
我们可以先画一个流程图，分析一下Mybatis的执行过程！
Java学习笔记之Mybatis_第2张图片

作用域理解

  • SqlSessionFactoryBuilder 的作用在于创建 SqlSessionFactory，创建成功后，SqlSessionFactoryBuilder 就失去了作用，所以它只能存在于创建 SqlSessionFactory 的方法中，而不要让其长期存在。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。
  • SqlSessionFactory 可以被认为是一个数据库连接池，它的作用是创建 SqlSession 接口对象。因为 MyBatis 的本质就是 Java 对数据库的操作，所以 SqlSessionFactory 的生命周期存在于整个 MyBatis 的应用之中，所以一旦创建了 SqlSessionFactory，就要长期保存它，直至不再使用 MyBatis 应用，所以可以认为 SqlSessionFactory 的生命周期就等同于 MyBatis 的应用周期。
  • 由于 SqlSessionFactory 是一个对数据库的连接池，所以它占据着数据库的连接资源。如果创建多个 SqlSessionFactory，那么就存在多个数据库连接池，这样不利于对数据库资源的控制，也会导致数据库连接资源被消耗光，出现系统宕机等情况，所以尽量避免发生这样的情况。
  • 因此在一般的应用中我们往往希望 SqlSessionFactory 作为一个单例，让它在应用中被共享。所以说 SqlSessionFactory 的最佳作用域是应用作用域。
  • 如果说 SqlSessionFactory 相当于数据库连接池，那么 SqlSession 就相当于一个数据库连接（Connection 对象），你可以在一个事务里面执行多条 SQL，然后通过它的 commit、rollback 等方法，提交或者回滚事务。所以它应该存活在一个业务请求中，处理完整个请求后，应该关闭这条连接，让它归还给 SqlSessionFactory，否则数据库资源就很快被耗费精光，系统就会瘫痪，所以用 try…catch…finally… 语句来保证其正确关闭。
  • 所以 SqlSession 的最佳的作用域是请求或方法作用域。

Java学习笔记之Mybatis_第3张图片

5. ResultMap

5.1 查询为null

要解决的问题：属性名和字段名不一致
环境：新建一个项目，将之前的项目拷贝过来
1、查看之前的数据库的字段名
Java学习笔记之Mybatis_第4张图片

2、Java中的实体类设计

package com.SolitudeAlma.pojo;

import org.apache.ibatis.type.Alias;

/**
 * @author SolitudeAlma
 * @date 2021/8/15
 * @description 实体类
 */
@Alias("user")
public class User {
    private int id;
    private String name;
    private String password;

    public User() {
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

3、接口

package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/15
 */
public interface UserDao {

    /**
     * 根据id查询用户信息
     * @param id 用户唯一标识
     * @return User 单个用户的信息
     */
    User getUserById(int id);
}

4、mapper映射文件


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.SolitudeAlma.dao.UserDao">
    <select id="getUserById" resultType="user" parameterType="int">
        select * from user where id = #{id};
    select>

mapper>

5、测试

package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * junit测试类
 * @author SolitudeAlma
 * @date 2021/8/15
 */
public class UserDaoTest {

    @Test
    public void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        User userInfo = mapper.getUserById(1);
        System.out.println(userInfo);
        sqlSession.close();
    }
}

结果:

  • User{id=1, name=‘SolitudeAlma’, password=‘null’}
  • 查询出来发现 password 为空 . 说明出现了问题！

分析：

  • select * from user where id = #{id} 可以看做select id,name,pwd from user where id = #{id}
  • mybatis会根据这些查询的列名(会将列名转化为小写,数据库不区分大小写) , 去对应的实体类中查找相应列名的set方法设值 , 由于找不到setPwd() , 所以password返回null ; 【自动映射】

5.1.1 解决方案

方案一：为列名指定别名 , 别名和java实体类的属性名一致。

<select id="selectUserById" resultType="User">
  select id , name , pwd as password from user where id = #{id}
select>

方案二：使用结果集映射->ResultMap 【推荐】


<resultMap id="UserMap" type="User">
   
   <id column="id" property="id"/>
   
   <result column="name" property="name"/>
   <result column="pwd" property="password"/>
resultMap>

<select id="selectUserById" resultMap="UserMap">
  select id , name , pwd from user where id = #{id}
select>

5.2 resultMap

自动映射

  • resultMap元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来。
  • 实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份resultMap能够代替实现同等功能的长达数千行的代码。
  • ResultMap 的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。

你已经见过简单映射语句的示例了，但并没有显式指定resultMap。比如：

<select id="selectUserById" resultType="map">
select id , name , pwd
  from user
  where id = #{id}
select>

上述语句只是简单地将所有的列映射到HashMap的键上，这由resultType属性指定。虽然在大部分情况下都够用，但是 HashMap 不是一个很好的模型。你的程序更可能会使用 JavaBean 或 POJO（Plain Old Java Objects，普通老式 Java 对象）作为模型。
ResultMap最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们。

5.2.1 手动映射

1、返回值类型为resultMap

<select id="selectUserById" resultMap="UserMap">
  select id , name , pwd from user where id = #{id}
select>

2、编写resultMap，实现手动映射！

<resultMap id="UserMap" type="User">
   
   <id column="id" property="id"/>
   
   <result column="name" property="name"/>
   <result column="pwd" property="password"/>
resultMap>

如果世界总是这么简单就好了。但是肯定不是的，数据库中，存在一对多，多对一的情况，我们之后会使用到一些高级的结果集映射，association，collection这些。

6. 日志

6.1 日志工厂

思考：在测试SQL的时候，要是能够在控制台输出 SQL 的话，是不是就能够有更快的排错效率？
如果一个 数据库相关的操作出现了问题，我们可以根据输出的SQL语句快速排查问题。
对于以往的开发过程，我们会经常使用到debug模式来调节，跟踪我们的代码执行过程。但是现在使用Mybatis是基于接口，配置文件的源代码执行过程。因此，我们必须选择日志工具来作为我们开发，调节程序的工具。
Mybatis内置的日志工厂提供日志功能，具体的日志实现有以下几种工具：

  • SLF4J
  • LOG4J 【掌握】
  • LOG4J2
  • JDK_LOGGING
  • COMMONS_LOGGING
  • STDOUT_LOGGING
  • NO_LOGGING

具体选择哪个日志实现工具由MyBatis的内置日志工厂确定。它会使用最先找到的（按SLF4J、Apache Commons Logging、Log4j 2、Log4j、JDK logging列举的顺序查找）。如果一个都未找到，日志功能就会被禁用。​

标准日志实现
指定 MyBatis 应该使用哪个日志记录实现。如果此设置不存在，则会自动发现日志记录实现。

<settings>
  <setting name="logImpl" value="STDOUT_LOGGING"/>
settings>

测试，可以看到控制台有大量的输出！我们可以通过这些输出来判断程序到底哪里出了Bug

6.2 Log4j

简介：

  • Log4j是Apache的一个开源项目
  • 通过使用Log4j，我们可以控制日志信息输送的目的地：控制台，文本，GUI组件…
  • 我们也可以控制每一条日志的输出格式；
  • 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

使用步骤：

  1. 导入log4j的包

<dependency>
    <groupId>log4jgroupId>
    <artifactId>log4jartifactId>
    <version>1.2.17version>
dependency>
  1. 配置文件编写
#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/Mybatis-04.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
  1. setting设置日志实现
<settings>
   <setting name="logImpl" value="LOG4J"/>
settings>
  1. 在程序中使用Log4j进行输出！
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;

/**
 * junit测试类
 * @author SolitudeAlma
 * @date 2021/8/15
 */
public class UserDaoTest {

    //注意导包：org.apache.log4j.Logger
    static Logger logger = Logger.getLogger(UserDaoTest.class);

    @Test
    public void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        User userInfo = mapper.getUserById(1);
        System.out.println(userInfo);
        sqlSession.close();
    }

    @Test
    public void selectUser() {
        logger.info("info：进入selectUser方法");
        logger.debug("debug：进入selectUser方法");
        logger.error("error: 进入selectUser方法");
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        User userInfo = mapper.getUserById(1);
        System.out.println(userInfo);
        sqlSession.close();
    }
}
  1. 测试，看控制台输出！
  • 使用Log4j 输出日志
  • 可以看到还生成了一个日志的文件 【需要修改file的日志级别】

需要导包，参数为当前类的class对象

https://www.cnblogs.com/xiaobaizhiqian/p/7956690.html
https://blog.csdn.net/eagleuniversityeye/article/details/80582140
https://www.cnblogs.com/wangzhuxing/p/7753420.html

7. 分页

思考：为什么需要分页？
在学习mybatis等持久层框架的时候，会经常对数据进行增删改查操作，使用最多的是对数据库进行查询操作，如果查询大量数据的时候，我们往往使用分页进行查询，也就是每次处理小部分数据，这样对数据库压力就在可控范围内。

7.1 使用Limit实现分页

#语法
SELECT * FROM table LIMIT stratIndex，pageSize

SELECT * FROM table LIMIT 5,10; // 检索记录行 6-15  

#为了检索从某一个偏移量到记录集的结束所有的记录行，可以指定第二个参数为 -1：   
SELECT * FROM table LIMIT 95,-1; // 检索记录行 96-last.  

#如果只给定一个参数，它表示返回最大的记录行数目：   
SELECT * FROM table LIMIT 5; //检索前 5 个记录行  

#换句话说，LIMIT n 等价于 LIMIT 0,n。

步骤：

  1. 修改Mapper文件
<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
  select * from user limit #{currentPage},#{pageSize};
select>
  1. Mapper接口，参数为map
//选择全部用户实现分页
List<User> selectUser(Map<String,Integer> map);
  1. 在测试类中传入参数测试
  • 推断：起始位置 = （当前页面 - 1 ） * 页面大小
//分页查询 , 两个参数startIndex , pageSize
@Test
public void getUserByLimit() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    int currentPage = 1;
    int pageSize = 2;
    Map<String, Integer> map = new HashMap<>();
    map.put("currentPage", (currentPage - 1) * pageSize);//下标从0开始
    map.put("pageSize", pageSize);
    List<User> userList = mapper.getUserByLimit(map);
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

7.2 使用RowBounds分页

我们除了使用Limit在SQL层面实现分页，也可以使用RowBounds在Java代码层面实现分页，当然此种方式作为了解即可。我们来看下如何实现的！
步骤：

  1. mapper接口
/**
* 通过Java类实现分页
* @return List 用户信息集合
*/
List<User> getUserByRowBounds();
  1. mapper文件
<select id="getUserByRowBounds" resultType="user">
  select * from user
select>
  1. 测试类
    在这里，我们需要使用RowBounds类
@Test
public void getUserByRowBounds() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    int currentPage = 1;
    int pageSize = 2;
    RowBounds rowBounds = new RowBounds(currentPage - 1, pageSize);
    //通过Java层代码实现分页
    //通过session.**方法进行传递rowBounds，[此种方式现在已经不推荐使用了]
    List<User> userList = sqlSession.selectList("com.SolitudeAlma.dao.UserDao.getUserByRowBounds", null, rowBounds);
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

7.3 PageHelper

Java学习笔记之Mybatis_第5张图片

了解即可，可以自己尝试使用

官方文档：https://pagehelper.github.io/​

在MyBatisPlu中，我们也讲解到了分页实现，所以实现方式很多，看自己的理解合熟练程度进行掌握即可

8. 使用注解开发

8.1 面向接口编程

面向接口编程：

  • 大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程
  • 根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好
  • 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了；
  • 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

  • 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
  • 接口的本身反映了系统设计人员对系统的抽象理解。
  • 接口应有两类：
    • 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)；
    • 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；
  • 一个个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

  • 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法 .
  • 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现 .
  • 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题.更多的体现就是对系统整体的架构

8.2 利用注解开发

  • mybatis最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到MyBatis 3提供了新的基于注解的配置。不幸的是，Java 注解的的表达力和灵活性十分有限。最强大的 MyBatis 映射并不能用注解来构建
  • sql 类型主要分成 :
    • @select ()
    • @update ()
    • @Insert ()
    • @delete ()

**注意：**利用注解开发就不需要mapper.xml映射文件了 .

  1. 我们在我们的接口中添加注解
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;
import java.util.Map;

/**
 * @author SolitudeAlma
 * @date 2021/8/17
 */
public interface UserDao {

    /**
     * 获取所用用户信息
     * @return List 用户信息集合
     */
    @Select("select id, name, pwd as password from user")
    List<User> selectAll();
}
  1. 在mybatis的核心配置文件中注入

<mappers>
  <mapper class="com.SolitudeAlma.dao.UserDao"/>
mappers>
  1. 我们去进行测试
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.User;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * junit测试类
 * @author SolitudeAlma
 * @date 2021/8/16
 */
public class UserDaoTest {

    @Test
    public void selectAll() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //底层主要应用反射
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.selectAll();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
}

  1. 利用Debug查看本质
    Java学习笔记之Mybatis_第6张图片

  2. 本质上利用了jvm的动态代理机制
    本质：反射机制
    底层：动态代理
    Java学习笔记之Mybatis_第7张图片

  3. Mybatis详细的执行流程

Java学习笔记之Mybatis_第8张图片

8.3 CRUD

改造MybatisUtils工具类的getSession( ) 方法，重载实现。

/**
* 既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。SqlSession 提供了在数据库执行 SQL
* 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的SQL语句。 sqlSession相当于jdbc中的
* prepareStatement对象
* @return SqlSessionFactory
*/
public static SqlSession getSqlSession() {
    return sqlSessionFactory.openSession(true);
}

【注意】确保实体类和数据库字段对应
查询：

  1. 编写接口方法注解
/**
* 根据id查询用户信息
* @param id 用户唯一标识 @Param("xxx") 方法存在多个参数时前面必须加上这个注解，也起到起别名的作用
* @return User类 用户信息类
*/
@Select("select id, name, pwd as password from user where id=#{id}")
User selectById(@Param("id") int id);
  1. 测试
@Test
public void selectById() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    User user = mapper.selectById(1);
    System.out.println(user);
    sqlSession.close();
}

新增：

  1. 编写接口方法注解
/**
* 插入一条用户信息
* @param user 用户信息类
* @return SQL查询结果，影响了几行
*/
@Insert("insert into user(`id`, `name`, `pwd`) values(#{id}, #{name}, #{password})")
int insertOne(User user);
  1. 测试
@Test
public void insertOne() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    int user = mapper.insertOne(new User(7, "asd", "asdsa"));
    System.out.println(user);
    sqlSession.close();
}

修改：

  1. 编写接口方法注解
/**
* 修改一条用户信息
* @param user 用户信息类
* @return SQL查询结果，影响了几行
*/
@Update("update user set name = #{name}, pwd = #{password} where id = #{id}")
int updateOne(User user);
  1. 测试
@Test
public void updateOne() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    int user = mapper.updateOne(new User(7, "小王", "145236"));
    System.out.println(user);
    sqlSession.close();
}

删除：

  1. 编写接口方法注解
/**
* 删除一条用户信息
* @param id 用户唯一标识
* @return SQL查询结果，影响了几行
*/
@Delete("delete from user where id = #{uid}")
int deleteOne(@Param("uid") int id);
  1. 测试
@Test
public void deleteOne() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    int user = mapper.deleteOne(7);
    System.out.println(user);
    sqlSession.close();
}

【注意点：增删改一定记得对事务的处理】​

关于@param
@Param注解用于给方法参数起一个名字。以下是总结的使用原则：

  • 在方法只接受一个参数的情况下，可以不使用@Param。
  • 在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。
  • 如果参数是 JavaBean ， 则不能使用@Param。
  • 不使用@Param注解时，参数只能有一个，并且是Javabean。

https://www.cnblogs.com/zhuhui-site/p/10088369.html
https://blog.csdn.net/sinat_33010325/article/details/84261662

#{}与${}的区别

  • #{} 的作用主要是替换预编译语句(PrepareStatement)中的占位符? 【推荐使用】
INSERT INTO user (name) VALUES (#{name});
INSERT INTO user (name) VALUES (?);
  • ${} 的作用是直接进行字符串替换（不推荐使用，容易引起SQL注入）
INSERT INTO user (name) VALUES ('${name}');
INSERT INTO user (name) VALUES ('kuangshen');

使用注解和配置文件协同开发，才是MyBatis的最佳实践

9. Lombok

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.
Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.

  • java library
  • plugs
  • build tools
  • with one annotation your class

使用步骤：

  1. 在idea安装Lombok插件
  2. 在项目中导入Lombok依赖

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.20version>
    <scope>providedscope>
dependency>
  1. 注解说明
@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass

//点开左边的structure查看类结构
@Data：无参构造、get、set、toString()、hashcode()、equals()
@AllArgsConstructor
@NoArgsConstructor
@ToString
@EqualsAndHashCode
@Getter 可以放在固定的字段或者直接放在类上

10. 多对一处理

多对一的理解：

  • 多个学生对应一个老师
  • 如果对于学生这边，就是一个多对一的现象，即从学生这边关联一个老师！

Java学习笔记之Mybatis_第9张图片

10.1 数据库设计

Java学习笔记之Mybatis_第10张图片

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4;

INSERT INTO teacher(`id`, `name`) VALUES (1, 'SolitudeAlma'); 

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4;
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

10.2 搭建测试环境

  1. IDEA安装Lombok插件
  2. 引入Maven依赖

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.20version>
    <scope>providedscope>
dependency>
  1. 在代码中增加注解
package com.SolitudeAlma.pojo;

import lombok.Data;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
@Data
public class Teacher {
    private int id;
    private String name;
}


package com.SolitudeAlma.pojo;

import lombok.Data;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
@Data
public class Student {
    private int id;
    private String name;
    private Teacher teacher;
}
  1. 编写实体类对应的Mapper接口 【两个】
  • 无论有没有需求，都应该写上，以备后来之需！
package com.SolitudeAlma.dao;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
public interface StudentMapper {
}

package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
public interface TeacherMapper {

    /**
     * 查询单个老师的信息
     * @param id 老师的唯一标识
     * @return Teacher 老师信息类
     */
    @Select("select * from teacher where id = #{tid}")
    Teacher getTeacher(@Param("tid") int id);
}
  1. 编写Mapper接口对应的 mapper.xml配置文件 【两个】
  • 无论有没有需求，都应该写上，以备后来之需！

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.SolitudeAlma.dao.StudentMapper">

mapper>


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.SolitudeAlma.dao.TeacherMapper">

mapper>
  1. 测试
import com.SolitudeAlma.dao.TeacherMapper;
import com.SolitudeAlma.pojo.Teacher;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
public class MyTest {
    @Test
    public void selectOne() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher.getId() + " " + teacher.getName());
        sqlSession.close();
    }
}

10.3 按查询嵌套处理

  1. 给StudentMapper接口增加方法
/**
* 查询所有学生的信息，以及对应老师的信息
* @return List 学生信息集合
*/
List<Student> getStudent();
  1. 编写对应的Mapper文件

DOCTYPE mapper
       PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.mapper.StudentMapper">
   
   <select id="getStudents" resultMap="studentInfo">
    select * from student
   select>
   <resultMap id="studentInfo" type="Student">
       <id property="id" column="id"/>
       <id property="name" column="name"/>
       
       <association property="teacher"  column="tid" javaType="Teacher" select="getTeacher"/>
   resultMap>
   
   <select id="getTeacher" resultType="Teacher">
      select id, name from teacher where id = #{id}
   select>
mapper>
  1. 编写完毕去Mybatis配置文件中，注册Mapper！
  2. 注意点说明：
<resultMap id="studentInfo" type="Student">
   
   <association property="teacher"  column="{id=tid}" javaType="Teacher" select="getTeacher"/>
resultMap>

<select id="getTeacher" resultType="teacher">
  select * from teacher where id = #{id}
select>
  1. 测试
import com.SolitudeAlma.dao.StudentMapper;
import com.SolitudeAlma.dao.TeacherMapper;
import com.SolitudeAlma.pojo.Student;
import com.SolitudeAlma.pojo.Teacher;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
public class MyTest {
    @Test
    public void selectOne() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher.getId() + " " + teacher.getName());
        sqlSession.close();
    }

    @Test
    public void selectAll() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> students = mapper.getStudent();
        for (Student student : students) {
            System.out.println("学生：" + student.getName() + "\t" + "老师：" + student.getTeacher().getName());
        }
        sqlSession.close();
    }
}

10.4 按结果嵌套处理

除了上面这种方式，还有其他思路吗？
我们还可以按照结果进行嵌套处理；

  1. 接口方法编写
/**
* 查询所有学生的信息，以及对应老师的信息
* @return List 学生信息集合
*/
List<Student> getStudent01();
  1. 编写对应的mapper文件

<select id="getStudent01" resultMap="studentInfo01">
  select s.id, s.name, t.name from student as s, teacher as t where s.tid = t.id
select>
<resultMap id="studentInfo01" type="Student">
  <id property="id" column="id"/>
  <result property="name" column="name"/>
  
  <association property="teacher" javaType="Teacher">
    <result property="name" column="name"/>
  association>
resultMap>
  1. 去mybatis-config文件中注入【此处应该处理过了】
  2. 测试
@Test
public void selectAll01() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> students = mapper.getStudent01();
    for (Student student : students) {
        System.out.println("学生：" + student.getName() + "\t" + "老师：" + student.getTeacher().getName());
    }
    sqlSession.close();
}

小结：
按照查询进行嵌套处理就像SQL中的子查询
按照结果进行嵌套处理就像SQL中的联表查询

11. 一对多处理

一对多的理解：

  • 一个老师拥有多个学生
  • 如果对于老师这边，就是一个一对多的现象，即从一个老师下面拥有一群学生（集合）！

11.1 数据库设计

不修改

11.2 搭建测试环境

把上一个项目拷过来，重新创建一个module

实体类:

package com.SolitudeAlma.pojo;

import lombok.Data;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
@Data
public class Teacher {
    private int id;
    private String name;
    private List<Student> studentList;
}

package com.SolitudeAlma.pojo;

import lombok.Data;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}

11.3 按结果嵌套处理

  1. TeacherMapper接口编写方法
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.Teacher;
import lombok.Data;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
public interface TeacherMapper {
    /**
     * 获取指定教师信息的同时获取其教的学生的信息
     * @param id 教师唯一标识
     * @return List 信息集合，包括教师及所教学生信息
     */
    List<Teacher> getTeacher(@Param("tid") int id);
}
  1. 编写接口对应的Mapper配置文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.SolitudeAlma.dao.TeacherMapper">
    
    <select id="getTeacher" resultMap="teacherInfo">
        select s.id as sid, s.name as sname, t.id as tid, t.name as tname from student as s, teacher as t where s.tid = t.id and t.id = #{tid};
    select>
    
    <resultMap id="teacherInfo" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection  property="studentList" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        collection >
    resultMap>
mapper>
  1. 将Mapper文件注册到MyBatis-config文件中
<mappers>
  <mapper resource="com/SolitudeAlma/dao/StudentMapper.xml"/>
  <mapper resource="com/SolitudeAlma/dao/TeacherMapper.xml"/>
mappers>
  1. 测试
import com.SolitudeAlma.dao.TeacherMapper;
import com.SolitudeAlma.pojo.Teacher;
import com.SolitudeAlma.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * @author SolitudeAlma
 * @date 2021/8/18
 */
public class MyTest {
    @Test
    public void getTeacher() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        List<Teacher> teacherList = mapper.getTeacher(1);
        for (Teacher teacher : teacherList) {
            System.out.println("teacher: " + teacher.getName());
            teacher.getStudentList().forEach(e -> {
                System.out.println("student" + e.getId() + ": name: " + e.getName() +  " tid: " + e.getTid());
            });
        }
    }
}

11.4 按查询嵌套处理

  1. TeacherMapper接口编写方法
/**
* 获取指定教师信息的同时获取其教的学生的信息
* @param id 教师唯一标识
* @return List 信息集合，包括教师及所教学生信息
*/
List<Teacher> getTeacher01(@Param("tid") int id);
  1. 编写接口对应的Mapper配置文件
<select id="getTeacher01" resultMap="teacherInfo01">
  select id, name from teacher
  where id = #{tid};
select>
<resultMap id="teacherInfo01" type="Teacher">
  <result property="id" column="id"/>
  
  <collection property="studentList" javaType="List" column="id" ofType="Student" select="getStudentByTeacherId"/>
resultMap>
<select id="getStudentByTeacherId" resultType="Student">
  select id, name, tid from student
  where tid = #{tid};
select>
  1. 将Mapper文件注册到MyBatis-config文件中
  2. 测试
@Test
public void getTeacher01() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
    List<Teacher> teacherList = mapper.getTeacher01(1);
    for (Teacher teacher : teacherList) {
        System.out.println("teacher: name: " + teacher.getName() + " id: " + teacher.getId());
        teacher.getStudentList().forEach(e -> {
            System.out.println("student" + e.getId() + ": name: " + e.getName() +  " tid: " + e.getTid());
        });
    }
}

小结：

  1. 关联-association
  2. 集合-collection
  3. 所以association是用于一对一和多对一，而collection是用于一对多的关系
  4. JavaType和ofType都是用来指定对象类型的
  • JavaType是用来指定pojo中属性的类型
  • ofType指定的是映射到list集合属性中pojo的类型。

注意说明：

  1. 保证SQL的可读性，尽量通俗易懂
  2. 根据实际要求，尽量编写性能更高的SQL语句
  3. 注意属性名和字段不一致的问题
  4. 注意一对多和多对一 中：字段和属性对应的问题
  5. 尽量使用Log4j，通过日志来查看自己的错误

12. 动态SQL

12.1 介绍

什么是动态SQL：动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句.

官网描述：
MyBatis 的强大特性之一便是它的动态 SQL。如果你有使用 JDBC 或其它类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句的痛苦。例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。
虽然在以前使用动态 SQL 并非一件易事，但正是 MyBatis 提供了可以被用在任意 SQL 映射语句中的强大的动态 SQL 语言得以改进这种情形。
动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。在 MyBatis 之前的版本中，有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类，现在只需学习原来一半的元素便可。MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。

  • if
  • choose (when, otherwise)
  • trim (where, set)
  • foreach

我们之前写的 SQL 语句都比较简单，如果有比较复杂的业务，我们需要写复杂的 SQL 语句，往往需要拼接，而拼接 SQL ，稍微不注意，由于引号，空格等缺失可能都会导致错误。
那么怎么去解决这个问题呢？这就要使用 mybatis 动态SQL，通过 if, choose, when, otherwise, trim, where, set, foreach等标签，可组合成非常灵活的SQL语句，从而在提高 SQL 语句的准确性的同时，也大大提高了开发人员的效率。

12.2 搭建环境

新建一个数据库表：blog
字段：id，title，author，create_time，views

CREATE TABLE `blog` (
`id` varchar(50) NOT NULL COMMENT '博客id',
`title` varchar(100) NOT NULL COMMENT '博客标题',
`author` varchar(30) NOT NULL COMMENT '博客作者',
`create_time` datetime NOT NULL COMMENT '创建时间',
`views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

  1. 创建Mybatis基础工程
    Java学习笔记之Mybatis_第11张图片

  2. IDutil工具类

package com.SolitudeAlma.utils;

import org.junit.Test;

import java.util.UUID;

/**
 * 如果想在非test目录下测试，把依赖的作用域改一下或者去掉
 * @author SolitudeAlma
 * @date 2021/8/19
 */
public class IDUtils {
    public static String getId() {
        return UUID.randomUUID().toString().replaceAll("-", "");
    }
}
  1. 实体类编写 【注意set方法作用】
package com.SolitudeAlma.pojo;

import lombok.Data;

import java.util.Date;

/**
 * @author SolitudeAlma
 * @date 2021/8/19
 */
@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;
}
  1. 编写Mapper接口及xml文件
package com.SolitudeAlma.dao;

/**
 * @author SolitudeAlma
 * @date 2021/8/19
 */
public interface BlogMapper {
}


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.SolitudeAlma.dao.BlogMapper">

mapper>
  1. mybatis核心配置文件，下划线驼峰自动转换
<settings>
  
  <setting name="logImpl" value="STDOUT_LOGGING"/>
  <setting name="mapUnderscoreToCamelCase" value="true"/>
settings>
<mappers>
  <mapper resource="com/SolitudeAlma/dao/BlogMapper.xml"/>
mappers>
  1. 插入初始数据
    编写接口
package com.SolitudeAlma.dao;

import com.SolitudeAlma.pojo.Blog;

/**
 * @author SolitudeAlma
 * @date 2021/8/19
 */
public interface BlogMapper {
    /**
     * 添加一篇文章
     * @param blog 文章类
     * @return SQL执行结果，影响了几行
     */
    int addArticle(Blog blog);
}

sql配置文件

<insert id="addArticle" parameterType="Blog">
  insert into blog(`id`, `title`, `author`, `create_time`, `views`)
  values (#{id}, #{title}, #{author}, #{createTime}, #{views});
insert>

测试

@Test
public void addArticleTest() throws ParseException {
    String strDateFormat = "yyyy-MM-dd HH:mm:ss";
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    SimpleDateFormat dateFormat = new SimpleDateFormat(strDateFormat);

    Blog blog = new Blog();
    blog.setId(IDUtils.getId());
    blog.setTitle("Mybatis如此简单");
    blog.setAuthor("SolitudeAlma");
    blog.setCreateTime(dateFormat.format(new Date()));
    blog.setViews(23333);
    int result = mapper.addArticle(blog);
    System.out.println(result);

    blog.setId(IDUtils.getId());
    blog.setTitle("Java如此简单");
    blog.setCreateTime(dateFormat.format(new Date()));
    result = mapper.addArticle(blog);
    System.out.println(result);

    blog.setId(IDUtils.getId());
    blog.setTitle("微服务如此简单");
    blog.setCreateTime(dateFormat.format(new Date()));
    result = mapper.addArticle(blog);
    System.out.println(result);

    blog.setId(IDUtils.getId());
    blog.setTitle("Spring如此简单");
    blog.setCreateTime(dateFormat.format(new Date()));
    result = mapper.addArticle(blog);
    System.out.println(result);

    sqlSession.close();
}

初始化数据完毕！

12.3 IF

需求：根据作者名字和博客名字来查询博客！如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询

  1. 编写接口类
/**
* 查询文章信息，并根据if语句进一步查询
* @param map 查询条件集合
* @return List 文章信息集合
*/
List<Blog> queryArticleIf(Map<String, Object> map);
  1. 编写SQL语句

<select id="queryArticleIf" parameterType="map" resultType="Blog">
  select * from blog where
  <if test="title != null">
    title = #{title}
  if>
  <if test="author != null">
    and author = #{author}
  if>
select>
  1. 测试
@Test
public void queryArticleIfTest() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Map<String, Object>map = new HashMap<>();
    //map.put("title", "Mybatis如此简单");
    map.put("author", "SolitudeAlma");
    List<Blog> blogs = mapper.queryArticleIf(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    sqlSession.close();
}

这样写我们可以看到，如果 author 等于 null，那么查询语句为 select * from user where title=#{title},但是如果title为空呢？那么查询语句为 select * from user where and author=#{author}，这是错误的 SQL 语句，如何解决呢？请看下面的 where 语句！

12.4 WHERE

修改上面的SQL语句：


<select id="queryArticleIf" parameterType="map" resultType="Blog">
  
  
  
  
  
  
  
  select * from blog
  <where>
    <if test="title != null">
      title = #{title}
    if>
    <if test="author != null">
      and author = #{author}
    if>
  where>
select>

这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。

12.5 choose (when, otherwise)

有时候，我们不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句​

  1. 编写接口方法
/**
* 查询文章信息，并根据choose语句进一步查询
* @param map 查询条件集合
* @return List 文章信息集合
*/
List<Blog> queryBlogChoose(Map<String, Object> map);
  1. sql配置文件

<select id="queryBlogChoose" parameterType="map" resultType="Blog">
  select * from blog
  <where>
    <choose>
      <when test="title != null">
        title = #{title}
      when>
      <when test="author != null">
        and author = #{author}
      when>
      <otherwise>
        and views = #{views}
      otherwise>
    choose>
  where>
select>
  1. 测试类
@Test
public void queryBlogChooseTest() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Map<String, Object>map = new HashMap<>();
    map.put("views", "23333");
    List<Blog> blogs = mapper.queryBlogChoose(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    sqlSession.close();
}

12.6 set

同理，上面的对于查询 SQL 语句包含 where 关键字，如果在进行更新操作的时候，含有 set 关键词，我们怎么处理呢？
SET元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

  1. 编写接口方法
/**
* 修改文章信息，并根据trim语句动态修改
* @param map 查询条件集合
* @return SQL执行结果，影响了几行
*/
int updateArticle(Map<String, Object> map);
  1. sql配置文件

<update id="updateArticle" parameterType="map" >
  update blog
  <set>
    <if test="title != null">
      title=#{title},
    if>
    <if test="author != null">
      author=#{author}
    if>
  set>
  where id =#{id}
update>
  1. 测试
@Test
public void updateArticleTest() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Map<String, Object>map = new HashMap<>();
    map.put("id", "de27dc043af84946b008ff6ce3b866d1");
    map.put("title", "Mybatis如此简单01");
    int i = mapper.updateArticle(map);
    System.out.println(i);
    sqlSession.close();
}

12.7 trim (where, set)

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ...
trim>

prefixOverrides 属性会忽略通过管道符分隔的文本序列（注意此例中的空格是必要的）。上述例子会移除所有 prefixOverrides 属性中指定的内容，并且插入 prefix 属性中指定的内容。
用于动态更新语句的类似解决方案叫做 set。set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。比如：

<update id="updateAuthorIfNecessary">
  update Author
    <set>
      <if test="username != null">username=#{username},if>
      <if test="password != null">password=#{password},if>
      <if test="email != null">email=#{email},if>
      <if test="bio != null">bio=#{bio}if>
    set>
  where id=#{id}
update>

这个例子中，set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。
来看看与 set 元素等价的自定义 trim 元素吧：

<trim prefix="SET" suffixOverrides=",">
  ...
trim>

注意，我们覆盖了后缀值设置，并且自定义了前缀值。​

这部分相当于扩展功能，需要的自己实践，所以就直接搬文档了

12.8 SQL片段

有时候可能某个 sql 语句我们用的特别多，为了增加代码的复用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。

提取SQL片段：

<sql id="if-title-author">
  <if test="title != null">
    title = #{title}
  if>
  <if test="author != null">
    and author = #{author}
  if>
sql>

引用SQL片段：

<select id="queryArticleIf" parameterType="map" resultType="Blog">
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  select * from blog
  <where>
    
    <include refid="if-title-author"/>
    
  where>
select>

注意：
①、最好基于单表来定义 sql 片段，提高片段的可复用性
②、在 sql 片段中不要包括 where

12.9 foreach

将数据库中前三个数据的id修改为1,2,3；
需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息

  1. 编写接口
/**
* 查询文章信息，根据foreach语句动态查询
* @param map 查询条件集合
* @return List 文章信息集合
*/
List<Blog> queryBlogForeach(Map<String, Object> map);
  1. 编写SQL语句
<select id="queryBlogForeach" parameterType="map" resultType="blog">
  select * from blog
  <where>
    
    <foreach collection="ids"  item="id" open="and (" close=")" separator="or">
      id=#{id}
    foreach>
  where>
select>
  1. 测试
@Test
public void testQueryBlogForeachTest() {
    SqlSession session = MybatisUtils.getSqlSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    Map<String, Object> map = new HashMap<>();
    List<Integer> ids = new ArrayList<>();
    ids.add(1);
    ids.add(2);
    ids.add(3);
    map.put("ids",ids);

    List<Blog> blogs = mapper.queryBlogForeach(map);

    System.out.println(blogs);

    session.close();
}

小结：其实动态 sql 语句的编写往往就是一个拼接的问题，为了保证拼接准确，我们最好首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错。多在实践中使用才是熟练掌握它的技巧。

13. 缓存

13.1 简介

1、什么是缓存 [ Cache ]？

  • 存在内存中的临时数据。
  • 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

2、为什么使用缓存？

  • 减少和数据库的交互次数，减少系统开销，提高系统效率。

3、什么样的数据能使用缓存？

  • 经常查询并且不经常改变的数据。

13.2 Mybatis缓存

  • MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
  • MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
    • 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
    • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
    • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

13.3 一级缓存

一级缓存也叫本地缓存：

  • 与数据库同一次会话期间查询到的数据会放在本地缓存中。
  • 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库；

测试：

  1. 在mybatis中加入日志，方便测试结果
  2. 编写接口方法
/**
* 根据id查询用户信息
* @param id 用户唯一标识
* @return User 用户信息类
*/
User getUserById(@Param("id") int id);
  1. 接口对应的Mapper文件
<select id="getUserById" resultType="User">
  select * from user where id = #{id};
select>
  1. 测试
@Test
public void getUserByIdTest() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    User user = mapper.getUserById(1);
    System.out.println(user);
    System.out.println("=========================");
    User user1 = mapper.getUserById(1);
    System.out.println(user1);
    System.out.println(user == user1);
    sqlSession.close();
}
  1. 结果分析

Java学习笔记之Mybatis_第12张图片

13.4 一级缓存失效的四种情况

一级缓存是SqlSession级别的缓存，是一直开启的，我们关闭不了它；
一级缓存失效情况：没有使用到当前的一级缓存，效果就是，还需要再向数据库中发起一次查询请求！

  1. sqlSession不同
@Test
public void getUserByIdTest01(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    SqlSession sqlSession1 = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    UserMapper mapper2 = sqlSession1.getMapper(UserMapper.class);

    User user = mapper.getUserById(1);
    System.out.println(user);
    User user2 = mapper2.getUserById(1);
    System.out.println(user2);
    System.out.println(user==user2);

    sqlSession.close();
    sqlSession1.close();
}

观察结果：发现发送了两条SQL语句！
结论：每个sqlSession中的缓存相互独立

  1. sqlSession相同，查询条件不同
@Test
public void getUserByIdTest02(){
    SqlSession session = MybatisUtils.getSqlSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    UserMapper mapper1 = session.getMapper(UserMapper.class);

    User user = mapper.getUserById(1);
    System.out.println(user);
    User user2 = mapper1.getUserById(2);
    System.out.println(user2);
    System.out.println(user==user2);

    session.close();
}

观察结果：发现发送了两条SQL语句！很正常的理解
结论：当前缓存中，不存在这个数据

  1. sqlSession相同，两次查询之间执行了增删改操作！
    增加方法
/**
* 修改用户信息
* @param map 条件以及修改信息的集合
* @return SQL执行的结果，影响了几行
*/
int updateUser(Map<String, Object> map);

编写SQL

<update id="updateUser" parameterType="map">
	  update user set name = #{name}, pwd = #{pwd} where id = #{id}
</update>

测试

@Test
public void updateUserTest() {
    SqlSession session = MybatisUtils.getSqlSession();
    UserMapper mapper = session.getMapper(UserMapper.class);

    User user = mapper.getUserById(1);
    System.out.println(user);

    Map<String, Object> map = new HashMap<>();
    map.put("name","SolitudeAlma");
    map.put("id",4);
    mapper.updateUser(map);

    User user2 = mapper.getUserById(1);
    System.out.println(user2);

    System.out.println(user==user2);

    session.close();
}

观察结果：查询在中间执行了增删改操作后，重新执行了
结论：因为增删改操作可能会对当前数据产生影响

  1. sqlSession相同，手动清除一级缓存
@Test
public void getUserById03(){
    SqlSession session = MybatisUtils.getSqlSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    User user = mapper.getUserById(1);
    System.out.println(user);

    session.clearCache();//手动清除缓存

    User user2 = mapper.getUserById(1);
    System.out.println(user2);

    System.out.println(user==user2);

    session.close();
}

一级缓存就是一个map

13.5 二级缓存

  • 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
  • 基于namespace级别的缓存，一个名称空间，对应一个二级缓存；
  • 工作机制
    • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
    • 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；
    • 新的会话查询信息，就可以从二级缓存中获取内容；
    • 不同的mapper查出的数据会放在自己对应的缓存（map）中；

13.5.1 使用步骤

  1. 开启全局缓存 【mybatis-config.xml】

<setting name="cacheEnabled" value="true"/>
  1. 去每个mapper.xml中配置使用二级缓存，这个配置非常简单；【xxxMapper.xml】
<cache/> 直接使用这个需要序列化类（org.apache.ibatis.cache.CacheException: Error serializing object.  Cause: java.io.NotSerializableException: com.SolitudeAlma.pojo.User），实现Serializable接口
或
官方示例=====>查看官方文档
<cache
 eviction="FIFO"
 flushInterval="60000"
 size="512"
 readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。
  1. 代码测试
  • 所有的实体类先实现序列化接口
  • 测试代码
@Test
public void testQueryUserById(){
   SqlSession session = MybatisUtils.getSession();
   SqlSession session2 = MybatisUtils.getSession();

   UserMapper mapper = session.getMapper(UserMapper.class);
   UserMapper mapper2 = session2.getMapper(UserMapper.class);

   User user = mapper.queryUserById(1);
   System.out.println(user);
   session.close();

   User user2 = mapper2.queryUserById(1);
   System.out.println(user2);
   System.out.println(user==user2);

   session2.close();
}

13.5.2 结论

  • 只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
  • 查出的数据都会被默认先放在一级缓存中
  • 只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中
  • 只有提交事务后才会写入二级缓存

13.6 缓存原理图

Java学习笔记之Mybatis_第13张图片

13.7 自定义缓存-ehcache

image.png

第三方缓存实现–EhCache: 查看百度百科
Ehcache是一种广泛使用的java分布式缓存，用于通用缓存；
要在应用程序中使用Ehcache，需要引入依赖的jar包


<dependency>
    <groupId>org.mybatis.cachesgroupId>
    <artifactId>mybatis-ehcacheartifactId>
    <version>1.2.1version>
dependency>

在mapper.xml中使用对应的缓存即可


<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

编写ehcache.xml文件，如果在加载时未找到/ehcache.xml资源或出现问题，则将使用默认配置。



<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
        updateCheck="false">
   
   <diskStore path="./tmpdir/Tmp_EhCache"/>
   
   <defaultCache
           eternal="false"
           maxElementsInMemory="10000"
           overflowToDisk="false"
           diskPersistent="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="259200"
           memoryStoreEvictionPolicy="LRU"/>

   <cache
           name="cloud_user"
           eternal="false"
           maxElementsInMemory="5000"
           overflowToDisk="false"
           diskPersistent="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           memoryStoreEvictionPolicy="LRU"/>
   
   

ehcache>

运行后会爆红

https://blog.csdn.net/qq_42262803/article/details/86485140
https://blog.csdn.net/theonegis/article/details/45873331
https://blog.csdn.net/langtian08/article/details/82015017

合理的使用缓存，可以让我们程序的性能大大提升！

附属代码
所有资源来源于狂神说的B站投稿视频

你可能感兴趣的:(Java,java,mybatis)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • MyBatis 详解 阿贾克斯的黎明 javamybatis
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • ASM系列四 利用Method 组件动态注入方法逻辑 lijingyao8206 字节码技术jvmAOP动态代理ASM
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
  • java编程思想 --内部类 百合不是茶 java内部类匿名内部类
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅   1,内部类的创建  内部类是创建在类中的 package com.wj.InsideClass; /* * 内部类的创建 */ public class CreateInsideClass { public CreateInsideClass(
  • web.xml报错 crabdave web.xml
    web.xml报错   The content of element type "web-app" must match "(icon?,display-  name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
  • 泛型类的自定义 麦田的设计者 javaandroid泛型
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 采用泛型类，完成扩展。   例如有一个学生类     Student{ Student(){ System.out.println("I'm a student....."); } }  有一个老师类  
  • CSS清除浮动的4中方法 IT独行者 JavaScriptUIcss
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 1、结尾处加空div标签 clear:both 1 2 3 4 .div 1 { background : #000080 ; border : 1px   s
  • Cygwin使用windows的jdk 配置方法 _wy_ jdkwindowscygwin
    1.[vim /etc/profile]    JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43)    PATH="$JAVA_HOME/bin:${PATH}"    CLAS
  • linux下安装maven 无量 mavenlinux安装
    Linux下安装maven(转) 1.首先到Maven官网 下载安装文件，目前最新版本为3.0.3，下载文件为 apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 2.进入下载文件夹，找到下载的文件，运行如下命令解压 tar -xvf  apache-maven-2.2.1-bin.tar.gz 解压后的文件夹
  • tomcat的https 配置,syslog-ng配置 aichenglong tomcathttp跳转到httpssyslong-ng配置syslog配置
    1) tomcat配置https,以及http自动跳转到https的配置     1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令)      keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
  • 关于领号活动总结 alafqq 活动
    关于某彩票活动的总结 具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 活动要求 1，随机性，一定要有随机性； 2，最少中奖概率，如果注数为3200注，则最多中4注 3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 解决方案 1，事先产生随机数1000个，并打
  • java数据结构 冒泡排序的遍历与排序 百合不是茶 java
    java的冒泡排序是一种简单的排序规则   冒泡排序的原理：           比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样；         针对所有的元素重复以上的步骤，除了最后一个     例题；将int array[]
  • JS检查输入框输入的是否是数字的一种校验方法 bijian1013 js
    如下是JS检查输入框输入的是否是数字的一种校验方法： <form method=post target="_blank"> 数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br> </form>
  • Test注解的两个属性：expected和timeout bijian1013 javaJUnitexpectedtimeout
    JUnit4：Test文档中的解释： 　　The Test annotation supports two optional parameters. 　　The first, expected, declares that a test method should throw an exception. 　　If it doesn't throw an exception or if it
  • [Gson二]继承关系的POJO的反序列化 bit1129 POJO
    父类     package inheritance.test2; import java.util.Map; public class Model { private String field1; private String field2; private Map<String, String> infoMap
  • 【Spark八十四】Spark零碎知识点记录 bit1129 spark
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中  
  • WAS各种脚本作用大全 ronin47 WAS 脚本
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 　　　 获取下载 这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句 bylijinnan switch
    借鉴网上的思路，用java实现： public class NoIfWhile { /** * @param args * * find x=1+2+3+....n */ public static void main(String[] args) { int n=10; int re=find(n); System.o
  • Netty源码学习-ObjectEncoder和ObjectDecoder bylijinnan javanetty
    Netty中传递对象的思路很直观： Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 那把对象序列化为字节流，就可以在Netty中传递对象了 相应的从ChannelBuffer恢复对象，就是反序列化的过程 Netty已经封装好ObjectEncoder和ObjectDecoder 先看ObjectEncoder ObjectEncoder是往外发送
  • spring 定时任务中cronExpression表达式含义 chicony cronExpression
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 代表含义            是否必须 允许的取值范围         &nb
  • Nutz配置Jndi ctrain JNDI
    1、使用JNDI获取指定资源： var ioc = { dao : { type :"org.nutz.dao.impl.NutDao", args : [ {jndi :"jdbc/dataSource"} ] } } 以上方法,仅需要在容器中配置好数据源,注入到NutDao即可.
  • 解决 /bin/sh^M: bad interpreter: No such file or directory daizj shell
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。   分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 解决： 1）在windows下转换： 利用一些编辑器如UltraEdit或EditPlus等工具
  • [转]for 循环为何可恨？ dcj3sjt126com 程序员读书
      Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
  • Android实用小技巧 dcj3sjt126com android
    1、去掉所有Activity界面的标题栏 　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar"   2、去掉所有Activity界面的TitleBar 和StatusBar  　　修改AndroidManifes
  • Oracle 复习笔记之序列 eksliang Oracle 序列sequenceOracle sequence
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 1.序列的作用 序列是用于生成唯一、连续序号的对象 一般用序列来充当数据库表的主键值 2.创建序列语法如下：   create sequence s_emp start with 1 --开始值 increment by 1 --増长值 maxval
  • 有“品”的程序员 gongmeitao 工作
    完美程序员的10种品质　　   完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的   完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强   （范围：用简单方式解决复杂问题）　　
  • 使用KeleyiSQLHelper类进行分页查询 hvt sql.netC#asp.nethovertree
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
  • SVG 教程 （三）圆形，椭圆，直线 天梯梦 svg
    SVG <circle> SVG 圆形 - <circle> <circle> 标签可用来创建一个圆： 下面是SVG代码： <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> <circle cx="100" c
  • 链表栈 luyulong java数据结构
    public class Node { private Object object; private Node next; public Node() { this.next = null; this.object = null; } public Object getObject() { return object; } public
  • 基础数据结构和算法十：2-3 search tree sunwinner Algorithm2-3 search tree
      Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
  • spring配置定时任务 stunizhengjia springtimer
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到：     //------------------------定时任务调用的方法------------------------------ /** * 存储过程定时器 */ publi
  • ITeye 8月技术图书有奖试读获奖名单公布 ITeye管理员 活动
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 8月试读活动回顾： http://webmaster.iteye.com/blog/2102830 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《跨终端Web》 gleams：http
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他