【Java WEB】MyBatis详解

个人博客：www.hellocode.top
⭐所有文章均在上方博客首发，其他平台同步更新
本文专栏：《Java Web从入门到实战》
> 如没有Java基础，请先前往《Java零基础指南》专栏学习相应知识
⚡如有问题，欢迎指正，一起学习~~

---

---

快速入门

框架是一款半成品软件，我们可以基于这个半成品软件继续开发，来完成我们的个性化需求

• ORM(Object Relational Mapping)：对象关系映射
  指的是持久化数据和实体对象的映射模式，为了解决面向对象与关系型数据库存在的互不匹配的现象的技术

MyBatis介绍

• 原始 JDBC 的操作问题分析
  1. 频繁创建和销毁数据库的连接会造成系统资源浪费从而影响系统性能
  2. sql 语句在代码中硬编码，如果要修改sql语句，就需要修改 java 代码，造成代码不易维护
  3. 查询操作时，需要手动将结果集中的数据封装到实体对象中
  4. 增删改查操作需要参数时，需要手动将实体对象的数据设置到sql 语句的占位符
• 原始 JDBC 的操作问题解决方案
  1. 使用数据库连接池初始化连接资源
  2. 将sql 语句抽取到配置文件中
  3. 使用反射、内省等底层操作技术，将实体与表进行属性与字段的自动映射
• MyBatis 是一个优秀的基于Java的持久层框架，它内部封装了 JDBC，使开发者只需要关注 SQL 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建执行者等复杂的操作
• MyBatis 通过xml 或注解的方式将要执行的各种 Statement 配置起来，并通过Java 对象和Statement 中 SQL 的动态参数进行映射生成最终要执行的SQL语句
• 最后 MyBatis 框架执行完SQL 并将结果映射为 Java对象并返回。采用 ORM 思想解决了实体和数据库映射的问题，对 JDBC 进行了封装，屏蔽了 JDBC API 底层访问细节，使我们不用与 JDBC API 打交道，就可以完成对数据库的持久化操作
• MyBatis官网：http://www.mybatis.org

入门程序

1. 数据库数据准备

2. 导入 jar 包

3. 在src 下创建映射配置文件

   
   DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="StudentMapper">
       <select id="selectAll" resultType="mybaits.study.bean.Student">
           SELECT * FROM student
       select>
   mapper>
   

4. 在 src 下创建核心配置文件

   
   DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
   
   <configuration>
       <environments default="mysql">
           <environment id="mysql">
               <transactionManager type="JDBC">transactionManager>
               <dataSource type="POOLED">
                   <property name="driver" value="com.mysql.jdbc.Driver"/>
                   <property name="url" value="jdbc:mysql://192.168.23.129:3306/db1"/>
                   <property name="username" value="root"/>
                   <property name="password" value="密码"/>
               dataSource>
           environment>
       environments>
       
       <mappers>
           <mapper resource="StudentMapper.xml">mapper>
       mappers>
   configuration>
   

5. 编写测试类完成相关API 的使用

6. 运行测试查看结果

package mybatis.study.dao;

import mybatis.study.bean.Student;
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 StudentTest01 {
    /*
    *       查询全部
    * */
    @Test
    public void selectAll() throws IOException {
        // 1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        // 2. 获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        // 3.通过SqlSession工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 4.执行映射配置文件中的sql语句，并接收结果
        List<Student> list = sqlSession.selectList("StudentMapper.selectAll");

        // 5.处理结果
        for(Student stu : list){
            System.out.println(stu);
        }

        // 6.释放资源
        sqlSession.close();
        is.close();
    }
}

---

相关API

Resources

• org.apache.ibaties.io.Resources：加载资源的工具类
• 核心方法

  返回值	方法名	说明
  InputStream	getResourcesAsStream(String fileName)	通过类加载器返回指定资源的字节输入流

  除了使用这个工具类的方法，还可以使用类名.class.getClassLoader().getResourceAsStream(配置文件名.xml)获取到字节输入流对象

SqlSessionFactoryBuilder

• org.apache.ibaties.session.SqlSessionFactoryBuilder：获取SqlSessionFactory 工厂对象的功能类
• 核心方法

  返回值	方法名	说明
  SqlSessionFactory	build(InputStream is)	通过指定资源字节输入流获取SqlSession 工厂对象

SqlSessionFactory

• org.apache.ibaties.srssion.SqlSessionFactory：获取SqlSession 构建者对象的工厂接口
• 核心方法

  返回值	方法名	说明
  SqlSession	openSession()	获取SqlSession 构建者对象，并开启手动提交事务
  SqlSession	openSession(boolean autoCommit)	获取SqlSession构建者对象，如果参数为true，则开启自动提交事务

SqlSession

• org.apache.ibaties.session.SqlSession：构建者对象接口。用于执行SQL、管理事务、接口代理
• 核心方法

  返回值	方法名	说明
  List	selectList(String statement,Object paramter)	执行查询语句，返回List集合
  T	selectOne(String statement,Object paramter)	执行查询语句，返回一个结果对象
  int	insert(String statement,Object paramter)	执行新增语句，返回影响行数
  int	update(String statement,Object paramter)	执行修改语句，返回影响行数
  int	delete(String statement,Object paramter)	执行删除语句，返回影响行数
  void	commit()	提交事务
  void	rollback()	回滚事务
  T	getMapper(Classcls)	获取指定接口的代理实现类对象
  void	close()	释放资源

---

映射配置文件

• 映射配置文件包含了数据和对象之间的映射关系以及要执行的SQL语句

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

<mapper namespace="StudentMapper">
    
    <select id="selectAll" resultType="mybaits.study.bean.Student">
        SELECT * FROM student
    select>
mapper>

查询功能

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="StudentMapper">
    <select id="selectAll" resultType="mybatis.study.bean.Student">
        SELECT * FROM student
    select>
    <select id="selectById" resultType="mybatis.study.bean.Student" parameterType="java.lang.Integer">
        SELECT * FROM student WHERE id = #{参数名称}
    select>
mapper>

@Test 
public void selectById() throws IOException {
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    Student stu = sqlSession.selectOne("StudentMapper.selectById", 1);
    System.out.println(stu);
    sqlSession.close();
    is.close();
}

