MyBatis学习笔记——未完结

MyBatis

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仓库：

  
  <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>3.5.5version>
  dependency>
  

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

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

1.2、持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库(jdbc)，io文件持久化
• 生活：；冷藏、罐头

为什么需要持久化？

• 有一些对象数据，不能让他丢失
• 内存太贵了

1.3、持久层

Dao层，Service层，Controller层…

• 完成持久化工作的代码块
• 层的界限十分明显

1.4、为什么需要Mybatis？

• 帮助程序员将数据存入到数据库中
• 方便
• 传统的JDBC代码太复杂了–>简化–>框架–>自动化
• 不用Mybatis也可以，mybatii更容易上手，技术没有高低之分
• 优点：
  • 简单易学
  • 灵活
  • sql和代码的分离，提高了可维护性
  • 提供映射标签，支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签，支持对象关系组建维护
  • 提供xml标签，支持编写动态sql

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

2、第一个MyBatis程序

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

2.1、搭建环境

搭建数据库

CREATE DATABASE `mybatis`;

USE `mybatis`;

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

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES
(1,'阿杰','123456'),
(2,'张三','123456'),
(3,'李四','123456')

新建项目

1. 新建一个普通的Maven项目

2. 删除src目录

3. 导入maven依赖

   
   <dependencies>
       
       <dependency>
           <groupId>mysqlgroupId>
           <artifactId>mysql-connector-javaartifactId>
           <version>8.0.20version>
       dependency>
       
       <dependency>
           <groupId>org.mybatisgroupId>
           <artifactId>mybatisartifactId>
           <version>3.5.5version>
       dependency>
       
       <dependency>
           <groupId>junitgroupId>
           <artifactId>junitartifactId>
           <version>4.12version>
           <scope>testscope>
       dependency>
   dependencies>
   

2.2、创建一个模板

每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例

1、编写MyBatis的核心文件

XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源（DataSource）以及决定事务作用域和控制方式的事务管理器（TransactionManager）

<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?serverTimezone=GMT%2B8&useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="12345678"/>
            dataSource>
        environment>
    environments>

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

configuration>

2、编写MyBatis工具类

//sqlSessionFactory  -->  构建sqlSession
public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static{
        try {
            // 使用Mybatis的第一步
            // 获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 既然有了 SqlSessionFactory，顾名思义，我们就可以从中获得 SqlSession 的实例了
    // SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }

}

2.3、编写代码

• 数据库相关实体类

  //实体类
  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 + '\'' +
                  '}';
      }
  }
  

• Dao接口

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

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

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

2.4、测试

注意点：

org.apache.ibatis.binding.BindingException: Type interface com.lj.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么？

• junit测试

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

可能会遇到的问题：

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

小结：

• 第一步先写mybatisUtils工具类，这个工具类需要一个配置文件

• 第二步在resources中写一个工具类的配置文件

• 第三步写实体类

• 第四步写接口，写完接口写mapper.xml

• 最后写junit测试，如果资源导出失败再在maven中的build中配置resources

3、CRUD

1、namespace

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

2、select

选择，查询语句；

• id：就是对应的namespace中的方法名
• resultType：Sql语句执行的返回值
• parameterType：参数类型

1. 编写接口

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

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

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

3. 测试

   @Test
   public void getUserByIdTest(){
       // 第一步：获得SqlSession对象
       SqlSession sqlSession = MybatisUtils.getSqlSession();
   
       try {
           // getMapper
           UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
           User user = userMapper.getUserById(1);
   
           System.out.println(user);
       }catch (Exception e) {
           e.printStackTrace();
       }finally {
           // 关闭SqlSession
           sqlSession.close();
       }
   }
   

3、insert

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

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

4、update

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

   <insert id="updateUser"  parameterType="com.lj.pojo.User">
       update mybatis.user set name=#{name},pwd=#{pwd}  where id = #{id} ;
   insert>
   

5、delete

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

   <insert id="deleteUser" parameterType="int">
       delete from mybatis.user  where id = #{id} ;
   insert>
   

注意点：

• 增删改需要提交事务

6、分析错误

• 标签不要匹配错
• resource绑定mapper，需要使用路径
• 程序配置文件必须符合规范
• NullPointerException，没有注册到资源
• 输出的xml文件中存在中文乱码问题
• maven资源没有导出问题

7、万能Map

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

