lagou 爪哇 1-1 mybatis 笔记

笔记主要来源
https://gitee.com/lagouedu/Basic-document/blob/master/document/MyBatis.md

l 经典三层

web表现层(视图+controller)、service层、dao层

分层的好处

代码清晰、解耦、便于维护,出现问题容易定位

分层开发下的常见框架

dao层:hibernate、mybatis

service层:spring框架(对象容器)

web表现层:springmvc框架

[了解]原生JDBC操作数据库分析

package com.mybatis.dao;

import com.mybatis.pojo.User;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class UserDaoImpl implements UserDao {

   private String driver = "com.mysql.jdbc.Driver";
   private String url = "jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8";
   private String username = "root";
   private String password = "root";


   public List queryUserList() throws Exception {
      List userList = new ArrayList();

      Class.forName(driver);
      /**
       * 问题一:频繁获取/释放数据库连接,影响数据库和应用性能
       * 解决:数据库连接池技术,C3P0,DRUID(阿里巴巴荣誉出品,号称前无古人后无来者世界最强没有之一)
       */
      Connection connection = DriverManager.getConnection(url, username, password);
      /**
       * 问题二:sql语句硬编码,后期难以维护
       * 解决:若sql语句和java代码分离,比如sql写在配置文件中。Mybatis就是这么干的
       */
      String sql = "select * from user";
      /**
       * 问题三:sql语句where条件和占位符一一对应,后期难以维护
       */
      // String sql1 = "select * from user where username=? and id=?";
      PreparedStatement preparedStatement = connection.prepareStatement(sql);
      // preparedStatement.setInt(1,2);
      ResultSet resultSet = preparedStatement.executeQuery();
      User user = null;
      /**
       * 问题四:结果集解析麻烦,查询列硬编码
       * 期望:如果单条记录直接返回实体对象,如果多条记录返回实体的集合
       */
      while(resultSet.next()) {
         user = new User();
         user.setId(resultSet.getInt("id"));
         user.setUsername(resultSet.getString("username"));
         user.setSex(resultSet.getString("sex"));
         user.setBirthday(resultSet.getDate("birthday"));
         user.setAddress(resultSet.getString("address"));

         userList.add(user);
      }
      resultSet.close();
      preparedStatement.close();
      connection.close();
      return userList;
   }
}

Mybatis框架是一个半自动的ORM持久层框架,也可以在Java中实现类似 insert(User)的操作最终操作数据库,但是需要我们自己写Sql语句。Mybatis是目前比较流行的Dao层框架。

自定义Mybatis框架小结

l 框架的开发使用流程

编写源代码—>打jar包—>框架使用者引入jar包—>按照框架的规范进行XML配置—>Java程序中调用框架API实现功能

l 引入框架坐标即可,它所依赖的dom4j和jaxen都不需要我们引入,这是Maven的依赖传递

l 框架是基础知识的整合(本课程中的jdbc、dom4j、xpath、反射、数据库元数据等)

l 框架往往都会用到设计模式(本课程扩展了工厂设计模式和构建者设计模式)

l 框架展示了代码的拆分思想,各司其职,便于维护

[掌握]Mybatis框架快速入门

l Mybatis入门程序



junit
junit
4.12



org.mybatis
mybatis
3.4.5



mysql
mysql-connector-java
5.1.46



log4j
log4j
1.2.17


n pojo类User.java

package com.mybatis.pojo;

import java.util.Date;

public class User {

    private Integer id;
    private String username;
    private String sex;
    private Date birthday;
    private String address;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}';
    }
}

n SqlMapConfig.xml



















    

n UserMapper.xml






n 测试程序

@Test
public void testMybatis() throws IOException {
      InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      List list = sqlSession.selectList("test.queryUserList");
      if(list != null && list.size() > 0) {
      for (int i = 0; i < list.size(); i++) {
      User user =  list.get(i);
      System.out.println(user);
      }
      }
      sqlSession.close();
      }

[理解]关于三个对象

l SqlSessionFactoryBuilder: 创建工厂,生命周期短暂即可,类似于一个工具类

l SqlSessionFactory: 应该只有一个工厂对象即可。

