Mybatis框架学习笔记（01）

彤彤的小跟班

已于 2022-04-22 10:31:00 修改

阅读量767

点赞数 4

分类专栏： SSM框架相关学习记录文章标签： mybatis mysql java

于 2020-07-29 21:29:57 首次发布

本文链接：https://blog.csdn.net/weixin_45583303/article/details/106386159

版权

SSM框架相关学习记录专栏收录该内容

12 篇文章 21 订阅

订阅专栏

01.Mybatis框架概述

Mybatis是一个基于java的持久层框架，内部封装了jdbc，使开发者只需要关注SQL语句本身，无需要花费精力去处理加载驱动，创建连接，创建Statement等复杂过程。
Mybatis通过XML或者注解的方式将要执行的各种statement配置起来，并通过java对象和statement中的SQL的动态参数进行映射，生成最终需要执行的SQL语句，最后由mybatis框架执行SQL并将结果映射为java对象返回。
使用mybatis配置之后就不用再写dao接口的实现类了（通过动态代理的方式创建实体类）
ORM：Object Relational Mapping 对象关系映射

简而言之：把数据库表的字段和实体类的属性对应起来，通过操作实体类实现对数据库表的操作

02.传统JDBC使用

传统JDBC指的是使用JDK自带的数据库连接库，使用方式包括如下步骤：注册驱动，获取连接，预处理，执行SQL语句，遍历结果集，释放资源

Connection
PerparedStatement
ResultSet

前提：声明三个变量
Connection connection=null;
PreparedStatement preparedStatement=null;
ResultSet resultSet=null;
1.加载数据库驱动(注册驱动)
Class.forName("com.mysql.jdbc.Driver");
2.通过驱动管理类获得数据库连接
Connection connection=DriverManager.getConnection(URL,USER,PASSWORD);
3.定义要执行的SQL语句
String sql="select * from user";
4.获取预处理statement
PreparedStatement=connection.prepareStatement(sql);
5.执行SQL语句获取结果集
resultSet=preparedStatement.executeQuery();
6.遍历结果集
while(resultSet.next()){
		
	}
7.释放资源
resultSet.close();
preparedStatement.close();
connection.close();

03.Mybatis环境搭建（入门案例）

3.1.创建一个maven工程（mybatis01）

mybatis坐标

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.4.5</version>
</dependency>

mysql坐标

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.6</version>
</dependency>

junit坐标

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.10</version>
</dependency>

3.2.创建一个数据库表（user）

数据库名称：myMabatis
表名称：user

1.创建表语句
CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
  `birthday` datetime default NULL COMMENT '生日',
  `sex` char(1) default NULL COMMENT '性别',
  `address` varchar(256) default NULL COMMENT '地址',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
2.添加信息语句
insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values 
(41,'老王','2018-02-27 17:47:08','男','河南'),
(42,'小王','2018-03-02 15:09:37','女','河南'),
(43,'小二王','2018-03-04 11:34:34','女','河南'),
(45,'隔壁老王','2018-03-04 12:04:06','男','河南'),
(46,'老王','2018-03-07 17:37:26','男','河南'),
(48,'老张','2018-03-08 11:44:00','女','河南');

3.3.在包下创建一个实体类（User.java）

注意：属性名称要与数据库的字段对应
1.声明属性变量
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
2.使用IEDA快速生成set和get方法以及重写toString方法

3.4.在包下创建一个持久层接口（IUserDao）

查询所有方法
List<User> findAll();

3.5.在Resource文件夹下创建mybatis的`主配置文件`（sqlMapConfig.xml）—重点掌握

<?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">
        <!--使用Alt+Enter引入包-->
        
<!--mybatis的主配置文件-->
<configuration>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <!--配置连接数据库的4个基本信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/myMybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="12345678"/>
            </dataSource>
        </environment>
    </environments>
    <!--指定映射配置文件的位置-->
    <mappers>
        <mapper resource="com/aismall/dao/IUserDao.xml"/>
    </mappers>
