mybatis

Cherish-G

已于 2023-09-16 08:18:55 修改

阅读量92

点赞数

文章标签： mybatis

于 2023-09-14 19:41:36 首次发布

本文链接：https://blog.csdn.net/m0_73430222/article/details/132887969

版权

mybatis

Mybatis

Mybatis

概念

框架是一款半成品软件，我们可以基于这个半成品软件继续开发，来完成我们个性化的需求！
ORM(Object Relational Mapping 对象关系映射)：指的是持久化数据和实体对象的映射模式。
mybatis:mybatis 是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。
mybatis通过xml或注解的方式将要执行的各种 statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句。
最后mybatis框架执行sql并将结果映射为java对象并返回。采用ORM思想解决了实体和数据库映射的问题，对jdbc 进行了封装，屏蔽了jdbc api 底层访问细节，使我们不用与jdbc api 打交道，就可以完成对数据库的持久化操作。

mybatis的使用

开发步骤

导入mybatis的maven依赖包

<dependencies>
		//JUnit：JUnit是一个Java编程语言的单元测试框架，用于编写和运行自动化测试。
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        //MySQL Connector/J：MySQL Connector/J是Java连接到MySQL数据库的官方驱动程序。
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
        </dependency>
        //MyBatis：MyBatis是一个Java持久层框架，用于将数据库操作与Java对象之间的映射进行配置和管理。
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>
        //Lombok：Lombok是一个Java库，用于通过注解自动化生成Java类的常用方法（如getter、setter、构造函数等），以减少样板代码的编写。
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        //Log4j：Log4j是一个Java日志记录工具，用于在应用程序中生成和管理日志。
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>

创建user数据表

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `phone` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

编写User实体类（model包）

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {
    private int id;
    private String username;
    private String password;
    private int age;
    private String phone;
}

编写mybatis的配置文件

核心文件 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--configuration 核心根标签-->
<configuration>

    <!--引入数据库连接的配置文件-->
    <properties resource="db.properties"/>

    <!--配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

    <!--起别名-->
    <typeAliases>
        <typeAlias type="com.xinzhi.model.User" alias="user"/>
        <!--<package name="com.xinzhi.model"/>-->
    </typeAliases>

    <!--environments配置数据库环境，环境可以有多个。default属性指定使用的是哪个-->
    <environments default="mysql">
        <!--environment配置数据库环境  id属性唯一标识-->
        <environment id="mysql">
            <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- dataSource数据源信息   type属性 连接池-->
            <dataSource type="POOLED">
                <!-- property获取数据库连接的配置信息 -->
                <property name="driver" value="${driver}" />
                <property name="url" value="${url}" />
                <property name="username" value="${username}" />
                <property name="password" value="${password}" />
            </dataSource>
        </environment>
    </environments>

    <!-- mappers引入映射配置文件 -->
    <mappers>
        <!-- mapper 引入指定的映射配置文件   resource属性指定映射配置文件的名称 -->
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

数据库信息 db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf-8
username=root
password=123456

日志文件 log4j.properties

# Global logging configuration
# ERROR WARN INFO DEBUG
log4j.rootLogger=DEBUG, stdout
# 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

编写接口（dao包）和映射文件（resources文件夹下）

public interface UserMapper {

    List<User> selectAll();

    User selectById(int id);
}

映射文件 UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--
    mapper：核心根标签
    namespace属性：名称空间
-->
<mapper namespace="com.xinzhi.mapper.UserMapper">
    <!--
        select：查询功能的标签
        id属性：唯一标识
        resultType属性：指定结果映射对象类型
        parameterType属性：指定参数映射对象类型
    -->
    <select id="selectAll" resultType="user">
        select id,username,password,age,phone from user
    </select>
    <select id="selectById" resultType="com.xinzhi.model.User" parameterType="int">
        select id,username,password,age,phone from user where id=#{id}
    </select>
</mapper>

namespace：配置接口的全限定名

编写测试类

public class Test01 {
    public static void main(String[] args) throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis.xml");
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = build.openSession();
        List<User> users = sqlSession.selectList("com.xinzhi.dao.UserMapper.selectAll");
        System.out.println(users);
        User user = sqlSession.selectOne("com.xinzhi.dao.UserMapper.selectById", 1);
        System.out.println(user);
        sqlSession.close();
    }
}
直接使用了SqlSession的selectList和selectOne方法来执行SQL语句。通过传入字符串参数指定了要执行的SQL语句的ID，例如"com.xinzhi.dao.UserMapper.selectAll"和"com.xinzhi.dao.UserMapper.selectById"。这种方式需要手动编写SQL语句并指定其ID，稍显繁琐。