l SqlSession: 和数据库通信的会话对象,底层对应connection连接。例如:假如多个线程公用一个sqlsession对象(connection),线程A操作了数据库尚未提交事务,线程B操作了数据库把这个connecttion的事务给提交了,会造成数据安全问题。所以一个线程应该有自己的一个sqlsession对象。

换言之,SqlSession是线程不安全的

[掌握]Mybatis入门级CRUD操作

功能需求:

基于已有数据表user,使用MyBatis实现以下功能:

n 根据用户id查询一个用户

n 根据用户名称模糊查询用户列表

n 添加一个用户

n 根据用户id修改用户名

n 根据用户id删除用户



junit
junit
4.12



mysql
mysql-connector-java
5.1.46



org.mybatis
mybatis
3.4.5



log4j
log4j
1.2.17






org.apache.maven.plugins
maven-compiler-plugin
3.1

1.8
1.8
utf-8




组件:

POJO

SqlMapConfig.xml

新增业务,修改:UserMapper.xml

关联SqlMapConfig和UserMapper

新增业务,修改:Java程序调用(测试程序)

根据用户id查询用户

l UserMapper.xml










l 测试程序

/**
 * 测试用例(Use_case):根据id查询用户
 */
@Test
public void testQueryUserById() throws IOException {
      InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      /*
       * 调用会话对象的api完成crud
       * param1:锁定sql的唯一标识符
       * param2:传入的参数
       * */
      User user = sqlSession.selectOne("test.queryUserById",1);
      System.out.println(user);
      sqlSession.close();
      inputStream.close();
      }

根据用户名模糊查询用户列表

l #{}方式取参

n UserMapper.xml




n 测试程序

/**
 * 测试用例(Use_case):根据用户名模糊查询用户列表
 */
@Test
public void testQueryUserByUsername() throws IOException {
      InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      // TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 2
      List  userList = sqlSession.selectList("test.queryUserByUsername","%王%");
      if(userList != null && userList.size() > 0) {
      for (int i = 0; i < userList.size(); i++) {
      User user =  userList.get(i);
      System.out.println(user);
      }
      }
      sqlSession.close();
      inputStream.close();
      }

l ${}方式取参

n UserMapper.xml





n 测试程序

  •  /**
     
      - 测试用例(Use_case):根据用户名模糊查询用户列表$取参形式
      */
     @Test
     public void testQueryUserByUsername$() throws IOException {
             InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
             SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
             SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
             SqlSession sqlSession = sqlSessionFactory.openSession();
             // TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 2
             List  userList = sqlSession.selectList("test.queryUserByUsername$","'%王%'");
             if(userList != null && userList.size() > 0) {
             for (int i = 0; i < userList.size(); i++) {
             User user =  userList.get(i);
             System.out.println(user);
             }
             }
             sqlSession.close();
             inputStream.close();
             }
    

小结

查询部分小结:

l selectOne,当结果集有多条记录的时候,抛出异常;

l #{}和${}使用原则

能使用#不用,特殊情况比如传入的参数是数据库对象(表名)或者order by的字段名时,不希望自动添加单引号对;

l 返回结果集列表的时候,resultType和返回单个对象配置都一样;

