Mybatis学习总结

最新推荐文章于 2022-09-02 16:47:32 发布
最新推荐文章于 2022-09-02 16:47:32 发布
阅读量77 收藏
点赞数
分类专栏： java笔记 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44027353/article/details/114585738
版权

学习Mybatis的第一天
今天主要学习了Mybatis的一些入门操作，首先是知到了什么是Mybatis，它的功能的什么，使用Mybatis的简单步骤，sql语句的映射文件，Mybatis的核心配置文件，java代码中的一些API对象……

文章目录

Mybatis的概念

它是持久化成的一个框架，它帮我门封装了元素jdbc繁琐的操作，就比如加载驱动，获取连接对象，获取执行sql对象，封装查询结果。Mybatis让我们只注重于sql语句的编写。
就我目前的理解，JdbcTemplate也能完成这些事请，但Mybatis将sql语句的java代码解耦合了，JdbcTemplate的sql语句还是和持久化成的java代码在一起。

入门的基本步骤

  1. 首先导入数据库的mysql-connector-java 和 Mybatis 的坐标
  2. 创建数据表 还有和数据表对应的实体类对象
  3. 创建sql语句的映射文件
  4. 创建Mybatis核心配置文件
  5. java代码运行

创建sql语句的映射文件

首先是命名规范，如果是maven工程，在resources文件夹下创建一个一个dao一样的目录，然后创建一个XXXMapper.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">

然后在创建一个mapper标签，为该标签配置一个属性namespace 表示命名空间，在该标签的标签体中创建insert、delete、update、select标签用来配置sql语句,这些标签需要id属性，还需要根据sql语句的情况来添加parameterType和resultType。
这是因为如果是查询某些数据的话，你要告诉Mybatis这些查询到的数据要封装成哪个类。然后我们再获取封装好的对象。
如果sql是需要几个参数来进行条件查询或修改的话，我们就需要一个parameterType来传一个参数类型。以前占位符的写法是使用问号？来占位，然后我们在为这些问号赋值，Mybatis不能使用? 而需要使用#{类的属性名}，注意大括号里面一定要和parameterType定义类的属性名一致，不然Mybatis不知道你的那些参数要放在那个位置。但如果parameterType不是一个实体类 而是只有一个参数的情况，那#{}这个里面就可以随便写名字。

创建Mybatis的核心配置文件

首先是在resources文件夹下创建一个Mybatis的核心配置文件，在这个配置文件中也要复制粘贴两行约束

<?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是用来配置数据源的，还有一个是mappers是用来加载sql语句的映射文件的。

在environments中可以配置多个数据源，它有一个default属性用来设置默认的数据源，environments标签下使用environment标签配置具体的数据源,可以为encironment标签设置一个id属性，将这个名字放入environments的default属性中表示默认使用这个数据源的环境。
encironment标签体中还有两个标签，一个是transactionMagger设置事务管理器，还有一个dataSource标签设置数据源的

<configuration>
    <environments default="developement">
        <environment id="developement">
            <!-- 事务管理器 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 数据源 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

事务管理器，常用的类型也就是JDBC 它的含义是接下来使用的数据库连接对象都是从下面配置的池中获取。还有一个就是MANAGED,他让容器来管理事务的整个生命周期。
数据源一般使用的是POOLED 表示使用数据库连接池，还有UNPOOLED 和JNDI

mappers标签的加载sql语句的映射文件的，

<mappers>
	<mapper resource="映射文件地址"></mapper>
</mappers>

映射文件的地址也有多种写法，一般是直接写在resources资源文件夹下的路径。还有的写法是写一个完整的URL 、使用映射器接口实现类的完全限定类名class、将包内的映射器接口实现全部注册为映射器name。

在configuration标签体中还有几个常用的标签
properties 引入其他properties文件
typeAliases 为自定义的全类名起别名，Mybatis

java测试部分

java代码的基本步骤就是

  1. 加载Mybatis的核心配置文件
  2. 创建SqlSession工厂构建类
  3. 获取SqlSession工厂类
  4. 从SqlSession工厂类中获取SqlSession对象
  5. 使用SqlSession调用增删改查四类方法进行执行sql
  6. 如果获取的SqlSession是不自动提交事件的话还需要我们手动提交事务
  7. 释放SqlSession对象。
    代码大致如下：
