2021.12.15    

mybatis 配置属性

properties（属性）

property

settings（全局配置参数）

setting

typeAliases（类型别名）

typeAliase

package

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境集合属性对象）

environment（环境子属性对象）

transactionManager（事务管理）

dataSource（数据源）

mappers（映射器）

mapper

package

① Properties属性

在使用 properties 标签配置时，我们可以采用两种方式指定属性配置。

第一种：

properties>

property name="jdbc.driver" value="com.mysql.jdbc.Driver"/>

property name="jdbc.url" value="jdbc:mysql://localhost:3306/test"/>

property name="jdbc.username" value="root"/>

property name="jdbc.password" value="root"/>

properties>

第二种：

在classpath下创建db.properties文件

jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/test 

jdbc.username=root

jdbc.password=root

 

properties  url=  file:///D:/workspace/day02_test/src/db.properties">properties>

此时我们的 dataSource 标签就变成了引用上面的配置

dataSource type="POOLED">

property name="driver" value="${jdbc.driver}"/>

property name="url" value="${jdbc.url}"/>

property name="username" value="${jdbc.username}"/>

property name="password" value="${jdbc.password}"/>

dataSource>

 

② typeAliases属性

在前面我们讲的 Mybatis 支持的默认别名，我们也可以采用自定义别名方式来开发

在 mybatis-config.xml 中配置：

typeAliases>

typeAlias alias="user" type="com.tledu.zrz.pojo.User"/>

package name="com.tledu.zrz.pojo"/>

package name="其它包"/>

typeAliases>

③ Mappers属性

Mappers使我们所说的映射器,用于通过mybatis配置文件去找到对应的mapper文件

有三种用法

④Resources

使用相对于类路径的资源

如：

⑤class

使用 mapper 接口类路径

如：

注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

⑥Package

注册指定包下的所有 mapper 接口

如：

注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

2.Mapper.xml属性

1.#和$区别

#{}表示一个占位符号

通过#{}可以实现 preparedStatement 向占位符中设置值，自动进行 java 类型和 jdbc 类型转换，

#{}可以有效防止 sql 注入。

举例：select * from user where username = ' ' or 1=1 # and passord=''

#{}可以接收简单类型值或 pojo 属性值。 如果 parameterType 传输单个简单类

型值，#{}括号中可以是 value 或其它名称。

可以自动对值添加 ’ ’ 单引号

${}表示拼接 sql 串

通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换， ${}可以接收简

单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，${}括号中只能是 value。

比如order by id  这种的,以id排序  那么这个id 是没有单引号的,就是简单的SQL拼接,所以我们应该使用${} 而不是#{}

举例： ALTER TABLE (表名)  ADD  keycode（字段） varchar(500)

2.parameterType 配置参数

我们在上一章节中已经介绍了 SQL 语句传参，使用标签的 parameterType 属性来设定。该属性的取值可以是基本类型，引用类型（例如:String 类型），还可以是实体类类型（POJO 类）。同时也可以使用实体类的包装类，本章节将介绍如何使用实体类的包装类作为参数传递。

注意事项

基本类型和String我们可以直接写类型名称,也可以使用包名.类名的方式

例如 ：

java.lang.String

实体类类型，目前我们只能使用全限定类名。

究其原因，是 mybaits 在加载时已经把常用的数据类型注册了别名，从而我们在使用时可以不写包名，而我们的是实体类并没有注册别名，所以必须写全限定类名。在 mybatis 的官方文档的说明(第 19 页)

3.resultType

resultType 属性可以指定结果集的类型，它支持基本类型和实体类类型。

我们在前面的 CRUD 案例中已经对此属性进行过应用了。

需要注意的是，它和 parameterType 一样，如果注册过类型别名的，可以直接使用别名。没有注册过的必须使用全限定类名。

例如：我们的实体类此时必须是全限定类名

同时，当是实体类名称时，还有一个要求，实体类中的属性名称必须和查询语句中的列名保持一致，否则无法实现封装(不区分大小写)

 

4.resultMap

我们在resultType ，提到在声明返回值类型为实体类型之后，实体中的属性必须和查询语句中的属性对应上，但是我们在开发的过程中也难免会遇到无法对应的情况。比如说我们在进行数据库设计的时候，多个单词往往是用_连接，但是在实体类中的属性往往采用小驼峰的方式命名。这就导致字段名无法对应上，这个时候我们就需要配置resultMap来解决这个问题了。

通过resultMap，我们可以指定查询结果字段和实体属性字段的映射关系。

