07_MyBatis

最新推荐文章于 2024-09-02 22:29:33 发布
最新推荐文章于 2024-09-02 22:29:33 发布
阅读量81 收藏
点赞数
分类专栏： java后端 文章标签： mybatis java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42430409/article/details/126618253
版权

1.基本使用

设置环境

  1. 打包方式:jar

  2. 添加依赖

    <dependencies>
    <!-- Mybatis核心 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
         <!--<version>5.1.3</version> 这是5版本的mysql-->
        <version>8.0.11</version>
    </dependency>
</dependencies>

创建配置文件

习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略

<?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="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

创建mapper接口以及实例

MyBatis中的mapper接口相当于以前的dao。但是区别在于，mapper仅仅是接口，我们不需要提供实现类

public interface UserMapper {  
    /**  
	* 添加用户信息  
	*/  
    int insertUser();  
}

public class User {
    private Integer id;
    private String name;
    private String password;
    private String address;
}

创建映射文件

  • MyBatis中可以面向接口操作数据，要保证两个一致
    • mapper接口的全类名和映射文件的命名空间（namespace）保持一致
    • mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致
<?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="mapper.UserMapper">
    <!--int insertUser();-->
    <insert id="insertUser">
        insert into user values(null,'张三','123456','芜湖','18795969888')
    </insert>
</mapper>

测试功能

@Test
public void testMybatis() throws IOException {
    //读取MyBatis的核心配置文件
    InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    //获取SqlSessionFactoryBuilder对象
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
    SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);

    //获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务
    //SqlSession sqlSession = sqlSessionFactory.openSession();

    //创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //通过代理模式创建UserMapper接口的代理实现类对象
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
    int result = userMapper.insertUser();

    //提交事务
    //sqlSession.commit();

    System.out.println("result:" + result);
}
  • 此时需要手动提交事务，如果要自动提交事务，则在获取sqlSession对象时，使用SqlSession sqlSession = sqlSessionFactory.openSession(true);，传入一个Boolean类型的参数，值为true，这样就可以自动提交

加入log4j日志功能

<!-- log4j日志 -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

log4j.xml,url报错不用管

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

2.核心文件配置详情

核心配置文件中的标签必须按照固定的顺序(有的标签可以不写，但顺序一定不能乱)：
properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、reflectorFactory、plugins、environments、databaseIdProvider、mappers

<?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文件，此时就可以${属性名}的方式访问属性值-->
    <properties resource="jdbc.properties"></properties>
    <settings>
        <!--将表中字段的下划线自动转换为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>
    <typeAliases>
        <!--
    typeAlias：设置某个具体的类型的别名
    属性：
    type：需要设置别名的类型的全类名
    alias：设置此类型的别名，且别名不区分大小写。若不设置此属性，该类型拥有默认的别名，即类名
    -->
        <!--<typeAlias type="com.rokned.mybatis.bean.User"></typeAlias>-->
        <!--<typeAlias type="com.rokned.mybatis.bean.User" alias="user">
    </typeAlias>-->
        <!--以包为单位，设置改包下所有的类型都拥有默认的别名，即类名且不区分大小写-->
        <package name="com.rokned.mybatis.bean"/>
    </typeAliases>
    <!--
    environments：设置多个连接数据库的环境
    属性：
    default：设置默认使用的环境的id
    -->
    <environments default="mysql_test">
        <!--
    environment：设置具体的连接数据库的环境信息
    属性：
    id：设置环境的唯一标识，可通过environments标签中的default设置某一个环境的id，表示默认使用的环境
    -->
        <environment id="mysql_test">
            <!--
    transactionManager：设置事务管理方式
    属性：
    type：设置事务管理方式，type="JDBC|MANAGED"
    type="JDBC"：设置当前环境的事务管理都必须手动处理
    type="MANAGED"：设置事务被管理，例如spring中的AOP
    -->
            <transactionManager type="JDBC"/>
            <!--
    dataSource：设置数据源
    属性：
    type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
    type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建
    type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
    type="JNDI"：调用上下文中的数据源
    -->
            <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>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <!-- <mapper resource="UserMapper.xml"/> -->
        <!--
    以包为单位，将包下所有的映射文件引入核心配置文件
    注意：
    1. 此方式必须保证mapper接口和mapper映射文件必须在相同的包下
    2. mapper接口要和mapper映射文件的名字一致
    -->
        <package name="com.rokned.mybatis.mapper"/>
    </mappers>
</configuration>

3.增删改查

<!--int insertUser();-->
<insert id="insertUser">
    insert into t_user values(null,'admin','123456',23,'男','12345@qq.com')
</insert>

<!--int deleteUser();-->
<delete id="deleteUser">
    delete from t_user where id = 6
