JavaWeb框架学习~Mybatis基础

最新推荐文章于 2024-08-14 00:13:01 发布
最新推荐文章于 2024-08-14 00:13:01 发布
阅读量282 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Java框架学习 JavaEE学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43479034/article/details/90901588
本文是MyBatis基础学习的全面指南，涵盖MyBatis简介、环境搭建、配置文件解析、映射文件操作、动态SQL以及与Hibernate的对比。通过实例解析MyBatis如何简化JDBC操作，包括映射文件中的ParameterType和resultType、动态标签if、where、foreach等，助你快速掌握MyBatis核心概念。

【MyBatis】

第一章 MyBatis 简介

1.1 MyBatis

  • 由来：

    • MyBaits本是apache的一个开源项目iBatis,改名为MyBatis,实质上Mybatis对iBatis进行了一些改进。

  • 简述：

    • MyBatis是一个优秀的持久层框架，对jdbc的操作数据库的过程进行封装，使得开发者只需要关注sql本身，而不需要花费精力去处理例如加载驱动，创建connection、创建statement、手动设置参数，结果集检索等jdbc繁琐的过程代码。

      注：对jdbc的封装框架：Hibernate、dbutils、jdbcTemplate(spring自带)

  • 实现对JDBC的封装原理：

    • MyBatis通过xml或者注解的方式将要执行的的各种statement（statement、 preparedStatement、CallableStatement）配置起来，并通过Java对象和statement中的sql进行映射生成最终执行的sql语句，最后由MyBatis框架执行sql并将结果影射成Java对象并返回。
1.2 JDBC的程序代码
1.3 MyBatis的框架核心
  1. mybatis配置文件：
    • 包括mybatis全局配置文件和mybatis映射文件，其中：
    • 全局配置文件：配置了数据源、事务等信息；
    • 映射文件：配置了sql执行相关信息；
  2. mybatis通过读取配置文件信息(全局配置文件和映射文件)，构造出SqlSessionFactory,即会话工厂。
  3. 通过SqlSessionFactory,可以创建SqlSession(会话)，MyBatis通过SqlSession来操作数据库
  4. SqlSession本身不能直接操作数据库，通过底层的Executor执行接口来操作数据库，Exceutor接口有两个实现类，一个是普通执行器，一个是缓存执行器(默认)
  5. Executor执行器要处理的SQL信息是封装到一个底层对象MappedStatement中，该对象包括：sql语句、输入参数映射信息、输出结果集映射信息，其中输入参数和输出结果的映射类型包括：HashMap集合对象、POJO对象类型。

第二章 MyBatis入门

2.1 环境准备
  • 创建数据库，建表，导入数据
  • 下载MyBatis
  • 创建项目
    • 导架包(新建lib文件夹将需要的依赖包、核心包、驱动包、junit4测试包导入)
    • src文件夹中添加日志文件(新建log4j.properties)

Mybatis使用的日志包是log4j的，所以需要添加log4j.properties,内容可以在mybatis-x-xx.pdf中拷贝

Log4J配置详解

  • 配置根Logger,log4j.rootLogger = [ level ] , appenderName
    • 【level】是日志的级别，分别有debug -> info -> warn -> error 四种日志级别；
    • 【appenderName】，配置日志的输出目录，同一个日志可以配置多个输出目的地；
  • 配置log输出目的地:
    • org.apache.log4j.ConsoleAppender（控制台）
    • org.apache.log4j.FileAppender（文件）
    • org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
    • org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
    • org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
  • log信息的格式，无需详细了解

log4j内容：

###Global logging configuration
log4j.rootLogger=ERROR, stdout

###Uncomment for MyBatis logging
log4j.logger.org.apache.ibatis=ERROR

###Console output…
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

2.2 开发步骤

  1. 创建PO类(对应表的model)，根据需求创建；

    package com.mdy.model;

import java.util.Date;

public class User {
    private int id;
    private String username; //用户名
    private String sex;     //性别
    private Date birthday;  //生日
    private String address; //地址

    public int getId() {
        return id;
    }

    public void setId(int 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 + "]";
    }
}

  2. 创建全局配置文件SqlMapConfig.xml(在src下创建)–配置数据源

    <?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>
