MyBatis
什么是 MyBatis?
MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录
教程
增删改注意
增加删除修改需要提交事务
session.commit();//提交事务
session.close();//关闭
依赖
--MyBatis依赖
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
--mysql依赖
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>
Java配置文件
resources下创建 jdbc.properties 和 mybatis-config.xml
jdbc.properties
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/cctv?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true
username=root
password=root
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>
<properties resource="jdbc.properties"/>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="org/mybatis/example/BlogMapper.xml"/>
</mappers>
</configuration>
解释:
<properties resource="数据库连接的配置文件"/>
<property name="..." value="${对应数据库配置文件的每个变量}"/>
sql映射
–sql语句映射路径 这个是mybatis.config.xml的mappers的节点
–resource=“sql语句配置文件的映射路径”
<mappers>
<mapper resource="mapper/ProjectMapper.xml"/>
</mappers>
在resources下创建一个文件夹 mapper mapper下创建ProjectMapper.xml
ProjectMapper.xml 这个文件名可以随便取
ProjectMapper.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.dao.AutosDao">
<!-- ID:就是接口方法的name resultType:返回到那个类 实体类名 namespace:接口路径-->
<select id="selectautos" resultType="com.entity.Autos">
select * from autos
</select>
</mapper>
ProjectMapper.xml解释
namespace=“接口路径”
id=“接口的某个方法 名字一致”
resultType=“实体类路径” 已sql语句返回结果为标准
<select>
sql语句</select>
在mybatis.config.xml配置sql映射路径
测试
package com.test;
import com.dao.AutosDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
/**
* @author 碰磕
*/
public class AutosMain {
public static void main(String[] args) throws IOException {
//mybatis-config.xml路径
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
//dao层
AutosDao audao=session.getMapper(AutosDao.class);
List lis=audao.seallinfo();
System.out.println(lis);
}
}
SQL语句有条件查询配置
字段名=#{dao层的传值的变量名}
实体类别名
mybatis-config.xml
-- 对某个包进行取别名 包下面的类名就是别名
<typeAliases>
<package name="com.entity"/>
</typeAliases>
AutosMapper.xml
因为取了别名所有resultType=“实体类的名字”
类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置,意在降低冗余的全限定类名书写。例如:
<typeAliases>
<typeAlias alias="Author" type="domain.blog.Author"/>
<typeAlias alias="Blog" type="domain.blog.Blog"/>
<typeAlias alias="Comment" type="domain.blog.Comment"/>
<typeAlias alias="Post" type="domain.blog.Post"/>
<typeAlias alias="Section" type="domain.blog.Section"/>
<typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>
当这样配置时,Blog
可以用在任何使用 domain.blog.Blog
的地方。
查询案列
AutosMapper.xml
<!--查询-->
<select id="seallinfo" resultType="com.entity.Autos">
select * from autos
</select>
<!--查询-->
<select id="secolo" resultType="Autos">
select * from autos where ccolor=#{color}
</select>
dao层
public List seallinfo();
public List secolo(String color);
测试
package com.test;
import com.dao.AutosDao;
import com.entity.Autos;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
/**
* @author 羡羡
*/
public class AutosMain {
public static void main(String[] args) throws IOException {
//查询
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
AutosDao audao=session.getMapper(AutosDao.class);
List lis=audao.seallinfo();
System.out.println(lis);
List pinkautos=audao.secolo("粉色");
System.out.println(pinkautos);
}
}
增加案列
AutosMapper.xml
<!--增加-->
<insert id="addautos" parameterType="com.entity.Autos">
insert into autos(cname,cnumber,ccolor) values (#{cname},#{cnumber},#{ccolor})
</insert>
dao层
public int addautos(Autos au);
测试
package com.test;
import com.dao.AutosDao;
import com.entity.Autos;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
/**
* @author 羡羡
*/
public class AutosAdd {
public static void main(String[] args) throws IOException {
//添加
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
AutosDao audao=session.getMapper(AutosDao.class);
Autos auts=new Autos();
auts.setCname("解放牌101");
auts.setCnumber("湘J09K12");
auts.setCcolor("绿色");
int adsu=audao.addautos(auts);
if(adsu>0){
session.commit();
System.out.println("添加成功!");
}else{
System.out.println("添加失败!");
}
}
}
删除案列
AutosMapper.xml
<!--删除-->
<delete id="deautos" parameterType="int">
delete from autos where id=#{id}
</delete>
---这样也可以
<!--删除-->
<delete id="deautos">
delete from autos where id=#{id}
</delete>
dao层
public int deautos(int id);
测试
package com.test;
import com.dao.AutosDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
/**
* @author 羡羡
*/
public class AutosDele {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
AutosDao audao=session.getMapper(AutosDao.class);
int desu=audao.deautos(2119);
if(desu>0){
session.commit();
System.out.println("删除成功!");
}else{
System.out.println("删除失败!");
}
}
}
更新案列
AutosMapper.xml
<!--更新-->
<update id="autoup" parameterType="com.entity.Autos">
update autos set cname=#{cname},cnumber=#{cnumber},ccolor=#{ccolor} where id=#{id}
</update>
dao层
public int autoup(Autos au);
测试
package com.test;
import com.dao.AutosDao;
import com.entity.Autos;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
public class AutosUpdate {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
AutosDao audao=session.getMapper(AutosDao.class);
Autos au=new Autos(5,"兰博基尼4","琼E45J78","黑色");
int upsu=audao.autoup(au);
if(upsu>0){
session.commit();
System.out.println("更新成功!");
}else{
System.out.println("更新失败!");
}
}
}
统计总条数
AutoMapper.xml
<!--统计总数!-->
<select id="secount" resultType="int">
select count(*) from autos
</select>
dao
public int secount();
测试
package com.test;
import com.dao.AutosDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
public class AutonCount {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
AutosDao audao=session.getMapper(AutosDao.class);
int count=audao.secount();
System.out.println("总条数:"+count);
}
}
模糊查询
AutosMapper.xml
<!--模糊查询 ${value} 也可以在sql语句中不要加 % 在获取值的时候加-->
<select id="selike" resultType="com.entity.Autos">
select * from autos where cname like '%${value}%'
</select>
dao层
public List selike(String carname);
测试
package com.test;
import com.dao.AutosDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class AutosLike {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
AutosDao audao=session.getMapper(AutosDao.class);
List lis=audao.selike("解放");
System.out.println(lis);
}
}
settings属性
settings配置在mybatis-config.xml里面 在起别名的前面
mybatis-config.xml
<!--设置属性-->
<settings>
<!--开启驼峰命名法 数据库表一般字段名是 表名_字段名 驼峰命名法后 去掉下划线 下划线后面第一个字母大写-->
<!--name就是下面的设置名-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
设置(settings)
这是 MyBatis 中极为重要的调整设置,它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。
设置名 | 描述 | 有效值 | 默认值 |
---|---|---|---|
cacheEnabled | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 | true | false | true |
lazyLoadingEnabled | 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 | true | false | false |
aggressiveLazyLoading | 开启时,任一方法的调用都会加载该对象的所有延迟加载属性。 否则,每个延迟加载属性会按需加载(参考 lazyLoadTriggerMethods)。 | true | false | false (在 3.4.1 及之前的版本中默认为 true) |
multipleResultSetsEnabled | 是否允许单个语句返回多结果集(需要数据库驱动支持)。 | true | false | true |
useColumnLabel | 使用列标签代替列名。实际表现依赖于数据库驱动,具体可参考数据库驱动的相关文档,或通过对比测试来观察。 | true | false | true |
useGeneratedKeys | 允许 JDBC 支持自动生成主键,需要数据库驱动支持。如果设置为 true,将强制使用自动生成主键。尽管一些数据库驱动不支持此特性,但仍可正常工作(如 Derby)。 | true | false | False |
autoMappingBehavior | 指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示关闭自动映射;PARTIAL 只会自动映射没有定义嵌套结果映射的字段。 FULL 会自动映射任何复杂的结果集(无论是否嵌套)。 | NONE, PARTIAL, FULL | PARTIAL |
NONE: 不做任何反应一个配置完整的 settings 元素的示例如下:
<settings>
<setting name="cacheEnabled" value="true"/>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="multipleResultSetsEnabled" value="true"/>
<setting name="useColumnLabel" value="true"/>
<setting name="useGeneratedKeys" value="false"/>
<setting name="autoMappingBehavior" value="PARTIAL"/>
<setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
<setting name="defaultExecutorType" value="SIMPLE"/>
<setting name="defaultStatementTimeout" value="25"/>
<setting name="defaultFetchSize" value="100"/>
<setting name="safeRowBoundsEnabled" value="false"/>
<setting name="mapUnderscoreToCamelCase" value="false"/>
<setting name="localCacheScope" value="SESSION"/>
<setting name="jdbcTypeForNull" value="OTHER"/>
<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>
HashMap参数
ClassMapper.xml
#{clid} 和 #{tid} 中的 clid 和 tid是HashMap的键 传多个值的时候用HashMap传值
<select id="seinf" parameterType="hashmap" resultType="com.entity.Class">
select * from class where classid>#{clid} or classworkid>#{tid}
</select>
dao
public List seinf(HashMap hash);
测试
package com.test;
import com.dao.ClassDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
public class SeHashMapTest {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
ClassDao cl=session.getMapper(ClassDao.class);
//Map传参数
HashMap ha=new HashMap();
//clid跟ClassMapper.xml中的clid需要相对应
ha.put("clid",3216);
//clid跟ClassMapper.xml中的tid需要相对应
ha.put("tid",2009);
List lis=cl.seinf(ha);
System.out.println(lis);
}
}
结果类型HashMap
两表查询返回HashMap
ClassMapper.xml
<!--返回值为HashMap-->
<select id="rehash" resultType="hashmap">
select * from class as a inner join teach as b on a.classworkid=b.classworkid;
</select>
dao层
public List rehash();
测试
package com.test;
import com.dao.ClassDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
public class ResultHashMap {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
ClassDao cl=session.getMapper(ClassDao.class);
List<HashMap> lis=cl.rehash();
System.out.println(lis);
for(HashMap mp:lis){
//键就是字段名
int clas= (int) mp.get("classid");
String name= (String) mp.get("tename");
System.out.println(clas+" "+name);
}
}
}
添加得到主键
说明:当一个表有主键自动生成时 一添加就要得到添加的那条数据的主键生成的ID
ClassMapper.xml
<!--得到主键的ID-->
<insert id="inclas" useGeneratedKeys="true" keyProperty="classid" parameterType="com.entity.Class">
insert into class values(null,#{classname},#{classcreate},#{classremark},#{classworkid},#{tecteacherid});
</insert>
解释:
useGenerateKeys=“true” 是开启生成主键 没有这个没有效果
还可以配置全局生成主键在mybatis-config.xml的settings里设置全局开启主键
dao层
public int inclas(Class cla);
测试
package com.test;
import com.dao.ClassDao;
import com.entity.Class;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
/**
* @author 羡羡
*/
public class FindKey {
public static void main(String[] args) throws IOException {
//添加数据时得到注解的ID
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
ClassDao cla=session.getMapper(ClassDao.class);
Class cl=new Class("C19017",new Date(),"20级垃圾版",2004,2021);
int csu=cla.inclas(cl);
if(csu>0){
session.commit();
session.close();
System.out.println(cl);
}else{
System.out.println("添加失败!");
}
}
}
HashMap参数分页
AutosMapper.xml
<!--分页-->
<select id="findpage" parameterType="hashmap" resultType="com.entity.Autos">
select * from autos limit #{currpage},#{pagecount};
</select>
dao
public List findpage(HashMap hash);
测试
package com.test;
import com.dao.AutosDao;
import com.entity.Autos;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
/**
* @author 羡羡
*/
public class AutosFindPage {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
AutosDao au=session.getMapper(AutosDao.class);
HashMap hasp=new HashMap();
hasp.put("currpage",0);//当前页
hasp.put("pagecount",10);//每页数量
List lis=au.findpage(hasp);
System.out.println(lis);
}
}
结果集映射
只有一个时用 association
多个时用 collection
resultMap
元素有很多子元素和一个值得深入探讨的结构。 下面是resultMap
元素的概念视图。
结果映射(resultMap)
constructor
- 用于在实例化类时,注入结果到构造方法中idArg
- ID 参数;标记出作为 ID 的结果可以帮助提高整体性能arg
- 将被注入到构造方法的一个普通结果
id
– 一个 ID 结果;标记出作为 ID 的结果可以帮助提高整体性能result
– 注入到字段或 JavaBean 属性的普通结果association
– 一个复杂类型的关联;许多结果将包装成这种类型- 嵌套结果映射 – 关联可以是
resultMap
元素,或是对其它结果映射的引用
- 嵌套结果映射 – 关联可以是
collection
– 一个复杂类型的集合- 嵌套结果映射 – 集合可以是
resultMap
元素,或是对其它结果映射的引用
- 嵌套结果映射 – 集合可以是
discriminator
– 使用结果值来决定使用哪个resultMap
case
– 基于某些值的结果映射- 嵌套结果映射 –
case
也是一个结果映射,因此具有相同的结构和元素;或者引用其它的结果映射
- 嵌套结果映射 –
属性 | 描述 |
---|---|
id | 当前命名空间中的一个唯一标识,用于标识一个结果映射。 |
type | 类的完全限定名, 或者一个类型别名(关于内置的类型别名,可以参考上面的表格)。 |
autoMapping | 如果设置这个属性,MyBatis 将会为本结果映射开启或者关闭自动映射。 这个属性会覆盖全局的属性 autoMappingBehavior。默认值:未设置(unset)。 |
最佳实践 最好逐步建立结果映射。单元测试可以在这个过程中起到很大帮助。 如果你尝试一次性创建像上面示例那么巨大的结果映射,不仅容易出错,难度也会直线上升。 所以,从最简单的形态开始,逐步迭代。而且别忘了单元测试! 有时候,框架的行为像是一个黑盒子(无论是否开源)。因此,为了确保实现的行为与你的期望相一致,最好编写单元测试。 并且单元测试在提交 bug 时也能起到很大的作用。
下一部分将详细说明每个元素。
id & result
<id property="id" column="post_id"/>
<result property="subject" column="post_subject"/>
这些元素是结果映射的基础。id 和 result 元素都将一个列的值映射到一个简单数据类型(String, int, double, Date 等)的属性或字段。
这两者之间的唯一不同是,id 元素对应的属性会被标记为对象的标识符,在比较对象实例时使用。 这样可以提高整体的性能,尤其是进行缓存和嵌套结果映射(也就是连接映射)的时候。
两个元素都有一些属性:
属性 | 描述 |
---|---|
property | 映射到列结果的字段或属性。如果 JavaBean 有这个名字的属性(property),会先使用该属性。否则 MyBatis 将会寻找给定名称的字段(field)。 无论是哪一种情形,你都可以使用常见的点式分隔形式进行复杂属性导航。 比如,你可以这样映射一些简单的东西:“username”,或者映射到一些复杂的东西上:“address.street.number”。 |
column | 数据库中的列名,或者是列的别名。一般情况下,这和传递给 resultSet.getString(columnName) 方法的参数一样。 |
javaType | 一个 Java 类的全限定名,或一个类型别名(关于内置的类型别名,可以参考上面的表格)。 如果你映射到一个 JavaBean,MyBatis 通常可以推断类型。然而,如果你映射到的是 HashMap,那么你应该明确地指定 javaType 来保证行为与期望的相一致。 |
jdbcType | JDBC 类型,所支持的 JDBC 类型参见这个表格之后的“支持的 JDBC 类型”。 只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程,你需要对可以为空值的列指定这个类型。 |
typeHandler | 我们在前面讨论过默认的类型处理器。使用这个属性,你可以覆盖默认的类型处理器。 这个属性值是一个类型处理器实现类的全限定名,或者是类型别名。 |
如果存在名称和类型相同的属性,那么可以省略 javaType
。
剩余的属性和规则和普通的 id 和 result 元素是一样的。
属性 | 描述 |
---|---|
column | 数据库中的列名,或者是列的别名。一般情况下,这和传递给 resultSet.getString(columnName) 方法的参数一样。 |
javaType | 一个 Java 类的完全限定名,或一个类型别名(关于内置的类型别名,可以参考上面的表格)。 如果你映射到一个 JavaBean,MyBatis 通常可以推断类型。然而,如果你映射到的是 HashMap,那么你应该明确地指定 javaType 来保证行为与期望的相一致。 |
jdbcType | JDBC 类型,所支持的 JDBC 类型参见这个表格之前的“支持的 JDBC 类型”。 只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程,你需要对可能存在空值的列指定这个类型。 |
typeHandler | 我们在前面讨论过默认的类型处理器。使用这个属性,你可以覆盖默认的类型处理器。 这个属性值是一个类型处理器实现类的完全限定名,或者是类型别名。 |
select | 用于加载复杂类型属性的映射语句的 ID,它会从 column 属性中指定的列检索数据,作为参数传递给此 select 语句。具体请参考关联元素。 |
resultMap | 结果映射的 ID,可以将嵌套的结果集映射到一个合适的对象树中。 它可以作为使用额外 select 语句的替代方案。它可以将多表连接操作的结果映射成一个单一的 ResultSet。这样的 ResultSet 将会将包含重复或部分数据重复的结果集。为了将结果集正确地映射到嵌套的对象树中,MyBatis 允许你 “串联”结果映射,以便解决嵌套结果集的问题。想了解更多内容,请参考下面的关联元素。 |
name | 构造方法形参的名字。从 3.4.3 版本开始,通过指定具体的参数名,你可以以任意顺序写入 arg 元素。参看上面的解释。 |
多对一
列如:多个学生对应一个班级
创建2个实体类 一个是Student.java 一个是Class.java
Class.java
package com.entity;
import java.util.Date;
public class Class {
public int classid;
public String classname;
public Date classcreate;
public String classremark;
public int classworkid;
public int tecteacherid;
public int getClassid() {
return classid;
}
public void setClassid(int classid) {
this.classid = classid;
}
public String getClassname() {
return classname;
}
public void setClassname(String classname) {
this.classname = classname;
}
public Date getClasscreate() {
return classcreate;
}
public void setClasscreate(Date classcreate) {
this.classcreate = classcreate;
}
public String getClassremark() {
return classremark;
}
public void setClassremark(String classremark) {
this.classremark = classremark;
}
public int getClassworkid() {
return classworkid;
}
public void setClassworkid(int classworkid) {
this.classworkid = classworkid;
}
public int getTecteacherid() {
return tecteacherid;
}
public void setTecteacherid(int tecteacherid) {
this.tecteacherid = tecteacherid;
}
public Class() {
}
public Class(String classname, Date classcreate, String classremark, int classworkid, int tecteacherid) {
this.classname = classname;
this.classcreate = classcreate;
this.classremark = classremark;
this.classworkid = classworkid;
this.tecteacherid = tecteacherid;
}
public Class(int classid, String classname, Date classcreate, String classremark, int classworkid, int tecteacherid) {
this.classid = classid;
this.classname = classname;
this.classcreate = classcreate;
this.classremark = classremark;
this.classworkid = classworkid;
this.tecteacherid = tecteacherid;
}
@Override
public String toString() {
return "Class{" +
"classid=" + classid +
", classname='" + classname + '\'' +
", classcreate=" + classcreate +
", classremark='" + classremark + '\'' +
", classworkid=" + classworkid +
", tecteacherid=" + tecteacherid +
'}';
}
}
Student.java
里面的字段和数据库里的字段名不同
package com.entity;
/**
* @author 羡羡
*/
public class Student {
/**
* 用户ID
*/
public int id;
/**
* 真实姓名
*/
public String name;
/**
* 性别
*/
public String stex;
/**
* 电话
*/
public String stel;
/**
* 班级实体类
*/
Class ben;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStex() {
return stex;
}
public void setStex(String stex) {
this.stex = stex;
}
public String getStel() {
return stel;
}
public void setStel(String stel) {
this.stel = stel;
}
public Class getBen() {
return ben;
}
public void setBen(Class ben) {
this.ben = ben;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", stex='" + stex + '\'' +
", stel='" + stel + '\'' +
", ben=" + ben +
'}';
}
}
配置
<!--解决字段名与数据库字段名不一致 当字段名不一致时查询不是resulttype 应该改成resultMap-->
<resultMap id="stud" type="com.entity.Student">
<!--id字段为主键 只有主键为ID column="数据库字段名"-->
<id property="id" column="ID"></id>
<!--result property="实体类的字段名" column="对应数据库的字段名"-->
<result property="name" column="usname"></result>
<result property="stex" column="sex"></result>
<result property="stel" column="tel"></result>
<!--property="在实体类中定义的名称" javaType="实体类路径"-->
<association property="ben" javaType="com.entity.Class">
<id property="classid" column="classid"/>
<result property="classname" column="classname"/>
<result property="classcreate" column="classcreate"/>
<result property="classremark" column="classremark"/>
<result property="classworkid" column="classworkid"/>
<result property="tecteacherid" column="tecteacherid"/>
</association>
</resultMap>
<select id="getsStudentinfo" resultMap="stud">
select * from student as a inner join class as b on a.classid=b.classid where ID=#{stid}
</select>
字段解释
<select resultMap="上面定义的resultMap的ID"></select
<resultMap id="随便起" type="实体类路径">
//主键用ID 其他用result
<id property="实体类主键字段名" colum="数据库字段名"></id>
<result property="实体类字段名"></result>
<result property="实体类字段名"></result>
<result property="实体类字段名"></result>
<association property="在上一节点的type属性的实体类中的名字" javaType="那实体类的属性字段">
//主键用ID 其他用result
<id property="实体类主键字段名" colum="数据库字段名"></id>
<result property="实体类字段名"></result>
<result property="实体类字段名"></result>
<result property="实体类字段名"></result>
</association>
</resultMap>
测试
package com.test;
import com.dao.StudentDao;
import com.entity.Student;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
/**
* @author 羡羡
*/
public class TwoTableQueryStudent {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
StudentDao stud=session.getMapper(StudentDao.class);
Student st=stud.getsStudentinfo(3012);
System.out.println(st);
}
}
一对多
比如:一个班级有多个学生 查询班级
Class02.java
package com.entity;
import java.util.Date;
import java.util.List;
/**
* @author 羡羡
*/
public class Class02 {
public int classid;
public String classname;
public Date classcreate;
public String classremark;
public int classworkid;
public int tecteacherid;
public List<Student02> stud;
public int getClassid() {
return classid;
}
public void setClassid(int classid) {
this.classid = classid;
}
public String getClassname() {
return classname;
}
public void setClassname(String classname) {
this.classname = classname;
}
public Date getClasscreate() {
return classcreate;
}
public void setClasscreate(Date classcreate) {
this.classcreate = classcreate;
}
public String getClassremark() {
return classremark;
}
public void setClassremark(String classremark) {
this.classremark = classremark;
}
public int getClassworkid() {
return classworkid;
}
public void setClassworkid(int classworkid) {
this.classworkid = classworkid;
}
public int getTecteacherid() {
return tecteacherid;
}
public void setTecteacherid(int tecteacherid) {
this.tecteacherid = tecteacherid;
}
public List getStud() {
return stud;
}
public void setStud(List stud) {
this.stud = stud;
}
@Override
public String toString() {
return "Class02{" +
"classid=" + classid +
", classname='" + classname + '\'' +
", classcreate=" + classcreate +
", classremark='" + classremark + '\'' +
", classworkid=" + classworkid +
", tecteacherid=" + tecteacherid +
", stud=" + stud +
'}';
}
}
Student02.java
package com.entity;
public class Student02 {
/**
* 用户ID
*/
public int id;
/**
* 真实姓名
*/
public String name;
/**
* 性别
*/
public String stex;
/**
* 电话
*/
public String stel;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStex() {
return stex;
}
public void setStex(String stex) {
this.stex = stex;
}
public String getStel() {
return stel;
}
public void setStel(String stel) {
this.stel = stel;
}
@Override
public String toString() {
return "Student02{" +
"id=" + id +
", name='" + name + '\'' +
", stex='" + stex + '\'' +
", stel='" + stel + '\'' +
'}';
}
}
配置
<resultMap id="mycalss" type="com.entity.Class02">
<id property="classid" column="classid"/>
<result property="classname" column="classname"/>
<result property="classcreate" column="classcreate"/>
<result property="classremark" column="classremark"/>
<result property="classworkid" column="classworkid"/>
<result property="tecteacherid" column="tecteacherid"/>
<collection property="stud" ofType="com.entity.Student02">
<id property="id" column="ID"></id>
<!--result property="实体类的字段名" column="对应数据库的字段名"-->
<result property="name" column="usname"></result>
<result property="stex" column="sex"></result>
<result property="stel" column="tel"></result>
</collection>
</resultMap>
<select id="getclass02" resultMap="mycalss">
select * from student as a inner join class as b on a.classid=b.classid where a.classid=#{classid}
</select>
字段解释
<!---
<collection property="在上一实体类中的变量字段" ofType="实体类">
其他主键用ID
其他用result
........
</collection>
--->
<collection property="stud" ofType="com.entity.Student02">
<id property="id" column="ID"></id>
<!--result property="实体类的字段名" column="对应数据库的字段名"-->
<result property="name" column="usname"></result>
<result property="stex" column="sex"></result>
<result property="stel" column="tel"></result>
</collection>
测试
package com.test;
import com.dao.StudentDao;
import com.entity.Class02;
import com.entity.Student02;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
/**
* @author 羡羡
*/
public class OneToManyClass {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
StudentDao stud=session.getMapper(StudentDao.class);
Class02 clas3=stud.getclass02(3209);
System.out.println(clas3);
}
}
嵌套结果集
例:类似博客 一个用户有一个博客 一个博客下面有多篇文章 文章下面有多个评论
实体大概过程:
用户实体{
用户的各种属性
}
博客实体{
博客的各种属性
用户实体
文章实体
}
文章实体{
文章属性
评论实体
}
评论实体{
评论的各种属性
}
用户实体
package com.entity;
public class User {
public int userid;
public String name;
public String pass;
public String imgurl;
public int getUserid() {
return userid;
}
public void setUserid(int userid) {
this.userid = userid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPass() {
return pass;
}
public void setPass(String pass) {
this.pass = pass;
}
public String getImgurl() {
return imgurl;
}
public void setImgurl(String imgurl) {
this.imgurl = imgurl;
}
@Override
public String toString() {
return "User{" +
"userid=" + userid +
", name='" + name + '\'' +
", pass='" + pass + '\'' +
", imgurl='" + imgurl + '\'' +
'}';
}
}
博客实体
package com.entity;
import java.util.Date;
import java.util.List;
/**
* @author 羡羡
*/
public class Blog {
public int wbid;
public int yhid;
public String wbtitle;
public Date wbcreate;
//用户
User use;
//list文章
List<Article> artl;
public int getWbid() {
return wbid;
}
public void setWbid(int wbid) {
this.wbid = wbid;
}
public int getYhid() {
return yhid;
}
public void setYhid(int yhid) {
this.yhid = yhid;
}
public String getWbtitle() {
return wbtitle;
}
public void setWbtitle(String wbtitle) {
this.wbtitle = wbtitle;
}
public Date getWbcreate() {
return wbcreate;
}
public void setWbcreate(Date wbcreate) {
this.wbcreate = wbcreate;
}
public User getUse() {
return use;
}
public void setUse(User use) {
this.use = use;
}
public List<Article> getArtl() {
return artl;
}
public void setArtl(List<Article> artl) {
this.artl = artl;
}
@Override
public String toString() {
return "Blog{" +
"wbid=" + wbid +
", yhid=" + yhid +
", wbtitle='" + wbtitle + '\'' +
", wbcreate=" + wbcreate +
", use=" + use +
", artl=" + artl +
'}';
}
}
文章实体
package com.entity;
import java.util.List;
public class Article {
public int wzid;
public String wztitle;
public String wzcontext;
public int wbid;
List<Comments> coms;
public int getWzid() {
return wzid;
}
public void setWzid(int wzid) {
this.wzid = wzid;
}
public String getWztitle() {
return wztitle;
}
public void setWztitle(String wztitle) {
this.wztitle = wztitle;
}
public String getWzcontext() {
return wzcontext;
}
public void setWzcontext(String wzcontext) {
this.wzcontext = wzcontext;
}
public int getWbid() {
return wbid;
}
public void setWbid(int wbid) {
this.wbid = wbid;
}
public List<Comments> getComs() {
return coms;
}
public void setComs(List<Comments> coms) {
this.coms = coms;
}
@Override
public String toString() {
return "Article{" +
"wzid=" + wzid +
", wztitle='" + wztitle + '\'' +
", wzcontext='" + wzcontext + '\'' +
", wbid=" + wbid +
", coms=" + coms +
'}';
}
}
评论实体
package com.entity;
import java.util.Date;
public class Comments {
public int plid;
public int wzid;
public String plnr;
public Date pltime;
public int userid;
public int getPlid() {
return plid;
}
public void setPlid(int plid) {
this.plid = plid;
}
public int getWzid() {
return wzid;
}
public void setWzid(int wzid) {
this.wzid = wzid;
}
public String getPlnr() {
return plnr;
}
public void setPlnr(String plnr) {
this.plnr = plnr;
}
public Date getPltime() {
return pltime;
}
public void setPltime(Date pltime) {
this.pltime = pltime;
}
public int getUserid() {
return userid;
}
public void setUserid(int userid) {
this.userid = userid;
}
@Override
public String toString() {
return "Comments{" +
"plid=" + plid +
", wzid=" + wzid +
", plnr='" + plnr + '\'' +
", pltime=" + pltime +
", userid=" + userid +
'}';
}
}
dao层
package com.dao;
import com.entity.Blog;
/**
* @author 羡羡
*/
public interface BlogDao {
public Blog seblinfo(int userid);
}
配置
<?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.dao.BlogDao">
<resultMap id="bloginf" type="com.entity.Blog">
<id property="wbid" column="wbid"></id>
<result property="yhid" column="yhid"></result>
<result property="wbtitle" column="wbtitle"></result>
<result property="wbcreate" column="wbcreate"></result>
<association property="use" javaType="com.entity.User">
<id property="userid" column="userid"/>
<result property="name" column="name"/>
<result property="pass" column="pass"/>
<result property="imgurl" column="imgurl"/>
</association>
<collection property="artl" ofType="com.entity.Article">
<id property="wzid" column="wzid"></id>
<!--result property="实体类的字段名" column="对应数据库的字段名"-->
<result property="wztitle" column="wztitle"></result>
<result property="wzcontext" column="wzcontext"></result>
<result property="wbid" column="wbid"></result>
<collection property="coms" ofType="com.entity.Comments">
<id property="plid" column="plid"></id>
<result property="wzid" column="wzid"></result>
<result property="plnr" column="plnr"></result>
<result property="pltime" column="pltime"></result>
<result property="userid" column="userid"></result>
</collection>
</collection>
</resultMap>
<select id="seblinfo" resultMap="bloginf">
select a.*,b.*,c.*,d.*from wb as a left join user as b on a.yhid=b.userid inner join wz as c on a.wbid=c.wbid right join pl as d on d.wzid=c.wzid where b.userid=#{userid};
</select>
</mapper>
测试
package com.test;
import com.dao.BlogDao;
import com.entity.Blog;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
/**
* @author 羡羡
*/
public class BlogTest {
public static void main(String[] args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
BlogDao blodao=session.getMapper(BlogDao.class);
Blog bl=blodao.seblinfo(101);
System.out.println(bl);
}
}
动态SQL
mybatis 的动态sql语句是基于OGNL表达式的。可以方便的在 sql 语句中实现某些逻辑. 总体说来mybatis 动态SQL 语句主要有以下几类:
- if 语句 (简单的条件判断)
- choose (when,otherwize) ,相当于java 语言中的 switch ,与 jstl 中的choose 很类似.
- trim (对包含的内容加上 prefix,或者 suffix 等,前缀,后缀)
- where (主要是用来简化sql语句中where条件判断的,能智能的处理 and or ,不必担心多余导致语法错误)
- set (主要用于更新时)
- foreach (在实现 mybatis in 语句查询时特别有用)
动态where if查询
配置
<!--when if可以多个条件同时满足-->
<select id="finde" resultType="com.entity.Heros">
select * from heros
<where>
<if test="sex != null">
AND sex=#{sex}
</if>
<if test="first != null">
AND first=#{first}
</if>
<if test="name != null">
AND name like #{name}
</if>
</where>
</select>
dao
public List finde(Heros her);
测试
package com.test;
import com.dao.AutosDao;
import com.dao.HerosDao;
import com.entity.Heros;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @author 碰磕
*/
public class DynamicSQL01 {
SqlSession session;
HerosDao he;
@Before
public void init() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
session=sqlSessionFactory.openSession();
he=session.getMapper(HerosDao.class);
}
@After
public void ends(){
session.commit();
session.close();
}
@Test
public void test01(){
//if语句 通过填写的不同值来查询数据
Heros hs=new Heros();
hs.setSex(1);
hs.setFirst("辅助");
/*hs.setName("%女%");*/
List lis=he.finde(hs);
System.out.println(lis);
}
}
choose查询
配置
<!--choose 类似switch 满足一个则不会向下执行 而且只会满足一个条件-->
<select id="finde02" resultType="com.entity.Heros">
select * from heros
<where>
<choose>
<when test="sex != null">
AND sex=#{sex}
</when>
<when test="name != null">
AND name=#{name}
</when>
<otherwise>
AND first=#{first}
</otherwise>
</choose>
</where>
</select>
dao
public List finde02(Heros her);
测试
package com.test;
import com.dao.AutosDao;
import com.dao.HerosDao;
import com.entity.Heros;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @author 羡羡
*/
public class DynamicSQL01 {
SqlSession session;
HerosDao he;
@Before
public void init() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
session=sqlSessionFactory.openSession();
he=session.getMapper(HerosDao.class);
}
@After
public void ends(){
session.commit();
session.close();
}
@Test
public void test02(){
//choose的用法 只会满足一个条件 这个测试只是找性别为女的 而类型辅助的这个则不会查找
Heros hs=new Heros();
hs.setSex(0);
hs.setFirst("辅助");
List lis=he.finde02(hs);
System.out.println(lis);
}
}
set更新数据
配置
<!--set if 添加数据-->
<update id="updateheros">
update heros
<set>
<if test="name!=null">name=#{name},</if>
<if test="sex!=null">sex=#{sex},</if>
<if test="nickname!=null">nickname=#{nickname},</if>
</set>
where id=#{id}
</update>
dao
public int updateheros(Heros hes);
测试
package com.test;
import com.dao.AutosDao;
import com.dao.HerosDao;
import com.entity.Heros;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @author 羡羡
*/
public class DynamicSQL01 {
SqlSession session;
HerosDao he;
@Before
public void init() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
session=sqlSessionFactory.openSession();
he=session.getMapper(HerosDao.class);
}
@After
public void ends(){
session.commit();
session.close();
}
@Test
public void test03(){
//set方法(填哪个值就改哪个值) 更新语句使用 以前更新数据是一整条数据都要进行更新 使用set就是填了哪个字段就更新哪个字段 其他字段不变
Heros hs=new Heros();
hs.setSex(0);
hs.setId(1);
int uin=he.updateheros(hs);
System.out.println(uin);
}
}
foreach(查询 in 条件)
配置
<!--foreach 循环查询in条件 item="元素下标名称" collection="变量数据类型 array || list " separator=","-->
<select id="gether" resultType="com.entity.Heros">
select * from heros where id in
<foreach item="item" collection="array"
open="(" separator="," close=")">
#{item}
</foreach>
</select>
dao
public List gether(int[] ar);
测试
package com.test;
import com.dao.AutosDao;
import com.dao.HerosDao;
import com.entity.Heros;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @author 羡羡
*/
public class DynamicSQL01 {
SqlSession session;
HerosDao he;
@Before
public void init() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
session=sqlSessionFactory.openSession();
he=session.getMapper(HerosDao.class);
}
@After
public void ends(){
session.commit();
session.close();
}
@Test
public void test04(){
//foreach测试 一般用户查询语句的in条件
int []nj={10,56,89,12};
List lis=he.gether(nj);
System.out.println(lis);
}
}
foreach批量添加数据
配置
<!--foreach循环批量添加-->
<insert id="addlis" parameterType="list">
insert into heros(name,nickname,sex,first)values
<foreach collection="list" separator="," item="hero">
(#{hero.name},#{hero.nickname},#{hero.sex},#{hero.first})
</foreach>
</insert>
dao
public int addlis(List<Heros> her);
测试
package com.test;
import com.dao.AutosDao;
import com.dao.HerosDao;
import com.entity.Heros;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @author 碰磕
*/
public class DynamicSQL01 {
SqlSession session;
HerosDao he;
@Before
public void init() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
session=sqlSessionFactory.openSession();
he=session.getMapper(HerosDao.class);
}
@After
public void ends(){
session.commit();
session.close();
}
@Test
public void test05(){
//foreach测试 批量查询
List lis=new ArrayList();
Heros her=new Heros("非","非洲",1,"辅助");
Heros he2=new Heros("非2","非洲2",1,"打野");
Heros he3=new Heros("非3","非洲3",0,"辅助");
Heros he4=new Heros("非3","非洲3",1,"法师");
lis.add(her);
lis.add(he2);
lis.add(he3);
lis.add(he4);
int sug=he.addlis(lis);
System.out.println(sug);
}
}
分页pageHelp
导入分页依赖
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.1.8</version>
</dependency>
配置分页插件
在mybatis-config.xml中配置
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
配置HerosMapper.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.dao.HerosDao">
<select id="seheall" resultType="com.entity.Heros">
select * from heros
</select>
</mapper>
dao层
package com.dao;
import java.util.List;
public interface HerosDao {
public List seheall();
}
测试
package com.it;
import com.dao.HerosDao;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.List;
public class HerosTest {
SqlSession session;
HerosDao her;
@Before
public void init() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
session=sqlSessionFactory.openSession();
her=session.getMapper(HerosDao.class);
}
@After
public void ends(){
session.commit();
session.close();
}
@Test
public void sehealltest(){
PageHelper.startPage(1,5);
List seall=her.seheall();
System.out.println(seall);
PageInfo pa=new PageInfo(seall);
pa.setNavigatePages(10);
pa.setNavigateLastPage(10);
System.out.println("总页数:"+pa.getPages());
System.out.println("当前页:"+pa.getPageNum());
int [] panum=pa.getNavigatepageNums();
System.out.println("导航条:"+ Arrays.toString(panum));
System.out.println(pa);
}
}
Struts And MybatisPage
struts框架和mybatis框架 分页
依赖
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>2.5.26</version>
</dependency>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-json-plugin</artifactId>
<version>2.5.20</version>
</dependency>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.1.8</version>
</dependency>
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>
<properties resource="jdbc.properties"/>
<!--设置属性-->
<settings>
<!--开启驼峰命名法 数据库表一般字段名是 表名_字段名 驼峰命名法后 去掉下划线 下划线后面第一个字母大写-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
<setting name="useGeneratedKeys" value="true"/>
</settings>
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="mapper/HerosMapper.xml"/>
</mappers>
</configuration>
struts.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
"http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
<constant name="struts.devMode" value="true"/>
<package name="lol" extends="struts-default" namespace="/">
<global-allowed-methods>regex:.*</global-allowed-methods>
<action name="her*" class="com.action.HerosAction" method="{1}">
<result>/index.jsp</result>
</action>
</package>
</struts>
jdbc.properties
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/heros?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true
username=root
password=root
修改web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<display-name>Archetype Created Web Application</display-name>
<filter>
<filter-name>action2</filter-name>
<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<!-- END SNIPPET: filter -->
<filter-mapping>
<filter-name>action2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
HerosMapper.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.dao.HerosDao">
<select id="seheall" resultType="com.entity.Heros">
select * from heros
</select>
</mapper>
dao层
package com.dao;
import java.util.List;
public interface HerosDao {
public List seheall();
}
entity实体
package com.entity;
public class Heros {
public int id;
public String name;
public String nickname;
public int sex;
public String first;
public String img;
public String getImg() {
return img;
}
public void setImg(String img) {
this.img = img;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
@Override
public String toString() {
return "Heros{" +
"id=" + id +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
", sex=" + sex +
", first='" + first + '\'' +
", img='" + img + '\'' +
'}';
}
}
SeeionReturn
方便Action中得到dao层
package com.dao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
/**
* @author 羡羡
*/
public class SeeionReturn {
public static SqlSession getsSession() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session=sqlSessionFactory.openSession();
return session;
}
}
Action
类名:HerosAction
package com.action;
import com.dao.HerosDao;
import com.dao.SeeionReturn;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.ibatis.session.SqlSession;
import java.io.IOException;
import java.util.List;
/**
* @author 羡羡
*/
public class HerosAction extends ActionSupport {
PageInfo pa;
int page=1;
public int getPage() {
return page;
}
public void setPage(int page) {
this.page = page;
}
public PageInfo getPa() {
return pa;
}
public void setPa(PageInfo pa) {
this.pa = pa;
}
public String show() throws IOException {
SqlSession session=SeeionReturn.getsSession();
HerosDao herdao=session.getMapper(HerosDao.class);
PageHelper.startPage(page,10);
List seall=herdao.seheall();
pa=new PageInfo(seall);
return SUCCESS;
}
}
界面
index.jsp
<%--
Created by IntelliJ IDEA.
User: 羡羡
Date: 2021/9/15
Time: 8:46
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>英雄列表</h1>
<table border='1px' cellspacing='0px' style="width: 800px;height: 600px">
<c:forEach items="${pa.list}" var="he">
<tr>
<td>${he.name}</td>
<td>${he.nickname}</td>
<td>${he.sex}</td>
<td>${he.first}</td>
<td><img src="herosimg/${he.img}"></td>
<td><a href="">编辑</a><a href="herde?id=${he.id}">删除</a></td>
</tr>
</c:forEach>
</table>
<a href="hershow?page=1">首页</a>
<a href="hershow?page=${pa.prePage}">上一页</a>
<c:forEach items="${pa.navigatepageNums}" var="p">
<a href="hershow?page=${p}">${p}</a>
</c:forEach>
<a href="hershow?page=${pa.nextPage}">下一页</a>
<a href="hershow?page=${pa.pages}">尾页</a>
</body>
</html>
访问:/action的name属性
这个访问就是:/hershow show是该Action下的一个方法
属性配置mybatis-config.xml 驼峰命名自增别名
<!--设置属性-->
<settings>
<!--开启驼峰命名法 数据库表一般字段名是 表名_字段名 驼峰命名法后 去掉下划线 下划线后面第一个字母大写-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
<!--获取主键自增-->
<setting name="useGeneratedKeys" value="true"/>
<!--使用列别名 替换列名-->
<setting name="useColumnLabel" value="true"/>
</settings>
返回一列
1、基本类型 :resultType=基本类型
2、List类型: resultType=List中元素的类型
3、Map类型 单条记录:resultType =map
多条记录:resultType =Map中value的类型
列:
dao
/**
* 查询所有的年份
* @return
*/
public List<String> findyear();
xml
<select id="findyear" resultType="java.lang.String">
SELECT date_format(b.createtime, '%Y') as year from article b GROUP BY year ORDER BY year DESC;
</select>
MyBatis总结~