实现添加用户(及Mysql自增主键返回)






        select last_insert_id()

        insert into user(username,sex,birthday,address)
        values(#{username},#{sex},#{birthday},#{address})

自增主键返回:其实就是mybaits在执行完insert之后立马查询last_insert_id()

根据用户id修改用户名

update user set username=#{username} where id=#{id}

根据用户id删除用户

delete from user where id=#{id}

Mybatis解决原生JDBC操作数据库存在的问题

1、频繁创建、释放数据库连接造成系统资源浪费,影响系统性能。使用数据库连接池技术可以解决此问题。

解决:在SqlMapConfig.xml中配置数据连接池,使用连接池管理数据库连接。

2、Sql语句写在代码中造成代码不易维护,实际应用中Sql变化的可能较大,Sql变动需要改变java代码。

解决:将Sql语句配置在XXXXmapper.xml文件中与Java代码分离。

3、向Sql语句传参数麻烦,因为Sql语句的where条件不一定,可能多也可能少,占位符需要和参数一一对应(硬编码)。

解决:Mybatis自动将Java对象映射至Sql语句,通过statement中的parameterType定义输入参数的类型。

4、对结果集解析麻烦(查询列硬编码),Sql变化会导致解析代码变化,且解析前需要遍历,如果能将数据库记录封装成Pojo对象解析比较方便。

解决:Mybatis自动将Sql执行结果映射至Java对象,通过statement中的resultType定义输出结果的类型。

[掌握]Mybatis的两种Dao开发方式

使用MyBatis开发DAO的方式实现以下的功能:

n 根据用户id查询一个用户信息

原始Dao开发方式

​ 定义接口(UserDao)

​ 写实现类(UserDaoImpl):在实现类中写crud那套程序

l 定义接口UserDao

package com.mybatis.dao;

import com.mybatis.pojo.User;

/**
 * 原始Dao开发方式接口定义
 */
public interface UserDao {

    User queryUserById(Integer id) throws Exception;
}

l 写实现类

package com.mybatis.dao;

import com.mybatis.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

public class UserDaoImpl implements UserDao {

    /**
     * 声明一个SqlSessionFactory变量,用于接收service层调用dao层时传入的工厂对象
     * 因为工厂对象全局唯一,对于全局唯一的对象,在分层的架构中,dao层使用时候应该由
     * 外部传入
     */
    private SqlSessionFactory sqlSessionFactory;
    public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    @Override
    public User queryUserById(Integer id) throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = sqlSession.selectOne("test.queryUserById", id);
        sqlSession.close();
        return user;
    }
}

注意:分层其实是对原有代码的重新组织

l 思考

一个项目当中会有很多表,都对应dao接口和实现类,实现类就是做增删改查这些东西

能否不写实现类只定义接口,让框架帮我们完成实现类的逻辑,那么就是Mapper动态代理的开发方式

Mapper动态代理开发方式

l 定义一个Mapper接口,这个接口其实和我们UserDao接口是一样的

Mapper接口中的接口方法被调用时候,最终要找到这个接口方法所使用的sql语句?那如何找到呢?

遵从下面4个规范即可

l 从Mybatis框架中拿到一个代理对象(代理的是这个Mapper接口),通过代理对象调用接口当中的方法完成业务

n 传统dao开发方式中的实现类其实起了一个连接、承上启下的作用,连接了接口和xml映射文件,效果就是调用接口方法时能够找到xml映射文件

n Mapper动态代理开发遵从的规范

u sql映射文件的namespace必须和mapper接口的全限定类名保持一致

u mapper接口的接口方法名必须和xml中的sql语句id保持一致

u mapper接口的接口方法形参类型必须和sql语句的输入参数类型保持一致

u mapper接口的接口方法返回类型必须和sql语句的resultType保持一致

小结

原始Dao和Mapper动态代理开发在企业中都很常见,推荐使用Mapper动态代理开发模式

[掌握]全局配置文件SqlMapConfig.xml的使用说明

注意:子标签是有顺序要求的,因为使用了dtd校验

properties(属性)

引入外部属性文件

typeAliases(类型别名)

Mybatis默认支持的别名

别名 映射的类型
_byte byte
_long long
_short short
_int int
_integer int
_double double
_float float
_boolean boolean
string String
byte Byte
long Long
short Short
int Integer
integer Integer
double Double
float Float
boolean Boolean
date Date
decimal BigDecimal
bigdecimal BigDecimal
map Map

注意:更多默认别名参见mybatis源码中的TypeAliasRegistry

自定义别名

mappers(映射器)

引入sql语句的xml配置文件,把sql语句加载到内存当中

l 万能型选手,基础crud、原始dao开发、mapper动态代理开发都可以使用这种方式

l 针对mapper动态代理开发dao层,我们进行一个增加

mapper class属性:执行mapper接口类的全限定类名

​ 前提要求:

​ 1、编译之后 mapper.xml和mapper.class在同一个目录文件夹中

2、两个文件名称相同

[掌握]Mybatis的输入类型和结果类型

parameterType(输入类型)

l 传递简单类型

参考上面

l 传递Pojo对象

参考上面

l 传递Pojo包装对象

n 需求:使用POJO包装对象,根据用户名模糊查询用户列表

地址:http://epub.sipo.gov.cn/gjcx.jsp

resultType(输出类型)

l 输出简单类型

查询user表总记录数

