学习目标
第一章-框架概述
知识点-框架概述
1.目标
2.路径
- 什么是框架
- 框架要解决的问题
3.讲解
3.1 什么是框架
框架(Framework)是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种定义认为,框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。
简而言之,框架是软件(系统)的半成品,框架封装了很多的细节,使开发者可以使用简单的方式实现功能,大大提高开发效率。
一句话解释: 框架其实就是一套模板,或者可重用的设计,套路。按照这种套路来写代码。尤其是在开发大型项目上,框架的作用体现得就更加淋漓尽致。小型项目,没有框架的用武之地。!
3.2 框架要解决的问题
框架要解决的最重要的一个问题是技术整合的问题,在 JAVA EE 的 框架中,有着各种各样的技术,不同的软件企业需要从J2EE 中选择不同的技术,这就使得软件企业最终的应用依赖于这些技术,技术自身的复杂性和技术的风险性将会直接对应用造成冲击。而应用是软件企业的核心,是竞争力的关键所在,因此应该将应用自身的设计和具体的实现技术解耦。这样,软件企业的研发将集中在应用的设计上,而不是具体的技术实现,技术实现是应用的底层支撑,它不应该直接对应用产生影响。
框架一般处在低层应用平台(如 J2EE)和高层业务逻辑之间的中间层。
代码是要分层,项目要分层,每一层的代码需要进行交互,对话。
4.小结
- 框架: 软件的半成品. 我们开发者使用框架开发, 更加的简单, 提高开发效率
- 学框架就是学套路,先把套路学会了,再去思考,这种套路(框架)背后的核心。
- SSM框架
知识点-MyBatis框架概述
1.目标
2.路径
- jdbc 程序回顾
- MyBatis框架概述
3.讲解
3.1jdbc 程序回顾
3.1.1程序回顾
- 注册驱动
- 获得连接
- 创建预编译sql语句对象
- 设置参数, 执行
- 处理结果
- 释放资源
public static void main(String[] args) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
//1.加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//2.通过驱动管理类获取数据库链接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "123456");
//3.定义 sql 语句 ?表示占位符
String sql = "select name from user where username = ?";
//4.获取预处理 statement
preparedStatement = connection.prepareStatement(sql);
//5.设置参数,第一个参数为 sql 语句中参数的序号(从 1 开始),第二个参数为设置的参数值
preparedStatement.setString(1, "王五");
//6.向数据库发出 sql 执行查询,查询出结果集
resultSet = preparedStatement.executeQuery();
//7.遍历查询结果集
while (resultSet.next()) {
System.out.println(resultSet.getString("id") + "
"+resultSet.getString(" username"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//8.释放资源
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (preparedStatement != null) {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
3.1.2 jdbc 问题分析
- 数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能,如果使用数据库链接池可解决此问题。
- Sql 语句在代码中硬编码,造成代码不易维护,实际应用 sql 变化的可能较大, sql 变动需要改变java 代码。
- 使用 preparedStatement 向占有位符号传参数存在硬编码,因为 sql 语句的 where 条件不一定,可能多也可能少,修改 sql 还要修改代码,系统不易维护。
- 对结果集解析存在硬编码(查询列名), sql 变化导致解析代码变化,系统不易维护,如果能将数据库记录封装成 pojo 对象解析比较方便
3.2MyBatis框架概述
mybatis 是一个优秀的基于 java 的持久层框架,它内部封装了 jdbc,使开发者只需要关注 sql 语句本身,而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。
mybatis 通过xml 或注解的方式将执行的各种statement 配置起来,并通过java 对象和statement 中sql的动态参数进行映射生成最终执行的 sql 语句,最后由 mybatis 框架执行 sql并将结果映射为 java 对象并返回。采用 ORM ( Object relational mapping)思想解决了实体和数据库映射的问题,对jdbc 进行了封装,屏蔽了jdbc api 底层访问细节,使我们不用与 jdbc api打交道,就可以完成对数据库的访问操作。
官网: http://www.mybatis.org/mybatis-3/
4.小结
- MyBatis: 持久层的一个框架, 封装了JDBC. 操作数据库
- 为什么要学习MyBatis?
- JDBC那一套代码和DBUtils都有一些很明显的缺点, JDBC和DBUtils不适合做项目
- MyBatis是工作里面的主流的持久层框架, 使用几率特别大
第二章-Mybatis入门
案例-Mybatis快速入门
1.需求
2.分析
- 创建Maven工程(java), 添加mybatis的依赖坐标
- 创建pojo (javabean)
- 创建UserDao接口
- 创建UserDao映射文件 (xml配置文件)
- 创建MyBatis核心配置文件SqlMapConfig.xml (xml配置文件)
- 编写java代码测试
3.实现
3.1准备工作
- 数据库
CREATE DATABASE mybatis_day01;
USE mybatis_day01;
CREATE TABLE t_user(
uid int PRIMARY KEY auto_increment,
username varchar(40),
sex varchar(10),
birthday date,
address varchar(40)
);
INSERT INTO `t_user` VALUES (null, 'zs', '男', '2018-08-08', '北京');
INSERT INTO `t_user` VALUES (null, 'ls', '女', '2018-08-30', '武汉');
INSERT INTO `t_user` VALUES (null, 'ww', '男', '2018-08-08', '北京');
3.2.MyBatis快速入门
![image-20210914162202529](https://img2022.cnblogs.com/blog/2848680/202204/2848680-20220423155432040-566213910.png)
3.2.1创建Maven工程(jar)导入坐标
<!--1. 添加依赖-->
<dependencies>
<!--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>5.1.37</version>
</dependency>
<!--单元测试-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
<scope>test</scope>
</dependency>
<!--lombok 依赖-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.18</version>
</dependency>
</dependencies>
3.2.2创建User实体类
- User .java
package com.itheima.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int uid;
private String username;
private String sex;
private Date birthday;
private String address;
}
3.2.3创建 UserDao 接口
- UserDao 接口就是我们的持久层接口(也可以写成 UserMapper) .我们就写成UserDao ,具体代码如下:
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
public interface UserDao {
/**
* 查询所有
* @return
*/
List<User> findAll();
}
3.2.4创建 UserDao.xml 映射文件
在resources 下面创建文件夹 com/itheima/dao 文件夹的名字需要与dao包的名字一样。
注意: 该文件要放在com/itheima/dao里面, 不要写成com.itheima.dao , 要使用 / 的方式创建
<?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">
<!--
这个文件其实就是我们dao的映射文件,通俗的讲,就是当我们要调用UserDao里面的findAll方法的时候
要执行什么样的sql语句,要在这里做配置!
1. 有接口,就有映射文件
2. 映射文件是一个xml文件,要放在resource文件夹里面,需要为它创建一个目录
3. 记住一下套路:
a. xml的目录最好要和dao接口的包名路径一样!
b. xml的目录创建的时候必须要使用 / 的形式,不能使用 . 的形式创建!
c. xml里面的命名空间必须要写成dao接口的全路径!
d. xml里面的语句的id值必须是dao接口的方法名字!
e. resultType: 写的是方法的返回值类型,如果方法的返回值是集合类型,那么写的是集合中的元素类型。
f. parameterType : 写的是参数的类型,参数是什么类型,就写什么类型,即是是集合,也写的是集合的类型。
-->
<mapper namespace="com.itheima.dao.UserDao">
<!--在这里写方法对应的sql语句-->
<select id="findAll" resultType="com.itheima.bean.User">
select * from t_user
</select>
</mapper>
3.2.5创建 SqlMapConfig.xml 配置文件
它的作用:告诉mybatis去连接哪个数据库, 告诉mybatis 项目有哪些映射文件(需要登记) , 起别名 ...
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--
这个文件是mybatis的核心配置文件,它里面包含两部分内容: 连接数据库, 映射文件在哪里-->
<configuration>
<!--
1. 数据库的连接
environments : 用于配置环境,它里面可以定义多个环境,使用 environment来定义
到底是用哪一个环境,取决于 default属性写的是哪个 environment的id值
environment : 用于定义环境,
id :声明一个标识,唯一标识
transactionManager : 事务管理员
dataSource :用不用连接池
-->
<environments default="dev">
<environment id="dev">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis_day01"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!--2. 映射文件在哪里?-->
<mappers>
<mapper resource="com/itheima/dao/UserDao.xml"/>
</mappers>
</configuration>
3.2.6 测试
package com.itheima.test;
import com.itheima.bean.User;
import com.itheima.dao.UserDao;
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.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class TestUserDao {
//查询所有
@Test
public void testFindAll() throws IOException {
//1. 读取SQLMapConfig文件,读取成一个输入流
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//2. 构建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//3. 使用输入流来构建SqlSessionFactory
SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(is);
//4. 问SqlSessionFactory要SqlSession
SqlSession session = sessionFactory.openSession();
//5. 问SqlSession要UserDao的代理对象
UserDao dao = session.getMapper(UserDao.class);
//6. 有了代理对象,就可以调用findAll方法
List<User> list = dao.findAll();
System.out.println("list = " + list);
//7. 关闭SqlSession
session.close();
}
}
4.小结
4.1步骤
- 创建Maven工程 导入坐标
- 创建pojo
- 创建Dao接口
- 创建Dao的映射文件
- 创建MyBatis核心配置文件SqlMapConfig.xml
- 编写Java代码
4.2注意事项
Dao的映射文件的路径
知识点-Mapper动态代理方式规范
1.目标
2.路径
- 入门案例回顾
- 规范
3.讲解
3.1入门案例回顾
3.1.1 创建接口
public interface UserDao {
List<User> findAll();
}
3.1.2 创建映射文件
定义mapper映射文件UserDao.xml,需要修改namespace的值为 UserDao接口全限定名。将UserDao.xml放在resource的xxx.xxx.dao目录下
<?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">
<!--
这个文件其实就是我们dao的映射文件,通俗的讲,就是当我们要调用UserDao里面的findAll方法的时候
要执行什么样的sql语句,要在这里做配置!
1. 有接口,就有映射文件
2. 映射文件是一个xml文件,要放在resource文件夹里面,需要为它创建一个目录
3. 记住一下套路:
a. xml的目录最好要和dao接口的包名路径一样!
b. xml的目录创建的时候必须要使用 / 的形式,不能使用 . 的形式创建!
c. xml里面的命名空间必须要写成dao接口的全路径!
d. xml里面的语句的id值必须是dao接口的方法名字!
e. resultType: 写的是方法的返回值类型,如果方法的返回值是集合类型,那么写的是集合中的元素类型。
f. parameterType : 写的是参数的类型,参数是什么类型,就写什么类型,即是是集合,也写的是集合的类型。
-->
<mapper namespace="com.itheima.dao.UserDao">
<!--在这里写方法对应的sql语句-->
<select id="findAll" resultType="com.itheima.bean.User">
select * from t_user
</select>
</mapper>
3.2.3 测试
package com.itheima.test;
import com.itheima.bean.User;
import com.itheima.dao.UserDao;
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.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class TestUserDao {
//查询所有
@Test
public void testFindAll() throws IOException {
//1. 读取SQLMapConfig文件,读取成一个输入流
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//2. 构建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//3. 使用输入流来构建SqlSessionFactory
SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(is);
//4. 问SqlSessionFactory要SqlSession
SqlSession session = sessionFactory.openSession();
//5. 问SqlSession要UserDao的代理对象
UserDao dao = session.getMapper(UserDao.class);
//6. 有了代理对象,就可以调用findAll方法
List<User> list = dao.findAll();
System.out.println("list = " + list);
//7. 关闭SqlSession
session.close();
}
}
![image-20210809161635583](https://img2022.cnblogs.com/blog/2848680/202204/2848680-20220423155432356-2044465640.png)
3.2规范
Mapper接口开发需要遵循以下规范:
1、 Mapper.xml(UserDao.xml)文件中的namespace必须和mapper(Dao)接口的全限定名相同。
否则出错: Type interface com.itheima.dao.UserDao is not known to the MapperRegistry.
2、Mapper.xml文件中select,update等的标签id的值必须和mapper(Dao)接口的方法名相同
Invalid bound statement (not found): com.itheima.dao.UserDao.findAll
3、Mapper.xml文件中select,update等的标签的parameterType必须和mapper(Dao)接口的方法的形参类型对应
4, Mapper.xml文件中select,update等的标签的resultType必须和mapper(Dao)接口的方法的返回值类型对应
5, Mapper.xml文件的文件名尽量和mapper(Dao)接口的名字一样
6, Mapper.xml文件的路径尽量和mapper(Dao)接口的路径在同一层目录
7,创建xml目录的时候,要使用 / 的方式创建,不要使用 . 的方式创建,否则报错!
4.小结
- 我们使用MyBatis 遵循这些规范
第三章-MyBatis进阶【重点】
案例-使用Mybatis完成CRUD【重点】
1.需求
2.分析
- 在Dao接口定义方法
- 在Dao映射文件配置
3.实现
3.1新增用户
3.1.1实现步骤
- UserDao中添加新增方法
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
public interface UserDao {
/**
* 添加
* @param user
* @return 影响的行数
*/
int add(User user);
}
- 在 UserDao.xml 文件中加入新增配置
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.UserDao">
<!--添加用户: 增删改操作不用写返回的类型,mybatis会自动返回影响的行数-->
<insert id="add" parameterType="com.itheima.bean.User">
insert into t_user values(null , #{username} , #{sex} ,#{birthday} , #{address})
</insert>
</mapper>
- 添加测试类中的测试方法
package com.itheima.test;
import com.itheima.bean.User;
import com.itheima.dao.UserDao;
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.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
public class TestUserDao {
@Test
public void testAdd() throws IOException {
//1. 读取SqlMapConfig文件
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//2. 构建SqlSessionFactoryBuilder
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//3. 构建SqlSessionFactory
SqlSessionFactory factory = builder.build(is);
//4. 构建SqlSession
SqlSession session = factory.openSession();
//5. 问SqlSession要dao的代理
UserDao userDao = session.getMapper(UserDao.class);
//6. 调用方法
User user = new User();
user.setUsername("zhangsan");
user.setSex("男");
user.setBirthday(new Date());
user.setAddress("深圳");
userDao.add(user);
//7. 提交事务: mybatis没有默认提交事务 ,它把setAutoCommit(false), 所以对于增删改操作,要记得提交事务
session.commit();
//8. 关闭SqlSession
session.close();
}
}
3.1.2新增用户 id 的返回值
-
有时候我们存在一些场景,把一条数据存储到数据库了之后,需要马上得到这条记录的id值。因为这条数据是我们自己创建赶出来的,它的id是多少,我们是不知道的,只有这条记录已经存在于数据库里面了,才知道它的id值。
-
什么情况下|场景下,我们需要在插入完这条记录之后,立即就需要得到这条记录的id呢?
当我们往A表里面添加一条记录之后,需要继续往B表里面添加一条记录,但是A表和B表形成了一种主外键关系。B表里面的外键就是A表里面的主键,所以往B表里面添加记录,必须要先知道A表的这条记录的主键
新增用户后, 同时还要返回当前新增用户的 id 值,因为 id 是由数据库的自动增长来实现的,所以就相当于我们要在新增后将自动增长 auto_increment 的值返回。
- 方式一 标签SelectKey获取主键
属性 | 描述 |
---|---|
keyProperty | selectKey 语句结果应该被设置的目标属性。 |
resultType | 结果的类型。MyBatis 通常可以算出来,但是写上也没有问题。MyBatis 允许任何简单类型用作主键的类型,包括字符串。 |
order | 这可以被设置为 BEFORE 或 AFTER。如果设置为 BEFORE,那么它会首先选择主键,设置 keyProperty 然后执行插入语句。如果设置为 AFTER,那么先执行插入语句,然后是 selectKey 元素-这和如 Oracle 数据库相似,可以在插入语句中嵌入序列调用。 |
UserDao.java
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
public interface UserDao {
/**
* 添加: 获取主键id,使用selectKey去获取
* @param user
* @return
*/
int add02(User user);
}
UserDao.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.UserDao">
<!--添加用户:并且获取id主键返回-->
<insert id="add02" parameterType="com.itheima.bean.User">
insert into t_user values(null , #{username} , #{sex} ,#{birthday} , #{address})
<!--
获取主键 alt + shift + 方向上下 移动快捷键
selectKey: 主要使用来获取主键id
keyProperty : 用参数user里面的什么属性来接收主键值
resultType: 接收主键的属性是什么类型
order: 只能写两个值: before | after
BEFORE: 先执行获取id的操作,再去执行添加数据的操作
AFTER : 先执行添加的操作,再去执行获取id的操作。
SELECT LAST_INSERT_ID() : 获取id的语句
-->
<selectKey keyProperty="uid" resultType="int" order="AFTER">
SELECT LAST_INSERT_ID()
</selectKey>
</insert>
</mapper>
-
方式二:属性配置
在isnert标签里面直接使用属性keyProperty 和 useGeneratedKeys来设置获取主键id值。
UserDao.java
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
public interface UserDao {
/**
* 添加: 获取主键id,使用属性的写法来获取
* @param user
* @return
*/
int add03(User user);
}
UserDao.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.UserDao">
<!--
添加用户,获取id主键返回
keyProperty :表示,使用参数user对象里面的什么属性来接收主键id
useGeneratedKeys: 表示,是否使用数据库自增创建创建出来的主键id值,还是由mybatis自己搞出来的id值。
true: 使用数据库创建给出来的id值
false: 不是用数据库创建出来的id值,由mybatis给出来。
-->
<insert id="add03" parameterType="com.itheima.bean.User" keyProperty="uid" useGeneratedKeys="true">
insert into t_user values(null , #{username} , #{sex} ,#{birthday} , #{address})
</insert>
</mapper>
3.1.3新增用户 id 的返回值(字符串类型)
主键不一定是int类型... 主键也可以是字符串类型。只有到以后做项目,有数据库合并,数据库集群的时候。
字符串类型的主键通常就是UUID生成的一串32个字符的字符串。 数据库合并!
User.java
package com.itheima.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private String myId;
private int uid;
private String username;
private String sex;
private Date birthday;
private String address;
}
UserDao.java
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
public interface UserDao {
/**
* 添加: 获取主键id 使用selectKey标签来获取,主键是字符串类型。
* @param user
* @return
*/
int add04(User user);
}
UserDao.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.UserDao">
<!--添加用户,获取id主键返回,但是主键是字符串类型的主键-->
<insert id="add04" parameterType="com.itheima.bean.User" >
insert into t_user values(null , #{username} , #{sex} ,#{birthday} , #{address})
<selectKey keyProperty="myId" resultType="String" order="BEFORE">
select uuid()
</selectKey>
</insert>
</mapper>
3.2修改用户
- UserDao中添加修改方法
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
public interface UserDao {
//=======================修改=======================
/**
* 根据id来查询用户
* @param id
* @return
*/
User findById(int id);
/**
* 修改用户
* @param user
* @return
*/
int update(User user);
}
- 在 UserDao.xml 文件中加入新增配置
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.UserDao">
<!--=========================更新===========================-->
<!--根据id来查询用户-->
<select id="findById" parameterType="int" resultType="com.itheima.bean.User">
select * from t_user where uid = #{id}
</select>
<!--更新用户-->
<update id="update" parameterType="com.itheima.bean.User">
update t_user set username = #{username} , sex = #{sex} , birthday=#{birthday} , address= #{address} where uid = #{uid}
</update>
</mapper>
- 添加测试类中的测试方法
//修改用户
@Test
public void testUpdate() throws IOException {
//1. 读取SqlMapConfig文件
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//2. 构建SqlSessionFactoryBuilder
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//3. 构建SqlSessionFactory
SqlSessionFactory factory = builder.build(is);
//4. 构建SqlSession
SqlSession session = factory.openSession();
//5. 问SqlSession要dao的代理
UserDao userDao = session.getMapper(UserDao.class);
//6. 调用方法
User user = userDao.findById(7);
//修改数据
user.setUsername("lisi");
userDao.update(user);
//7. 提交事务: mybatis没有默认提交事务 ,它把setAutoCommit(false), 所以对于增删改操作,要记得提交事务
session.commit();
//8. 关闭SqlSession
session.close();
}
3.3删除用户
- UserDao中添加删除方法
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
public interface UserDao {
/**
* 删除用户
* @param id
* @return
*/
int delete(int id);
}
- 在 UserDao.xml 文件中加入新增配置
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.UserDao">
<!--删除用户-->
<delete id="delete" parameterType="int">
delete from t_user where uid = #{id}
</delete>
</mapper>
- 添加测试类中的测试方法
//删除用户
@Test
public void testDelete() throws IOException {
//1. 读取SqlMapConfig文件
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//2. 构建SqlSessionFactoryBuilder
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//3. 构建SqlSessionFactory
SqlSessionFactory factory = builder.build(is);
//4. 构建SqlSession
SqlSession session = factory.openSession();
//5. 问SqlSession要dao的代理
UserDao userDao = session.getMapper(UserDao.class);
//6. 调用方法
userDao.delete(7);
//7. 提交事务: mybatis没有默认提交事务 ,它把setAutoCommit(false), 所以对于增删改操作,要记得提交事务
session.commit();
//8. 关闭SqlSession
session.close();
}
3.4模糊查询
3.4.1 方式一
- UserDao 中添加根据姓氏来查询用户的方法
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
public interface UserDao {
/**
* 模糊查询,根据姓氏来查询用户
* @param name
* @return
*/
List<User> findByUsername(String name);
}
- 在 UserDao.xml 文件中加入新增配置
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.UserDao">
<!--1. 从外面传递进来 % 的写法-->
<select id="findByUsername" parameterType="string" resultType="com.itheima.bean.User">
select * from t_user where username like #{name}
</select>
</mapper>
- 添加测试类中的测试方法
在外面拼接 % ,然后再传递数据进来
//模糊查询: 从外面传递进去 %
@Test
public void testFindByUsername() throws IOException {
//1. 读取SqlMapConfig文件
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//2. 构建SqlSessionFactoryBuilder
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//3. 构建SqlSessionFactory
SqlSessionFactory factory = builder.build(is);
//4. 构建SqlSession
SqlSession session = factory.openSession();
//5. 问SqlSession要dao的代理
UserDao userDao = session.getMapper(UserDao.class);
//6. 调用方法
List<User> list = userDao.findByUsername("zhang%");
System.out.println("list = " + list);
//8. 关闭SqlSession
session.close();
}
3.4.2 方式二
- UserDao 中添加新增方法
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
public interface UserDao {
/**
* 模糊查询,根据姓氏来查询用户
* @param name
* @return
*/
List<User> findByUsername02(String name);
/**
* 模糊查询,根据姓氏来查询用户
* @param name
* @return
*/
List<User> findByUsername03(String name);
/**
* 模糊查询,根据姓氏来查询用户
* @param name
* @return
*/
List<User> findByUsername04(String name);
}
- 在 UserDao.xml 文件中加入新增配置
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.UserDao">
<!--2. 在语句里面追加 % , 外面不传递进来 % , 使用#{}取参数的值 -->
<select id="findByUsername02" parameterType="string" resultType="com.itheima.bean.User">
select * from t_user where username like #{name}"%"
</select>
<!--3. 在语句里面追加 % , 外面不传递进来 % , 使用${}取参数的值-->
<select id="findByUsername03" parameterType="string" resultType="com.itheima.bean.User">
select * from t_user where username like '${value}%'
</select>
<!--4. 在语句里面追加 % , 外面不传递进来 % , 使用#{}取参数的值-->
<select id="findByUsername04" parameterType="string" resultType="com.itheima.bean.User">
<!--select * from t_user where username like concat("%" , #{name} , "%")-->
select * from t_user where username like concat( #{name} , "%")
</select>
</mapper>
3.4.3 #{}与${}的区别【面试】
-
{}
- 可以防止sql注入
- 会对sql语句进行预编译|解析,传递什么参数进来,仅仅是顶替占位
#{}
而已。 - 一般使用的都是这个#{}
-
{} 背后会自动的拼接上 ' '
- ${}
- 不能防止sql注入
- 不会对sql语句进行预先编译,传递什么参数进来,不会仅仅认为这数据,会和sql语句做拼接之后再解析SQL语句 ' or '1=1'
- 一般比较少用这个,能使用#{}就先使用这个#{}
- ${} 不会拼接上 ' ' 所以有时候,我们需要做一些order by 这样的列名指定,需要的是准确的列名,而不是 '列名'
- 如果只有一个简单参数的话,那么名字只能用${} 里面只能写value, 不能使用其他的名字
一般来说,只要 #{} 能用的,基本都用它,只要它不能用的时候,再想想这个 ${}
3.5.SqlSessionFactory工具类的抽取
步骤:
- 创建SqlSessionFactoryUtils
- 定义一个getSqlSession()方法获得sqlSession
- 定义释放资源方法
- 保证SqlSessionFactory只有一个(静态代码块)
实现
package com.itheima.utils;
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;
/*
这是专门用来提供Session的工具类
1. 对外提供一个方法,用于获取SqlSession
2. 对外提供一个方法,用于提交事务以及关闭SqlSession
3. 对外提供一个方法,用于关闭SqlSession
*/
public class SqlSessionFactoryUtil {
private static SqlSessionFactory factory = null;
//使用静态代码块确保工厂只有一个!
static{
try {
//1. 读取SqlMapConfig文件
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//2. 构建SqlSessionFactoryBuilder
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//3. 构建SqlSessionFactory
factory = builder.build(is);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 获取sqlsession
* @return
*/
public static SqlSession getSession(){
//4. 构建SqlSession
return factory.openSession();
}
/**
* 提交事务并且关闭sqlsession
* @param session
*/
public static void commitAndClose(SqlSession session){
session.commit();
session.close();
}
/**
* 关闭sqlsession
* @param session
*/
public static void close(SqlSession session){
session.close();
}
}
4.小结
4.1增删改查
- 增加
<insert id="" parameterType="" resultType="" keyProperty="" useGeneratedKeys="true">
sql语句
</insert>
- 更新
<update id="" parameterType="" resultType="" >
sql语句
</update>
- 删除
<delete id="" parameterType="" resultType="" >
sql语句
</delete>
- 查询
<select id="" parameterType="" resultType="" >
sql语句
</select>
4.2#和$区别
#{}
表示一个占位符号- 通过
#{}
可以实现 preparedStatement 向占位符中设置值,自动进行 java 类型和 数据库 类型转换 #{}
可以有效防止 sql 注入#{}
可以接收简单类型值或 pojo 属性值- 如果 parameterType 传输单个简单类型值(String,基本类型),
#{}
括号中可以是 value 或其它名称。
- 通过
${}
表示拼接 sql 串- 通过
${}
可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换. ${}
不能防止 sql 注入${}
可以接收简单类型值或 pojo 属性值- 如果 parameterType 传输单个简单类型值.
${}
括号中只能是 value
- 通过
知识点-parameterType深入
1.目标
2.路径
- 传递简单类型
- 传递 pojo 对象
- 传递 pojo 包装对象类型
3.讲解
3.1传递简单类型
基本的类型,字符串
直接写#{任意字段}
或者${value}
- dao
package com.itheima.dao;
import com.itheima.bean.QueryVo;
import com.itheima.bean.User;
import org.apache.ibatis.annotations.Param;
/*
演练的是: parameterType
*/
public interface UserDao {
/**
* 根据用户名来查询用户 : 传递简单的参数
* @param username
* @return
*/
User findByUsername(String username);
}
- 映射文件
<?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.itheima.dao.UserDao">
<!--
传递简单的参数
1. 如果方法的参数是一个简单的类型(基本数据类型和字符串) ,parameterType就直接写它的类型即可
2. 不需要写完整的全路径,可以直接写全小写名字,因为mybatis给这种类型起了别名了。
3. 当传递进来的是简单的参数,那么取值的时候,可以使用#{参数名} | ${任意值} | ${value} 来取值
-->
<select id="findByUsername" parameterType="string" resultType="com.itheima.bean.User">
select * from t_user where username = #{username}
</select>
</mapper>
3.2传递 pojo 对象
Mybatis 使用 ognl 表达式解析对象字段的值, #{}或者${}括号中的值为 pojo 属性名称。
- dao
package com.itheima.dao;
import com.itheima.bean.QueryVo;
import com.itheima.bean.User;
import org.apache.ibatis.annotations.Param;
/*
演练的是: parameterType
*/
public interface UserDao {
/**
* 根据用户名来查询用户 : 传递简单的参数
* @param user
* @return
*/
User findByUsername2(User user);
}
- 映射文件
<?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.itheima.dao.UserDao">
<!--
传递对象的参数
1. 如果方法的参数是对象类型,那么parameterType就直接写它的类型即可(全路径 | 别名)
2. 取对象中的某个属性的值,那么可以使用 #{属性名} | ${属性名} 即可取值,千万不要写成#{参数名.属性名}
-->
<select id="findByUsername2" parameterType="com.itheima.bean.User" resultType="com.itheima.bean.User">
select * from t_user where username = #{username}
</select>
</mapper>
3.3传递 pojo 包装对象类型
包装对象类型,就是: 对象里面的属性是一个对象。
开发中通过 pojo 传递查询条件 ,查询条件是综合的查询条件,不仅包括用户查询条件还包括其它的查询条件(比如将用户购买商品信息也作为查询条件),这时可以使用包装对象传递输入参数。Pojo 类中包含 pojo。
京东查询的例子:
需求:根据用户名查询用户信息,查询条件放到 QueryVo 的 user 属性中。
- QueryVo
package com.itheima.bean;
import lombok.Data;
/*
查询对象
*/
@Data
public class QueryVo {
private User user;
}
- UserDao接口
package com.itheima.dao;
import com.itheima.bean.QueryVo;
import com.itheima.bean.User;
import org.apache.ibatis.annotations.Param;
/**
* 根据用户名来查询用户 : 传递简单的参数
* @param qv
* @return
*/
User findByUsername3(QueryVo qv);
}
- UserDao.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.UserDao">
<!--
传递对象包含对象的参数
1. 去参数的时候,使用#{对象属性名.子属性即可} : #{user.username}
2. 如果内部的子属性还是一个对象,那么接着继续往下 . 即可
-->
<select id="findByUsername3" parameterType="com.itheima.bean.QueryVo" resultType="com.itheima.bean.User">
select * from t_user where username = #{user.username}
</select>
</mapper>
3.4 传递多个参数
在方法的参数上打上注解@param
如果方法有传递多个参数的必要,那么通常有四种写法来实现:
- 使用#{0} , #{1} , #{2} ... 来获取指定位置的参数。 0 表示第一个参数,1表示第二个参数。阅读性差。
- 使用注解@param来给参数起名字。然后在xml里面使用#{参数的别名}取值
- 可以使用一个Map集合来封装这些数据,然后传递map集合进去。直接写 #
- 可以使用一个javaBean来包装这些数据,然后传递javabean的对象进去。 直接写 #
- UserDao
package com.itheima.dao;
import com.itheima.bean.QueryVo;
import com.itheima.bean.User;
import org.apache.ibatis.annotations.Param;
/*
演练的是: parameterType
*/
public interface UserDao {
/**
* 按照用户名和性别来查询用户
* @param username
* @param sex
* @return
*/
User findByUsernameAndSex(@Param("username") String username , @Param("sex") String sex);
}
- Usredao.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.itheima.dao.UserDao">
<!--
传递多个参数
1. 当传递多个参数的时候,需要给参数加上注解 @param("别名") 起别名。
2. 在映射文件中使用 #{别名} 来取参数的值。
-->
<select id="findByUsernameAndSex" parameterType="string" resultType="com.itheima.bean.User">
select * from t_user where username = #{username} and sex = #{sex}
</select>
</mapper>
4.小结
- 传递简单类型
#{任意字段}或者${value}
- 传递pojo对象类型
#{javaBean属性名}或者${javaBean属性名}
- 传递的包装的pojo
#{属性名.属性名} 或者${属性名.属性名}
- 传递多个参数
#{别名}
知识点-resultType深入
1.目标
2.路径
- 输出简单类型
- 输出pojo对象
- 输出pojo列表
- resultMap结果类型
3.讲解
3.1输出简单类型
直接写对应的Java类型. eg: 返回int
UserDao02.java
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
/*
演练resultType
*/
public interface UserDao02 {
/**
* 返回简单的数据
* @return
*/
long findCount();
}
UserDao02.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.itheima.dao.UserDao02">
<!--返回简单的类型:
1. 如果返回简单的类型,那么resultType只要写这个类型即可 : 简写的别名即可-->
<select id="findCount" resultType="long">
select count(*) from t_user
</select>
</mapper>
3.2 输出pojo对象
直接写当前pojo类的全限定名 eg: 返回User
UserDao02.java
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
/*
演练resultType
*/
public interface UserDao02 {
/**
* 返回对象的数据
* @param uid
* @return
*/
User findByUid(int uid);
}
UserDao02.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.itheima.dao.UserDao02">
<!--
返回对象类型:
1. 如果返回的是一个对象的类型,那么resultType就写这个对象的类型即可:
可以写全路径名,也可以写别名!
-->
<select id="findByUid" parameterType="int" resultType="com.itheima.bean.User">
select * from t_user where uid = #{uid}
</select>
</mapper>
3.3 输出pojo列表
直接写当前pojo类的全限定名 eg: 返回 List
UserDao02.java
package com.itheima.dao;
import com.itheima.bean.User;
import java.util.List;
/*
演练resultType
*/
public interface UserDao02 {
/**
* 返回集合数据
* @return
*/
List<User> findAll();
}
UserDao02.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.itheima.dao.UserDao02">
<!-- 返回集合类型:
1. 如果返回的是一个集合的类型,那么resultType写的是集合里面的元素类型
可以写全路径名,也可以写别名!-->
<select id="findAll" resultType="com.itheima.bean.User">
select * from t_user
</select>
</mapper>
3.4 resultMap结果类型
-
resultType可以指定pojo将查询结果映射为pojo,但需要pojo的属性名和sql查询的列名一致方可映射成功。
如果sql查询列名和javaBean的属性名不一致,那么数据就不能封装到对象的属性身上,要解决这个问题,有两种办法:
a. 把查询出来的列名,给它起别名,让这个别名和我们的JavaBean的属性名一样即可!
b. 使用resultMap来做列和属性的映射设置!
- user03
package com.itheima.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User03 {
private int uid;
private String username1;
private String sex2;
private Date birthday3;
private String address4;
}
方式一: 给列名起别名
- UserDao03.java
package com.itheima.dao;
import com.itheima.bean.User;
import com.itheima.bean.User03;
import java.util.List;
/*
演练resultMap
*/
public interface UserDao03 {
/**
* 根据uid来查询用户
* @param uid
* @return
*/
User03 findByUid(int uid);
}
- UserDao03.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.itheima.dao.UserDao03">
<!--根据用户id来查询用户, 列的名字和对象中的属性名不一致,给列起别名 ,别名就以对象的属性名来取即可-->
<select id="findByUid" parameterType="int" resultType="com.itheima.bean.User03">
select uid , username username1 , sex sex2 , birthday birthday3, address address4 from t_user where uid= #{uid}
</select>
</mapper>
方式二: 使用resultMap
- UserDao03.java
package com.itheima.dao;
import com.itheima.bean.User;
import com.itheima.bean.User03;
import java.util.List;
/*
演练resultMap
*/
public interface UserDao03 {
/**
* 根据uid来查询用户
* @param uid
* @return
*/
User03 findByUid2(int uid);
}
- UserDao03.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.itheima.dao.UserDao03">
<!--
定义映射关系: 表和对象的映射(列和属性的映射)
resultMap : 用于定义映射关系
id: 唯一标识值
type : 要和哪个JavaBean映射
id标签: 专门是给主键列做映射的
result标签: 专门是给普通列做映射的
column :列名
property: 属性名
如果列的名字和属性的名字已经是一样了,那么可以省略它的映射配置!
-->
<resultMap id="user03Map" type="com.itheima.bean.User03">
<id column="uid" property="uid"/>
<result column="username" property="username1"/>
<result column="sex" property="sex2"/>
<result column="birthday" property="birthday3"/>
<result column="address" property="address4"/>
</resultMap>
<select id="findByUid2" parameterType="int" resultMap="user03Map">
select * from t_user where uid = #{uid}
</select>
</mapper>
4.小结
- 输出简单类型 直接写
java类型名
eg: int - 输出pojo对象 直接写
pojo类型名
eg: User - 输出pojo列表类型 写
列表里面的泛型的类型
eg: List写User - ResultMap
- 解决查询出来的结果的列名和javaBean属性不一致的请求
第四章-日志【了解】
知识点-日志的使用
1.目标
我们在使用MyBatis的时候, 其实MyBatis框架会打印一些必要的日志信息, 在开发阶段这些日志信息对我们分析问题,理解代码的执行是特别有帮助的; 包括项目上线之后,我们也可以收集项目的错误日志到文件里面去; 所以我们采用专门的日志系统来处理.
2.步骤
- 导入坐标
- 拷贝日志配置文件到项目
3.讲解
- 导入坐标
<!-- log start -->
<!-- 日志的具体实现 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<!-- 接口 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.6</version>
</dependency>
<!-- 中间的转化jar包 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.6</version>
</dependency>
- 拷贝log4j.properties到resources目录
在resources文件夹下,创建一个文件 log4j.properties **这个名字是固定的! **
##设置日志记录到控制台的方式
log4j.appender.std=org.apache.log4j.ConsoleAppender
log4j.appender.std.Target=System.err
log4j.appender.std.layout=org.apache.log4j.PatternLayout
log4j.appender.std.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n
##设置日志记录到文件的方式
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=mylog.txt
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
##日志输出的级别,以及配置记录方案
log4j.rootLogger= debug,std,file
级别:error > warn > info>debug>trace
4.小结
-
日志系统就是一个工具
- 拷贝坐标
- 拷贝log4j.properties到项目
-
配置文件一般的配置
- 开发阶段: log4j.rootLogger= debug,std,file
- 上线之后: log4j.rootLogger= error ,file
总结
mybatis是什么?
其实是一个作用于dao层的框架,提高我们的开发效率。
入门:
1. 导入依赖
2. 创建JavaBean
3. 创建Dao
4. 创建Dao的映射文件
5. 创建核心配置文件:SqlMapConfig.xml
6. 单元测试
细节(套路):
1. 映射文件的路径必须要和Dao文件的路径一致
2. 映射文件的路径必须使用 / 来创建
3. 映射文件的名字,要和Dao文件名字一致
4. 映射文件的命名空间,必须要写Dao的全路径地址
5. 映射文件中的语句块的id值必须是Dao的方法名
6. parameterType写参数的类型
7. resultType 写返回值类型
8. 映射文件需要在核心配置文件里面登记
crud:
新增:
新增的时候,获取id的返回值:
1. 使用<selectKey>来获取id值
<selectKey keyProperty="uid" resultType="int" order="AFTER">
select last_insert_id()
</selectKey>
2. 使用属性的写法来获取id值
<insert id="" keyProperty="uid" useGeneratorKey="true">
删除: <delete id="">
修改: <update id= "">
查询: <select id="">
#{} 和 ${}
1. #{}可以防止SQL注入,${}不可以
2. #{}的sql语句会进行预编译,使用?来占位
3. 取简单的数据 #{任意值} , ${value}来取值
模糊查询:
只需要记住 concat("%", #{参数} , "%")
parameterType:
1. 简单参数
2. 对象参数
3. 对象包含对象
4. 多个参数
取别名 @param("别名") ===> 使用#{别名取值}
resultType:
1. 简单数据
2. 对象数据
3. 集合数据
4. resultMap