Mybatis框架_CRUD

最新推荐文章于 2022-04-18 19:16:09 发布
最新推荐文章于 2022-04-18 19:16:09 发布
阅读量498 收藏 1
点赞数
分类专栏： 框架 文章标签： 框架
肉man
本文链接：https://blog.csdn.net/weixin_42166907/article/details/82919581
版权

第1章
Mybatis实现CRUD操作

1.1 Mybatis实现CRUD操作

1.1.1
功能需求

基于已有数据表user，使用MyBatis实现以下功能：

n 根据用户id查询一个用户

n 根据用户名称模糊查询用户列表

n 添加一个用户

n 根据用户id修改用户名

n 根据用户id删除用户

1.1.2
工程准备

参照第一天Mybatis快速入门部分

1.1.3
实现根据用户id查询一个用户

使用的Sql：SELECT * FROM USER WHERE ID=1

1.1.3.1 Pojo

public class User {
private int
id;
private String username;// 用户名称
private String sex; // 性别
private Date birthday; // 生日
private String address; // 地址
get/set……
}

1.1.3.2 映射文件

在resources目录下新建sqlmap子目录,创建UserMapper.xml,添加如下内容

<?xml version="1.0" encoding="UTF-8" ?> select * from user where id=#{id}

1.1.3.3 测试程序

public class MybatisTest {
@Test
public void
testQueryUserById() throws Exception { InputStream
inputStream = Resources.getResourceAsStream(“SqlMapConfig.xml”); SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new
SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = sqlSession.selectOne(“test.queryUserById”, 1);
System.out.println(user);
sqlSession.close();
}
}

1.1.3.4 效果

1.1.4
实现根据用户名模糊查询用户列表

使用的Sql：SELECT * FROM USER WHERE USERNAME LIKE ‘%王%’

1.1.4.1 方法一

（1）映射文件

在UserMapper.xml配置文件中添加如下内容：

 <!-- 如果返回多个结果，mybatis会自动把返回的结果放在list容器中 -->
 <!-- resultType的配置和返回一个结果的配置一样 -->
 <select id="queryUserByUsername1"

parameterType=“string”
resultType=“com.itheima.mybatis.pojo.User”>
SELECT * FROM USER WHERE USERNAME LIKE
#{username}

（2）测试程序

MybatisTest中添加测试方法如下：

@Test
public void
testQueryUserByUsername1() throws Exception {
// 1. 加载SqlMapConfig.xml配置文件
InputStream inputStream = Resources.getResourceAsStream(“SqlMapConfig.xml”);
// 2. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder
sqlSessionFactoryBuilder = new
SqlSessionFactoryBuilder();
// 3. 创建SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
// 4. 创建SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();

     // 5. 执行SqlSession对象执行查询，获取结果User
     // 查询多条数据使用selectList方法
     List<User> list = sqlSession.selectList("test.queryUserByUsername1", "%王%");

     // 6. 打印结果
     for (User user : list) {
        System.out.println(user);
     }

     // 7. 释放资源
     sqlSession.close();
 }

（3）效果

测试效果如下图：

1.1.4.2 方法二

（1）映射文件

在UserMapper.xml配置文件中添加如下内容：


SELECT * FROM USER WHERE
USERNAME LIKE ‘%${value}%’

注意：如果传入的参数是简单数据类型，${}里面必须写value字符串，源码如下：

这就说明了源码中指定了读取的key的名字就是”value”，所以我们在绑定参数时就只能叫value的名字了。

（2）测试程序

MybatisTest中添加测试方法如下：

@Test
public void
testQueryUserByUsername2() throws Exception {
// 1. 加载SqlMapConfig.xml配置文件
InputStream inputStream =
Resources.getResourceAsStream(“SqlMapConfig.xml”);
// 2. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder
sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 3. 创建SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory
= sqlSessionFactoryBuilder.build(inputStream);
// 4. 创建SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();

 // 5. 执行SqlSession对象执行查询，获取结果User
 // 查询多条数据使用selectList方法
 List<User> list = sqlSession.selectList("test.queryUserByUsername2", "王");

 // 6. 打印结果
 for (User user : list) {
     System.out.println(user);
 }

 // 7. 释放资源
 sqlSession.close();

}

（3）效果

测试结果如下图：

1.1.5
小结

1.1.5.1 #{}和${}

n 关于#{}：

1、#{}等同于PreparedStatement中的占位符?，会自动对传入的字符串数据加一对单引号，可以避免Sql注入。

比如 select * from user where username
= #{username} ,传入的username为小张，那么最后打印出来的就是

select *
from user where username = ‘小张’

2、#{}可以接收简单类型值或Pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是任意名称。