</delete>

<!--int updateUser();-->
<update id="updateUser">
    update t_user set username = '张三' where id = 5
</update>

<!--User getUserById(); mapper中需要一个返回对象-->  
<select id="getUserById" resultType="com.rokned.mybatis.bean.User">  
    select * from t_user where id = 2  
</select>

<!--List<User> getUserList(); mapper中需要一个返回对象的集合-->
<select id="getUserList" resultType="com.rokned.mybatis.bean.User">
    select * from t_user
</select>
  1. 查询的标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射关系
    1. resultType：自动映射，用于属性名和表中字段名一致的情况
    2. resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况
  2. 当查询的数据为多条时，不能使用实体类作为返回值，只能使用集合，否则会抛出异常TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

4.MyBatis获取参数值的两种方式

  • MyBatis获取参数值的两种方式：${}和#{}
  • ${}的本质就是字符串拼接，#{}的本质就是占位符赋值
  • ${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；但是#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

尽量使用#{}

单个字面量类型的参数

  • 若mapper接口中的方法参数为单个的字面量类型，此时可以使用KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}以任意的名称（最好见名识意…{}需要手动加单引号
<!--User getUserByUsername(String username);-->
<select id="getUserByUsername" resultType="User">
    select * from t_user where username = #{username}
</select>

<!--User getUserByUsername(String username);-->
<select id="getUserByUsername" resultType="User">  
	select * from t_user where username = '${username}'  
</select>

多个字面量类型的参数

  • 若mapper接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个map集合中
    • 以arg0,arg1…为键，以参数为值；
    • 以param1,param2…为键，以参数为值；
  • 因此只需要通过KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}访问map集合的键就可以获…{}需要手动加单引号。
  • 使用arg或者param都行，要注意的是，arg是从arg0开始的，param是从param1开始的
<!--User checkLogin(String username,String password);-->
<select id="checkLogin" resultType="User">  
	select * from t_user where username = #{arg0} and password = #{arg1}  
</select>

map集合类型的参数

<!--User checkLoginByMap(Map<String,Object> map);-->
<select id="checkLoginByMap" resultType="User">
    select * from t_user where username = #{username} and password = #{password}
</select>

@Test
public void checkLoginByMap() {
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    Map<String,Object> map = new HashMap<>();
    map.put("usermane","admin");
    map.put("password","123456");
    User user = mapper.checkLoginByMap(map);
    System.out.println(user);
}

实体类类型的参数

<!--int insertUser(User user);-->
<insert id="insertUser">
	insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email})
</insert>

@Test
public void insertUser() {
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    User user = new User(null,"Tom","123456",12,"男","123@321.com");
    mapper.insertUser(user);
}

使用@Param标识参数

  • 可以通过@Param注解标识mapper接口中的方法参数，此时，会将这些参数放在map集合中
    1. 以@Param注解的value属性值为键，以参数为值；
    2. 以param1,param2…为键，以参数为值；
<!--User CheckLoginByParam(@Param("username") String username, @Param("password") String password);-->
<select id="CheckLoginByParam" resultType="User">
    select * from t_user where username = #{username} and password = #{password}
</select>


@Test
public void checkLoginByParam() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
	mapper.CheckLoginByParam("admin","123456");
}

5.查询多条数据为map集合

方法一

/**  
 * 查询所有用户信息为map集合  
 * @return  
 * 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取  
 */  
List<Map<String, Object>> getAllUserToMap();

<!--Map<String, Object> getAllUserToMap();-->  
<select id="getAllUserToMap" resultType="map">  
    select * from t_user  
</select>
<!--
结果：
[{password=123456, sex=男, id=1, age=23, username=admin},
{password=123456, sex=男, id=2, age=23, username=张三},
{password=123456, sex=男, id=3, age=23, username=张三}]
-->

方法二

/**
 * 查询所有用户信息为map集合
 * @return
 * 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，并且最终要以一个map的方式返回数据，此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的map集合
 */
@MapKey("id")
Map<String, Object> getAllUserToMap();

<!--Map<String, Object> getAllUserToMap();-->
<select id="getAllUserToMap" resultType="map">
    select * from t_user
</select>
<!--
    结果：
{
    1={password=123456, sex=男, id=1, age=23, username=admin},
    2={password=123456, sex=男, id=2, age=23, username=张三},
    3={password=123456, sex=男, id=3, age=23, username=张三}
}
-->

6.特殊SQL的执行

模糊查询

/**
 * 根据用户名进行模糊查询
 * @param username 
 * @return java.util.List<com.rokned.mybatis.pojo.User>
 * @date 2022/2/26 21:56
 */
List<User> getUserByLike(@Param("username") String username);

