spring整合mybatis
文章目录
前言
当我们在spring里面执行数据库操作的时候，发现原始的方法来操作数据库非常麻烦，而且影响代码的美观，所以我们的spring整合mybatis横空出世，就是为了来解决我们的麻烦。
一、核心对象分析
1.环境准备
数据库的创建
我们在旁边找到数据库，找到对话框的左上方的加号，添加我们是数据源mysql
然后输入用户名和密码，在确认一下数据库是否连接到，如果连接成功我们就可以创建数据库表了
然后我们添加我们的架构
注意：我们这个架构的名字要与后面要创建的 jdbc.properties文件的jdbc.url相同
然后我们开始创建我们表结构
注意：如果我们d的IDEA没有这个创建旧表的按键可以参考创建旧表创建方法
然后进行表内容创建
最后进行数据插入
我们先创建查询控制台
然后进行数据插入
代码：
insert into table_name(id, name, money) VALUES (1, 'tom', 100),(2, 'jerry', 200)
结果：
项目创建
我们在左上方找到文件，在文件里面找到新模块
然后在新建模块里面创建
注意：我们的模块没有父项，并且我们模块的位置不能被其他模块包含，模块管理我们选择maven进行模块管理
（1）配置文件的创建及配置
pom.xml文件的配置
我们找到pom.xml文件，将下面的代码复制到pom.xml文件里面，引入我们所需要的依赖
代码：
<dependencies>
<!--引入spring的依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.1.12</version>
</dependency>
<!--引入第三方数据库连接池的依赖-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
<!--引入操作数据库mybatis的依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<!--引入数据库驱动的依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
</dependencies>
</dependencies>
SqlMapConfig.xml文件的配置
配置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">
<configuration>
<properties resource="jdbc.properties"></properties>
<typeAliases>
<package name="com.itheima.domain"/>
</typeAliases>
<environments default="mysql">
<environment id="mysql">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</dataSource>
</environment>
</environments>
<mappers>
<package name="com.itheima.dao"></package>
</mappers>
</configuration>
jdbc.properties文件的配置
配置连接数据库的相关信息
代码：
driverClassName：数据库连接池驱动类
url：数据库的地址
username：用户名
password：密码
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/tlias
jdbc.username=root
jdbc.password=123456
（2）相关类的创建
模块目录：
dao接口的创建
dao这个接口作用是操作数据库的类
注意：我们这个的数据库表因为不同所以需要更改
代码：
package com.itheima.dao;
import com.itheima.domain.Account;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import java.util.List;
public interface AccountDao {
@Insert("insert into account.table_name(name,money)values(#{name},#{money})")
void save(Account account);
@Delete("delete from account.table_name where id = #{id} ")
void delete(Integer id);
@Update("update account.table_name set name = #{name} , money = #{money} where id = #{id} ")
void update(Account account);
@Select("select * from account.table_name")
List<Account> findAll();
@Select("select * from account.table_name where id = #{id} ")
Account findById(Integer id);
}
domain类的创建
domain这个类作用是存储操作数据库后获得的信息
代码：
package com.itheima.domain;
import java.io.Serializable;
public class Account implements Serializable {
private Integer id;
private String name;
private Double money;
/**
* 获取
* @return id
*/
public Integer getId() {
return id;
}
/**
* 设置
* @param id
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return money
*/
public Double getMoney() {
return money;
}
/**
* 设置
* @param money
*/
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
service类的创建
service这个类作用是调用dao的各个方法来操作数据库，将得到的数据进行处理
service接口创建
代码：
package com.itheima.service;
import com.itheima.domain.Account;
import java.util.List;
public interface AccountService {
void save(Account account);
void delete(Integer id);
void update(Account account);
List<Account> findAll();
Account findById(Integer id);
}
service实现类创建
在我们继承我们的service接口之后，想自动重写接口方法，我们快捷键是Alt+Enter
代码：
package com.itheima.service.impl;
import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
public void save(Account account) {
accountDao.save(account);
}
public void update(Account account){
accountDao.update(account);
}
public void delete(Integer id) {
accountDao.delete(id);
}
public Account findById(Integer id) {
return accountDao.findById(id);
}
public List<Account> findAll() {
return accountDao.findAll();
}
}
主函数App的创建
代码：
package com.itheima;
import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
public class App {
public static void main(String[] args) throws IOException {
// 1. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 2. 加载SqlMapConfig.xml配置文件
InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
// 3. 创建SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
// 4. 得到具体的连接SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 5. 获取到操作数据库的接口
AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
//执行数据库的操作
Account ac = accountDao.findById(1);
System.out.println(ac);
// 6. 释放资源
sqlSession.close();
}
}
结果：
2.spring要管理的核心对象
（1）mybatis核心对象分析
在主函数当中我们可以把我们的代码分成四部分
第一部分：
该部分为当中类为factory对象，就是用来造对象的，这是早期spring进行bean管理的方法，所以我们知道该类就是我们mybatis的核心对象
第二部分：
该部分只是从数据连接池中获取一个连接对象，从而进行后面的操作，所以也不可能是核心对象
第三部分：
该部分只是从连接对象获取要操作数据库的对象，来进行数据操作，所以不会是核心对象
第四部分：
该部分只是关闭数据库的连接，所以不可能是核心东西
（2）整合mybatis
第一部分：
该部分只是在读取配置文件的信息，即我们要连接数据库的哪个架构
第二部分：
该部分只是在当我们在mapper操作完数据库之后，我们的数据由哪个类型进行封装（存储）
第三部分：
该部分就是我们sqlsessionfactory在连接数据库的时候，配置的信息进行注入，所以更加肯定了，sqlsessionfactory就是我们mybatis的核心对象，如果数据库都没有连接，我们后来的方法怎么操作数据库呢？
第四部分：
该部分就是sqlSession.getMapper(AccountDao.class)所需要返回要操作数据库的类，sqlsessionfactory并不负责生成这个类，而是sqlSession负责
二、spring整合mybatis方法
目录：
1.pom.xml相关依赖的引入
代码：
<!--引入spring对jdbc的支持的依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<!--引入mybatis-spring的依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
2.配置类的实现
实现SpringConfig类
代码：
package com.itheima.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MybatisConfig.class})
public class SpringConfig {
}
实现JdbcConfig类
代码：
package com.itheima.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource getDataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(username);
ds.setPassword(password);
return null;
}
}
实现MybatisConfig类
代码：
package com.itheima.config;
import com.itheima.dao.AccountDao;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class MybatisConfig {
@Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
ssfb.setTypeAliasesPackage("com.itheima.domain");
ssfb.setDataSource(dataSource);
return ssfb;
}
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.itheima.dao");
return msc;
}
}
对比
3.测试函数的创建
代码：
package com.itheima;
import com.itheima.config.MybatisConfig;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App2 {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MybatisConfig.class);
AccountService service = applicationContext.getBean(AccountService.class);
Account byId = service.findById(1);
System.out.println(byId);
}
}
结果：
