官方链接

为什么要集成MyBatis

  • 每次都需要在MyBatis的核心配置文件中写Mapper文件的路径,如果Mapper文件非常多,需要手动的一个一个写

    1. <!-- 映射文件 -->
    2. <mappers>
    3. <mapper resource="mappers/person.xml"/>
    4. <mapper resource="mappers/xxxx.xml"/>
    5. <mapper resource="mappers/xxxx.xml"/>
    6. </mappers>
  • 每次做数据库的查询操作都需要拿到sqlSession对象,然后再调用getMapper方法拿到Dao代理对象执行操作,如果能直接拿到Dao代理对象就好了,并且如果进行数据库的插入、修改、删除操作还要手动的提交事务

    1. //使用该方式生成Dao接口的代理对象
    2. CustomerDaoInterface customerDao = session.getMapper(CustomerDaoInterface.class);
    3. customerDao.add(customers1);
    4. session.commit();
  • 需要提前创建好sqlSessionFactory工厂对象,。。。。。。。等等

    集成所需的依赖

  • Spring的依赖

    1. <dependency>
    2. <groupId>org.springframework</groupId>
    3. <artifactId>spring-context</artifactId>
    4. <version>5.2.8.RELEASE</version>
    5. </dependency>
  • MyBatis的依赖

    1. <dependency>
    2. <groupId>org.mybatis</groupId>
    3. <artifactId>mybatis</artifactId>
    4. <version>3.5.5</version>
    5. </dependency>
    6. <dependency>
    7. <groupId>mysql</groupId>
    8. <artifactId>mysql-connector-java</artifactId>
    9. <version>5.1.49</version>
    10. </dependency>
    11. <dependency>
    12. <groupId>com.alibaba</groupId>
    13. <artifactId>druid</artifactId>
    14. <version>1.1.22</version>
    15. </dependency>
  • Spring整好MyBatis所需的依赖

    1. <dependency>
    2. <groupId>org.springframework</groupId>
    3. <artifactId>spring-jdbc</artifactId>
    4. <version>5.2.8.RELEASE</version>
    5. </dependency>
    6. <dependency>
    7. <groupId>org.mybatis</groupId>
    8. <artifactId>mybatis-spring</artifactId>
    9. <version>2.0.5</version>
    10. </dependency>
  • 其它日志、单元测试等(可选) ```xml

    ch.qos.logback logback-classic 1.2.3

junit junit 4.13 test

  1. <a name="u6kvy"></a>
  2. ## Spring配置文件
  3. 以后我们不再需要关系MyBatis的配置文件了,统一使用Spring的配置文件来管理MyBatis的配置文件。
  4. - 数据源
  5. ```xml
  6. <!-- 数据源(Druid) 当然可以使用其的数据源-->
  7. <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  8. <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  9. <property name="url" value="jdbc:mysql://localhost:3306/customer_test"/>
  10. <property name="username" value="root"/>
  11. <property name="password" value="root"/>
  12. </bean>
  • 创建SqlSessionFactory

    1. <!-- 创建SqlSessionFactory -->
    2. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    3. <!-- 数据源 -->
    4. <property name="dataSource" ref="dataSource"/>
    5. <!-- 这个包底下的类会自动设置别名(一般是领域模型) -->
    6. <property name="typeAliasesPackage" value="com.lff.domain"/>
    7. <!-- 映射文件的位置 -->
    8. <property name="mapperLocations">
    9. <array>
    10. <value>mappers/*.xml</value>
    11. </array>
    12. </property>
    13. </bean>

    注意上面别名的配置,在自己的项目要修改

  • 扫描dao

    1. <!-- 扫描dao -->
    2. <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    3. <!-- 设置SqlSessionFactoryBean的id -->
    4. <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    5. <!-- 设置dao的包 -->
    6. <property name="basePackage" value="com.lff.dao"/>
    7. </bean>

具体外界使用

外界使用先创建好对应的Mapper文件,Dao、模型
模型:

  1. package com.lff.domain;
  2. public class Customer {
  3. private Integer custId;
  4. private String custName;
  5. private String custAddress;
  6. private String custCity;
  7. private String custState;
  8. private String custZip;
  9. private String custCountry;
  10. private String custContact;
  11. private String custEmail;
  12. //setter and getter
  13. }

Dao

  1. package com.lff.dao;
  2. import com.lff.domain.Customer;
  3. import java.util.List;
  4. public interface CustomerDao {
  5. public List<Customer> list();
  6. }

mapper

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.lff.dao.CustomerDao">
  6. <select id="list" resultMap="customerDomain">
  7. SELECT * FROM Customers
  8. </select>
  9. <resultMap id="customerDomain" type="com.lff.domain.Customer">
  10. <result property="custName" column="cust_name" />
  11. <result property="custCity" column="cust_city" />
  12. </resultMap>
  13. <delete id="delete" parameterType="int">
  14. DELETE FROM Customers WHERE cust_id = #{id}
  15. </delete>
  16. </mapper>

外界使用:

  1. ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  2. CustomerDao customerDao = ctx.getBean("customerDao", CustomerDao.class);
  3. List<Customer> list = customerDao.list();
  4. System.out.println(customerDao.list());

因为在配置文件里面已经扫描到项目中的所有Dao啦,所以可以直接使用以下代码取到Dao

  1. ctx.getBean("customerDao", CustomerDao.class);

bean的id是Dao的小驼峰形式,比如com.lff.Dao.CustomerDao的id是customerDao
拿到Dao后执行Dao相关的数据库操作,是不是非常简单啦哈哈

注解方式集成

我们可以不在Spring配置文件里面配置下面内容

  1. <!-- 数据源(Druid) 当然可以使用其的数据源-->
  2. <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  3. <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  4. <property name="url" value="jdbc:mysql://localhost:3306/customer_test"/>
  5. <property name="username" value="root"/>
  6. <property name="password" value="root"/>
  7. </bean>
  8. <!-- 创建SqlSessionFactory -->
  9. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  10. <!-- 数据源 -->
  11. <property name="dataSource" ref="dataSource"/>
  12. <!-- 这个包底下的类会自动设置别名(一般是领域模型) -->
  13. <property name="typeAliasesPackage" value="com.lff.domain"/>
  14. <!-- 映射文件的位置 -->
  15. <property name="mapperLocations">
  16. <array>
  17. <value>mappers/*.xml</value>
  18. </array>
  19. </property>
  20. </bean>
  21. <!-- 扫描dao -->
  22. <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  23. <!-- 设置SqlSessionFactoryBean的id -->
  24. <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
  25. <!-- 设置dao的包 -->
  26. <property name="basePackage" value="com.lff.dao"/>
  27. </bean>

上面的内容完全可以使用注解的方式替代
思路很简单,XML配置的内容会创建对应的对象放到IOC容器里面,我们也只要创建对应的对象放到IOC容器里面就可以了。

  1. @Configuration
  2. @MapperScan("com.lff.dao")//扫描dao层,生成动态代理,相当于写了MapperScannerConfigurer类的Bean
  3. @EnableTransactionManagement //事务管理,相当于写<tx:annotation-driven transaction-manager="transactionManager" />
  4. public class MyBatisConfig {
  5. //配置数据源
  6. @Bean
  7. public DataSource dataSource() {
  8. DruidDataSource ds = new DruidDataSource();
  9. ds.setDriverClassName("com.mysql.jdbc.Driver");
  10. ds.setUrl("jdbc:mysql://localhost:3306/customer_test");
  11. ds.setUsername("root");
  12. ds.setPassword("root");
  13. return ds;
  14. }
  15. //配置核心Mybatis核心工厂
  16. @Bean
  17. public SqlSessionFactoryBean sqlSessionFactory() throws Exception {
  18. SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  19. bean.setDataSource(dataSource());
  20. bean.setTypeAliasesPackage("com.lff.domain");//设置实体类别名
  21. PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
  22. bean.setMapperLocations(resolver.getResources("classpath:/mappers/*.xml"));//配置Mapper映射文件的路径
  23. return bean;
  24. }
  25. //配置事务管理器,替换配置里面的DataSourceTransactionManager
  26. @Bean
  27. public DataSourceTransactionManager dataSourceTransactionManager(DataSource ds){
  28. DataSourceTransactionManager dm = new DataSourceTransactionManager();
  29. dm.setDataSource(ds);
  30. return dm;
  31. }
  32. }