InputStream is = Resources.getResourecsAsStream("核心配置文件名");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder.build(is);
SqlSession sqlSession = sqlSessionFactory.openSession(boolean 决定SqlSession是否会自动提交事务)
sqlSession.update("Mappers标签namespace.Mapper标签的id",Mapper标签中属性parameterType或resultType类型的对象)
sqlSession.commit();
sqlSession.close();

SqlSessionFactoryBuilder类是用来构建SqlSessionFactor类的
SqlSessionFactory是用来为我们提供SqlSession对象的
SqlSession对象是执行sql和事务操作的。

执行sql语句的方法

第一种是直接在dao层中创建接口+实现类，在实现类中创建每个sql语句对应的方法，通过SqlSession对象.select、insert、delete、update（“sql语句的映射” ， 参数）。
还有一种是直接创建dao层的接口，在接口中创建sql语句对应的方法，然后可以在业务层通过SqlSession对象的getMapper(接口名.class)方法获取接口的代理对象，代理对象再调用接口中的方法，接口中的方法与映射文件中的sql语句有映射关系，可以调用接口中的方法，然后直接指向sql语句。但有一些前提条件：

  • <mapper>标签中的namespace属性为接口的全类名
  • <select或delete或insert或update>标签中的id为接口中的方法名
  • parameterType属性要与方法的形参对应
  • resultType属性与方法的返回值对应

代码如下：

  1. 定义一个接口
public interface UserMapper {
    public User findUserById(int id);
}
  1. 映射文件
<mapper namespace="com.XXX.dao.UserMapper">
    <select id="findUserById" parameterType="int" resultType="com.XXX.domain.User">
        select * from user where id=#{id}
    </select>
</mapper>
  1. java测试代码
@Test
public void test6() throws IOException {
    //加载配置文件
    InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
    //创建SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    //获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //获得持久化层接口代理对象
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    //执行方法
    User user = userMapper.findUserById(1);
    //输出
    System.out.println(user);
    //关闭
    sqlSession.close();
}

这两种方法是主要区别就在与我自己是否手动编写了接口实现类。

映射文件的其他技术

动态sql

在日常的开发中，有很多时候我们的sql语句是没办法确定的，我们需要根据传递过来的参数的多少来决定sql语句的编写，就比如分页查询数据，有时候可能直接查询某页的多少数据，有时候也有可能使用模糊查询，查询某内容的某页数据。这就需要使用到<if>标签了。
使用如下所示：

<!-- 例如 根据user的某些属性来查询数据 -->
<mapper namespace="user">
	<select id="findAll" parameterType="com.XXX.XXX.User" resultType="com.XXX.XXX.User">
		select * from user
		<where>
			<if test="id!=0">
				and id=#{id}
			</if>
			<if test="username!=null">
				and username=#{username}
			</if>
	</select>
</mapper>

主要就是在if标签的test属性中判断某个属性的值是否存在，如果存在就在原sql语句中添加一个查询条件。

还有foreach标签。该标签的使用没有if标签的使用次数多，它主要是用来查询比如id=1 或者是 id=2 或者是id=3 ……的用户 。具体使用如下：

<!-- 查询user  通过动态sql的foreach标签查询 -->
<!-- 原本SQL  select * from user where id in(1,2,3)   -->
<!-- foreach标签属性介绍 collection就是传过来的参数 open是以什么开始  close是以什么结束 
     item就是起的一个变量名 遍历集合时用这个名字  separator是sql参数之间的分割  -->
<select id="findByIds" parameterType="list" resultType="com.hnyyjsxy.domain.User">
    select * from user
    <where>
        <foreach collection="list"  open="id in("    close=")"    item="id"   separator=",">
            #{id}
        </foreach>
    </where>
</select>

sql片段的抽取

<!-- sql的抽取-->
<sql id="selectUser">select * from user</sql>

使用如下：

<!-- 查询所有user -->
<select id="findAll" resultType="com.XXX.domain.User">
    <include refid="selectUser"/>
</select>

映射文件的总结

