Mybatis与Spring整合以及Aop整合pagehelper插件

一. Mybatis与Spring的集成

将MyBatis与Spring进行整合，主要解决的问题就是将SqlSessionFactory对象交由Spring容器来管理，所以，该整合，只需要将SqlSessionFactory的对象生成器SqlSessionFactoryBean注册在Spring容器中，再将其注入给Dao的实现类即可完成整合。

1. 导入pom依赖

1. 添加spring相关依赖(5.0.2.RELEASE)
   spring-core
   spring-beans
   spring-context
   spring-orm
   spring-tx
   spring-aspects
   spring-web
2. 添加mybatis相关依赖
   mybatis核心：mybatis(3.4.5)
   Mybatis分页：pagehelper(5.1.2)
3. spring整合mybatis(1.3.1)
   mybatis-spring
4. 添加dbcp2连接池
   commons-dbcp2(2.1.1)
   commons-pool2(2.4.3)
5. 添加日志配置(2.9.1)
   log4j-core
   log4j-api
   log4j-web
6. 其他
   junit(4.12)
   javax.servlet-api(4.0.0)
   lombok(1.18.2)

    UTF-8
    1.8
    1.8
    3.7.0

    
    
    5.0.2.RELEASE
    
    3.4.5
    
    5.1.44
    
    5.1.2
    
    1.3.1
    
    2.1.1
    2.4.3
    
    2.9.1
    
    4.12
    4.0.0
    1.18.2




    
    
        org.springframework
        spring-context
        ${spring.version}
    
    
        org.springframework
        spring-orm
        ${spring.version}
    
    
        org.springframework
        spring-tx
        ${spring.version}
    
    
        org.springframework
        spring-aspects
        ${spring.version}
    
    
        org.springframework
        spring-web
        ${spring.version}
    
    
        org.springframework
        spring-test
        ${spring.version}
    

    
    
        org.mybatis
        mybatis
        ${mybatis.version}
    
    
    
        mysql
        mysql-connector-java
        ${mysql.version}
    
    
    
        com.github.pagehelper
        pagehelper
        ${pagehelper.version}
    
    
    
        org.mybatis
        mybatis-spring
        ${mybatis.spring.version}
    

    
    
        org.apache.commons
        commons-dbcp2
        ${commons.dbcp2.version}
    
    
        org.apache.commons
        commons-pool2
        ${commons.pool2.version}
    

    
    
    
        org.apache.logging.log4j
        log4j-core
        ${log4j2.version}
    
    
        org.apache.logging.log4j
        log4j-api
        ${log4j2.version}
    
    
    
        org.apache.logging.log4j
        log4j-web
        ${log4j2.version}
    

    
    
        junit
        junit
        ${junit.version}
      
    
    
        javax.servlet
        javax.servlet-api
        ${servlet.version}
        provided
    
    
        org.projectlombok
        lombok
        ${lombok.version}
        provided
    





    
    
        src/main/java
        
            **/*.xml
        
    
    
    
        src/main/resources
        
            jdbc.properties
            *.xml
        
    




    org.apache.maven.plugins
    maven-compiler-plugin
    ${maven.compiler.plugin.version}
    
        ${maven.compiler.source}
        ${maven.compiler.target}
        ${project.build.sourceEncoding}
    


    org.mybatis.generator
    mybatis-generator-maven-plugin
    1.3.2
    
        
        
            mysql
            mysql-connector-java
            ${mysql.version}
        
    
    
        true
    

数据库连接池：会初始化n个数据库连接对象，当需要用户请求操作数据库时，那么会直接在数据库连接池中获取连接，用完会放回连接池中。

2. 利用mybatis逆向工程生成模型层层代码

3. 添加配置文件

 注解式开发
   @Repository：将DAO类声明为Bean
   @Service：通常作用在业务层
   @Constroller：通常作用在控制层，将在Spring MVC中使用
   @Component：是一个泛化的概念，仅仅表示spring中的一个组件（Bean），可以作用在任何层次
   @Scope：模式声明（singleton|prototype）
   @Autowired：将自动在代码上下文与其匹配（默认是类型匹配）的Bean，并自动注入到相应的地方
   @Resource：
   1）@Resource后面没有任何内容，默认通过name属性去匹配bean，找不到再按type去匹配
   2）指定了name或者type则根据指定的类型去匹配bean
   3）指定了name和type则根据指定的name和type去匹配bean，任何一个不匹配都将报错

   问题：@Autowired和@Resource两个注解的区别：
   1）@Autowired默认按照byType方式进行bean匹配，@Resource默认按照byName方式进行bean匹配
   2）@Autowired是Spring的注解，@Resource是J2EE的注解，这个看一下导入注解的时候这两个注解的包名就一清二楚了
   Spring属于第三方的，J2EE是Java自己的东西，因此，建议使用@Resource注解，以减少代码和Spring之间的耦合。

   @Transactional
   注：个人感觉注解式事务比以前的声明式事务更加麻烦，要写的东西更多

spring-context.xml（核心文件）

spring-mybatis.xml
1.扫描所有JavaBean，将对应的组件加载到spring上下文中
2.配置数据源（也就是数据库连接池）
3.配置session工厂
4.配置mapper扫描接口
5.配置事务管理器
6.配置aop自动代理

    
    
    
    
    

    

    
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
    

    
    
    
        
        
        
        
        
        
        
        
            
                
                    
                        
                            helperDialect=mysql
                        
                    
                
            
        
    

    
    
    
        
        
        
        
    

    
        
    
    
    

4. 测试

业务层

package com.xissl.biz;

import com.xissl.model.Book;

/**
 * @author xissl
 * @create 2023-08-25 14:37
 */