• ：查询功能标签
  属性
  id：唯一标识
  parameterType：指定参数映射的对象类型
  resultType：指定结果映射的对象类型
  SQL 获取参数
  #{属性名}

  注意：属性名要和对象中的成员变量名称一致，才能获取到正确的值

  新增功能

  <insert id="insert" parameterType="mybatis.study.bean.Student">
  	INSERT INTO student VALUES (#{id},#{name},#{age})
  insert>
  

  @Test
  public void insert() throws IOException {
      InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession(true);
      Student stu = new Student(7,"老八",28);
      int result = sqlSession.insert("StudentMapper.insert", stu);
      // 如果没有开启自动提交事务，对于增删改，在执行完SQL后还需要提交事务
      // sqlSession.commit();
      System.out.println(result);
      is.close();
      sqlSession.close();
  }
  

  • ：新增功能标签
  • 属性
    id：唯一标识，配合名称空间使用
    parameterType：指定参数映射的对象类型
    resultType：指定结果映射的对象类型

    对于增删改操作，返回的的结果都是int类型的影响行数，故resultType可以省略不写

  • SQL获取参数
    #{属性名}

    注意：属性名要和对象中的成员变量名称一致，才能获取到正确的值

  修改功能

  <update id="update" parameterType="mybatis.study.bean.Student">
  	UPDATE student SET name = #{name},age = #{age} WHERE id = #{id}
  update>
  

  @Test
  public void update() throws IOException {
      InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      Student stu = new Student(6,"周七七",37);
      int result = sqlSession.insert("StudentMapper.update", stu);
      // 如果没有开启自动提交事务，对于增删改，在执行完SQL后还需要提交事务
      sqlSession.commit();
      System.out.println(result);
      is.close();
      sqlSession.close();
  }
  

  • ：修改功能标签
  • 属性
    id：唯一标识，配合名称空间使用
    parameterType：指定参数映射的对象类型
    resultType：指定结果映射的对象类型
  • SQL 获取参数
    #{属性名}

  删除功能

  <delete id="delete" parameterType="java.lang.Integer">
  	DELETE FROM student WHERE id = #{id}
  delete>
  

  @Test
  public void delete() throws IOException {
      InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      int result = sqlSession.delete("StudentMapper.delete", 7);
      System.out.println(result);
      // 提交事务
      sqlSession.commit();
      sqlSession.close();
      is.close();
  }
  

  • ：删除功能标签
  • 属性
    id：唯一标识，配合名称空间使用
    parameterType：指定参数映射的对象类型
    resultType：指定结果映射的对象类型
  • SQL 获取参数
    #{属性名}

  ---

  核心配置文件

  • 核心配置文件包含了MyBatis 最核心的设置和属性信息。如数据库的连接、事务、连接池信息等

  
  
  DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
  
  
  <configuration>
      
      <environments default="mysql">
          
          <environment id="mysql">
              
              <transactionManager type="JDBC">transactionManager>
              
              <dataSource type="POOLED">
                  
                  <property name="driver" value="com.mysql.jdbc.Driver"/>
                  <property name="url" value="jdbc:mysql://192.168.23.129:3306/db1"/>
                  <property name="username" value="root"/>
                  <property name="password" value="lh18391794828"/>
              dataSource>
          environment>
      environments>
      
      <mappers>
          
          <mapper resource="StudentMapper.xml">mapper>
      mappers>
  configuration>
  

  数据库连接配置文件引用

  • 为了方便修改，可以将核心配置文件中的数据库连接信息抽取出来：jdbc.properties

    driver=com.mysql.jdbc.Driver
    url=jdbc:mysql://192.168.23.129
    username=root
    password=密码
    

  • ：使用该标签可以引入数据库连接配置文件
  • 属性
    resource：数据库连接配置文件路径
  • 获取数据库连接参数
    ${键名}

  
  DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
  
  <configuration>
      
      <properties resource="jdbc.properties">properties>
      <environments default="mysql">
          <environment id="mysql">
              <transactionManager type="JDBC">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>
      <mappers>
          <mapper resource="StudentMapper.xml">mapper>
      mappers>
  configuration>
  

  起别名

  • ：为全类名起别名的父标签
  • ：为全类名起别名的子标签
  • 属性
    type：指定全类名
    alias：指定别名
  • ：为指定包下所有的类起别名的子标签（别名就是类名）

  
  <typeAliases>
  	<typeAlias type="mybatis.study.bean.Student" alias="Student">typeAlias>
      
  typeAliases>
  

  在核心配置文件中起别名后，就可以简化映射配置文件中的全类名

  MyBatis自带的一些别名

  别名	数据类型
  string	java.lang.String
  long	java.lang.Long
  int	java.lang.Integer
  double	java.lang.Double
  boolean	java.lang.Boolean
  …	…

  ---

  Dao层的实现

  传统方式

  • 分层思想：控制层（controller）、业务层（service）、持久层（dao）
  • 调用流程
    控制层 --> 业务层 --> 持久层 --> DB

    在MyBatis中，持久层叫mapper

  package mybatis.study.mapper;
  
  import mybatis.study.bean.Student;
  
  import java.util.List;
  
  /*
  *       持久层
  * */
  
  
  public interface StudentMapper {
      // 查询全部
      public abstract List<Student> selectAll();
  
      // 根据id查询
      public abstract Student selectById(Integer id);
  
      // 新增数据
      public abstract Integer insert(Student stu);
  
      // 修改数据
      public abstract Integer update(Student stu);
  
      // 删除数据
      public abstract Integer delete(Integer id);
  }
  

  package mybatis.study.mapper.impl;
  
  import mybatis.study.bean.Student;
  import mybatis.study.mapper.StudentMapper;
  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;
  import java.util.List;
  
  public class StudentMapperImpl implements StudentMapper {
      @Override
      public List<Student> selectAll() {
          InputStream is = null;
          SqlSession sqlSession = null;
          List<Student> list = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              list = sqlSession.selectList("StudentMapper.selectAll");
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return list;
      }
  
      @Override
      public Student selectById(Integer id) {
          InputStream is = null;
          SqlSession sqlSession = null;
          Student stu = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              stu = sqlSession.selectOne("StudentMapper.selectById",id);
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return stu;
      }
  
      @Override
      public Integer insert(Student stu) {
          InputStream is = null;
          SqlSession sqlSession = null;
          Integer result = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              result = sqlSession.insert("StudentMapper.insert",stu);
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return result;
      }
  
      @Override
      public Integer update(Student stu) {
          InputStream is = null;
          SqlSession sqlSession = null;
          Integer result = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              result = sqlSession.update("StudentMapper.update",stu);
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return result;
      }
  
      @Override
      public Integer delete(Integer id) {
          InputStream is = null;
          SqlSession sqlSession = null;
          Integer result = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              result = sqlSession.delete("StudentMapper.delete",id);
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return result;
      }
  }
  

  package mybatis.study.service;
  
  import mybatis.study.bean.Student;
  
  import java.util.List;
  
  /*
  *       业务层
  * */
  
  public interface StudentService {
      // 查询全部
      public abstract List<Student> selectAll();
  
      // 根据id查询
      public abstract Student selectById(Integer id);
  
      // 新增数据
      public abstract Integer insert(Student stu);
  
      // 修改数据
      public abstract Integer update(Student stu);
  
      // 删除数据
      public abstract Integer delete(Integer id);
  }
  

  package mybatis.study.service.impl;
  
  import mybatis.study.bean.Student;
  import mybatis.study.mapper.StudentMapper;
  import mybatis.study.mapper.impl.StudentMapperImpl;
  import mybatis.study.service.StudentService;
  
  import java.util.List;
  
  public class StudentServiceImpl implements StudentService {
      // 创建持久层对象
      private StudentMapper mapper = new StudentMapperImpl();
  
      @Override
      public List<Student> selectAll() {
          return mapper.selectAll();
      }
  
      @Override
      public Student selectById(Integer id) {
          return mapper.selectById(id);
      }
  
      @Override
      public Integer insert(Student stu) {
          return mapper.insert(stu);
      }
  
      @Override
      public Integer update(Student stu) {
          return mapper.update(stu);
      }
  
      @Override
      public Integer delete(Integer id) {
          return mapper.delete(id);
      }
  }
  

  package mybatis.study.controller;
  
  import mybatis.study.bean.Student;
  import mybatis.study.service.StudentService;
  import mybatis.study.service.impl.StudentServiceImpl;
  import org.junit.Test;
  
  import java.util.List;
  
  /*
  *   控制层测试类
  * */
  public class StudentController {
      // 创建业务层对象
      private StudentService service = new StudentServiceImpl();
  
      @Test
      public void selectAll(){
          List<Student> stus = service.selectAll();
          for(Student stu : stus){
              System.out.println(stu);
          }
      }
  
      @Test
      public void selectById(){
          Student stu = service.selectById(5);
          System.out.println(stu);
      }
  
      @Test
      public void insert(){
          Student stu = new Student(5,"赵六",46);
          Integer result = service.insert(stu);
          System.out.println(result);
      }
  
      @Test
      public void delete(){
          Integer result = service.delete(5);
          System.out.println(result);
      }
  
      @Test
      public void update(){
          Student stu = new Student(5,"赵六六",36);
          Integer result = service.update(stu);
          System.out.println(result);
      }
  }
  

  LOG4J

  • 在日常开发过程中，排查问题时难免需要输出 MyBatis 真正执行的 SQL语句、参数、结果等信息，我们就可以借助 LOG4J 的功能来实现执行信息的输出
  • 使用步骤
    1. 导入jar 包
    2. 修改核心配置文件

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

    3. 在 src下编写LOG4J 配置文件

       # Global logging configuration
       # 输出信息的显示。四个级别：ERROR、WARN、INFO、DEBUG
       log4j.rootLogger=DEBUG, stdout
       # Console output...
       log4j.appender.stdout=org.apache.log4j.ConsoleAppender
       log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
       log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
       

  接口代理方式

  传统方式实现Dao层，我们既需要写接口，还要写实现类。而MyBatis 框架可以帮助我们省略编写 Dao层接口实现类的步骤。程序员只需要编写接口，由MyBatis 框架根据接口的定义来创建该接口的动态代理对象

  实现规则

  1. 映射配置文件中的名称空间必须和 Dao 层接口的全类名相同
  2. 映射配置文件中的增删改查标签的id属性必须和Dao层接口的方法名相同
  3. 映射配置文件中的增删改查标签的 parameterType 属性必须和 Dao层 接口方法的参数相同
  4. 映射配置文件中的增删改查标签的resultType 属性必须和 Dao层 接口方法的返回值相同

  代码实现

  1. 删除mapper层接口的实现类
  2. 修改映射配置文件
  3. 修改service 层接口的实现类，采用接口代理方式实现功能

   
   
   DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="mybatis.study.mapper.StudentMapper">
       <select id="selectAll" resultType="Student">
           SELECT * FROM student
       select>
       <select id="selectById" resultType="Student" parameterType="int">
           SELECT * FROM student WHERE id = #{id}
       select>
       <insert id="insert" parameterType="Student">
           INSERT INTO student VALUES (#{id},#{name},#{age})
       insert>
       <update id="update" parameterType="Student">
           UPDATE student SET name = #{name},age = #{age} WHERE id = #{id}
       update>
       <delete id="delete" parameterType="int">
           DELETE FROM student WHERE id = #{id}
       delete>
   mapper>
  

   @Override
   public List<Student> selectAll() {
       InputStream is = null;
       List<Student> list = null;
       SqlSession sqlSession = null;
       try{
           // 1.加载核心配置文件
           is = Resources.getResourceAsStream("MyBatisConfig.xml");
           // 2. 获取SqlSessionFactory 工厂对象
           SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
           // 3. 获取SqlSession对象
           sqlSession = sqlSessionFactory.openSession(true);
           // 4.获取StudentMapper持久层接口的实现类对象
           StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
           // 5.通过实现类对象调用方法，接收结果
           list = mapper.selectAll();
       }catch (Exception e){
           e.printStackTrace();
       }finally {
           // 6.释放资源
           if(sqlSession != null){
               sqlSession.close();
           }
           if(is != null){
               try {
                   is.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
       return list;
   }
  

  通过动态代理开发模式，我们只编写一个接口，不写实现类，我们通过 getMapper()方法最终获取到org.apache.ibatis.binding.MapperProxy 代理对象，然后执行功能，而这个代理对象正是 MyBatis 使用了 JDK 的动态代理技术，帮助我们生成了代理实现类对象，从而可以进行相关持久化操作

  动态代理实现类对象在执行方法的时候最终调用了 mapperMethod.execute() 方法，这个方法中通过 switch语句根据操作类型来判断是新增、修改、删除、查询操作，最后一步回到了 MyBatis 最原生的 SqlSession 方式来执行增删改查

  ---

  动态sql

  • MyBatis 映射配置文件中，前面使用的SQL 都是比较简单的，有些时候业务逻辑复杂时，我们的 SQL就是动态变化的，此时前面学习的 SQL 就不能满足需求了
  • 多条件查询
    SELECT * FROM student WHERE id = ? AND name = ? AND age = ?
SELECT * FROM student WHERE id = ? AND name = ?
  • 动态SQL 标签
    ：条件判断标签
    ：循环遍历标签

  if标签

  • ：条件标签。如果有动态条件，则使用该标签代替where 关键字
  • ：条件判断标签

    <if test="条件判断">
        查询条件拼接
    if>
    

  <select id="selectCondition" resultType="student" parameterType="student">
      SELECT * FROM student
      <where>
          <if test="id != null">
              id = #{id}
          if>
          <if test="name != null">
              AND name = #{name}
          if>
          <if test="age != null">
              AND age = #{age}
          if>
      where>
  select>
  

  foreach标签

  • ：循环遍历标签。适用于多个参数或者的关系

    <foreach collection = "" open = "" close = "" item = "" separator = "">
        获取参数
    foreach>
    

  • 属性
    collection：参数容器类型，（list-集合，array-数组）
    open：开始的 SQL 语句
    close：结束的 SQL 语句
    item：参数变量名
    separator：分隔符

  <select id="selectByIds" resultType="Student" parameterType="list">
      SELECT * FROM student
      <where>
          <foreach collection="list" open="id IN (" close=")" item="id" separator=",">
              #{id}
          foreach>
      where>
  select>
  

  SQL 片段的抽取

  • 我们可以将一些重复性的SQL 语句进行抽取，以达到复用的效果
  • ：抽取SQL语句标签
    抽取的SQL语句
  • ：引入SQL片段标签
    

  <sql id="select">SELECT * FROM studentsql>
  
  <select id="selectAll" resultType="Student">
      <include refid="select" />
  select>
  <select id="selectById" resultType="Student" parameterType="int">
      <include refid="select" /> WHERE id = #{id}
  select>
  

  ---

  分页插件

  • 分页可以将很多条结果进行分页显示
  • 如果当前在第一页，则没有上一页。如果在最后一页，则没有下一页
  • 需要明确当前是第几页，这一页中显示多少条结果

  在企业级的开发中，分页也是一种常见的技术。而目前使用的 MyBatis 是不带分页功能的，如果想实现分页的功能，需要我们手动编写 LIMIT 语句。但是不同的数据库实现分页的 SQL 语句也是不同的，所以手写分页成本较高。这个时候可以借助分页插件来帮助我们实现分页功能

  • PageHelper：第三方分页助手。将复杂的分页操作进行封装，从而让分页功能变得非常简单

  分页插件实现步骤

  1. 导入jar 包：pagehelper-5.1.10.jar jsqlparser-3.1.jar
  2. 在核心配置文件中集成分页助手插件
  3. 在测试类中使用分页助手相关 API 实现分页功能

  
  <plugins>
      <plugin interceptor="com.github.pagehelper.PageInterceptor">plugin>
  plugins>
  

  分页参数的获取

  • PageInfo：封装分页相关参数的功能类
  • 核心方法

    返回值	方法名	说明
    long	getTotal()	获取总条数
    int	getPages()	获取总页数
    int	getPageNum()	获取当前页
    int	getPageSize()	获取每页显示条数
    int	getPrePage()	获取上一页
    int	getNextPage()	获取下一页
    boolean	isIsFirstPage()	获取是否是第一页
    boolean	isIsLastPage()	获取是否是最后一页

  @Test
  public void selectPaging() throws IOException {
      InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession(true);
      StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
  
      // 通过分页助手实现分页功能
      // 参数：当前页,显示的条数
      PageHelper.startPage(1,3);
  
      List<Student> list = mapper.selectAll();
      for(Student stu : students){
          System.out.println(stu);
      }
  
      //获取分页相关参数
      PageInfo<Student> info = new PageInfo<>(list);
      
      System.out.println("总条数" + info.getTotal());
      System.out.println("总页数" + info.getPages());
      System.out.println("当前页" + info.getPageNum());
      System.out.println("每页条数" + info.getPageSize());
      System.out.println("上一页" + info.getPrePage());
      System.out.println("下一页" + info.getNextPage());
      System.out.println("是否是第一页：" + info.isIsFirstPage());
      System.out.println("是否是最后一页：" + info.isIsLastPage());
  
      sqlSession.close();
      is.close();
  }
  

  ---

  多表操作

  • 我们之前学习的都是基于单表操作的，二实际开发中，随着业务逻辑难度的加深，肯定需要多表操作的
  • 多表模型的分类
    • 一对一：在任意一方建立外键，关联对方的主键
    • 一对多：在多的一方建立外键，关联少的一方的主键
    • 多对多：借助中间表，中间表至少两个字段，分别关联两张表的主键

  一对一

  • 一对一模型：人和身份证，是一对一的关系
  • 数据准备

    CREATE DATABASE db12;
    USE db12;
    CREATE TABLE person(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(20),
    	age INT
    );
    INSERT INTO person VALUES (NULL,'张三',23),(NULL,'李四',24),(NULL,'王五',25);
    CREATE TABLE card(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	number VARCHAR(30),
    	pid INT,
    	CONSTRAINT cp_fk FOREIGN KEY (pid) REFERENCES person(id)
    );
    INSERT INTO card VALUES (NULL,'12345',1),(NULL,'23456',2),(NULL,'34567',3);
    

  • 映射配置文件

    
    DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="mybatis.study.table01.OneToOneMapper">
        
        <resultMap id="oneToOne" type="card">
            <id column="cid" property="id" />
            <result column="number" property="number" />
            
            <association property="p" javaType="person">
                <id column="pid" property="id" />
                <result column="name" property="name" />
                <result column="age" property="age" />
            association>
        resultMap>
        <select id="selectAll" resultMap="oneToOne">
            SELECT c.id,number,pid,NAME,age FROM card c,person p WHERE c.pid = p.id;
        select>
    mapper>
    

    @Test
    public void selectAll() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        OneToOneMapper mapper = sqlSession.getMapper(OneToOneMapper.class);
        List<Card> list = mapper.selectAll();
        for(Card card : list){
            System.out.println(card);
        }
    }
    

  • ：配置字段和对象属性的映射关系标签
    id属性：唯一标识
    type属性：实体对象类型
  • ：配置主键映射关系标签
  • ：配置非主键映射关系标签
    column属性：表中字段名称
    property属性：实体对象变量名称
  • ：配置被包含对象的映射关系标签
    property属性：被包含对象的变量名
    javaType属性：被包含对象的数据类型

  一对多

  • 一对多模型：班级和学生，一个班级可以有多个学生
  • 数据准备

    CREATE TABLE classes(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(20)
    );
    INSERT INTO classes VALUES (NULL,'一班'), (NULL,'二班');
    CREATE TABLE student(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(30),
    	age INT,
    	cid INT,
    	CONSTRAINT cs_fk FOREIGN KEY (cid) REFERENCES classes(id)
    );
    INSERT INTO student VALUES (NULL,'张三',23,1),(NULL,'李四',24,1),(NULL,'王五',25,2),(NULL,'赵六',26,2);
    

  • 映射配置文件

    
    DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="mybatis.study.table02.OneToManyMapper">
        <resultMap id="oneToMany" type="classes">
            <id column="cid" property="id" />
            <result column="cname" property="name" />
            
            
            <collection property="students" ofType="student">
                <id column="sid" property="id" />
                <result column="sname" property="name" />
                <result column="sage" property="age" />
            collection>
            
        resultMap>
        <select id="selectAll" resultMap="oneToMany">
            SELECT c.id cid,c.name cname,s.id sid, s.name sname,s.age sage FROM classes c,student s WHERE c.id = s.cid;
        select>
    mapper>
    

  @Test
      public void selectAll() throws IOException {
          InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
          SqlSession sqlSession = sqlSessionFactory.openSession(true);
          OneToManyMapper mapper = sqlSession.getMapper(OneToManyMapper.class);
          List<Classes> classes = mapper.selectAll();
          for(Classes cls : classes){
              System.out.println(cls.getId() + "," + cls.getName());
              List<Student> students = cls.getStudents();
              for(Student stu : students){
                  System.out.println("\t" + stu);
              }
          }
      }
  

  • ：配置字段和对象属性的映射关系标签
    id属性：唯一标识
    type属性：实体对象类型
  • ：配置主键映射的关系标签
  • ：配置非主键映射关系标签
    column属性：表中字段名称
    property属性：实体对象变量名称
  • ：配置被包含集合对象的映射关系标签
    property属性：被包含集合对象的变量名
    ofType属性：集合中保存的对象数据类型

  多对多

  • 多对多模型：学生和课程，一个学生可以选择多门课程，一个课程也可以被多个学生所选择
  • 数据准备

    CREATE TABLE course(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(20)
    );
    INSERT INTO course VALUES (NULL,'语文'),(NULL,'数学');
    CREATE TABLE stu_cr(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	sid INT,
    	cid INT,
    	CONSTRAINT sc_fk1 FOREIGN KEY (sid) REFERENCES student(id),
    	CONSTRAINT sc_fk2 FOREIGN KEY (cid) REFERENCES course(id)
    );
    INSERT INTO stu_cr VALUES (NULL,1,1),(NULL,1,2),(NULL,2,1),(NULL,2,2);
    

  • 映射配置文件

    
    DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="mybatis.study.table03.ManyToManyMapper">
        <resultMap id="manyToMany" type="student">
            <id column="sid" property="id" />
            <result column="sname" property="name" />
            <result column="sage" property="age" />
            
            <collection property="courses" ofType="course">
                <id column="cid" property="id" />
                <result column="cname" property="name" />
            collection>
        resultMap>
        
        <select id="selectAll" resultMap="manyToMany">
            SELECT sc.sid,s.name sname,s.age sage,sc.cid,c.name cname FROM student s,course c,stu_cr sc WHERE sc.sid = s.id AND sc.cid = c.id;
        select>
    mapper>
    

  @Test
  public void selectAll() throws IOException {
      InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession(true);
      ManyToManyMapper mapper = sqlSession.getMapper(ManyToManyMapper.class);
      List<Student> students = mapper.selectAll();
      for(Student stu : students){
          System.out.println(stu.getId() + "," + stu.getName() + "," + stu.getAge());
          List<Course> courses = stu.getCourses();
          for(Course cour : courses){
              System.out.println("\t" + cour);
          }
      }
  }
  

  • ：配置字段和对象属性的映射关系标签
    id属性：唯一标识
    type属性：实体对象类型
  • ：配置主键映射关系标签
  • ：配置非主键映射关系标签
    column属性：表中字段名称
    property属性：实体对象变量名称
  • ：配置被包含集合对象的映射关系标签
    property属性：被包含集合对象的变量名
    ofType属性：集合中保存的对象数据类型

  ---

  注解开发

  • 我们除了使用映射配置文件来操作以外，还可以使用注解形式来操作
  • 常用注解
    @Select("查询的SQL语句")：执行查询操作注解
    @Insert("新增的SQL语句")：执行新增操作注解
    @Update("修改的SQL语句")：执行修改操作注解
    @Delete("删除的SQL语句")：执行删除操作注解

  查询操作

  1. 创建接口和查询方法
  2. 在核心配置文件中配置映射关系

     <mappers>
         
     	<package name="mybatis.study.mapper" />
     mappers>
     

  3. 编写测试类

     @Test
     public void selectAll() throws IOException {
         InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
         SqlSession sqlSession = sqlSessionFactory.openSession(true);
         StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
         List<Student> students = mapper.selectAll();
         for (Student student : students) {
             System.out.println(student);
         }
     }
     

  新增操作

  1. 在接口中创建新增方法

     // 新增操作
     @Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")
     public abstract Integer insert(Student stu);
     

  2. 编写测试类
  3. 实现功能

     @Test
     public void insert() throws IOException {
         InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
         SqlSession sqlSession = sqlSessionFactory.openSession(true);
         StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
         Student stu = new Student(null,"周七",27);
         Integer result = mapper.insert(stu);
         System.out.println(result);
     }
     

  修改、删除操作原理相同

  ---

  注解多表操作

  一对一

  // 查询全部
  @Select("SELECT * FROM card")
  @Results(
      {
          @Result(column = "id", property = "id"),
          @Result(column = "number", property = "number"),
          @Result(
              property = "p",     //被包含对象的变量名
              javaType = Person.class,     //被包含对象的实际数据类型
              column = "pid",         // 根据查询出的card表中的pid查询person表
              // one、@One 是一对一操作的固定写法
              // select属性：指定调用哪个接口中的哪个方法
              one=@One(select = "mybatis.study.one_to_one.PersonMapper.selectById")
          )
      }
  )
  public abstract List<Card> selectAll();
  

  // 根据id查询
  @Select("SELECT * FROM student WHERE id = #{id}")
  public abstract Person selectById(Integer id);
  

  • @Results：封装映射关系的父注解
    Result[] value()：定义了Result数组
  • @Result：封装映射关系的子注解
    column属性：查询出表中的字段名称
    property属性：实体对象中的属性名
    javaType属性：被包含对象的数据类型
    one属性：一对一查询的固定属性
  • @One：一对一查询的注解
    select属性：指定调用某个接口中的方法

  一对多

  // 查询全部
  @Select("SELECT * FROM classes")
  @Results({
      @Result(column = "id",property = "id"),
      @Result(column = "name",property = "name"),
      @Result(
          property = "students",
          javaType = List.class,
          column = "id",
          /*
          *       many、@Many 一对多查询的固定写法
          *       select：指定调用哪个接口中的哪个查询方法
          * */
          many=@Many(select = "mybatis.study.one_to_many.StudentMapper.selectByCid")
      )
  })
  public abstract List<Classes> selectAll();
  

  //根据cid查询student表
  @Select("SELECT * FROM student WHERE cid = #{cid}")
  public abstract List<Student> selectByCid(Integer cid);
  

  • many属性：一对多查询的固定属性
  • @Many：一对多查询的注解
    select属性：指定调用某个接口中的方法

  多对多

  // 查询全部
  @Select("SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id")
  @Results({
      @Result(column = "id",property = "id"),
      @Result(column = "name",property = "name"),
      @Result(column = "age",property = "age"),
      @Result(
          property = "courses",
          javaType= List.class,
          column = "id",
          many = @Many(select = "mybatis.study.many_to_many.CourseMapper.selectBySid")
      )
  })
  public abstract List<Student> selectAll();
  

  // 根据学生id查询所选课程
  @Select("SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid = #{id}")
  public abstract List<Course> selectBySid(Integer id);
  

  多对多中的一些注解和一对多一样，主要区别就是多对多中使用了第三张中间表

  ---

  构建SQL

  • 我们之前通过注解开发时，相关SQL语句都是自己直接拼写的。一些关键字写起来比较麻烦，而且容易出错
  • MyBatis 给我们提供了 org.apache.ibatis.jdbc.SQL 功能类，专门用于构建 SQL语句

  方法名	说明
  SELECT(String…column)	根据字段拼接查询语句
  FROM(String…table)	根据表名拼接语句
  WHERE(String…condition)	根据条件拼接语句
  INSERT_INTO(String table)	根据表名拼接新增语句
  VALUES(String column,String values)	根据字段和值拼接插入数据语句
  UPDATE(String table)	根据表名拼接修改语句
  DELETE_FROM(String table)	根据表名拼接删除语句
  … …	… …

  查询操作

  • 定义功能类并提供获取查询的SQL 语句的方法
  • @SelectProvider：生成查询用的 SQL语句注解
    type属性：生成SQL 语句功能类对象
    method属性：指定调用方法

  public static String getSql(){
      String sql = new SQL(){
          {
              SELECT("*");
              FROM("student");
          }
      }.toString();
      return sql;
  }
  

  // 查询全部
  // @Select("SELECT * FROM student")
  @SelectProvider(type = ReturnSql.class, method = "getSelectAll")
  public abstract List<Student> selectAll();
  

  新增操作

  • 定义功能类并提供获取新增SQL语句的方法
  • @InsertProvider：生成新增用的SQL语句注解
    type属性：生成SQL语句功能类对象
    method属性：指定调用方法

  // 定义方法，返回新增的sql语句
  public String getInsert(Student stu){
      return new SQL(){
          {
              INSERT_INTO("student");
              INTO_VALUES("#{id},#{name},#{age}");
          }
      }.toString();
  }
  

  // 新增操作
  // @Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")
  @InsertProvider(type = ReturnSql.class,method = "getInsert")
  public abstract Integer insert(Student stu);
  

  修改操作

  • 定义功能类并提供获取修改SQL语句的方法
  • @UpdateProvider：生成修改用的 SQL语句注解
    type属性：生成SQL 语句功能类对象
    method属性：指定调用方法

  // 定义方法，返回修改的SQL语句
  public String getUpdate(Student stu){
      return new SQL(){
          {
              UPDATE("student");
              SET("name=#{name}","age=#{age}");
              WHERE("id=#{id}");
          }
      }.toString();
  }
  

  // 修改操作
  //@Update("UPDATE student SET name=#{name},age=#{age} WHERE id = #{id}")
  @UpdateProvider(type = ReturnSql.class,method = "getUpdate")
  public abstract Integer update(Student stu);
  

  删除操作

  • 定义功能类并提供获取删除的 SQL语句的方法
  • @DeleteProvider：生成删除用的SQL语句注解
    type属性：生成SQL 语句功能类对象
    method属性：指定调用方法

  // 定义方法，返回删除的sql语句
  public String getDelete(Integer id){
      return new SQL(){
          {
              DELETE_FROM("student");
              WHERE("id=#{id}");
          }
      }.toString();
  }
  

  // 删除操作
  //@Delete("DELETE FROM student WHERE id = #{id}")
  @DeleteProvider(type = ReturnSql.class,method = "getDelete")
  public abstract Integer delete(Integer id);
  

  ---

  推荐阅读：【JavaWEB】JavaScript基础

  你可能感兴趣的:(Java,WEB从入门到实战,java,后端,开发语言,MyBatis,mysql)

  • python连接elasticsearch实战（附完整代码） 当初 pythonelasticsearch
    python连接elasticsearchfromelasticsearchimportElasticsearchfromelasticsearch.helpersimportscanES_HOSTS=[{'host':'','port':9200,'scheme':'http'}]es=Elasticsearch(hosts=ES_HOSTS,basic_auth=('账号','密码'))#检查
  • Ruby转Go语言：实现高效后端开发 BugTO rubygolang前端后端
    在现代软件开发中，选择合适的编程语言对于构建高效的后端系统至关重要。Ruby和Go语言都是备受开发者青睐的语言之一。然而，随着项目的发展和规模的增长，将Ruby代码迁移到Go语言成为了一个常见的需求。本文将探讨从Ruby迁移到Go语言的过程，并提供一些实用的源代码示例。了解Go语言Go语言是由Google开发的一种静态类型、编译型语言。它具有简洁、高效和并发性强的特点，适合构建高性能的后端系统。在
  • Java 9 Optional新特性深度剖析与实例应用 2501_90323865 pythonwindows开发语言个人开发
    在Java编程的漫长旅程中，Optional类一直是处理可选值的得力助手。Java9对其进行了重要扩展，引入了诸多新方法，让Optional的使用更加灵活高效。本文将深入剖析这些新特性，并结合实例进行详细解读。ifPresentOrElse(Consumer,Runnable)方法介绍ifPresentOrElse(Consumer,Runnable)方法是Java9为Optional新增的。当O
  • 如何优化项目预算编制？关键步骤解析 项目管理项目管理工具项目资金
    在项目管理中，资金管理是确保项目顺利进行的关键因素之一。项目资金管理的主要办法和原则包括：预算编制、资金使用监控、风险控制、财务透明度、及时报告和审计。其中，预算编制是项目资金管理的基础，它涉及到对项目所需资金的合理预测和分配。有效的预算编制不仅能帮助项目团队合理配置资源，还能为项目的成功实施提供保障。一、预算编制的重要性预算编制是项目资金管理的首要步骤，它直接影响到项目的整体执行和结果。一个合理
  • 项目范围管理的最佳实践：避免软件项目膨胀 项目管理软件
    在软件项目管理中，有效的项目范围管理是防止项目过度膨胀的关键。项目范围管理不仅涉及到项目的初步定义，还包括对项目需求的持续监控和控制。通过明确项目目标、合理规划资源、及时调整需求，可以有效避免项目在实施过程中出现范围蔓延的现象。特别是在软件开发中，需求的不断变化和增加往往会导致项目延期和成本超支。因此，建立清晰的项目范围界限、与利益相关者保持良好的沟通、定期进行项目审查是确保项目成功的必要措施。一
  • 2024金三银四必备：Java后端开发面试总结【25个技术专题】 2401_89790869 java面试开发语言
    16、List和Map、Set的区别？17、数组和链表分别比较适合用于什么场景，为什么？18、说说ConcurrentHashMap19、Java中ArrayList和LinkedList区别？20、TreeMap（可排序）21、请用两个队列模拟堆栈结构？22、Map中的key和value可以为null？23、数据结构基础之双向链表24、HashMap的底层实现25、ConcurrentHashM
  • HTML期末学生大作业-最新QQ音乐、网易云音乐、酷狗音乐、虾米音乐、咪咕音乐网站html+css+javascript 2401_89790869 html课程设计css
    href=“https://y.qq.com/n/ryqq/playlist/7772849553”>好评999+英文歌！轻松解压100％播放量：2.8亿扎心情歌丨爱到最后终是空欢喜播放量：510.4万如果词不达意就把爱藏心里播放量：1645.7万深情片段：深夜我还是会想起你播放量：2663.8万href=“https://y.qq.com/n/ryqq/playlist/7537828
  • Hana 到 PostgreSQL 数据迁移同步
    简述SAPHana与PostgreSQL已成为许多企业常用的两款重要数据库，实现这两者之间高效稳定的数据传输也是许多企业的诉求之一。本文将介绍如何使用国产数据迁移同步工具CloudCanal构建一条Hana到PostgreSQL的数据同步链路。技术点表级别CDC表CloudCanal在实现Hana源端增量同步时，最初采用的是单CDC表的模式，即所有订阅表的增量数据（插入、更新、删除）通过触发器统一
  • ReactNative进阶（三十五）：应用脚手架 Yo 构建 RN 页面_reactnative 脚手架 2401_84438654 程序员reactnativearcgisreact.js
    算法冒泡排序选择排序快速排序二叉树查找:最大值、最小值、固定值二叉树遍历二叉树的最大深度给予链表中的任一节点，把它删除掉链表倒叙如何判断一个单链表有环由于篇幅限制小编，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！如果你觉得对你有帮助，可以戳这里获取：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】sudo
  • web前端常见的面试题总结 2401_84436095 程序员前端
    script.src=url+‘?’+data+‘callback=’+funcNamedocument.body.appendChild(script);//这里得到请求的数据，在回调函数中执行处理window[funcName]=function(data){callback(data)}}//使用jsonp(‘http:127.0.0.1:3000/api’,{},function(res)
  • 小白WEB前端学习（五） Sun ᥫᩣ涵 WEB前端前端学习
    续：小白WEB前端学习（四）继续正式学习CSS（三）6.float布局！主要用于左右做图片，右文字的题目标准流标准流也叫文档流，指的是标签在页面中默认的排布规则，使⼀个元素脱离标准文档流有三种方式1.浮动2.绝对定位3.固定定位例如:块元素独占一行，行内元素可以一行显示多个。浮动作用：让块元素水平排列属性名：float属性值：left和right浮动后会脱离标准流，等于开了一个新的页面，内容在的话
  • 用JavaScript实现找不同小游戏 算是难了 javascript开发语言前端websocket
    目录倒计时的实现找不同实现对canvas的初始化实现画布的分割,父盒子>子盒子>canvas找不同逻辑的判断实现图片的导入DOM节点的监听声明两个需要监听的节点禁用页面点击事件的函数DOM监听实现勋章分数增加和生命的减少减命逻辑死亡响应websocket交互定义给后端发送的数据包断线重连最后,调用封装好的websocket创建初始之物，其行必丑代码写的非常繁琐,有很多细节在复盘的时候也会想不起来为
  • 深入理解GPT底层原理--从n-gram到RNN到LSTM/GRU到Transformer/GPT的进化 网络安全研发随想 rnngptlstm
    从简单的RNN到复杂的LSTM/GRU,再到引入注意力机制,研究者们一直在努力解决序列建模的核心问题。每一步的进展都为下一步的突破奠定了基础,最终孕育出了革命性的Transformer架构和GPT大模型。1.从n-gram到循环神经网络(RNN)的诞生1.1N-gram模型在深度学习兴起之前,处理序列数据主要依靠统计方法,如n-gram模型。N-gram是一种基于统计的语言模型,它的核心思想是:一
  • C++: Dtrees:load(constg String& filepath, const String& nodeName)中nodeName参数含义 湫兮之风 c++c++开发语言算法
    1.nodeName的作用当你保存模型时，整个决策树会被序列化到一个XML或YAML文件中。nodeName是加载时指定的一个逻辑路径，用于从文件中找到某个节点或子结构，而不是存储在文件中的字段。如果你不指定nodeName，OpenCV默认会尝试加载文件中根节点对应的模型。2.默认的行为如果你不指定nodeName，通常会加载文件的根节点：Ptrtree=cv::ml::DTrees::load
  • Ruby语言的软件开发工具 2501_90183952 包罗万象golang开发语言后端
    Ruby语言的软件开发工具概述引言Ruby是一种高效、灵活的动态编程语言，因其简洁的语法和强大的功能而受到开发者的欢迎。在软件开发过程中，使用合适的开发工具可以大幅提高工作效率，提升代码质量。本文将详细介绍一些常用的Ruby开发工具，从代码编辑器到版本控制，再到测试工具，深入探讨它们的功能及使用方法。1.Ruby语言简介Ruby语言由松本行弘（YukihiroMatsumoto）于1995年首次发
  • 前端如何实现分页 忆宸_1 js前端js
    前言虽然在实际开发中，大多数分页都是由后端处理，但还是有小部分场景需要前端来实现分页。实现并不难，仅作为记录，方便下次拿来直接使用。准备数据源数据源可以是从后端获取的数据列表，也可以是前端模拟的数据集。将数据源格式处理成数组即可。//模拟50条数据constlist=Array.from({length:50},(_,index)=>`Item${index+1}`);计算总页数计算总页数需要知道
  • 零基础小白学习网络安全的必备指南！ Stanford_1106 学习网络运维网络微信开放平台微信小程序微信公众平台twitterweb安全安全
    成长路上不孤单【14后///计算机爱好者///持续分享所学///如有需要欢迎收藏转发///】今日分享关于网络安全方面的相关内容！关于【网络安全】目录：一、了解网络安全基础知识二、学习计算机和网络基础知识三、掌握网络安全技术四、使用网络安全工具五、实战操作六、了解法律法规与职业道德七、持续学习与提升网络安全对于现代社会的重要性不言而喻，它关乎到个人信息安全、企业机密保护乃至国家安全。然而，对于许多零
  • Java工程结构：服务器规约（JVM 碰到 OOM 场景时输出 dump 信息、设置tomcat的 JVM 的内存参数、了解服务平均耗时） iOS逆向 Java开发的深入浅出java服务器开发语言
    文章目录I调用远程操作必须有超时设置。II推荐了解每个服务大致的平均耗时JVM的Xms和Xmx设置一样大小的内存容量让JVM碰到OOM场景时输出dump信息调大服务器所支持的最大文件句柄数（FileDescriptor，简写为fd）高并发服务器建议调小TCP协议的time_wait超时时间。III设置tomcat的JVM的内存参数查找Tomcat位置：快速定位服务状态和部署位置具体配置步骤查看JV
  • 策略模式和职责链模式实现坦克大战 科学的发展-只不过是读大自然写的代码 设计模式-坦克大战-java策略模式
    目录：一个实例讲完23种设计模式当前：策略模式职责链观察者上一篇《命令模式坦克大战简单实现(java实现)》需求：坦克大战创建两种坦克坦克类型射程速度b7070米时/70公里b5050米时/70公里简单说明一下：这任然用坦克大战的需求，实现了如下3种模式策略职责链观察者（这里的观察者就一个，没有体现被观察者和观察者1对多的关系，但是观察者的价值在于被观察者发现自己有变化的时候，对观察者自动的通知，
  • Redis实战之Jedis使用技巧详解 小马不敲代码 实战redis缓存
    一、前言基于redis开放的通信协议，大神们纷纷开发了各种语言的redis客户端，有c、c++、java、python、php、nodeJs等等开发语言的客户端，准确来说其实这些客户端都是基于redis命令做了一层封装，然后打包成工具以便大家更佳方便的操作redis，以Java项目为例，使用最广的就是以下三种客户端：JedisLettuceRedisson二、JedisJedis是老牌的Redis
  • 深入探索C#中Newtonsoft.Json库的高级进阶之路 步、步、为营 c#jsonphp
    引言在C#开发的广袤天地中，数据的序列化与反序列化是构建高效、灵活应用程序的关键环节。而Newtonsoft.Json库，作为这一领域的璀璨明星，以其强大的功能和出色的性能，成为了众多开发者的首选工具。它不仅仅是一个简单的JSON处理库，更是一把能够解锁复杂数据处理场景的万能钥匙。无论是在构建WebAPI时，需要将服务器端的对象快速转换为JSON格式，以便在网络中传输；还是在处理复杂的配置文件，需
  • python selenium安装步骤_Python：Selenium+Webdriver安装 weixin_39619893 pythonselenium安装步骤
    本人小白一枚，今天在使用selenium+webdriver的时候遇到了一个小问题：WebDriverException:'chromedriver'executableneedstobeinPATH.Pleaseseehttps://sites.google.com/a/chromium.org/chromedriver/home在debug过程中，也去baidu上查询了，很多说法，但是有些是行
  • python selenium canvas_selenium webdriver 实现Canvas画布自动化测试 我不勇敢 pythonseleniumcanvas
    https://blog.csdn.net/xiaoguanyusb/article/details/80324210由借鉴意义,转过来canvas是一个画布，定位元素时只能定位到画布上，如下乳所示，网页上有一张类似于下图的eChart报表图片。selenium的基本定位方式只能定位到该画布上，画布上的子元素通过selenium的基础定位方式是定位不到的，此时就需要使用selenium的js注入的
  • n8n 全面实战指南：从零开始构建强大的自动化工作流 ivwdcwso 运维开发自动化运维开发
    1.引言在当今快节奏的数字世界中,自动化已成为提高效率和减少重复工作的关键。n8n作为一款强大的开源工作流自动化工具,为开发者和业务用户alike提供了一个灵活的平台,用于连接各种应用和服务,创建复杂的自动化流程。本文将带您深入了解n8n,从基础安装到高级应用,全面掌握这个强大工具的使用方法。©ivwdcwso(ID:u012172506)2.n8n基础n8n(发音为“n-eight-n”)是一个
  • 【转】ASP.NET Core 实战：基于 Jwt Token 的权限控制全揭露 GoToDinner core
    【转】https://www.cnblogs.com/danvic712/p/10331976.html?tdsourcetag=s_pcqq_aiomsgASP.NETCore实战：基于JwtToken的权限控制全揭露一、前言#在涉及到后端项目的开发中，如何实现对于用户权限的管控是需要我们首先考虑的，在实际开发过程中，我们可能会运用一些已经成熟的解决方案帮助我们实现这一功能，而在Grapefru
  • 【Spring】Spring DI(依赖注入)详解——注入参数的细节处理-内部Bean的注入 AI人H哥会Java JAVAjava开发语言spring后端
    引言在现代Java开发中，Spring框架已经成为了构建企业级应用的标准工具之一。Spring的核心特性之一就是依赖注入（DependencyInjection，DI），它通过将对象的依赖关系从代码中解耦出来，提升了代码的可维护性和可测试性。特别是在大型项目中，良好的依赖管理能够显著降低代码的复杂度，提高开发效率。依赖注入的基本概念依赖注入是一种设计模式，用于实现控制反转（InversionofC
  • arcgis for JavaScript入门篇 五彩斑斓黑123 arcgisforjavascriptarcgisjavascript开发语言
    介绍ArcGISforJavaScript是一种基于Web的地图开发解决方案，由ESRI公司开发。它允许开发人员在Web应用程序中嵌入交互式地图，并使用JavaScript编写地图应用程序。ArcGISforJavaScript提供了许多功能强大的API和工具，使开发人员能够创建高度定制的地图应用程序。它支持各种地图数据源，包括ESRI的ArcGISOnline服务、第三方地图服务、以及开发人员自
  • JSONObject解析数据库Date类型报错问题 知忆_IS 数据库javadatabasepostgresql
    JSONObject解析数据库Date类型报错问题最近项目在写服务器后端查询空间数据的接口时，由于表结构不一致，直接写了一个通用函数用json储存数据库中查询的结果，然而今天前端查询一个表的时候无法查到相应的结果，查了一下代码发现爆了如下错误。报错：Causedby:java.lang.IllegalArgumentExceptionatjava.sql.Date.getHours原因是该表中存在
  • 使用VUE的axios解决调用百度地图api的跨域访问问题 知忆_IS vuehtmlnpmjavascriptchrome
    在构建一个vue前后端分离的项目时候，需要用到百度地图提供的web服务，但是在使用axios方式发送get请求的时候，web页面不显示相应结果，在Google中按F12进入开发者模式之后，发现提示如下：XMLHttpRequestcannotloadOriginhttp://localhost:8080isnotallowedbyAccess-Control-Allow-Origin.根据网上的搜
  • embed版Python如何安装第三方包 peanutwang python开发语言
    embed版本相当于一个纯Python运行环境，解压之后在命令行就可以Python.exexxx.py。但是涉及到使用第三方包的情况，还是需要安装的。以下是安装方法（整个过程无需配置环境变量）：1.解压python-3.8.10-embed-amd642.配置包导入搜索路径默认的包导入搜索路径由根目录内pythonXX._pth，打开它把它前面的#注释去掉#importsite3.配置pip国内源
  • 设计模式介绍 tntxia 设计模式
    设计模式来源于土木工程师 克里斯托弗 亚历山大（http://en.wikipedia.org/wiki/Christopher_Alexander）的早期作品。他经常发表一些作品，内容是总结他在解决设计问题方面的经验，以及这些知识与城市和建筑模式之间有何关联。有一天，亚历山大突然发现，重复使用这些模式可以让某些设计构造取得我们期望的最佳效果。 亚历山大与萨拉-石川佳纯和穆雷 西乐弗斯坦合作
  • android高级组件使用(一) 百合不是茶 androidRatingBarSpinner
    1、自动完成文本框（AutoCompleteTextView） AutoCompleteTextView从EditText派生出来，实际上也是一个文本编辑框，但它比普通编辑框多一个功能：当用户输入一个字符后，自动完成文本框会显示一个下拉菜单，供用户从中选择，当用户选择某个菜单项之后，AutoCompleteTextView按用户选择自动填写该文本框。 使用AutoCompleteTex
  • [网络与通讯]路由器市场大有潜力可挖掘 comsci 网络
              如果国内的电子厂商和计算机设备厂商觉得手机市场已经有点饱和了,那么可以考虑一下交换机和路由器市场的进入问题.....        这方面的技术和知识,目前处在一个开放型的状态,有利于各类小型电子企业进入  &nbs
  • 自写简单Redis内存统计shell 商人shang Linux shell统计Redis内存
    #!/bin/bash address="192.168.150.128:6666,192.168.150.128:6666" hosts=(${address//,/ }) sfile="staticts.log" for hostitem in ${hosts[@]} do ipport=(${hostitem
  • 单例模式(饿汉 vs懒汉) oloz 单例模式
    package 单例模式; /* * 应用场景:保证在整个应用之中某个对象的实例只有一个 * 单例模式种的《 懒汉模式》 * */ public class Singleton { //01 将构造方法私有化，外界就无法用new Singleton()的方式获得实例 private Singleton(){}; //02 申明类得唯一实例 priva
  • springMvc json支持 杨白白 json springmvc
    1.Spring mvc处理json需要使用jackson的类库，因此需要先引入jackson包 2在spring mvc中解析输入为json格式的数据:使用@RequestBody来设置输入 @RequestMapping("helloJson") public @ResponseBody JsonTest helloJson() {
  • android播放，掃描添加本地音頻文件 小桔子
            最近幾乎沒有什麽事情，繼續鼓搗我的小東西。想在項目中加入一個簡易的音樂播放器功能，就像華為p6桌面上那麼大小的音樂播放器。用過天天動聽或者QQ音樂播放器的人都知道，可已通過本地掃描添加歌曲。不知道他們是怎麼實現的，我覺得應該掃描設備上的所有文件，過濾出音頻文件，每個文件實例化為一個實體，記錄文件名、路徑、歌手、類型、大小等信息。具體算法思想，
  • oracle常用命令 aichenglong oracledba常用命令
    1 创建临时表空间 create temporary tablespace user_temp  tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf' size 50m  autoextend on  next 50m maxsize 20480m  extent management local
  • 25个Eclipse插件 AILIKES eclipse插件
    提高代码质量的插件1. FindBugsFindBugs可以帮你找到Java代码中的bug，它使用Lesser GNU Public License的自由软件许可。2. CheckstyleCheckstyle插件可以集成到Eclipse IDE中去，能确保Java代码遵循标准代码样式。3. ECLemmaECLemma是一款拥有Eclipse Public License许可的免费工具，它提供了
  • Spring MVC拦截器+注解方式实现防止表单重复提交 baalwolf spring mvc
    原理：在新建页面中Session保存token随机码，当保存时验证，通过后删除，当再次点击保存时由于服务器端的Session中已经不存在了，所有无法验证通过。   1.新建注解：   ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
  • 《Javascript高级程序设计(第3版)》闭包理解 bijian1013 JavaScript
    “闭包是指有权访问另一个函数作用域中的变量的函数。”--《Javascript高级程序设计(第3版)》         看以下代码： <script type="text/javascript"> function outer() { var i = 10; return f
  • AngularJS Module类的方法 bijian1013 JavaScriptAngularJSModule
            AngularJS中的Module类负责定义应用如何启动，它还可以通过声明的方式定义应用中的各个片段。我们来看看它是如何实现这些功能的。 一.Main方法在哪里         如果你是从Java或者Python编程语言转过来的，那么你可能很想知道AngularJS里面的main方法在哪里？这个把所
  • [Maven学习笔记七]Maven插件和目标 bit1129 maven插件
    插件(plugin)和目标(goal) Maven，就其本质而言，是一个插件执行框架，Maven的每个目标的执行逻辑都是由插件来完成的，一个插件可以有1个或者几个目标，比如maven-compiler-plugin插件包含compile和testCompile，即maven-compiler-plugin提供了源代码编译和测试源代码编译的两个目标   使用插件和目标使得我们可以干预
  • 【Hadoop八】Yarn的资源调度策略 bit1129 hadoop
    1. Hadoop的三种调度策略 Hadoop提供了3中作业调用的策略， FIFO Scheduler Fair Scheduler Capacity Scheduler 以上三种调度算法，在Hadoop MR1中就引入了，在Yarn中对它们进行了改进和完善.Fair和Capacity Scheduler用于多用户共享的资源调度   2. 多用户资源共享的调度
  • Nginx使用Linux内存加速静态文件访问 ronin47
    Nginx是一个非常出色的静态资源web服务器。如果你嫌它还不够快，可以把放在磁盘中的文件，映射到内存中，减少高并发下的磁盘IO。 先做几个假设。nginx.conf中所配置站点的路径是/home/wwwroot/res，站点所对应文件原始存储路径：/opt/web/res shell脚本非常简单，思路就是拷贝资源文件到内存中，然后在把网站的静态文件链接指向到内存中即可。具体如下：
  • 关于Unity3D中的Shader的知识 brotherlamp unityunity资料unity教程unity视频unity自学
    首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，然后我们来看下Unity3D自带的60多个S
  • CopyOnWriteArrayList vs ArrayList bylijinnan java
    package com.ljn.base; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; /** * 总述： * 1.ArrayListi不是线程安全的，CopyO
  • 内存中栈和堆的区别 chicony 内存
    1、内存分配方面：     堆：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。     栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中
  • 回答一位网友对Scala的提问 chenchao051 scalamap
    本来准备在私信里直接回复了，但是发现不太方便，就简要回答在这里。 问题 写道 对于scala的简洁十分佩服，但又觉得比较晦涩，例如一例，Map("a" -> List(11,111)).flatMap(_._2)，可否说下最后那个函数做了什么，真正在开发的时候也会如此简洁？谢谢    先回答一点，在实际使用中，Scala毫无疑问就是这么简单。
  • mysql 取每组前几条记录 daizj mysql分组最大值最小值每组三条记录
    一、对分组的记录取前N条记录：例如：取每组的前3条最大的记录 1.用子查询： SELECT * FROM tableName a  WHERE 3> (SELECT COUNT(*) FROM  tableName b WHERE b.id=a.id AND b.cnt>a. cnt) ORDER BY a.id,a.account DE
  • HTTP深入浅出 http请求 dcj3sjt126com http
      HTTP(HyperText Transfer Protocol)是一套计算机通过网络进行通信的规则。计算机专家设计出HTTP，使HTTP客户（如Web浏览器）能够从HTTP服务器(Web服务器)请求信息和服务，HTTP目前协议的版本是1.1.HTTP是一种无状态的协议，无状态是指Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后We
  • 判断MySQL记录是否存在方法比较 dcj3sjt126com mysql
    把数据写入到数据库的时，常常会碰到先要检测要插入的记录是否存在，然后决定是否要写入。 　　我这里总结了判断记录是否存在的常用方法： 　　sql语句： select   count ( * )  from  tablename; 　　然后读取count(*)的值判断记录是否存在。对于这种方法性能上有些浪费，我们只是想判断记录记录是否存在，没有必要全部都查出来。
  • 对HTML XML的一点认识 e200702084 htmlxml
    感谢http://www.w3school.com.cn提供的资料 HTML 文档中的每个成分都是一个节点。 节点 根据 DOM，HTML 文档中的每个成分都是一个节点。 DOM 是这样规定的： 整个文档是一个文档节点 每个 HTML 标签是一个元素节点 包含在 HTML 元素中的文本是文本节点 每一个 HTML 属性是一个属性节点 注释属于注释节点 Node 层次
  • jquery分页插件 genaiwei jqueryWeb前端分页插件
    //jquery页码控件// 创建一个闭包    (function($) {      // 插件的定义      $.fn.pageTool = function(options) {        var totalPa
  • Mybatis与Ibatis对照入门于学习 Josh_Persistence mybatisibatis区别联系
    一、为什么使用IBatis/Mybatis         对于从事 Java EE 的开发人员来说，iBatis 是一个再熟悉不过的持久层框架了，在 Hibernate、JPA 这样的一站式对象 / 关系映射（O/R Mapping）解决方案盛行之前，iBaits 基本是持久层框架的不二选择。即使在持久层框架层出不穷的今天，iBatis 凭借着易学易用、
  • C中怎样合理决定使用那种整数类型？ 秋风扫落叶 c数据类型
    如果需要大数值(大于32767或小于32767), 使用long 型。 否则, 如果空间很重要 (如有大数组或很多结构), 使用 short 型。 除此之外, 就使用 int 型。 如果严格定义的溢出特征很重要而负值无关紧要, 或者你希望在操作二进制位和字节时避免符号扩展的问题, 请使用对应的无符号类型。 但是, 要注意在表达式中混用有符号和无符号值的情况。    &nbs
  • maven问题 zhb8015 maven问题
      问题1： Eclipse 中 新建maven项目 无法添加src/main/java 问题    eclipse创建maevn web项目，在选择maven_archetype_web原型后，默认只有src/main/resources这个Source Floder。     按照maven目录结构，添加src/main/ja
  • (二)androidpn-server tomcat版源码解析之--push消息处理 spjich javaandrodipn推送
    在 (一)androidpn-server tomcat版源码解析之--项目启动这篇中，已经描述了整个推送服务器的启动过程，并且把握到了消息的入口即XmppIoHandler这个类，今天我将继续往下分析下面的核心代码，主要分为3大块，链接创建，消息的发送，链接关闭。 先贴一段XmppIoHandler的部分代码 /** * Invoked from an I/O proc
  • 用js中的formData类型解决ajax提交表单时文件不能被serialize方法序列化的问题 中华好儿孙 JavaScriptAjaxWeb上传文件FormData
    var formData = new FormData($("#inputFileForm")[0]); $.ajax({ type:'post', url:webRoot+"/electronicContractUrl/webapp/uploadfile", data:formData, async: false, ca
  • mybatis常用jdbcType数据类型 ysj5125094 mybatismapperjdbcType
      MyBatis 通过包含的jdbcType 类型 BIT         FLOAT      CHAR          
  按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
  首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

  版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.