在sql的映射文件中 目前共使用了以下标签

  • mapper ------>标签体
  • insert ------>插入相关sql
  • delete ------>删除相关sql
  • update ------>修改相关sql
  • select ------>查询相关sql
  • if ------>动态sql语句条件判断标签
  • where ------>动态sql语句 不需要我们在sql语句中写where
  • foreach ------>sql语句的动态添加
  • sql ------>sql片段的抽取

配置文件的其他技术

类型转换 typeHandlers标签

mybatis框架已经自动帮我们实现了一些常见的java和数据库之间的类型转换。就比如我们的POJO类和parameterType属性、数据库查询结果帮我们封装resultType属性、java中的String 和 数据库之间是varchar 等等。但还有一些情况下，它提供的类型转换不能够满足我们业务的需要，这就需要自定义类型转换了。
我们可以实现org.apache.ibatis.type.TypeHandler接口，或者是继承org.apache.ibatis.type.BaseTypeHandler 类，后面这个类是实现了前面的接口，然后选择性的将它映射到JDBC类型中。

开发步骤：

①定义转换类继承类BaseTypeHandler<T>

②覆盖4个未实现的方法，其中setNonNullParameter为java程序设置数据到数据库的回调方法，getNullableResult为查询时 mysql的字符串类型转换成 java的Type类型的方法

③在MyBatis核心配置文件中进行注册

public class MyDateTypeHandler extends BaseTypeHandler<Date> {
    //将java类型转换成数据库需要的类型
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, Date date, JdbcType type) {
        preparedStatement.setString(i,date.getTime()+"");
    }
    //将数据库中的数据转换成java对象
    //参数中ResultSet查询结果集     String 就是数据库中要转换的字段的名称
    public Date getNullableResult(ResultSet resultSet, String s) throws SQLException {
        //获取结果集中我需要的数据
        return new Date(resultSet.getLong(s));
    }
    //将数据库中的数据转换成java对象
    //产生中int是字段的位置
    public Date getNullableResult(ResultSet resultSet, int i) throws SQLException {
        return new Date(resultSet.getLong(i));
    }
    //将数据库中的数据转换成java对象
    public Date getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
        return callableStatement.getDate(i);
    }
}

在核心配置文件中配置代码如下：

<!--注册类型自定义转换器-->
<typeHandlers>
    <typeHandler handler="com.itheima.typeHandlers.MyDateTypeHandler"></typeHandler>
</typeHandlers>

使用第三方插件 plugins标签

mybatis可以使用第三方插件来对功能进行扩展，这里就拿分页查询的插件来举例。
开发步骤：

①导入通用PageHelper的坐标

<!-- 分页查询的插件 -->
<dependency>
  <groupId>com.github.pagehelper</groupId>
  <artifactId>pagehelper</artifactId>
  <version>3.7.5</version>
</dependency>
<!-- 解析器 -->
<dependency>
  <groupId>com.github.jsqlparser</groupId>
  <artifactId>jsqlparser</artifactId>
  <version>0.9.1</version>
</dependency>

②在mybatis核心配置文件中配置PageHelper插件

<!-- 配置分页查询的插件 -->
<plugins>
    <plugin interceptor="com.github.pagehelper.PageHelper">
        <!-- 指定方言 -->
        <property name="dialect" value="mysql"/>
    </plugin>
</plugins>

③测试分页数据获取

/**
 * 查询全部学生数据  添加了分页查询插件后 查询分页的几条数据
 * @throws Exception
 */
@Test
public void test9() throws Exception{
    InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession();

    //设置分页相关参数 当前页+每页显示条数 下面就是第一页 每页显示4条
    PageHelper.startPage(1,4);

    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = userMapper.findAll();
    for (User user : userList) {
        System.out.println(user);
    }

    //其他分页的数据 首先创建一个pageInfo对象 泛型是查询到的结果类型   构造方法中传的是查询结果集合
    PageInfo<User> pageInfo = new PageInfo<User>(userList);
    System.out.println("总条数："+pageInfo.getTotal());
    System.out.println("总页数："+pageInfo.getPages());
    System.out.println("当前页："+pageInfo.getPageNum());
    System.out.println("每页显示长度："+pageInfo.getPageSize());
    System.out.println("上一页：" +pageInfo.getPrePage());
    System.out.println("下一页：" +pageInfo.getNextPage());
    System.out.println("是否第一页："+pageInfo.isIsFirstPage());
    System.out.println("是否最后一页："+pageInfo.isIsLastPage());

    sqlSession.close();
}

