Mybatis总结

合集下载

MyBatis实现Mysql数据库分库分表操作和总结

MyBatis实现Mysql数据库分库分表操作和总结

MyBatis实现Mysql数据库分库分表操作和总结前⾔作为⼀个数据库,作为数据库中的⼀张表,随着⽤户的增多随着时间的推移,总有⼀天,数据量会⼤到⼀个难以处理的地步。

这时仅仅⼀张表的数据就已经超过了千万,⽆论是查询还是修改,对于它的操作都会很耗时,这时就需要进⾏数据库切分的操作了。

MyBatis实现分表最简单步骤既然⽂章的标题都这么写了,不如直接上⼲货来的⽐较实际,我们就先来看看如何实现最简单的分表。

1、我们模拟⽤户表数据量超过千万(虽然实际不太可能)2、⽤户表原来的名字叫做user_tab,我们切分为user_tab_0和user_tab_1(实际也可能不是这么随意的名字),这样就能把原来千万的数据分离成两个百万的数据量的两张表了。

3、如何操作这两张表呢?我们利⽤userId也就是⽤户的唯⼀标识进⾏区分。

4、userId%2 == 0的⽤户操作表user_tab_0,同理userId%2 == 1的⽤户操作表user_tab_15、那么在MyBatis中sql语句如何实现呢?下⾯是举例查询⼀个⽤户的sql语句<select id="getUser" parameterType="java.util.Map" resultType="UserDO">SELECT userId, nameFROM user_tab_#{tabIndex}WHERE userId = #{userId}</select>其中我们传⼊了两个参数tabIndex和userId,tabIndex就是需要操作表的标⽰值(0或1),这样如果需要查询userId为5的⽤户,那么最终出现的sql语句就会是:SELECT userId, nameFROM user_tab_1WHERE userId = 5其他多余的DAO服务和实现我这⾥就不多展⽰了,相信聪明的你肯定会的。

mybatis数据库开发实验总结

mybatis数据库开发实验总结

mybatis数据库开发实验总结MyBatis数据库开发实验总结一、引言MyBatis是一种Java持久化框架,它简化了数据库操作的开发过程。

在本次实验中,我们使用MyBatis进行了数据库开发,通过对实验过程的总结,可以对MyBatis的使用方法和注意事项有更深入的了解。

二、实验目的本次实验的目的是熟悉MyBatis的基本用法,掌握MyBatis的配置和使用方法。

具体来说,我们需要完成以下几个任务:1. 创建数据库表并插入数据;2. 编写实体类和映射文件;3. 配置MyBatis的数据库连接信息;4. 编写数据库操作接口和SQL语句;5. 测试数据库操作功能。

三、实验步骤1. 安装MyBatis并配置开发环境。

2. 创建数据库表,包括表结构和数据。

3. 编写实体类,对应数据库表的字段。

4. 创建映射文件,配置实体类和数据库表的映射关系。

5. 配置MyBatis的数据库连接信息,包括数据库驱动、连接URL、用户名和密码。

6. 编写数据库操作接口,定义数据库操作的方法。

7. 编写SQL语句,包括插入、更新、删除和查询等操作。

8. 测试数据库操作功能,验证数据库操作的正确性和可靠性。

四、实验结果与分析经过实验,我们成功完成了数据库的创建和数据的插入。

通过编写实体类和映射文件,我们实现了实体类和数据库表的映射关系。

在数据库操作接口中,我们定义了各种数据库操作的方法,并在SQL 语句中实现了这些操作。

最后,通过测试数据库操作功能,我们验证了数据库操作的正确性和可靠性。

五、实验总结通过本次实验,我对MyBatis的使用方法和注意事项有了更深入的了解。

首先,我们需要正确配置MyBatis的数据库连接信息,包括数据库驱动、连接URL、用户名和密码。

其次,我们需要编写实体类和映射文件,对应数据库表的字段和映射关系。

在数据库操作接口中,我们定义了各种数据库操作的方法,并在SQL语句中实现了这些操作。

最后,通过测试数据库操作功能,我们验证了数据库操作的正确性和可靠性。

MyBatis逆向工程生成的Example类的方法总结

MyBatis逆向工程生成的Example类的方法总结

MyBatis逆向⼯程⽣成的Example类的⽅法总结很早之前就在项⽬开发中多次使⽤MyBatis逆向⼯程⽣成的Example类,但⼀直没有对其下的⽅法做⼀个简单的总结,现总结如下:⼀、mapper接⼝中的⽅法解析mapper接⼝中的部分常⽤⽅法及功能如下:⽅法功能说明int countByExample(UserExample example) thorws SQLException按条件计数int deleteByPrimaryKey(Integer id) thorws SQLException按主键删除int deleteByExample(UserExample example) thorws SQLException按条件删除String/Integer insert(User record) thorws SQLException插⼊数据(返回值为ID)User selectByPrimaryKey(Integer id) thorws SQLException按主键查询ListselectByExample(UserExample example) thorws SQLException按条件查询ListselectByExampleWithBLOGs(UserExample example) thorws SQLException 按条件查询(包括BLOB字段)。

只有当数据表中的字段类型有为⼆进制的才会产⽣int updateByPrimaryKey(User record) thorws SQLException按主键更新int updateByPrimaryKeySelective(User record) thorws SQLException按主键更新值不为null的字段int updateByExample(User record, UserExample example) thorwsSQLException按条件更新int updateByExampleSelective(User record, UserExample example)thorws SQLException按条件更新值不为null的字段⼆、Example类解析mybatis的逆向⼯程中会⽣成实体类及实体类对应的example类,example类⽤于添加条件,相当where后⾯的部分。

【Java】关于MyBatis框架的总结

【Java】关于MyBatis框架的总结

【Java】关于MyBatis框架的总结最近在学习MyBatis框架,我在这⾥记录⼀下学习MyBatis过程中的⼼得体会。

Mybatis是什么?使⽤它我们可以做什么?MyBatis是⼀个开源的数据持久层框架,它内部封装了通过JDBC访问数据库的操作,⽀持普通的SQL查询、存储过程和⾼级映射,⼏乎消除了所有的JDBC代码和参数的⼿⼯设置以及结果集的检索。

MyBatis作为持久层框架,其主要思想是将程序中⼤量SQL语句剥离出来,配置在配置⽂件中,实现SQL的灵活配置。

这样做的好处是将SQL与程序代码分离,可以在不修改程序代码的情况下,直接在配置⽂件中修改SQL。

Mybatis通过简单的XML或者注解进⾏配置和原始映射,将实体类和SQL语句之间建⽴映射关系,是⼀种半⾃动化的ORM实现。

MyBatis环境搭建这⾥我们使⽤的编译程序以Eclipse为例。

下载jar包==>部署jar包==>编写configuration核⼼配置⽂件==>创建pojo实体类==>创建DAO接⼝==>创建SQL映射⽂件==>编写测试类需要的jar包:创建MyBatis核⼼配置⽂件configuration.xmlMyBatis核⼼配置⽂件主要⽤于配置数据库连接和MyBatis运⾏时所需的各种特性,包含了设置和影响MyBatis⾏为的属性MyBatis的核⼼接⼝和类1)每个MyBatis的应⽤程序都以⼀个SqlSessionFactory对象的实例为核⼼。

