笔触狂放9

这个屌丝很懒，什么也没留下！

热门标签

Mybatis总结_mybatis注解的学生管理系统实验心得

作者：笔触狂放9 | 2024-08-03 07:18:25

踩

mybatis注解的学生管理系统实验心得

Mybatis使用总结

1.快速使用

1.创建数据库

2.创建Maven项目

3.创建实体类

4.创建核心配置文件 Mybatis-config.xml

5.创建接口

6.创建接口映射文件

1.创建数据库

CREATE DATABASE mybatis_day01;
USE mybatis_day01;
CREATE TABLE t_user(
		uid int PRIMARY KEY auto_increment,
		username varchar(40),
	 	sex varchar(10),
		birthday date,
		address varchar(40)
);

INSERT INTO `t_user` VALUES (null, 'zs', '男', '2018-08-08', '北京');
INSERT INTO `t_user` VALUES (null, 'ls', '女', '2018-08-30', '武汉');
INSERT INTO `t_user` VALUES (null, 'ww', '男', '2018-08-08', '北京');
1
2
3
4
5
6
7
8
9
10
11
12
13

2.创建Maven 项目引入Maven 坐标

 <dependencies>
    <dependency>
      <!--myaql驱动-->
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.23</version>
    </dependency>
    <dependency>
      <!--mybatis驱动-->
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.4</version>
    </dependency>
    <dependency>
      <!--junit驱动-->
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
  </dependencies>

//要注意的地方：数据库驱动要根据版本号进行选择
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3.创建实体类

public class User implements Serializable{
    private int uid; //用户id
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
	
    public User() {
    }
    
    public User(String username, String sex, Date birthday, String address) {
        this.username = username;
        this.sex = sex;
        this.birthday = birthday;
        this.address = address;
    }
    //get..set..toString
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.创建查询接口

public interface UserMapper {
    List<User> getUserList();
}
1
2
3

5.创建接口的映射文件

<?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=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.ac.Mapper.UserMapper">
    <!--select查询语句，id对应的是接口中的方法！-->
    <select id="getUserList"  resultType="com.ac.pojo.User">
         select * from user;
  </select>
</mapper>
1
2
3
4
5
6
7
8
9
10

6.创建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 default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
        <mapper resource="com/ac/Mapper/UserMapper.xml"/>
    </mappers>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

7.编辑测试类