核心配置文件总结

在mybatis的核心配置文件中，目前共使用了如下几种标签

标签说明
configration配置文件的根标签
properties加载外部properties文件
typeAliases设置类型别名
environments数据源环境配置
typeHandlers自定义类型转换
plugins加载插件
mappers加载映射文件

多表查询

多表查询的表结构一般有 一对一 一对多 多对多

一对一

  1. 首先在实体类中1添加一个属性，用来存放实体类2的数据。
  2. 在持久层的接口中创建相应的方法
  3. 映射文件的编写，主要内容如下：
    我觉得多表查询无非就是多查询了几个字段的数据，问题在于如果告诉mybatis这几个字段我是需要封装到实体类2 中。解决方法就是<ResultMap>标签
<mapper namsepace="接口全类名">

	<resultMap id="自己随便起名" type="将结果封装为哪个类的全类名">
		<!-- 主键一般使用id标签 其他的使用result标签 -->
		<id column="数据库字段" property="实体类1属性名"/>
		<result column="数据库字段" property="实体类1属性名"/>
		……
		<!-- 接下里封装的数据是实体类2的数据 这里需要在核心配置文件中为实体类2起别名 
			  我这里试了一下，如果直接使用全类名.属性名就会报错  
			  我看的教学视频也没讲太清楚 我也纠结过这下面的到底是别名还是实体类1中定义实体类2的属性名
			  之后我也测试了一下，修改了属性名 可以正常运行 如果修改了别名 就报错 所以这下面的别名	
		 -->
		<result column="数据库字段" property="实体类2别名.属性名"/>


	</resultMap>
	
	<select id="接口中方法名" resultMap="上面定义的resultMap标签id">
		多表查询的sql语句
	</select>
</mapper>

还有一种写法

<mapper namespace="接口全类名">

	<resultMap id="自己随便起名" type="将结果封装为哪个类的全类名">
		<!-- 主键一般使用id标签 其他的使用result标签 -->
		<id column="数据库字段" property="实体类1属性名"/>
		<result column="数据库字段" property="实体类1属性名"/>
		……
		<!-- 接下里封装的数据是实体类2的数据 -->
		<association property="实体类2的属性名" javaType="实体类2的全类名">
			<id column="数据库字段" property="实体类2属性名"/>
			<id column="数据库字段" property="实体类2属性名"/>
			……
		</association>
	</resultMap>
	
	<select id="接口中方法名" resultMap="上面定义的resultMap标签id">
		多表查询的sql语句
	</select>
</mapper>

一对多

  1. 在实体类1中创建一个属性——实体类2的集合
  2. 在持久化层接口定义相应的方法
  3. 映射文件的编写
<mapper namespace="接口全类名">
	
	<resultMap id="随便命名" type="实体类1的全类名">
	    <!-- 先把实体类1的一般属性写好 -->
	    <id column="数据库字段" property="实体类1属性名"/>
	    <result column="数据库字段" property="实体类1属性名"/>
	    <result column="数据库字段" property="实体类1属性名"/>
	    <!-- 接下来配置实体类1属性中的 List<实体类2>  这是一个集合，和之前一对一就不太一样-->
	    <!-- property: 当前实体类1的集合属性名   ofType：集合中存储的类的类型 -->
	    <collection property="属性名" ofType="实体类2全类名">
	        <id column="数据库字段" property="实体类属性名"/>
	        <result column="数据库字段" property="实体类属性名"/>
	        <result column="数据库字段" property="实体类属性名"/>
	    </collection>
	</resultMap>
	
	<select id="接口中方法名" resultMap="上面定义的id">
	    多表查询的sql语句
	</select>
</mapper>

多对多

其实多对多和一对多基本上没区别，唯一的区别就是sql语句多加了一个表。查询出来的数据进行封装和一对多没什么区别，