l 输出Pojo对象

参考上面

l 输出Pojo列表

参考上面

resultMap(手动映射)

l 订单表POJO类

package com.mybatis.pojo;

import java.util.Date;

public class Orders {
    // 订单id
    private int id;
    // 用户id
    private Integer userId;
    // 订单号
    private String number;
    // 订单创建时间
    private Date createtime;
    // 备注
    private String note;

    public int getId() {
        return id;
    }

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

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }

    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", userId=" + userId +
                ", number='" + number + '\'' +
                ", createtime=" + createtime +
                ", note='" + note + '\'' +
                '}';
    }
}

n OrdersMapper.xml





















工程准备

新建一个Maven类型的module:实现Mybatis第二天的保存用户功能,便于基于该功能的代码程序说明Mybatis数据库连接池和Mybatis事务控制。

[理解]Mybatis连接池和事务控制

Mybatis连接池

l POOLED使用连接池

n 什么时候从连接池获取连接

getMapper的时候还是真正调用api操作数据库的时候?

从连接池获取连接的时机:真正操作数据库调用api的时候,不是getMapper的时候

l 其他

n UNPOOLED:不使用数据库连接池(一般不使用)

n JNDI:(前提你的Mybatis环境必须是Web应用)(了解)

u 什么是JNDI

JNDI:java naming directory interface(java命名目录接口),它是一种该服务发布技术,可以通过JNDI技术把数据源发布成一个服务,那么客户端可以调用这个服务

u 为什么必须是web应用

因为支持JNDI技术的往往是tomcat/weblogic/websphere这些中间件才支持JNDI技术

u 如果在Mybatis当中用,怎么用

参考附录

Mybatis事务控制

type="JDBC":使用Jdbc的事务管理机制,connection的事务

Mybatis默认把Jdbc的事务自动提交给关闭了

注意:考虑提交的数据量较小的时候使用自动提交,如果数据量大影响了操作数据库的性能,那么考虑分批次手动控制事务的提交

type="MANAGED":什么都不做,交给其他框架管理事务

[掌握]Mybatis映射文件的Sql深入(即动态Sql)

更优雅更方便的帮助我们拼接sql语句。

根据用户性别和用户名称查询用户列表

if标签/where标签

sql片段

引用sql片段使用include标签,refid指向sql片段的id,如果共享其他mapper文件当中的sql片段,只需要refid前面加上另外一个mapper映射文件的namespace即可

foreach标签

delete from user where id in(1,2,3)

String sql = "delete from user where id in("

for(String s: list) {

​   sql += s + ","

}

substring

sql += ")"

需求:根据多个id来查询用户列表

select * from user where id in(1,2,3)

l 形式一:直接传入list集合给mybatis

l 形式二:直接传入数组给Mybatis

Mybatis底层别名定义类


 

l 形式三:传入一个pojo,pojo中有list或者数组

 

[掌握]Mybatis的多表关联查询

多表:至少2张表

多表关系分析技巧:从一条记录出发,比如分析A表和B表的关系,就看A表的一条记录可以对应B表中几条记录,如果对应一条,从A到B表就是一对一的关系,如果对应多条就是一对多的关系。

多对多其实是双向的一对多

l 一对一

从订单表出发到用户表,一条订单记录只会对应用户表的一条记录,一对一

l 一对多

从用户表出发到订单表,一个用户记录可以对应订单表的多条记录,一对多

(通过主外键,一的一方是主表,多的一方是从表,外键在从表多的那一方)

l 多对多

用户和角色,一个用户可以有多个角色,一个角色也可以对应多个用户

通过中间表表达两个表之间的关系

a表 b表

id field.. id field..

中间表(往往两个字段即可)

aid bid

多表关联的SQL语句表达分析

l Sql语句表达

n 笛卡尔积

u SELECT * FROM USER,orders

SELECT * FROM USER u,orders o WHERE u.id=o.user_id(笛卡尔积进一步筛选)

n 关联查询

u 内关联 innder join on(和笛卡尔积进一步筛选效果一样)

SELECT * FROM USER u INNER JOIN orders o ON u.id=o.user_id

u 外连接(outer join on)(使用较多)

左外连接(left join) left join左边的表是基础表