2)⾸先获取SqlSessionFactoryBuilder对象,可以根据XML配置⽂件或Configuration类的实例构建该对象。

3)然后获取SqlSessionFactory对象,该对象实例可以通过SqlSessionFactoryBuilder对象来获得。

4)使⽤SqlSessionFactory对象获取SqlSession实例。

SqlSessionFactoryBuilder负责构建SqlSessionFactory,提供多个build()⽅法的重载,主要分为三个:build(Reader reader,String environment,Properties properties)build(InputStream inputStream,String environment,Properties properties)build(Configuration config)最⼤的特点是⽤过即丢,⼀旦创建了SqlSessionFactory对象之后,这个类就不再需要存在了,因此SqlSessionFactoryBuilder的最佳作⽤范围就是存在于⽅法体内,也就是局部变量。

spring整合mybatis出现的异常总结

spring整合mybatis出现的异常总结

spring整合mybatis出现的异常总结1.数据库版本及url配置问题,如图-20所⽰:问题分析:在url中追加时区配置(serverTimezone=GMT%2B8)2.数据库服务连接不上,如图-21所⽰:问题分析:检查数据库服务是否启动,连接数据库的⽤户名,密码是否正确.3.数据库版本或url配置问题,如图-22所⽰:问题分析:检查数据的服务是否已启动,连接数据的url配置是否正确,数据库版本与驱动是否匹配.4.访问的数据库不存在,如图-23所⽰:问题分析:检查url配置的数据库是否存在(数据库是否没创建)5.指定命名空间下的元素ID已经存在。

问题分析:可能是GoodsDao接⼝或映射⽂件对应的映射元素有重复。

6.MyBatis 绑定异常,如图-24所⽰问题分析:1. 检查接⼝类全名与映射⽂件中的命名空间是否不⼀致。

2. 检查接⼝⽅法名与映射⽂件中的元素是否不⼀致。

3. 查接⼝⽅法参数与映射⽂件可接收的参数不匹配。

4. 检查接⼝对应的映射⽂件路径是否配置不正确(mapper-locations)。

7.MyBatis 参数绑定异常,如图-25所⽰:问题分析:检查调⽤的dao⽅法参数与对应的SQL参数是否有映射关系.(SQL中的使⽤的ids参数可能没有使⽤@Param注解进⾏描述)8.运⾏时的SQL语法问题,图-26所⽰问题分析:1. 认真分析操作中提⽰的SQL语法问题,以及出现的⼤概位置。

2. 检测业务执⾏时传⼊的参数数据是否正常。

9.⽆限递归调⽤导致的栈内存溢出,如图-27所⽰:问题分析:基于错误检查⾃⼰写的类,哪⾥出现了循环递归调⽤。

10.JVM端⼝号被占⽤,如图-28所⽰其解决⽅案为:1. 关闭已启动的tomcat,重新启动。

2. 杀进程(windows)1. 查找进程id:netstat -ano|findstr "8080"2. 基于进程id杀进程:taskkill /f /pid 进程id11.URL响应资源不存在,如图-29所⽰:问题分析:检查tomcat启动是否OK,检查url对应的服务端资源是否匹配(客户端url与controller定义url),检查controller的包结构(所在包应在主启动类所在包的同包或⼦包中)。

基于mybatis的学生信息管理系统实训总结

基于mybatis的学生信息管理系统实训总结

基于mybatis的学生信息管理系统实训总结学生信息管理系统是一个常见的基于数据库的管理系统,通过MyBatis等框架的实现,可以实现对学生的信息管理、查询、修改和删除等操作。

以下是学生信息管理系统的实训总结:1、数据库设计和建模:首先需要进行数据库设计和建模,确定学生信息的数据结构,包括学生的基本信息(姓名、学号、性别等)和选课信息(课程名称、成绩等)。

同时需要确定数据表之间的关系,如学生和课程之间的关系。

2、MyBatis框架的配置和基本使用:MyBatis是一款优秀的ORM 框架,可以实现数据库操作和对象之间的映射。

在实训中需要掌握MyBatis框架的配置和使用方法,包括定义Mapper接口和XML映射文件,以及使用MyBatis进行数据库的增删改查操作。

3、学生信息管理功能的实现:学生信息管理是系统的核心功能,包括学生的基本信息查询、修改和删除,以及学生选课信息的查询和修改。

在实训中需要掌握如何使用MyBatis进行数据的查询和更新操作,以及如何通过前端界面实现对学生信息的操作和管理。

4、用户权限管理:学生信息管理系统需要设置用户权限管理,以保证学生信息的安全性和保密性。

在实训中需要实现用户注册、登录、权限分配等功能,同时需要保证用户信息的安全性和验证机制。

5、系统测试和调试:最后需要对系统进行测试和调试,确保系统的稳定性和正确性。

在实训中需要对系统的各个功能模块进行测试,并记录测试结果,及时发现和解决问题,确保系统的质量。

在实现学生信息管理系统时,需要注意以下几点:1、数据库设计和建模是系统的基础,需要充分考虑数据结构和关系的设计。

2、MyBatis框架的配置和使用是系统的关键,需要熟练掌握ORM 框架的基本原理和使用方法。

3、功能模块的实现需要注重代码的可读性和可维护性,遵循面向对象编程的基本原则。

4、用户权限管理是系统的安全保障,需要充分考虑用户验证、授权和安全保护机制的实现。

5、系统测试和调试是保证系统质量的重要环节,需要充分测试各个功能模块的正确性和稳定性。

MyBatis框架常见问题解析

MyBatis框架常见问题解析

MyBatis框架常见问题解析MyBatis是一种持久化框架,它简化了Java与数据库之间的交互。

尽管MyBatis使用起来相对容易,但在实际应用中,仍然会遇到一些常见的问题。

本文将对MyBatis框架的常见问题进行解析,帮助读者更好地理解和使用该框架。

一、连接数据库问题连接数据库是使用MyBatis框架的第一步,但在实践中可能会遇到一些连接数据库的问题。

以下是一些常见问题及解决方案:1. 数据库连接失败:MyBatis框架不能直接连接数据库,而是通过数据源来管理数据库连接。

因此,当数据库连接失败时,首先需要检查数据源的配置是否正确、数据库是否正常运行以及网络连接等因素。

2. 连接池问题:连接池的配置对于数据库连接的性能和稳定性至关重要。

如果连接池的配置不合理,可能导致数据库连接过多或者连接不释放,进而影响系统的性能。

解决该问题的方法包括调整连接池的大小、配置连接的最大空闲时间等。

二、SQL语句编写问题在使用MyBatis框架时,编写SQL语句是最常见的操作之一。

下面是一些SQL语句编写常见问题及解决方案:1. SQL注入问题:为了避免SQL注入漏洞,应该使用预编译的语句,而不是直接拼接SQL字符串。

同时,还可以使用参数化查询等方式来提高SQL的安全性。

2. 动态SQL问题:MyBatis框架允许使用动态SQL语句,但在实践中可能出现逻辑错误。

解决该问题的方法包括熟悉动态SQL的语法、使用if、choose和foreach等标签来构建复杂的SQL查询。