<!--List<User> getUserByLike(@Param("username") String username);-->
<select id="getUserByLike" resultType="User">
    <!--select * from t_user where username like '%${mohu}%'-->  
    <!--select * from t_user where username like concat('%',#{mohu},'%')-->  
    select * from t_user where username like "%"#{mohu}"%" <!-- 最常用 -->
</select>

批量删除

/**
 * 根据id批量删除
 * @param ids 
 * @return int
 * @date 2022/2/26 22:06
 */
int deleteMore(@Param("ids") String ids);

<delete id="deleteMore">
	delete from t_user where id in (${ids}) <!-- 此时不能使用#{}，因为会自动添加单引号 -->
</delete>

//测试类
@Test
public void deleteMore() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
	int result = mapper.deleteMore("1,2,3,8");
	System.out.println(result);
}

动态设置表名

  • 只能使用${}，因为表名不能加单引号
/**
 * 查询指定表中的数据
 * @param tableName 
 * @return java.util.List<com.rokned.mybatis.pojo.User>
 * @date 2022/2/27 14:41
 */
List<User> getUserByTable(@Param("tableName") String tableName);

<!--List<User> getUserByTable(@Param("tableName") String tableName);-->
<select id="getUserByTable" resultType="User">
	select * from ${tableName}
</select>

添加功能获取自增的主键

  • 在mapper.xml中设置两个属性

    • useGeneratedKeys：设置使用自增的主键

    • keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中

/**
 * 添加用户信息
 * @param user 
 * @date 2022/2/27 15:04
 */
void insertUser(User user);

<!--void insertUser(User user);-->
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
    insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email})
</insert>

//测试类
@Test
public void insertUser() {
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    User user = new User(null, "ton", "123", 23, "男", "123@321.com");
    mapper.insertUser(user);
    System.out.println(user);
    //输出：user{id=10, username='ton', password='123', age=23, sex='男', email='123@321.com'}，自增主键存放到了user的id属性中
}

7.自定义映射resultMap

若字段名和实体类中的属性名不一致，但是字段名符合数据库的规则（使用_），实体类中的属性名符合Java的规则（使用驼峰）。此时也可通过以下两种方式处理字段名和实体类中的属性的映射关系

字段起别名

<!--List<Emp> getAllEmp();-->
<select id="getAllEmp" resultType="Emp">
	select eid,emp_name empName,age,sex,email from t_emp
</select>

设置全局配置信息

可以在查询表中数据时，自动将_类型的字段名转换为驼峰，例如：字段名user_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为userName。

<settings>
    <setting name="mapUnderscoreToCamelCase" value"true"/>
</settings>

resultmap

  • resultMap：设置自定义映射
    • 属性：
      • id：表示自定义映射的唯一标识，不能重复
      • type：查询的数据要映射的实体类的类型
    • 子标签：
      • id：设置主键的映射关系
      • result：设置普通字段的映射关系
      • 子标签属性：
        • property：设置映射关系中实体类中的属性名
        • column：设置映射关系中表中的字段名
  • 若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射，即使字段名和属性名一致的属性也要映射，也就是全部属性都要列出来
<resultMap id="empResultMap" type="Emp">
    <id property="eid" column="eid"></id>
    <!-- 此处empName是属性，emp_name是字段 -->
    <result property="empName" column="emp_name"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
    <result property="email" column="email"></result>
</resultMap>
<!--List<Emp> getAllEmp();-->
<select id="getAllEmp" resultMap="empResultMap">
    select * from t_emp
</select>

多对一映射处理

级联方式处理映射关系
public class Emp {  
	private Integer eid;  
	private String email;  
	private Dept dept;
	//...构造器、get、set方法等
}

<resultMap id="empAndDeptResultMapOne" type="Emp">
    <id property="eid" column="eid"></id>
    <result property="dept.did" column="did"></result>
    <result property="dept.deptName" column="dept_name"></result>
</resultMap>
<!--Emp getEmpAndDept(@Param("eid")Integer eid);-->
<select id="getEmpAndDept" resultMap="empAndDeptResultMapOne">
    select * from t_emp left join t_dept on t_emp.eid = t_dept.did where t_emp.eid = #{eid}
</select>
使用association处理映射关系
  • association：处理多对一的映射关系
  • property：需要处理多对的映射关系的属性名
  • javaType：该属性的类型
<resultMap id="empAndDeptResultMapTwo" type="Emp">
	<id property="eid" column="eid"></id>
	<association property="dept" javaType="Dept">
		<id property="did" column="did"></id>
		<result property="deptName" column="dept_name"></result>
	</association>