</configuration>

3.6.在Resource文件夹下创建`映射配置文件`的约束（IUserDao.xml）—重点掌握

此处注意要在Resource中创建与dao接口相同包，然后把文件放到包中

<?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">
        <!--Alt+Enter解决爆红问题-->
<!--Mapper映射配置文件-->
<!--此处的namespace的值一定要与SqlMapConfig.xml中mapper标签中的值对应-->
<mapper namespace="com.aismall.dao.IUserDao">
    <!--配置查询所有-->
    <select id="findAll" resultType="com.aismall.domain.User">
        select * from user;
    </select>
</mapper>

3.7.环境搭建注意事项

第一个：在Mybatis中把持久层的操作接口名称和映射配置文件叫做Mapper，我们叫做Dao，其实IUserDao 和 IUserMapper是一样的，只是叫法不同，都是持久层接口名称。
第二个：在idea中快速创建目录和包是不一样的，包（package）在创建时：com.aismall.dao它是三级结构，目录在创建时com.aismall.dao是一级目录
第三个：mybatis的映射配置文件目录结构必须和dao接口的包结构相同。
第四个：映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
第五个：映射配置文件的操作配置（select），id属性的取值必须和dao接口的方法名相同
当我们遵从了第三，四，五点之后，我们在开发中就无须再写dao的实现类（太棒了！！！！）

3.8.在test目录下创建一个包然后编写测试类（MybatisTest.java）

/*入门案例*/
public class MybatisTest {
    public static void main(String[] args) throws IOException {
        //1.读取配置文件
        InputStream io= Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂，因为接口不能直接new，所以借助SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        SqlSessionFactory factory=builder.build(io);
        //3.使用工厂生产SqlSession对象
        SqlSession session=factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象,因为此接口没有实现类，所以使用代理的方式对接口进行增强
        IUserDao userDao=session.getMapper(IUserDao.class);
        //5.使用代理对象执行方法
        List<User> users=userDao.findAll();
        for (User user: users) {
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        io.close();
    }
}

mybatis的入门案例总结

第一步：读取配置文件
第二步：创建SqlSessionFactory工厂
第三步：创建SqlSession
第四步：创建Dao接口的代理对象
第五步：执行dao中的方法
第六步：释放资源
注意事项：

不要忘记在映射配置中告知mybatis要封装到哪个实体类中，配置的方式：指定实体类的全限定类名

04.mybatis除了使用xml还可以使用注解（入门案例）

使用注解进行开发的时候，环境配置和上面的基本差不多，因为使用注解，所以Resource下的dao接口的映射配置文件就没有用了（IUserDao.xml），删除掉，然后进行改进，
注意：主配置文件（sqlMapConfig.xml）是不可以删除的。

4.1.在Resource文件夹下创建mybatis的约束（sqlMapConfig.xml）改写—重点掌握

只需要修改mappers标签内容：把映射配置文件位置修改为dao接口位置

<?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">
        <!--使用Alt+Enter引入包-->
<!--mybatis的主配置文件-->
<configuration>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <!--配置连接数据库的4个基本信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/myMybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="12345678"/>
            </dataSource>
        </environment>
    </environments>
    <!--指定dao接口的位置-->
    <mappers>
        <mapper class="com.aismall.dao.IUserDao"/>
    </mappers>
</configuration>

4.2.在dao接口的抽象方法上添加注解

public interface IUserDao {
    /*定义一个查询操作*/
    //使用注解
    @Select("select * from user")
    List<User> findAll();//抽象方法
}

4.3.基于注解使用的总结

mybatis基于注解的入门案例

把IUserDao.xml移除，在dao接口的方法上使用@Select注解，并且指定SQL语句
同时需要在SqlMapConfig.xml中的mapper配置时，使用class属性指定dao接口的全限定类名

05.mybatis的CRUD（代理Dao的方式）

5.1.环境搭建（基于xml方式）

1，创建一个maven工程（mybatis01）
2，创建一个数据库表（user）
3，在包下创建一个实体类（User.java）
4，在包下创建一个持久层接口（IUserDao）
5，在Resource文件夹下创建mybatis的约束（sqlMapConfig.xml
6，在Resource文件夹下创建映射配置文件的约束（IUserDao.xml）
在这里插入图片描述
注意：具体内容参考03节内容

5.2.在IUserDao中添加方法

/*用户持久层接口*/
public interface IUserdao {
    /*查询所有方法*/
    List<User> findAll();