三、异常处理问题在使用MyBatis框架时,可能会遇到一些异常情况。

以下是一些常见的异常问题及解决方案:1. 数据库事务问题:在处理数据库操作时,可能遇到事务异常的情况。

解决该问题的方法包括配置事务管理器、使用@Transactional注解等方式来确保事务的正确提交和回滚。

2. 数据库乐观锁问题:在并发环境下,可能会出现数据库的乐观锁问题,导致数据的不一致性。

mybatis传入集合参数遍历查询总结

mybatis传入集合参数遍历查询总结

mybatis传⼊集合参数遍历查询总结出⾃:/u013628152/article/details/511846411. findByIds(List ids)如果参数的类型是List, 则在使⽤时,collection属性要必须指定为 list<select id="findByIdsMap" resultMap="BaseResultMap">Select<include refid="Base_Column_List"/>from jria where ID in<foreach item="item" index="index" collection="list" open="(" separator="," close=")">#{item}</foreach></select>2:findByIds(Long[] ids)如果参数的类型是Array,则在使⽤时,collection属性要必须指定为 array<select id="findByIdsMap" resultMap="BaseResultMap">select<include refid="Base_Column_List"/>from tabs where ID in<foreach item="item" index="index" collection="array" open="(" separator="," close=")">#{item}</foreach></select>3. findByIds(String name, Long[] ids)当查询的参数有多个时:这种情况需要特别注意,在传参数时,⼀定要改⽤Map⽅式, 这样在collection属性可以指定名称Map<String, Object> params = new HashMap<String, Object>(2);params.put("name", name);params.put("ids", ids);mapper.findByIdsMap(params);<select id="findByIdsMap" resultMap="BaseResultMap">select<include refid="Base_Column_List"/>from tabs wherename = #{name}and ID in<foreach item="item" index="index" collection="ids" open="(" separator="," close=")">#{item}</foreach></select>。

总结一下mybatis对多对多查询与增删改查的心得

总结一下mybatis对多对多查询与增删改查的心得

总结一下mybatis对多对多查询与增删改查的心得引言在实际的开发中,多对多关联关系是经常遇到的问题,而m yba t is作为一款高效的持久层框架,为我们提供了便捷的解决方案。

本文将总结一下通过m yb at is对多对多关系进行查询和增删改查的心得。

查询多对多关系在m yb at is中,查询多对多关系可以通过嵌套查询和关联表查询来实现。

嵌套查询嵌套查询是通过在映射文件中定义多个查询语句,并通过r esu l tM ap来关联结果,从而实现多对多关系的查询。

具体步骤如下:1.在映射文件中定义多个s el ec t语句,分别查询两个关联表的数据。

2.使用\<re su lt Map>标签定义一个结果映射,包括两个关联表的字段。

3.在主查询语句中使用\<co ll ec ti on>标签来引用结果映射和关联查询语句。

4.使用联合结果映射来获取最终查询结果。

关联表查询关联表查询是通过多表联查来实现多对多关系的查询。

具体步骤如下:1.在映射文件中编写多表联查的SQ L语句,使用J OI N语句关联两个关联表。

2.在\<s el ec t>标签中使用\<re su lt Ma p>定义结果映射,包括两个关联表的字段。

3.在J av a代码中编写相应的Ma pp er接口和Ma pp er.x ml文件。

4.调用Ma pp er接口中的方法来执行查询操作。

增删改查多对多关系m y ba ti s对多对多关系的增删改查操作也是通过多表关联来实现的。

增加记录要增加多对多关系的记录,需要进行以下操作:1.在映射文件中定义插入操作的SQ L语句,插入关联表的数据。

2.在J av a代码中编写相应的Ma pp er接口和Ma pp er.x ml文件。

3.调用Ma pp er接口中的方法来执行插入操作。

删除记录要删除多对多关系的记录,需要进行以下操作:1.在映射文件中定义删除操作的SQ L语句,删除关联表的数据。

Mybatis与Hibernate区别与常见面试题总结

Mybatis与Hibernate区别与常见面试题总结

Mybatis与Hibernate区别与常见⾯试题总结1、什么是Mybatis?(1)Mybatis是⼀个半ORM(对象关系映射)框架,它内部封装了JDBC,开发时只需要关注SQL语句本⾝,不需要花费精⼒去处理加载驱动、创建连接、创建statement等繁杂的过程。

程序员直接编写原⽣态sql,可以严格控制sql执⾏性能,灵活度⾼。

(2)MyBatis 可以使⽤ XML 或注解来配置和映射原⽣信息,将 POJO映射成数据库中的记录,避免了⼏乎所有的 JDBC 代码和⼿动设置参数以及获取结果集。

(3)通过xml ⽂件或注解的⽅式将要执⾏的各种 statement 配置起来,并通过java对象和 statement中sql的动态参数进⾏映射⽣成最终执⾏的sql语句,最后由mybatis框架执⾏sql并将结果映射为java对象并返回。

(从执⾏sql到返回result的过程)。

2、Mybaits的优点:(1)基于SQL语句编程,相当灵活,不会对应⽤程序或者数据库的现有设计造成任何影响,SQL写在XML⾥,解除sql与程序代码的耦合,便于统⼀管理;提供XML标签,⽀持编写动态SQL语句,并可重⽤。

(2)与JDBC相⽐,减少了50%以上的代码量,消除了JDBC⼤量冗余的代码,不需要⼿动开关连接;(3)很好的与各种数据库兼容(因为MyBatis使⽤JDBC来连接数据库,所以只要JDBC⽀持的数据库MyBatis都⽀持)。

(4)能够与Spring很好的集成;(5)提供映射标签,⽀持对象与数据库的ORM字段关系映射;提供对象关系映射标签,⽀持对象关系组件维护。

3、MyBatis框架的缺点:(1)SQL语句的编写⼯作量较⼤,尤其当字段多、关联表多时,对开发⼈员编写SQL语句的功底有⼀定要求。

(2)SQL语句依赖于数据库,导致数据库移植性差,不能随意更换数据库。

4、MyBatis框架适⽤场合:(1)MyBatis专注于SQL本⾝,是⼀个⾜够灵活的DAO层解决⽅案。

MyBatis学习总结

MyBatis学习总结

MyBatis学习总结(一)——MyBatis快速入门一、Mybatis介绍MyBatis是一个支持普通SQL查询,存储过程和高级映射的优秀持久层框架。

MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。

MyBatis可以使用简单的XML或注解用于配置和原始映射,将接口和Java的POJO (Plain Old Java Objects,普通的Java对象)映射成数据库中的记录。

二、mybatis快速入门2.1、准备开发环境1、创建测试项目,普通java项目或者是JavaWeb项目均可,如下图所示:2、添加相应的jar包【mybatis】mybatis-3.1.1.jar【MYSQL驱动包】mysql-connector-java-5.1.7-bin.jar3、创建数据库和表,针对MySQL数据库SQL脚本如下:1createdatabase mybatis;2use mybatis;3CREATETABLE users(id INTPRIMARYKEY AUTO_INCREMENT, NAME VARCHAR(20), age INT);4INSERTINTO users(NAME, age) VALUES('孤傲苍狼', 27);5INSERTINTO users(NAME, age) VALUES('白虎神皇', 27);将SQL脚本在MySQL数据库中执行,完成创建数据库和表的操作,如下:到此,前期的开发环境准备工作全部完成。