<mapper namespace="接口全类名">
	
	<resultMap id="随便命名" type="实体类1的全类名">
	    <!-- 先把实体类1的一般属性写好 -->
	    <id column="数据库字段" property="实体类1属性名"/>
	    <result column="数据库字段" property="实体类1属性名"/>
	    <result column="数据库字段" property="实体类1属性名"/>
	   
	    <collection property="属性名" ofType="实体类2全类名">
	        <id column="数据库字段" property="实体类属性名"/>
	        <result column="数据库字段" property="实体类属性名"/>
	        <result column="数据库字段" property="实体类属性名"/>
	    </collection>
	</resultMap>
	
	<select id="接口中方法名" resultMap="上面定义的id">
	    多对多查询的sql语句
	</select>
</mapper>

基于注解的开发

注解的方式相对来说比较容易，而且还不需要创建专门为sql语句创建一个映射文件了。下面简单讲讲注解开发的一个基本过程吧：

  1. 创建持久化层接口
  2. 接口中定义方法，方法上面直接使用注解定义sql语句
  3. 在mybatis核心配置文件中加载映射关系，这里不用加载映射文件了，但是接口中的方法和sql语句其实还是存在映射关系的，不然你执行一个方法，鬼知道你要执行哪个sql语句。
<mappers>
	<package name="持久化层接口所在的包名，只需要写到包即可 注意 加载映射文件和加载映射关系的语句不能同时存在"/>
</mappers>

常用注解

注解说明
@Insert用于往数据库中添加数据
@Delete删除数据
@Update修改数据
@Select查询数据
@Result对结果进行封装
@Results与@Result注解一起使用，该注解有一个数组属性，数组中存放多个@Result
@One多表查询中的 实现一对一表结构数据的封装
@Many多表查询中实现一对多或多对多表结构数据的封装

一张表的crud

定义一个接口+多个方法，直接在方法名上面使用注解

public interface UserMapperAnno {

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