1.1.5.2 关于${}:

1、${}将传入的数据直接显示生成在Sql中，只是简单的拼接。如：order by ${id}，如果传入的值是id，则解析成的Sql为order by id。

如果上面的例子使用${}，则成了select * from user where username = 小张

2、 可 以 接 收 简 单 类 型 值 或 P o j o 属 性 值 ， 如 果 p a r a m e t e r T y p e 传 输 单 个 简 单 类 型 值 ， {}可以接收简单类型值或Pojo属性值，如果parameterType传输单个简单类型值， 可以接收简单类型值或Pojo属性值，如果parameterType传输单个简单类型值，{}括号中只能是“value”这个字符串

n 总结：

1、$方式一般用于传入数据库对象，例如传入表名、order by 的字段

2、一般能用#的就别用$.

1.1.5.3 parameterType和resultType

parameterType：指定输入参数类型

resultType：指定输出结果类型，Mybatis将Sql查询结果的一行记录数据映射为resultType指定类型的对象。如果有多条数据，则分别进行映射，并把对象放到容器List中

1.1.5.4 selectOne和selectList

selectOne查询一条记录，如果使用selectOne查询多条记录则抛出异常：

org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be
returned by selectOne(), but found: 3

at

org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(DefaultSqlSession.java:70)

selectList可以查询一条或多条记录。

1.1.6
实现添加用户

使用的Sql：

INSERT INTO USER
(username,birthday,sex,address) VALUES

(‘黄忠’,‘2016-07-26’,‘1’,‘三国’)

1.1.6.1 映射文件

在UserMapper.xml配置文件中添加如下内容：