2.2、使用MyBatis查询表中的数据1、添加Mybatis的配置文件conf.xml在src目录下创建一个conf.xml文件,如下图所示:conf.xml文件中的内容如下:1<?xml version="1.0" encoding="UTF-8"?>2<!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN" "/dtd/mybatis-3-config.dtd">3<configuration>4<environments default="development">5<environment id="development">6<transactionManager type="JDBC"/>7<!-- 配置数据库连接信息 -->8<dataSource type="POOLED">9<property name="driver" value="com.mysql.jdbc.Driver"/>10<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/> 11<property name="username" value="root"/>12<property name="password" value="XDP"/>13</dataSource>14</environment>15</environments>1617</configuration>2、定义表所对应的实体类,如下图所示:User类的代码如下:1package me.gacl.domain;23/**4 * @author gacl5 * users表所对应的实体类6*/7publicclass User {89//实体类的属性和表的字段名称一一对应10privateint id;11private String name;12privateint age;1314publicint getId() {15return id;16 }1718publicvoid setId(int id) {19this.id = id;20 }2122public String getName() {23return name;24 }2526publicvoid setName(String name) { = name;28 }2930publicint getAge() {31return age;32 }3334publicvoid setAge(int age) {35this.age = age;36 }3738 @Override39public String toString() {40return "User [id=" + id + ", name=" + name + ", age=" + age + "]";41 }42 }3、定义操作users表的sql映射文件userMapper.xml创建一个me.gacl.mapping包,专门用于存放sql映射文件,在包中创建一个userMapper.xml文件,如下图所示:userMapper.xml文件的内容如下:1<?xml version="1.0" encoding="UTF-8" ?>2<!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd">3<!-- 为这个mapper指定一个唯一的namespace,namespace的值习惯上设置成包名+sql映射文件名,这样就能够保证namespace的值是唯一的4例如namespace="erMapper"就是me.gacl.mapping(包名)+userMapper(userMapper.xml文件去除后缀)5-->6<mapper namespace="erMapper">7<!-- 在select标签中编写查询的SQL语句,设置select标签的id属性为getUser,id属性值必须是唯一的,不能够重复8使用parameterType属性指明查询时使用的参数类型,resultType属性指明查询返回的结果集类型9 resultType="er"就表示将查询结果封装成一个User类的对象返回10 User类就是users表所对应的实体类11-->12<!--13根据id查询得到一个user对象14-->15<select id="getUser" parameterType="int"16 resultType="er">17 select * from users where id=#{id}18</select>19</mapper>4、在conf.xml文件中注册userMapper.xml文件1<?xml version="1.0" encoding="UTF-8"?>2<!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd">3<configuration>4<environments default="development">5<environment id="development">6<transactionManager type="JDBC"/>7<!-- 配置数据库连接信息 -->8<dataSource type="POOLED">9<property name="driver" value="com.mysql.jdbc.Driver"/>10<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>11<property name="username" value="root"/>12<property name="password" value="XDP"/>13</dataSource>14</environment>15</environments>1617<mappers>18<!-- 注册userMapper.xml文件,19 userMapper.xml位于me.gacl.mapping这个包下,所以resource写成me/gacl/mapping/userMapper.xml-->20<mapper resource="me/gacl/mapping/userMapper.xml"/>21</mappers>2223</configuration>5、编写测试代码:执行定义的select语句创建一个Test1类,编写如下的测试代码:package me.gacl.test;import java.io.IOException;import java.io.InputStream;import java.io.Reader;import er;import org.apache.ibatis.io.Resources;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;publicclass Test1 {publicstaticvoid main(String[] args) throws IOException {//mybatis的配置文件String resource = "conf.xml";//使用类加载器加载mybatis的配置文件(它也加载关联的映射文件)InputStream is =Test1.class.getClassLoader().getResourceAsStream(resource);//构建sqlSession的工厂SqlSessionFactory sessionFactory = newSqlSessionFactoryBuilder().build(is);//使用MyBatis提供的Resources类加载mybatis的配置文件(它也加载关联的映射文件) //Reader reader = Resources.getResourceAsReader(resource);//构建sqlSession的工厂//SqlSessionFactory sessionFactory = newSqlSessionFactoryBuilder().build(reader);//创建能执行映射文件中sql的sqlSessionSqlSession session = sessionFactory.openSession();/*** 映射sql的标识字符串,* erMapper是userMapper.xml文件中mapper标签的namespace属性的值,* getUser是select标签的id属性值,通过select标签的id属性值就可以找到要执行的SQL*/String statement = "erMapper.getUser";//映射sql的标识字符串//执行查询返回一个唯一user对象的sqlUser user = session.selectOne(statement, 1);System.out.println(user);}}执行结果如下:可以看到,数据库中的记录已经成功查询出来了。

基于mybatis的学生信息管理系统实训总结

基于mybatis的学生信息管理系统实训总结

基于mybatis的学生信息管理系统实训总结学生信息管理系统是一种用于管理学生信息的软件系统。

近年来,随着互联网技术的发展,学生信息管理系统在高校和教育机构中得到了广泛应用。

本次实训中,我们使用mybatis作为ORM(Object-Relational Mapping)框架开发了一个基于Web的学生信息管理系统。

在这个实训总结中,我将对实训过程进行总结和反思,并对系统的功能和性能进行评估。

在实训开始之前,我们首先进行了对mybatis框架的学习和了解。

Mybatis是一个开源的Java持久层框架,它简化了传统的JDBC编程模型。

通过配置文件和Java注解的方式,我们可以实现数据库表和Java 对象的映射,从而达到方便操作数据库的目的。

在实际开发过程中,我们首先进行了需求分析和数据库设计。

我们通过与教务部门进行沟通,了解了他们对学生信息管理系统的实际需求。

根据需求,我们设计了数据库表结构,并使用mysql数据库进行建表。

然后,我们开始进行编码工作。

在编码过程中,我们首先配置了mybatis的相关文件,包括mybatis-config.xml和mapper.xml。

同时,我们也使用了Spring框架进行依赖注入和事务管理。

通过这些配置文件,我们可以方便地进行数据库操作,并且保证了数据的一致性和完整性。

在编码过程中,我们遵循了面向对象的编程原则,将实体类与数据库表进行了映射,同时定义了相应的DAO(Data Access Object)接口和实现类。

通过这种方式,我们可以方便地对数据库进行增删改查的操作。

在编码过程中,我们还对系统的安全性和性能进行了考虑。

我们使用了Spring Security框架对系统进行了安全验证,并对敏感信息进行了加密处理。

我们还进行了性能测试,通过使用JMeter等测试工具,模拟了多用户并发访问系统的场景,发现了系统的性能瓶颈,并进行了优化。

在整个实训过程中,我学到了很多知识和技能。

Mybatis如何自动生成数据库表结构总结

Mybatis如何自动生成数据库表结构总结

