MyBatis持久层框架

MyBatis

✨✨✨✨✨✨✨✨✨✨✨✨✨✨

1. 简介

（1）简介

什么是MyBatis？

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

为什么需要MyBatis？

• Mybatis就是帮助我们将数据存入数据库中，和从数据库中取数据。
• 传统的jdbc操作，有很多重复代码块 。比如 : 数据取出时的封装 , 数据库的建立连接等等… , 通过框架可以减少重复代码,提高开发效率。
• MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射。
• 所有的事情，不用Mybatis依旧可以做到，只是用了它，所有实现会更加简单！

MyBatis的优点:

• 简单易学。
  • 本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件就可以。
• 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。
  • sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
• 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离。
  • 使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
• 提供xml标签，支持编写动态sql。

什么是持久化？

• 持久化是将程序数据在持久状态和瞬时状态间转换的机制。
• 即把内存中的数据保存到可永久保存的存储设备中（如磁盘）。
• JDBC就是一种持久化机制。文件IO也是一种持久化机制。
• 为什么需要持久化服务呢？那是由于内存本身的缺陷引起的
  • 内存断电后数据会丢失。
  • 内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。

Hibernate 简介

• 数据库交互框架（ORM框架）。ORM—> Object Relation Mapping 对象关系映射。黑箱操作，不需写SQL。
• Hibernate 缺点：
  • 不能自己写SQL。
  • 全映射框架，做部分字段映射很难。

---

MyBatis将SQL写在配置文件中。

即：

1. MyBatis将重要步骤抽取出来，可以定制，其他步骤自动化，
2. 重要的步骤都写在配置文件中（易于修改）
3. 完全解决数据库优化的问题
4. MyBatis底层就是对原生JDBC的一个简单封装。
5. 半持久化框架。既将java编码与SQL抽取分离，还不会失去自动化功能。
6. MyBatis是一个轻量级框架

SQL和java分开，功能边界清晰，一个专注于数据，一个专注于业务。

（2）环境

1. 数据库驱动：mysql-connector-java

2. MyBatis包：org.mybatis

3. 日志包（非必需）：在关键环节就会有日志打印。：log4j

   1. 这个日志框架依赖一个 log4j.xml 的配置文件。 （放在类路径下）

 
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

 <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
   <param name="Encoding" value="UTF-8" />
   <layout class="org.apache.log4j.PatternLayout">
    <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m  (%F:%L) \n" />
   layout>
 appender>
 <logger name="java.sql">
   <level value="debug" />
 logger>
 <logger name="org.apache.ibatis">
   <level value="info" />
 logger>
 <root>
   <level value="debug" />
   <appender-ref ref="STDOUT" />
 root>
log4j:configuration>

        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.5.6version>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.47version>
        dependency>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>

        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.17version>
        dependency>

2. HelloWorld

（1）环境搭建

• 创建java工程

• 创建测试数据库

  1. 创建表。JavaBean，操作数据库的dao接口

（2）MyBatis操作数据库的一般步骤

1. 导包
2. 写配置
3. 写测试

配置文件：两个

1. 全局配置文件：指导MyBatis如何正确运行，例如：连接哪个数据库
   1. 在 下配置环境 。环境可以配置多个。
   2. 配置基本属性。

<configuration>
    
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            

            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_test?serverTimezone=UTC&rewriteBatchedStatements=true"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            dataSource>
        environment>
    environments>
    <mappers>
        <mapper resource="lu/dao/EmpDao.xml"/>
    mappers>
configuration>