</resultMap>
<!--Emp getEmpAndDept(@Param("eid")Integer eid);-->
<select id="getEmpAndDept" resultMap="empAndDeptResultMapTwo">
	select * from t_emp left join t_dept on t_emp.eid = t_dept.did where t_emp.eid = #{eid}
</select>
分布查询
实现
  • select：设置分布查询的sql的唯一标识（namespace.SQLId或mapper接口的全类名.方法名）
  • column：设置分步查询的条件
//EmpMapper里的方法
/**
 * 通过分步查询，员工及所对应的部门信息
 * 分步查询第一步：查询员工信息
 * @param  
 * @return com.rokned.mybatis.pojo.Emp
 * @date 2022/2/27 20:17
 */
Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);

//DeptMapper里的方法
/**
 * 通过分步查询，员工及所对应的部门信息
 * 分步查询第二步：通过did查询员工对应的部门信息
 * @param
 * @return com.rokned.mybatis.pojo.Emp
 * @date 2022/2/27 20:23
 */
Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);

<resultMap id="empAndDeptByStepResultMap" type="Emp">
	<id property="eid" column="eid"></id>
	<association property="dept"
				 select="com.rokned.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
				 column="did"></association>
</resultMap>
<!--Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);-->
<select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
	select * from t_emp where eid = #{eid}
</select>

<!-- 两个查询不在同一个xml下 -->
<!--此处的resultMap仅是处理字段和属性的映射关系-->
<resultMap id="EmpAndDeptByStepTwoResultMap" type="Dept">
	<id property="did" column="did"></id>
	<result property="deptName" column="dept_name"></result>
</resultMap>
<!--Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);-->
<select id="getEmpAndDeptByStepTwo" resultMap="EmpAndDeptByStepTwoResultMap">
	select * from t_dept where did = #{did}
</select>
懒加载
  • 分步查询的优点：可以实现延迟加载，但是必须在核心配置文件中设置全局配置信息：
    • lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。需要开启
    • aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。 否则，每个属性会按需加载。需要关闭
  • 此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType=“lazy(延迟加载)|eager(立即加载)”
<settings>
    <!--开启延迟加载-->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>


@Test
public void getEmpAndDeptByStepOne() {
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    Emp emp = mapper.getEmpAndDeptByStepOne(1);
    System.out.println(emp.getEmpName());
}

在这里插入图片描述

在这里插入图片描述

@Test
public void getEmpAndDeptByStepOne() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	Emp emp = mapper.getEmpAndDeptByStepOne(1);
	System.out.println(emp.getEmpName());
	System.out.println("----------------");
	System.out.println(emp.getDept());
}

在这里插入图片描述

fetchType：当开启了全局的延迟加载之后，可以通过该属性手动控制延迟加载的效果，fetchType=“lazy(延迟加载)|eager(立即加载)”

<resultMap id="empAndDeptByStepResultMap" type="Emp">
	<id property="eid" column="eid"></id>
	<result property="empName" column="emp_name"></result>
	<result property="age" column="age"></result>
	<result property="sex" column="sex"></result>
	<result property="email" column="email"></result>
	<association property="dept"
				 select="com.rokned.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
				 column="did"
				 fetchType="lazy"></association>
</resultMap>

一对多映射处理

collection
  • collection：用来处理一对多的映射关系
  • ofType：表示该属性对应的集合中存储的数据的类型
<resultMap id="DeptAndEmpResultMap" type="Dept">
    <id property="did" column="did"></id>
    <result property="deptName" column="dept_name"></result>
    <collection property="emps" ofType="Emp">
        <id property="eid" column="eid"></id>
        <result property="empName" column="emp_name"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
        <result property="email" column="email"></result>
    </collection>
</resultMap>
<!--Dept getDeptAndEmp(@Param("did") Integer did);-->
<select id="getDeptAndEmp" resultMap="DeptAndEmpResultMap">
    select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did}
</select>
分步查询
/**
 * 通过分步查询，查询部门及对应的所有员工信息
 * 分步查询第一步：查询部门信息
 * @param did 
 * @return com.rokned.mybatis.pojo.Dept
 * @date 2022/2/27 22:04
 */
Dept getDeptAndEmpByStepOne(@Param("did") Integer did);

<resultMap id="DeptAndEmpByStepOneResultMap" type="Dept">
    <id property="did" column="did"></id>
    <result property="deptName" column="dept_name"></result>
    <collection property="emps"
                select="com.rokned.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
                column="did"></collection>
</resultMap>
<!--Dept getDeptAndEmpByStepOne(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepOne" resultMap="DeptAndEmpByStepOneResultMap">
    select * from t_dept where did = #{did}
</select>

/**
 * 通过分步查询，查询部门及对应的所有员工信息
 * 分步查询第二步：根据部门id查询部门中的所有员工
 * @param did
 * @return java.util.List<com.rokned.mybatis.pojo.Emp>
 * @date 2022/2/27 22:10
 */
List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);	