Mybatis如何⾃动⽣成数据库表结构总结⼀般情况下,⽤Mybatis的时候是先设计表结构再进⾏实体类以及映射⽂件编写的,特别是⽤代码⽣成器的时候。

但有时候不想⽤代码⽣成器,也不想定义表结构,那怎么办?这个时候就会想到Hibernate,然后想到它的hibernate.hbm2ddl.auto配置项。

所以⼿⼯创表的问题可以很⽅便的迅速⽤Hibernate来解决。

那有⼈问啦:就是不想⽤Hibernate才换的Mybatis,你这⼜兜回去了吗?其实不是的,我们需要的就是单单⼀个hbm2ddl功能。

其实应该这么想:有⼀款⼯具能够⾃动根据注解的实体类来⽣成各种数据库相应的表结构,只需要加⼏个jar包 (经测试后只要7个)并且少量配置(3个配置项)。

这款⼯具就是Hibernate。

为什么不能是它呢原理说来也是超级的简单:加⼊hibernate的包,注解实体类,程序开始时初始化⼀下hibernate的SessionFactory并清除它。

⽰例:需要的Hibernate相关的JAR包 (本例基于Hibernate5.0.7,仅需要7个):hibernate-core-5.0.7.Final.jarhibernate-commons-annotations-5.0.1.Final.jarhibernate-jpa-2.1-api-1.0.0.Final.jargeronimo-jta_1.1_spec-1.1.1.jarjboss-logging-3.3.0.Final.jardom4j-1.6.1.jarjavassist-3.18.1-GA.jarHibernate.cfg.xml⽂件:(去掉多余的,精简后的内容)<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!--不采⽤InnoDB⽅式加快速度 --><property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property><!-- 注意update⽅式时对于属性的删减并不会删除数据库字段 --><property name="hibernate.hbm2ddl.auto">update</property><!-- 注意注解的话,只能⽤class⼀个⼀个引⽤。

mybatis语法

mybatis语法

mybatis语法MyBatis是一种优秀的持久层框架,是基于Java的持久层框架。

它的最大特点就是采用XML文件或注解的形式来配置数据库操作,使用MyBatis以后可以进行SQL语句的操作,这使得工作更加简单快捷。

本文就MyBatis语法相关知识来进行介绍。

MyBatis语法框架中使用了4种不同类型的语句,分别是:Select,Insert,Update和Delete。

这4种语句是数据库操作的4大基本操作,只要通过这4种基本操作可以完成90%以上的数据库操作,这就是MyBatis语法框架的核心所在。

首先来看看Select语句,它的作用是从数据库中查询满足条件的数据,它的语法格式如下:Select * from TableName where Condition;其中,TableName表示数据表的名称,Condition是查询条件,比如可以指定查询某个字段的值等等。

接下来看看Insert语句,它的作用是向数据库中插入一行新数据,它的语法格式如下:Insert into TableName(Column1, Column2,…values(Value1, Value2,…);其中,TableName表示数据表的名称,Column1和Column2表示需要插入的字段,Value1和Value2表示插入字段的值。

接下来看看Update语句,它的作用是更新数据库中的数据,它的语法格式如下:Update TableName set Column1=Value1,Column2=Value2 where Condition;其中,TableName表示数据表的名称,Column1和Column2表示需要更新的字段,Value1和Value2表示更新字段的值,Condition 是查询条件,表示需要更新哪些数据。

最后看看Delete语句,它的作用是删除数据库中的数据,它的语法格式如下:Delete from TableName where Condition;其中,TableName表示数据表的名称,Condition是查询条件,表示需要删除哪些数据。

mybatis

mybatis

mybatismybatis第⼀章介绍1. 三层架构 界⾯层:和⽤户打交道的,接收⽤户的请求参数,显⽰处理结果的。

(jsp ,html ,servlet) 业务逻辑层:接收了界⾯层传递的数据,计算逻辑,调⽤数据库,获取数据 数据访问层:就是访问数据库,执⾏对数据的查询,修改,删除等等的。

三层对应的包 界⾯层: controller包(servlet) 业务逻辑层: service 包(XXXService类) 数据访问层: dao包(XXXDao类)三层中类的交互 ⽤户使⽤界⾯层--> 业务逻辑层--->数据访问层(持久层)-->数据库(mysql)三层对应的处理框架 界⾯层---servlet---springmvc(框架) 业务逻辑层---service类--spring(框架) 数据访问层---dao类--mybatis(框架)2.框架 框架是⼀个舞台,⼀个模版模版: 1. 规定了好⼀些条款,内容。

2. 加⼊⾃⼰的东西框架是⼀个模块 1.框架中定义好了⼀些功能。

这些功能是可⽤的。

2.可以加⼊项⽬中⾃⼰的功能,这些功能可以利⽤框架中写好的功能。

框架是⼀个软件,半成品的软件,定义好了⼀些基础功能,需要加⼊你的功能就是完整的。

基础功能是可重复使⽤的,可升级的。

框架特点: 1. 框架⼀般不是全能的,不能做所有事情 2. 框架是针对某⼀个领域有效。

特长在某⼀个⽅⾯,⽐如mybatis做数据库操作强,但是他不能做其它的。

3. 框架是⼀个软件mybatis框架⼀个框架,早期叫做ibatis, 代码在github。

mybatis是 MyBatis SQL Mapper Framework for Java (sql映射框架) 1)sql mapper :sql映射 可以把数据库表中的⼀⾏数据映射为⼀个java对象。

⼀⾏数据可以看做是⼀个java对象。

操作这个对象,就相当于操作表中的数据 2) Data Access Objects(DAOs) : 数据访问,对数据库执⾏增删改查。

mybatis语法和介绍详细

mybatis语法和介绍详细

mybatis语法和介绍详细MyBatis是一个开源的持久层框架,它简化了数据库访问的操作。

它与传统的ORM框架相比,更加灵活和强大,能够提供更高效的数据库访问性能。

本文将对MyBatis的语法和特点进行详细介绍。

一、MyBatis语法1. SQL映射文件:MyBatis使用XML文件来配置SQL语句和映射关系。

SQL映射文件中包含了SQL语句以及与数据库表字段的映射关系。

2. SQL语句:MyBatis支持标准的SQL语句,可以直接在SQL映射文件中编写SQL语句。

可以使用动态SQL来实现灵活的条件查询和动态更新。

3. 参数映射:MyBatis支持将Java对象与SQL语句中的参数进行映射。

可以使用#{param}语法来引用参数,也可以使用${param}语法来引用参数。

4. 结果映射:MyBatis支持将SQL查询结果映射到Java对象或集合中。

可以通过配置来实现一对一、一对多、多对一、多对多等复杂的关联关系。

6. 缓存:MyBatis支持缓存,可以将查询结果缓存到内存中,提高查询性能。

可以使用一级缓存和二级缓存来实现不同级别的缓存。

7. 插件:MyBatis支持插件,可以通过插件来扩展MyBatis的功能。

可以自定义插件来实现自定义的功能,如日志记录、性能监控等。

二、MyBatis特点1. 简单易用:MyBatis的语法简单明了,易于上手。

通过XML配置即可完成数据库的访问操作,无需编写繁琐的SQL语句。

2. 灵活性高:MyBatis支持动态SQL,可以根据不同的条件生成不同的SQL语句。