2. SQL映射文件：每一个方法都如何想数据库发送SQL语句，如何执行等。
   1. 将namespace为接口的全类名。相当于告诉MyBatis这个配置文件是实现哪个接口的
   2. 使用 标签定义一个查询操作
      1. id：Dao接口中的方法名
      2. resultType：指定方法运行后的返回值类型（查询操作必须指定）
      3. 在SQL语句中可以使用#{id} 取值。取的是方法传过来的参数。

      
      
      
      
      <mapper namespace="lu.dao.EmpDao">
      
          <select id="getEmpById" resultType="lu.pojo.Emp">
          select * from emp where id = #{id}
        select>
      mapper>
      

      3. 我们写的dao接口的实现文件，MyBatis默认是不知道的，需要在全局配置文件中注册。使用标签

         <mappers>
              <mapper resource="lu/dao/EmpDao.xml"/>
          mappers>
      

      从 XML 中构建 SqlSessionFactory，SqlSessionFactory构建SqlSession（SQL会话，SqlSession是跟数据库的一次会话，就相当于是一个Connection）。

      String resource = "org/mybatis/example/mybatis-config.xml";
      InputStream inputStream = Resources.getResourceAsStream(resource);
      sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
      

      测试：

      1. 根据全局配置文件先创建一个：SqlSessionFactory
      2. 从SqlSessionFactory中获取SqlSession对象来操作数据库
      3. 用SqlSession拿到dao接口的实现
      4. 使用dao接口的实现去调用方法，去查询。

      import lu.dao.EmpDao;
      import lu.pojo.Emp;
      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;
      
      /**
       * @author 满眼星河
       * @create 2020-11-25-9:05
       */
      public class MyTest {
      
          @Test
          public void test01() throws IOException
          {
              //1. 根据全局配置文件构建出一个SQLSessionFactory
      
              /**
               * SqlSessionFactory是SqlSession工厂，负责创建SqlSession对象。
               *
               * SqlSession：代表和数据库的一次会话。
               */
              String resource = "mybatis-config.xml";
              InputStream inputStream = Resources.getResourceAsStream(resource);
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
      
              SqlSession sqlSession=null;
              Emp emp=null;
              try{
                  //2. 获取和数据库的一次会话，相当于getConnection()。拿到连接
                  sqlSession = sqlSessionFactory.openSession();
      
                  //3. 使用SQLSession操作数据库，获取到dao接口的实现。（相当于获取EmpDao.xml）
                  EmpDao empDao = sqlSession.getMapper(EmpDao.class);
      
                  //4. 调用dao接口的方法去查询即可
                   emp = empDao.getEmpById(1);
              }
              catch (Exception e)
              {
                  e.printStackTrace();
              }
              finally
              {
                  sqlSession.close();
              }
      
              System.out.println(emp);
          }
      }
      
      

      配置文件的约束文件：dtd是约束文件，

      http://mybatis.org/dtd/mybatis-3-config.dtd
      

      MyBatis中的增删改不会自动提交。

      1. 解决方案一：需要手动提交。

      sqlSession.commit();
      

      2. 解决方案二：在获取sqlsession时传入true参数，表示设置为自动提交。

      SqlSession sqlSession = sqlSessionFactory.openSession(true);
      

      3. MyBatis全局配置文件

      （1）两个文件：

      1. 一个是全局配置文件：mybatis-config.xml
         1. 指导MyBatis正确运行的一些全局配置文件。
      2. SQL映射文件：EmpDao.xml
         1. 相当于是对EmpDao接口的实现。

              //class com.sun.proxy.$Proxy6
              EmpDao empDao = sqlSession.getMapper(EmpDao.class);
              System.out.println(empDao.getClass());
      

      EmpDao是一个代理对象，MyBatis自动为其创建一个代理对象。

      HelloWorld细节：

      1. 获取到的是接口的代理对象。
      2. SqlSessionFactory和SqlSession
         1. SqlSessionFactory是创建SqlSession的工厂。
         2. SqlSession：相当于Connection。和数据库的一次会话。

      （2）全局配置文件：

      
      
      
      
      <configuration>
          
          <environments default="development">
              <environment id="development">
                  <transactionManager type="JDBC"/>
                  
      
                  <dataSource type="POOLED">
                      <property name="driver" value="com.mysql.jdbc.Driver"/>
                      <property name="url" value="jdbc:mysql://localhost:3306/mybatis_test?serverTimezone=UTC&rewriteBatchedStatements=true"/>
                      <property name="username" value="root"/>
                      <property name="password" value="root"/>
                  dataSource>
              environment>
          environments>
          <mappers>
              <mapper resource="lu/dao/EmpDao.xml"/>
          mappers>
      
      configuration>
      

      配置文件中可以写如下配置：

      

      这些标签的编写都是有顺序的，而且必须遵守，否则报错。

      1. properties属性：引入外部资源文件。在下面可以使用${}获取值。

       
          
          <properties resource="dbconfig.properties">properties>
      
          <environments default="development">
              <environment id="development">
                  <transactionManager type="JDBC">transactionManager>
                  <dataSource type="POOLED">
                      <property name="driver" value="${driverclass}"/>
                      <property name="url" value="${jdbcurl}"/>
                      <property name="username" value="${username}"/>
                      <property name="password" value="${password}"/>
                  dataSource>
              environment>
          environments>
      

      2. setting设置：

         MyBatis中查询操作，会将查询结果自动封装为一个指定的对象（前提是要求数据库字段和pojo类的属性名一致）

         1. 如果不一致，我们以前采取的措施是在SQL语句中给相应字段起别名。
         2. 现在我们可以在MyBatis的配置文件中使用setting进行设置。数据库中的“-”连接命名转为java中的驼峰命名。
            1. emp_Name ----> empName
         3. 数据库不区分大小写。

         <settings>
                 <setting name="mapUnderscoreToCamelCase" value="true"/>
             settings>
         

      3. typeAliases属性：指定别名。指定之后就可以在Empdao的实现文件中使用。

         1. 是package批量指定别名，默认就是类名。
         2. 可以是java类上使用注解：@Alias(“Empss”)指定别名。
         3. 推荐不起别名，就使用全类名。

         
             <typeAliases>
                 <package name="lu.pojo" />
             typeAliases>
         

          <typeAliases>
      
              <typeAlias type="lu.pojo.Emp" alias="Emp"/>
          typeAliases>
      

      已经为许多常见的 Java 类型内建了相应的类型别名。它们都是大小写不敏感的，需要注意的是由基本类型名称重复导致的特殊处理。

      

      4. typeHandlers：类型处理器。

         1. 作用：无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。下表描述了一些默认的类型处理器。（部分）
         

      5. objectFactory：对象工厂。查询SQL的返回的对象。MyBatis底层利用objectFactory通过反射来给我们创建对象。

      6. plugins：插件。是MyBatis中的一个强大的功能。

         1. MyBatis通过四大对象来工作。
            1. Executor：执行器，执行CRUD操作。
            2. ParameterHandler：参数处理器，给预编译对象设置参数。
            3. ResultSetHandler：结果集处理器。负责将查询出来的结果集封装成对应的javaBean对象。
            4. StatementHandler：预编译参数。相当于原生的PreparedStatement。
         2. 插件通过动态代理机制，可以介入四大对象的任何一个方法的执行。

      7. environments：配置环境。可以配置多个环境，

         1. environment：配置一个具体的环境。（需要一个事务管理器和一个数据源）
            1. transactionManager
            2. dataSource
         2. id是一个环境的唯一辨识，要切换使用的环境，在中指定即可。
         3. 我们以后的数据源和事务管理都是spring来管理。

         <environment id="development">
                  <transactionManager type="JDBC">transactionManager>
                  <dataSource type="POOLED">
                      <property name="driver" value="${driverclass}"/>
                      <property name="url" value="${jdbcurl}"/>
                      <property name="username" value="${username}"/>
                      <property name="password" value="${password}"/>
                  dataSource>
              environment>
      

      8. databaseIdProvider：MyBatis用来做数据库移植性的。type="DB_VENDOR" 这是写死的。
         1. name：数据库厂商别名。
         2. value：给这个标识起个别名
            1. MySQL，SQL Server

      
          <databaseIdProvider type="DB_VENDOR">
              <property name="MySQL" value="mysql"/>
              <property name="SQL Server" value="sqlserver"/>
              <property name="Oracle" value="oracle"/>
          databaseIdProvider>
      

      精确匹配优先。

      
          <select id="getEmpById" resultType="Empss" databaseId="mysql">
              select * from emp where id = #{id}
          select>
      

      9. mapper标签：将写好的SQL映射文件需要使用mapper注册进来。
         1. resource：在类路径下找SQL映射文件
         2. class：直接引用接口的全类名。必须将SQL映射文件放在和接口同包下，而且必须同名。另外一种用法：使用注解开发
         3. url：从磁盘路径下，或者网络路径下引入

      
          <mappers>
      		<mapper resource="lu/dao/EmpDao.xml">mapper>
              <mapper class="lu.dao.EmpDaoAnnotation">mapper>
      		<mapper url="">mapper>
          mappers>
      

      批量注册：

      name写Dao接口所在的包名。

      注意：批量注册时，dao的实现文件（例如：EmpDao.xml）一定要放在和dao同包的路径下才能获取到。

      注解：

      ​ 使用@Select之类的注解

      public interface EmpDaoAnnotation {
      
          @Select("select * from emp where id = #{id}")
          Emp getEmpById(Integer id);
          
      }
      

      注解的形式只能使用class 注册。

          <mappers>
              <mapper class="lu.dao.EmpDaoAnnotation">mapper>
          mappers>
      

      注解和配置配合使用：

      • 重要的dao写配置。
      • 简单的dao就直接写注解。

      ---

      4. SQL映射文件

      （1）Dao映射文件中能写的标签：

      1. cache：缓存相关
      2. cache-ref：缓存相关
      3. delete，update，insert，select：和增删改查有关
      4. resultMap：结果映射，自定义结果集的封装映射规则。
      5. SQL：抽取可重用的SQL语句。

      select标签的属性

      

      id：指定方法。不能写重载方法。

      statementType：指定执行SQL语句的执行器类型。

      1. statement：相当于原生JDBC的statement
      2. prepareStatement：相当于原生JDBC的prepareStatement
      3. Callable：调用数据库的存储过程
      

      实现获取自增主键：

      
      
          <insert id="insertEmp" useGeneratedKeys="true" keyProperty="id">
              insert into Emp(name,deptId) values(#{name},#{deptId})
          insert>
      

      但是：有的数据库不支持自增主键。或者没有设置主键自增。

      在使用全字段更新时，如果插入的id已有，就会报错，为了解决这个问题，就可以使用 selectKey 先查询出最大的id再加一，赋值JavaBean给指定的属性。

      调用这个方法时，传入的Emp为：

      Emp emp = new Emp(null, "BBB", 2);
      int i = empdao.insertEmp(emp);
      

      <insert id="insertEmp">
      
              <selectKey order="BEFORE" resultType="integer" keyProperty="id">select Max(id)+1 from empselectKey>
      
              insert into Emp(id,name,deptId) values(#{id},#{name},#{deptId})
          insert>
      

      selectKey标签的属性。

      

      （2）查询

      传参到底能传什么？

      <select id="getEmpByIdAndName" resultType="nuc.pojo.Emp">
          select * from emp where id=#{id} and name=#{name}
      select>
      

      多个参数时，#{} 取不出来。报错如下：

      Cause: org.apache.ibatis.binding.BindingException: Parameter 'id' not found. Available parameters are [arg1, arg0, param1, param2]
      

      这样才是正确的：或者使用 param1, param2

      <select id="getEmpByIdAndName" resultType="nuc.pojo.Emp">
          select * from emp where id=#{arg0} and name=#{arg1}
      select>
      

      如果只有一个参数时，在SQL语句中取参数时，使用#{} ，大括号中无论写什么都能正确获取到参数。

      现象：

      1. 单个参数：

         1. 基本类型：
            1. 取值：#{随便写}
         2. 复杂类型：

      2. 多个参数：（推荐在方法命名时使用 @Param 命名参数）

         1. 取值：#{参数名}是无效的。只能使用#{param1……}

            1. 原因：只要传入的多个参数，MyBatis会自动将这些参数封装在一个Map中。使用的key就是参数的索引和第几个标识。
            2. 例：map.put(“param1”,传入的参数值)
            3. 所以：#{key} 就是去这个map中取值。

         2. 我们可以告诉MyBatis，封装map的时候，使用我们指定的key。使用 @Param 注解

            Emp getEmpByIdAndName(@Param("id") Integer id, @Param("name") String name);
            

         3. 所以，@Param 为参数指定key。命名参数。

      3. 传入pojo：

         1. 取值：#{pojo的属性名}

      4. 传入Map：可以直接传入一个Map，将要使用的参数封装起来。

         1. Emp getEmpByMap(Map<String,Object> map);
            

         2. 所以，#{}的本意就是去Map中取值。

      EmpDao接口：

      package nuc.inter;
      public interface EmpDao {
          Emp getEmpByMap(Map<String,Object> map);
      }
      

      EmpDao.xml实现文件：

      <select id="getEmpByMap" resultType="nuc.pojo.Emp">
          select * from emp where id=#{testId} and name=#{testName}
      select>
      

      传入Map作为参数的测试：

      @Test
      public void test01()
      {
          SqlSession sqlSession = sqlSessionFactory.openSession();
      
          EmpDao empdao = sqlSession.getMapper(EmpDao.class);
      
          Map<String, Object> map = new HashMap<>();
          map.put("testId",2);
          map.put("testName","李四");
      
      
          Emp emp = empdao.getEmpByMap(map);
          System.out.println(emp);
      }
      

      多个参数的情况下：MyBatis会自动封装Map。

      扩展：

      Dao接口中的方法：

      Emp method(@Param("id") Integer id, @Param("name") String name, @Param("emp") Emp emp);
      

      取值：

      #{id}
      #{name}
      #{emp.name}  取这个对象的name属性。
      

      传参推荐使用Map。

      在MyBatis中有两种取值方式：

      1. #{}：是参数预编译的方式，参数的位置都是？，参数后来都是预编译设置进去的。

      2. ${}：不是预编译方式，而是直接和SQL进行拼串。

         1. 使用场景：SQL语句只要参数位置是支持预编译的。可以动态传入表名。

         select * from ${tableName} where id=${testId} and name=#{testName}
         

         1. 一般都使用#{}，在不支持参数预编译的位置要使用${}。

      5. 查询的返回结果

      （1）查询多条记录，返回一个List

      List getAllEmp();
      

      • resultType：如果返回的是集合，这里写集合里面的元素的类型
      • MyBatis会自动给我们封装为一个List

      
          <select id="getAllEmp" resultType="nuc.pojo.Emp">
              select * from emp
          select>
      

      （2）查询单条记录，返回类型写Map

      • 列名作为key，值作为value

      Map<String,Object> getEmpByIdReturnMap(Integer id);
      

      

      （3）查询多条记录，封装为Map。

      • 在Dao接口的方法上使用注解：@MapKey(value="") 指定key
      • 多条记录时，select标签的返回值类型写Map中元素的类型。

      @MapKey("id")
      Map<Integer,Emp> getAllEmpReturnMap();
      

      <select id="getAllEmpReturnMap" resultType="nuc.pojo.Emp">
          select * from emp
      select>
      

      （4）自定义封装规则

      MyBatis默认自动封装结果集：

      • 按照列名和属性名一一对应的规则。（不区分大小写）

      • 如果不一一对应

        • 开启驼峰命名法。满足驼峰命名规则
          • 数据库中是：aaa_BBB
          • JavaBean中是：aaaBBB
        • 不满足驼峰命名规则，就起别名。
        • 自定义结果集：哪一列和那个JavaBean的属性对应，我们自己定义。

      • 自定义封装：

        • resultType：是使用默认规则，属性和列名一一对应。
        • resultMap：resultMap="myEmp" 查出数据封装结果的时候，使用myEmp自定义的规则封装 。
        • 使用 标签自定义封装规则：
          1. id属性：唯一标识，让别名在后面可以使用。
          2. type：指定为哪个JavaBean自定义封装规则。写JavaBean的全类名
          3. 再使用 标签指定主键的对应规则
             1. column：指定哪一列是主键列。
             2. property：指定JavaBean中哪个属性封装id这一列数据。
          4. 使用 标签定义普通列的对应规则。

      自定义结果集代码示例：

      
      <select id="getAllEmpReturnMap" resultMap="myEmp">
          select * from emp
      select>
          
          
          
      
          <resultMap id="myEmp" type="nuc.pojo.Emp">
      
              <id column="id" property="id">id>
      
              <result property="name" column="Cname">result>
          resultMap>
      

      6. 联合查询

      （1）如果JavaBean中还有一个JavaBean

      1. 创建数据库表，搭建环境。创建key表和lock表，一把钥匙只能开一个锁，所有在key表中建立外键，引用lock表中的数据。

      （2）代码实现：

      JavaBean—>Key类：

      package nuc.pojo;
      
      /**
       *  查询钥匙的时候，顺便将这把钥匙能开的锁也查出来，封装进lock对象中。
       */
      public class Key {
          private Integer id;
          private String keyName;
      
          /**
           * 表示当前这把钥匙能开哪个锁
           */
          private Lock lock;
          //省略getter、setter、toString
      }
      

      JavaBean—>Lock类：

      package nuc.pojo;
      
      public class Lock {
          private Integer id;
          private String LockName;
      	//省略getter、setter、toString
      }
      

      KeyDao接口：

      public interface KeyDao {
      
          /**
           * 将钥匙和锁的信息一起查询出来
           * @param id
           * @return
           */
          Key getKeyById(Integer id);
      }
      

      KeyDao.xml：

      • 使用“左外连接查询”

      • SELECT k.id kid,k.keyname,k.lockid,l.id lid,l.lockname FROM t_key k LEFT JOIN t_lock l ON k.`lockid`=l.`id` WHERE k.id=1;
        

      • 在多表查询时，结果中有两个字段是同名的，为了后面的查询操作方便封装，需要在SQL中起别名。

      • 在级联查询时，使用自定义封装：

        • 使用标签：
          • property：JavaBean中的属性
          • column：数据库表中的值

      
      
      <mapper namespace="nuc.inter.KeyDao">
      
          <select id="getKeyById" resultMap="myKey">
      
              SELECT k.id kid,k.keyname,k.lockid,l.id lid,l.lockname FROM t_key k
                  LEFT JOIN t_lock l ON k.`lockid`=l.`id`
                  WHERE k.id=#{id};
          select>
      
      
          <resultMap id="myKey" type="nuc.pojo.Key">
              <id property="id" column="id">id>
              <result property="keyName" column="keyname"/>
              <result property="lock.id" column="lid"/>
              <result property="lock.LockName" column="lockname"/>
          resultMap>
      
      mapper>
      

      上面使用的时级联赋值，MyBatis中推荐使用的是association 标签

      实例：

      1. 也是在resultMap标签中定义：
         1. association标签的属性：
            1. property：指定JavaBean中的那个属性。
            2. javaType；指定这个属性的类型。
         2. 然后，也是使用id标签和result标签对这个属性进行赋值。

      
          <resultMap id="myKey" type="nuc.pojo.Key">
              <id property="id" column="id">id>
              <result property="keyName" column="keyname"/>
      
      
              <association property="lock" javaType="nuc.pojo.Lock">
      
                  <id property="id" column="lid"/>
                  <result property="LockName" column="lockname"/>
              association>
          resultMap>
      

      （3）一个JavaBean中的属性是一个集合。

      

      需求：查锁子，也要查询出该锁子的所有钥匙：

      Lock类：

      public class Lock {
          private Integer id;
          private String LockName;
          /**
           * 查询锁子的时候，将该锁子的所有钥匙都查出来，放在这个List中
           */
          private List<Key> keys;
          //省略set，get方法
      }
      

      Key类：

      public class Key {
          private Integer id;
          private String keyName;
      
          /**
           * 表示当前这把钥匙能开哪个锁
           */
          private Lock lock;
           //省略set，get方法
      }
      

      LockDao接口：

      public interface LockDao {
      
          /**
           * 查询所有锁子，并将该锁子的所有钥匙都查出来
           */
          Lock getLockById(Integer id);
      }
      

      LockDao.xml：

      1. JavaBean中的属性是一个集合。
      2. 需要使用自定义封装规则，在 中使用 标签定义这个集合的封装规则。
         1. property：指定哪个属性是集合属性
         2. ofType：指定这个集合中元素的类型

      
      
      <mapper namespace="nuc.inter.LockDao">
      
          <select id="getLockById" resultMap="myLock">
              SELECT k.id kid,k.keyname,k.lockid,l.id lid,l.lockname
                 FROM t_key k
                 LEFT JOIN t_lock l ON k.`lockid`=l.`id`
                 WHERE l.id=#{id}
          select>
      
          <resultMap id="myLock" type="nuc.pojo.Lock">
              <id property="id" column="lid"/>
              <result property="LockName" column="lockname"/>
      
              <collection property="keys" ofType="nuc.pojo.Key">
                  <id property="id" column="kid"/>
                  <result property="keyName" column="keyname"/>
              collection>
          resultMap>
      
      mapper>
      

      SQL查询结果：

      

      ---

      扩展思考：

      1-1：一个key开一个lock

      1-n：一个lock有多个key

      n-n：一个老师教多个学生，一个学生又有多个老师

      问题：1-n，n-1，n-n：外键放在那个表中呢？

      • 1-n：外键放在n的那一段。
      • n-1：和1-n一样，只是反过来看。
      • n-n：建一个中间表来存储对应关系

      老师表：

      

      学生表：

      

      学生-老师关系表：

      

      7. 分步查询

      查钥匙的时候，顺便查出锁子

      写两个简单的select语句，先查询出钥匙，再根据查询结果中的lockid查询出对应的锁子。

      LockDao.xml中简单的select语句，根据id查询锁子。

      
      
      <mapper namespace="nuc.inter.LockDao">
      
          <select id="getLockByIdSimple" resultType="nuc.pojo.Lock">
              select * from t_lock where id=#{id}
          select>
      
      mapper>
      

      KeyDao.xml：

      1. 在这个简单查询中使用自定义封装规则。
      2. 在自定义封装中，使用association 标签说明这个属性是JavaBean，然后再使用select属性指定一个查询SQL，使用column给这个SQL传递参数。
      3. 可以看到过程是执行了两条SQL语句。
      

      
      
      <mapper namespace="nuc.inter.KeyDao">
      
          <select id="getKeyByIdSimple" resultMap="myKey02">
              select * from t_key where id=#{id}
          select>
      
          <resultMap id="myKey02" type="nuc.pojo.Key">
              <id property="id" column="id"/>
              <result property="keyName" column="keyname"/>
      
              <association property="lock" select="nuc.inter.LockDao.getLockByIdSimple" column="lockid"/>
          resultMap>
      mapper>
      

      需求：在如下的案例中

      • 需求中通常只需要查询key的名，lock只是偶尔会用到，但是MyBatis还是会每次都查询锁子，造成了浪费。

      • 解决：只需开启全局按需加载功能：

        • 在MyBatis的配置文件中设置：

        • 开启延迟加载功能：lazyLoadingEnabled 置为true。

        • 开启属性按需加载：aggressiveLazyLoading置为false

        •     <settings>
          
                  <setting name="lazyLoadingEnabled" value="true"/>
          
                  <setting name="aggressiveLazyLoading" value="false"/>
              settings>
          

      @Test
      public void test04()
      {
          SqlSession sqlSession = sqlSessionFactory.openSession();
      
          KeyDao keyDao = sqlSession.getMapper(KeyDao.class);
          Key key = keyDao.getKeyByIdSimple(1);
          //如果
          System.out.println(key.getKeyName());
      
          //解决数据库资源的浪费：按需加载--->需要的时候才去查询
          //只需开启全局按需加载功能
      
      }
      

      

      因为代码中只需要key的name，所有就只执行一条SQL，只查询key的信息。

      当需要查询lock的信息时，只管拿即可，MyBatis会自动去查询。

      ​ 例：给上述测试代码加上：System.out.println(key.getLock().getLockName()); ，之后，MyBatis就会执行两条SQL去查询出锁子的信息。

      

      设置了懒加载之后，也可以在resultMap的association标签中使用，fetchType属性开启立即加载。eager表示立即加载。写上之后，就会覆盖MyBatis的全局设置。

          <resultMap id="myKey02" type="nuc.pojo.Key">
              <id property="id" column="id"/>
              <result property="keyName" column="keyname"/>
      
              <association property="lock" select="nuc.inter.LockDao.getLockByIdSimple" column="lockid" fetchType="eager"/>
          resultMap>
      

      collection的分步查询和association类似。

      推荐：使用连接查询，因为分步查询的效率不如连接查询

      8. 动态SQL

      动态SQL时MyBatis最强大的功能，极大的简化我们拼装SQL的操作。

      有如下四个基本语法：

      1. if
      2. choose (when, otherwise)
      3. trim (where, set)
      4. foreach

      （1）if标签

      • if标签的 test=""属性后：编写判断条件
        • 例：
      • 注意：这里不能写&&，可以写and，也可以使用转义字符。例：&

      
          <select id="getTeacherByCondition" resultMap="myTeacher">
              select * from t_teacher where
              <if test="id!=null">
                  id > #{id} and
              if>
              <if test="teacherName!=null">
                  teacherName like #{teacherName}
              if>
          select>
      

      (2) where标签

      • 可以帮我们去掉前面的and

      （3）trim标签，截取字符串

      prefix="" ：前缀，为我们下面的SQL整体添加一个前缀。

      prefixOverrides=""：取出多余的字符串，例：and

      suffixOverrides="" ：去掉多余的字符串，例：AMD

      suffix=""：为所有SQL添加后缀

      推荐使用where标签，并将所有的and写在前面。

      （4）foreach标签：遍历集合

      • collection：指定要遍历的集合
      • item：每次遍历出的元素起一个变量名，方便引用。
      • open：开始遍历时的拼接字符串
      • close：结束时拼接的字符串
      • separator：遍历的元素之间的分隔符。
      • index: 索引
        • 如果遍历的是list，index保存就是当前元素的索引
        • 如果遍历的是map，index保存的就是当前元素的key。

      <select id="getTeacherList" resultType="myTeacher">
          select * from t_teacher where id IN
          <where>
              <foreach collection="ids" item="id_item" open=" (" close=")" separator=",">
                  #{id_item}
              foreach>
          where>
      select>
      

      (5)choose标签

      • 只进一个when标签。

      <select id="getTeahcers" resultType="myTeacher">
          select * from t_teacher
          <where>
              <choose>
                  <when test="id!=null">
                      id = #{id}
                  when>
                  <when test="name!=null">
                      teachername=#{name}
                  when>
                   <when test="birth!=null">
                      birth_date=#{birth}
                  when>
                  <otherwise>
                      1=1
                  otherwise>
              choose>
          where>
      select>
      

      （6）set标签，update语句使用

      • set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号

          <update id="updateTeacher">
              update t_teacher
              <set>
                  <if test="teacherName!=null">
                      teachername = #{teacherName},
                  if>
                  <if test="className!=null">
                      class_name=#{className},
                  if>
              set>
              <where>
                  id=#{id}
              where>
          update>
      

      （7）bind标签

      绑定一个表达式给一个变量。

      （8）sql标签：抽取可重用的SQL语句

      • 搭配include标签使用，引入SQL。

      <sql id="sql01">
       	select * from t_teacher
      sql>
      
      
      <select id="getTeacherById" resultMap="myTeacher">
             <include refid="sql01">include>
      select>
      

      9. 扩展：OGNL

          OGNL：（ Object Graph Navigation Language ）对象图导航语言，这是一种强大的表达式语言，通过它可以非常方便的来操作对象属性。 类似于我们的EL，SpEL等。

      有类似以下的类，属性如下：

      class Person{
      	lastName;
          email;
          Address;
          	city;
          	province;
          	street;
      }
      

      用点分隔各层属性，就是导航图。如：person.Address.street

      OGNL 不仅可以访问属性，也可以访问方法，静态方法，构造方法，运算符，逻辑运算符。

      在MyBatis中，除了可以使用传入的参数来判断外，还可以使用两个额外的参数。

      1. _parameter 代表传入的参数
         1. 单个参数：就代表传入的参数。
         2. 多个参数：就代表多个参数组成的Map
      2. _databaseId 代表当前环境：MySQL，Oracle等
         1. 配置的数据库移植，才可以使用。databaseIdProvider标签。（在MyBatis核心配置文件中配置）

      10. 缓存机制

      • 缓存：暂时的存储一些数据，加快系统的查询速度。
      • MyBatis中的缓存机制，本质就是一个Map，能保存查询出的一些数据。
        • 一级缓存：线程级别的；本地缓存；SqlSession级别的缓存（和数据库的一次会话）；
        • 二级缓存：全局缓存；其他的sqlSession也能使用。

      查询的时候，先看缓存中有没有，没有的话再去数据库中查。

      （1）一级缓存

      默认存在的。只要之前查询过的数据，MyBatis就会将其保存在缓存中（Map中），下次直接从缓存中拿。

          @Test
          public void test01()
          {
              SqlSession sqlSession = sqlSessionFactory.openSession();
              TeacherDao teacherDao = sqlSession.getMapper(TeacherDao.class);
              Teacher teacher01 = teacherDao.getTeacherById(1);
      
              Teacher teacher02 = teacherDao.getTeacherById(1);
              System.out.println(teacher01==teacher02);
          }
      

      输出：只执行一次SQL语句

      

      一级缓存失效的情况：

      1. 一级缓存是sqlSession级别的缓存，不同的sqlSession，使用不同的一级缓存。
         1. 一个sqlSession查询到的数据会保存在这个sqlSession的一级缓存中，第二次如果查询相同的数据，就从缓存中拿，而不是再去查询数据库。

      /**
       * 一级缓存失效的几种情况：
       * 
       */
      @Test
      public void test02()
      {
          //第一次会话
          SqlSession sqlSession01 = sqlSessionFactory.openSession();
          TeacherDao teacherDao01 = sqlSession01.getMapper(TeacherDao.class);
          Teacher teacher01 = teacherDao01.getTeacherById(1);
      
          //第二次会话
          SqlSession sqlSession02 =sqlSessionFactory.openSession();
          TeacherDao teacherDao02 = sqlSession02.getMapper(TeacherDao.class);
          Teacher teacher02 = teacherDao02.getTeacherById(1);
          
          System.out.println(teacher01==teacher02);//false
      }
      

      输出：执行了两次SQL，查询数据库两次。

      
      2. 在两次拿数据之间，执行任意一个增删改操作。一级缓存就会失效。原因是：增删改操作会将缓存清空。

       @Test
          public void test02()
          {
              //第一次会话
              SqlSession sqlSession01 = sqlSessionFactory.openSession();
              TeacherDao teacherDao01 = sqlSession01.getMapper(TeacherDao.class);
              Teacher teacher01 = teacherDao01.getTeacherById(1);
      
              //执行一次增删改操作
              Teacher teacher = new Teacher();
              teacher.setId(2);
              teacher.setTeacherName("Test");
              teacherDao01.updateTeacher(teacher);
      
      
              Teacher teacher02 = teacherDao01.getTeacherById(1);
      
              System.out.println(teacher01==teacher02);//false
      
              sqlSession01.commit();
      
          }
      

      输出：在一个sqlSession中查询同样的数据，也会执行两次SQL语句。

      
      3. 手动清空缓存：

        @Test
          public void test02()
          {
              //第一次会话
              SqlSession sqlSession01 = sqlSessionFactory.openSession();
              TeacherDao teacherDao01 = sqlSession01.getMapper(TeacherDao.class);
              Teacher teacher01 = teacherDao01.getTeacherById(1);
      
      
              //手动清空缓存
              sqlSession01.clearCache();
              Teacher teacher02 = teacherDao01.getTeacherById(1);
      
              System.out.println(teacher01==teacher02);//false
      
          }
      

      总结：每次查询，先去缓存中查看有没有该数据，如果没有才发起新的SQL。每个sqlSession拥有自己的缓存。

      ---

      MyBatis的缓存就是一个Map，如下：

      保存的数据的key：hashCode+查询的SqlId+编写的sql查询语句+参数，我们可以打开它的源码看一下。

      

      （2）二级缓存

      • 二级缓存：全局作用域缓存，默认不开启，需要手动配置。（从一级缓存搬到二级缓存）
      • 在MyBatis的配置文件中开启缓存。
      • 二级缓存在sqlSession关闭或提交之后才会生效。

      MyBatis中使用二级缓存的步骤：

      1. 在MyBatis配置文件中开启二级缓存。

      
              <setting name="cacheEnabled" value="true"/>
      

      2. 在Dao的实现文件中使用二级缓存。TeacherDao.xml文件中加上。

      <cache/>
      

      3. POJO需要实现Serializable接口。（序列化接口）

      测试代码：

      @Test
          public void test_03()
          {
              //创建两个会话
              SqlSession sqlSession01 = sqlSessionFactory.openSession();
              SqlSession sqlSession02 = sqlSessionFactory.openSession();
      
              UserDao UserDao01 = sqlSession01.getMapper(UserDao.class);
              UserDao UserDao02 = sqlSession02.getMapper(UserDao.class);
      
              //第一个Dao查询一号用户
              User user1 = UserDao01.getUserById(1);
              sqlSession01.close();
              System.out.println("user1: "+user1);
      
              //第二个Dao也查询一号用户
              User user2 = UserDao02.getUserById(1);
              sqlSession02.close();
              System.out.println("user2: "+user2);
             System.out.println("user1是否与user2相同："+(user1==user2));
      
          }
      
      }
      

      输出：

      显然只执行一次SQL

      

      二级缓存总结：

      1. 二级缓存是namespace级别的缓存，哪个Dao要用缓存，就配置在哪个Dao的实现文件中。

      2. 在Dao中的 标签中可以配置的属性：

         1. eviction：缓存回收策略：
            1. LRU – 最近最少使用的：移除最长时间不被使用的对象。
            2. FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
            3. SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
            4. WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
               默认的是 LRU。
         2. flushInterval：刷新间隔，单位毫秒
            1. 默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新
         3. size：引用数目，正整数
            1. 代表缓存最多可以存储多少个对象，太大容易导致内存溢出
         4. readOnly：只读，true/false
            1. true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
            2. false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是 false。

      3. 不会出现二级缓存和一级缓存中有同一个数据。

         1. 二级缓存：一级缓存关闭了之后，才有二级缓存的数据。
         2. 一级缓存：当二级缓存中没该数据时，就先看一级缓存，当一级缓存中也没有时，就去查询数据库。
            1. 数据库中查询出来的数据，就放在一级缓存中。

      4. 任何时候都是先看二级缓存，再看一级缓存，再数据库。

      缓存原理：

      

      sql标签（增删改查）的flushCache属性：

      • 增删改默认flushCache=true。sql执行以后，会同时清空一级和二级缓存。
      • 查询默认flushCache=false。
      • sqlSession.clearCache()：只是用来清除一级缓存

      11. 整合第三方缓存

      因为MyBatis的缓存太过简陋，就是一个Map。

      MyBatis将Cache做成了一个接口，可以使用其他第三方缓存进行代替。

      （1）导入jar包

      ehcache-core：ehcache的核心包

      mybatis-ehcache：ehcache和MyBatis的整合包

      依赖的日志包：

      slf4j-api：

      slf4j-log4j12：

      <dependency>
          <groupId>net.sf.ehcachegroupId>
          <artifactId>ehcache-coreartifactId>
          <version>2.6.11version>
      dependency>
      
      <dependency>
         <groupId>org.mybatis.cachesgroupId>
         <artifactId>mybatis-ehcacheartifactId>
         <version>1.1.0version>
      dependency>
      
      <dependency>
          <groupId>org.slf4jgroupId>
          <artifactId>slf4j-apiartifactId>
          <version>2.0.0-alpha1version>
      dependency>
      
      <dependency>
          <groupId>org.slf4jgroupId>
          <artifactId>slf4j-log4j12artifactId>
          <version>2.0.0-alpha1version>
          <scope>testscope>
      dependency>
      

      （2）ehcache的配置文件

      • ehcache的配置文件叫ehcache.xml，放在类路径下。
      • 使用ehcache之后，pojo类可以不用实现 Serializable 接口。

      
      <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
       
       <diskStore path="E:\ehcache" />
       
       <defaultCache 
         maxElementsInMemory="100000" 
         maxElementsOnDisk="10000000"
         eternal="false" 
         overflowToDisk="true" 
         timeToIdleSeconds="120"
         timeToLiveSeconds="120" 
         diskExpiryThreadIntervalSeconds="120"
         memoryStoreEvictionPolicy="LRU">
       defaultCache>
      ehcache>
       
      
      

      （3）在Mapper.xml文件中配置使用自定义的缓存

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

      ---

      【系列文章】
      1. Git&GitHub（基础）
      2. Git&GitHub（进阶）
      3. Java多线程
      4. JavaScript 总结
      5. SpringMVC（一）
      6. SpringMVC（二）
      ……

      关注博主

      

      你可能感兴趣的:(MyBatis,mybatis,数据库)

      • Google earth studio 简介 陟彼高冈yu 旅游
        GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
      • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
        目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
      • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
        1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
      • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
        深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
      • MongoDB Oplog 窗口 喝醉酒的小白 MongoDB运维
        在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
      • python os 环境变量 CV矿工 python开发语言numpy
        环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
      • 【PG】常见数据库、表属性设置 江无羡 数据库
        PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
      • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
        Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
      • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
        前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
      • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解 秋刀prince mysqlmysql数据库
        提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
      • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
        一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
      • MongoDB知识概括 GeorgeLin98 持久层mongodb
        MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
      • Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net 佛一脚 errorreactmongodb数据库
        背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
      • 入门MySQL——查询语法练习 K_un
        前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
      • 博客网站制作教程 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
      • ubuntu安装wordpress lissettecarlr
        1安装nginx网上安装方式很多，这就就直接用apt-get了apt-getinstallnginx不用启动啥，然后直接在浏览器里面输入IP:80就能看到nginx的主页了。如果修改了一些配置可以使用下列命令重启一下systemctlrestartnginx.service2安装mysql输入安装前也可以更新一下软件源，在安装过程中将会让你输入数据库的密码。sudoapt-getinstallmy
      • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
        一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
      • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
        文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
      • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php课程设计vue.js
        该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
      • MyBatis 详解 阿贾克斯的黎明 javamybatis
        目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
      • 3.增删改查--连接查询 问女何所忆
        关系型数据库的一个特点就是，多张表之间存在关系，以致于我们可以连接多张表进行查询操作，所以连接查询会是关系型数据库中最常见的操作。连接查询主要分为三种，交叉连接、内连接和外连接，我们一个个说。1、交叉连接交叉连接其实连接查询的第一个阶段，它简单表现为两张表的笛卡尔积形式，具体例子：如果你没学过数学中的笛卡尔积概念，你可以这样简单的理解这里的交叉连接：两张表的交叉连接就是一个连接合并的过程，T1表中
      • docker from指令的含义_多个FROM-含义 weixin_39722188 dockerfrom指令的含义
        小编典典什么是基本图片？一组文件，加上EXPOSE端口ENTRYPOINT和CMD。您可以添加文件并基于该基础图像构建新图像，Dockerfile并以FROM指令开头：后面提到的图像FROM是新图像的“基础图像”。这是否意味着如果我neo4j/neo4j在FROM指令中声明，则在运行映像时，neo数据库将自动运行并且可在端口7474的容器中使用？仅当您不覆盖CMD和时ENTRYPOINT。但是图像
      • Redis:缓存击穿 我的程序快快跑啊 缓存redisjava
        缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
      • mysql学习教程，从入门到精通，TOP 和MySQL LIMIT 子句（15） 知识分享小能手 大数据数据库MySQLmysql学习oracle数据库开发语言adb大数据
        1、TOP和MySQLLIMIT子句内容在SQL中，不同的数据库系统对于限制查询结果的数量有不同的实现方式。TOP关键字主要用于SQLServer和Access数据库中，而LIMIT子句则主要用于MySQL、PostgreSQL（通过LIMIT/OFFSET语法）、SQLite等数据库中。下面将分别详细介绍这两个功能的语法、语句以及案例。1.1、TOP子句（SQLServer和Access）1.1
      • ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your †徐先森® Oracle数据库Web相关错误集
        createtablestudents(idintunsignedprimarykeyauto_increment,namevarchar(50)notnull,ageintunsigned,highdecimal(3,2),genderenum('男','女','中性','保密','妖')default'保密',cls_idintunsigned);在对数据库插入如上带有中文带有默认值的字段的时
      • Redis 有哪些危险命令？如何防范？ 花小疯 redis缓存数据库危险命令大数据
        Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
      • 【Golang】 Golang 的 GORM 库中的 Rows 函数 不爱洗脚的小滕 golang开发语言后端
        文章目录前言一、Rows函数解释二、代码实现三、总结前言在使用Go语言进行数据库操作时，GORM（GoObject-RelationalMapping）库是一个常用的工具。它提供了一种简洁和强大的方式来处理数据库操作。本文将介绍GORM库中的Rows函数，这是一个用于执行原生SQL查询并返回结果的函数。一、Rows函数解释在GORM库中，Rows函数用于执行原生SQL查询并返回*sql.Rows结
      • 接口测试如何设计测试用例 李蕴Ronnie
        接口测试用例设计方式针对每个必填参数，都设计一条参数为空的测试用例必填参数不存在传的参数值在数据库中不存在添加数据接口，传入已有的数据重复添加编辑数据接口，各个字段分别编辑，合并编辑参数数据类型限制，针对每个参数设计一条参数值类型不符合的逆向用例参数自身取值范围，针对所有参数，设计一条每个参数值在取值范围内最大值的正向测试用例是否满足前提条件（token、headers），几个前提条件几条用例针对
      • Hadoop架构 henan程序媛 hadoop大数据分布式
        一、案列分析1.1案例概述现在已经进入了大数据(BigData)时代，数以万计用户的互联网服务时时刻刻都在产生大量的交互，要处理的数据量实在是太大了，以传统的数据库技术等其他手段根本无法应对数据处理的实时性、有效性的需求。HDFS顺应时代出现，在解决大数据存储和计算方面有很多的优势。1.2案列前置知识点1.什么是大数据大数据是指无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的大量数据集合，
      • 非关系型数据库 天秤-white nosql
        一、为什么要用Nosql1.单机MySQL的时代。一个基本的网站访问量一般不会太大，单个数据库完全足够。那时候更多使用的静态网页html，服务器根本没有太大压力。这时候网站的瓶颈是什么？-数据量如果太大，一个机器放不下。-数据量太大需要建立数据的索引（B+Tree），一个服务器内存放不下。-访问量读写混合，一个服务器承受不了。2.memcached缓存+MySQL+垂直拆分（读写分离）。网站80%
      • sql统计相同项个数并按名次显示 朱辉辉33 javaoracle
        现在有如下这样一个表： A表 ID Name time ------------------------------ 0001 aaa 2006-11-18 0002 ccc 2006-11-18 0003 eee 2006-11-18 0004 aaa 2006-11-18 0005 eee 2006-11-18 0004 aaa 2006-11-18 0002 ccc 20
      • Android+Jquery Mobile学习系列-目录 白糖_ JQuery Mobile
        最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。   从现在起，往后一段时间，我打算
      • 如何给线程池命名 daysinsun 线程池
                在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下：     public class Named
      • IE 中"HTML Parsing Error:Unable to modify the parent container element before the 周凡杨 html解析errorreadyState
          错误： IE 中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"     现象： 同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
      • java上传 g21121 java
        我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。 我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/ 下面是servlet的代码： //定义一个磁盘文件工厂 DiskFileItemFactory fact
      • SpringMVC配置学习 510888780 springmvc
        spring MVC配置详解 现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。 　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
      • spring mvc-jfreeChart 柱图(1) 布衣凌宇 jfreechart
        第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可； 第二步：配置web.xml; web.xml代码如下 <servlet>     <servlet-name>jfreechart</servlet-nam
      • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
        PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
      • java 线程池使用 Runnable&Callable&Future antlove javathreadRunnablecallablefuture
        1. 创建线程池 ExecutorService executorService = Executors.newCachedThreadPool();   2. 执行一次线程，调用Runnable接口实现 Future<?> future = executorService.submit(new DefaultRunnable()); System.out.prin
      • XML语法元素结构的总结 百合不是茶 xml树结构
        1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
      • 改变eclipse编码格式 bijian1013 eclipse编码格式
        1.改变整个工作空间的编码格式         改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。         Eclipse->window->preferences->General->workspace-
      • javascript中return的设计缺陷 bijian1013 JavaScriptAngularJS
        代码1： <script> var gisService = (function(window) { return { name:function () { alert(1); } }; })(this); gisService.name(); &l
      • 【持久化框架MyBatis3八】Spring集成MyBatis3 bit1129 Mybatis3
        pom.xml配置 Maven的pom中主要包括： MyBatis MyBatis-Spring Spring MySQL-Connector-Java Druid applicationContext.xml配置   <?xml version="1.0" encoding="UTF-8"?> &
      • java web项目启动时自动加载自定义properties文件 bitray javaWeb监听器相对路径
        创建一个类 public class ContextInitListener implements ServletContextListener 使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。 类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。 <listener> <des
      • 用nginx区分文件大小做出不同响应 ronin47
        昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
      • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大 bylijinnan java
        package com.ljn.base; import java.util.Arrays; import java.util.Random; public class ContinuousPoker { /** * Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。 * 2-10为数字本身，A为1，J为1
      • 翟鸿燊老师语录 ccii 翟鸿燊
        一、国学应用智慧TAT之亮剑精神A 1. 角色就是人格     就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。     还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
      • [光速与宇宙]进行光速飞行的一些问题 comsci 问题
             在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家     仅仅是猜想。。。未经官方证实      1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
      • oracle undo解析 cwqcwqmax9 oracle
        oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿 Undo是干嘛用的？         &nb
      • java中各种集合的详细介绍 dashuaifu java集合
        一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
      • 卸载windows服务的方法 dcj3sjt126com windowsservice
        卸载Windows服务的方法 在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
      • Warning: The Copy Bundle Resources build phase contains this target's Info.plist dcj3sjt126com iosxcode
            http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html Excerpt: You are getting this warning because you probably added your Info.plist file to your Copy Bundle
      • 2014之C++学习笔记（一） Etwo C++EtwoEtwoiterator迭代器
                已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
      • js跨越获取数据问题记录 haifengwuch jsonpjsonAjax
        js的跨越问题，普通的ajax无法获取服务器返回的值。   第一种解决方案，通过getson，后台配合方式，实现。 Java后台代码： protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String ca
      • 蓝色jQuery导航条 ini JavaScripthtmljqueryWebhtml5
        效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
      • linux部署jdk,tomcat,mysql kerryg jdktomcatlinuxmysql
        1、安装java环境jdk:     一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。    1.1）、卸载：      （rpm -qa :查询已经安装哪些软件包；        rmp -q 软件包：查询指定包是否已
      • DOMContentLoaded VS onload VS onreadystatechange mutongwu jqueryjs
        1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+） 2. onload是最早支持的事件，要求所有资源加载完毕触发。 3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
      • sql批量插入数据 qifeifei 批量插入
        hi，   自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。    WITH tempT AS ( SELECT item_id AS combo_id, item_id, now() AS create_date FROM a
      • log4j打印日志文件 如何实现相对路径到 项目工程下 thinkfreer Weblog4j应用服务器日志
        最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下 需求： 用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
      • linux下mysql-5.6.23.tar.gz安装与配置 笑我痴狂 mysqllinuxunix
        1.卸载系统默认的mysql [root@localhost ~]# rpm -qa | grep mysql mysql-libs-5.1.66-2.el6_3.x86_64 mysql-devel-5.1.66-2.el6_3.x86_64 mysql-5.1.66-2.el6_3.x86_64 [root@localhost ~]# rpm -e mysql-libs-5.1
      按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
      首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

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