本文概述了使用JDBC的基本流程，分析了其在业务开发中的局限，并介绍了MyBatis的ORM解决方案，包括配置、动态代理和别名设置。探讨了架构选型和代码优化策略，如使用MyBatis的接口绑定和全局配置管理。
回顾
1.开发流程
1.注册驱动
驱动概念：比如你如果想要使用u盘、网卡、声卡等等这些硬件设备，必须安装相关驱动,同理，我们想要使用mysql的服务器去对数据进行操作，那么我们也需要安装mysql的驱动；
驱动的规范化接口是由jdbc提供的，那么驱动需要注册的驱动实现由不同的数据库厂商来实现；
Class.forName("com.mysql.jdbc.Driver");
mysql提供具体驱动实现类：com.mysql.jdbc.Driver
jdbc提供驱动接口：java.sql.Driver
2.获取连接对象
说白了就是与数据库服务器建议一个连接的通道，底层基于tcp协议；
面向接口编程，开发人员无需关注具体的实现的，只需了解接口提供的功能即可；
Connection conn= DriverManager.getConnection(url,userName,password);
url:主协议:子协议：//ip:端口/数据库名称
jdbc:mysql://192.168.188.200:3306/数据库名称
3.设置事务
jdbc默认事务自动提交
设置手动提交：conn.setAutoCommit(false);
如果设置了手动提交，那么事务必须调用提交或者回滚的方法
提交：conn.commit();
回滚：conn.rollback();
4.获取发送SQL语句的对象
【1】statement
Statement stm= conn.createStatement();
int count= stm.executeUpdate(SQL);//返回受影响的额行数
ResultSet rs=stm.executeQuery(SQL);//返回结果集，数据封装到ResultSet下
解析结果集：
boolean flag=rs.next();//flag=true表示有下一行，false则没有下一行
rs.getXXX(字段的索引位)或者rs.getXXX(字段的名称); //开发推荐使用第二种
【2】PreparedStatement-预编译对象，防止SQL注入
PreparedStatement pstm=conn.prepareStatement(sql模板);
sql模板中以问号？作为参数的占位符，参数在第一个问号的位置，那么参数的索引位就是几；
如何设置参数？
pstm.setXXX(参数索引位，值)
执行：
int count= pstm.executeUpdate();//返回受影响的额行数
ResultSet rs=stm.executeQuery();//返回结果集，数据封装到ResultSet下
5.关闭资源，释放连接
3个close
由内到外
rs.close();
pstm.close();
conn.close();
2.分析业务开发中使用JDBC的弊端？
1.存在大量重复的代码（冗余的代码），比如注册驱动，获取连接对象，......
2.既然是开发业务，那么程序员应该将精力聚焦于业务开发（这样开发效率才会更高），但是使用jdbc你不仅要关注业务开发，还要关注驱动是否注册、连接是否获取、是否创建了发送sql语句的对象.......
理论上讲，我们的重点应该在书写SQL上；
3.jdbc开发中SQL代码与java代码耦合在一块了？
有什么不好？
实际开发中，因为业务需求的频发改动，可能导致SQL不断的重构，间接导致java代码断的改动，维护性不好；
如何解决？
动静分离：想办法经动态的sql配置到一个静态的文件中；
配置SQL至少携带这么几个信息：增删改查的类型、配置一个唯一标识、配置具体的sql逻辑、封装的结果集类型；
propeties文件适合配置简单的key-value结构的数据；
mybatis采用xml配置复杂的数据结构，包含多元信息；
4.封装结果
基于jdbc封装查询结果集，即耗时，又没有技术含量；
可以交给框架去实现；
3.作为一个架构师，如何选型技术？
1.成本看
时间成本
开发中越开越好；
技术成本
稳定，有保证 团队
1.稳定，不要有过多的开发风险（选择的技术，获取活跃度要高）
2.团队对某些技术比较熟悉的（避免了对新技术学习的时间开销）
1.Mybatis入门
1.什么叫orm
o:object（对象）
r:relationship(关系)
m:mapping（映射）
对象关系映射，说白了将数据库表中的数据映射成java的实体类对象；
实体类：封装数据的，不写复杂的逻辑处理，一般类中的方法仅仅包含setter和getter
2.Mybatis快速入门
数据准备：
create table user (
id int primary key auto_increment,
username varchar(20) not null,
birthday date,
sex char(1) default '男',
address varchar(50)
);
insert into user values (null, '孙悟空','1980-10-24','男','花果山水帘洞');
insert into user values (null, '白骨精','1992-11-12','女','白虎岭白骨洞');
insert into user values (null, '猪八戒','1983-05-20','男','福临山云栈洞');
insert into user values (null, '蜘蛛精','1995-03-22','女','盤丝洞');
select * from user;
1.旧式开发流程（了解即可）
1.创建java工程，导入依赖
mybatis-3.5.0.jar
log4j-1.2.17.jar
mysql-connector-java-5.1.37-bin.jar
2.创建实体类
存放表中的数据的实体类：
package com.itheima.pojo;
import java.sql.Date;
/**
* @author by itheima
* @Date 2021/8/20
* @Description 定义user表对应的实体类
* 实体类中属性名称与table中字段名称一样，那么mybatis自动映射
* 就是表中的数据自动填充到与对应字段形同的属性下
*/
public class User {
private Integer id;
private String username;
/**
* 数据库中类型是date对应java中util下Date也可以是sql下的Date
*/
private Date birthday;
private String sex;
private String address;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", birthday=" + birthday +
", sex='" + sex + '\'' +
", address='" + address + '\'' +
'}';
}
}
3.配置核心配置文件
核心干了2件事：
1.配置数据源
2.关联xml映射文件
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>
<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://192.168.188.130:3306/day06_1"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<!--关联加载xml映射文件-->
<mapper resource="UserMapper.xml"/>
</mappers>
</configuration>
3.配置xml映射文件
实际项目开发中，还很多个映射文件，但是核心配置文件一般在项目中只有一个；
UserMapper.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="org.mybatis.example.UserMapper">
<!--接收参数使用#{},sql预编译处理-->
<select id="findUserById" resultType="com.itheima.pojo.User">
select * from user where id = #{id}
</select>
</mapper>
4.加载核心配置文件，完成SQL功能
package com.itheima.test;
import com.itheima.pojo.User;
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 by itheima
* @Date 2021/8/20
* @Description
*/
public class MybatisTest {
public static void main(String[] args) throws IOException {
//1.将核心配置文件转换成文件流对象
//说明：Resources是mybatis给我们提供的加载配置文件的工具类：org.apache.ibatis.io.Resources
InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
//2.构建会话工厂
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
//3.从会话工厂获取会话对象
//说明：会话对象就是操纵sql进行增删改查的核心对象 底层对Connection封装
SqlSession session = sessionFactory.openSession();
//4.调用SqlSession的api完成查询操作
User user = session.selectOne("org.mybatis.example.UserMapper.findUserById", 3);
System.out.println(user);
//5.关闭资源，释放连接
session.close();
in.close();
}
}
记忆窍门：
SqlSessionFactoryBuilder:构建会话工厂的工具类，调用buid方法构建会话工厂
SqlSessionFactory：会话工厂类，通过openSession方法获取会话
SqlSession：会话对象，通过该对象完成crud操作；
5.注意事项
1.在src根路径下创建log4j.properties
### 设置Logger输出级别和输出目的地 ###
log4j.rootLogger=debug, stdout
### 把日志信息输出到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
2.结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uwXEhQ2Z-1631327342767)(img/image-20210820104545321.png)]
6.开发中的问题？
//4.调用SqlSession的api完成查询操作
User user = session.selectOne("org.mybatis.example.UserMapper.findUserById", 3);
存在什么问题？
拼接过程极容易写错（维护性差）；
每次要想调用映射文件中的sql，你首先要找到这个映射文件，实际项目中xml映射文件是非常多的，查找非常麻烦；
还需要反复确认sql的入参的个数，以及参数的类型；
结论：实际开发中不会使用这种方式开发；
2.基于动态代理的方式
1. 定义接口
package com.itheima.mapper;
import com.itheima.pojo.User;
/**
* @author by itheima
* @Date 2021/8/20
* @Description 定义操纵user表的接口
* 接口与xml映射文件绑定：
* 1.接口的全限定名称要与xml映射文件中namespace（全局id）要保证一致
* 2.接口中的方法名称要与xml映射文件的增删改查标签的属性id一致
* mybatis底层通过解析xml映射文件，就可以通过反射获取接口的信息，然后mybatis体层会为接口生成代理对象，
* 每个方法都关联一个SQL
* 以findUserById为例：
* 代理方法的实现：
* 获取去查询的sql:select * from user where id=?
* 调用jdbc预编译对象发送sql模板
* 调用接口方法时，传入值，底层预编译对象调用setxxx(参数索引，接口传入的值)
* 执行查询
* 获取ResultSet结果
* ORM映射，将结果集封装到User对象；
*/
public interface UserMapper {
/**
* 根据id查询用户信息
* @param id
* @return
*/
User findUserById(Integer id);
}
2.配置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">
<!--
基于动态代理的模式：
namespace：命名空间，说白了就是当前这个配置文件的【唯一】表示
命名空间名称跟接口的全限定名称（包名.类型）一致
xml映射文件在实际开发中非常多，且mybatis已启动，就被加载到内存，如何表示内存中的映射文件的信息呢？
method对象===>获取method对象的全限定名称===》类的全限定名称.方法名称
-->
<mapper namespace="com.itheima.mapper.UserMapper">
<!--接收参数使用#{},sql预编译处理-->
<!--
此时也不能乱写，跟接口中的方法名称一致
-->
<select id="findUserById" resultType="com.itheima.pojo.User">
select * from user where id = #{id}
</select>
</mapper>
3.调用Mybatis API获取接口的代理对象
package com.itheima.test;
import com.itheima.mapper.UserMapper;
import com.itheima.pojo.User;
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 by itheima
* @Date 2021/8/20
* @Description
*/
public class MybatisTest2 {
/**
* 开发中推荐使用基于接口动态代理的方式
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//1.将核心配置文件转换成文件流对象
//说明：Resources是mybatis给我们提供的加载配置文件的工具类：org.apache.ibatis.io.Resources
InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
//2.构建会话工厂
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
//3.从会话工厂获取会话对象
//说明：会话对象就是操纵sql进行增删改查的核心对象 底层对Connection封装
SqlSession session = sessionFactory.openSession();
//4.获取接口的代理对象
//说明：传入接口的字节码对象，获取接口的动态代理对象
UserMapper mapper = session.getMapper(UserMapper.class);
//5.调用接口方法，完成功能
User user = mapper.findUserById(1);
System.out.println(user);
//5.关闭资源，释放连接
session.close();
in.close();
}
}
2.核心配置文件
1.properties标签
作用：定义全局的变量
变量定义完毕，全局共享（各个xml都可以使用）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QMu3w1JL-1631327342780)(img/image-20210820114435795.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ge48tYxX-1631327342782)(img/image-20210820114602382.png)]
1.通过properties子标签定义全局变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J2MosiBm-1631327342785)(img/image-20210820114850293.png)]
2.通过加载外部的properties文件定义全局共享变量
jdbc.user=root
jdbc.password=root
jdbc.url=jdbc:mysql://192.168.188.130:3306/day06_1
jdbc.driver=com.mysql.jdbc.Driver
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2UW7n9XY-1631327342787)(img/image-20210820115532537.png)]
2.别名设置
解决代码冗余问题；
【1】方式2
核心配置文件中：
<!--
typeAliases:给类的全限定名称取短的名称（别名）
-->
<typeAliases>
<!--方式1：
type:指定需要被取别名的类全限定名称
alias:指定别名
弊端：有多个实体类，就需要配置多少次，维护性差
好处：别名随便定义
-->
<typeAlias type="com.itheima.pojo.User" alias="myUser"/>
</typeAliases>
在xml映射文件中：
<select id="findUserById" resultType="myUser">
select * from user where id = #{id}
</select>
【2】方式2：开发推荐
核心配置文件：
<!--方式2：基于扫描包，给指定包下的所有的实体类取别名【开发推荐】
特点：别名就是类型或者类名首字母小写
优点：可以批量给实体类取别名，维护性比较好
弊端：别名不能随便定义
-->
<typeAliases>
<package name="com.itheima.pojo"/>
</typeAliases>
xml映射文件中：
<!--
别名就是扫包提供的别名
-->
<select id="findUserById" resultType="User">
select * from user where id = #{id}
</select>
【3】内置别名
mybatis内置别名规律：
基本类型别名：_类型名称
包装类：类名首字母小写作为别名
【4】测试
根据用户id查询用户名称；
定义接口方法：
package com.itheima.mapper;
import com.itheima.pojo.User;
/**
* @author by itheima
* @Date 2021/8/20
* @Description 定义操纵user表的接口
* 接口与xml映射文件绑定：
* 1.接口的全限定名称要与xml映射文件中namespace（全局id）要保证一致
* 2.接口中的方法名称要与xml映射文件的增删改查标签的属性id一致
* mybatis底层通过解析xml映射文件，就可以通过反射获取接口的信息，然后mybatis体层会为接口生成代理对象，
* 每个方法都关联一个SQL
* 以findUserById为例：
* 代理方法的实现：
* 获取去查询的sql:select * from user where id=?
* 调用jdbc预编译对象发送sql模板
* 调用接口方法时，传入值，底层预编译对象调用setxxx(参数索引，接口传入的值)
* 执行查询
* 获取ResultSet结果
* ORM映射，将结果集封装到User对象；
*/
public interface UserMapper {
/**
* 根据id查询用户信息
* @param id
* @return
*/
User findUserById(Integer id);
/**
* 根据用户id查询用户名称
* @param id
* @return
*/
String findUserNameById(Integer id);
}
xml映射文件绑定：
<!--
返回值类型是String类的内置的别名string
-->
<select id="findUserNameById" resultType="string">
select user_name from user where id=#{id}
</select>
测试：
/**
* @Description 测试根据用户id查询用户姓名的功能
*/
@Test
public void test() throws IOException {
//1.获取核心配置文件的流对象
InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
//2.构建会话工厂
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
//3.通过会话工厂获取会话对象
SqlSession session = sessionFactory.openSession();
//4.获取代理对象
UserMapper mapper = session.getMapper(UserMapper.class);
//5.调用接口方法，实行功能
String username = mapper.findUserNameById(4);
System.out.println(username);
//6.关闭资环
in.close();
session.close();
}
3.配置数据源
在核心配置文件中：
方式1；切换数据源（通过environments下的属性default指定数据源）
<!--
environments:可以进行多数据源配置，
属性： default 指定默认使用的数据源环境
-->
<environments default="test">
<!--
environment：具体配置数据源环境标签
属性：id===>指定当前配置的数据源的唯一表示
-->
<environment id="dev">
<!--
transactionManager：事务管理器，
type="jdbc":表示事务交给jdbc去管理
-->
<transactionManager type="JDBC"/>
<!--
datasource:配置数据源
type="pooled":使用mybatis内置的连接池
-->
<dataSource type="POOLED">
<!--四个参数：指定连接数据库的四大核心参数-->
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
<!--设置数据库测试环境-->
<environment id="test">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="jdbc:mysql://192.168.188.130:3306/day06_2"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
方式2：通过代码指定
通过代码指定数据源，优先级更高
4.mappers映射器
方式1：理解
<!--
方式1：通过mapper子标签下的resource属性加载类路径下的xml映射文件（src内）
好处：xml映射文件存储的路径和名称随便定义
弊端：有多少个xml映射文件，就要配置多少次，维护性差
-->
<mapper resource="UserMapper.xml"/>
方式2：了解
<!--方式2：通过绝对路径加载，此时文件可以不放在类路径下[了解]
弊端：使用绝对路径加载。路径不够灵活，需要面临频繁的改动，维护性差
-->
<mapper url="file:///D:\mycode\t3_mysql\day06_1_code\src\UserMapper.xml"/>
方式3：了解
<!--方式3：通过接口的间接加载xml映射文件 【了解】-->
<!--
org.apache.ibatis.binding.BindingException: Invalid bound statement (not found):
可能的情况：
1.接口找不到需要绑定的xml映射文件
2.接口中的方法找不到对应sql
3.接口中的入参与sql中的入参不一致；
-->
<!--
前提要求：
xml映射文件存储的路径和名称不能随便定义
1.xml的存储路径与接口的路径要一致
2.xml的文件名称要与接口的名称要一致
弊端：1. 前提约定比较繁杂：必须同名同路径
2. 有多少个接口，就需要配置多少次，维护性差
-->
<mapper class="com.itheima.mapper.UserMapper"/>
方式4：开发主流
<!--
方式4：基于扫描mapper接口的包，批量加载 【企业开发主流】
前提要求：
xml映射文件存储的路径和名称不能随便定义
1.xml的存储路径与接口的路径要一致
2.xml的文件名称要与接口的名称要一致
-->
<package name="com.itheima.mapper"/>
3.工具类封装
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;
/**
* @author by itheima
* @Date 2021/8/20
* @Description 定义mybatis的工具类
*/
public class MybatisUtil {
//定义全局的会话工厂属性
private static SqlSessionFactory factory;
/**
* 通过静态代码块，使得核心配置文件只加载一次，
* 避免了io开销
*/
static {
//1.获取核心配置文件的流对象
InputStream in = null;
try {
in = Resources.getResourceAsStream("mybatis-config.xml");
} catch (IOException e) {
e.printStackTrace();
}
factory = new SqlSessionFactoryBuilder().build(in);
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 封装获取会话对象的方法
* @return
*/
public static SqlSession getSession(){
return factory.openSession();
}
/**
* 获取代理对象的方法
* @param mapperClass
* @param <T>
* @return ThreadLocal
*/
// public static <T> T getMapper(Class<T> mapperClass){
// return getSession().getMapper(mapperClass);
// }
}
4.xml映射文件
1.select标签
使用流程：
定义接口方法：
/**
* 根据用户id查询生日
* @param id
* @return
*/
Date findBirthdayById(Integer id);
/**
* 获取所有的用户信息
* @return
*/
List<User> findAll();
接口方法绑定xml映射文件：
<!--
parameterType:表示入参的类型，【一般缺省不写 】
resultType：查询结果的类型，必须要写
注意事项：在mybatis内置别名中date是java.until.Date类的别名
在sql中如果入参是基本类型，且是单个，那么可以使用任意参数取接收
-->
<select id="findBirthdayById" parameterType="int" resultType="java.sql.Date">
select birthday from user where id=#{id}
</select>
<!--
如果接口获取的是list类型，那么resutlType指定的应该是集合的泛型；
怎么思考这个事？
因为java的泛型是伪泛型，代码一旦编译，泛型擦除，那么mybatis就不知道集合的类型了，所以
通过resutlType提示mybatis底层进行orm映射的时候，使用集合对应的泛型类型进行映射
-->
<select id="findAll" resultType="com.itheima.pojo.User">
select * from user
</select>
测试：
/**
* @Description 测试根据用户id查询生日
*/
@Test
public void test3(){
SqlSession session = MybatisUtil.getSession();
UserMapper mapper = session.getMapper(UserMapper.class);
Date date = mapper.findBirthdayById(3);
System.out.println(date);
session.close();
}
/**
* @Description 测试获取所有用户信息
*/
@Test
public void test4(){
SqlSession session = MybatisUtil.getSession();
UserMapper mapper = session.getMapper(UserMapper.class);
List<User> all = mapper.findAll();
System.out.println(all);
session.close();
}
2.insert
定义接口方法：
/**
* 插入用户信息
* @param user
* @return 获取受影响的行数
*/
Integer insertUser(User user);
xml映射文件绑定方法：
<!--
insert标签：表示插入操作的标签
属性id:必须填写，返回值受影响的行数，在接口中直接声明即可
sql中获取来自pojo对象属性的参数注意事项：
#{name与实体类中属性名称一致}
-->
<insert id="insertUser">
insert into user values(null,#{username},#{birthday},#{sex},#{address})
</insert>
在mybatis中进行增删改时，事务默认手动提交；
如何设置自动提交呢？
SqlSessioin session=factory.openSession(true);
如何手动提交事务
session.commit();
session.rollback();
3.update标签
1.定义接口方法
/**
* 更新用户信息
* @param user
* @return 返回受影响行数
*/
Integer updateUser(User user);
2.xml映射文件绑定方法：
<update id="updateUser">
update user set user_name=#{username},birthday=#{birthday},sex=#{sex},address=#{address}
where id=#{id}
</update>
3.测试：
/**
* @Description 更新数据
*/
@Test
public void test6(){
SqlSession session = MybatisUtil.getSession();
UserMapper mapper = session.getMapper(UserMapper.class);
User user = new User();
user.setId(1);
user.setBirthday(Date.valueOf("2021-08-20"));
user.setAddress("上海");
user.setSex("男");
user.setUsername("牛魔王");
Integer count = mapper.updateUser(user);
System.out.println(count);
//事务手动提交
//session.commit();
session.close();
}
4.delete标签
1.定义接口方法：
/**
* 根据用户id删除用户信息
* @param id
*/
void deleteById(Integer id);
2.绑定xml：
<delete id="deleteById">
delete from user where id=#{id}
</delete>
3.测试
/**
* @Description 删除数据
*/
@Test
public void test7(){
SqlSession session = MybatisUtil.getSession();
UserMapper mapper = session.getMapper(UserMapper.class);
mapper.deleteById(1);
//事务手动提交
//session.commit();
session.close();
}
回顾：
1.基于动态代理的开发流程？
1.创建工程，导入jar包：mybatis.jar mysql.jar
2.定义实体类对象（细节：实体类中属性名称与表的列名成一致）
3.定义核心配置文件
3.1 配置数据源
3.2 关联xml映射文件
4.定义接口
5.接口绑定xml映射文件
开发主流的方式：扫淼接口所在的包路径
5.1 xml与接口名称一致
5.2 xml与接口的存储路径要一致
6.加载核心配置文件，完成crud操作
6.1 加载核心配置文件，转换成文件流对象
InputStream in= Resources.getResourceAsStream(核心配置文件的路径);
SqlSesssionFactory fac= new SqlSesssionFactoryBuilder().build(in);
SqlSession se= fac.openSession(true/false);
代理对象： se.getMapper(接口.classs);
se.close;
2.核心配置文件标签
使用注意事项：标签的顺序不能随便写，严格按照官网指定的顺序开发，否则，xml报错；
1.properties标签：作用：定义全局的共享变量；
配置变量的2种方式：
1.通过子标签定义变量[了解]
eg: <properties> <property name="key" value="值"/> </properties>
2.通过properties属性resource加载外部的properties文件❤❤❤❤
eg:<propeties resource="xxxx.properties"/>
如何获取共享的变量？
${key},key可以是配置文件中定义的key，也可以是子标签<property>指定的key
2.settings标签：作用：改变mybatis的运行时的行为（是否开启缓存，是否懒加载，是否开启驼峰映射）
配置方式：
<settings>
<setting name="mapUnderscoreToCamelCase" value="true/false"/>
</settings>
什么叫做驼峰映射？
表：aa_bb_cc===>类：aaBbCc(不使用as关键字，就可以完成映射)
3.typeAliases标签：作用：给繁杂的全限定名称取别名，减少冗余代码
2种配置方式：
方式1：
<typeAliases><typeAlias type="类的全限定名称" alias="别名"/></typeAliases>
方式2：基于扫包批量取别名 ❤❤❤❤
<typeAliases>
<package name="pojo类所在的包名路径"/>
</typeAliases>
规则：在指定包下的所有的类的别名是类名或者类名首字母小写
4.envoronments标签：多环境配置标签
要求：使用该标签会修改数据源就可以了
<environments default="dev">
<environment id="dev">
<transactionManager type="JDBC">
<property name="..." value="..."/>
</transactionManager>
<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>
5.mappers标签：配置xml映射文件的加载方式
有两类：
1.直接加载xml映射文件
<mappers>
<mapper resource="xml映射文件的路径"/>
</mappers>
好处：文件名称和路径随便定义
弊端：有多少个xml映射文件，就配置多少次，维护性差；
2.先加载接口，然后间接加载xml映射文件 ❤❤❤❤
前提要求：
接口与xml映射文件必须同名且同路径
<mappers>
<package="接口的包路径"/>
</mappers>
3.xml映射文件
1.select
属性：
id:必须填写，且唯一 paramperType:指定入参的类型，一般不写 resultType/resultMap：必须填写，指定返回值的类型
注意事项：如果返回值是list集合，那么resultType指定的类型是list中的泛型；
2.insert标签
作用：插入 属性：id 必须填写 可以获取操作影响的行数，直接在接口中返回值声明即可；
注意事项：插入操作传入的是pojo对象，那么在sql中如何获取pojo对象中的属性值？
#{名称为实体对象中属性名称} ❤❤❤❤
3.update标签：
作用：更新，使用方式同上insert标签；
4.delete标签：
作用：删除
扫一扫
529
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