可以灵活地处理复杂的查询需求。

3. 性能优越:MyBatis使用了预编译的SQL语句和缓存机制,可以提高查询性能。

通过合理地配置缓存可以减少数据库的访问次数,进一步提升性能。

4. 易于集成:MyBatis可以与各种主流的Java框架集成,如Spring、Spring Boot等。

可以通过注解方式来简化配置,提高开发效率。

mybatisif标签使用总结

mybatisif标签使用总结

mybatisif标签使⽤总结在项⽬开发中,mybatis <if> 标签使⽤⼴泛,本⽂讲解if标签的两种使⽤⽅式其⼀、使⽤ <if> 标签判断某⼀字段是否为空其⼆、使⽤ <if> 标签判断传⼊参数是否相等具体代码如下数据库表结构和数据实体类package com.demo.bean;public class Commodity {private String name;private String date;public String getName() {return name;}public void setName(String name) { = name;}public String getDate() {return date;}public void setDate(String date) {this.date = date;}@Overridepublic String toString() {return "Com [name=" + name + ", date=" + date + "]";}}mapper层package com.demo.mapper;import java.util.List;import org.apache.ibatis.annotations.Mapper;import org.apache.ibatis.annotations.Param;import modity;@Mapperpublic interface CommodityMapper {List<Commodity> getListByDate(Commodity commodity);List<Commodity> getListByStartDateAndEndDate(@Param("startDate")String startDate, @Param("endDate")String endDate); }mapper.xml⽂件<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd" ><mapper namespace="modityMapper"><resultMap id="BaseResultMap" type="modity"><id column="name" property="name" jdbcType="VARCHAR" /><result column="date" property="date" jdbcType="VARCHAR" /></resultMap><select id="getListByDate" resultMap="BaseResultMap">select * from commodity where 1 = 1<if test="date != null and date != ''">and date = #{date}</if></select><select id="getListByStartDateAndEndDate" resultMap="BaseResultMap">select * from commodity where 1 = 1<if test="#{startDate}.toString() != #{endDate}.toString()">and date between #{startDate} and #{endDate}</if></select></mapper>注意:mybatis 等值判断的 tostring()⽅法 (上边代码中第⼆个select中的toString()⽅法)controller层package com.demo.controller;import java.util.HashMap;import java.util.Map;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;import org.springframework.web.bind.annotation.RestController;import modity;import modityMapper;@RestControllerpublic class DemoController {@Autowiredprivate CommodityMapper comMapper;@RequestMapping(value = "/commodity")public Object commodity() {Map<String, Object> map = new HashMap<String, Object>();Commodity com =new Commodity();com.setDate("2018-10-12");map.put("res", comMapper.getListByDate(com));return map;}@RequestMapping(value = "/between")public Object commodityBetween() {Map<String, Object> map = new HashMap<String, Object>();map.put("res", comMapper.getListByStartDateAndEndDate("2018-10-09", "2018-10-13"));return map;}}测试以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。

mybatis-中文文档

mybatis-中文文档

mybatis-中⽂⽂档1 Mybatis的介绍Mybatis就是⼀个封装jdbc的持久层框架,它和hibernate都属于ORM框架,但是具体的说,hibernate是⼀个完全的orm框架,⽽mbatis是⼀个不完全的orm框架.Mybatis让程序员只关注sql本⾝,⽽不需要去关注如连接的创建、statement 的创建等操作。

Mybatis会将输⼊参数据、输出结果进⾏映射MyBatis 本是的⼀个开源项⽬, 2010年这个项⽬由apache software foundation 迁移到了google code,并且改名为MyBatis,实质上Mybatis 对ibatis进⾏⼀些改进。

MyBatis是⼀个优秀的持久层框架,它对jdbc的操作数据库的过程进⾏封装,使开发者只需要关注 SQL 本⾝,⽽不需要花费精⼒去处理例如注册驱动、创建connection、创建statement、⼿动设置参数、结果集检索等jdbc繁杂的过程代码。

Mybatis通过xml或注解的⽅式将要执⾏的各种statement(statement、preparedStatemnt、CallableStatement)配置起来,并通过java对象和statement中的sql进⾏映射⽣成最终执⾏的sql语句,最后由mybatis框架执⾏sql并将结果映射成java对象并返回。