public interface BookBiz {
    int deleteByPrimaryKey(Integer bid);

    int insert(Book record);

    int insertSelective(Book record);

    Book selectByPrimaryKey(Integer bid);

    int updateByPrimaryKeySelective(Book record);

    int updateByPrimaryKey(Book record);
}

package com.xissl.biz.impl;

import com.xissl.biz.BookBiz;
import com.xissl.mapper.BookMapper;
import com.xissl.model.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author xissl
 * @create 2023-08-25 14:38
 */
@Service
public class BookBizImpl implements BookBiz {
    @Autowired
    private BookMapper bookMapper;

    @Override
    public int deleteByPrimaryKey(Integer bid) {
        return bookMapper.deleteByPrimaryKey(bid);
    }

    @Override
    public int insert(Book record) {
        return bookMapper.insert(record);
    }

    @Override
    public int insertSelective(Book record) {
        return bookMapper.insertSelective(record);
    }

    @Override
    public Book selectByPrimaryKey(Integer bid) {
        return bookMapper.selectByPrimaryKey(bid);
    }

    @Override
    public int updateByPrimaryKeySelective(Book record) {
        return bookMapper.updateByPrimaryKeySelective(record);
    }

    @Override
    public int updateByPrimaryKey(Book record) {
        return bookMapper.updateByPrimaryKey(record);
    }
}

测试代码

package com.xissl.biz.impl;

import com.xissl.biz.BookBiz;
import com.xissl.model.Book;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import static org.junit.Assert.*;

/**
 * @author xissl
 * @create 2023-08-25 14:44
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring-context.xml"})
public class BookBizImplTest {
    @Autowired
    private BookBiz bookBiz;

    @Before
    public void setUp() throws Exception {
    }

    @After
    public void tearDown() throws Exception {
    }
    @Test
    public void selectByPrimaryKey() {
        Book book = bookBiz.selectByPrimaryKey(33);
        System.out.println(book);
    }

}

运行结果：

二. Aop整合pagehelper插件

好处：使用AOP编程解决分页代码重复的问题

 @Around("execution(* *..*Service.*pager(..))")
   public Object invoke(ProceedingJoinPoint args)

语法结构：execution(方法修饰符  方法返回值  方法所属类 匹配方法名 (  方法中的形参表 )  方法申明抛出的异常  )
"*"  ：代表一个任意类型的参数；
“..”：代表零个或多个任意类型的参数。

切面类：

package com.xissl.aspect;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.xissl.utils.PageBean;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author xissl
 * @create 2023-08-25 16:48
 */
@Aspect //代表当前类为切面类
@Component //代表当前类交给spring进行管理
public class PagerAspect {

    @Around("execution(* *..*Biz.*Pager(..))")
    public Object invoke(ProceedingJoinPoint args) throws Throwable{
        PageBean pageBean = null;
//        获取目标方法中的所有参数
        Object[] argsArgs = args.getArgs();
        for (Object argsArg : argsArgs) {
            if(argsArg instanceof PageBean){
                pageBean = (PageBean) argsArg;
                break;
            }
        }
        if(pageBean!=null && pageBean.isPagination()){
            PageHelper.startPage(pageBean.getPage(),pageBean.getRows());
        }
//        执行目标方法
        Object proceed = args.proceed();
        if(pageBean!=null && pageBean.isPagination()){
            PageInfo info = new PageInfo((List) proceed);
            pageBean.setTotal(info.getTotal()+"");
        }
        return proceed;
    }

}

测试代码：
mapper层

  
    select
    
    from t_mvc_book
    
      
        and bname like concat('%',#{bname},'%')
      
    
  

业务层

    @Override
    public List listPager(Book book, PageBean pageBean) {
        return bookMapper.listPager(book);
    }

测试：

    @Test
    public void listPager() {
        Book book = new Book();
        PageBean pageBean = new PageBean();
        pageBean.setPage(5);
        pageBean.setRows(10);
//        book.setBname("圣墟");
        this.bookBiz.listPager(book,pageBean).forEach(System.out::println);
    }

运行结果：