mybatis笔记(超详细全面)
mybatis第二天课堂笔记高级映射 查询缓存 和spring整合
mybatis第二天高级映射查询缓存和spring整合课程复习:mybatis是什么?mybatis是一人持久层框架,mybatis是一个不完全的ORM框架。
sql语句需要程序员自己去编写,但是mybatis也有映射(输入参数映射、输出结果映射)。
mybatis入门门槛不高,学习成本低,让程序员把精力放在sql语句上,对sql语句优化非常方便,适用与需求变化较多项目,比如互联网项目。
mybatis框架执行过程:1、配置mybatis的配置文件,SqlMapConfig.xml(名称不固定)2、通过配置文件,加载mybatis运行环境,创建SqlSessionFactory会话工厂SqlSessionFactory在实际使用时按单例方式。
3、通过SqlSessionFactory创建SqlSessionSqlSession是一个面向用户接口(提供操作数据库方法),实现对象是线程不安全的,建议sqlSession应用场合在方法体内。
4、调用sqlSession的方法去操作数据。
如果需要提交事务,需要执行SqlSession的commit()方法。
5、释放资源,关闭SqlSessionmybatis开发dao的方法:1、原始dao 的方法需要程序员编写dao接口和实现类需要在dao实现类中注入一个SqlSessionFactory工厂。
2、mapper代理开发方法(建议使用)只需要程序员编写mapper接口(就是dao接口)程序员在编写mapper.xml(映射文件)和mapper.java需要遵循一个开发规范:1、mapper.xml中namespace就是mapper.java的类全路径。
2、mapper.xml中statement的id和mapper.java中方法名一致。
3、mapper.xml中statement的parameterType指定输入参数的类型和mapper.java的方法输入参数类型一致。
MyBatis核心技术全解与项目实战读书笔记
《MyBatis核心技术全解与项目实战》读书笔记1. 第一章 MyBatis简介本章主要介绍了MyBatis的基本概念、特点和优势,以及其在Java企业级应用开发中的重要作用。
MyBatis是一个优秀的持久层框架,它将SQL语句与Java对象映射(POJO)相结合,使得开发人员可以更加方便地操作数据库。
MyBatis的主要目标是简化数据库操作,提高开发效率,同时也提供了良好的数据封装和安全性。
SqlSessionFactory:用于创建SqlSession对象,SqlSession是MyBatis中执行SQL语句的核心接口。
SqlSession:用于执行SQL语句的会话对象,可以通过它来执行增删改查等操作。
Mapper:映射器接口,用于定义SQL语句和Java对象之间的映射关系。
Configuration:MyBatis的全局配置类,用于配置各种属性,如缓存策略、事务管理等。
插件:MyBatis的插件机制,允许开发者自定义拦截器、类型处理器等组件,以实现对MyBatis的功能扩展。
灵活性:MyBatis支持多种存储结构,如JDBC、ODBC、JNDI等,同时还支持自定义类型处理器和插件,使得MyBatis能够满足各种复杂的数据库操作需求。
易用性:MyBatis提供了简洁的XML映射文件来描述SQL语句和Java对象之间的映射关系,使得开发者无需编写复杂的SQL语句即可完成数据库操作。
性能优化:MyBatis通过一级缓存和二级缓存机制来提高查询性能,同时还支持动态SQL、分页查询等功能,使得MyBatis能够在高并发环境下保持良好的性能表现。
安全性:MyBatis提供了严格的权限控制机制,可以限制不同用户对数据库的操作权限,保证数据的安全性。
1.1 MyBatis概念及特点MyBatis是一个优秀的持久层框架,它支持定制化SQL、存储过程以及高级映射。
相比于传统的数据访问技术,MyBatis让开发者能够更加直接地与数据库交互,从而有效地避免了大量繁琐的SQL语句编写工作。
MyBatis框架思维导图笔记总结
<!-- 模糊查询 --> <select id="findLike" resultMap="userMap">
select * from user where user_name like "%"#{name}"%" </select>
<update id="updateUser"> update user set user_name=#{userName}, password=#{password} where id=#{id}
select last_insert_id() </selectKey> </insert>
<!-- select元素中指定resultType(找到与字段同名的属性名,赋值)或者 resultMap(用于字段和属性不一 致)-->
<select id="findUserById" ultMap="userMap"> select * from user where id = #{id}
PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"> <!-- namespace为唯一标识,映射器接口的全限定名 --> <mapper namespace="erMapper">
<insert id="insertUser" parameterType="er" useGeneratedKeys="true" keyProperty="id"> insert into user(id,username,password) values(#{id},#{userName},#{password})
mybatis笔记(超详细全面)
1.Mybatis入门从一个jdbc程序开始public static void main(String[] args) {Connection connection = null;PreparedStatement preparedStatement = null;ResultSet resultSet = null;try {//加载数据库驱动Class.forName("com.mysql.jdbc.Driver");//通过驱动管理类获取数据库链接connection =DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncod ing=utf-8", "root", "mysql");//定义sql语句 ?表示占位符String sql = "select * from user where username = ?";//获取预处理statementpreparedStatement = connection.prepareStatement(sql);//设置参数,第一个参数为sql语句中参数的序号(从1开始),第二个参数为设置的参数值preparedStatement.setString(1, "王五");//向数据库发出sql执行查询,查询出结果集resultSet = preparedStatement.executeQuery();//遍历查询结果集while(resultSet.next()){System.out.println(resultSet.getString("id")+""+resultSet.getString("username"));}} catch (Exception e) {e.printStackTrace();}finally{//释放资源if(resultSet!=null){try {resultSet.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if(preparedStatement!=null){try {preparedStatement.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if(connection!=null){try {connection.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}上边使用jdbc的原始方法(未经封装)实现了查询数据库表记录的操作。
MyBatis部分笔记
mybatis入门小结:mybatis一个半自动化的持久层框架(SQL抽取出来进行手动编写),支持定制化SQL。
1、接口式编程原生:Dao ==> DaoImplmybatis:Mapper ==> xxMapper.xml2、SqlSession代表和数据库的一次回话,用完就要关闭3、SqlSession和Connection一样是非线程安全的,不能写成员变量,每次使用都应该new新的对象4、mapper接口没有实现类,但是mybatis会为接口类型生成一个代理对象5、连个配置文件1)全局配置文件mybatis-config.xml:包含事务管理器,数据源等信息。
2)SQL映射文件:保存了每个SQL语句映射信息,唯一标识,返回结果类型等信息,通过这种方式将关键SQL语句抽取出来自己写。
<!-- 写好的映射文件一定要注册到全局mybatis-config.xml配置文件之间去--><mapper resource="EmployeeMapper.xml" />mybatis基本使用过程:1.得到sqlSessionFactory对象2.获取sqlSession对象3.获取接口的实现类对象会为接口自动创建一个代理对象,代理对象执行增删改查操作4.mapper的接口的方法每个线程都应该有它自己的SqlSession 实例。
SqlSession 的实例不能共享使用,它也是线程不安全的。
因此最佳的范围是请求或方法范围。
SqlSession 的实例不是线程安全的,因此是不能被共享的。
mybatis关于缓存?两级缓存:一级缓存:(本地缓存):sqlSession级别的缓存。
一级缓存是一直开启的;SqlSession级别的一个Map 与数据库同一次会话期间查询到的数据会放在本地缓存中。
以后如果需要获取相同的数据,直接从缓存中拿,没必要再去查询数据库;一级缓存失效情况(没有使用到当前一级缓存的情况,效果就是,还需要再向数据库发出查询):1、sqlSession不同。
mybatis第一天课堂笔记资料讲解
m y b a t i s第一天课堂笔记mybatis 第一天 mybatis的基础知识课程安排:mybatis和springmvc通过订单商品案例驱动第一天:基础知识(重点,内容量多)对原生态jdbc程序(单独使用jdbc开发)问题总结mybatis框架原理(掌握)mybatis入门程序用户的增、删、改、查mybatis开发dao两种方法:原始dao开发方法(程序需要编写dao接口和dao实现类)(掌握)mybaits的mapper接口(相当于dao接口)代理开发方法(掌握)mybatis配置文件SqlMapConfig.xmlmybatis核心:mybatis输入映射(掌握)mybatis输出映射(掌握)mybatis的动态sql(掌握)第二天:高级知识订单商品数据模型分析高级结果集映射(一对一、一对多、多对多)mybatis延迟加载mybatis查询缓存(一级缓存、二级缓存)mybaits和spring进行整合(掌握)mybatis逆向工程1对原生态jdbc程序中问题总结1.1环境java环境:jdk1.7.0_72eclipse:indigomysql:5.11.2创建mysql数据导入下边的脚本:sql_table.sql:记录表结构sql_data.sql:记录测试数据,在实际企业开发中,最后提供一个初始化数据脚本1.3jdbc程序使用jdbc查询mysql数据库中用户表的记录。
创建java工程,加入jar包:数据库驱动包(mysql5.1)上边的是mysql驱动。
下边的是oracle的驱动。
程序代码:1.4问题总结1、数据库连接,使用时就创建,不使用立即释放,对数据库进行频繁连接开启和关闭,造成数据库资源浪费,影响数据库性能。
设想:使用数据库连接池管理数据库连接。
2、将sql语句硬编码到java代码中,如果sql 语句修改,需要重新编译java代码,不利于系统维护。
设想:将sql语句配置在xml配置文件中,即使sql变化,不需要对java代码进行重新编译。
mybatis
关于MyBatis的笔记1.SQL的动态查询1. 动态sql动态sql是mybatis中的一个核心,什么是动态sql?动态sql即对sql语句进行灵活操作,通过表达式进行判断,对sql进行灵活拼接、组装。
就拿上一篇博文中对用户的综合查询一例来说:假如这个user是null咋整?或者user.sex或者ername为null呢?所以更严谨的做法应该是在执行这个语句之前要先进行判断才对,确保都不为空,那么我再去查询。
这就涉及到了mybatis中的动态sql了。
在mybatis中,动态sql可以使用标签来表示,这很类似于jstl表达式,我们可以将上面的sql语句改成动态sql,如下:上面的代码很好理解,主要就是加了一些判断,条件不为空,才进行查询条件的拼接,让mybatis动态的去执行。
那么在测试代码中,我们可以故意的将user.sex不赋初值,就可以看到查询的结果是不一样的。
2. sql片段那么现在还有个问题,如果好几个statement都需要这样做,而且动态sql 部分都一样,这就会导致一些代码的重复,所以如果遇到这种情况,我们就应该抽取,动态sql也可以抽取,我们可以将动态的这部分sql抽取成sql片段,然后在具体的statement中引用进来即可。
如下:id是给该sql片段起个名字而已,内部就是上面的where动态部分,然后我们将上面原来的动态部分改成对这个sql片段的引用,如下:3. foreach还有个问题:如果我们要向sql传递数组或List该咋整呢?mybatis使用的是foreach解析。
为了模拟这个场景,我们将上面的查询改成多个id查询,有两种查询方式:∙1∙2∙1∙2首先有一点很明确,既然要使用多个id进行查询,那么多个id肯定要作为参数传进来,所以存储多个id的List需要放到UserQueryVo中作为一个属性,这点很好理解,所以我们先在UserQueryVo中增加这个属性:然后我们修改UserMapper.xml中的sql片段(还是写在sql片段中),如下:下面简单介绍一下这个foreach中相关属性的作用:collection:指定输入对象中的集合属性,这里就是这个ids。
Parch系列 - MyBatis学习笔记
3,不使用 XML 构建 SqlSessionFactory
从 Java 程序而非 XML 文件中直接创建配置实例,或创建配置构建器: DataSource dataSource = BlogDataSourceFactory.getBlogDataSource(); TransactionFactory transactionFactory = new JdbcTransactionFactory(); Environment environment = new Environment("development", transactionFactory, dataSource);
(3)XML 配置文件介绍 XML 配置文件包含对 MyBatis 系统的核心设置,包含获取数据库连接实例的数据源和决定事务范
围和控制的事务管理器。 示例: <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN" &ig.dtd"> <configuration> <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> XML 头部的声明,需要用来验证 XML 文档正确性。environment 元素体中包含对事务管理和连
Mybatis知识点汇总
Mybatis知识点汇总MyBatis是一款优秀的持久层框架,它支持定制化SQL、存储过程以及高级映射。
MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。
MyBatis可以使用简单的XML或注解进行配置和原始映射,将接口和Java的POJOs (Plain Old Java Objects,普通的Java对象)映射成数据库中的记录。
以下是MyBatis的主要知识点汇总:1.基础概念:o SQL映射文件:MyBatis使用SQL映射文件(或称为Mapper文件)来定义SQL语句,每个映射文件对应数据库中的一张表。
o映射器:映射器是MyBatis的核心,它负责将方法调用映射到SQL语句,并且将结果集映射回Java对象。
o注解:MyBatis支持使用注解来配置SQL语句,这可以减少XML 配置的使用。
2.配置:o mybatis-config.xml:这是MyBatis的主配置文件,其中包含了数据源、事务管理器等信息。
o别名:MyBatis中可以使用别名来简化全限定类名,如使用别名可以使代码更简洁易读。
o配置元素:包括<settings>、<typeAliases>、<environments>等元素。
3.SQL映射:o select:用于执行查询语句,并返回结果集。
o insert:用于插入新的记录。
o update:用于更新已存在的记录。
o delete:用于删除记录。
4.结果映射:o resultMap:用于定义结果集的映射规则,可以将结果集的列映射到Java对象的属性。
o association:用于定义复合主键或是关联其他表的数据。
o collection:用于表示一个对象中有多个集合属性。
5.动态SQL:o if:用于判断条件是否满足,根据条件来决定是否执行某段SQL 语句。
o choose/when/otherwise:类似于Java中的switch语句,根据条件选择执行不同的SQL语句。
Mybatis学习笔记(详细)
Mybatis学习笔记(详细)介绍三层架构:视图层、业务逻辑层、持久层mybatis框架:执⾏数据库操作,完成对数据库的增删改查,封装了jdbcmapper映射,将表中数据转为⼀个Java对象,⼀个表对应⼀个接⼝Mybatis实战使⽤⽅式:直接获取SqlSession,根据sql id执⾏sql⾃定义dao接⼝实现类,使⽤接⼝实现类对象操作(会有⼤量重复代码)使⽤mybatis的代理对象:使⽤getMapper()获取dao对象,直接执⾏⽅法访问数据库。
mybatis框架使⽤步骤:定义实体类定义接⼝定义mapper⽂件定义主配置⽂件:1.数据源,2.mapper⽂件位置使⽤SqlSessionFactoryBuild创建SqlSessionFactory并传⼊xml配置⽂件,通过Factory创建SqlSession,通过SqlSession执⾏⼀系列数据库操作mybatis传递参数dao⽅法有⼀个简单类型,直接使⽤#{任意字符}多个参数:使⽤@Param("xx")指明xml解析的名字使⽤Java对象,mapper中使⽤对象的属性#和$的区别#是占位符,使⽤PreparedStatement执⾏sql,效率⾼表⽰列的值,⼀般放在等号右侧使⽤$是字符串连接,使⽤Statement,效率低,有sql注⼊的风险$⼀般是替换表名、列名mybatis封装sql的执⾏结果标签中的resultType,指明封装结果的对象,可以使⽤别名(需要定义,可以复⽤)标签中的resultMap,指明数据库列名与Java对象属性的对应关系(需要定义,可以复⽤),或者使⽤sql语句的as给列取别名like:直接使⽤#{xxx},传递参数给mapper动态sql<where>:⾥⾯是if,条件满⾜加⼊where,并去除多余的and,or等关键字<if>:如果条件满⾜,加⼊后⾯的sql语句<foreach>:list或arraymybatis主配置⽂件:配置项有顺序<properties resource=xxx>配置.properties:,使⽤${}引⽤<settings>中可以配置⽇志<typeAliases>配置别名:<typeAlias>给某个类型,<package>把⼀个包中的类作为别名(如果有名称相同的类会有冲突)<plugins>配置插件<environments>配置<dataSource>mapper⽂件的位置:<mapper resource>单个指定,<package name>指定某个包(要求名称与接⼝名相同,并在同⼀个包下)PageHelper分页插件加⼊依赖在执⾏查询前调⽤PageHelper的静态⽅法即可代码pom<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.bingmous</groupId><artifactId>mybatis</artifactId><version>1.0-SNAPSHOT</version><properties><piler.source>11</piler.source><piler.target>11</piler.target></properties><dependencies><!--mybatis依赖--><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.1</version></dependency><!--postgresql驱动--><dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId><version>42.2.19</version></dependency><!--mybatis分页插件--><dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId><version>5.2.1</version></dependency><!--其他开发插件--><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.20</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13</version><scope>test</scope></dependency></dependencies><build><!--把src⽬录下的⽂件复制到target⽬录--><resources><resource><directory>src/main/java</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource></resources></build></project>Mybatis主配置⽂件<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><!--读取别的地⽅的配置⽂件--><properties resource="jdbc.properties"></properties><!--全局配置--><settings><setting name="logImpl" value="STDOUT_LOGGING"/><!--加⼊⽇志配置,可以在控制台输出执⾏的sql--> </settings><!--定义别名1 指定某个类型2 指定某个包,该包下的类都是别名,不区分⼤⼩写(如果有名字相同的类则报错)建议不使⽤别名,使⽤全限定名--><typeAliases><!-- <typeAlias type="com.bingmous.beans.Student" alias="stu"></typeAlias>--><!-- <package name="com.bingmous.beans"/>--></typeAliases><!--使⽤page插件,在environments之前插⼊--><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="${jdbc.drive}"/><property name="url"value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/></dataSource></environment></environments><mappers><mapper resource="com/bingmous/dao/StudentDao.xml"/><!-- <mapper resource="mapper/StudentDao.xml"/>--><!--指定包下的所有接⼝注意:必须mapper名与dao名相同,且在同⼀个包下--><!-- <package name="com.bingmous.dao"/>--></mappers></configuration>jdbc配置⽂件jdbc.drive=org.postgresql.Driverjdbc.url=jdbc:postgresql://10.194.227.212:5432/zztestername=postgresjdbc.password=hik12345+操作student表的接⼝/*** 操作student表的接⼝* created by Bingmous on 2021/7/6 9:59*/public interface StudentDao {List<Student> selectStudents();//单个简单参数Student selectStudentById(Integer id);//多个简单参数List<Student> selectStudentByNameAndAge(@Param("name") String name, @Param("age") Integer age);//使⽤对象传递参数List<Student> selectStudentByNameAndAge2(Student student);//likeList<Student> selectStudentLike(String name);int insertStudent(Student student); //插⼊数据// List<Student> selectDynamicSQL(Student student);// List<Student> selectDynamicSQL(@Param("name") String name,// @Param("age") Integer age);List<Student> selectDynamicSQL(@Param("age") Integer age);List<Student> selectDynamicSQL2(ArrayList<Student> list);}对应的mybatis配置⽂件<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><!--⽂档约束⽂件--><!--namespace:命名空间,写表的Dao的全限定名select:执⾏select语句id:sql语句的唯⼀表⽰resultType:查询结果的类型--><mapper namespace="com.bingmous.dao.StudentDao"><!--1 使⽤resultMap指定列与java对象的对应关系(可以复⽤)2 sql语句中使⽤别名--><resultMap id="studentMap" type="com.bingmous.beans.Student"><id column="id" property="id"></id><!--主键--><result column="name" property="name"></result><!--⾮主键--><result column="email" property="email"></result><result column="age" property="age"></result></resultMap><select id="selectStudents" resultMap="studentMap">select id, name, email, age from student order by id</select><!--单个简单参数:可以不写--><select id="selectStudentById" resultType="com.bingmous.beans.Student">select id, name, email, age from student where id = #{id}</select><!--多个参数:使⽤@Param--><select id="selectStudentByNameAndAge" resultType="com.bingmous.beans.Student">select id, name, email, age from student where name = #{name} or age = #{age}</select><!--使⽤对象传递参数:使⽤对象的属性--><select id="selectStudentByNameAndAge2" resultType="com.bingmous.beans.Student">select id, name, email, age from student where name = #{name} or age = #{age}</select><select id="selectStudentLike" resultType="com.bingmous.beans.Student"><include refid="selectFragment"></include> where name like #{name}</select><insert id="insertStudent">insert into student(id, name, email, age)values (#{id}, #{name}, #{email}, #{age})</insert><!--动态sql--><select id="selectDynamicSQL" resultType="com.bingmous.beans.Student">select id, name, email, age from student<where><!-- <if test="name=''">/*null和""都会解析成空字符串*/id=1001</if>--><if test="age > 0">or age > 0</if></where></select><select id="selectDynamicSQL2" resultType="com.bingmous.beans.Student"><include refid="selectFragment"></include> where id in<foreach collection="list" item="stu" open="(" close=")" separator=",">#{stu.id}</foreach></select><!--sql⽚段,可以复⽤--><sql id="selectFragment">select id, name, email, age from student</sql></mapper>接⼝实现类测试/*** created by Bingmous on 2021/7/6 14:14*///public class StudentDaoImpl implements StudentDao {// @Override// public List<Student> selectStudents() {// SqlSession sqlSession = MybatisUtils.getSqlSession();// List<Student> list = sqlSession.selectList("com.bingmous.dao.StudentDao.selectStudents"); // mit();// sqlSession.close();// return list;// }//// @Override// public int insertStudent(Student student) {// SqlSession sqlSession = MybatisUtils.getSqlSession();// int nums = sqlSession.insert("com.bingmous.dao.StudentDao.insertStudent", student);// mit();// sqlSession.close();// return nums;// }////}获取连接的⼯具类/*** created by Bingmous on 2021/7/6 13:51*/public class MybatisUtils {private static SqlSessionFactory factory = null; //重量级对象,⼀个项⽬只有⼀份就可以了static {InputStream is = null;is = Resources.getResourceAsStream("mybatis.xml");factory = new SqlSessionFactoryBuilder().build(is);} catch (IOException e) {e.printStackTrace();}}//获取sessionpublic static SqlSession getSqlSession(){if (factory != null) {return factory.openSession();}return null;}}student实体类/*** created by Bingmous on 2021/7/6 9:56*/@Data@AllArgsConstructor@NoArgsConstructorpublic class Student {private Integer id;private String name;private String email;private Integer age;/*** 如果没有⽆参构造⽅法,Mybatis会调⽤全参构造⽅法* 如果没有⽆参,没有全参,会调⽤其他有参,但必须只有⼀个*/// public Student(Integer id, String name) {// this.id = id;// = name;// System.out.println("构造⽅法被调⽤了。
什么是Mybatis?最全的Mybatis知识点整合!
什么是Mybatis?最全的Mybatis知识点整合!什么是Mybatis?最全的Mybatis知识点整合!⼀、什么是Mybatis?MyBatis是⼀个半ORM(对象关系映射)框架,它内部封装了JDBC,开发时只需要关注SQL语句本⾝,不需要花费精⼒去加载驱动、创建连接、创建Statement等繁杂过程。
程序员直接编写原⽣态sql,可以严格控制sql执⾏性能,灵活度⾼。
Mybatis可以使⽤XML或注解来配置和映射原⽣信息,将POJO映射成数据库中的记录,避免⼏乎所有JDBC代码和⼿动设置参数以及获得结果集。
通过xml⽂件或注解的⽅式将要执⾏的各种statement配置起来,并通过java对象和statement中sql的动态参数进⾏映射⽣成最终执⾏的sql语句,最后由Mybatis框架执⾏sql并将返回结果映射为java对象并返回。
(从执⾏sql到返回result的过程)。
⼆、Mybatis的优点基于SQL语句编程,相当灵活,不会对应⽤程序或者数据库的现有设计造成任何影响,SQL写在XML⽂件中,接触SQL与程序代码的耦合,便于统⼀管理;提供XML便签,⽀持编写动态SQL语句,并可以重⽤。
与JDBC相⽐,减少了50%以上的代码量,消除了JDBC⼤量冗余的代码,不需要⼿动开关连接。
很好的与各种数据库兼容(因为MyBatis使⽤JDBC来连接数据,所以只要JDBC⽀持数据库MyBatis都⽀持)。
能够与Spring框架很好的集成。
提供映射标签,⽀持对象与数据库的ORM字段关系映射;提供对象关系映射标签,⽀持对象关系组件维护。
三、Mybatis框架的缺点SQL语句的编写⼯作量较⼤,尤其当字段多,关联表多时,对开发⼈员编写SQL语句的功底有⼀定要求。
SQL语句依赖数据库,导致数据库移植性差,不能随意更换数据库。
四、MyBatis框架使⽤场合MyBatis专注于SQL本⾝,是⼀个⾜够灵活的DAO层解决⽅案。
MyBatis笔记:获取自增主键的值(Mysql)和非自增主键(Oracle)
MyBatis笔记:获取⾃增主键的值(Mysql)和⾮⾃增主键(Oracle)获取⾃增主键的值mysql⽀持⾃增主键,⾃增主键值得获取,mybatis也是利⽤statement.getGenreatedKeys()useGeneratedKeys="true":使⽤⾃增主键获取主键值策略KeyProperty:指定对应的主键属性,也就是mybatis获取到主键值以后,将这个值封装给javaBean的哪个属性例:如果没写:useGeneratedKeys="true" keyProperty="id",我们是获取不到id的值的<insert id="addEmp" parameterType="com.yorkmass.mybatis.bean.Employee"useGeneratedKeys="true" keyProperty="id">insert into tbl_employee(last_name,email,gender)value(#{lastName},#{email},#{gender})</insert>添加之后可t通过如下⽅式获取主键的值://测试添加Employee employee=new Employee(null,"jerry","150********@","1");mapper.addEmp(employee);System.out.println(employee.getId());获取⾮⾃增主键的值Oracle不⽀持⾃增;Oracle使⽤序列来模拟⾃增;每次插⼊的数据的主键是从序列中拿到的值;如何获取到这个值;<insert id="addEmp" databaseId="oracle"><!-- 插⼊时的主键是从序列中拿到的 --><!--KeyProperty:查出的主键值封装给javaBean的那个属性order="BEFORE":当前sql在插⼊sql之前运⾏AFTER:当前sql在插⼊sql之后运⾏resultType:查出的数据的返回值类型BEFORE运⾏顺序:先运⾏selectKey查询id的sql;查出id值封装给javaBean的id属性再运⾏插⼊的sql;就可以去除id属性对应的值AFTER运⾏顺序:先运⾏插⼊的sql(从序列中取出新值作为id);然后再运⾏selectKey查询id的sql;推荐使⽤BEFORE的⽅式--><!--BEFORE:--><selectKey keyProperty="id" order="BEFORE" resultType="Integer"><!-- 编写查询主键的sql语句 -->select EMPLOYEES_SEQ.nextval from dual</selectKey>insert into employee(EMPLOYEE_ID,LAST_NAME,EMAIL)values(#{id},#{lastName},#{email})<!-- 插⼊时的主键是从序列中拿到的,⽰例的id就是从序列中拿到的 --><!-- <selectKey keyProperty="id" order="AFTER" resultType="Integer">--><!-- 编写查询主键的sql语句 --><!-- 获取当前主键值 --><!--select EMPLOYEES_SEQ.currval from dual--><!--</selectKey>insert into employee(EMPLOYEE_ID,LAST_NAME,EMAIL)values(EMPLOYEES_SEQ.nextval,#{lastName},#{email})--></insert>结果就是能得到⽰例中id的值。
MyBatis学习笔记(动力节点学习的)
MyBatis学习笔记(动⼒节点学习的)MyBatis框架什么是框架框架定义框架(Framework)是整个或部分系统的可重⽤设计,表现为⼀组抽象构件及构件实例间交互的⽅法;另⼀种认为,框架是可被应⽤开发者定制的应⽤⾻架、模板。
简单的说,框架其实是半成品软件,就是⼀组组件,供你使⽤完成你⾃⼰的系统。
从另⼀个⾓度来说框架⼀个舞台,你在舞台上做表演。
在框架基础上加⼊你要完成的功能。
框架安全的,可复⽤的,不断升级的软件。
框架解决的问题框架要解决的最重要的⼀个问题是技术整合,在 J2EE 的框架中,有着各种各样的技术,不同的应⽤,系统使⽤不同的技术解决问题。
需要从 J2EE 中选择不同的技术,⽽技术⾃⾝的复杂性,有导致更⼤的风险。
企业在开发软件项⽬时,主要⽬的是解决业务问题。
即要求企业负责技术本⾝,⼜要求解决业务问题。
这是⼤多数企业不能完成的。
框架把相关的技术融合在⼀起,企业开发可以集中在业务领域⽅⾯。
另⼀个⽅⾯可以提供开发的效率。
常⽤框架介绍MyBatis框架MyBatis 是⼀个优秀的基于 java 的持久层框架,内部封装了 jdbc,开发者只需要关注 sql 语句本⾝,⽽不需要处理加载驱动、创建连接、创建 statement、关闭连接,资源等繁杂的过程。
MyBatis 通过 xml 或注解两种⽅式将要执⾏的各种 sql 语句配置起来,并通过java 对象和sql 的动态参数进⾏映射⽣成最终执⾏的 sql 语句,最后由 mybatis 框架执⾏ sql 并将结果映射为 java 对象并返回。
MyBatis 本是 apache 的⼀个开源项⽬ iBatis, 2010 年这个项⽬由 apache software foundation 迁移到了 google code,并且改名为 MyBatis 。
2013 年 11 ⽉迁移到 Github。
iBATIS ⼀词来源于“internet”和“abatis”的组合,是⼀个基于 Java 的持久层框架。
java_MyBatis知识点总结
MyBatis 学习mybatis入门Example:第一步:建立java工程第二步:导入jar包第三步:编写配置文件①.sqlMapConfig.xml②.jdbc.properties及log4j.properties(略)④.编写javabean类(略)⑥.运行结果2014-05-19 01:16:49,657 [main] DEBUG [cn.itcast.Person.selectPerson] - ==> Preparing: select * from person where id = ?2014-05-19 01:16:49,677 [main] DEBUG [cn.itcast.Person.selectPerson] - ==> Parameters: 1(Integer)Person [id=1, name=张无忌, birthday=Mon May 12 00:00:00 CST 2014, address=陕西, salary=2312]发现运行成功,sql语句生成成功。
注意:javabean没有set,get方法,也能注入值成功Mybatis的简单查询第一:javabean可以和数据库字段不一致,不一致时需要在配置文件指明数据表如下:发现字段使用了下划线:javabean属性命名必须遵循驼峰模式那么现在我使用上面的Test进行查询时:(查询前:把select * from person where person_id = #{id} 修改为数据库字段)查询结果:Person [personId=null, name=张无忌, birthday=Mon May 12 00:00:00 CST 2014, personAddress=null, salary=2312]我们发现:personId和personAddress都为null,而其他的全部有值。
可以发现:他们的值没有匹配上,即数据库的字段和javabean的字段不匹配。
My batis使用笔记
My batis使用笔记一、搭建Mybatis环境1、mybatis相应的jar包加入到项目中,详情见pom.xml2、把mybatis-config.xml主配置文件放入项目中的classPath路径3、编写一个model类,Person类4、编写dao层接口PersonDao,编写dao层映射文件,PersonDao5、把映射文件加入到主配置文件6、把log4j.properties文件放入到项目中的classPath路径,日志级别设置成debug,不然不会显示SQL语句7、编写mybatis API进行测试二、jdbcType取值java类型jdbcTypeint INTEGERfloat FLOATdouble DOUBLEString(固定长度)CHACHARRString(实际长度)VARDate(年月日)DATEDate(年月日时分秒)TIMESTAMP三、parameterType、parameterMap、resultType、resultMapparameterType属性:参数类型,一般写类的完整路径parameterMap属性:参数映射,参数类的属性名与SQL语句中#{变量}不一样时,需要映射resultType属性:结果集类型,查询结果集中的字段名与结果集类中的属性名相同,就可以使用resultMap属性:结果集映射,把结果集与类中的属性一一对应,一个类对应一个结果集,一个属性对应一个结果集字段四、一级缓存*****1、什么是一级缓存SqlSessionFactory创建SQLSession是分配的一片内存空间,用来缓存查询过的数据,SQLSession管理,又称为:session缓存2、生命周期SqlSessionFactory创建SQLSession一级缓存被分配,SQLSession被close()时,一级缓存被回收3、一级缓存的特点*****a、一级缓存,默认是开启的,直接使用,b、session与session之间不能共享c、一级缓存只认相同的SQL语句,缓存的不是对象,相同的SQL语句只会发一次d、添加、修改、的数据不会在一级缓存中,再次查询还是会发生SQL语句e、一级缓存由session管理,通过session.clearCache()方法清除缓存1、hibernate一级缓存存的是单个对象,mybatis存的是一组数据2、hibernate查询首先会在一级缓存中拿,如果没有就发送SQL语句到数据库查询mybatis只认相同的SQL语句,将数据存入一级缓存的SQL语句如果与将要执行的SQL语句相同,就直接调用一级缓存里面的数据,不再发送SQL语句,如果不同将发送SQL 查询,mybatis只认相同的SQL语句3、hibernate中被session操作过的对象,一定会存一份到一级缓存中,除非是session被清除或关闭mybatis添加、修改、的数据不会在一级缓存中4、hibernate中关闭或清除缓存有4种方式sessio.close()、sessio.clear()、sessio.evict(Object)、sessio.flush() mybatis中关闭或清除缓存只有2种方式SqlSession.close(),SqlSession.clear();五、多表映射*****1、对方是一,在resultMap标签中使用<association></association>标签association标签常用属性:deptid属性:类中外键属性column属性:外键字段resultMap属性:指向外键类的映射2、对方是多,在resultMap标签中使用标签<collection></collection>标签collection标签常用属性:property属性:另一端在本类中的属性名esultMap属性:执行另一个类的结果集映射六、延迟加载(了解)1、在mybatis-config.xml中配置开启懒加载,配置如下<!--设置信息--><settings><!--开启或关闭延迟加载--><setting name="lazyLoadingEnabled" value="true"/><!--支持延迟加载,在需要时加载外表,为true加载本表也会加载外表--><setting name="aggressiveLazyLoading" value="false"/></settings>2、在多表映射时、关联表的标签使用select属性,不要使用resultMap属性<association property="deptid" column="f_departId" select="findDeparById"/><collection property="emps" select=""/>3、select属性中写一个方法的名字,关联对应表时会执行方法对应的SQL语句,如下:dao接口:public Depart findDeparById(int depId);mapper.xml<select id="findDeparById" resultMap="departMap">select t.f_id as f_dapartId,t.f_name as f_depName from t_depart t where t.f_id=#{depId}</select>七、#{}与${}的区别*****1、#{}是预编译的,${}是字符串替换字符2、#{}处理时使用?代替,PreparedStatement的set方法来赋值${}处理时替换成变量的值3、#{}可以防止sql语句注入,安全性高${}是字符串替换符,会造成SQL语句注入,不安全八、mybatis一级缓存与hibernate一级缓存相同点与不同点相同点:1、一级缓存都是默认开启自动死亡2、一级缓存都是session级别,由session管理3、生命周期一样,session被创建时分配一级缓存空间,session被close时一级缓存被回收4、session与session之间不能共享一级缓存5、查询时都会以一级缓存优先,一级缓存中没有才发送SQL语句到数据库查询不同点:1、hibernate一级缓存缓存的是session操作过的对象,如果查询一组数据也是拆成单个对象存储在一级缓存中mybatis一级缓存,缓存的是查询过的数据映射对象,相同的SQL只会查询一次2、hibernate一级缓存insert 、update、delectable、select操作过的对象都会在一级缓存中存储一份mybatis只有selete操作过的数据会在一级缓存中存储一份3、hibernate一级缓存不受事务影响,事务提交或回滚都不影响一级缓存中存储的对象mybatis一级缓存受事务影响,事务提交或回滚会清除一级缓存4、hibernate管理缓存方式:close回收一级缓存clear清除一级缓存evict清除单个对象flush刷新一级缓存,同步一级缓存与数据库mybatis管理缓存方式:close回收一级缓存clearCache清除一级缓存。
mybatis学习笔记1
第一章回顾jdbc开发1)优点:简单易学,上手快,非常灵活构建SQL,效率高2)缺点:代码繁琐,难以写出高质量的代码(例如:资源的释放,SQL注入安全性等)开发者既要写业务逻辑,又要写对象的创建和销毁,必须管底层具体数据库的语法(例如:分页)。
3)适合于超大批量数据的操作,速度快第二章回顾hibernate单表开发1)优点:不用写SQL,完全以面向对象的方式设计和访问,不用管底层具体数据库的语法,(例如:分页)便于理解。
2)缺点:处理复杂业务时,灵活度差, 复杂的HQL难写难理解,例如多表查询的HQL语句3)适合于中小批量数据的操作,速度慢第三章什么是mybatis,mybatis有什么特点1)基于上述二种支持,我们需要在中间找到一个平衡点呢?结合它们的优点,摒弃它们的缺点,这就是myBatis,现今myBatis被广泛的企业所采用。
2)MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。
2013年11月迁移到Github。
3)iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。
iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO)4)jdbc/dbutils/springdao,hibernate/springorm,mybaits同属于ORM解决方案之一第四章mybatis快速入门1)创建一个mybatis-day01这么一个javaweb工程或java工程2345678第五章mybatis工作流程1)通过Reader对象读取src目录下的mybatis.xml配置文件(该文本的位置和名字可任意) 2)通过SqlSessionFactoryBuilder对象创建SqlSessionFactory对象3)从当前线程中获取SqlSession对象4)事务开始,在mybatis中默认5)通过SqlSession对象读取StudentMapper.xml映射文件中的操作编号,从而读取sql语句6)事务提交,必写7)关闭SqlSession对象,并且分开当前线程与SqlSession对象,让GC尽早回收第六章mybatis配置文件祥解(mybatis.xml)1第七章mybatis映射文件祥解(StudentMapper.xml)1)以下是mybatis.xml文件,提倡放在src目录下,文件名任意第八章MybatisUtil工具类的作用1)在静态初始化块中加载mybatis配置文件和StudentMapper.xml文件一次2)使用ThreadLocal对象让当前线程与SqlSession对象绑定在一起3)获取当前线程中的SqlSession对象,如果没有的话,从SqlSessionFactory对象中获取SqlSession对象4第九章基于MybatisUtil工具类,完成CURD操作12第十章分页查询12第十一章动态SQL操作之查询1)查询条件不确定,需要根据情况产生SQL语法,这种情况叫动态SQL 2)参见<<动态SQL—查询.JPG>>第十二章动态SQL操作之更新1)更新条件不确定,需要根据情况产生SQL语法,这种情况叫动态SQL 2)参见<<动态SQL—更新.JPG>>第十三章动态SQL操作之删除1)根据ID删除学生2)参见<<动态SQL—删除.JPG>>第十四章动态SQL操作之插入1)根据条件,插入一个学生2)参见<<动态SQL—插入.JPG>>第十五章jsp/js/jquery/easyui/json + @springmvc + spring + mybatis + oracle开发【员工管理系统--增加员工】。
Mybatis-Plus实战完整学习笔记(九)------条件构造器核心用法大全(上)
Mybatis-Plus实战完整学习笔记(九)------条件构造器核⼼⽤法⼤全(上)⼀、Mybatisplus通⽤(公共⽅法)CRUD,⼀共17种(3.0.3版),2.3系列也是这么多,这个新版本⼀定程度进⾏了改造和删减。
⼆、构造器UML图(3.0.3)-----实体包装器,主要⽤于处理 sql 拼接,排序,实体参数查询等1. 注意: 使⽤的是数据库字段,不是 Java 属性!总体就是⼊上图的样式的结构,主要使⽤QueryWrapper 和UpdateWrapper,JDK1.8使⽤LambdaQueryWrapper和LambdaUpdateWrapper 注意2.3版本使⽤的是EntityWrapper实现条件构造器,这⾥将阐述和说明构造器拼接的⽅法实战演练:(3.0.3版)1、全部查询,拼接⼀个where过滤条件1 @Test2 public void selectWrapper() throws SQLException {345 // 条件构造器使⽤67 // 1、全部查询,拼接⼀个where过滤条件,如果是多个可以map中put多个,多个字段如果有某个字段是空的,就会默认添加空查询条件8 // SELECT id,last_name,email,gender,age FROM tbl_employee WHERE gender = ? AND age IS NULL9 Employee employee = new Employee();10 employee.setGender(1);1112 Map<String,Object> map = new HashMap<>(16);13 map.put("gender",employee.getGender());14 map.put("age",employee.getAge());1516 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().allEq(map));171819 if (!employeeList.isEmpty()) {20 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));21 }22 }View Code注意2.3版本的可以⽤EntityWrapper代替QureyWrapper,其他写法⼀样2、map添加的字段是否加到where的条件中1 @Test2 public void selectWrapper() throws SQLException {345 // 条件构造器使⽤6 Map<String,Object> map = new HashMap<>(16);7 map.put("gender",employee.getGender());8 map.put("age",employee.getAge());910 // 2、map添加的字段是否加到where的条件中,通过lambda表达式判断,如果是true就加⼊,反之,不加⼊,因为Map的key的String有gender,所以会过滤11 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().allEq((String,Object)->String.equals("gender"),map));121314 if (!employeeList.isEmpty()) {15 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));16 }17 }View Code3、and使⽤1 @Test2 public void selectWrapper() throws SQLException {34 // 条件构造器使⽤5 // 3、and使⽤67 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().and(i -> i.eq("last_name", "Betty0")));89 if (!employeeList.isEmpty()) {10 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));11 }View Code相当于SQL语句SELECT id,last_name,email,gender,age FROM tbl_employee WHERE ( last_name = ? )and前会有⼀个condition,判别是否加⼊到sql语句中的条件,默认是trueList<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().and(true,i -> i.eq("last_name", "Betty0")));4、apply拼接条件使⽤1 4、apply使⽤2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().apply("last_name='Betty0'"));345 if (!employeeList.isEmpty()) {6 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));7 }View Code外部参数调⽤的话List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().apply("last_name= {0}","Betty0"));5、between使⽤⽅法1 5、between2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().between("age",20,50));34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code6、eq 等于 =1 6、eq 充当and使⽤2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().eq("last_name","Betty0"));34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code7、ge⼤于等于 >=1 7、ge⼤于等于23 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().ge("age","40"));456 if (!employeeList.isEmpty()) {7 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));8 }View Code8、gt⼤于1 // 8 、gt ⼤于2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().gt("age","40"));34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code9、分组操作1 // 9、分组操作2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().eq("id","25").groupBy("age","gender")); 34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code10、having使⽤1 10、having使⽤2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().eq("gender","1").having("age = {0}",30)); 34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code11、in使⽤1 // 11、in 操作2 List<Integer> idList = new ArrayList<>();3 idList.add(31);4 idList.add(32);56 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().in(true,"id",idList));7 if (!employeeList.isEmpty()) {8 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));9 }View Code12、inSql使⽤1 12、inSql使⽤2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().inSql("id", "12,22,23,24,25,26"));3 if (!employeeList.isEmpty()) {4 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));5 }View Code13、isNotNull字段值⾮空1 13、字段值⾮空2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().isNotNull("age"));34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code14、字段值为空的1 14、字段值为空的2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().isNull("age"));34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code15、结尾拼接sql语句,存在Sql注⼊风险,不建议使⽤1 15、结尾拼接sql语句2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().last("and age >30"));345 if (!employeeList.isEmpty()) {6 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));7 }View Code16、⼩于等于 <=1 16、⼩于等于 <=2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().le("age", "20"));34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code17、⼩于1 17、⼩于2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().lt("age", "20"));345 if (!employeeList.isEmpty()) {6 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));7 }View Code18、模糊查询1 18、模糊查询2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().like("age", "20"));345 if (!employeeList.isEmpty()) {6 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));7 }View Code19、LikeLeft以什么结尾的查询1 19、 LikeLeft以什么结尾的查询2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().likeLeft("age", "20"));345 if (!employeeList.isEmpty()) {6 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));7 }View Code20、likeRight以什么开头1 20、likeRight以什么开头2 // List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().likeRight("age", "20"));34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code21、ne不等于 <>⽤法1 21、ne不等于 <>⽤法2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().ne("age", "20"));345 if (!employeeList.isEmpty()) {6 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));7 }View Code22、嵌套的查询1 22、嵌套的查询2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().nested(true,i -> i.eq("last_name", "Betty0")));3456 if (!employeeList.isEmpty()) {7 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));8 }View Code23、不在什么区间1 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().notBetween("age",20,50));23 if (!employeeList.isEmpty()) {4 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));5 }View Code24、不存在notexist1 24、不存在2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().notExists("select id from tbl_employee where age = 1")); 34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code25、存在exist1 25、存在2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().exists("select id from tbl_employee where age = 12")); 345 if (!employeeList.isEmpty()) {6 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));7 }View Code26、not in 不在区间内1 List<Integer> idList = new ArrayList<>();2 idList.add(31);3 idList.add(32);4 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().notIn("id",idList));56 if (!employeeList.isEmpty()) {7 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));8 }View Code27、notSQL 不在区间内1 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().notInSql("id","12,22"));234 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code28、notLike 模糊查询没有这个关键字1 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().notLike("age", "2"));23 if (!employeeList.isEmpty()) {4 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));5 }View Code29、orderBy根据字段升序还是降序排序1 29、orderBy根据字段升序还是降序排序2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().orderBy(true, false, "age"));345 if (!employeeList.isEmpty()) {6 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));7 }View Code30、or或者1 30、or或者2 List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().eq("id","25").or().eq("gender","1")); 34 if (!employeeList.isEmpty()) {5 ("++条件构造器查询员⼯信息+++++" + gson.toJson(employeeList));6 }View Code。
MyBatis第二天课堂笔记
1MyBatis第二天课堂笔记2输入映射和输出映射2.1parameterType(输入类型)2.1.1传递简单类型参考第一天内容2.1.2传递pojo对象参考第一天内容Mybatis使用ognl表达式解析对象字段的值,#{}或者${}括号中的值为pojo属性名称。
2.1.3传递pojo包装对象1. 新建包装pojo对象QueryVo/*** 包装pojo* @author Steven*/public class QueryVo {//用户对象private User user;public User getUser() {return user;}public void setUser(User user) {er = user;}}2. 映射文件与sql<!-- 1、resultType:如果要返回数据集合,只需设定为每一个元素的数据类型2、包装的pojo取值通过 "."来获取--><select id="getUserByQueryVo"parameterType="queryvo"resultType="er"><!-- SELECT * FROM USER WHERE username LIKE #{name} -->SELECT * FROM USER WHERE username LIKE '%${ername}%' </select>3. 新增接口方法4. 增加测试方法,完成测试2.2resultType(输出类型)2.2.1输出简单类型<!-- 查询用户总记录数,演示返回简单类型 --><select id="getUserCount"resultType="int">SELECT COUNT(1) FROM USER</select>其它步骤跟前面类似,添加接口方法与测试方法,完成测试。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1.Mybatis入门从一个jdbc程序开始public static void main(String[] args) {Connection connection = null;PreparedStatement preparedStatement = null;ResultSet resultSet = null;try {//加载数据库驱动Class.forName("com.mysql.jdbc.Driver");//通过驱动管理类获取数据库链接connection =DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?charac terEncoding=utf-8", "root", "mysql");//定义sql语句 ?表示占位符String sql = "select * from user where username = ?";//获取预处理statementpreparedStatement = connection.prepareStatement(sql);//设置参数,第一个参数为sql语句中参数的序号(从1开始),第二个参数为设置的参数值preparedStatement.setString(1, "王五");//向数据库发出sql执行查询,查询出结果集resultSet = preparedStatement.executeQuery();//遍历查询结果集while(resultSet.next()){System.out.println(resultSet.getString("id")+""+resultSet.getString("username"));}} catch (Exception e) {e.printStackTrace();}finally{//释放资源if(resultSet!=null){try {resultSet.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if(preparedStatement!=null){try {preparedStatement.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if(connection!=null){try {connection.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}上边使用jdbc的原始方法(未经封装)实现了查询数据库表记录的操作。
jdbc操作步骤总结如下:1、加载数据库驱动2、创建并获取数据库链接3、创建jdbc statement对象4、设置sql语句5、设置sql语句中的参数(使用preparedStatement)6、通过statement执行sql并获取结果7、对sql执行结果进行解析处理8、释放资源(resultSet、preparedstatement、connection)jdbc问题总结如下:1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能,如果使用数据库链接池可解决此问题。
2、Sql语句写在代码中造成代码不易维护,实际应用sql变化的可能较大,sql变动需要改变java代码。
3、向sql语句传参数麻烦,因为sql语句的where条件不一定,可能多也可能少,占位符需要和参数一一对应。
4、对结果集解析麻烦,sql变化导致解析代码变化,且解析前需要遍历,如果能将数据库记录封装成pojo对象解析比较方便。
MyBatis介绍MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis。
MyBatis是一个优秀的持久层框架,它对jdbc的操作数据库的过程进行封装,使开发者只需要关注 SQL 本身,而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
Mybatis通过xml或注解的方式将要执行的statement配置起来,并通过java对象和statement中的sql进行映射生成最终执行的sql语句,最后由mybatis框架执行sql并将结果映射成java对象并返回。
Mybatis架构1、mybatis配置SqlMapConfig.xml,此文件作为mybatis的全局配置文件,配置了mybatis的运行环境等信息。
mapper.xml文件即sql映射文件,文件中配置了操作数据库的sql语句。
此文件需要在SqlMapConfig.xml中加载。
2、通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂3、由会话工厂创建sqlSession即会话,操作数据库需要通过sqlSession进行。
4、mybatis底层自定义了Executor接口操作数据库,Executor接口有两个实现,一个是基本实现、一个是缓存实现。
5、Mapped Statement也是mybatis一个底层对象,它包装了mybatis配置信息及sql映射信息等。
mapper.xml文件中一个sql对应一个Mapped Statement对象,sql的id即是Mapped statement的id。
6、Mapped Statement对sql执行输入参数进行定义,包括HashMap、基本类型、pojo,Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中,输入参数映射就是jdbc编程中对preparedStatement设置参数。
7、Mapped Statement对sql执行输出结果进行定义,包括HashMap、基本类型、pojo,Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中,输出结果映射过程相当于jdbc编程中对结果的解析处理过程。
Mybatis第一个程序第一步:创建JAVA工程使用eclipse创建java工程,jdk使用1.6。
第二步:加入jar包加入mybatis核心包、依赖包、数据驱动包。
第三步:log4j.properties在classpath下创建log4j.properties如下:# Global logging configurationlog4j.rootLogger=DEBUG, stdout# Console output...log4j.appender.stdout=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%5p [%t] - %m%nmybatis默认使用log4j作为输出日志信息。
第四步:SqlMapConfig.xml在classpath下创建SqlMapConfig.xml,如下:<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE configurationPUBLIC"-////DTD Config 3.0//EN"""><configuration><!-- <properties resource=""></properties> --><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?characterEncoding=utf-8"/> <property name="username"value="root"/><property name="password"value="mysql"/></dataSource></environment></environments></configuration>SqlMapConfig.xml是mybatis核心配置文件,上边文件的配置内容为数据源、事务管理。
第五步:po类Po类作为mybatis进行sql映射使用,po类通常与数据库表对应,User.java如下:public class User {private int id;private String username;// 用户姓名private String sex;// 性别private Date birthday;// 出生日期private String address;// 地址private String detail;// 详细信息private Float score;// 成绩get/set……第六步:sql映射文件在classpath下的sqlmap目录下创建sql映射文件User.xml:<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE mapperPUBLIC"-////DTD Mapper 3.0//EN"""><mapper namespace="test"><!-- 根据id获取用户信息 --><select id="selectUserById"parameterType="int"resultType="er">select * from user where id = #{id}</select><!-- 获取用户列表 --><select id="selectUserList"resultType="er"> select * from user</select><!-- 添加用戶 --><insert id="insertUser"parameterType="er"> insert into user(username,birthday,sex,address,detail,score)values(#{username},#{birthday},#{sex},#{address},#{detail},#{score});</insert><!-- 更新用戶 --><update id="updateUser"parameterType="er">update user setusername=#{username},birthday=#{birthday},sex=#{sex},address=#{address} ,detail=#{detail},score=#{score}where id=#{id}</update><!-- 刪除用戶 --><delete id="deleteUser"parameterType="er"> delete from user where id=#{id}</delete></mapper>namespace :命名空间,用于隔离sql语句,后面会讲另一层非常重要的作用。