    @Insert("insert into user(username,password) values(#{username},#{password})")
    void save(User user);

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

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

核心配置文件中加载映射关系

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

测试类中通过SqlSession对象获取接口的代理对象，然后使用代理对象调用接口中的各个方法，执行相应的sql语句，并接收查询后的返回值。

@Test
public void test(){
	InputStream is= Resoucres.getResoucreAsStream("核心配置文件名.xml");
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	接口类型 动态对象名 = sqlSession.getMapper(接口名.class);
	//然后通过对象调用接口中方法实现crud
}

一对一

接口方法上面的注解需要加一点修改

public interface UserMapperAnno {
	@Select("select * from 表1，表2 where 表1.id = 表2.id")
	@Results({
		//如果是主键可以加一个id=true的属性
		@Result(id=true , column="数据库字段" ,property="实体类1属性名"),
		@Result(column="数据库字段" ,property="实体类1属性名"),
		@Result(column="数据库字段" ,property="实体类1属性名"),
		@Result(column="数据库字段" ,property="实体类2别名.属性名"),
		@Result(column="数据库字段" ,property="实体类2别名.属性名")
	})
    User findAll();
}

第二种方式

public interface UserMapperAnno {
	@Select("select * from 表1")
	@Results({
		//如果是主键可以加一个id=true的属性
		@Result(id=true , column="数据库字段" ,property="实体类1属性名"),
		@Result(column="数据库字段" ,property="实体类1属性名"),
		@Result(column="数据库字段" ,property="实体类1属性名"),
		@Result(
			column="数据库的字段，也就是通过那个字段去查询表2",
			javaType="实体类2的全类名  表示查询到了数据封装的类型是什么样子的",
			column="当前实体类要封装的属性名",
			one=@One(select = "表2接口全类名.方法名")
		)
	})
    User findAll();
}

这里还需要表2接口中定义一个根据id查询数据的方法，意思其实就是这传一个id给另一个接口中的方法，另一个接口执行然后获取返回值，将返回值封装到javaType声明类型column属性中。这里我的确不知道该怎么组织语言来表达了。

一对多

一对多 和 声明一对一其实没有太大区别 唯一区别就是@One注解该为@Many注解。也还是先查询当前表，然后通过某一个字段去查第二张表

public interface UserMapper{
	@Select("select * from user")
	@Results({
		@Result(column="字段",property="属性名"),
		@Result(column="字段",property="属性名"),
		@Result(column="字段",property="属性名"),
		@Result(
			column="字段",
			javaType="实体类2全类名",
			property="属性名",
			many=@Many(select = "接口全类名.方法")
		)
	})
	List<User> findAll();
}

多对多查询

多对多的查询和一对多的查询唯一的不同就在于sql语句，它需要在查询的时候查询两张表，将中间表一起查询出来，然后用中间表的字段去查询另外一张表。也可以先查询一张表，将中间表和接口2方法上的sql一起查。
其他数据封装方式还是和一对多一致。

总结

如果是基于配置文件方式：主要就是使用如下标签：

<mapper>  <select>  <insert>  <update>  <delete>  <resultMap>  <result>  <where>   <if>   <foreach>  <sql>

核心配置文件中一般使用的标签有：

<configuration>   <properties>   <typeAliases>   <typeAlias>   <environments>    <environment>  <transactionManager>   <dataSource>  <typeHandlers>    <plugins>    <mappers>  <mapper>

注解方式 常用的注解有：

@select@update@insert
@delete@One@many
胡尚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring整合mybatis学习总结
Twillight_clever的博客
07-10 409
spring整合mybatis
mybatis学习总结
weixin_45773632的博客
10-11 1551
文章目录注意点入门安装从 XML 中构建 SqlSessionFactory不使用 XML 构建 SqlSessionFactory从 SqlSessionFactory 中获取 SqlSession探究已映射的 SQL 语句作用域（Scope）和生命周期XML配置属性（properties） mybatis-02设置（settings）类型别名（typeAliases）环境配置（environments）映射器（mappers）XML 映射文件参数结果映射 (解决数据库中的字段名和实体类中的属性名不匹
MyBatis学习总结
weixin_44630656的博客
09-27 955
一、MyBatis简介 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。 Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行
Mybatis学习总结_1
m0_46552030的博客
03-21 740
1. MyBatis 1.1 框架 1.1.1 什么是框架 框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种 定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。 简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别 人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。 1.1.2 框架解决什么问题 框架要解决的最重要的一个问题是技术整合的问题，在 J2E
Mybatis学习总结（三）
我的博客
02-12 472
mybatis的级联查询一.准备环境1.1创建班级，学生，老师表。其中班级和老师是一对一关系，班级和学生是一对多关系。
MyBatis的学习总结
GD的博客
10-28 1675
1、前言 mybatis是一款优秀的持久层框架, 它支持定制化SQL、存储过程、高级映射、逆向工程… mybatis可以使用简单XML或注解用于配置和原始映射,将接口和java的pojo映射成数据库中的记录 为什么要使用MaBatis？ mybatis是一款半自动化的持久层框架 在JDBC中,我们在Java代码中夹杂着大量SQL语句,耦合度高,在我们实际维护的过程中总是需求的sql是有变化的,频繁修改的情况多见 而mybatis框架帮助我们在代码中实现java与sql的分离,一个专注业务,一个专注数据
学习Mybatis总结
最新发布
weixin_59779524的博客
09-02 313
学习这几天Mybatis最大的感觉就是每天都在找错误，一个错误要找很久，还需要继续努力提升自己的能力。
Mybatis学习总结之mybatis使用建议
09-02
MyBatis是一个强大的持久层框架，它允许开发者自定义SQL、存储过程以及高级映射，极大地简化了Java与数据库交互的复杂度。MyBatis消除了手动编写JDBC代码和管理参数的过程，同时也支持XML和注解两种方式来配置和映射...
【狂神说】mybatis学习总结笔记（全）PDF格式文档 MyBatis.pdf
01-04
MyBatis学习总结笔记 MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。MyBatis可以通过简单的XML或注解来配置和映射原始...
【狂神说】mybatis学习总结后源码下载（全） mybatis-study.zip
01-04
总结，MyBatis作为一个轻量级的持久层框架，通过灵活的XML或注解配置，将Java对象与数据库操作紧密结合，简化了开发工作，提高了开发效率。同时，其强大的动态SQL功能和良好的扩展性，使其在Java Web开发中广泛应用...
mybatis学习总结:基础示例
04-26
【标题】：“mybatis学习总结:基础示例” 在IT领域，MyBatis是一个非常流行的持久层框架，它简化了Java开发中数据库操作的复杂性。这篇“mybatis学习总结:基础示例”旨在帮助初学者理解MyBatis的核心概念，并通过...
netty——Channl的常用方法、ChannelFuture、CloseFuture
qq_44027353的博客
11-15 6019
文章目录ChannelChannel的常用方法ChannelFutureCloseFuture Channel Channel的常用方法 close() 关闭channel closeFuture() 处理关闭channel后要执行的操作 sync()方法是同步等待channel的关闭 addListener()方法是异步等待channel的关闭 pipeline()添加处理器 write() 将数据写入，netty里面其实还有一个缓冲区，当我们执行flush()方法后或者是缓冲区中数据达到
linux ACL权限，设定，删除
qq_44027353的博客
04-10 4925
文章目录ACL权限简介和开启查看和设定ACL权限最大有效和删除ACL权限默认ACL和递归ACL权限 ACL权限 简介和开启 如下图所示，假如一个目录已经给所有者，所属组和其他人分配了相应的权限，然后这个时候又有了一个用户st，他需要有读和执行的权限，不能有写权限，所以用户st放在所属组和其他人中都不合适，这个目录的三个身份就不够用了，ACL权限就是专门用来解决身份不足的情况 如果要使用ACL权限，前提是需要让文件所在的分区支持ACL权限 # 首先查看分区 [root@VM-8-7-centos ~]# d
netty——bytebuf的创建、内存分配与池化、组成、扩容规则、写入读取、内存回收、零拷贝
qq_44027353的博客
11-16 4265
文章目录ByteBuf创建内存分配与池化ByteBuf组成扩容规则写入读取内存回收零拷贝ByteBuf优势 ByteBuf ByteBuf是对nio中ByteBuffer的增强。主要的增强点就是ByteBuf它可以动态调整容量大小，当要存储的数据超过了当前容量的上限就会进行扩容，扩容的上限是多少？扩容机制是什么？请跟着本文往下看。对了，还有一个增强就是byteBuf不用和ByteBuffer一样进行读写模式的切换，ByteBuffer中读与写是共用一个指针，而ByteBuf既有读指针，也有写指针。 创建
java零拷贝
qq_44027353的博客
11-13 3194
服务器有这样一个需求，读取一个文件，然后通过socket传输给客户端，代码如下 这上面的代码看起来就是把文件读取到byte数组，然后在通过byte数组写给客户端。但其实经过了4次数据拷贝，三次内核系统切换。 因为java是没办法直接读取文件的，需要通过先将文件读取到内核缓冲区，然后在读取到用户缓冲区，也就是byte数组，同样java没办法直接写数据，需要先将数据转换存入到socket缓冲区，然后再将数据拷贝到网卡进行数据的发送。所以经过了4次数据拷贝，三次内核系统切换。 NIO进行改进1： 我们可以将上
linux用户管理：添加用户、设置密码、修改删除
qq_44027353的博客
04-08 3002
用户管理 添加一个用户 命令名称：useradd 语法：useradd [选项] 用户名 范例：$ useradd hushang 常用命令选项 -g 用户组 指定用户所属的用户组。 -G 用户组，用户组 指定用户所属的附加组。 -m　使用者目录如不存在则自动建立。 为新添加的用户设置登录密码 命令名称：passwd 语法：passwd 用户名 范例：passwd hushang passwd 用户名 按回车后 再输入密码 输入了密码 但是界面上面的不会显示的 公司中我们一般是拿不到root账号的
netty——EventLoop概念、处理普通任务定时任务、处理io事件、EventLoopGroup
qq_44027353的博客
11-15 2005
文章目录EventLoop执行普通任务和定时任务处理io事件EventLoopGroup EventLoop EventLoop本质上就是一个Selector+一个单线程执行器。里面的run方法处理channel上源源不断的io事件 EventLoop它继承两个类 第一个是继承netty自己的OrderedEventExecutor接口 第二个是继承java.util.concurrent.ScheduledExecutorService接口 我们一般是不会直接用EventLoop 一般是使用Event
MyBatis核心技术与实战总结
"MyBatis学习总结，涵盖了MyBatis的基础知识、常用特性、高级应用及扩展点，包括XML和注解方式的开发，主键返回，批量查询，动态传参，缓存机制，延迟加载，关联查询，逆向工程，PageHelper分页，以及注解开发等内容...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值