@Test
public void getUserById2Test(){
    // 第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    try {
        // getMapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("userID",4);
        map.put("userName","王五");
        User user = userMapper.getUserById2(map);

        System.out.println(user);
    }catch (Exception e) {
        e.printStackTrace();
    }finally {
        // 关闭SqlSession
        sqlSession.close();
    }
}

@Test
public void addUser2Test(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    try {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("userID",4);
        map.put("userName","王五");
        map.put("passWord","12345678");
        int result = userMapper.addUser2(map);
        if(result>0){
            System.out.println("插入成功！");
        }
        // 提交事务
        sqlSession.commit();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        sqlSession.close();
    }
}

Map传递参数，直接在sql中取出key即可

对象传递参数，直接在sql中取对象的属性即可

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

多个参数用Map，或者注解！

8、思考题

模糊查询怎么写？

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

   List<User> userList = mapper.getUserLike("李");
   

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

   select * from mybatis.user where name like "%"#{value}"%";
   

4、配置解析

1、核心配置文件

• mybatis-config.xml
• MyBatis的配置文件包含了会深深影响Mybatis行为的设置和属性信息
• configuration（配置）
  • properties（设置）
  • settings（设置）
  • typeAliases（类别别名）
  • typeHandlers（类型处理器）
  • objectFactory（对象工厂）
  • plugins（插件）
  • environment（环境配置）
    • environment（环境变量）
    • transactionManager（事务管理器）
    • dataSource（数据源）
  • databaseldProvider（数据库厂商标识）
  • mappers（映射器）

2、环境配置（environments）

Mybatis可以适应多种环境

一次只能选择一个环境

事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：

• JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。

• MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。例如:

  <transactionManager type="MANAGED">
    <property name="closeConnection" value="false"/>
  transactionManager>
  

如果在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置

数据源（dataSource）

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

• 大多数 MyBatis 应用程序会按示例中的例子来配置数据源。虽然数据源配置是可选的，但如果要启用延迟加载特性，就必须配置数据源。

有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）：

UNPOOLED– 这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对数据库连接可用性要求不高

POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这种处理方式很流行，能使并发 Web 应用快速响应请求

JNDI – 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用。这种数据源配置只需要两个属性

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

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

但要学会配置多套运行环境

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

3、属性（properties）

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

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

配置文件标签要按顺序

编写一个配置文件

db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT%2B8&useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=12345678

在核心配置文件中引入

<properties resource="db.properties">
    <property name="username" value="root"/>
    <property name="pwd" value="111111"/>
properties>

• 可以直接引入外部文件
• 可以在其中增加一些属性配置
• 如果两个文件有同一个字段，优先使用外部配置文件的

官方文档：

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。例如：

<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="dev_user"/>
  <property name="password" value="F2Fa3!33TYyg"/>
properties>

设置好的属性可以在整个配置文件中用来替换需要动态配置的属性值。比如:

<dataSource type="POOLED">
  <property name="driver" value="${driver}"/>
  <property name="url" value="${url}"/>
  <property name="username" value="${username}"/>
  <property name="password" value="${password}"/>
dataSource>

这个例子中的 username 和 password 将会由 properties 元素中设置的相应值来替换。 driver 和 url 属性将会由 config.properties 文件中对应的值来替换。这样就为配置提供了诸多灵活选择

如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：

• 首先读取在 properties 元素体内指定的属性。
• 然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。
• 最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。

因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的则是 properties 元素中指定的属性

4、类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写

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

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

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

<typeAliases>
   <package name="com.lj.pojo">package>
typeAliases>

每一个在包 com.lj.pojo 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 com.lj.pojo.User 的别名为 user；若有注解，则别名为其注解值。见下面的例子：

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

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

如果实体类十分多，建议使用第二种

第一种可以自定义别名，第二种则不行，如果非要改，需要在实体类上增加注释

5、设置（settings）

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

6、其他配置

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins（插件）
  • mybatis-generator-core
  • mybatis-plus
  • 通用mapper

7、映射器（mappers）

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

方式一：

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

方式二：

<mappers>
    <mapper class="com.lj.dao.UserMapper"/>
mappers>

注意点：

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

8、生命周期和作用域（Scope）

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

SqlSessionFactoryBuilder

• 一旦创建了 SqlSessionFactory，就不再需要它了
• 方法作用域（也就是局部方法变量）

SqlSessionFactory

• 可以想象成是一个数据库连接池
• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
• 应用作用域
• 最简单的就是使用单例模式或者静态单例模式

SqlSession