<!--List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepTwo" resultType="Emp">
    select * from t_emp where did = #{did}
</select>

8.动态SQL

if

  • if标签可通过test属性（即传递过来的数据）的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中的内容不会执行
  • 在where后面添加一个恒成立条件1=1
    • 这个恒成立条件并不会影响查询的结果
    • 这个1=1可以用来拼接and语句，例如：当empName为null时
      • 如果不加上恒成立条件，则SQL语句为select * from t_emp where and age = ? and sex = ? and email = ?，此时where会与and连用，SQL语句会报错
      • 如果加上一个恒成立条件，则SQL语句为select * from t_emp where 1= 1 and age = ? and sex = ? and email = ?，此时不报错
<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp where 1=1
    <if test="empName != null and empName !=''">
        and emp_name = #{empName}
    </if>
    <if test="age != null and age !=''">
        and age = #{age}
    </if>
    <if test="sex != null and sex !=''">
        and sex = #{sex}
    </if>
    <if test="email != null and email !=''">
        and email = #{email}
    </if>
</select>

where

  • where和if一般结合使用：
    • 若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字
    • 若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and/or去掉
<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
	select * from t_emp
	<where>
		<if test="empName != null and empName !=''">
			emp_name = #{empName}
		</if>
		<if test="age != null and age !=''">
			and age = #{age}
		</if>
		<if test="sex != null and sex !=''">
			and sex = #{sex}
		</if>
		<if test="email != null and email !=''">
			and email = #{email}
		</if>
	</where>
</select>

注，只能去掉最前面的，不能去掉后面的

<!--这种用法是错误的，只能去掉条件前面的and/or，条件后面的不行-->
<if test="empName != null and empName !=''">
    emp_name = #{empName} and
</if>
<if test="age != null and age !=''">
    age = #{age}
</if>

trim

  • trim用于去掉或添加标签中的内容
  • 常用属性
    • prefix：在trim标签中的内容的前面添加某些内容
    • suffix：在trim标签中的内容的后面添加某些内容
    • prefixOverrides：在trim标签中的内容的前面去掉某些内容
    • suffixOverrides：在trim标签中的内容的后面去掉某些内容
  • 若trim中的标签都不满足条件，则trim标签没有任何效果，也就是只剩下select * from t_emp
<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
    <trim prefix="where" suffixOverrides="and|or">
        <if test="empName != null and empName !=''">
            emp_name = #{empName} and
        </if>
        <if test="age != null and age !=''">
            age = #{age} and
        </if>
        <if test="sex != null and sex !=''">
            sex = #{sex} or
        </if>
        <if test="email != null and email !=''">
            email = #{email}
        </if>
    </trim>
</select>

choose、when、otherwise

  • choose、when、otherwise相当于if...else if..else
  • when至少要有一个，otherwise至多只有一个
<select id="getEmpByChoose" resultType="Emp">
    select * from t_emp
    <where>
        <choose>
            <when test="empName != null and empName != ''">
                emp_name = #{empName}
            </when>
            <when test="age != null and age != ''">
                age = #{age}
            </when>
            <when test="sex != null and sex != ''">
                sex = #{sex}
            </when>
            <when test="email != null and email != ''">
                email = #{email}
            </when>
            <otherwise>
                did = 1
            </otherwise>
        </choose>
    </where>
</select>

foreach

  • 属性：

    • collection：设置要循环的数组或集合
    • item：表示集合或数组中的每一个数据
    • separator：设置循环体之间的分隔符，分隔符前后默认有一个空格，如,
    • open：设置foreach标签中的内容的开始符
    • close：设置foreach标签中的内容的结束符

  • 批量删除

    <!--int deleteMoreByArray(@Param("eids") Integer[] eids);-->
<delete id="deleteMoreByArray">
	delete from t_emp where eid in
	<foreach collection="eids" item="eid" separator="," open="(" close=")">
		#{eid}
	</foreach>
</delete>

    @Test
public void deleteMoreByArray() {
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    int result = mapper.deleteMoreByArray(new Integer[]{6, 7, 8, 9});
    System.out.println(result);
}

  • 批量添加

    <!--int insertMoreByList(@Param("emps") List<Emp> emps);-->
