MyBatis与Spring的集成整合加优化分页功能

目录

一.为什么要将MyBatis和Spring整合？？？

二.配置环境

        2.1 pom文件

        2.2  xml文件

三.演示举例

四.Aop整合pageHelper 分页插件

今天的分享就到这啦！！！

---

一.为什么要将MyBatis和Spring整合？？？

        将MyBatis和Spring整合的主要目的是为了更好地管理和使用数据库连接，并实现事务管理和依赖注入等功能。

        如果不进行整合，可能会导致以下问题：

1.   需要手动管理数据库连接：在不整合的情况下，需要手动获取和释放数据库连接，而整合后可以通过Spring容器自动管理连接，提高代码的可维护性和简洁性。
2.  需要手动处理事务：在不整合的情况下，需要手动开启、提交或回滚事务，而整合后可以通过Spring的事务管理器自动处理事务，减少代码的冗余和错误。
3.  需要手动注入依赖：在不整合的情况下，需要手动实例化和注入依赖对象，而整合后可以使用Spring的依赖注入功能，方便管理和切换依赖。

二.配置环境

        2.1 pom文件

        当我们创好一个项目，然后先来配置pom文件，配置一些相关的插件

  4.0.0

  com.zking
  yzssm
  1.0-SNAPSHOT
  war

  yzssm Maven Webapp
  
  http://www.example.com

  
    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
    

  
  
    yzssm
    
      
      
        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
          
        
        
          maven-clean-plugin
          3.1.0
        
        
        
          maven-resources-plugin
          3.0.2
        
        
          maven-compiler-plugin
          3.8.0
        
        
          maven-surefire-plugin
          2.22.1
        
        
          maven-war-plugin
          3.2.2
        
        
          maven-install-plugin
          2.5.2
        
        
          maven-deploy-plugin
          2.8.2
        
      
  

        2.2  xml文件

                首先是generatorConfig.xml

        其次就是idbc.properties  ,连接数据库文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://47.100.191.44:3308/mybatis_ssm?useUnicode=true&characterEncoding=UTF-8
jdbc.username=test01
jdbc.password=test01

        第三个就是日志文件 log4j2.xml

    
        
        /root/workspace/lucenedemo/logs
        /root/workspace/lucenedemo/logs/error
        /root/workspace/lucenedemo/logs/warn
        %d{yyyy-MM-dd HH:mm:ss.SSS} [%t-%L] %-5level %logger{36} - %msg%n
    

    
        
        
            
            
            
            
            
        

        
        
        
            
        
        
        
            
            
            
            
                
                
                
                
                
                
            
        

        
            
            
            
                
                
            
            
            
        

        
            
            
            
                
                
                
            
        

    

    
    
        
        
        

        
        
        
        
        
        


        
        
            
            
            
            
        

    

                第四个就是spring上下文配置文件 spring-context.xml

                最后一个spring-mybatis.xml 它的作用是：

        1.扫描所有的JavaBean,将组件加载到spring的上下文中

        2.配置数据源--数据库连接池

        3.配置session工厂

        4.配置mapper扫描接口

        5.配置事务管理器

        6.配置aop自动代理   

    
        
        
        
        
        

        

        
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
        

        
        
        
            
            
            
            
            
            
            
            
                
                    
                        
                            
                                helperDialect=mysql
                            
                        
                    
                
            
        

        
        
        
            
            
            
            
        

        
            
        
        
        
    

               注意：有些地方需要根据自己的需求更改，比如数据库的路径，密码账号，还有JavaBean的文件路径，等类似这些地方需要更改

                将这些配置完后，我们直接生成即可

 

 这样我们的环境就搭建好啦！！

---

三.演示举例

        在这里我们先给BookMapper使用注解   @Repository   将这个给spring管理，相当于之前我们在spring-context.xml文件中写的   

        有了上面生成出来的实体类和方法，现在我们直接开始写Biz层，继承BookBiz接口

这里面也是运用了注解的方式

        @Service  将该类交给spring处理  ；@Autowired 相当于set,get方法

package com.zking.biz;

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

/**
 * @author yinzi
 * @create 2023-08-25 15:37
 */
@Service
//将类交给spring处理
public class BookBizImpl implements BookBiz{
    @Autowired   //相当于set,get方法
    private BookMapper bm;

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

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

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

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

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

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

        测试：

 

四.Aop整合pageHelper 分页插件

      -----  也算是完善上一篇分页功能

        首先，一样先导入pageBean工具类

package com.zking.util;

import javax.servlet.http.HttpServletRequest;
import java.io.Serializable;
import java.util.Map;

public class PageBean implements Serializable {

	private static final long serialVersionUID = 2422581023658455731L;