注意如果是增删改需要提交事务 sqlSession.commit();
如果sqlSessionFactory.openSession(true)，括号中添加了true，那么就是自动提交事务。

注意事项

# 事务管理器（transactionManager）
	- JDBC：这个配置就是直接使用了JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
	- MANAGED：这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接，然而一些容器并不希望这样，因此需要将 closeConnection 属性设置为 false 来阻止它默认的关闭行为。
# 数据源（dataSource）
	- UNPOOLED：这个数据源的实现只是每次被请求时打开和关闭连接。
	- POOLED：这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来。
	- JNDI：这个数据源的实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。

代理方式开发

采用 Mybatis 的代理开发方式实现 DAO 层的开发，这种方式是我们后面进入企业的主流。
Mapper 接口开发方法只需要程序员编写Mapper 接口（相当于Dao 接口），由Mybatis 框架根据接口定义创建接口的动态代理对象。
Mapper 接口开发需要遵循以下规范：
1. Mapper.xml文件中的namespace与mapper接口的全限定名相同
2. Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
3. Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同
4. Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

public class Test02 {
    public static void main(String[] args) throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis.xml");
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = build.openSession();
        //获取到mapper的代理对象，代理对象直接操作数据库
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.selectAll();
        System.out.println(users);
        User user = mapper.selectById(1);
        System.out.println(user);
        sqlSession.close();
    }
}
使用了MyBatis的Mapper接口和注解来执行数据库操作。首先通过SqlSession的getMapper方法获取到对应的Mapper接口的实例，然后直接调用接口中定义的方法来执行SQL语句，例如mapper.selectAll()和mapper.selectById(1)。这种方式通过接口的方法来执行SQL语句，更加简洁和易于维护。

mybatis和spring整合

开发步骤

导入maven依赖

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <!-- 基于AspectJ的aop依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <!-- spring 事务管理和JDBC依赖包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <!-- spring 单元测试组件包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <!-- 单元测试Junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!-- mysql数据库驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
        </dependency>
        <!-- dbcp连接池的依赖包 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <!-- mybatis依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>
        <!-- mybatis和spring的整合依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>

创建account的实体类（model包）

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Account {
    private int id;
    private String name;
    private BigDecimal money;
}

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `money` decimal(11,0) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

创建mapper接口（dao包）和对应的xml文件（resources/mapper文件夹下）

public interface AccountMapper {
    BigDecimal selectMoney(String name);
    int updateMoney(@Param("name")String name,@Param("money")BigDecimal money);
}

说明

@Param 注解用于给方法参数取别名，以便在SQL语句中引用这些参数。
这个注解的作用是为了在SQL语句中清晰地指定参数的别名，以避免在复杂的SQL语句中出现歧义或混淆。

<?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="com.xinzhi.dao.AccountMapper">
    <select id="selectMoney" parameterType="string" resultType="decimal">
        select money from account where name=#{name}
    </select>
    <update id="updateMoney" parameterType="account">
        update account set money=#{money} where name=#{name}
    </update>
</mapper>

Service接口类（service包）和实现类（impl包）

public interface IAccountService {
    void transfer(String from, String to, BigDecimal money);
}

@Service
@Transactional
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private AccountMapper accountMapper;
    @Override
    public void transfer(String from, String to, BigDecimal money) {
        BigDecimal fromMoney = accountMapper.selectMoney(from);
        accountMapper.updateMoney(from,fromMoney.subtract(money));
        BigDecimal toMoney = accountMapper.selectMoney(to);
        accountMapper.updateMoney(to,toMoney.add(money));
        System.out.println("支付宝到账"+money+"元");
    }
}

数据库的配置文件（db.properties）

数据库信息 db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf-8
username=root
password=123456