SELECT * FROM USER u LEFT JOIN orders o ON u.id=o.user_id

右外连接(right join) right join右边的表是基础表

SELECT * FROM USER u RIGHT JOIN orders o ON u.id=o.user_id

l 内关联和外关联分析

一对一查询

Mybatis帮我们做的事情:

1、 SQL语句是用户自己写,Mybatis框架只是帮我们执行而已

2、 封装结果集

需求:查询订单表全部数据,关联查询出订单对应的用户数据(username address)

l Mapper映射文件


















 

l 测试程序

@Test
public void testQueryOrdersUser() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
        List ordersList = ordersMapper.queryOrdersUser();
        if(ordersList != null && ordersList.size() > 0) {
        for (int i = 0; i < ordersList.size(); i++) {
        Orders orders =  ordersList.get(i);
        System.out.println(orders);
        }
        }
        sqlSession.close();
        }

一对多查询

需求:查询全部用户数据,关联查询出订单数据

l Mapper映射文件























多对多查询

多对多关系分析

多对多是双向的一对多

实现Role到User的一对多

l Mapper映射文件














实现User到Role的一对多

[了解]扩展知识

Tomcat配置JNDI数据源(了解)

l 第一步:将数据库驱动程序(jar包)放到tomcat安装目录下的common\lib文件夹下

l 第二步:在Tomcat的conf/context.xml文件中进行jndi数据源服务配置

name:在JNDI中叫做目录名,等同于服务名,此处的jndi/mybatis是自定义的,往往以/连接前后字符串即可。

auth和type是固定的,其他都是数据库连接池的具体配置信息

l 第三步:在自己web项目的web.xml中引用Jndi数据源服务

l 第四步:在自己web项目的Mybatis配置文件中使用

配置data_source属性,指向你的数据源引用,java:comp/env/jndi/mybatis中红色部分是固定的,绿色部分是你自己定义的目录名(服务名)

工程准备

使用Mapper动态代理的方式实现:

l 根据用户id查询用户

l 查询全部订单数据并关联查询出用户数据(一对一)

l 查询全部用户数据并关联查询出订单数据(一对多)

便于基于代码程序讲解Mybatis延迟加载和缓存。

[掌握]Mybatis延迟加载策略

关联对象:数据库层次用户和订单是关联表,在对象层次订单对象和用户对象就叫做关联对象

什么是延迟加载?

在使用关联对象的过程中

比如使用了Orders对象,但是我只是获取Orders的订单数据尚未获取user的数据,但是依然查询了user表(这不是延迟)

我orders.getNumber()你不要查user表的数据,当我orders.getUser()你再去查user表

关联查询的关联对象,在较多的场合中并不需要的时候,只在少部分场合需要关联的那个对象数据,可以考虑使用延迟加载

Mybatis中怎么实现延迟加载?

步骤1:原来关联sql语句要拆分

1) 第一条sql查询基础表

2) 第二条sql根据基础表的条件查询关联表

步骤2:让两条sql自动产生联系,通过 或者

l 全局延迟加载开关配置(一对一和一对多都需要开启)

l 一对一关联查询的延迟加载















 

l 一对多关联查询的延迟加载















 

[了解]Mybatis缓存

Mybatis的一级缓存

Mybatis的一级缓存是SqlSession级别的缓存,是默认开启的

注意:以下情形缓存会失效(被清理掉):

n sqlSession关闭

n sqlSession提交事务:意味着可能是一个增删改的动作,数据表数据产生变化,那么这个时候Mybatis就会把这个sqlSession已有的一级缓存给清理掉

Mybatis的二级缓存

l Mybatis二级缓存机制

l 怎么用Mybatis的二级缓存

n 开启二级缓存开关

第一个开关:需要在SqlMapConfig.xml中开启二级缓存总开关

第二个开关:需要在使用二级缓存的mapper.xml中开启(因为二级缓存是mapper级别的)

n Pojo实现序列化

ratio:命中率的意思,两次都去查询了二级缓存,但是第一次的时候缓存中没有数据,所以没有命中,第二次查询的时候缓存中已经有数据了,所以命中率是0.5

l Mybatis二级缓存的清理时机:当这个mapper.xml中执行了非select语句的时候,整个Mapper的缓存全部清除掉。