<!-- 配置mybatis的环境信息 -->
<environments default="development">
	<environment id="development">
		<!-- 配置JDBC事务控制，由mybatis进行管理 -->
		<transactionManager type="JDBC"></transactionManager>
		<!-- 配置数据源，采用dbcp连接池 -->
		<dataSource type="POOLED">
			<property name="driver" value="com.mysql.jdbc.Driver"/>
			<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8"/>
			<property name="username" value="root"/>
			<property name="password" value="12345"/>
		</dataSource>
	</environment>
</environments>
</configuration>

  3. 编写映射文件(在src中，创建sqlmap文件夹，在该目录下，创建User.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">
<!--
	namespace：命名空间，它的作用就是对SQL进行分类化管理，可以理解为SQL隔离
	注意：使用mapper代理开发时，namespace有特殊且重要的作用
 -->
<mapper namespace="test">
    <!--
        [id]：statement的id，要求在命名空间内唯一
        [parameterType]：入参的java类型
        [resultType]：查询出的单条结果集对应的java类型
        [#{}]： 表示一个占位符?
        [#{id}]：表示该占位符待接收参数的名称为id。注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
     -->
    <select id="findUserById" parameterType="int" resultType="com.gyf.domain.User">
		SELECT * FROM USER WHERE id = #{id}
	</select>
</mapper>

  4. 加载映射文件，在SqlMapConfig.xml中进行加载；(在全局配置文件中添加)

    <!--告诉mybatis要加载映射文件-->
    <mappers>
        <mapper resource="com/mdy/sqlmap/User.xml"></mapper>
    </mappers>

  5. 编写测试程序，即编写Java代码，连接并操作数据库

    思路：

    1. 读取配置文件；
    2. 通过SqlSessionFcatoryBuilder创建SqlSessionFactory会话工厂
    3. 通过SqlSessionFactory创建SqlSession
    4. 调用SqlSession的操作数据库的方法
    5. 关闭SqlSession
    package com.mdy.test;

import com.mdy.model.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

/*
    1. 读取配置文件；
    2. 通过SqlSessionFcatoryBuilder创建SqlSessionFactory会话工厂
    3. 通过SqlSessionFactory创建SqlSession
    4. 调用SqlSession的操作数据库的方法
    5. 关闭SqlSession
*/
public class Demo1 {

    @Test
    public void test1() throws IOException {
        //读取配置文件；
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        //通过SqlSessionFcatoryBuilder创建SqlSessionFactory会ss话工厂
        SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(is);
        //通过SqlSessionFactory创建SqlSession
        SqlSession ss = sf.openSession();
        //调用SqlSession的操作数据库的方法
        //查询一条语句
        User user = ss.selectOne("findUserById",10);
        System.out.println(user);
        //关闭SqlSession
        ss.commit();
    }

}

  6. 更多案例、

    • 模糊查询用户信息

      • 只需要改变映射文件内容

      在当前添加一行模糊查询的代码

      <!--
		[${}]：表示拼接SQL字符串
	 	[${value}]：表示要拼接的是简单类型参数。
	 	简单类型：int,...,还包括Strng
		 注意：
		1、如果参数为简单类型时，${}里面的参数名称必须为value
		2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}
	-->
    <select id="findUserByName" parameterType="String" resultType="com.mdy.model.User">
		SELECT * FROM USER WHERE username like '%${value}%';
	</select>
      • 改变测试类中调用SqlSession的操作数据库的方法(查询多条语句)
       List<User> users = ss.selectList("findUserByName","张");
 System.out.println(users);

  • 插入用户信息

    • 简单的插入一条语句

      • 在映射文件中添加插入语句

        <insert id="insertUser" parameterType="com.mdy.model.User">
        insert into user(username,sex,birthday,address)
        values(#{username},#{sex},#{birthday},#{address})
</insert>

      • 在测试类中

             @Test
         public void test2() throws IOException{
     		//调用SqlSession操作数据的方法
             //创建User类对象
             User user =  new User("枫林","男",new Date(),"江苏南京");
             ss.insert("insertUser",user);
     
         }

  • 更新用户信息

    • 在映射文件中添加更新语句

      <!--更新用户信息-->
    <update id="updateUser" parameterType="com.mdy.model.User">
        update user
        set    username = #{username}
        where  id = #{id}
    </update>

    • 在测试类中添加

      /*
        * 更新一条数据
        * */
       @Test
       public void test4() throws IOException{
   
           //创建User类对象
           User user =  new User();
           //只读需要更新的主键
           user.setId(27);
           user.setUsername("枫林");
           //此方法放回的是受影响的行数，进行数据的传递时，需要通过model来传递
           int row = ss.update("updateUser",user);
           //需要自己手动进行事务提交
           ss.commit();
           System.out.println(row);
   
       }

  • 删除一条记录

    • 在映射文件中添加

      <!--删除一条事务信息-->
    <delete id="deleteID" parameterType="int">
        delete from user where id = #{id};
    </delete>

    • 在测试类中添加调用方法

      /*
     * 删除一条数据
     * */
    @Test
    public void test3() throws IOException{


        int row = ss.delete("deleteID",29);
        //需要自己手动进行事务提交
        ss.commit();
        System.out.println(row);

    }

  • 主键返回之mysql自增主键

    • 思路：

      • mysql自增主键，是指在insert之前会自动生成一个自增主键

      • 可以通过Mysql的函数获取到刚刚插入的自增主键

        last_insert_id()

      • 上面的函数是在insert语句之后去调用的

    • 实现方式，在映射文件插入标签中加入以下代码

      [selectKey标签]：通过select查询来生成主键
      [keyProperty]：指定存放生成主键的属性
      [resultType]：生成主键所对应的Java类型
      [order]：指定该查询主键SQL语句的执行顺序，相对于insert语句(至为before时：代表在插入前返回上一条语句的主键，after：代表返回当前插入的主键)
      [last_insert_id]：MySQL的函数，要配合insert语句一起使用

      <insert id="insertUser" parameterType="com.gyf.domain.User">
		<!-- 
			[selectKey标签]：通过select查询来生成主键
			[keyProperty]：指定存放生成主键的属性
			[resultType]：生成主键所对应的Java类型
			[order]：指定该查询主键SQL语句的执行顺序，相对于insert语句
			[last_insert_id]：MySQL的函数，要配合insert语句一起使用 -->
		<selectKey keyProperty="id" resultType="int" order="AFTER">
			SELECT LAST_INSERT_ID()
		</selectKey>
		<!-- 如果主键的值是通过MySQL自增机制生成的，那么我们此处不需要再显示的给ID赋值 -->
		INSERT INTO USER (username,sex,birthday,address) 
		VALUES(#{username},#{sex},#{birthday},#{address})
</insert>

    • 测试类中添加方法

       / *
        * 插入一条数据后，往模型中设置id
        * */
       @Test
       public void test5() throws IOException{
   
           //创建User类对象
           User user =  new User("林耿","男",new Date(),"江苏扬州");
           //此方法放回的是受影响的行数
           int row = ss.insert("insertUser",user);
           //需要自己手动进行事务提交
           ss.commit();
           System.out.println(row);
       	//输出主键
           System.out.println("插入数据的主键:"+user.getId());
   
       }

  • 主键返回之mysql自增UUID

    • 只需要更改插入映射文件中的返回主键部分代码

      <insert id="insertUser" parameterType="com.gyf.domain.User">
		<selectKey keyProperty="id" resultType="String" order="BEFORE">
			SELECT UUID()
		</selectKey>
		<!-- 如果主键的值是通过MySQL自增机制生成的，那么我们此处不需要再显示的给ID赋值 -->
		INSERT INTO USER (username,sex,birthday,address) 
		VALUES(#{username},#{sex},#{birthday},#{address})
</insert>

小结

  • parameterType和resultType

    parameterType：指定SqlSession操作数据方法中输入参数的Java类型，可以填别名，或Java的全限定名；

    resultType：指定输出结果的Java类型，可以填写别名或者Java的全限定名；

  • #{}和${}

    #{}：相当于预处理中的占位符？。

    #{}里面的参数表示接收java输入参数的名称。

    #{}可以接受HashMap、POJO类型的参数。

    当接受简单类型的参数时，#{}里面可以是value，也可以是其他。

    #{}可以防止SQL注入。

    ${}：相当于拼接SQL串，对传入的值不做任何解释的原样输出。

    ${}会引起SQL注入，所以要谨慎使用。

    ${}可以接受HashMap、POJO类型的参数。

    当接受简单类型的参数时，${}里面只能是value。

  • selectOne和selectList

    selectOne：只能查询0或1条记录，大于1条记录的话，会报错：

    selectList：可以查询0或N条记录

2.3 msbatis的Dao的编写（一般不用，会由更好方式）

  1. DAO

    • 在使用DAO时，需要编写Dao接口和接口实ss现类，将获取session和操作方法放到dao中实现

  2. 定义别名:在全局配置文件中添加以下标签

    <!--定义别名-->
    <typeAliases>
        <typeAlias type="com.mdy.model.User" alias="user"/>
    </typeAliases>
2.4 mybatis 的Dao编写【mapper代理实现方式】
  • Mapper代理的开发方式，程序员只需要编写mapper接口（相当于dao接口）即可。Mybatis会自动的为mapper接口生成动态代理实现类。
  • 不过要实现mapper代理的开发方式，需要遵循一些开发规范。

开发规范：

  1. mapper接口的全限定名要和mapper映射文件的namespace的值相同；
  2. mapper接口的方法名称要和mapper映射文件中的statement的id相同；
  3. mapper接口的方法参数只能有一个，且类型要和mapper映射文件中statement的parameterType的值保持一致；
  4. mapper接口的返回值类型要和mapper映射文件中statement的resultType值或resultMap中的type值保持一致；
2.5 加载映射文件的方式

  1. 使用相对类路径的资源(写映射文件名)

    <mappers>
        <mapper resource="com/mdy/sqlmap/User.xml"></mapper>
</mappers>

  2. 使用mapper接口的权限定名(一般此种方式使用注解)

    <mappers>
        <mapper class="com.mdy.mapper.UserMapper"></mapper>
</mappers>

  3. 写包名(要求映射文件和mapper接口在一个同路径下的同目录中)

    <mappers>
        <package name="com.mdy.mapper"/>
</mappers>

第三章 mybatis映射文件

3.1输入映射ParameterType

指定输入参数的java类型，可以使用别名或类的全限定名，可以接受简单类型，POJO对象，HashMap

  • 简单类型：int double …或者String

  • POJO对象：就是实体类的的全限定类名或者别名，也可以是包装类

  • hashMap:使用Map方式流程如下

    • 在Mapper接口中定义一个方法，传入map参数。

      public List<User> findUserListByMap(Map<String,Object> map);

    • 在相应的映射文件中添加一条语句,注意传入的参数值为hashmap,

      <!--使用map方式查询-->
    <select id="findUserListByMap" parameterType="hashmap" resultType="com.mdy.model.User">
        select * from user where username = #{username};
    </select>

    • 使用方式

      public void test2() throws Exception{
        ss = ssf.openSession();
        UserMapper um = ss.getMapper(UserMapper.class);

        //定义一个map对象
        Map<String,Object> map = new HashMap<String, Object>();
    	//存放值
        map.put("username","林");
		//传入map对象
        List<User> list = um.findUserListByMap(map);
        System.out.println(list);
    }
3.2 输出映射resultType/resultMap

  • resultType

    使用resultType进行结果集映射时，查询的列名和映射的pojo属性名完全一致，该列才能映射成功

    如果查询的列名和映射的pojo属性名全部不一致，则不会创建pojo对象

    如果查询的列名和映射的pojo属性名有一个一致，就会创建pojo对象

    • 输出类型是简单类型

      例如：count(*),resultType=“int”

      在Mapper接口中添加一个方法

      public int findUserCount(Map<String,Object> map);

      在映射文件添加一个查询，输入是hashmap,输出结果是int

      <select id="findUserCount" parameterType="hashmap" resultType="int">
        select count(*) from user where sex = #{sex};
</select>

      在测试中调用

      @Test
    public void test3() throws Exception{
        ss = ssf.openSession();
        UserMapper um = ss.getMapper(UserMapper.class);

        //定义一个map对象
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("sex","男");

        int count = um.findUserCount(map);
        System.out.println("男生的个数："+count);
    }

    • 输出单个pojo对象

      在resultType中是pojo类的权限定名或者别名

      <select id="findUserListByMap" parameterType="hashmap" resultType="com.mdy.model.User">
        select * from user where username = #{username};
    </select>

    • 输出列表pojo对象，同上一样

      注：上面两个的resultType的类型都一样，在Mapper接口中返回值类型不同，单个是该类User，列表是List

  • resultMap

    如查询出来的列名和属性名不一致时，通过定义一个resultMap将列名和pojo属性名之间作一个映射关系

    • 定义resultMap，在映射文件中定义

      <!--映射关系
        type:是实体类
    -->
    <resultMap id="userResultMap" type="com.mdy.model.User">
        <!--
        id:一般是表中主键，其他用result
        property：是实体类中的属性，
        column:是数据库查询列-->
        <id property="id" column="id_"></id>
        <result property="username" column="username_"></result>
        <result property="sex" column="sex_"></result>
    </resultMap>

    • 使用resultMap作为statement的输出映射类型，resultMap中的值为上面定义的resultMap标签的id

      <select id="findUserByResultMap" parameterType="" resultMap="userResultMap">
        select id id_,username username_,sex sex_ from user where id = #{id}
</select>

第四章 动态sql

4.1 if 和 where

  • if标签：作为判断入参来使用，如果符合条件，则把if标签内的sql拼接上，

    用if进行判断是否为空时，不仅要判断null,也要判断空字符串’ ';

  • where标签：会去掉条件中的第一个and符号

<select id="fndUser" parameterType="hashmap" resultType="com.mdy.model.User">
        select * from  user
        <where>
            <if test="sex != null and sex != ''">
                sex = #{sex}
            </if>
            <if test="name != null and name !=''">
                and username like '%${name}%'
            </if>

        </where>
    </select>
4.2 sql片段

sql片段的就是将动态sql提取出来，提高SQL的可重用性

方法：在映射文件添加标签，将if语句存放进去，在查询中where标签中引用>

<!--sql片段-->
    <sql id="select_user_where">
        <if test="sex != null and sex != ''">
            sex = #{sex}
        </if>
        <if test="name != null and name !=''">
            and username like '%${name}%'
        </if>
    </sql>
    <select id="fndUser" parameterType="hashmap" resultType="com.mdy.model.User">
        select * from  user
        <where>
            <include refid="select_user_where"></include>
        </where>
    </select>
4.3 foreach遍历

例如 select * from user where id in (31,32,22)

  • 定义一个包装类，在类中定义 List ids

    package com.mdy.vo;

import com.mdy.model.User;

import java.util.List;

public class UserQueryVo {
    private User usr;

    private List<Integer> ids;

    public User getUsr() {
        return usr;
    }

    public void setUsr(User usr) {
        this.usr = usr;
    }

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }

}

  • 在映射文件中的if和where标签中添加foreach标签

    foreach标签：表示一个foreach循环

    collection:集合参数的名称，如果是直接传入集合参数，则该处的参数名称只能填写list

    item:每次遍历出来的对象，

    open:开始遍历时拼接的串

    close:结束遍历时拼接的串

    separator:每次遍历出对象之间需要拼接的字符

    <select id="findUserByVo" parameterType="com.mdy.vo.UserQueryVo" resultType="com.mdy.model.User">
        select * from user
        <where>
            <if test="ids != null and ids.size > 0">
                <foreach collection="ids" item="id" open="and id in (" close=")" separator=",">
                    #{id}
                </foreach>
            </if>

        </where>

    </select>

  • 测试类中调用

    @Test
    public void test5() throws Exception{
        ss = ssf.openSession();
        UserMapper um = ss.getMapper(UserMapper.class);

        //定义一个包装类对象
        UserQueryVo uqv = new UserQueryVo();
        List<Integer> ids = new ArrayList<>();
        ids.add(27);
        ids.add(31);
        ids.add(25);
        uqv.setIds(ids);
        List<User> user =  um.findUserByVo(uqv);
        System.out.println(user);

    }

  • foreach遍历传入参数方式二：参数是数组，直接传入List集合

  • 在接口中定义一个方法，参数为List

    public List<User> findUserByList(List<Integer> list);

  • 在映射文件中添加，如果参数是数组的话，输入参数为java.util.List也可是别名list，集合参数为 list(固定)

    <select id="findUserByList" parameterType="java.util.List" resultType="com.mdy.model.User">
        select * from user
        <where>
            <if test="list != null and list.size() > 0">
                <foreach collection="list" item="id" open="and id in (" close=")" separator=",">
                    #{id}
                </foreach>
            </if>
        </where>
    </select>

第五章 全局配置文件其他配置

5.1 properties数据库文件配置
  • 在src下配置个db.properties文件
driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://loaclhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8
username=root
password=12344
  • 修改主配置文件在configuration标签中添加
<properties resource="db.properties"/>
  • 修改标签中代码
<property name="driver" value="${driverClass}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
5.2 setting【后续】
<settings>
	<setting name="" value=""></setting>
</settings>
5.3 typeAliases 起别名

使用别名是为了在映射文件中，更方便的指定参数和结果集，不用写很长的全限定名

系统支持的别名列表：

_bytebyte
_longlong
_shortshort
_intint
_integerint
_doubledouble
_floatfloat
_booleanboolean
stringString
byteByte
longLong
shortShort
intInteger
integerInteger
doubleDouble
floatFloat
booleanBoolean
dateDate
decimalBigDecimal
bigdecimalBigDecimal

自定义别名

在主配置文件中添加

<typeAliases>
    <!--单个别名-->
    <typeAlias type="com.mdy.model.User" alias="user"></typeAlias>
    <!--批量配置别名-->
    <!--name,指定批量定义别名的类包，别名为类名-->
    <package name="com.mdy.model"></package>
</typeAliases>

第六章 mybatis和hibernate的区别

  • mybatis技术特点

    优点：

    • 通过直接编写SQL语句，可以直接对SQL进行性能的优化；
    • 学习门槛低，学习成本低，只要有sql基础，就可以学习Mybatis,而且很容易上手；
    • 由于直接编写sql语句，所以灵活多变，代码维护性更好；

    缺点：

    • 不能支持数据库无关性，即数据库发生变更，要写多套代码进行支持，移植性不好
      • 分页Mysql:limit
      • 分页Oracle：rownum
    • 需要编写结果映射

  • hibernate技术特点

    优点：

    • 标准的ORM框架，程序员不需要写sql语句；
    • 具有良好的数据库无关性，即数据库发生变化，代码无需再次编写
      • 在mysql迁移到Oracle时，只需改变配置

    缺点：

    • 学习门槛高，需要对数据模型有良好的基础，而且在设置ORM映射时，需要考虑好性能和对象模型的
    • 程序员不能自主的去进行SQL性能优化

  • Mybatis的应用场景

    1. 需求多变的互联网项目，如电商项目

  • Hibernate的应用场景

    1. 需求明确，业务固定的项目，例如OA项目，ERP项目
Java web项目集成Mybatis
wangjunjie0817的博客
02-26 2580
配置pom文件 &amp;lt;!-- Mysql依赖，版本号与所用Mysql的版本保持一致 --&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;mysql&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;mysql-connector-java&amp;lt;/artif
javaweb框架-mybatis参考资料.zip
最新发布
11-27
学习MyBatis，首先需要了解其核心组件和工作原理，其次要熟悉其配置文件的编写和映射规则的设计。掌握MyBatis的高级特性，如动态SQL、插件等，对于实现复杂的查询和优化性能至关重要。此外，通过阅读源码和参考官方...
MyBatis框架介绍及实战操作
weixin_34405925的博客
04-11 239
一、基本概念和介绍 　　数据持久化的概念 　　数据持久化是将内存中的数据模型转换为存储模型，以及将存储模型转换为内存中的数据模型的统称。例如，文件的存储、数据的读取等都是数据持久化操作。数据模型可以是任何数据结构或对象模型、XML、二进制流等。 　　当我们编写应用程序操作数据库，对表数据进行增删改查的操作的时候就是数据持久化的操作。 　　Mybatis框架简介 MyBatis框架是一个开源的数据持...
Web项目集成Mybatis
wangxx的博客
02-17 2006
1.根据【分层思想】创建包类 分层思想（解耦：高内聚低耦合） controller层 接收请求 （调用service层，返回结果） 响应结果 service层 业务逻辑判断 mapper（dao） 接口类 mapper.xml（Mybatis与数据库的相关操作） entity（po、model） JaveBean实体 util 工具类（通用...
虽然不简单但还是要学的JavaWeb—MyBatis
Cc0010852的博客
10-16 989
MyBatis简介（百度百科）：MyBatis 原名 iBatis 是一款持久层框架，支持定制化框架，存储过程，高级映射。MyBatis 避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis 使用xml配置或注解来进行映射，将实体类中的属性映射为数据库中的字段。—> 2010年从apache software foundaction 迁移至 google Code改名 MyBat
基于Spring boot + Mybatis-Plus+Thymeleaf+Bootstrap 开发的 JavaWeb 留言板
江小举的博客
04-13 2271
JavaWeb 留言板 项目采用的技术 业务层和业务层是基于Springboot整合的SSM 持久层采用的Mybatis-Plus，连接池采用的是Druid 模板引擎采用的是Thymeleaf。 前端框架采用的是Bootstrap 项目功能 注册：可以通过邮箱发送验证码进行验证注册。 防盗链：未登录状态无法查看留言 留言提醒：留言可以选择消息提醒功能，开启后每当有评论，则会通过邮件的方式提醒。 网易云插件：可以在网...
【Java基础】SSM框架基础-mybatis与javaweb整合（适用于新手）
10-20
本文将深入讲解如何将MyBatis集成到Java Web项目中，适合初学者入门学习。 首先，我们需要了解MyBatis的基本概念。MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。它避免了几乎所有的JDBC...
javaWeb-springboot+mybatis+materializecss 图书销售系统.zip
03-26
总的来说，这个"javaWeb-springboot+mybatis+materializecss 图书销售系统"项目提供了一个全面的学习平台，涵盖了后端开发、数据库管理和前端设计等多个方面，对于JavaWeb开发者来说是一份宝贵的资源。通过深入研究...
JavaWeb SMBMS后端开发Mybatis框架实践教程
由于标签指明了是针对"javaweb smbms 后端开发"，可以推测该资源适用于正在学习或需要了解如何使用MyBatis框架来构建一个具有基本物料管理功能的JavaWeb应用的开发人员。资源可能包含了实际代码示例、配置样例以及对...
一文彻底搞懂Mybatis系列（六）之在WEB应用中使用Mybatis
weixin_43860634的博客
10-22 1173
在WEB应用中使用Mybatis
基于struts+Spring+mybatis实现旅游管理系统
10-26
基于struts+Spring+mybatis实现旅游管理系统，包括用户管理，前后端html，css，js等前后端技术应用
MyBatis框架基本的搭建
weixin_42105374的博客
02-17 264
1、简介 1.1、什么是 MyBatis？ MyBatis 是一款优秀的持久层框架。 它支持自定义 SQL、存储过程以及高级映射。 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。 MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java...
MyBatis入门
SongZhengxing_的博客
06-27 802
下载地址：https://github.com/mybatis/mybatis-3打开地址后选择 zip 文件下载 添加mybatis配置文件 新建 mybatis-config.xml ,名称自定义，内容直接复制将该文件放在 resources 文件下中 创建mapper接口 首先数据库中新建 t_user 表创建对应的实体类 创建 UserMapper 接口 创建MyBatis映射文件 相关概念：ORM（Object Relationship Mapping）对象关系映射。 对象：Java的实体类对象
Mybatis学习教程—— Mybatis入门实例
u011269801的专栏
02-28 827
MyBatis         MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框
「MyBatis」实现留言板
Ice_Sugar_7的博客
08-14 1996
来个留言板练练手！
mybatis框架的使用方法
a_lilixxx的博客
11-14 510
1.配置maven仓库。 新建一个文件夹存放maven的文件夹以及maven的代码仓库repository，在系统环境变量中新建环境变量MAVEN_HOME 。 2.配置插件、jar包，等。 在IDEA中创建一个Maven项目，可以选择建立模板，或者建立一个新的空项目，在pom.xml中使用标签，写入关键jar包mybatis，junit（测试）并点击刷新。 3.建立基本的三层架构（dao，service，servlet），entity包，并用IDEA自带的database引入实体类，其中servlet可以
【MybatisPlus】QueryWrapper、UpdateWrappe、LambdaQueryWrapper、LambdaUpdateWrapper
代码的魅力，根本走不出来
03-06 4607
和都是 MyBatis-Plus 框架中用于构建条件的工具类，它们之间的关系是继承关系。其中和是基于普通的对象属性名来构建条件的，而和则是基于 Lambda 表达式来构建条件的。下面是AbstractWrapper中的方法。
MyBatis Plus应用实践总结
小小默：进无止境
09-01 5913
【1】MyBatis Plus中的嵌套查询 很多时候我们可能需要构造一个嵌套查询，如WHERE (name = ? AND ( (id = ? OR type = ?) ))。外层是and(or)连接，嵌套一个or(and)查询。MyBatis Plus同样对此提供了支持，在Nested<Param, Children>接口中我们可以看到具体使用方法。 ① Nested<Param, Children>接口源码 public interface Nested<Param, Ch
mybatis plus 之UpdateWrapper操作
热门推荐
weixin_41377877的博客
04-06 4万+
目前java开发的系统为了可移植性更高，都采用了mybatis plus来做持久层，现在介绍一下其中UpdateWrapper的用法： UpdateWrapper<TemplateDetailsEntity> wrapper = Wrappers.update(); wrapper.lambda() .set(TemplateDetailsEntity::getPriority, "")
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值