spring配置文件（applicationContext.xml）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
	    http://www.springframework.org/schema/tx
	    http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
	    http://www.springframework.org/schema/context
	    http://www.springframework.org/schema/context/spring-context-4.3.xsd
	    http://www.springframework.org/schema/aop
	    http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!--引入外部的配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>
    <!--	配置数据源-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!--	配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!--开启事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager" />

    <!--	xml方式配置事务，一般使用上面注解的方式，因为方便和简单，其实事务也是对业务层逻辑的增强-->
    <!--	<tx:advice transaction-manager="transactionManager" id="txAdvice" >-->
    <!--		<tx:attributes>-->
    <!--			<tx:method name="*" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/>-->
    <!--		</tx:attributes>-->
    <!--	</tx:advice>-->
    <!--	-->
    <!--	<aop:config>-->
    <!--		<aop:pointcut id="myPointCut" expression="execution(* com.soft.impl.*.*(..))"/>-->
    <!--		<aop:advisor advice-ref="txAdvice" pointcut-ref="myPointCut"/>-->
    <!--	</aop:config>-->


    <!--	配置sqlSessionFactory，主要是指定数据源，配置文件的位置-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>

    </bean>

    <!--	扫描mapper文件-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.xinzhi.dao"/>
    </bean>


    <!--	组件扫描，扫描指定包下的注解-->
    <context:component-scan base-package="com.xinzhi"/>

</beans>

mybatis的配置文件（mybatis-config.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>
    <!--    开启二级缓存，默认是关闭的-->
    <settings>
        <setting name = "cacheEnabled" value = "true" />
    </settings>

    <!--    别名-->
    <typeAliases>
        <package name="com.xinzhi.model" />
    </typeAliases>

    <!--    map.xml文件的位置指定，因为sqlsessionfactory中已经指定过了，所以可以不配置-->
    <mappers>
        <!--        <mapper resource="mapper/AccountMapper.xml"/>-->
    </mappers>

</configuration>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class Test03 {
    @Autowired
    private IAccountService accountService;
    @Test
    public void test03(){
        accountService.transfer("隔壁老王","小明", BigDecimal.valueOf(100));
    }
}

说明

@RunWith(SpringJUnit4ClassRunner.class) : 这是JUnit的一个注解，用于指定运行测试的类。 SpringJUnit4ClassRunner 是一个JUnit的扩展类，用于在测试时启动Spring容器，以便进行Spring框架的集成测试。
@ContextConfiguration(locations = {“classpath:applicationContext.xml”}) : 这是Spring的一个注解，用于指定配置文件的位置。在这个示例中， applicationContext.xml 是Spring的配置文件，通过 classpath:applicationContext.xml 指定了该配置文件的位置。该配置文件包含了Spring容器的配置信息，包括Bean的定义、依赖注入等。

mybatis的缓存

mybatis的缓存主要是针对查询操作的

一级缓存

一级缓存默认是开启的， SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。
当调用 SqlSession 的修改，添加，删除，commit()，close()等，方法时，就会清空一级缓存。

二级缓存

二级缓存是 mapper 映射级别的缓存，默认是不开启的，需要手动开启二级缓存
当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，也就是序列化

<!-- 开启二级缓存的支持 --> 
<setting name="cacheEnabled" value="true"/></settings>

隔离级别

读未提交（Read uncommitted）：脏读
脏读：一个事务在执行的过程中读取到了其他事务还没有提交的数据
读已提交（Read committed）：可避免脏读的发生。
两次读取的数据不一样，自己事务没有提交的时候可以读取别的已经提交的事务。
可重复读（Repeatable read）：幻读
MySql默认隔离级别。自己事务没有提交的时候，读不到别的已经提交的事务。
串行化（Serializable ）：可避免脏读、不可重复读、幻读的发生。

事务

事务有以下特性(ACID)：
1、原子性（Atomicity）
事务作为一个整体被执行，包含在其中的对数据库的操作要么全部被执行，要么都不执行。

2、一致性（Consistency）
事务应确保数据库的状态从一个一致状态转变为另一个一致状态。一致状态的含义是数据库中的数据应满足完整性约束。

3、隔离性（Isolation）
多个事务并发执行时，一个事务的执行不应影响其他事务的执行。

4、持久性（Durability）
已被提交的事务对数据库的修改应该永久保存在数据库中

mybatis中# 和 $的区别

在MyBatis中， # 和 $ 是用于参数替换的两种不同的占位符。

#占位符：它会将参数值以安全的方式传递给数据库，可以防止SQL注入攻击。MyBatis会将占位符替换为预编译的参数，然后将其传递给数据库执行。
$ 占位符：它会将参数值直接拼接到SQL语句中。MyBatis不会对参数进行预编译处理，而是将参数值直接替换到SQL语句中。

