• spring整合mybatis

    前期表准备：

    1. create table tbl_account(
    2.     id int primary key auto_increment,
    3.     name varchar(50) ,
    4.     money int
    5. );
    6.  
    7. insert into tbl_account values (1,'Tom',1000),(2,'Jerry',500);

    一、没使用spring整合mybatis的时候，我们的mybatis写法如下所示：

    程序测试：

    1. import com.itheima.dao.AccountDao;
    2. import com.itheima.domain.Account;
    3. import org.apache.ibatis.io.Resources;
    4. import org.apache.ibatis.session.SqlSession;
    5. import org.apache.ibatis.session.SqlSessionFactory;
    6. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    7. import java.io.IOException;
    8. import java.io.InputStream;
    9.  
    10. public class App {
    11.     public static void main(String[] args) throws IOException {
    12.         // 1. 创建SqlSessionFactoryBuilder对象
    13.         SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    14.         // 2. 加载SqlMapConfig.xml配置文件
    15.         InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
    16.         // 3. 创建SqlSessionFactory对象
    17.         SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
    18.         // 4. 获取SqlSession
    19.         SqlSession sqlSession = sqlSessionFactory.openSession();
    20.         // 5. 执行SqlSession对象执行查询，获取结果User
    21.         AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
    22.  
    23.         Account ac = accountDao.findById(1);
    24.         System.out.println(ac);
    25.  
    26.         // 6. 释放资源
    27.         sqlSession.close();
    28.     }
    29. }

    核心配置文件SqlMapConfig.xml：（以前我们的名字起的是官网形式：mybatis-config.xml）

    新增知识点1：数据库的连接信息可以先写在jdbc.properties文件当中，然后通过 ${#} 符号来获取文件中的属性值

    新增知识点2：当dao/mapper层的代理接口全是通过注解的形式来进行对数据库的增删改查等一些操作的时候，那么我们就可以不再写AccountDao.xml代理接口文件了（在核心配置文件中加载sql映射文件的地方直接加载dao层里的AccountDao类即可访问到该类了，以前我们都是加载到AccountDao.xml）

    2. configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.     
    7.     <properties resource="jdbc.properties">properties>
    8.     <typeAliases>
    9.         <package name="com.itheima.domain"/>
    10.     typeAliases>
    11.     <environments default="mysql">
    12.         <environment id="mysql">
    13.             <transactionManager type="JDBC">transactionManager>
    14.             <dataSource type="POOLED">
    15.  
    16.                 
    17.                 <property name="driver" value="${jdbc.driver}">property>
    18.                 <property name="url" value="${jdbc.url}">property>
    19.                 <property name="username" value="${jdbc.username}">property>
    20.                 <property name="password" value="${jdbc.password}">property>
    21.             dataSource>
    22.         environment>
    23.     environments>
    24.     <mappers>
    25.  
    26.         
    27.         <package name="com.itheima.dao">package>
    28.     mappers>
    29. configuration>

    更正：起别名的那个地方是错误的，不是起别名的。

    作用是：因为没有AccountDao代理开发接口的xml文件格式，所以这个 标签的意义是：加载sql映射文件到 AccountDao代理开发接口 通过sql语句查询出来的数据是通过该标签包下的Account类进行封装返回数据的

    dao/mapper层AccountDao：

    1. package com.itheima.dao;
    2.  
    3. import com.itheima.domain.Account;
    4. import org.apache.ibatis.annotations.Delete;
    5. import org.apache.ibatis.annotations.Insert;
    6. import org.apache.ibatis.annotations.Select;
    7. import org.apache.ibatis.annotations.Update;
    8.  
    9. import java.util.List;
    10.  
    11. public interface AccountDao {
    12.  
    13.     @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    14.     void save(Account account);
    15.  
    16.     @Delete("delete from tbl_account where id = #{id} ")
    17.     void delete(Integer id);
    18.  
    19.     @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    20.     void update(Account account);
    21.  
    22.     @Select("select * from tbl_account")
    23.     List findAll();
    24.  
    25.     @Select("select * from tbl_account where id = #{id} ")
    26.     Account findById(Integer id);
    27. }

    jdbc.properties：

     运行结果如下所示：

    二、使用spring整合mybatis

    其实也就是整合mybatis的核心配置文件（如下所示进行整合即可）

     第一步导坐标：

     第二步：既然我们使用spring整合mybatis了（整合的就是mybatis的核心配置文件）那么我们就可以把mybatis的核心配置文件给删除掉了：

     代码演示如下所示：

    App2程序测试类：

    注意：获取IOC容器中被管理的bean的时候我们尽量写接口.class

     如：AccountService accountService =at.getBean(AccountService.class);

    下面我们是用实现接口类的形式，原理是一样的，都是获取被管理的bean

    1. package com.itheima;
    2.  
    3. import com.itheima.config.SpringConfig;
    4. import com.itheima.domain.Account;
    5. import com.itheima.service.AccountService;
    6. import com.itheima.service.impl.AccountServiceImpl;
    7. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    8.  
    9. public class App2 {
    10.  
    11.     public static void main(String[] args) {
    12.  
    13.         // 1、获取IOC容器    注意：这个IOC容器名称SpringConfig.class需要参考自己写的
    14.         AnnotationConfigApplicationContext at =new AnnotationConfigApplicationContext(SpringConfig.class);
    15.  
    16.         // 2、获取IOC容器中被管理的bean
    17.         AccountService accountService =at.getBean(AccountServiceImpl.class);
    18.  
    19.         // 3、调用bean的方法
    20.         Account account =accountService.findById(2);
    21.         System.out.println(account);
    22.     }
    23. }

    java代码代替spring的xml配置文件：

    SpringConfig：

    1. package com.itheima.config;
    2.  
    3. import org.springframework.context.annotation.ComponentScan;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.context.annotation.Import;
    6. import org.springframework.context.annotation.PropertySource;
    7.  
    8.  
    9. /**
    10.  *  第二种方式：纯注解开发方式
    11.  *
    12.  *      java代码代替spring的xml配置文件
    13.  */
    14.  
    15. @Configuration  // 相当于spring xml配置文件中的总体标签    
    16. @ComponentScan("com.itheima")   // 扫描该包下是否有注解bean的类，有的话就能取到该类对象了，也就是说有注解bean的类就会被IOC容器给管理了
    17. @PropertySource({"jdbc.properties"})    // 配置加载jdbc.properties文件 使用$符获取数据
    18. @Import({JdbcConfig.class,MybatisConfig.class})   
    19.  // 导入这两个的目的就是相当于我们没有用spring整合mybatis的时候，mybatis测试程序中“加载核心置
    20. //  文件”的步骤是一样的，这里导入后就说明加载了核心配置文件
    21. public class SpringConfig {
    22.  
    23. }

     扫描到com.itheima包下的AccountServiceImpl类（该类加了bean注解）：

    eg1：那么说明该类就被IOC容器给管理起来了，我们只需要获取到IOC容器，然后拿到IOC容器内被管理的对象，就可以拿到该类

    eg2：该业务逻辑层加上 private AccountDao accountDao; 就和代理接口accountDao产生依赖关系了，就可以调用代理接口中的如增删改查的方法了

    1. package com.itheima.service.impl;
    2.  
    3. import com.itheima.dao.AccountDao;
    4. import com.itheima.domain.Account;
    5. import com.itheima.service.AccountService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    8.  
    9. import java.util.List;
    10.  
    11.  
    12. @Service    // 注解 bean
    13. public class AccountServiceImpl implements AccountService {
    14.  
    15.     @Autowired // 自动装配 处理依赖关系 private AccountDao accountDao = new AccountDao();
    16.     /**
    17.      *  也就是说：处理完依赖关系后，就相当于这里可以拿到代理接口AccountDao了，然后调用代理接口中的增删改查的方法即可
    18.      */
    19.     private AccountDao accountDao;
    20.  
    21.     public void save(Account account) {
    22.         // 调用代理接口的save方法
    23.         // 也就是说，当我们调用AccountService类当中的save()方法后，然后就调用了代理接口的save方法
    24.         accountDao.save(account);
    25.     }
    26.  
    27.     public void update(Account account){
    28.         accountDao.update(account);
    29.     }
    30.  
    31.     public void delete(Integer id) {
    32.         accountDao.delete(id);
    33.     }
    34.  
    35.     public Account findById(Integer id) {
    36.         return accountDao.findById(id);
    37.     }
    38.  
    39.     public List findAll() {
    40.         return accountDao.findAll();
    41.     }
    42. }

    业务逻辑层的AccountService接口（该接口写的代码和mapper代理接口其实是一样的）：

    eg：业务逻辑层就是做一些相应的逻辑，其实业务逻辑层的接口AccountService的代码和代理接口AccountDao的代码是一样的，只不过有时候会在实现业务层接口AccountServiceImpl的代码上加上了一些逻辑，

    那么你可能会问：为什么业务逻辑层的接口和mapper接口代码一样的话，不直接让实现业务层接口的类直接实现mapper接口呢？

    因为mapper接口有可能会写一些sql注解语句

    1. package com.itheima.service;
    2.  
    3. import com.itheima.domain.Account;
    4.  
    5. import java.util.List;
    6.  
    7. public interface AccountService {
    8.  
    9.     void save(Account account);
    10.  
    11.     void delete(Integer id);
    12.  
    13.     void update(Account account);
    14.  
    15.     List findAll();
    16.  
    17.     Account findById(Integer id);
    18.  
    19. }

    代理接口AccountDao：

    1. package com.itheima.dao;
    2.  
    3. import com.itheima.domain.Account;
    4. import org.apache.ibatis.annotations.Delete;
    5. import org.apache.ibatis.annotations.Insert;
    6. import org.apache.ibatis.annotations.Select;
    7. import org.apache.ibatis.annotations.Update;
    8.  
    9. import java.util.List;
    10.  
    11. public interface AccountDao {
    12.  
    13.     @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    14.     void save(Account account);
    15.  
    16.     @Delete("delete from tbl_account where id = #{id} ")
    17.     void delete(Integer id);
    18.  
    19.     @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    20.     void update(Account account);
    21.  
    22.     @Select("select * from tbl_account")
    23.     List findAll();
    24.  
    25.     @Select("select * from tbl_account where id = #{id} ")
    26.     Account findById(Integer id);
    27. }

    jdbcConfig：（做mybatis核心配置文件中的连接数据库的操作信息，这里把连接数据库的信息先写在jdbcConfig类当中，然后等会再通过引用类型传给MybatisConfig：专门处理mybatis核心配置文件的类当中）

    注意1：如果加载的是properties文件中的数据的话，就需要在SpringConfig类中添加注解@PropertySource({"jdbc.properties"}) // 配置加载jdbc.properties文件

    1. package com.itheima.config;
    2.  
    3. import com.alibaba.druid.pool.DruidDataSource;
    4. import org.springframework.beans.factory.annotation.Value;
    5. import org.springframework.context.annotation.Bean;
    6.  
    7. import javax.sql.DataSource;
    8.  
    9. /**
    10.  *  管理第三方jdbc的对象
    11.  */
    12. public class JdbcConfig {
    13.  
    14.     /**
    15.      *  注解方式完成属性赋值
    16.      *
    17.      *      注意：这里注解的值是通过获取jdbc.properties文件中获取的，因此别忘记加@PropertySource("#")注解形式
    18.      */
    19.  
    20.     @Value("${jdbc.driver}")
    21.     private String driver;
    22.     @Value("${jdbc.url}")
    23.     private String url;
    24.     @Value("${jdbc.username}")
    25.     private String username;
    26.     @Value("${jdbc.password}")
    27.     private String password;
    28.  
    29.     /**
    30.      *  定义一个方法：用来获取要管理的第三方bean/对象
    31.      */
    32.  
    33.  
    34.     @Bean
    35.     public DataSource dataSource(){
    36.  
    37.         // 1、new 第三方bean/对象
    38.         DruidDataSource dataSource =new DruidDataSource();
    39.  
    40.         // 2、给第三方bean/对象属性赋值
    41.         dataSource.setDriverClassName(driver);
    42.         dataSource.setUrl(url);
    43.         dataSource.setUsername(username);
    44.         dataSource.setPassword(password);
    45.  
    46.         // 3、把第三方bean/对象返回给该方法
    47.         return dataSource;
    48.     }
    49.  
    50.  
    51. }

    MybatisConfig：

    1. package com.itheima.config;
    2.  
    3. import org.mybatis.spring.SqlSessionFactoryBean;
    4. import org.mybatis.spring.mapper.MapperScannerConfigurer;
    5. import org.springframework.context.annotation.Bean;
    6.  
    7. import javax.sql.DataSource;
    8.  
    9. /**
    10.  *  spring整合mybatis （ 其实也就是整合mybatis的核心配置文件 ）
    11.  */
    12.  
    13. public class MybatisConfig {
    14.    /*
    15.      
    16.     
    17.             
    18.     
    19.     
    20.         
    21.             
    22.             
    23.                 
    24.                 
    25.                 
    26.                 
    27.                 
    28.             
    29.         
    30.     
    31.     */
    32.  
    33.     /**
    34.      *  该sqlSessionFactory方法new出来的SqlSessionFactoryBean对象相当于整合mybatis的核心配置文件中的上面那些信息
    35.      */
    36.     @Bean
    37.     public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){  // 传参的目的就是处理引用型依赖关系拿到DataSource对象
    38.         // 1、new SqlSessionFactoryBean 对象
    39.         SqlSessionFactoryBean sqfb =new SqlSessionFactoryBean();
    40.         // 2、整合mybatis的核心配置信息
    41.         sqfb.setTypeAliasesPackage("com.itheima.domain");
    42.         sqfb.setDataSource(dataSource); // 引用型依赖关系为mybatis核心配置文件设置jdbc连接信息
    43.  
    44.         return sqfb;
    45.     }
    46.  
    47.     /*
    49.         
    50.         
    51.     
    52.      */
    53.  
    54. /**
    55.  *  该mapperScannerConfigurer方法new出来的MapperScannerConfigurer对象相当于整合mybatis的核心配置文件中的上面那些信息
    56.  */
    57.     @Bean
    58.     public MapperScannerConfigurer mapperScannerConfigurer(){
    59.         // 1、new MapperScannerConfigurer对象
    60.         MapperScannerConfigurer mp =new MapperScannerConfigurer();
    61.         // 2、整合mybatis的核心配置信息
    62.         mp.setBasePackage("com.itheima.dao");
    63.         return mp;
    64.     }
    65. }

  • 相关阅读:
    Java学习笔记（十四）：String类
    2021年中国环境统计年鉴、工业企业污染排放数据库
    一文讲解ARMv8内存属性与类型（Memory types and attributes）简介
    npm——整理前端包管理工具(cnpm、yarn、pnpm)
    聊聊Android线程优化这件事
    使用jstack工具排查JVM中CPU高消耗问题
    有趣的 Go HttpClient 超时机制
    高级词汇和句子（一）-day30
    怎样下载视频号视频？分享6种有效方法
    【无标题】
  • 原文地址：https://blog.csdn.net/lwj_07/article/details/125865556