2 分析jdbc的问题2.1 原⽣态的jdbc代码publicstaticvoid main(String[] args) {Connection connection = null;PreparedStatement preparedStatement = null;ResultSet resultSet = null;try {//1、加载数据库驱动Class.forName("oracle.jdbc.OracleDriver");//2、通过驱动管理类获取数据库链接connection = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "xiaoming", "root");//3、定义sql语句 ?表⽰占位符String sql = "select * from t_user where t_name = ?";//4、获取预处理statementpreparedStatement = connection.prepareStatement(sql);//5、设置参数,第⼀个参数为sql语句中参数的序号(从1开始),第⼆个参数为设置的参数值preparedStatement.setString(1, "程冠西");//6、向数据库发出sql执⾏查询,查询出结果集resultSet = preparedStatement.executeQuery();//7、遍历查询结果集while(resultSet.next()){System.out.println(resultSet.getString("t_id")+""+resultSet.getString("t_name")); }} catch (Exception e) {e.printStackTrace();}finally{//8、释放资源if(resultSet!=null){try {resultSet.close();} catch (SQLException e) {e.printStackTrace();}}if(preparedStatement!=null){try {preparedStatement.close();} catch (SQLException e) {e.printStackTrace();}}if(connection!=null){try {connection.close();} catch (SQLException e) {e.printStackTrace();}}}}2.2 问题总结1、在创建连接时,存在硬编码配置⽂件2、在执⾏statement时存在硬编码配置⽂件(映射⽂件)3、频繁的开启的关闭数据库连接,会造成数据库性能下降。

mybatiscollection一对多关联查询,单边分页的问题总结!

mybatiscollection一对多关联查询,单边分页的问题总结!

mybatiscollection⼀对多关联查询,单边分页的问题总结!若想直接通过sql实现多级关联查询表结构得有2 个必不可少的字段:id ,parentId,levelIdid:主键id,parentId:⽗idlevelId:表⽰第⼏级(表本⾝关联查询的时候需要⽤到,不然会有重复数据)利⽤mybatis collection 实现⼀对多关联查询Dto:(⼀级)public class ProvinceInfoDTO implements Serializable {private String id;private String name;private String pinyin;private String firstLetter;private List<CitysInfoDTO> cities;}Dto:(⼆级)public class CitysInfoDTO implements Serializable {private String id;private String name;private String pinyin;private String firstLetter;private String acronym;private List<RegionInfoDTO> regions;}Dto(三级)public class RegionInfoDTO implements Serializable {private String id;private String name;private String pinyin;private String firstLetter;}resultMap<resultMap id="unloadAreaQueryResultMap" type="com.haoyunhu.res.ProvinceInfoDTO"> // ⼀级<result column="aid" property="id"/><result column="aname" property="name"/><result column="apinyin" property="pinyin"/><result column="aletter" property="firstLetter"/><collection property="cities" ofType="com.haoyunhu.res.CitysInfoDTO"> //⼆级<result column="bid" property="id"/><result column="bname" property="name"/><result column="bpinyin" property="pinyin"/><result column="bletter" property="firstLetter"/><result column="bacronym" property="acronym"/><collection property="regions" ofType="com.haoyunhu.res.RegionInfoDTO"> // 三级<result column="cid" property="id"/><result column="cname" property="name"/><result column="cpinyin" property="pinyin"/><result column="cletter" property="firstLetter"/></collection></collection></resultMap>省市区级联查询sql:SELECT a.PROV_NAME,b.PROV_NAME,c.PROV_NAMEFROM T_DATA_AREAS aLEFT JOIN T_DATA_AREAS bON a.id=b.PROV_PARENTIDLEFT JOIN T_DATA_AREAS CON b.id =C.PROV_PARENTIDWHERE a.PROV_LEVELTYPE=1AND b.PROV_LEVELTYPE =2AND c.PROV_LEVELTYPE =3ORDER BY a.PROV_NAME;以上mybatis的操作最终得到的json是:{"id":"310000","name":"上海","pinyin":"Shanghai","firstLetter":"","cities":[{"id":"310100","name":"上海市","pinyin":"Shanghai","firstLetter":"","acronym":"","regions":[{"id":"230506","name":"宝⼭区","pinyin":"Baoshan","firstLetter":""}]}]}⼀对多关联查询单边分页:上述的这种关联查询时没法直接使⽤pagehelper分页插件的,因为pagehelper分页插件是针对真个sql 截取,所以只能⼿动分页(简单,分页⽆⾮就是截取sql +查询总条数),所以若⼀对多关联查询想分页得针对主表(案例中的A表)截取sql(pageindex pagesize) ,再另外写条sql查询主表(案例中的A表)的记录数 ------注意mysql 的偏移量的概念还需要注意的坑:1:这种需要做级联查询,表结构⼜不满⾜的坑:若表结构不满⾜,但是⼜想省事,就得写sql 把原表整成这种固定格式的临时表结构(⼦查询)2:电商领域的商品类⽬的级联查询和这个省市区的查询⼀样(都需要levelid,⽤在查询条件处:where a.levelid=0 and b.levelid=1 and c.levelid=2;当然这种级联查询可以在java代码中可以实现,三条sql,分别查询 level =0 1 2的,然后java代码⾥⾯循环!。

mybatis when then 的用法

mybatis when then 的用法

mybatis when then 的用法【实用版】目录1.MyBatis 简介2.MyBatis 中的 when 和 then 用法3.when 和 then 的具体使用示例4.总结正文一、MyBatis 简介MyBatis 是一个优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。

MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。

MyBatis 可以使用简单的 XML 或注解进行配置和原生映射,将接口和 Java 的 POJO(Plain Old Java Objects,普通的 Java 对象)映射成数据库中的记录。

二、MyBatis 中的 when 和 then 用法在 MyBatis 中,when 和 then 是用于处理条件判断和逻辑分支的关键字。

它们主要用于映射文件中的 SQL 语句,可以根据特定的条件执行不同的 SQL 片段。

1.when:表示在某个条件满足时执行相应的 SQL 片段。

2.then:表示在满足某个条件后执行相应的 SQL 片段。

三、when 和 then 的具体使用示例下面通过一个具体的例子来说明 when 和 then 的用法:假设我们有一个用户表(user),包含以下字段:id(主键)、name (姓名)、age(年龄)、status(状态)。

现在我们需要根据用户的年龄和状态来更新用户的信息。

在 MyBatis 的映射文件中,我们可以使用 when 和 then 来实现这个需求:```xml<update id="updateUserInfo" parameterType="map">UPDATE userSET<if test="age > 18">age = #{age},status = #{status}</if>WHERE id = #{id}</update>```在上面的示例中,我们使用了 when 和 then 关键字来实现条件判断。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Mybatis总结1.mybatis的简单概述:1.1mybatis简单概述:MyBatis 是一款优秀的持久层框架,它支持定制化SQL、存储过程以及高级映射。

MyBatis 避免了几乎所有的JDBC 代码和手动设置参数以及获取结果集。

MyBatis 可以使用简单的XML 或注解来配置和映射原生信息,将接口和Java 的POJOs(Plain Old Java Objects,普通的Java对象)映射成数据库中的记录。

1.2 功能架构:分为三层:(1).API接口层:定义api接口,外部人员通过这个接口来调用方法从而操纵数据库。

(2).数据处理层:负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。

它主要的目的是根据调用的请求完成一次数据库操作。

(3).基础支撑层:负责最基础的功能支撑,包括连接管理、事务管理、配置加载和缓存处理,这些都是共用的东西,将他们抽取出来作为最基础的组件。

为上层的数据处理层提供最基础的支撑。

2.mybatis快速入门:a. 添加jar包:mybatisasm-3.3.1.jarcglib-2.2.2.jarcommons-logging-1.1.1.jarlog4j-1.2.16.jarmybatis-3.1.1.jarslf4j-api-1.6.2.jarslf4j-log4j12-1.6.2.jarmysql驱动mysql-connector-java-5.1.7-bin.jarb. 建库+表:create database mybatis;use mybatis;CREATE TABLE users(id INT PRIMARY KEY AUTO_INCREMENT, NAMEVARCHAR(20), age INT);INSERT INTO users(NAME, age) VALUES('Tom', 12);INSERT INTO users(NAME, age) VALUES('Jack', 11);c. 在应用的src下添加Mybatis的配置文件conf.xml:<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN /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" /><propert name="url value="jdbc:mysql://localhost:3306/mybatis" /><property name="username" value="root" /><property name="password" value="root" /></dataSource></environment></environments></configuration>d. 定义表所对应的实体类:public class User {private int id;private String name;private int age;}e. 定义操作users表的sql映射文件userMapper.xml:<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="org.mybatis.example.BlogMapper"><select id="selectBlog" parameterType="int" resultType="Blog">select * from Blog where id = #{id}</select></mapper>f. 在conf.xml文件中注册userMapper.xml文件:<mappers><mapper resource="com/atguigu/day03_mybatis/test1/userMapper.xml"/> </mappers>g. 编写测试代码:执行定义的select语句:public class Test {public static void main(String[] args) throws IOException {String resource = "conf.xml";//加载mybatis的配置文件(它也加载关联的映射文件)Reader reader = Resources.getResourceAsReader(resource);//构建sqlSession的工厂SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);//创建能执行映射文件中sql的sqlSessionSqlSession session = sessionFactory.openSession();//映射sql的标识字符串String statement = "erMapper"+".selectUser";//执行查询返回一个唯一user对象的sqlUser user = session.selectOne(statement, 1);System.out.println(user);}}3. 编写基于mybatis的操作users表的CRUD操作的dao类:a. XML的实现:1. 定义sql映射xml文件:<insert id="insertUser" parameterType="er"> insert into users(name, age) values(#{name}, #{age});</insert><delete id="deleteUser" parameterType="int">delete from users where id=#{id}</delete><update id="updateUser" parameterType="er"> update users set name=#{name},age=#{age} where id=#{id}</update><select id="selectUser" parameterType="int" resultType="er">select * from users where id=#{id}</select><select id="selectAllUsers" resultType="er"> select * from users</select>2. 在config.xml中注册这个映射文件<mapper resource="net/lamp/java/ibatis/bean/userMapper.xml"/>3. 在dao中调用:public User getUserById(int id) {SqlSession session = sessionFactory.openSession();User user = session.selectOne(URI+".selectUser", id);return user;}b. 注解的实现:1. 定义sql映射的接口public interface UserMapper {@Insert("insert into users(name, age) values(#{name}, #{age})")public int insertUser(User user);@Delete("delete from users where id=#{id}")public int deleteUserById(int id);@Update("update users set name=#{name},age=#{age} where id=#{id}")public int updateUser(User user);@Select("select * from users where id=#{id}")public User getUserById(int id);@Select("select * from users")public List<User> getAllUser();}2. 在config中注册这个映射接口<mapper class="erMapper"/>3. 在dao类中调用public User getUserById(int id) {SqlSession session = sessionFactory.openSession();UserMapper mapper = session.getMapper(UserMapper.class);User user = mapper.getUserById(id);return user;}4. 几个可以优化的地方:a. 连接数据库的几个配置可以单独放在一个properties文件中db.properties:<properties resource="db.properties"/><property name="driver" value="${driver}" /><property name="url" value="${url}" /><property name="username" value="${username}" /><property name="password" value="${password}" />b. 为实体类定义别名,简化sql映射xml文件中的引用<typeAliases><typeAlias type="er" alias="_User"/> </typeAliases>c. 可以在src下加入log4j的配置文件,打印日志信息(主要是sql语句)1. log4j.propertieslog4j.properties,log4j.rootLogger=DEBUG, Console#Consolelog4j.appender.Console=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d [%t] %-5p [%c] - %m%nlog4j.logger.java.sql.ResultSet=INFO.apache=INFOlog4j.logger.java.sql.Connection=DEBUGlog4j.logger.java.sql.Statement=DEBUGlog4j.logger.java.sql.PreparedStatement=DEBUG5. 解决表的字段名与实体类的属性名不相同的冲突:a. 准备表和数据:CREATE TABLE orders(order_id INT PRIMARY KEY AUTO_INCREMENT,order_no VARCHAR(20),order_price FLOAT);INSERT INTO orders(order_no, order_price) VALUES('aaaa', 23);INSERT INTO orders(order_no, order_price) VALUES('bbbb', 33);INSERT INTO orders(order_no, order_price) VALUES('cccc', 22);b. 定义实体类:public class Order {private int id;private String orderNo;private float price;}c. 实现getOrderById(id)的查询定义<resultMap>:<select id="selectOrderResultMap" parameterType="int" resultMap="orderResultMap"> select * from orders where order_id=#{id}</select><resultMap type="_Order" id="orderResultMap"><id property="id" column="order_id"/><result property="orderNo" column="order_no"/><result property="price" column="order_price"/></resultMap>6. 实现联表查询:1). 一对一:a. 创建表和数据:CREATE TABLE teacher(t_id INT PRIMARY KEY AUTO_INCREMENT,t_name VARCHAR(20));CREATE TABLE class(c_id INT PRIMARY KEY AUTO_INCREMENT,c_name VARCHAR(20),teacher_id INT);ALTER TABLE class ADD CONSTRAINT fk_teacher_id FOREIGN KEY (teacher_id) REFERENCES teacher(t_id);INSERT INTO teacher(t_name) VALUES('LS1');INSERT INTO teacher(t_name) VALUES('LS2');INSERT INTO class(c_name, teacher_id) VALUES('bj_a', 1);INSERT INTO class(c_name, teacher_id) VALUES('bj_b', 2);b. 定义实体类:public class Teacher {private int id;private String name;}public class Classes {private int id;private String name;private Teacher teacher;}c. 定义sql映射文件ClassMapper.xml:<!-- 方式一:嵌套查询方式, 通过执行另外一个SQL映射语句来返回预期的复杂类型--><select id="getClasses" parameterType="int"resultMap="ClassesResultMap2">select * from class where c_id=#{id}</select><resultMap type="CLasses" id="ClassesResultMap2"><id column="c_id" property="id"/><result column="c_name" property="name"/><association property="teacher" javaType="Teacher" column="teacher_id" select="getTeacher"></association></resultMap><select id="getT eacher" parameterType="int" resultType="Teacher">select t_id id, t_name name from teacher where t_id=#{id}</select><!--方式二:嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集--><select id="getClasses2" parameterType="int" resultMap="ClassesResultMap"> select * from class c,teacher t where c.c_id=#{id} and c.teacher_id=t.t_id;</select><resultMap type="Classes" id="ClassesResultMap"><id column="c_id" property="id"/><result column="c_name" property="name"/><association column="teacher_id" property="teacher" javaType="Teacher"><id column="t_id" property="id"/><result column="t_name" property="name"/></association></resultMap>2) 一对多a. 创建表和数据:CREATE TABLE student(s_id INT PRIMARY KEY AUTO_INCREMENT,s_name VARCHAR(20),class_id INT);INSERT INTO student(s_name, class_id) VALUES('xs_B', 1);INSERT INTO student(s_name, class_id) VALUES('xs_D', 1);INSERT INTO student(s_name, class_id) VALUES('xs_E', 1);INSERT INTO student(s_name, class_id) VALUES('xs_A', 2);INSERT INTO student(s_name, class_id) VALUES('xs_H', 2);INSERT INTO student(s_name, class_id) VALUES('xs_J', 2);b. 定义实体类:public class Student {private int id;private String name;}public class Classes {private int id;private String name;private Teacher teacher;private List<Student> students;}c. 定义sql映射文件ClassMapper.xml:(根据classId查询对应的班级信息,包括学生)<!-- 集合的嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集--><select id="getClasses3" parameterType="int" resultMap="ClassesResultMap3"> select * from class c,teacher t, student s where c.c_id=#{id} and c.teacher_id=t.t_id and s.class_id=c.c_id</select><resultMap type="Classes" id="ClassesResultMap3"><id column="c_id" property="id"/><result column="c_name" property="name"/><association column="teacher_id" property="teacher" javaType="Teacher"><id column="t_id" property="id"/><result column="t_name" property="name"/></association><collection property="students" ofType="Student" javaType="ArrayList"><id property="id" column="s_id" /><result property="name" column="s_name"/></collection></resultMap><!-- 集合的嵌套查询方式, 通过执行另外一个SQL映射语句来返回预期的复杂类型--><select id="getClasses4" parameterType="int" resultMap="ClassesResultMap4">select * from class c where c.c_id=#{id}</select><resultMap type="CLasses" id="ClassesResultMap4"><id column="c_id" property="id"/><result column="c_name" property="name"/><association property="teacher" javaType="Teacher" column="teacher_id" select="getTeacher"></association><collection property="students" ofType="T eacher" column="c_id" select="getStudentsSelect" ></collection></resultMap><select id="getT eacher" parameterType="int" resultType="Teacher">select t_id id, t_name name from teacher where t_id=#{id}</select><select id="getStudentsSelect" parameterType="int" resultType="Student" > select s_id id, s_name name from student where class_id=#{id} </select>。

相关文档
最新文档