	//页码
	private int page=1;
	//每页显示记录数
	private int rows=10;
	//总记录数
	private int total=0;
	//是否分页
	private boolean isPagination=true;
	//上一次的请求路径
	private String url;
	//获取所有的请求参数
	private Map map;
	
	public PageBean() {
		super();
	}
	
	//设置请求参数
	public void setRequest(HttpServletRequest req) {
		String page=req.getParameter("page");
		String rows=req.getParameter("rows");
		String pagination=req.getParameter("pagination");
		this.setPage(page);
		this.setRows(rows);
		this.setPagination(pagination);
		this.url=req.getContextPath()+req.getServletPath();
		this.map=req.getParameterMap();
	}
	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public Map getMap() {
		return map;
	}

	public void setMap(Map map) {
		this.map = map;
	}

	public int getPage() {
		return page;
	}

	public void setPage(int page) {
		this.page = page;
	}
	
	public void setPage(String page) {
		if(null!=page&&!"".equals(page.trim()))
			this.page = Integer.parseInt(page);
	}

	public int getRows() {
		return rows;
	}

	public void setRows(int rows) {
		this.rows = rows;
	}
	
	public void setRows(String rows) {
		if(null!=rows&&!"".equals(rows.trim()))
			this.rows = Integer.parseInt(rows);
	}

	public int getTotal() {
		return total;
	}

	public void setTotal(int total) {
		this.total = total;
	}
	
	public void setTotal(String total) {
		this.total = Integer.parseInt(total);
	}

	public boolean isPagination() {
		return isPagination;
	}
	
	public void setPagination(boolean isPagination) {
		this.isPagination = isPagination;
	}
	
	public void setPagination(String isPagination) {
		if(null!=isPagination&&!"".equals(isPagination.trim()))
			this.isPagination = Boolean.parseBoolean(isPagination);
	}
	
	/**
	 * 获取分页起始标记位置
	 * @return
	 */
	public int getStartIndex() {
		//(当前页码-1)*显示记录数
		return (this.getPage()-1)*this.rows;
	}
	
	/**
	 * 末页
	 * @return
	 */
	public int getMaxPage() {
		int totalpage=this.total/this.rows;
		if(this.total%this.rows!=0)
			totalpage++;
		return totalpage;
	}
	
	/**
	 * 下一页
	 * @return
	 */
	public int getNextPage() {
		int nextPage=this.page+1;
		if(this.page>=this.getMaxPage())
			nextPage=this.getMaxPage();
		return nextPage;
	}
	
	/**
	 * 上一页
	 * @return
	 */
	public int getPreivousPage() {
		int previousPage=this.page-1;
		if(previousPage<1)
			previousPage=1;
		return previousPage;
	}

	@Override
	public String toString() {
		return "PageBean [page=" + page + ", rows=" + rows + ", total=" + total + ", isPagination=" + isPagination
				+ "]";
	}
}

        其次，建立一个切面类aspect，我们需要使用注解的方式   @Aspect  代表为切面类 @Component  代表该类交给spring管理 ，然后将写在impl里面的分页方法分出来，单独写在切面类里面，将其放在环绕通知中 需要注解 @Around("execution(* *..*Biz.*Pager(..))")    环绕通知

* *..*Biz.*Pager(..)

1. * *..*Service.*List(..)) 第一个* 代表了任意返回值
2. *.. 代表了任意包，不限层级
3. *Biz代表了以Service结尾的类/接口
4. *List 代表了以pager结尾的方法
5. .. 括号的点点 代表了任意参数 符合以上则为目标类或者目标方法

        并且运用了环绕通知的方法，做判断，如果有pageBean作为参数就强转

package com.zking.aspect;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zking.model.Book;
import com.zking.util.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 yinzi
 * @create 2023-08-25 17:05
 */

@Aspect //代表为切面类
@Component  //代表该类交给spring管理
public class PageAspect {

    @Around("execution(* *..*Biz.*List(..))")  //环绕通知
    //* *..*Service.*Pager(..))
    //第一个* 代表了任意返回值
    //*.. 代表了任意包，不限层级
    //*Service 代表了以Service结尾的类/接口
    //*Pager  代表了以pager结尾的方法
    //.. 括号的点点 代表了任意参数
    //符合以上则为目标类或者目标方法
    public Object invoke(ProceedingJoinPoint args) throws Throwable {
        PageBean pageBean=null;
        //获取目标方法的所有参数
        Object[] args1 = args.getArgs();
        for (Object parm:args1){
            //如果有参数是pageBean 那么就强转
            if(parm instanceof PageBean){
                pageBean = (PageBean) parm;
                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((int) info.getTotal());
        }
            return proceed;

    }
}

最后测试：

 

今天的分享就到这啦！！！