<insert id="insertMoreByList">
    insert into t_emp values
    <foreach collection="emps" item="emp" separator=",">
        (null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
    </foreach>
</insert>

    @Test
public void insertMoreByList() {
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    Emp emp1 = new Emp(null,"a",1,"男","123@321.com",null);
    Emp emp2 = new Emp(null,"b",1,"男","123@321.com",null);
    Emp emp3 = new Emp(null,"c",1,"男","123@321.com",null);
    List<Emp> emps = Arrays.asList(emp1, emp2, emp3);
    int result = mapper.insertMoreByList(emps);
    System.out.println(result);
}

SQL片段

  • sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引入
  • 声明sql片段：<sql>标签
  • 引用sql片段：<include>标签
<sql id="empColumns">eid,emp_name,age,sex,email</sql>

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
	select <include refid="empColumns"></include> from t_emp
</select>

9.MyBatis的缓存

一级缓存

  • 一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问
  • 使一级缓存失效的四种情况：
    • 不同的SqlSession对应不同的一级缓存
    • 同一个SqlSession但是查询条件不同
    • 同一个SqlSession两次查询期间执行了任何一次增删改操作
    • 同一个SqlSession两次查询期间手动清空了缓存

二级缓存

  • 二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取
  • 二级缓存开启的条件
    • 在核心配置文件中，设置全局配置属性cacheEnabled=“true”，默认为true，不需要设置
    • 在映射文件中设置标签<cache />
    • 二级缓存必须在SqlSession关闭或提交之后有效
    • 查询的数据所转换的实体类类型必须实现序列化的接口 implements Serializable
  • 使二级缓存失效的情况：两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

二级缓存的相关配置

在mapper配置文件中添加的cache标签可以设置一些属性

  • eviction属性：缓存回收策略
    • LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。
    • FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。
    • SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
    • WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
    • 默认的是 LRU
  • flushInterval属性：刷新间隔，单位毫秒
    • 默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句（增删改）时刷新
  • size属性：引用数目，正整数
    • 代表缓存最多可以存储多少个对象，太大容易导致内存溢出
  • readOnly属性：只读，true/false
    • true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
    • false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false

MyBatis缓存查询的顺序

  • 先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用
  • 如果二级缓存没有命中，再查询一级缓存
  • 如果一级缓存也没有命中，则查询数据库
  • SqlSession关闭之后，一级缓存中的数据会写入二级缓存

10.MyBatis的逆向工程

  • 正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。Hibernate是支持正向工程的
  • 逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：
    • Java实体类
    • Mapper接口
    • Mapper映射文件

依赖

<dependencies>
    <!-- MyBatis核心依赖包 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.27</version>
    </dependency>
    <!-- log4j日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>
<!-- 控制Maven在构建过程中相关配置 -->
<build>
    <!-- 构建过程中用到的插件 -->
    <plugins>
        <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.0</version>
            <!-- 插件的依赖 -->
            <dependencies>
                <!-- 逆向工程的核心依赖 -->
                <dependency>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-core</artifactId>
                    <version>1.3.2</version>
                </dependency>
                <!-- 数据库连接池 -->
                <dependency>
                    <groupId>com.mchange</groupId>
                    <artifactId>c3p0</artifactId>
                    <version>0.9.2</version>
                </dependency>
                <!-- MySQL驱动 -->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>8.0.27</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

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>
    <properties resource="jdbc.properties"/>
    <typeAliases>
        <package name=""/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <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>
        </environment>
    </environments>
    <mappers>
        <package name=""/>
    </mappers>
</configuration>

逆向工程的配置文件

  • 文件名必须是：generatorConfig.xml
  • url报红没关系
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
    targetRuntime: 执行生成的逆向工程的版本
    MyBatis3Simple: 生成基本的CRUD（清新简洁版）
    MyBatis3: 生成带条件的CRUD（奢华尊享版）
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
                        userId="root"
                        password="123456">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.rokned.mybatis.pojo" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="com.rokned.mybatis.mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.rokned.mybatis.mapper" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- 逆向分析的表 -->
        <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
        <!-- domainObjectName属性指定生成出来的实体类的类名 -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

运行

在这里插入图片描述

QBC

查询
  • selectByExample：按条件查询，需要传入一个example对象或者null；如果传入一个null，则表示没有条件，也就是查询所有数据
  • example.createCriteria().xxx：创建条件对象，通过andXXX方法为SQL添加查询添加，每个条件之间是and关系
  • example.or().xxx：将之前添加的条件通过or拼接其他条件
@Test 
public void testMBG() throws IOException {
    InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    EmpExample example = new EmpExample();
    //名字为张三，且年龄大于等于20
    example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThanOrEqualTo(20);
    //或者did不为空
    example.or().andDidIsNotNull();
    List<Emp> emps = mapper.selectByExample(example);
    emps.forEach(System.out::println);
}
增改

  • updateByPrimaryKey：通过主键进行数据修改，如果某一个值为null，也会将对应的字段改为null

    • mapper.updateByPrimaryKey(new Emp(1,"admin",22,null,"456@qq.com",3));
    • 在这里插入图片描述

  • updateByPrimaryKeySelective()：通过主键进行选择性数据修改，如果某个值为null，则不修改这个字段

    • mapper.updateByPrimaryKeySelective(new Emp(2,"admin2",22,null,"456@qq.com",3));
    • 在这里插入图片描述

11.分页插件

依赖

<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>5.2.0</version>
</dependency>

配置插件

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

<plugins>
	<!--设置分页插件-->
	<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

开启使用

  • 在查询功能之前使用

    PageHelper.startPage(int pageNum, int pageSize)

  • 开启分页功能

    • pageNum：当前页的页码
    • pageSize：每页显示的条数
@Test
public void testPageHelper() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	//访问第一页，每页四条数据
	PageHelper.startPage(1,4);
	List<Emp> emps = mapper.selectByExample(null);
	emps.forEach(System.out::println);
}