INSERT INTO USER (username,birthday,sex,address) VALUES (#{username},#{birthday},#{sex},#{address})

1.1.6.2 测试程序

MybatisTest中添加测试方法如下：

@Test
public void testSaveUser()
throws Exception{
// 1. 加载SqlMapConfig.xml配置文件
InputStream inputStream =
Resources.getResourceAsStream(“SqlMapConfig.xml”);
// 2. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder
sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 3. 创建SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory =
sqlSessionFactoryBuilder.build(inputStream);
// 4. 创建SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();

 // 5. 执行SqlSession对象执行保存
 // 创建需要保存的User
 User user = new User();
 user.setUsername("张飞");
 user.setSex("1");
 user.setBirthday(new Date());
 user.setAddress("蜀国");

 sqlSession.insert("test.saveUser", user);
 System.out.println(user);

 // 需要进行事务提交
 sqlSession.commit();

 // 7. 释放资源
 sqlSession.close();

}

1.1.6.3 效果

如上所示，保存成功，但是id=0，需要解决id返回不正常的问题。

1.1.6.4 Mysql自增主键返回

查询Mysql自增id的Sql：SELECT LAST_INSERT_ID()

通过修改UserMapper.xml映射文件，可以将Mysql自增主键返回：

如下添加selectKey 标签







SELECT
LAST_INSERT_ID()

INSERT INTO USER
(username,birthday,sex,address)
VALUES
(#{username},#{birthday},#{sex},#{address})

LAST_INSERT_ID():是Mysql的函数，返回auto_increment自增列新记录id值。

效果如下图所示：

返回的id为22，能够正确的返回id了。

1.1.7
修改用户

根据用户id修改用户名

使用的Sql：UPDATE USER SET USERNAME = ‘赵云’ WHERE ID= 1

1.1.7.1 映射文件

在UserMapper.xml配置文件中添加如下内容：

UPDATE USER SET USERNAME = #{username} WHERE ID = #{id}

1.1.7.2 测试程序

MybatisTest中添加测试方法如下：

@Test
public void
testUpdateUserById() throws Exception{
// 1. 加载SqlMapConfig.xml配置文件
InputStream inputStream =
Resources.getResourceAsStream(“SqlMapConfig.xml”);
// 2. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder
sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 3. 创建SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory =
sqlSessionFactoryBuilder.build(inputStream);
// 4. 创建SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();

 // 5. 执行SqlSession对象执行更新
 // 创建需要更新的User
 User user = new User();
 user.setId(1);
 user.setUsername("关羽");
 
 sqlSession.update("test.updateUserById", user);

 // 需要进行事务提交
 sqlSession.commit();

 // 7. 释放资源
 sqlSession.close();

}

1.1.7.3 效果

测试效果如下图：

1.1.8
删除用户

根据用户id删除用户

使用的Sql：DELETE FROM USER WHERE ID = 1

1.1.8.1 映射文件

在UserMapper.xml配置文件中添加如下内容：

delete from user where id=#{id}

1.1.8.2 测试程序

MybatisTest中添加测试方法如下：

@Test
public void testDeleteUserById() throws Exception{
// 1. 加载SqlMapConfig.xml配置文件
InputStream inputStream =
Resources.getResourceAsStream(“SqlMapConfig.xml”);
// 2. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder
sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 3. 创建SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory =
sqlSessionFactoryBuilder.build(inputStream);
// 4. 创建SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();

     // 5. 执行SqlSession对象执行删除
     sqlSession.delete("test.deleteUserById", 1);

     // 需要进行事务提交
     sqlSession.commit();

     // 7. 释放资源
     sqlSession.close();

}

1.1.8.3 效果

测试效果如下图：

1.2 Mybatis解决原生jdbc编程的问题

1、频繁创建、释放数据库连接造成系统资源浪费，影响系统性能。使用数据库连接池技术可以解决此问题。

解决：在SqlMapConfig.xml中配置数据连接池，使用连接池管理数据库连接。

2、Sql语句写在代码中造成代码不易维护，实际应用中Sql变化的可能较大，Sql变动需要改变java代码。

解决：将Sql语句配置在XXXXmapper.xml文件中与Java代码分离。

3、向Sql语句传参数麻烦，因为Sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应（硬编码）。

解决：Mybatis自动将Java对象映射至Sql语句，通过statement中的parameterType定义输入参数的类型。

4、对结果集解析麻烦（查询列硬编码），Sql变化会导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成Pojo对象解析比较方便。

解决：Mybatis自动将Sql执行结果映射至Java对象，通过statement中的resultType定义输出结果的类型。

第2章Mybatis的两种Dao开发方式

使用MyBatis开发Dao，通常有两个方法，即原始Dao开发方法和Mapper动态代理开发方法。

第2章

2.1
功能需求

使用MyBatis开发DAO实现以下的功能：

n 根据用户id查询一个用户信息

2.2
SqlSession使用分析

SqlSession中封装了对数据库的操作，如：查询、插入、更新、删除等。

通过SqlSessionFactory创建SqlSession，而SqlSessionFactory是通过SqlSessionFactoryBuilder进行创建。

SqlSessionFactoryBuilder用于创建SqlSessionFacoty，SqlSessionFacoty一旦创建完成就不需要SqlSessionFactoryBuilder了，因为SqlSession是通过SqlSessionFactory生产，所以可以将SqlSessionFactoryBuilder当成一个工具类使用，最佳使用范围是方法范围即方法体内局部变量。

SqlSessionFactory是一个接口，接口中定义了openSession的不同重载方法，SqlSessionFactory的最佳使用范围是整个应用运行期间，一旦创建后可以重复使用，通常以单例模式管理SqlSessionFactory。

SqlSession是一个面向用户的接口， sqlSession中定义了数据库操作方法。

每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用，它也是线程不安全的（因为SqlSession底层对应的是Connection连接）。因此最佳的范围是请求或方法范围。

2.3
原始Dao开发方式

原始Dao开发方式需要程序员编写Dao接口和Dao实现类。

2.3.1
映射文件

编写映射文件如下：（也可以使用入门程序完成的映射文件）

<?xml version="1.0" encoding="UTF-8" ?> 
 <!-- 根据id查询用户 -->
 <select id="queryUserById"

parameterType=“Integer”
resultType=“com.itheima.mybatis.pojo.User”>
select * from user
where id = #{id}

2.3.2
Dao接口

先进行DAO的接口开发，编码如下：

public interface UserDao {
/**
* 根据id查询用户
*
* @param id
* @return
*/
User queryUserById(int id);
}

2.3.3
Dao实现类

编写的Dao实现类如下

public class UserDaoImpl implements UserDao {
private SqlSessionFactory sqlSessionFactory;

 public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
     super();
     this.sqlSessionFactory = sqlSessionFactory;
 }

 @Override
 public User queryUserById(int id) {
     // 创建SqlSession
     SqlSession sqlSession = this.sqlSessionFactory.openSession();
     // 执行查询逻辑
     User user = sqlSession.selectOne("test.queryUserById", id);
     // 释放资源
     sqlSession.close();

     return user;
 }

}

2.3.4
Dao测试

创建一个JUnit的测试类，对UserDao进行测试，测试代码如下：

public class UserDaoTest {
private SqlSessionFactory sqlSessionFactory;

 @Before
 public void init() throws Exception {
     // 创建SqlSessionFactoryBuilder
     SqlSessionFactoryBuilder

sqlSessionFactoryBuilder = new
SqlSessionFactoryBuilder();
// 加载SqlMapConfig.xml配置文件
InputStream inputStream = Resources.getResourceAsStream(“SqlMapConfig.xml”);
// 创建SqlsessionFactory
this.sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
}

 @Test
 public void

testQueryUserById() {
// 创建DAO
UserDao userDao = new UserDaoImpl(this.sqlSessionFactory);
// 执行查询
User user = userDao.queryUserById(2);
System.out.println(user);
}
}

2.3.5
原始Dao开发方式源码分析SQL语句执行过程

现在我们可以通过调用SqlSession接口中的方法实现CRUD操作了，那么SqlSession接口中的方法是如何实现的。

此处一起来分析SqlSession接口中的insert()方法的执行过程（也可断点进入其它接口，原理一样），我们进行源码跟踪发现了Mybatis只是对于Jdbc的封装。

insert()方法的执行过程分析

  • DefaultSqlSession----> return update(statement, parameter);185行
  • 进入DefaultSqlSession—> public int update(String statement,
    Object parameter) {方法定义
  • 进入198行— return executor.update(ms, wrapCollection(parameter));
  • 找到executor对象的update方法------------查看update()方法-----------------BaseExecutor类的update()方法
  • 进入BaseExecutor类的update()第117行return doUpdate(ms, parameter);
  • 查看doUpdate()方法------------------查看SimpleExecutor类的doUpdate()方法
  • 查看doUpdate()方法------------------stmt = prepareStatement(handler,
    ms.getStatementLog()); 49行
  • 查看prepareStatement()方法----------进入这个方法的84,85行
  • 得到代码： Connection connection =
    getConnection(statementLog);
    stmt = handler.prepare(connection,
    transaction.getTimeout());
    查看代码：
    stmt = handler.prepare(connection,
    transaction.getTimeout()); //StatementHandler的子类BaseStatementHandler类
    查看BaseStatementHandler类的prepare（）方法，该类的84行
    再进入这个类的88行,找到代码:
    statement =
    instantiateStatement(connection);
    进入SimpleStatementHandler类的instantiateStatement(connection)
    protected Statement
    instantiateStatement(Connection connection) throws SQLException {
    if (mappedStatement.getResultSetType()
    != null) {
    return
    connection.createStatement(mappedStatement.getResultSetType().getValue(),
    ResultSet.CONCUR_READ_ONLY);
    } else {
    return connection.createStatement();
    }
    }

2.3.6
思考

原始方式开发Dao层时，如果接口中定义了很多方法，那么实现类中就得写很多的实现代码，但Dao层的逻辑总结起来就是增、删、改、查，是否可以不写实现类？

2.4
Mapper动态代理方式

2.4.1
开发规范

Mapper动态代理开发方式只需要程序员开发Mapper接口（相当于Dao接口），Mybatis框架会根据接口定义创建接口的动态代理对象，代理对象的方法同Dao接口实现类中的方法。

Mapper接口开发需要遵循以下4个规范：

n
Mapper映射文件中的namespace与mapper接口的类路径相同。

n
Mapper接口方法名和Mapper映射文件中定义的每个Sql的id相同

n
Mapper接口方法的输入参数类型和Mapper映射文件中定义的每个Sql的ParameterType的类型相同

n
Mapper接口方法的输出参数类型和Mapper映射文件中定义的每个Sql的resultType的类型相同

2.4.2
Mapper.xml(映射文件)

定义Mapper映射文件UserMapper.xml，放在resources的mapper目录下，

UserMapper.xml配置文件内容：

<?xml version="1.0" encoding="UTF-8"?> select * from user where id = #{id}

2.4.3
UserMapper(接口文件)

创建UserMapper接口代码如下：

public interface UserMapper {
/**

  • 根据id查询
  • @param id
  • @return
    */
    User queryUserById(int id);
    }

2.4.4
加载UserMapper.xml文件

修改SqlMapConfig.xml文件，添加以下所示的内容：

2.4.5
测试

编写的测试方法如下：

public class UserMapperTest {
private SqlSessionFactory sqlSessionFactory;

 @Before
 public void init() throws Exception {
     // 创建SqlSessionFactoryBuilder
     SqlSessionFactoryBuilder

sqlSessionFactoryBuilder = new
SqlSessionFactoryBuilder();
// 加载SqlMapConfig.xml配置文件
InputStream inputStream = Resources.getResourceAsStream(“SqlMapConfig.xml”);
// 创建SqlsessionFactory
this.sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
}

 @Test
 public void

testQueryUserById() {
// 获取sqlSession
SqlSession sqlSession = this.sqlSessionFactory.openSession();

     // 从sqlSession中获取Mapper接口的代理对象
     UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
     // 执行查询方法
     User user = userMapper.queryUserById(2);
     System.out.println(user);
     sqlSession.close();
 }

}

2.4.6
Mapper动态代理方式实现DAO源码分析

我们总结一下会发现，采用代理方式开发DAO是非常简单的，只需要定义DAO接口并开发出它所对应的sql映射文件，就可以实现DAO。我们一起思考一下，这个接口的实现类是没有的，那么DAO接口的实现是如何产生的？

通过对源代码进行跟踪，我们会发现这个过程如下：

在调用SqlSession接口的getMapper()方法时
getMapper(Class type, SqlSession sqlSession)
它的底层进一步调用了JDK动态代理方式来生成代理子类对象的
protected T newInstance(MapperProxy mapperProxy)
{
return (T)
Proxy.newProxyInstance(mapperInterface.getClassLoader(),
new Class[] { mapperInterface }, mapperProxy);
}
当调用具体的方法时，会去调用MapperProxy的invoke()方法
这个invoke()的最后一行： return mapperMethod.execute(sqlSession,
args);
继续跟踪这个方法：execute(sqlSession, args);
下面是它的方法体
Object result;
switch (command.getType()) {
case INSERT: {
Object param =
method.convertArgsToSqlCommandParam(args);
result =
rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
case UPDATE: {
Object param =
method.convertArgsToSqlCommandParam(args);
result =
rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: {
Object param =
method.convertArgsToSqlCommandParam(args);
result =
rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT:
if (method.returnsVoid() &&
method.hasResultHandler()) {
executeWithResultHandler(sqlSession,
args);
result = null;
} else if (method.returnsMany()) {
result = executeForMany(sqlSession,
args);
} else if (method.returnsMap()) {
result = executeForMap(sqlSession,
args);
} else if (method.returnsCursor()) {
result = executeForCursor(sqlSession,
args);
} else {
Object param =
method.convertArgsToSqlCommandParam(args);
result =
sqlSession.selectOne(command.getName(), param);
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution
method for: " + command.getName());
}

2.5
小结

Mybatis官方推荐使用Mapper接口的方式开发Dao，这样程序员就不用去开发实现类了，这种方式是我们后面进入企业的主流方式。但是有一些企业还是用第一种方式开发Dao，因为在介绍Mybatis时，我们知道Mybatis的前身是ibatis，而ibatis是没有提供这种方式开发Dao的，所有很多公司还没有习惯使用第二种方式开发Dao。

第3章
全局配置文件SqlMapConfig.xml

3.1
配置内容和顺序

SqlMapConfig.xml中配置的内容和顺序如下：

properties（属性配置）

settings（全局配置参数）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境集合属性对象）

environment（环境子属性对象）

transactionManager（事务管理）

dataSource（数据源）

mappers（映射器）

注意：标签是有顺序的，如上。

3.2
properties（属性）

使用的properties的好处：配置数据共享

db.properties配置文件内容如下：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

SqlMapConfig.xml引用如下：

<?xml version="1.0" encoding="UTF-8" ?>

注意： MyBatis 将按照下面的顺序来加载属性：

n
在 properties
元素体内定义的属性首先被读取。

n
然后会读取properties 元素中resource或 url 加载的属性，它会覆盖已读取的同名属性。

3.3
typeAliases（类型别名）

     Mybatis默认情况下支持一些参数写别名，如下，也可以参考官方文档说明（第19页）

3.3.1
Mybatis默认支持的别名

别名

映射的类型

_byte

byte

_long

long

_short

short

_int

int

_integer

int

_double

double

_float

float

_boolean

boolean

string

String

byte

Byte

long

Long

short

Short

int

Integer

integer

Integer

double

Double

float

Float

boolean

Boolean

date

Date

decimal

BigDecimal

bigdecimal

BigDecimal

map

Map

这些都是支持的默认别名。我们也可以从源码角度来看它们分别都是如何定义出来的。

可以参考TypeAliasRegistery.class的源码。

3.3.2
自定义别名

在SqlMapConfig.xml中配置如下：

<?xml version="1.0" encoding="UTF-8" ?> 
 <typeAliases>
     <!-- 单个别名定义 -->
     <typeAlias alias="user" type="com.itheima.mybatis.pojo.User" />
     <!-- 批量别名定义，扫描整个包下的类，别名为类名（大小写不敏感）

–>


 <environments default="development">
     <environment id="development">
        <!-- 使用jdbc事务管理 -->
        <transactionManager type="JDBC"

/>








 <!-- 加载映射文件

–>




在mapper.xml配置文件中，就可以使用设置的别名了

注意：别名大小写不敏感，推荐使用批量定义别名

3.4
mappers（映射器）

Mapper配置的几种方法：

3.4.1
通过resource加载单个映射文件

使用相对于类路径的资源（现在的使用方式）

如：

3.4.2
另外两种加载方式（仅支持Mapper动态代理开发Dao）

3.4.3
通过mapper接口加载单个映射文件

n 通过Mapper接口类加载单个映射文件

使用mapper接口类路径，如：

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。

n 批量加载映射文件

加载指定包下的所有Mapper接口类，如：

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。

n 注意：使用Mapper动态代理方式开发Dao层时，推荐使用批量加载的方式，这种方式也用的最多。

第四章 Mybatis输入类型和结果类型

第4章

4.1
parameterType(输入类型)

4.1.1
传递简单类型

参考第一天内容。

使用#{}占位符，或者${}进行Sql拼接。

4.1.2
传递Pojo对象

参考第一天的内容。

#{}或者${}括号中的值为Pojo属性名称。

4.1.3
传递Pojo包装对象

包装对象：Pojo类中的一个属性是另外一个Pojo。

为什么使用包装对象？

在平时的开发中，不一定就是单纯的对一个实体进行增删改查，例如完成用户信息的综合查询，有时需要传入查询条件很复杂，可能包括用户信息、关联表的其它信息等。针对这种需求，在Mybatis中我们可以使用自定义的包装类型的Pojo，在包装类型的Pojo中将复杂的查询条件包装进去。

功能需求：根据用户名模糊查询用户信息，查询条件放到QueryVo的user属性中。

4.1.3.1 编写QueryVo

public class QueryVo {
// 包含其他的pojo
private User user;

public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}

4.1.3.2 Sql语句

SELECT * FROM
USER WHERE USERNAME LIKE ‘%王%’

4.1.3.3 Mapper.xml文件

在UserMapper.xml中配置Sql，如下图。

4.1.3.4 Mapper接口

在UserMapper接口中添加方法，如下图：

4.1.3.5 测试方法

在UserMapeprTest增加测试方法，如下：

@Test
public void testQueryUserByQueryVo() {
SqlSession sqlSession = this.sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 使用userMapper执行查询，使用包装对象
QueryVo queryVo = new QueryVo();
// 设置user条件
User user = new User();
user.setUsername("%王%");
// 设置到包装对象中
queryVo.setUser(user);
// 执行查询
List list = userMapper.queryUserByQueryVo(queryVo);
for (User u : list) {
System.out.println(u);
}
sqlSession.close();
}

4.1.3.6 效果

测试结果如下图：

4.2
resultType(输出结果类型)

4.2.1
输出简单类型

功能需求：查询用户表数据条数

Sql语句：SELECT count(*) FROM user

4.2.1.1 Mapper.xml文件

在UserMapper.xml中配置Sql，如下图：

4.2.1.2 Mapper接口

在UserMapper添加方法，如下图：

4.2.1.3 测试方法

在UserMapeprTest增加测试方法，如下：

@Test
public void testQueryUserCount() {
SqlSession sqlSession = this.sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
int count = userMapper.queryUserCount();
System.out.println(count);
sqlSession.close();
}

4.2.1.4 效果

测试结果如下图：

注意：输出简单类型必须查询出来的结果集有一条记录，最终将第一个字段的值转换为输出类型

4.2.2
输出Pojo对象

参考第一天内容

4.2.3
输出Pojo列表

参考第一天内容

4.3
resultMap

resultType可以指定将查询结果映射为Pojo，但需要Pojo的属性名和Sql查询的列名一致方可映射成功。

如果Sql查询字段名和Pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系
，resultMap实质上还需要将查询结果映射到Pojo对象中。

功能需求：查询订单表orders的所有数据

Sql语句：SELECT id, user_id, number, createtime,
note FROM orders

4.3.1
创建数据表、初始化测试数据、声明Pojo对象

创建订单表并查询订单表的全部数据，Sql语句如下：

– Table structure for orders

DROP TABLE IF EXISTS orders;
CREATE TABLE orders (

id int(11) NOT NULL AUTO_INCREMENT,

user_id int(11) NOT NULL COMMENT ‘下单用户id’,

number varchar(32) NOT NULL COMMENT ‘订单号’,

createtime datetime NOT NULL COMMENT ‘创建订单时间’,

note varchar(100) DEFAULT NULL COMMENT ‘备注’,

PRIMARY KEY (id),

KEY FK_orders_1 (user_id),

CONSTRAINT FK_orders_id FOREIGN KEY (user_id) REFERENCES user
(id) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6
DEFAULT CHARSET=utf8;

– Records of orders

INSERT INTO orders VALUES
(‘3’, ‘3’, ‘1000010’, ‘2015-02-04 13:22:35’, null);
INSERT INTO orders VALUES
(‘4’, ‘3’, ‘1000011’, ‘2015-02-03 13:22:41’, null);
INSERT INTO orders VALUES
(‘5’, ‘4’, ‘1000012’, ‘2015-02-12 16:13:23’, null);

Orders对象：

public class Orders {
// 订单id
private int id;
// 用户id
private Integer userId;
// 订单号
private String number;
// 订单创建时间
private Date createtime;
// 备注
private String note;
get/set…
}

4.3.2
Mapper.xml文件

创建OrdersMapper.xml配置文件，如下：

<?xml version="1.0" encoding="UTF-8" ?> SELECT id, user_id, number, createtime, note FROM orders

4.3.3
Mapper接口

编写接口如下：

public interface OrdersMapper {
/**
* 查询所有订单
*
* @return
*/
List
queryOrdersAll();
}

4.3.4
测试方法

编写测试方法OrdersMapperTest如下：

public class OrdersMapperTest {
private SqlSessionFactory sqlSessionFactory;

 @Before
 public void init() throws Exception {
     InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
     this.sqlSessionFactory = new

SqlSessionFactoryBuilder().build(inputStream);
}

 @Test
 public void testQueryAll()

{
// 获取sqlSession
SqlSession sqlSession = this.sqlSessionFactory.openSession();
// 获取OrderMapper
OrdersMapper orderMapper = sqlSession.getMapper(OrdersMapper.class);

     // 执行查询
     List<Orders> list = orderMapper.queryOrdersAll();
     for (Orders order : list) {
        System.out.println(order);
     }

sqlSession.close();
}
}

4.3.5
效果

测试效果如下图：

发现userId为null

解决方案：使用resultMap

4.3.6
使用resultMap

由于上边的mapper.xml中Sql查询列(user_id)和Order类属性(userId)不一致，所以查询结果不能映射到Pojo中。

需要定义resultMap，把orderResultMap将Sql查询列(user_id)和Order类属性(userId)对应起来

改造OrderMapper.xml，如下：

<?xml version="1.0" encoding="UTF-8" ?> 
 <!-- resultMap最终还是要将结果映射到pojo上，type就是指定映射到哪一个pojo -->
 <!-- id：设置ResultMap的id -->
 <resultMap type="orders" id="orderResultMap">
     <!-- 定义主键 ,非常重要。如果是多个字段,则定义多个id -->
     <!-- property：主键在pojo中的属性名 -->
     <!-- column：主键在数据库中的列名 -->
     <id property="id" column="id" />

     <!-- 定义普通属性

–>




 <!-- 查询所有的订单数据

–>

SELECT id, user_id,
number,
createtime, note
FROM orders

4.3.7
效果

只需要修改Mapper.xml就可以了，再次测试结果如下：

肉man
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
解决mybatis：Expected one result (or null) to be returned by selectOne(), but found: 7
weixin_59527409的博客
04-02 1621
mybatis报错
使用MyBatis实现CRUD
Mr. Xu的博客
11-03 733
MyBatis介绍： ​ mybatis 是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。 ​ mybatis 通过xml 或注解的方式将执行的各种statement 配置起来，并通过java 对象和statement 中sql的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql并将结果映射为 java 对象并返回。 采用 ORM (
Mybatis入门(实现简单的CRUD)
w7486的博客
01-19 1024
目录 一.先配置Mybatis主配置文件 二.实体类 三.Dao层(mapper) 四.CRUD 查询所有学生信息 根据ID查学生信息 添加学生 修改学生信息 删除学生 一.先配置Mybatis主配置文件 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/
在手写CRUD代码？这款开源框架助你解放双手
代码界的扛把子
04-18 327
相信很多朋友在项目中使用的ORM框架都是MyBatis，如果单用MyBatis来操作数据库的话，需要手写很多单表查询的SQL实现。这时候我们往往会选择一个增强工具来实现这些单表CRUD操作，这里推荐一款好用的工具MyBatis-Plus！ MyBatis-Plus简介 MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。MyBatis-Plus 提供了代码生成器，可以一键生成controller、servi.
MyBatis实现简单的CRUD，适合初学者
08-10
MyBatis实现简单的CRUD，适合初学者，包含了项目完整源码。
day01_02_mybatis_crud_mybatis_
09-29
MyBatis 是一款深受开发者喜爱的 Java 持久层框架，它简化了与数据库交互的复杂性，尤其是在 CRUD（创建、读取、更新、删除）操作中。本教程将带你深入了解 MyBatis 的基本使用，并通过实际示例进行演示。 在开始...
Springboot_mybatis_CRUD.zip
02-27
接下来，我们将深入探讨这两个框架以及在"Springboot_mybatis_CRUD.zip"项目中的应用。 1. **SpringBoot简介** SpringBoot由Pivotal团队提供，旨在简化Spring应用的初始搭建以及配置工作。它默认配置了很多常见的...
mybatis_crud增删改查数据库操作.zip
06-04
MyBatis是一个优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。在本示例中，"mybatis_crud增删改查数据库操作.zip" 提供了一个使用MyBatis进行CRUD（Create、Read、Update、Delete）操作的教程。通过...
Mybatis资料_mybatis_
10-04
Mybatis是中国著名的开源Java持久层框架之一，由Clinton Begin在2003年发起，旨在简化...以上是Mybatis框架的关键知识点，掌握这些内容，将有助于深入理解Mybatis的工作原理，从而在实际开发中高效利用这一强大工具。
MyBatis1_areavcc_mybatis_
10-01
MyBatis是一个流行的Java持久层框架，它简化了数据库操作，允许开发者将SQL语句直接集成到Java...这是一个全面掌握MyBatis框架的良好起点。在实际应用中，MyBatis的灵活性和强大的功能使其成为Java开发者的首选之一。
S2SH-CRUD整合框架
02-22
用于基础的增删改查，并完美实现ssh2的框架组合。
MyBatis 采用注解方式实现CRUD
03-06
MyBatis 采用注解方式实现CRUD 参考博客：https://www.jianshu.com/p/74fbe5f1e610
用mybatis实现简单的CRUD
Alan_Xiang的博客
12-20 4563
下面介绍如何用mybatis实现简单的增删改查功能，有两种方式，一种是通过xml配置文件实现，一种是通过注解实现。 　　仍然通过对user的操作进行说明，新建好项目并导入jar包后，新建数据库和表，并插入两条记录：create database mybatis; use mybatis; CREATE TABLE users(id INT PRIMARY KEY AUTO_INCREMENT, N
Spring框架CRUD(配置文件+注解)
Mr_Li的博客
07-04 660
Spring框架CRUD(配置文件+注解) 注解开发流程 导入依赖 配置文件 applicationContext.xml 在需要创建对象的类上添加注解 测试 具体实现 导入依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xm...
Springboot+mybatis完整实现CRUD
desky的专栏
06-21 6248
很多年没有从事编程，之前的经验也在C#，从头开始学习Java也是万般无奈。好在经过一个月的学习也算是稍有收获，希望经过这次历程能让自己浴火重生。 一、概述 在网上看了一段时间的SpringBoot学习视频，感觉不如自己脱离教学独立写一遍CRUD应该会有更多收获，有困难就百度，虽然会慢一些但是效果更好一些。经过一周多的折腾，终于把增删改查写了一遍，页面和样式是网上找的模板。涉及的主要技术点有 ...
Mybatis实现CRUD
qq_58856859的博客
09-16 310
Mybatis 是对数据库进行操作 以对学生表进行增删改查(CRUD)为例 步骤 1.创建数据库 即 数据表(确保自己的Mysql服务已打开) 数据库名 mybatis-zcong 数据表名 tb_student 数据库脚本语言 CREATE TABLE `tb_student` ( `id` varchar(20) NOT NULL, `name` varchar(20) DEFAULT NULL, `grade` varchar(20) DEFAULT NULL, P...
动态 SQL
weixin_34238633的博客
08-19 314
MyBatis 的强大特性之一便是它的动态 SQL。如果你有使用 JDBC 或其他类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句有多么痛苦。拼接的时候要确保不能忘了必要的空格，还要注意省掉列名列表最后的逗号。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。 通常使用动态 SQL 不可能是独立的一部分,MyBatis 当然使用一种强大的动态 SQL 语言来改进这种情形,这种语言可以被用...
一步一步搭建Mybatis开发环境，实现CRUD增删改查操作
shang_0122的博客
05-25 3676
从零搭建Mybatis开发环境，一步一步实现CRUD操作，助你更好使用Mybatis
通用DAO之MyBatis封装，封装通用的增删改查（一）
Only丿阿海的专栏
05-20 8409
曾经用过同事的一个基于Hibernate的通用增删改查框架，当时我的感觉相方便，简直是开发小型项目的不二选择，并且那个‘框架’也做为了当时公司里的标准。   膜拜归膜拜，勤于钻研善学善用是鞭长一族的传统美德！作为鞭长创始人阿海，我认为膜拜的同时更有必要将其技术学为己用。 还好Eclipse中带有一个反编译的插件，可以清楚的看到Jar包中的源代码，经过一下午的研究，得出结论：        
mybatis的框架员工信息crud
最新发布
05-23
MyBatis 是一种持久化框架，可以轻松地实现数据库操作。以下是使用 MyBatis 实现员工信息的 CRUD 操作的示例： 1. 首先，创建一个 Employee 类，该类包含员工的基本信息： ```java public class Employee { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值