Mybatis

标签：支持   面向对象编程   dir   sql语句   持久层   utf-8   debug   loaded   方法   

环境：

• JDK1.8

• Mysql 5.7

• maven 3.6.1

• IDEA

回顾：

• JDBC

• Mysql

• java基础

• Maven

• Junit

SSM框架：配置文件的：最好的方式：看官网文档；

1、简介

1.1、什么是Mybatis

• MyBatis 是一款优秀的持久层框架

• 它支持定制化 SQL、存储过程以及高级映射

• MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集

• MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

• MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。

• 2013年11月迁移到Github。

如何获得Mybatis？

• maven仓库：https://mvnrepository.com/artifact/org.mybatis/mybatis

  <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
  <dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis</artifactId>
     <version>3.5.3</version>
  </dependency>

   

• Github：https://github.com/mybatis/mybatis-3

• 中文文档：https://mybatis.org/mybatis-3/zh/index.html

1.2、持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程；

• 内存：断电即失

• 数据库（jdbc）io文件持久化。

• 生活中：冷藏、罐头。

为什么需要持久化？

• 有一些对象不能让他丢掉；

• 内存太贵了；

1.3、持久层

Dao层、Service层、Controller层...

• 完成持久化工作的代码层；

• 层：界限十分明显；

1.4、为什么需要Mybatis？

• 帮助程序员将数据存入到数据库中

• 方便

• 传统的JDBC代码太复杂了，简化

• 不用Mybatis也可以，但Mybatis更容易上手。

• 有点：

  • 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。

  • 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。

  • 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。

  • 提供映射标签，支持对象与数据库的orm字段关系映射

  • 提供对象关系映射标签，支持对象关系组建维护

  • 提供xml标签，支持编写动态sql。

最重要的一点：使用的人多！

2、第一个Mybatis程序

思路：搭建环境--->导入Mybatis--->编写代码--->测试！

2.1、搭建环境

• 搭建数据库

• 新建项目:

1. 新建一个普通Maven项目

2. 删除src目录

3. 导入maven依赖

<!--       Mysql驱动-->
       <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>8.0.18</version>
       </dependency>
?
       <!--       Mybatis-->
       <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis</artifactId>
           <version>3.5.3</version>
       </dependency>
?
<!--Junit-->
       <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
       <dependency>
           <groupId>org.junit.jupiter</groupId>
           <artifactId>junit-jupiter-api</artifactId>
           <version>5.5.2</version>
           <scope>test</scope>
       </dependency>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
       PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
   <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://120.79.15.118:3306/test_sql?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
               <property name="username" value="test"/>
               <property name="password" value="123"/>
           </dataSource>
       </environment>
   </environments>
?
</configuration>

//从SqlSessionFactory拿到SqlSession
public class MybatisUtils {
   private static SqlSessionFactory sqlSessionFactory;//提升作用域
   static {
       String resource = "mybatis-config.xml";
       InputStream inputStream = null;
       try {
           //使用mybatis第一步：获取SqlSessionFactory对象
           inputStream = Resources.getResourceAsStream(resource);
      } catch (IOException e) {
           e.printStackTrace();
      }
       SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
?
  }
   
   //既然有了 SqlSessionFactory，顾名思义，我们就可以从中获得 SqlSession 的实例了。
   // SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法。
   
   public static SqlSession getSqlSession(){
       return sqlSessionFactory.openSession();
       
  }
}

package com.yuan.pojo;
//实体类
public class User {
   private int id;
   private String name;
   private String pwd;
?
   public User() {
  }
?
   public User(int id, String name, String pwd) {
       this.id = id;
       this.name = name;
       this.pwd = pwd;
  }
?
   public int getId() {
       return id;
  }
?
   public void setId(int id) {
       this.id = id;
  }
?
   public String getName() {
       return name;
  }
?
   public void setName(String name) {
       this.name = name;
  }
?
   public String getPwd() {
       return pwd;
  }
?
   public void setPwd(String pwd) {
       this.pwd = pwd;
  }
?
   @Override
   public String toString() {
       return "User{" +
               "id=" + id +
               ", name=‘" + name + ‘\‘‘ +
               ", pwd=‘" + pwd + ‘\‘‘ +
               ‘}‘;
  }
}