使用 # 占位符可以提供更好的安全性，因为它会对参数进行预编译处理，防止SQL注入攻击。而使用 $ 占位符可以提供更大的灵活性，可以在SQL语句中直接拼接参数值，但也增加了潜在的安全风险。

动态sql

if

格式

<if test="条件">
    sql 语句
</if>
当条件成立的时候，会执行sql语句
if (条件){
	sql 语句
}
<if test="age!=null and age!=''">
     and age=#{age}
</if>
<if test="phone!=null and phone!=''">
     and phone=#{phone}
</if>

注意: 在where 后面加 “1=1” 才能执行，否则会报sql语法不正确

choose…when…otherwise…

格式

<choose>
    <when test="条件1"> 
    	sql语句1
    </when>
    
    <when test="条件2"> 
    	sql语句2
    </when>
    
    <otherwise>
        sql语句3
    </otherwise>
</choose>
和我们java的if...else if ...else格式一样
当条件1成立，那么就不会执行后面的代码

<choose>
  <when test="age!=null and age!=''">
     and age=#{age}
  </when>
  <when test="phone!=null and phone!=''">
     and phone=#{phone}
  </when>
  <otherwise>
     and password='666666'
  </otherwise>
</choose>

where

说明

- 标签里边的if 至少有一个成立，就会动态添加一个where，如果都不成立，不添加where 
- 第一个if条件成立的，会自动去除连接符and 或者 or

<where>
  <if test="age!=null and age!=''">
      and age=#{age}
  </if>
  <if test="phone!=null and phone!=''">
      and phone=#{phone}
  </if>
</where>

set

动态添加了set字段，也会动态的去掉最后一个逗号

<set>
 <if test="username!=null and username!=''">username=#{username},</if>
 <if test="password!=null and password!=''">password=#{password},</if>
</set>

foreach

格式

循环遍历标签。适用于多个参数或者的关系。
<foreach collection=“”open=“”close=“”item=“”separator=“”>
    获取参数
</foreach>
<foreach collection="list" item="id" open="id in (" close=")" separator=",">
   #{id}
</foreach>

trim

格式

格式 <trim prefix=前缀''   prefixoverrides=''
	      suffix=后缀''   suffixoverrides=''>

替换where

<trim prefix="where" prefixOverrides="and">
   <if test="age!=null and age!=''">
       and age=#{age}
   </if>
   <if test="phone!=null and phone!=''">
       and phone=#{phone}
   </if>
</trim>

替换set

<trim prefix="set" suffixOverrides=",">
   <if test="password!=null and password!=''">
       password=#{password},
   </if>
   <if test="age!=null and age!=''">
       age=#{age},
   </if>
</trim>

sql片段

格式

<sql id="别名">
    查询的所有字段
</sql>

使用的时候 <include refid="别名"/>

分页

导入maven依赖

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>4.1.6</version>
        </dependency>
        <dependency>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
            <version>0.9.6</version>
        </dependency>

mybatis配置文件中指定方言

    <!--配置LOG4J-->
<settings>
   <setting name="logImpl" value="log4j"/>
</settings>
<plugins>
    <!-- 注意：分页助手的插件  配置在通用mapper之前 -->
    <plugin interceptor="com.github.pagehelper.PageHelper">
        <!-- 指定方言 -->
        <property name="dialect" value="mysql"/>
    </plugin>
</plugins>

mybatis多表查询

创建实体类
创建数据库表
在dao层创建实体类的mapper接口，并编写方法
在resources/mapper文件夹下创建对应接口的配置文件
编写测试类
配置文件格式

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="实体类对应接口的配置文件的全限定名">
	<resultMap id="" type="实体类的全限定名称">
		<id property="" column=""/>
		<result property="" column=""/>
		<collection property="" ofType="实体类的全限定名称">
			<id property="" column=""/>
			<result property="" column=""/>
		</collection>
	</resultMap>
	<select id="接口中的方法名" resultMap="映射关系标签">
		sql查询语句
	</select>
</mapper>

标签说明

<resultMap>：配置字段和对象属性的映射关系标签。
    id 属性：唯一标识
    type 属性：实体对象类型
<id>：配置主键映射关系标签。
<result>：配置非主键映射关系标签。
    column 属性：表中字段名称
    property 属性： 实体对象变量名称
<collection>：配置被包含集合对象的映射关系标签。
    property 属性：被包含集合对象的变量名
    ofType 属性：集合中保存的对象数据类型