注意:避免使用二级缓存,因为二级缓存带来的好处远远比不上他所隐藏的危害

n 如果你针对user表的sql操作并不是全部都在UserMapper.xml中,使用缓存的结果可能会不正确。

n 多表操作一定不能使用缓存

为什么不能?
首先不管多表操作写到那个Mapper.xml下,都会存在某个表不在这个Mapper下的情况。
例如两个表:role和user_role,如果我想查询出某个用户的全部角色role,就一定会涉及到多表的操作


像上面这个查询,你会写到那个xml中呢??
不管是写到RoleMapper.xml还是UserRoleMapper.xml,或者是一个独立的XxxMapper.xml中。如果使用了二级缓存,都会导致上面这个查询结果可能不正确。
如果你正好修改了这个用户的角色,上面这个查询使用缓存的时候结果就是错的。

[掌握]Mybatis的注解开发

效果:没有写sql语句的xml了

l 基础的crud(基础crud怎么使用注解)

l 关联查询延迟加载(怎么使用注解完成)

l 动态sql的注解方式

原则:把原来xml里面的内容都对应的放到注解上即可

注解开发不需要引入额外的jar包,和原来一致即可

注解添加在接口类的方法上

使用注解实现基本的CRUD

@Insert("insert into user(username,sex,birthday,address) values (#{username},#{sex},#{birthday},#{address})")

/*回显mysql自增主键id 
  等同于原来我们xml中使用,一一对应过来即可
* */
@SelectKey(statement = "select last_insert_id()",before = false,keyProperty = "id",resultType = Integer.class)
void saveUser(User user);

@Update("update user set username=#{username} where id=#{id}")
void updateUsernameById(User user);

@Delete("delete from user where id=#{id}")
void deleteUserById(Integer id);

@Select("select id,username,sex,birthday,address from user where id=#{id}")
User queryUserById(Integer id);

@Select("select id,username,sex,birthday,address from user")
List queryUserList();


@Select("")
List queryUserByWhere(User user);


@Select("")
List queryUserByIdsList(List ids); 

使用注解实现复杂关系映射开发

使用注解实现一对一查询

/*
 * 对应关系
 * @Results对应xml中的resultMap
 * @Result对应xml中的id/result
 * id:true/false,是否是主键,默认false
 * column:查询列名
 * property:pojo属性名
 * association:在注解中使用@Result+one=@One的方式去表达
 * fetchType:延迟加载类型,默认是延迟加载,eager:积极加载
 * */

@Results({
        @Result(id = true,column = "id",property = "id"),
        @Result(column = "user_id",property = "userId"),
        @Result(column = "number",property = "number"),
        @Result(column = "createtime",property = "createtime"),
        @Result(column = "note",property = "note"),
        @Result(property = "user",column = "user_id",javaType = User.class,one=@One(select = "com.mybatis.mapper.UserMapper.queryUserByUserid",fetchType = FetchType.LAZY))
})
List queryOrdersUser();

@Select("select id,username,sex,birthday,address from user where id=#{user_id}")
User queryUserByUserid(Integer id); 

使用注解实现一对多查询

l mapper接口

/*
 * 对应关系
 * @Results对应xml中的resultMap
 * @Result对应xml中的id/result
 * id:true/false,是否是主键,默认false
 * column:查询列名
 * property:pojo属性名
 * collection:在注解中使用@Result+many=@Many的方式去表达
 * xml中的ofType在注解中使用 javaType表达=List.class
 * fetchType:延迟加载类型,默认是延迟加载,eager:积极加载
 * */
@Select("select id,username,sex,birthday,address from user")
@Results({
        @Result(id = true,column = "id",property = "id"),
        @Result(column = "username",property = "username"),
        @Result(column="sex",property="sex"),
        @Result(column="birthday",property="birthday"),
        @Result(column="address",property="address"),
        @Result( property="ordersList",javaType = List.class,column="id",
                many = @Many(select="com.mybatis.mapper.OrdersMapper.queryOrdersByUserid",fetchType = FetchType.LAZY))
})
List queryUserOrders();

@Select("select id,number from orders where user_id=#{userId}")
List queryOrdersByUserid(Integer userId); 

你可能感兴趣的:(lagou 爪哇 1-1 mybatis 笔记)