• 可以想象成是一个连接到连接池的一个请求
• 用完之后请求需要赶紧关闭，否则资源被占用
• SqlSession 的实例不是线程安全的，因此是不能被共享的
• 请求或方法作用域

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

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

数据库中的字段

新建一个项目，拷贝之前的，测试实体类

public class User {
    private int id;
    private String name;
    private  String password;
}

测试出现问题

解决方法：

• 起别名

  <select id="getUserById" parameterType="int" resultType="com.lj.pojo.User">
      select id,name,pwd as password from mybatis.user where id = #{id};
  select>
  

5.2、resultMap

结果集映射

id name pwd
id name password

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


<select id="getUserById" parameterType="int" resultMap="UserMap">
    select * from mybatis.user where id = #{id};
select>

• resultMap 元素是 MyBatis 中最重要最强大的元素
• ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了
• ResultMap 的优秀之处——你完全可以不用显式地配置它们
• 如果这个世界总是这么简单就好了

6、日志

6.1、日志工厂

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

之前：sout、debug

现在：日志工厂

• SLF4J
• LOG4J
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING
• NO_LOGGING

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

STDOUT_LOGGING：标准日志输出

6.2、log4j

什么是log4j？

• log4j是Apache的一个开源项目，通过使用log4j，我们可以控制日志信息树洞的目的地是控制台、文件、GUI组件
• 我们可以控制每一条日志的输出格式
• 通过定义每一条日志信息的级别，能够更加细致的控制日志的生成过程
• 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码

1. 先导入log4j的包

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

2. log4j.properties

   #将等级为debug的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
   log4j.rootLogger=debug,console,file
   
   #控制台输出的相关设置
   log4j.appender.console = org.apache.log4j.ConsoleAppender
   log4j.appender.console.Target = System.out
   log4j.appender.console.Threshold = debug
   log4j.appender.console.layout = org.apache.log4j.PatternLayout
   log4j.appender.console.layout.ConversionPattern = [%c]-%m%n
   
   #文件输出的相关设置
   log4j.logger.file = org.apache.log4j.RollingFileAppender
   log4j.appender.file = ./log/lj.log
   log4j.appender.file.MaxFileSize = 10mb
   log4j.appender.file.Threshold = debug
   log4j.appender.file.layout = org.apache.log4j.PatternLayout
   log4j.appender.file.layout.ConversionPattern = [%p][%d{yy-MM-dd}][%c]%m%n
   
   #日志输出级别
   log4j.logger.org.mybatis = debug
   log4j.appender.java.sql = debug
   log4j.appender.java.sql.Statement = debug
   log4j.appender.java.sql.ResultSet = debug
   log4j.appender.java.sql.PreparedStatement = debug
   

3. 配置log4j为日志的实现

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

4. log4j的使用，直接测试运行刚才的查询
   

简单使用

1. 再要使用log4j的类中导入包 import org.apache.log4j.Logger;

2. 日志对象，参数为当前类的class

   static Logger logger = Logger.getLogger(UserMapperTest.class);
   

3. 日志级别

   logger.info("info:进入了testLog4j");
   logger.debug("debug:进入了testLog4j");
   logger.error("error:进入了testLog4j");
   

7、分页

7.1、使用Limit分页

思考：为什么要分页？

• 减少数据的处理量

使用limit分页

语法： SELECT * from user linit startIndex,pageSize;
SELECT * from user limit 3;	#[0,n]

使用MyBatis实现分页，核心还是SQL

1. 接口

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

2. Mapper.xml

   
   <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
       select * from mybatis.user limit #{startIndex},#{pageSize};
   select>
   

3. 测试

   @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();
   }
   

7.2、RowBounds

不再使用sql实现分页

1. 接口

   //分页2
   List<User> getUserByRowBounds();
   

2. mapper.xml

   
   <select id="getUserByRowBounds" resultMap="UserMap">
       select * from mybatis.user;
   select>
   

3. 测试

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

7.3、分页插件

了解即可

8、使用注解开发

8.1、面向接口编程

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

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

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

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

关于接口的理解

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

三个面向区别

• 面向对象是指，我们考虑问题是，以对象为单位，考虑它的属性及方法
• 面向过程是指，我们考虑问题，以一个具体的流程（事物过程）为单位，考虑

8.2、使用注解开发

1. 注解在接口上实现

   @Select("select * from user")
   List<User> getUsers();
   

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

   
   <mappers>
       <mapper class="com.lj.dao.UserMapper"/>
   mappers>
   

3. 测试

本质：反射机制实现

底层：动态代理