public interface UserDao {
?
   List<User> getUserList();
?
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
       PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--       namespace:绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.yuan.dao.UserDao">
?
<!--   select 查询语句-->
   <select id="getUserList" resultType="com.yuan.dao.User">//写泛型内的User
      select * from mybatis.user
   </select>
?
</mapper>

<!--   每一个Mapper.xml都需要在Mybatis的核心配置文件中注册-->
   <mappers>
       <mapper resource="com/yuan/dao/UserMapper.xml"/>
   </mappers>

<!--   在build中配置resources，来防止我们资源导出失败的问题-->
   <build>
       <resources>
           <resource>
               <directory>src/main/resources</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>true</filtering>
           </resource>
           <resource>
               <directory>src/main/java</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>true</filtering>
           </resource>
       </resources>
   </build>

public class UserDaoTest {
?
   @Test
   public void test(){
?
?
       //第一步：获取sqlSession对象
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       //执行SQL
       //方式一：getMapper
       UserDao mapper = sqlSession.getMapper(UserDao.class);
       List<User> userList = mapper.getUserList();
?
       for (User user : userList) {
           System.out.println(user);
?
      }
       //关闭sqlSession
       sqlSession.close();
  }
}

//根据id查询用户
User getUserById(int id);
?

<select id="getUserById" parameterType="int"
resultType="com.yuan.pojo.User">
select * from mybatis.user where id = #{id}
</select>

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

<insert id="addUser" parameterType="User"><br>  
  Insert into user(id,name,level,phone) values(#{id},#{name},#{level},#{phone});
   </insert>

<update id="updateUser" parameterType="User">
  update user set name=#{name},level=#{level},phone=#{phone} where id=#{id};
   </update>

<delete id="deleteUser" parameterType="User">
  delete from user where id=#{id};
   </delete>

sqlSession.commit();

configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

driver = com.yuan.jdbc.Driver
url=jdbc:mysql://120.79.15.118:3306/test_sql?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=test
password=123

//引入外部配置文件
   <properties resource="db.properties">
       <property name="username" value="test"/>
       <property name="pwd" value="11111"/>
   </properties>

//可以给实体类起别名
   <typeAliases>
       <typeAlias type="com.yuan.pojo.User" alias="USER"/>
   </typeAliases>

  //可以给实体类起别名
   <typeAliases>
       <package name="com.yuan.pojo"/>
   </typeAliases>

@Alias("author")
public class Author {
  ...
}

idnamepwd (数据库)
idnamepassword  （实体类）

<!--   结果集映射-->
   <resultMap id="UserMap" type="User">
<!--       column:数据库中的字段 property：实体类中的属性 -->
       <result column="id" property="id"/>
       <result column="name" property="name"/>
       <result column="pwd" property="password"/>
   </resultMap>
   
   <select id="getUserById" resultMap="UserMap">
      select * from mybatis.user where id = #{id}
   </select>
?

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

<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
<dependency>
   <groupId>org.apache.logging.log4j</groupId>
   <artifactId>log4j-core</artifactId>
   <version>2.12.1</version>
</dependency>
?
?

### 配置根 ###
log4j.rootLogger = debug,console ,fileAppender,dailyRollingFile,ROLLING_FILE,MAIL,DATABASE
?
### 设置输出sql的级别，其中logger后面的内容全部为jar包中所包含的包名 ###
log4j.logger.org.apache=dubug
log4j.logger.java.sql.Connection=dubug
log4j.logger.java.sql.Statement=dubug
log4j.logger.java.sql.PreparedStatement=dubug
log4j.logger.java.sql.ResultSet=dubug
?
### 配置输出到控制台 ###
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern = %d{ABSOLUTE} %5p %c{ 1 }:%L - %m%n
?
### 配置输出到文件 ###
log4j.appender.fileAppender = org.apache.log4j.FileAppender
log4j.appender.fileAppender.File = logs/log.log
log4j.appender.fileAppender.Append = true
log4j.appender.fileAppender.Threshold = DEBUG
log4j.appender.fileAppender.layout = org.apache.log4j.PatternLayout
log4j.appender.fileAppender.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
?
### 配置输出到文件，并且每天都创建一个文件 ###
log4j.appender.dailyRollingFile = org.apache.log4j.DailyRollingFileAppender
log4j.appender.dailyRollingFile.File = logs/log.log
log4j.appender.dailyRollingFile.Append = true
log4j.appender.dailyRollingFile.Threshold = DEBUG
log4j.appender.dailyRollingFile.layout = org.apache.log4j.PatternLayout
log4j.appender.dailyRollingFile.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
?
### 配置输出到文件，且大小到达指定尺寸的时候产生一个新的文件 ###
log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender 
log4j.appender.ROLLING_FILE.Threshold=ERROR 
log4j.appender.ROLLING_FILE.File=rolling.log 
log4j.appender.ROLLING_FILE.Append=true 
log4j.appender.ROLLING_FILE.MaxFileSize=10KB 
log4j.appender.ROLLING_FILE.MaxBackupIndex=1 
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout 
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
?
### 配置输出到邮件 ###
log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.From=chenyl@yeqiangwei.com
log4j.appender.MAIL.SMTPHost=mail.hollycrm.com
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=chenyl@yeqiangwei.com
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
?
### 配置输出到数据库 ###
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
log4j.appender.DATABASE.user=root
log4j.appender.DATABASE.password=
log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES (‘[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n‘)
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A1.File=SampleMessages.log4j
log4j.appender.A1.DatePattern=yyyyMMdd-HH‘.log4j‘
log4j.appender.A1.layout=org.apache.log4j.xml.XMLLayout

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

语法： SELECT * from limit startIndex,pageSize;
?
例：  SELECT * from limit 0,2;
每页显示两个，从第零个查；
SELECT * from limit 3;   # [0,n]

//分页
List<User> getUserByLimit (Map<String,Integer> map);

<!--   分页-->
   <select id="getUserByLimit" parameterType="map" resultType="user">
      select * from mybatis.user limit #{startIndex},#{pageSize}
   </select>
?

@Test
   public void getUserByLimit(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
?
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
?
       HashMap<String,Integer> map = new HashMap<String, Integer>();
       map.put("startIndex",0);
       map.put("pageSize",2);
?
      List<User> userList mapper.getUserByLimit(map);
      
      for (User user : userList){
          System.out.println(user);
      }
?
       sqlSession.close();
?

?
   //使用RowBounds分页
   List<User> getUserByRowBounds ();

<!-- RowBounds分页-->
   <select id="getUserByLimit" parameterType="map" resultType="user">
      select * from mybatis.user
   </select>

@Test
   public void getUserByRowBounds(){
?
       SqlSession sqlSession = MybatisUtils.getSqlSession();
?
       //RowBounds实现
       RowBounds rowBounds = new RowBounds(1, 2);
?
       //通过java代码层面实现分页
       List<User> userList = sqlSession.selectList("com.yuan.dao.UserMapper.getUserByRowBounds",null,rowBounds);
?
       for (User user : userList){
           System.out.println(user);
      }
?
  }
?
}

//绑定接口
<mappers>
<mapper class="com.yuan.dao.userMapper"/>
</mappers>

public static SqlSession getSqlSession(){
 return sqlSessionFactory.openSession(true);
}

 @Select("select * from user where id = #{id}")
   List<User> getUsers();
?
   //方法存在多个参数，所有的参数前面必须加上@Param()注解
   @Select("select * from user where id = #{id}")
   User getUserById(@Param("id") int id);
?
?
   @Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
   int addUser(User user);
?
   @Update("update user set name=#{name),pwd=#{password} where id = #{id}")
   int updateUser(User user);
?
   @Delete("delete from user where id = #{id}")
   int seleteUser(@Param("id")int id);

Project Lombok makes java a spicier language by adding ‘handlers‘ that know how to build and compile simple, boilerplate-free, not-quite-java code.

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <version>1.18.10</version>
   <scope>provided</scope>
</dependency>

动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。在 MyBatis 之前的版本中，有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类，现在只需学习原来一半的元素便可。MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。
?
if
choose (when, otherwise)
trim (where, set)
foreach

Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存.

<!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
<dependency>
   <groupId>org.ehcache</groupId>
   <artifactId>ehcache</artifactId>
   <version>3.8.1</version>
</dependency>
?

• diskStore ： ehcache支持内存和磁盘两种存储

  • path ：指定磁盘存储的位置

• defaultCache ： 默认的缓存

  • maxEntriesLocalHeap=”10000”

  • eternal=”false”

  • timeToIdleSeconds=”120”

  • timeToLiveSeconds=”120”

  • maxEntriesLocalDisk=”10000000”

  • diskExpiryThreadIntervalSeconds=”120”

  • memoryStoreEvictionPolicy=”LRU”

• cache ：自定的缓存，当自定的配置不满足实际情况时可以通过自定义（可以包含多个cache节点）

  • name : 缓存的名称，可以通过指定名称获取指定的某个Cache对象

  • maxElementsInMemory ：内存中允许存储的最大的元素个数，0代表无限个

  • clearOnFlush：内存数量最大时是否清除。

  • eternal ：设置缓存中对象是否为永久的，如果是，超时设置将被忽略，对象从不过期。根据存储数据的不同，例如一些静态不变的数据如省市区等可以设置为永不过时

  • timeToIdleSeconds ： 设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。

  • timeToLiveSeconds ：缓存数据的生存时间（TTL），也就是一个元素从构建到消亡的最大时间间隔值，这只能在元素不是永久驻留时有效，如果该值是0就意味着元素可以停顿无穷长的时间。

  • overflowToDisk ：内存不足时，是否启用磁盘缓存。

  • maxEntriesLocalDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。

  • maxElementsOnDisk：硬盘最大缓存个数。

  • diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。

  • diskPersistent：是否在VM重启时存储硬盘的缓存数据。默认值是false。

  • diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。

  • maxEntriesLocalHeap：是用来限制当前缓存在堆内存上所能保存的最大元素数量的。Ehcache规定如果在CacheManager上没有指定maxBytesLocalHeap时必须在各个Cache上指定maxBytesLocalHeap或者maxEntriesLocalHeap，但maxEntriesLocalHeap和maxBytesLocalHeap不能同时出现。也就是说我们不能在一个Cache上同时指定maxBytesLocalHeap和maxEntriesLocalHeap，当然我们也不能在Cache上指定maxEntriesLocalHeap的同时在CacheManager上指定maxBytesLocalHeap。但同时在CacheManager和Cache上指定maxBytesLocalHeap则是允许的。

要在程序中使用ehcache，首先要导包

13.6、自定义缓存-ehcache

13.5、缓存原理

• 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存

• 基于namespace级别的缓存，一个名称空间，对应一个二级缓存

• 工作机制

  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中

  • 如果当前会话关闭了，这个回话对应的一级缓存就没了，但是我们想要的是，会话关闭了，一级缓存中的数据保存到二级缓存中

  • 新的回话查询信息，就可以从二级缓存中获取内容

  • 不同的mapper查出的数据会放在自己对应的缓存（map）中

13.4、二级缓存

• 一级缓存也叫本地缓存

  • 与数据库同一次回话期间查询到的数据会放在本地缓存中；

  • 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库

13.3、一级缓存

读写分离，主从复制

• Mybatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大地提升查询效率；

• Mybatis系统中默认定义了两级缓存：一级缓存和二级缓存

  • 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）

  • 二级缓存需要手动开启和配置，它是基于namespace级别的缓存

  • 为了提高扩展性，Mybatis定义了缓存接口Cache，我们通过实现Cache接口来自定义二级缓存

13.2、Mybatis缓存

1. 什么是缓存[Cache]?

   • 存在内存中的临时数据

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

2. 为什么使用缓存？

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

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

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

13.1、简介

13、缓存

https://mybatis.org/mybatis-3/zh/dynamic-sql.html

具体内容看官方文档吧！！

1. 导包

2. 编写配置文件

3. 编写实体类

4. 编写实体类对应的Mapper接口和Mapper.xml文件

创建一个基础工程：

什么是动态sql：动态sql就是指根据不同的条件生成不同的sql语句；

12、动态SQL

https://www.jianshu.com/p/4ff554003c6e

11、一对多处理

• 多个学生，对应一个老师

• 对于学生这边而言，关联 多个多生关联一个老师【多对一】

• 对于老师而言，集合 一个老师有很多学生【一对多】

多对一：

10、多对一处理

参考博客：https://www.cnblogs.com/heyonggang/p/8638374.html

1. 不支持多种参数构造器的重载

2. 虽然省去了手动创建getter/setter方法的麻烦，但大大降低了源代码的可读性和完整性，降低了阅读源代码的舒适度

缺点：

1. 能通过注解的形式自动生成构造器、getter/setter、equals、hashcode、toString等方法，提高了一定的开发效率

2. 让代码变得简洁，不用过多的去关注相应的方法

3. 属性做修改时，也简化了维护为这些属性所生成的getter/setter方法等

优点：

优缺点：

Lombok能通过注解的方式，在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString方法。出现的神奇就是在源码中没有getter和setter方法，但是在编译生成的字节码文件中有getter和setter方法。这样就省去了手动重建这些代码的麻烦，使代码看起来更简洁些。

3. 在实体类上加注解即可

2. 导入依赖（或者下载jar）

https://www.2cto.com/kf/201709/682062.html

1. 安装Lombok插件

使用步骤：

官方介绍：

9、Lombok

${}底层采用字符串拼接的方式绑定数据 字符串拼接方式： 优点：不但能绑定数据，还可以拼接表名,列名,关键字,运算符 缺点：可能会被SQL注入攻击 #{}底层采用？占位符的方式绑定数据 占位符的方式： 优点：可以防止SQL注入攻击 缺点：只能绑定数据，不能拼接表明,列名,关键字,运算符

#{}和#{}区别：

• 基本类型的参数或者String类型，需要加上

• 引用类型不需要加

• 如果只有一个基本类型的话，可以忽略，但是建议大家都加上！

• 我们在SQL中引用的就是我们这里的@Param()中设定的属性名！

关于@Param()注解

【注意】我们必须要将接口注册绑定到我们的核心配置文件中！

编写接口，增加注解

我们可以在工具类创建的时候实现自动提交事务！

8.3、CRUD

Mybatis详细执行流程：

底层：动态代理！

本质：反射机制实现！

3. 测试

2. 需要在核心配置文件中绑定接口

1. 注解在接口上实现

8.2、使用注解开发

• 面向对象是指：我们考虑问题时，以对象为单位，考虑它的属性与方法；

• 面向过程是指：我们考虑问题时，以一个具体流程（事务过程）为单位，考虑它的实现；

• 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多的体现就是对系统整体的架构；

三个面向的区别：

• 接口从更深层次的理解，应是定义（规范、约束）与实现（名实分离的原则）的分离；

• 接口的本身反映了系统设计人员对系统的抽象理解；

• 接口应有两类：

  • 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class）；

  • 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；

  • 一个个体可能被有多个抽象面。抽象体与抽象面是有区别的。

关于接口的理解：

• 大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程

• 根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好；

• 在一个面向对象的系统中，系统的各种功能是由许许多多不同对象协作完成的。在这种病情况下，各个对象内部是如何实现自己的，对系统设计人员来说的不那么重要了；

• 而各个对象之间的协作关系则成为系统设计的关键，小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要内容。面向接口编程就是按照这种思想来编程；

8.1、面向接口编程

8、使用注解开发

7.3、分页插件

3. 测试

2. mapper.mxl

1. 接口

不再使用sql实现分页

7.2、RowBounds分页（不建议在开发中使用）

3. 测试

2. Mapper.xml

1. 接口

使用Mybatis实现分页，核心sql

7.1、使用Limit分页

• 减少数据的处理量

思考：为什么要分页？

7、分页

4. log4j的使用！直接运行刚才的查询！

3. 配置log4j为日志的实现

2. Log4j.properties 例：

1. 先导入LOG4J的包；

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；

• 我们也可以控制每一条日志的输出格式；

• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。

• 最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

什么是LOG4J？

6.2、LOG4J

注意：一定要准确写出name和value的值，最好复制，防止出错。

在Mybatis核心配置文件中，配置我们的日志：

STDOUT_LOGGING ：标准日志输出！

在Mybatis中具体使用哪一个日志实现，在设置中设定！

• SLF4J

• LOG4J 【掌握】

• LOG4J2

• JDK_LOGGING

• COMMONS_LOGGING

• STDOUT_LOGGING 【掌握】

• NO_LOGGING

现在：日志工厂！

曾经：sout、debug

如果一个数据库操作出现了异常，我们需要排错，日志就是好的助手。

6.1、日志工厂

6、日志

• resultMap 元素是 MyBatis 中最重要最强大的元素。

• ResultMap 的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。

• ResultMap 最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们。

• 如果世界总是这么简单就好了。

结果集映射：

5.1、resultMap

5、解决属性名和字段名不一致的问题（ResultMap）

这里的每一个Mapper，就代表一个具体的业务！

• 连接到连接池的一个请求！

• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。

• 用完之后赶紧关闭，否则资源被占用

SqlSession：

• 相当于数据库连接池

• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。

• SqlSessionFactory 的最佳作用域是应用作用域

• 最简单的就是使用单例模式或者静态单例模式。

SqlSessionFactory：

• 一旦创建了 SqlSessionFactory，就不再需要它了

• 局部变量

SqlSessionFactoryBuilder：

生命周期和作用域是至关重要的，因为错误的使用会导致非常严重的并发问题。

4.8、生命周期和作用域

• 接口和它的Mapper配置文件必须同名！   

• 接口和它的Mapper配置文件必须在同一个包下！

注意点：

MapperRegister：注册绑定我们的Mapper文件；

4.7、映射器（mappers）

• typeHandlers（类型处理器）

• objectFactory（对象工厂）

• plugins（插件）

  • MyBatis Generator core

  • Mybatis plus

  • 通用mapper

4.6、其他配置

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

4.5、设置

下面是一些为常见的 Java 类型内建的相应的类型别名。它们都是不区分大小写的，注意对基本类型名称重复采取的特殊命名风格。

比如 domain.blog.Author的别名为 author；若有注解，则别名为其注解值。见下面的例子：

第二种在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。

第一种可以DIY别名，第二种则不行。

如果实体类比较多，建议使用第二种~

在实体类比较少的时候，使用第一种方式

扫描实体类的包，它的默认别名就为这个类的类名，首字母小写！

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

当这样配置时，Blog 可以用在任何使用 domain.blog.Blog 的地方。

• 类型别名是为 Java 类型设置一个短的名字。

• 它只和 XML 配置有关。存在的意义仅在于用来减少类完全限定名的冗余。

4.4、类型别名（typeAliases）

• 可以直接引用外部文件！

• 可以在其中增加一些属性配置！

• 如果两个文件有同一个字段，有限使用外部配置文件的！

2. 在核心配置文件中引入

1. 编写一个配置文件

注意xml中的标签顺序！！！

这些属性都是可外部配置且可动态替换的，既可以在典型的 Java 属性文件中配置，亦可通过 properties 元素的子元素来传递。【db.properties】

我们可以通过properties属性来实现引用配置文件！

4.3、属性（properties）

Mybatis默认的事务管理器就是JDBC，连接池：POOLED！

学会使用多套运行环境！

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

MyBatis 可以配置成适应多种环境

4.2、环境配置（environments）

• Mybatis-config.xml

4.1、核心配置文件

4、配置解析

1. Java代码执行的时候，传递通配符% %

2. 在sql拼接中使用通配符！

3.8、模糊查询怎么写

多个参数用Map或者注解！

只有一个基本类型参数的情况下，可以直接在sql中取到！

对象传递参数，直接在sql中取对象的属性即可！【parameterType="Object"】

Map传递参数，直接在sql中取出key即可！【parameterType="map"】

假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map！

3.7、万能Map

• 标签不要匹配错

• resource绑定mapper需要使用路径

• 程序配置文件必须符合规范

• NullPointerException，没有注册到资源

• 输出的xml文件中存在中文乱码的问题

• maven资源没有导出问题

3.6、分析错误

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

3.5、Delete

3.4、Update

3.3、Insert

3. 测试

2. 编写对应的Mapper中的sql语句

1. 编写接口

• id：就是对应namespace中的方法名；

• resultType：sql语句执行的返回值；

• parameterType：参数类型；

选择、查询语句；

3.2、select

namespace中的包名要和Dao/Mapper接口包名一致！

3.1、namespace

3、CRUD

架构截图：

1. 配置文件没有注册

2. 绑定接口错误

3. 方法名不对

4. 返回类型不对

5. Maven导出资源问题

可能会遇到的问题：

• Junit测试

解决方法：在pom.xml文件内：build中配置resources，来防止我们资源导出失败的问题

2. 报错：java.lang.ExceptionInInitializerError

   Maven导出资源错误

解决方法：在mybatis-config.xml中注册

MapperRegistry未注册

注意点：1. 报错：org.apache.ibatis.binding.BindingException: Type interface *** is not known to the MapperRegistry.

2.4、测试

• 接口实现类由原来的UserDaoImpl转变为一个Mapper配置文件

• Dao接口

• 实体类

2.3、编写代码

2. 编写mybatis工具类 mybatisUtils下

1. 编写Mybatis的核心配置文件 resources下

2.2、创建一个模块

Mybatis

标签：支持   面向对象编程   dir   sql语句   持久层   utf-8   debug   loaded   方法   

原文地址：https://www.cnblogs.com/tomcatist/p/12239385.html