分页数据

在这里插入图片描述

@Test
public void testPageHelper() throws IOException {
    InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    //访问第一页，每页四条数据
    Page<Object> page = PageHelper.startPage(1, 4);
    List<Emp> emps = mapper.selectByExample(null);
    //在查询到List集合后，打印分页数据
    System.out.println(page);
}

Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=8, pages=2, reasonable=false, pageSizeZero=false}[Emp{eid=1, empName='admin', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=2, empName='admin2', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=3, empName='王五', age=12, sex='女', email='123@qq.com', did=3}, Emp{eid=4, empName='赵六', age=32, sex='男', email='123@qq.com', did=1}]

使用PageInfo

  • 在查询获取list集合之后，使用

    PageInfo pageInfo = new PageInfo<>(List list, intnavigatePages)

  • 获取分页相关数据

    • list：分页之后的数据
    • navigatePages：导航分页的页码数
@Test
public void testPageHelper() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	PageHelper.startPage(1, 4);
	List<Emp> emps = mapper.selectByExample(null);
	PageInfo<Emp> page = new PageInfo<>(emps,5);
	System.out.println(page);
}

PageInfo{
pageNum=1, pageSize=4, size=4, startRow=1, endRow=4, total=8, pages=2, 
list=Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=8, pages=2, reasonable=false, pageSizeZero=false}[Emp{eid=1, empName='admin', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=2, empName='admin2', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=3, empName='王五', age=12, sex='女', email='123@qq.com', did=3}, Emp{eid=4, empName='赵六', age=32, sex='男', email='123@qq.com', did=1}], 
prePage=0, nextPage=2, isFirstPage=true, isLastPage=false, hasPreviousPage=false, hasNextPage=true, navigatePages=5, navigateFirstPage=1, navigateLastPage=2, navigatepageNums=[1, 2]}
Flandre_rokned
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis mysql 分表_Mybatis的分表实战
weixin_34670892的博客
01-27 513
前言:以前写代码, 关于mysql的分库分表已被中间件服务所支持, 业务代码涉及的sql已规避了这块. 它对扩展友好, 你也不知道到底他分为多少库, 多少表, 一切都是透明的.不过对于小的团队/工作室而言, 可能就没有那么强大的分布式中间件的基础设施支持了, 而当数据库上去的时候, 分库分表就需要客户端client这边去支持维护了. 如何优雅地使用mybatis支持分表, 这就是本文的主题.myb...
mybatis mysql set命令_Mybatis-Plus 常用操作
weixin_35538624的博客
02-17 3643
MyBatis-Plus系列推荐阅读顺序:本文目录结构一、SQL日志开关二、常用注解三、代码生成器四、分页查询五、Mybatis-Plus Wrapper六、自动填充数据功能七、逻辑删除八、乐观锁一、SQL日志开关配置文件application.properties，增加最后一行，执行时会打印出 sql 语句。spring.application.name=mybatis-plus# 应用服务 W...
Mybatis07_Mybatis连接池的介绍
weixin_44051048的博客
11-16 303
1 连接池 ​ 我们实际开发中都会使用连接池，因为他可以减少我们获取连接所消耗的时间 ​ 其实连接池就是一个储存 连接的 一个容器（基于队列的实现） ​ 2 Mybatis中的连接池 mybatis连接池提供了3种方式的配置： 配置的位置： 主配置文件Mybatis_config.xml中的dataSource标签，type属性就是表示采用何种连接池方式。 type属性的取值： POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis
MyBatis复习——day07_MyBatis分页插件的使用
qq_46061535的博客
08-29 124
pageSize：每页显示的条数pageNum：当前页的页码index：当前页的起始索引，index=(pageNum-1)*pageSizecount：总记录数totalPage：总页数= 0){}select * from 表名 limit index,pageSize;index从0开始。
2021-06-07_Mybatis——动态SQL，结果集映射
折枝
06-07 262
Mybatis——动态SQL，结果集映射动态SQLDao接口：select按照对象查询Dao接口：insert按照对象插入Dao接口：update按照对象修改Dao接口：update按照对象修改 动态SQL Dao接口：select按照对象查询 List<Student> selectByStudentSelective(Student student); 对应的 SQL <select id="selectAll" resultType="com.wistron.pojo.SfcCo
05_02_Mybatis||day02_Mybatis第二天||（总结篇，原文很详细）
qq_40572023的博客
06-21 154
今日课程内容介绍 第二章 Mybatis的curd（基于代理dao的方式） 2.1 回顾自定义Mybatis的流程 流程图 不管使用哪种方式都只干了两件事： 查询结果，封装结果集 创建代理对象，调用查询结果 总结（自定义不是重点，重点还是如何去实现与执行Mybatis的使用） 2.2 xml和注解重点流程【重点】 不要拘泥于某个技术点来得到某些内容 主要关注的是从里面拿出什么内容来解决什么内容【如下】 获取到连接数据库的信息 拿到映射配置的信息（映射配置里面提供的信息） xm
07_MyBatis原始的Dao编写方法
weixin_30901729的博客
07-24 65
【UserDao.java 】 package com.Higgin.Mybatis.dao; import com.Higgin.Mybatis.po.User; public interface UserDao { //根据id查询用户信息 public User findUserById(int id) throws Exception; ...
最详细的分库分表Demo—springboot_shardingjdbc_mybatis
热门推荐
不是很懂
04-19 2万+
分库分表 — Shardingjdbc 分库分表：分库分表 为什么分表？ 肯定是因为需要 怎么进行分表？垂直分表和水平分表 什么是垂直分表？如果表过大，垂直分表就是按照业务角度将大列分为几个表，划分的原则一般是频繁变化的分为一个表，不频繁变化的，尤其大字段，如text和blob字段这种影响io性能的划分为另外一个表中，这样就实现了垂直分表。如下图： 什么是水平分表？就是将数据根据策略分到不同的表中，从而使数据均匀的分布在不同的数据库和表中，也是最常见的分表方式。如下就是将一个表分为四个表： 将ds库中的o
2024年最新MyBatis 拦截器使用方法总结_mybatis拦截器的使用
2401_84302796的博客
05-01 348
MyBatis。
【SSM_Mybatis】学习笔记07
多啦CCCC梦的百宝袋
01-27 218
Mybatis-spring框架整合开发： 目的： （1）使用Spring容器用单例模式管理Mybatis的sqlSessionFactory； （2）使用Spring管理连接池、数据源等； （3）将dao\mapper动态代理对象注入到Spring容器中，使用时直接获取； 1、Mybatis和Spring框架整合 a)导入所需的包 b)创建Mybatis主配置文件 sqlMap...
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 2706
【代码】MybatisPlus的LambdaQueryWrapper用法。
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3115
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1147
浅析synchronized锁升级的原理与实现
操作系统原子操作
zzt_is_me的博客
08-28 8617
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 386
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 5641
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 825
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 5760
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
java后端开发-Mybatis连接数据库步骤
最新发布
weixin_73355603的博客
09-02 1543
🎙座右铭：得之坦然，失之淡然。💎擅长领域：前端是的，我需要您的：是我持续下去的动力！先看看目录，是不是IDEA的配置，数据库mysql或者其他的数据库这套方法都适合的。
mybatis-plus 依赖
07-27
Mybatis-Plus是一个基于Mybatis的增强工具，可以简化Mybatis的开发流程。根据提供的引用内容，可以看出Mybatis-Plus的依赖有两个版本，分别是3.5.2和3.3.1。其中，引用\[1\]和引用\[2\]都是使用的3.5.2版本的依赖，而引用\[3\]使用的是3.3.1版本的依赖。具体的依赖配置如下： 引用\[1\]和引用\[2\]的依赖配置： ```xml <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.2</version> </dependency> ``` 引用\[3\]的依赖配置： ```xml <!--Mybatis-plus的依赖--> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.3.1</version> </dependency> <!--mysql的依赖--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <!--lombok的依赖，为了优化实体类，可以不去实现实体类的set()、get()--> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> ``` 所以，根据你的需求，你可以根据自己的项目需要选择使用3.5.2版本的依赖还是3.3.1版本的依赖。 #### 引用[.reference_title] - *1* *2* [[Mybatis-Plus笔记] MybatisPlus-07-代码生成器及相关依赖](https://blog.csdn.net/Cey_Tao/article/details/127012002)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [MyBatisPlus](https://blog.csdn.net/m0_60213304/article/details/124203155)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值