配置插件

在mybatis-config.xml中，添加plugins标签配置，表示开启PageHelper插件

                                                                                                                            .....           ...      

修改CategoryMapper.xml

limit注释掉，因为分页相关工作，会由PageHelper去做掉，不需要自己去写了

                          select * from   t_category                  

分页查询测试

查询很有意思，只需要在执行查询所有的调用之前，执行一条语句即可：

PageHelper.offsetPage(0, 5);

public class TestMybatis {     public static void main(String[] args) throws IOException, InterruptedException {         String resource = "mybatis-config.xml";         InputStream inputStream = Resources.getResourceAsStream(resource);         SqlSessionFactory sqlSessionFactory = newSqlSessionFactoryBuilder().build(inputStream);         SqlSession session = sqlSessionFactory.openSession();                PageHelper.offsetPage(0, 5);           List cs = session.selectList("listCategory");         for (Category c : cs) {             System.out.println(c.getName());         }           session.commit();         session.close();     } }

获取总数

public class TestMybatis {     public static void main(String[] args) throws IOException, InterruptedException {         String resource = "mybatis-config.xml";         InputStream inputStream = Resources.getResourceAsStream(resource);         SqlSessionFactory sqlSessionFactory = newSqlSessionFactoryBuilder().build(inputStream);         SqlSession session = sqlSessionFactory.openSession();                PageHelper.offsetPage(0, 5);           List cs = session.selectList("listCategory");         for (Category c : cs) {             System.out.println(c.getName());         }                   PageInfo pageInfo = new PageInfo<>(cs);         System.out.println("总数："+pageInfo.getTotal());         System.out.println(pageInfo);           session.commit();         session.close();     } }

-------------------------------------------------------------------------------------------------------------------------------------

四、完成模糊查询

模糊查询

1. 修改UserMapper.xml，提供listUserByName查询语句