  @Test
    public void test01() throws  Exception{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //方式二：getMapper，流行使用！
        UserMapper Um = sqlSession.getMapper( UserMapper.class);
        List<User> userList = Um.getUserList();
        //打印结果
        System.out.println(userList);
        //释放资源
        sqlSession.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

8.Log4j配置文件 log4j.properties

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.Mybatis核心配置文件

2.1. properties

作用（引入外部properties文件）可以引入外部配置文件还可以配置常量

1、mybatis可以使用properties来引入外部properties配置文件的内容；
resource：引入类路径下的资源
url：引入网络路径或者磁盘路径下的资源

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/eesy_mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=1234
1
2
3
4

SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
    <properties resource="jdbc.properties">
    </properties>
    <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>
        <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
        <mapper resource="com/ac/Mapper/UserMapper.xml"/>
    </mappers>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.2settings

包含很多重要的设置项

setting:用来设置每一个设置项
name：设置项名
value：设置项取值

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。下表描述了设置中各项设置的含义、默认值等。

<settings>
    <!--启用了驼峰命名发-->
		<setting name="mapUnderscoreToCamelCase" value="true"/>
	</settings>
1
2
3
4

2.3.typeAliases

作用：修改类的别名，按照别名的方式进行注入

//为实体类创建对应的别名
例如：
<!--
 	1、typeAlias:为某个java类型起别名
				type:指定要起别名的类型全类名;默认别名就是类名小写；employee 
				alias:指定新的别名
		 -->
<typeAliases>
	<typeAlias type="com.ac.bean.User" alias="user"></typeAlias>
</typeAliases>
则
<select id="findaALL" resultType="user">
    select * from t_user
</select>

<!--
 2、package:为某个包下的所有类批量起别名 
	name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写），）
		-->
<typeAliases>
	<package name="com.ac.bean.User" />
</typeAliases>

<!--3. 在需要注入的类上加注解@Alias注解为某个类型指定新的别名-->
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.4 environments

作用：配置环境变量，Mybatis支持多种的环境变量，default属性指定默认的环境变量

environment：配置一个具体的环境信息；必须有两个标签；id代表当前环境的唯一标识
transactionManager：事务管理器；
type：事务管理器的类型;JDBC(JdbcTransactionFactory)|MANAGED(ManagedTransactionFactory)
自定义事务管理器：实现TransactionFactory接口.type指定为全类名
dataSource：数据源;
type:数据源类型;UNPOOLED(UnpooledDataSourceFactory)
|POOLED(PooledDataSourceFactory)
|JNDI(JndiDataSourceFactory)
自定义数据源：实现DataSourceFactory接口，type是全类名

<environments default="dev_mysql">
		<environment id="dev_mysql">
			<transactionManager type="JDBC"></transactionManager>
			<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>
	
		<environment id="dev_oracle">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${orcl.driver}" />
				<property name="url" value="${orcl.url}" />
				<property name="username" value="${orcl.username}" />
				<property name="password" value="${orcl.password}" />
			</dataSource>
		</environment>
	</environments>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.5.mapper

作用：将sql映射注册到全局配置文件中,写的sql 的xml文件映射到全局配置文件中

	<!-- 
			mapper:注册一个sql映射 
				注册配置文件
				resource：引用类路径下的sql映射文件
					com/ac/Mapper/UserMapper.xml
				url：引用网路路径或者磁盘路径下的sql映射文件
					file:///var/com/ac/Mapper/UserMapper.xml
					
				注册接口
				class：引用（注册）接口，
					1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；
					2、没有sql映射文件，所有的sql都是利用注解写在接口上;
					推荐：
						比较重要的，复杂的Dao接口我们来写sql映射文件
						不重要，简单的Dao接口为了开发快速可以使用注解；
		-->

//1.单个接口文件的扫描
<mappers>
    <mappler resources="com/ac/Mapper/UserMapper.xml"></mappler>
</mappers>

//2.批量扫描：1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；必须放在类的根目录下和接口同级，编译后的效果必须在同一级目录下
<mappers>
    <package name="com.ac.Mapper"></package>
</mappers>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.6databaseIdProvider

作用：databaseIdProvider：支持多数据库厂商的；
type=“DB_VENDOR”：VendorDatabaseIdProvider
作用就是得到数据库厂商的标识(驱动getDatabaseProductName())，mybatis就能根据数据库厂商标识来执行不同的sql;
MySQL，Oracle，SQL Server,xxxx

<databaseIdProvider type="DB_VENDOR">
		<!-- 为不同的数据库厂商起别名 -->
		<property name="MySQL" value="mysql"/>
		<property name="Oracle" value="oracle"/>
		<property name="SQL Server" value="sqlserver"/>
	</databaseIdProvider>


在sql的映射文件中使用 databaseId=”Mysql“

例如：
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
		databaseId="mysql">
		select * from tbl_employee where id = #{id}
	</select>
	<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
		databaseId="oracle">
		select EMPLOYEE_ID id,LAST_NAME	lastName,EMAIL email 
		from employees where EMPLOYEE_ID=#{id}
	</select>


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.获取自增id 的方式

1.通过语句查询

<!--添加测试parameterType属性:参数的类型;赋值的时候直接写对象里面的属性名-->
<insertid="save" parameterType="com.ac.bean.User">
    <!--查询主键自增值
	presultType:主键类型;
	keyProperty:pojo里面对应的id的属性名;
	order属性:指定是在目标的sql语句之前还是之后执行-->
    <selectKey resultType="int" keyProperty="uid" order="AFTER">
        SELECT LAST_INSERT_ID()
    </selectKey>
    INSERT INTO 
    t_user(username,sex,birthday,address)VALUES(#{username},#{sex},#{birthday},#{address})
    </insert>
1
2
3
4
5
6
7
8
9
10
11
12

2通过语句中的配置向进行查询

<!--
keyProperty:pojo里面对应的id的属性名;
useGeneratedKeys="true"使用主键自增值-->

  <insert id="save" parameterType="com.ac.bean.User" keyProperty="uid"                    useGeneratedKeys="true"> 
      INSERT INTO t_user(username,sex,birthday,address)VALUES(#{username},#{sex},#{birthday},#{address})
</insert>
1
2
3
4
5
6
7

4.#{} 和 ${} 的区别

1. #{}表示一个占位符号
	通过#{}可以实现 preparedStatement 向占位符中设置值,自动进行 java 类型和数据库类型转换
	#{}可以有效防止 sql 注入
	#{}可以接收简单类型值或 pojo 属性值
	如果 parameterType 传输单个简单类型值，#{}括号中可以是 value 或其它名称
2.${}表示拼接 sql 串
	通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换.
	${}不能防止 sql 注入
	${}可以接收简单类型值或 pojo 属性值
	如果 parameterType 传输单个简单类型值.${}括号中只能是 value
	
	
	原生jdbc不支持占位符的地方我们就可以使用${}进行取值
		比如分表、排序。。。；按照年份分表拆分
			select * from ${year}_salary where xxx;
			select * from tbl_employee order by ${f_name} ${order}

#{}:更丰富的用法：
	规定参数的一些规则：
	javaType、 jdbcType、 mode（存储过程）、 numericScale、
	resultMap、 typeHandler、 jdbcTypeName、 expression（未来准备支持的功能）；

	jdbcType通常需要在某种特定的条件下被设置：
		在我们数据为null的时候，有些数据库可能不能识别mybatis对null的默认处理。比如Oracle（报错）；
		
		JdbcType OTHER：无效的类型；因为mybatis对所有的null都映射的是原生Jdbc的OTHER类型，oracle不能正确处理;
		
		由于全局配置中：jdbcTypeForNull=OTHER；oracle不支持；两种办法
		1、#{email,jdbcType=OTHER};
		2、jdbcTypeForNull=NULL
			<setting name="jdbcTypeForNull" value="NULL"/>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

5.动态sql

1.if 标签：用来判断条件

<select id="findByQueryVo" resultType="com.ac.bean.User" parameterType="com.ac.bean.QueryVo"> 
    SELECT*FROM t_user WHERE 1=1
    <if test="user!=null and user.uid!=0">
        AND uid>#{user.uid}
    </if>
    <if test="user!=null and user.username!=null and user.username!=''">
        AND user name like#{user.username}
    </if>
 </select>
1
2
3
4
5
6
7
8
9

2.where 标签：消除where 1=1

<select id="findByQueryVo" resultType="com.ac.bean.User" parameterType="com.ac.bean.QueryVo"> 
    SELECT*FROM t_user 
    <where>
         <if test="user!=null and user.uid!=0">
        AND uid>#{user.uid}
    	</if>
        <if test="user!=null and user.username!=null and user.username!=''">
            AND user name like#{user.username}
        </if>
    </where>
 </select>
1
2
3
4
5
6
7
8
9
10
11

3.foreach标签：循环读取条件

例如sql:
select uid,username,birthday,sex,address from t_user WHERE username LIKE'张%' AND uid IN(1,7,10,18)
1
2

则标签处理的时候

<select id="findByQueryVo" resultType="com.ac.bean.User" parameterType="com.ac.bean.QueryVo"> 
    SELECT uid,username,birthday,sex,address FROM t_user 
    <where>
         <if test="user!=null and user.username!=null and user.username!=''">
        AND username like #{user.username}
    	</if>
        <--! ids 传入的数据
             collection:代表要遍历的集合元素，注意编写时不要写#{}
             open:代表语句的开始部分(一直到动态的值之前)
             close:代表语句结束部分
             item:代表遍历集合的每个元素，生成的变量名(随便取)
             sperator:代表分隔符 (动态值之间的分割)
             -->
        <if test="ids!=null">
            <foreach collection="ids" item="id" open="AND uid in(" close=")" separator=",">
        		#{id}    
            </foreach>
        </if>
    </where>
 </select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.SQL标签

//一般公共的标签都用sql标签
--定义sql片段
<sql id="sqlpd">
select * from 
</sql>

--引用sql片段
<include refid="sqlpd"></include>
1
2
3
4
5
6
7
8

6.Mybatis 的日志使用

1.导入Maven 坐标

<dependencies>
    <!--MyBatis坐标-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>

    <!-- log start -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.6.6</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.6.6</version>
    </dependency>
    <!--单元测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.10</version>
        <scope>test</scope>
    </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

2.添加配置文件----log4j.properties

##日志输出的级别，以及配置记录方案
log4j.rootLogger= DEBUG,Console,info,std,file
#日志输出配置
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
log4j.logger.org.apache=DEBUG##设置日志记录到控制台的方式
log4j.appender.std=org.apache.log4j.ConsoleAppender
log4j.appender.std.Target=System.err
log4j.appender.std.layout=org.apache.log4j.PatternLayout
log4j.appender.std.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n

##设置日志记录到文件的方式
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=mylog.txt
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

PatternLayout:日志布局类型

ConversionPattern：日志输出格式

    %m 输出代码中指定的消息 
    %p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL 
    %r 输出自应用启动到输出该log信息耗费的毫秒数 
    %c 输出所属的类目，通常就是所在类的全名 
    %t 输出产生该日志事件的线程名 
    %n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n” 
    %d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 ：10：28，921
    %l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。
1
2
3
4
5
6
7
8

级别:error > warn > info>debug>trace

trace:追踪,是最低的日志级别,相当于追踪程序的执行,一般不怎么使用。

debug:一般在开发中,都将其设置为最低的日志级别。

info:输出感兴趣的信息,我在开发中一般都会用info去输出。

warn:警告.有些时候,虽然程序不会报错,但是还是需要告诉程序员的。

error:错误,这个在开发中也挺常用的。

fatal:极其重大的错误,这个一旦发生,程序基本上也要停止了,目前限于开发经验,生产环境一般不用。

7.表和表之间的关系

1.一对一查询

例如账户和用户关系：一个账户对应一个用户(用户表的uid 是账户表Uid的外键)

SELECT a.*,u.username,u.address FROM t_account a,t_user u WHERE a.uid=u.uid
1

Account.java

在 Account 类中加入 User类的对象作为 Account 类的一个属性。

public class Account implements Serializable {
    private Integer aid;
    private Integer uid;
    private Double money;

    //表示一个账号属于一个用户的，是一种一对一的关系
    private User user;
    
    //get..set..toString
}
1
2
3
4
5
6
7
8
9
10

AccountDao.java

public interface AccountDao {
    /***
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
}
1
2
3
4
5
6
7

AccountDao.xml

<?xml version="1.0" encoding="UTF-8"?>

<!--
    定义结果集映射转换器
    唯一标识符：accountListMap
    type:结果集需要转换的Pojo
-->
<resultMap id="accountListMap" type="Account">
    <!--
        SQL语句中的aid列的值赋值给需要转换的对象的aid属性
        id：表示该映射关系是主键对象
        column="aid"：指定SQL语句中的列名字
        property="aid"：需要赋值给转换对象的指定属性
    -->
    <id column="aid" property="aid"></id>
    <result column="money" property="money"></result>
    <result column="uid" property="uid"></result>
    <!--
        association:用于关联加载的对象，用于一对一关系,
        property:Account中的属性名字
        javaType:为需要加载对应的类型
    -->
    <association property="user" javaType="User">
        <result column="username" property="username"></result>
        <result column="address" property="address"></result>
    </association>
</resultMap>

<!--
    查询所有账号
    resultMap:使用accountListMap映射转换器进行转换
-->
<select id="findAllAccount" resultMap="accountListMap">
    SELECT a.*,u.username,u.address FROM t_account a, t_user u WHERE a.uid = u.uid
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

```

2.一对多查询

例如：用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息查询出来，我们想到了左外连接查询比较合适。

SELECT u.*, a.aid, a.money  FROM t_user u LEFT OUTER JOIN t_account a ON u.uid = a.uid
1

Account.java

public class Account {
    private Integer aid;
    private Integer uid;
    private Double money;
}
1
2
3
4
5

User.java

为了能够让查询的 User 信息中，带有他的个人多个账户信息，我们就需要在 User 类中添加一个集合，
用于存放他的多个账户信息，这样他们之间的关联关系就保存了。

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

    //表达关系:1个用户对应多个账户
    private List<Account> accounts;
}
1
2
3
4
5
6
7
8
9
10

UserDao.java

public interface UserDao {
    /**
     * 查询所有的用户对应的账户信息
     * @return
     */
    List<User> findUserAccountList();
}
1
2
3
4
5
6
7

UserDao.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="com.ac.dao.UserDao">
<!--
    定义一个映射转换器，唯一标识：userAccountListMap
    需要转换的类型为User
-->
<resultMap id="userAccountListMap" type="User">
    <id property="uid" column="uid"></id>
    <result property="username" column="username"></result>
    <result property="sex" column="sex"></result>
    <result property="birthday" column="birthday"></result>
    <result property="address" column="address"></result>
    <!--
        加载多方数据,
        property属性:一方类里面List集合的属性名;
        ofType:List中的对象类型
    -->
    <collection property="accounts" ofType="Account">
        <result property="aid" column="aid"></result>
        <result property="money" column="money"></result>
    </collection>
</resultMap>

<!--一对多查询-->
<select id="findUserAccountList" resultMap="userAccountListMap">
    SELECT u.*, a.aid, a.money  FROM t_user u LEFT OUTER JOIN t_account a ON u.uid = a.uid
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3.多对多查询

多对多关系其实我们看成是双向的一对多关系。用户与角色的关系模型就是典型的多对多关系.

需求：实现查询所有角色对象并且加载它所分配的用户信息。

1.创建表

CREATE TABLE t_role(
	rid INT PRIMARY KEY AUTO_INCREMENT,
	rName varchar(40),
	rDesc varchar(40)
);
INSERT INTO `t_role` VALUES (null, '校长', '负责学校管理工作');
INSERT INTO `t_role` VALUES (null, '副校长', '协助校长负责学校管理');
INSERT INTO `t_role` VALUES (null, '班主任', '负责班级管理工作');
INSERT INTO `t_role` VALUES (null, '教务处主任', '负责教学管理');
INSERT INTO `t_role` VALUES (null, '班主任组长', '负责班主任小组管理');


-- 中间表(关联表)
CREATE TABLE user_role(
	uid INT,
	rid INT
);

ALTER TABLE  user_role ADD FOREIGN KEY(uid) REFERENCES t_user(uid);
ALTER TABLE  user_role ADD FOREIGN KEY(rid) REFERENCES t_role(rid);

INSERT INTO `user_role` VALUES ('1', '1');
INSERT INTO `user_role` VALUES ('3', '3');
INSERT INTO `user_role` VALUES ('2', '3');
INSERT INTO `user_role` VALUES ('2', '5');
INSERT INTO `user_role` VALUES ('3', '4');
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.分析

案例场景：查询所有角色，并且查询出每个角色授予的用户集合。

查询角色我们需要用到 Role 表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中间表(USER_ROLE 表)才能关联到用户信息。
下面是实现的 SQL 语句：

SELECT r.*, u.uid, u.username,u.sex,u.birthday,u.address FROM t_role r INNER JOIN user_role ur
ON r.rid = ur.rid INNER JOIN t_user u ON ur.uid = u.uid
或者
SELECT r.*, u.uid, u.username,u.sex,u.birthday,u.address FROM  t_role r, user_role ur, t_user u
WHERE r.rid = ur.rid AND ur.uid = u.uid
1
2
3
4
5

3.实现

User.java

public class User implements Serializable{
    private int uid;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
}
1
2
3
4
5
6
7

Role.java

public class Role {
    private Integer rid;
    private String rName;
    private String rDesc;

    //1个角色对应多个用户
    private List<User> users;
	
}
1
2
3
4
5
6
7
8
9

RoleDao.java

public interface RoleDao {
    /**
     * 查询角色信息
     * @return
     */
    List<Role> findRoleList();
}
1
2
3
4
5
6
7

RoleDao.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="com.ac.dao.RoleDao">

    <!--和一对多实现一致-->
    <resultMap id="roleListMap" type="role">
        <id column="rid" property="rid"></id>
        <result column="rName" property="rName"></result>
        <result column="rDesc" property="rDesc"></result>
        <collection property="users" ofType="user">
            <result property="username" column="username"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
            <result property="address" column="address"></result>
        </collection>
    </resultMap>

    <select id="findRoleList" resultMap="roleListMap">
        SELECT r.*,u.username,u.sex,u.birthday, u.address FROM t_role r,user_role ur,t_user u WHERE r.rid = ur.rid AND ur.uid = u.uid
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

8.延迟加载

1.多对一,一对一延迟加载

1.1需求

查询账户(Account)信息并且关联查询用户(User)信息。

先查询账户(Account)信息，当我们需要用到用户(User)信息时再查询用户(User)信息。

-- 1. 查询账户
SELECT * FROM t_account
-- 2, 再查询用户(等使用到用户再查询 account.getUser().getName())
--    再根据查询结果里面的uid查询当前账户所属的用户
SELECT * FROM t_user WHERE uid = 1
1
2
3
4
5

sql:select * from account

1.2实现

User.java

public class User{
    private int uid;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
  
}
1
2
3
4
5
6
7
8

Account.java

public class Account {
    private Integer aid;
    private Integer uid;
    private Double money;

    //表达关系:1个用户对应1个账户
    private User user;

}
1
2
3
4
5
6
7
8
9

AccountDao.java

public interface AccountDao {
    /**
     * 查询账户信息(包含用户信息)
     *
     * @return
     */
    List<Account> findAccountList();

}
1
2
3
4
5
6
7
8
9

AccountDao.xml

<mapper namespace="com.ac.dao.AccountDao">
    <select id="findAccountList"  resultMap="accountListId">
        SELECT * FROM t_account
    </select>
    <resultMap id="accountListId" type="Account">
        <id property="aid" column="aid"/>
        <result property="money" column="money"/>
        <result property="uid" column="uid"/>
        <!--association用于关联加载的对象,
                property属性:多方类里面一方对象的属性名
               javaType属性:一方对象的类型
               select属性: 用于关联查询另外的一方(User)对应的id
               column属性: 填写我们要传递给 select 映射的参数
               fetchType属性：lazy延迟
         -->
        <association property="user" javaType="User" select="com.ac.dao.UserDao.findByUid" column="uid" fetchType="lazy" >
        </association>
    </resultMap>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

UserDao.java

public interface UserDao {
    /**
     * 根据id查询user
     * @param uid
     * @return
     */
    User findByUid(Integer uid);

}
1
2
3
4
5
6
7
8
9

UserDao.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="com.ac.dao.UserDao">
    <select id="findByUid"  resultType="User" parameterType="Integer">
        SELECT * FROM t_user WHERE  uid = #{uid}
    </select>
</mapper>
1
2
3
4
5
6
7
8
9

2.一对多，多对对的延迟加载

2.1需求

完成加载用户对象时，查询该用户所拥有的账户信息。

等账户信息使用的时候再查询.

-- 1.先把用户查询出来
SELECT * FROM t_user
-- 2. 等使用了该用户的账户的时候再把账户查询出来(user.getAccounts()...)
--    把查询出来的uid去查询当前用户的账户信息
SELECT * FROM t_account WHERE uid = 1
1
2
3
4
5

2.2实现

Account.java

public class Account {
    private Integer aid;
    private Integer uid;
    private Double money;
}
1
2
3
4
5

User.java

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

    //表达关系:1个用户对应多个账户
    private List<Account> accounts;
}
1
2
3
4
5
6
7
8
9
10

UserDao.java

public interface UserDao {
    /**
     * 查询所有的用户对应的账户信息
     * @return
     */
    List<User> findUserAccountList();

}
1
2
3
4
5
6
7
8

UserDao.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="com.ac.dao.UserDao">
    <select id="findUserAccountList" resultMap="userListId">
        SELECT * FROM t_user
    </select>
    <resultMap id="userListId" type="user">
        <result property="uid" column="uid"/>
        <result property="username" column="username"/>
        <result property="sex" column="sex"/>
        <result property="birthday" column="birthday"/>
        <result property="address" column="address"/>
        <!--加载多方数据,property属性:一方类里面List集合的属性名; ofType:List中的对象类型-->
        <collection property="accounts" ofType="account" select="com.ac.dao.AccountDao.findByUid" column="uid" fetchType="lazy"/>
    </resultMap>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

AccountDao.java

public interface AccountDao {
    /**
     * 根据uid查询当前用户的账户
     * @return
     */
    List<Account> findByUid(Integer uid);

}
1
2
3
4
5
6
7
8

AccountDao.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="com.ac.dao.AccountDao">
    <select id="findByUid" resultType="Account" parameterType="Integer" >
        SELECT * FROM t_account WHERE  uid = #{uid}
    </select>
</mapper>
1
2
3
4
5
6
7
8
9

延迟加载需要在配置文件中开启延迟加载设置

<settings>
		<!--开启Mybatis的日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"></setting>
        <!--开启全局延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--
        启用按需加载：false，则按需加载，延迟加载
        true,每次查询，用不用都全部查询
        -->
        <setting name="aggressiveLazyLoading" value="false" />

        <!--开启缓存-->
        <setting name="cacheEnabled" value="true" />
    </settings>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

9.Mybatis缓存

一级缓存：它是sqlSession对象的缓存，自带的(不需要配置)不可卸载的(不想使用还不行). 一级缓存的生命周期与sqlSession一致。

二级缓存：它是SqlSessionFactory的缓存。只要是同一个SqlSessionFactory创建的SqlSession就解压共享二级缓存的内容，并且可以操作二级缓存。二级缓存如果要使用的话，需要我们自己手动开启(需要配置的)。

1.一级缓存

第一次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，如果没有，从数据库查询用户信息。得到用户信息，将用户信息存储到一级缓存中。第二次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，缓存中有，直接从缓存中获取用户信息。

如果 sqlSession 去执行 commit操作（执行插入、更新、删除），清空 SqlSession 中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。

 //证明一级缓存的存在
    public void fun01() throws Exception {
        SqlSession sqlSession = SqlSessionFactoryUtil.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        User user01 = userDao.findByUid(1);
        User user02 = userDao.findByUid(1);

        System.out.println(user01 == user02);

        sqlSession.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12

2.二级缓存

二级缓存是SqlSessionFactory的缓存。只要是同一个SqlSessionFactory创建的SqlSession就共享二级缓存的内容，并且可以操作二级缓存.

1.在 SqlMapConfig.xml 文件开启二级缓存

<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>
1
2
3

2.配置属性

将 .xml 映射文件中的 <select>标签中设置 useCache=”true”代表当前这个 statement 要使用二级缓存，如果不使用二级缓存可以设置为 false。
注意：针对每次查询都需要最新的数据 sql，要设置成 useCache=false，禁用二级缓存。

<?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.ac.dao.AccountDao">
    <select id="findByUid" resultType="Account" parameterType="Integer"  useCache="true">
        SELECT * FROM t_account WHERE  uid = #{uid}
    </select>
</mapper>
1
2
3
4
5
6
7
8
9

=====================================
以上是自己的一点小总结，有问题可以评论出来，有不足可以指正出来。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/922005

Mybatis总结_mybatis注解的学生管理系统实验心得

Mybatis使用总结

1.快速使用

1.创建数据库

2.创建Maven 项目引入Maven 坐标

3.创建实体类

4.创建查询接口

5.创建接口的映射文件

6.创建Mybatis的核心配文件

7.编辑测试类

8.Log4j配置文件 log4j.properties

2.Mybatis核心配置文件

2.1. properties

**2.2settings **

2.3.typeAliases

2.4 environments

2.5.mapper

2.6databaseIdProvider

3.获取自增id 的方式

4.#{} 和 ${} 的区别

5.动态sql

6.Mybatis 的日志使用

7.表和表之间的关系

1.一对一查询

2.一对多查询

3.多对多查询

8.延迟加载

9.Mybatis缓存

2.2settings