    /*保存用户*/
    void saveUser(User user);

    /*更新用户*/
    void updateUser(User user);

    /*根据ID删除操作*/
    void deleteUser(Integer id);

    /*根据Id擦查询操作*/
    User findById(Integer id);

    /*根据用户名模糊查询*/
    List<User> findByName(String name);
}

5.3.在IUserDao.xml映射配置文件中进行配置（重点）

查询操作标签：select
插入操作标签：insert
更新操作标签：update
删除操作标签：delete

<?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确定该方法在哪个接口-->
<mapper namespace="com.aismall.dao.IUserdao">
    <!--id确定该接口中的方法-->
    <!--resultType确定结果封装的位置-->
    <!--parameterType确定传递参数数据类型-->
    
    <!--查询所有-->
    <select id="findAll" resultType="com.aismall.domain.User">
        select * from user;
    </select>
    
    <!--保存用户-->
    <insert id="saveUser" parameterType="com.aismall.domain.User">
    	<!--配置插入操作后，获取插入数据id的值-->
    	<selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
    		<!-- 此id必须是数据库中有的id-->
    		select last_insert_id();
   		</selectKey>
        insert into user(username,address,sex,birthday)values (#{username},#{address},#{sex},#{birthday});
    </insert>
    
    <!--更新用户-->
    <update id="updateUser" parameterType="com.aismall.domain.User">
        update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id=#{id};
    </update>
    
    <!--删除用户-->
    <!--当封装为基本类型的包装类时#{占位符}，占位符可以随意写-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id=#{Uid}
    </delete>
    
    <!--根据Id查询用户-->
    <!--注意：要说明查询过来的数据封装的位置（resultType）-->
    <select id="findById" parameterType="INT" resultType="com.aismall.domain.User">
        select * from user where id=#{Uid};
    </select>
    
    <!--根据名称模糊查询-->
    <select id="findByName" parameterType="String" resultType="com.aismall.domain.User">
        select * from user where username like #{name};
    </select>
</mapper>

5.4.编写测试类mybatisTest.java

/*编写测试类*/
public class mybatis_Test{
    //成员变量
    private  InputStream in;
    private SqlSession sqlSession;
    private IUserdao userdao;
    @Before//用于在测试方法执行之前操作
    /*初始化方法*/
    public void init() throws IOException {
        //1.读取配置文件，生成字节输入流
        //静态方法可以使用类名直接调用
        in= Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取sqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        //通过构建者创建工厂
        SqlSessionFactory factory=builder.build(in);
        //3.通过SqlSessionFactory工厂生成sqlSession对象
        sqlSession=factory.openSession();
        //4.获取dao的代理对象
        userdao=sqlSession.getMapper(IUserdao.class);
    }

    @After//用于在测试方法执行之后操作
    /*释放资源方法*/
    public void destory() throws IOException {
        //事务提交
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    @Test
    /*测试查询所有*/
    public void testFindAll() {
        //查询所有
        List<User> users=userdao.findAll();
        for (User user:users) {
            System.out.println(user);
        }
    }

    @Test
    /*测试保存数据*/
    public void testSaveUser() {
        User user=new User();
        user.setUsername("AISMALL");
        user.setAddress("北京市");
        user.setSex("女");
        user.setBirthday(new Date());

        userdao.saveUser(user);
        System.out.println("保存数据结束");
    }

    @Test
    /*更新用户*/
    public void testUpdateUser(){
        User user=new User();
        user.setUsername("AISMALl_01");
        user.setAddress("北京市");
        user.setSex("女");
        user.setBirthday(new Date());
        user.setId(41);

        userdao.updateUser(user);
        System.out.println("更新数据结束");
    }
    @Test
    public void testDeleteUser(){
        userdao.deleteUser(42);
        System.out.println("删除数据结束");
    }
    @Test
    /*根据id查询用户*/
    public void testFindById(){
        User user=userdao.findById(43);
        System.out.println(user);
    }

    @Test
    /*根据用户名进行模糊查询*/
    public void testFindByName(){
        //因为进行模糊查询，包含AISMALL的都被查询出来，所以下面要加上% %，SQL语法内容
        List<User> users=userdao.findByName("%AISMALL%");
        for (User user:users) {
            System.out.println(user);
        }
    }
}

06.配置文件参数深入以及结果集深入

6.1.parameterType(参数)

SQL语句传参，使用 parameterType标签属性来设置要传入参数的属性。参数属性可以是基本类型，引用类型（例如:String 类型），还可以是实体类类型（POJO 类），同时也可以使用实体类的包装类
- POJO（Plain Ordinary Java Object）：简单的Java对象，实际就是普通JavaBeans
- 基本类型和String类型：这种方式可以直接写类型名称，也可以使用包名类名的方式，例如：java.lang.String。
- 实体类类型：目前我们只能使用全限定类名。

6.1.1.parameterType传递 pojo 包装对象

在第五部分项目的基础上进行改写，

1.在IUserDao接口中添加方法，根据queryVo中的条键查询用户

/*根据queryVo中的条键查询用户*/
List<user> findUserByVo(QueryVo vo);

2.在domain包下创建一个类（QueryVo.java）

public class QueryVO{
	//1.成员属性
	private User user;
	//2.set和get方法
	public User getUser(){
		return user;
	}
	public void setUser(User user){
		this.user=user;
	}
}

3.在IUserDao.xml映射配置文件中添加一条查询记录

<!--根据queryVo的条件查询用户-->
<select id="findUserByVo" parameterType="com.aismall.domain.QueryVo" resultType="com.aismall.domain.User">
	select * from user where username like #{user.username}
</select>

分析：我们使用IUserDao接口中的findByname方法进行查询，此方法中需要一个name参数，我们通过parameterType传递过来是一个pojo类对象，我们要拿到该对象的username属性，就必须使用user.username这种方式

4.编写测试类（MybatisTest.java）

/*测试使用QueryVoid作为查询条件*/
@Test
public void testFindByVo(){
	QueryVo vo=new QueryVo();
	User user=new User();
	user.setUsername("%王%");
	//让两者建立关系
	vo.setUser(user);
	//使用代理类来调用方法
	List<User> users=userdao.findUserByVo(vo);
	for(User u:users){
		System.out.println(u);
	}
}

6.2.resultType(结果)

resultType 属性可以指定拿到结果集的类型，它支持基本类型和实体类类型
它和 parameterType 一样，如果注册过类型别名的，可以直接使用别名，没有注册过的必须使用全限定类名。例如：使用我们的自己编写的实体类就必须使用全限定类名
当是实体类名称是，还有一个要求，实体类中的属性名称必须和查询语句中的列名保持一致，否则无法实现封装。（ORM思想：实体类属相必须和数据库字段对应）
如果实体类属性名称和数据库字段的名称不对应，也不是没有办法，可以使用别名的方法（不想用，不想看），还是说一下吧，我们可以在sql语句中这样写

<select id="findAll" resultType="com.aismall.domain.User">
	select 
	id as userId,
	username as userName,
	birthday as userBirthday, 
	sex as userSex,
	address as userAddress from user
</select>

如果实体类属性和数据库字段名称对应，则等价于：select * from user

6.2.1.resultType为基本数据类型时

在第五部分和第6.1部分代码的基础上进行改写

1.在IUserDao接口中添加方法

/*查询总数*/
int findTotal();

2.在IUserDao.xml映射配置文件中添加一条记录

<select id="findTotal" resultType="INT">
	select count(*) from user;
</select>

分析：参数findTotal方法中没有参数，所以我们不需要传递参数，也就是省略parameterType参数。

3.编写测试类

/*测试查询总记录条数方法*/
@Test
public void testFindTotal(){
	int count=userdao.findTotal();
	System.out.println(count);
}

6.2.2.resultType为实体类时

和基本数据类型的操作差不多，只需要把resultType中的参数改为实体类的全限定类名即可

6.2.3.特殊情况

当实体类属性与数据库字段名称不匹配的时候，我们可以使用别名的方式，来用resultType进行接收返回结果，在前面也简单介绍了
如果感觉使用别名写SQL语句比较繁琐，我们可以使用resultMap来接收结果，下面将介绍resultMap。

6.3.resultMap(结果）

resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装
在 select 标签中使用 resultMap 属性指定引用即可

6.3.1.环境搭建

在这里插入图片描述

新建一个maven工程，用于演示当实体类的名称和数据库字段名称不匹配时做法
1，创建一个maven工程（mybatis_userMap）
2，数据库还是用之前的数据库即可
3，在包中创建实体类（User），然后生成set和get方法，重写toString方法

private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;

4，在Resource文件夹写导入主配置文件（SqlMapConfig.xml）

<?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="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置连接池-->
            <dataSource type="POOLED">
                <!--数据库驱动信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--数据库url信息-->
                <property name="url" value="jdbc:mysql://localhost:3306/myMybatis"/>
                <!--数据库用户名-->
                <property name="username" value="root"/>
                <!--数据库密码-->
                <property name="password" value="12345678"/>
            </dataSource>
        </environment>
    </environments>

    <!--配置映射文件位置-->
    <mappers>
        <!--resource代表xml，class代表映射-->
        <mapper resource="com/aismall/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

5，在Resource文件夹下出创建一个包，然后导入映射配置文件
（IUserDao.xml）

<?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">
        <!--Alt+Enter解决爆红问题-->
<mapper namespace="com.aismall.dao.IUserdao">
<!-- 
建立 User 实体和数据库表的对应关系
在resultMap标签中：
type 属性：指定实体类的全限定类名
id 属性：给定一个唯一标识，是给查询 select 标签引用用的

在result标签中：
id 标签：用于指定主键字段
result 标签：用于指定非主键字段
column 属性：用于指定数据库列名
property 属性：用于指定实体类属性名称
-->
<resultMap type="com.aismall.domain.User" id="userMap">
	<id column="id" property="userId"/>
	<result column="username" property="userName"/>
	<result column="sex" property="userSex"/>
	<result column="address" property="userAddress"/>
	<result column="birthday" property="userBirthday"/>
</resultMap>

<!-- 配置查询所有操作 -->
<select id="findAll" resultMap="userMap">
	select * from user
</select>
</mapper>

6，在包中创建一个接口（IUserDao）

/*用户持久层接口*/
public interface IUserdao {
    /*查询所有方法*/
    List<User> findAll();
}

7，编写测试类

/*编写测试类*/
public class mybatis_Test{
    //成员变量
    private  InputStream in;
    private SqlSession sqlSession;
    private IUserdao userdao;
    @Before//用于在测试方法执行之前操作
    /*初始化方法*/
    public void init() throws IOException {
        //1.读取配置文件，生成字节输入流
        //静态方法可以使用类名直接调用
        in= Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取sqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        //通过构建者创建工厂
        SqlSessionFactory factory=builder.build(in);
        //3.通过SqlSessionFactory工厂生成sqlSession对象
        sqlSession=factory.openSession();
        //4.获取dao的代理对象
        userdao=sqlSession.getMapper(IUserdao.class);
    }

    @After//用于在测试方法执行之后操作
    /*释放资源方法*/
    public void destory() throws IOException {
        //事务提交
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    @Test
    /*测试查询所有*/
    public void testFindAll() {
        //查询所有
        List<User> users=userdao.findAll();
        for (User user:users) {
            System.out.println(user);
        }
    }
}

6.3.2.定义resultMap

在前的环境搭建的第五步中的resultMap标签就是为了定义一个resultMap
resultMap使用之前需要先定义
如果遵循ORM思想，则不必使用resultMap
修改映射配置文件IUserDao.xml
抽取出来如下：

<!-- 
建立 User 实体和数据库表的对应关系
在resultMap标签中：
type 属性：指定实体类的全限定类名
id 属性：给定一个唯一标识，是给查询 select 标签引用用的

在result标签中：
id 标签：用于指定主键字段
result 标签：用于指定非主键字段
column 属性：用于指定数据库列名
property 属性：用于指定实体类属性名称
-->
<resultMap type="com.aismall.domain.User" id="userMap">
	<id column="id" property="userId"/>
	<result column="username" property="userName"/>
	<result column="sex" property="userSex"/>
	<result column="address" property="userAddress"/>
	<result column="birthday" property="userBirthday"/>
</resultMap>

<!-- 配置查询所有操作 -->
<select id="findAll" resultMap="userMap">
	select * from user
</select>

注意返回值的接收类型为resultMap类型

6.3.3.其他的CRUD方法

在IUserDao接口中添加方法

 /*保存用户*/
    void saveUser(User user);

    /*更新用户*/
    void updateUser(User user);

    /*根据ID删除操作*/
    void deleteUser(Integer id);

    /*根据Id擦查询操作*/
    User findById(Integer id);

    /*根据用户名模糊查询*/
    List<User> findByName(String name);

在IUserDao.xml中进行配置

 <!--保存用户-->
    <insert id="saveUser" parameterType="com.aismall.domain.User">
        insert into user(username,address,sex,birthday)values (#{userName},#{userAddress},#{userSex},#{userBirthday});
    </insert>
    <!--更新用户-->
    <update id="updateUser" parameterType="com.aismall.domain.User">
        update user set username=#{userName},address=#{userAddress},sex=#{userSex},birthday=#{userBirthday} where id=#{userId};
    </update>
    <!--删除用户-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id=#{Uid}
    </delete>
    <!--根据Id查询用户-->
    <!--注意：要说明查询过来的数据封装的位置（resultType）-->
    <select id="findById" parameterType="INT" resultMap="userMap">
        select * from user where id=#{Uid};
    </select>
    <!--根据名称模糊查询-->
    <select id="findByName" parameterType="String" resultMap="userMap">
        select * from user where username like #{name};
    </select>

在测试类中添加测试方法

  @Test
    /*测试保存数据*/
    public void testSaveUser() {
        User user=new User();
        user.setUserName("AISMALL");
        user.setUserAddress("北京市");
        user.setUserSex("女");
        user.setUserBirthday(new Date());

        userdao.saveUser(user);
        System.out.println("保存数据结束");
    }

    @Test
    /*更新用户*/
    public void testUpdateUser(){
        User user=new User();
        user.setUserName("AISMALL");
        user.setUserAddress("北京市");
        user.setUserSex("女");
        user.setUserBirthday(new Date());
        user.setUserId(41);

        userdao.updateUser(user);
        System.out.println("更新数据结束");
    }
    @Test
    public void testDeleteUser(){
        userdao.deleteUser(42);
        System.out.println("删除数据结束");
    }
    @Test
    /*根据id查询用户*/
    public void testFindById(){
        User user=userdao.findById(43);
        System.out.println(user);
    }

    @Test
    /*根据用户名进行模糊查询*/
    public void testFindByName(){
        //因为进行模糊查询，包含AISMALL的都被查询出来，所以下面要加上% %，SQL语法内容
        List<User> users=userdao.findByName("%AISMALL%");
        for (User user:users) {
            System.out.println(user);
        }

07.mybatis中的主要配置文件分析（sql.MapConfig.xml）

SqlMapConfig.xml 中配置的内容和顺序

-properties（属性）
	--property
	
-settings（全局配置参数）
	--setting
	
-typeAliases（类型别名）
	--typeAliase
	--package
	
-typeHandlers（类型处理器）

-objectFactory（对象工厂）
-plugins（插件）

-environments（环境集合属性对象）
	--environment（环境子属性对象）
		---transactionManager（事务管理）
		---dataSource（数据源）
		
-mappers（映射器）
	--mapper
	--package

7.1.properties标签（属性）

7.1.1.第一种配置方法

之前一直在使用

<properties>
	<property name="jdbc.driver" value="com.mysql.jdbc.Driver"/>
	<property name="jdbc.url" value="jdbc:mysql://localhost:3306/myMybatis"/>
	<property name="jdbc.username" value="root"/>
	<property name="jdbc.password" value="12345678"/>
</properties>

7.1.2.第二种配置方法

在 classpath 下定义 db.properties 文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis_note01
username=root
password=12345678

sql.MapConfig.xml文件（引用了properties标签）

<?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>
    <!--配置properties信息-->
    <!--注意resource：参数内容为类路径，同一个包中直接写名字就可以啦-->
    <properties resource="db.properties"></properties>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置连接池-->
            <dataSource type="POOLED">
                <!--数据库驱动信息-->
                <property name="driver" value="${driver}"/>
                <!--数据库url信息-->
                <property name="url" value="${url}"/>
                <!--数据库用户名-->
                <property name="username" value="${username}"/>
                <!--数据库密码-->
                <property name="password" value="${password}"/>

            </dataSource>
        </environment>
    </environments>

    <!--配置映射文件位置-->
    <mappers>
        <!--resource代表xml，class代表映射-->
        <mapper resource="com/aismall/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

7.2.typeAliases标签（类别名）

使用此标签可以给我们的实体类（domain包下）自定义别名
配置别名之后引用别名时就不区分大小写了

<typeAliases>
	<!-- 单个别名定义 -->
	<typeAlias alias="user" type="com.aismall.domain.User"/>
	<!-- 批量别名定义，扫描整个包下的类，别名为类名（首字母大写或小写都可以） -->
	<package name="com.aismall.domain"/>
</typeAliases>

7.3.mappers标签（映射器）

7.3.1.mapper标签中的resource属性

使用相对于类路径的资源
如： <mapper resource="com/aismall/dao/IUserDao.xml" />

7.3.2.mapper标签中的class属性

使用 mapper 接口类路径
如： <mapper class="com.aismall.dao.UserDao"/>
注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

7.3.3.mappers标签中的package标签

注册指定包下的所有 mapper 接口
如： <package name="cn.aismall.dao"/>
注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。
当指定之后，就不需要写mapper以及resource或者class了

彤彤的小跟班

关注

4
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
1
评论
Mybatis框架学习笔记（01）

目录01Mybatis框架概述02传统JDBC03Mybatis环境搭建（入门案例）3.1创建一个maven工程（mybatis01）3.2创建一个数据库表（user）3.3.在包下创建一个实体类（User.java）3.4.在包下创建一个持久层接口（IUserDao）3.5.在Resource文件夹下创建mybatis的约束（sqlMapConfig.xml）—重点掌握3.6.在Resource文件夹下创建映射配置文件的约束（IUserDao.xml）—重点掌握3.7环境搭建注意事项3.8 在Resour
复制链接

扫一扫