select * from t_user where username like concat('%',#{0},'%')

2. 测试

@Test public void listUserByName() { SqlSession session = null; try { session = MybatisUtil.getSession(); List list = session.selectList("User.listUserByName","d"); for (User user : list) { System.out.println(user); } } catch (Exception e) { e.printStackTrace(); } finally { MybatisUtil.closeSession(session); } }

多条件查询

结合前面的模糊查询，多一个id大于多少的条件

1. UserMapper.xml 准备sql语句

select * from t_user where id> #{id} and username like concat('%',#{username},'%')

2. 测试代码

因为是多个参数，而session.selectList()方法又只接受一个参数对象，所以需要把多个参数放在Map里，然后把这个Map对象作为参数传递进去

Map params = new HashMap<>(); params.put("id", 8); params.put("username", "d"); List ulist= session.selectList("User.listUserByIdAndName",params);

-------------------------------------------------------------------------------------------------------------------------------------

五、掌握动态SQL

动态SQL是MyBatis的一个强大特性之一,如果你有使用 JDBC 或其他 相似框架的经验,你就明白条件地串联 SQL 字符串在一起是多么的痛苦,确保不能忘了空 格或在列表的最后省略逗号。动态 SQL 可以彻底处理这种痛苦。 

动态 SQL 元素和使用 JSTL 或其他相似的基于 XML 的文本处理器相似。在 MyBatis 之 前的版本中,有很多的元素需要来了解。MyBatis 3 大大提升了它们,现在用不到原先一半 的元素就能工作了。MyBatis 采用功能强大的基于 OGNL 的表达式来消除其他元素。

· if

· choose (when, otherwise)

· where等

用法可参照API MyBatis3.2.3帮助文档（中文版）.chm

创建产品表

create table t_product( id int NOT NULL AUTO_INCREMENT, name varchar(30) DEFAULT NULL, price float DEFAULT 0, cid int , PRIMARY KEY (id) )AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

新增6条产品数据

INSERT INTO t_product VALUES (1,'product a', 88.88, 1); INSERT INTO t_product VALUES (2,'product b', 88.88, 1); INSERT INTO t_product VALUES (3,'product c', 88.88, 1); INSERT INTO t_product VALUES (4,'product x', 88.88, 2); INSERT INTO t_product VALUES (5,'product y', 88.88, 2); INSERT INTO t_product VALUES (6,'product z', 88.88, 2);

创建Product实体类

public class Product {     private int id;     private String name;     private float price;     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 float getPrice() {         return price;     }     public void setPrice(float price) {         this.price = price;     }     @Override     public String toString() {         return "Product [id=" + id + ", name=" + name + ", price=" + price + "]";     }

动态SQL导入

执行不同的条件限定，需要准备两条sql语句

假设需要对Product执行两条sql语句，一个是查询所有，一个是根据名称模糊查询。

那么按照现在的方式，必须提供两条sql语句：listProduct和listProductByName

然后在调用的时候，分别调用它们来执行。

在ProductMapper.xml添加如下代码

              select * from t_product                              select * from t_product where name like concat('%',#{name},'%')             

在测试类进行测试

    System.out.println("查询所有的");     List ps = session.selectList("listProduct");     for (Product p : ps) {          System.out.println(p);     }               System.out.println("模糊查询");     Map params = new HashMap<>();     params.put("name","a");     List ps2 = session.selectList("listProductByName",params);     for (Product p : ps2) {          System.out.println(p);     } 

if标签

如果Product的字段比较多的话，为了应付各个字段的查询，那么就需要写多条sql语句，这样就变得难以维护。这个时候，就可以使用Mybatis 动态SQL里的if标签

select * from t_product where name like concat('%',#{name},'%')

在测试类进行测试

    System.out.println("查询所有的");     List ps = session.selectList("listProduct");     for (Product p : ps) {          System.out.println(p);     }               System.out.println("模糊查询");     Map params = new HashMap<>();     params.put("name","a");     List ps2 = session.selectList("listProductByName",params);     for (Product p : ps2) {          System.out.println(p);     } 

where标签

基于上一个知识点if 标签进行

在ProductMapper.xml添加如下代码

如果要进行多条件判断，就会写成这样：

select * from t_product where name like concat('%',#{name},'%') and price > #{price}

这么写的问题是：当没有name参数，却有price参数的时候，执行的sql语句就会是：

select * from t_product and price > 10

这样执行就会报错

这个问题可以通过标签来解决，如代码所示

select * from t_product and name like concat('%',#{name},'%') and price > #{price}

标签会进行自动判断

如果任何条件都不成立，那么就在sql语句里就不会出现where关键字

如果有任何条件成立，会自动去掉多出来的 and 或者 or。

所以在测试代码里

Map params = new HashMap<>(); //params.put("name","a"); params.put("price","10");

这个参数map，无论是否提供值都可以正常执行

set标签

与where标签类似的，在update语句里也会碰到多个字段相关的问题。 在这种情况下，就可以使用set标签：

            update t_product                      name=#{name},             price=#{price}                   where id=#{id}        

其效果与where标签类似，有数据的时候才进行设置。

测试：

Product p = new Product(); p.setId(6); p.setName("product zz"); p.setPrice(99.99f); session.update("updateProduct",p);

trim标签

trim 用来定制想要的功能，比如where标签就可以用

prefix ：内容之前加的前缀 

suffix ：内容之后加的后缀 

prefixOverrides:  属性会忽略通过管道分隔的文本序列

...

来替换

set标签就可以用

...

来替换

测试ProductMapper.xml

        select * from t_product                                       name like concat('%',#{name},'%')                                                   price > #{price}                                       update t_product                      name=#{name},             price=#{price},                  where id=#{id}     

choose、when、otherwise

类似于Java中的switch case default

在ProductMapper.xml文件中添加如下代码

SELECT * FROM t_product and name like concat('%',#{name},'%') and price > #{price} and id >1

在测试类中添加如下代码测试

      Map params = new HashMap<>(); //    params.put("name","a"); //    params.put("price","10");       List ps = session.selectList("listProduct",params);       for (Product p : ps) {           System.out.println(p);       }

foreach标签

ProductMapper.xml

foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。

foreach元素的属性主要有 item，index，collection，open，separator，close。

item集合中每一个元素进行迭代时的别名，

open该语句以什么开始，

separator在每次进行迭代之间以什么符号作为分隔 符，

close以什么结束，

在使用foreach的时候最关键的也是最容易出错的就是collection属性，

该属性是必须指定的，但是在不同情况 下，该属性的值是不一样的，

主要有一下3种情况：

1.     如果传入的是单参数且参数类型是一个List的时候，collection属性值为list

2.     如果传入的是单参数且参数类型是一个array数组的时候，collection的属性值为array

3.     如果传入的参数是多个的时候，我们就需要把它们封装成一个Map了

 

       SELECT * FROM t_product            WHERe ID in                                    #{item}                  

在测试类中添加如下代码测试

List ids = new ArrayList();         ids.add(1);         ids.add(3);         ids.add(5);            List ps = session.selectList("listProduct",ids);       for (Product p : ps) {           System.out.println(p);       }

        ids.add(1);

bind标签

ProductMapper.xml

                                                      select * from  t_product where name like #{likename}         

             

在测试类中添加如下代码测试

Map params =new HashMap();     params.put("name", "product");          List ps = session.selectList("listProduct",params);        for (Product p : ps) {            System.out.println(p);        }

六、关联查询

在项目中，某些实体类之间肯定有关联关系，比如一对一、多对一、一对多、多对多等，在mybatis 中可以通过association和collection，来处理这些关联关系。

1、一对多

对于产品类型来说，一种产品类型就对应了多个产品，那么在mybatis中我们可以通过collections解决。

1.1、创建产品表

create table t_product( id int NOT NULL AUTO_INCREMENT, name varchar(30) DEFAULT NULL, price float DEFAULT 0, cid int , PRIMARY KEY (id) )AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

1.2、创建产品类型表

create table t_category ( id int(11) NOT NULL AUTO_INCREMENT, name varchar(32) DEFAULT NULL, PRIMARY KEY (id) ) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

1.3、清空t_category 和 t_product_ 表 新增2条分类数据，id分别是1,2 ；新增6条产品数据，分

别关联上述2条分类数据

delete from t_category; INSERT INTO t_category VALUES (1,'category1'); INSERT INTO t_category VALUES (2,'category2'); delete from t_product; INSERT INTO t_product VALUES (1,'product a', 88.88, 1); INSERT INTO t_product VALUES (2,'product b', 88.88, 1); INSERT INTO t_product VALUES (3,'product c', 88.88, 1); INSERT INTO t_product VALUES (4,'product x', 88.88, 2); INSERT INTO t_product VALUES (5,'product y', 88.88, 2); INSERT INTO t_product VALUES (6,'product z', 88.88, 2);

1.4、创建Product实体类

public class Product {     private int id;     private String name;     private float price;     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 float getPrice() {         return price;     }     public void setPrice(float price) {         this.price = price;     }     @Override     public String toString() {         return "Product [id=" + id + ", name=" + name + ", price=" + price + "]";     }

1.5、创建Category实体

public class Category {     private int id;     private String name;     List products;     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 List getProducts() {         return products;     }     public void setProducts(List products) {         this.products = products;     }     @Override     public String toString() {         return "Category [id=" + id + ", name=" + name + "]";     } }

1.6、创建CategoryMapper.xml

select c.*, p.*, c.id 'cid', p.id 'pid', c.name 'cname', p.name 'pname' from t_category c left join t_product p on c.id = p.cid

1.7、创建MyBatis测试类

 public static void main(String[] args) throws IOException {     String resource = "mybatis-config.xml";     InputStream inputStream = Resources.getResourceAsStream(resource);     SqlSessionFactory sqlSessionFactory = newSqlSessionFactoryBuilder().build(inputStream); SqlSession session = sqlSessionFactory.openSession();            List cs = session.selectList("listCategory");         for (Category c : cs) {             System.out.println(c);             List ps = c.getProducts();             for (Product p : ps) {                 System.out.println("t"+p);             }         }         session.commit();         session.close();     }

2、多对一

对于产品类型来说，一种类型就对应了多个产品，但对于产品来说只能对应一种产品类型，这种情况，在mybatis中就可以通过association 解决。本知识点建立在一对多的基础上讲解多对一关系。

2.1、修改Product.java 添加Category对象属性

public class Product {     private int id;     ......     private Category category;           public Category getCategory() {         return category;     }     public void setCategory(Category category) {         this.category = category;     }     ......     @Override     public String toString() {         return "Product [id=" + id + ", name=" + name + ", price=" + price + "]";     } }

2.2、创建ProductMapper.xml

                                                                                                                                                                                              select c.*, p.*, c.id 'cid', p.id 'pid', c.name 'cname', p.name 'pname' from t_category c left join t_product p on c.id = p.cid         

        

2.3、修改mybatis-config.xml

                                                                                                                                                                   

2.4、在测试类中测试

 public static void main(String[] args) throws IOException {         String resource = "mybatis-config.xml";         InputStream inputStream = Resources.getResourceAsStream(resource);         SqlSessionFactory sqlSessionFactory = newSqlSessionFactoryBuilder().build(inputStream);         SqlSession session = sqlSessionFactory.openSession();         List ps = session.selectList("listProduct");         for (Product p : ps) {             System.out.println(p+" 对应的分类是 t "+ p.getCategory());         }         session.commit();         session.close();     }