mybatis之spring集成

一、ybatis与spring集成

添加spring相关依赖(5.0.2.RELEASE)：

spring-core、spring-beans、spring-context、spring-orm、spring-tx、

spring-aspects、spring-web

添加mybatis相关依赖：

mybatis核心：mybatis(3.4.5)、Mybatis分页：pagehelper(5.1.2)

spring整合mybatis(1.3.1)：

mybatis-spring

添加dbcp2连接池：

commons-dbcp2(2.1.1)、commons-pool2(2.4.3)

添加日志配置(2.9.1)：

log4j-core、 log4j-api、log4j-web

其他：

junit(4.12)、javax.servlet-api(4.0.0)、lombok(1.18.2)

注：使用mybatis-generator插件，pom文件添加支持

1、导入pom.xml相关插件




    
        ssm
        org.example
        1.0-SNAPSHOT
    
    4.0.0

    Mybatise
    war

    Mybatise 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}
            test
        
        
            javax.servlet
            javax.servlet-api
            ${servlet.version}
            provided
        
        
            org.projectlombok
            lombok
            ${lombok.version}
            provided
        
    
    
        ssm
        
            
            
                src/main/java
                
                    **mappermodel"/>
        
        
            
                
                    
                        
                            helperDialect=mysql

5、Spring Test+junit完美组合

①、在工程的pom文件中增加spring-test的依赖

我已经在前面就增加了依赖



org.springframework spring-test

${spring.version}

②、创建测试类，在该类上加上两个注解

@RunWith(SpringJUnit4ClassRunner.class)：用于指定junit运行环境，是junit提供给其他框架测试环境接口扩展，为了便于使用spring的依赖注入
@ContextConfiguration(locations={"classpath:applicationContext-mybatis.xml"})：可以用classes来直接导入同包下写的配置类。或者导入配置文件

   @RunWith(SpringJUnit4ClassRunner.class)
   @ContextConfiguration(locations={"classpath:applicationContext.xml"})

同样service层也需注解，这样无需写get/set方法：

（@Autowired：是可以让spring完成自动装配的用途）

测试一下查看的方法，检查是否成功：

这里用上篇博客的代码进行修改并验证

package com.zxy.service.imp;
import com.zxy.mapper.BookMapper;
import com.zxy.model.Book;
import com.zxy.service.BookService;
import com.zxy.util.PageBean;
import com.zxy.util.SessionUtil;
import com.zxy.vo.BookVo;
import org.apache.ibatis.session.SqlSession;
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 java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext-mybatis.xml"})
public class BookServiceImplTest2 {
@Autowired
    private BookService bookService;
    private SqlSession sqlSession;


    @Before
    public void setUp() throws Exception {

    }

    @After
    public void tearDown() throws Exception {

    }

    @Test
    public void selectBooksIn() {
        System.out.println("mybatis的foreach方法");
        List books = this.bookService.selectBooksIn(Arrays.asList(new Integer[]{35, 36, 37}));
        books.forEach(System.out::println);
    }

    @Test
    public void testDeleteByPrimaryKey() {
        System.out.println("业务方法");
        this.bookService.deleteByPrimaryKey(23);
    }

    @Test
    public void selectBooksLike1() {
        System.out.println("#模糊查询");
        List books = this.bookService.selectBooksLike1("%圣墟%");
        books.forEach(System.out::println);
    }
    @Test
    public void selectBooksLike2() {
        System.out.println("$模糊查询");
        List books = this.bookService.selectBooksLike2("%圣墟%");
        books.forEach(System.out::println);
    }
    @Test
    public void selectBooksLike3() {
        System.out.println("Concat模糊查询");
        List books = this.bookService.selectBooksLike3("圣墟");
        books.forEach(System.out::println);
    }

    @Test
    public void List1() {
        System.out.println("使用resultMap返回自定义类型集合");
        List books = this.bookService.list1();
        books.forEach(System.out::println);
    }
    @Test
    public void List2() {
        System.out.println("使用resultType返回List");
        List books = this.bookService.list2();
        books.forEach(System.out::println);
    }
    @Test
    public void List3() {
        System.out.println("使用resultType返回单个对象");
        BookVo booKVo = new BookVo();
        booKVo.setBookIds(Arrays.asList(new Integer[]{49}));
        System.out.println(this.bookService.list3(booKVo));
    }
    @Test
    public void List4() {
        System.out.println("使用resultType返回List，适用于多表查询返回结果集");
        List books = this.bookService.list4();
        books.forEach(System.out::println);
    }
    @Test
    public void List5() {
        System.out.println("使用resultType返回Map，适用于多表查询返回单个结果");
        Map map = new HashMap();
        map.put("bid",49);
        Map m = this.bookService.list5(map);
        System.out.println(m);
    }

    


    @Test
    public void testPager() {
        System.out.println("分页");
        Map map = new HashMap();
        map.put("bname","圣墟");
        PageBean pageBean = new PageBean();
        pageBean.setPage(4);
//        不分页
//        pageBean.setPagination(false);
        List m = this.bookService.listPager(map,pageBean);
        System.out.println(m);
    }

    @Test
    public void testlist6(){
        System.out.println("特殊字符的处理--");
        BookVo booKVo = new BookVo();
        booKVo.setMin(20f);
        booKVo.setMax(50f);
        List books = this.bookService.list6(booKVo);
        books.forEach(System.out::println);
    }
    @Test
    public void testlist7(){
        System.out.println("特殊字符的处理--");
        BookVo booKVo = new BookVo();
        booKVo.setMin(20f);
        booKVo.setMax(50f);
        List books = this.bookService.list7(booKVo);
        books.forEach(System.out::println);
    }

    @Test
    public void selectByPrimaryKey() {
        System.out.println(this.bookService.selectByPrimaryKey( 45));
    }
}

二、aop整合pagehelper

如果一个项目里有很多分页，每次都按照上一期内容写很麻烦，内容重复，这节内容就是使用AOP编程解决分页代码重复的问题。以下是每次分页需要写的方法

根据总结分页内容：

①、定义分页的方法，分页方法至少要传递两个参数

②、分页的核心关键点：pageBean、PageHelper

③、代码逻辑顺序

PageHelper.startPage 启动分页

正常业务查询——》加入环绕通知中

处理查询的结果集——》加入环绕通知中
1、切面中需要思考的部分
1、pageHelper.startPage 启动分页>处理查询结果集>加入环绕通知中

2、切面类上要定义规则，只有分页方法才能进切面类

3、必须要判断*Pager是否传递了pageBean
2、编码阶段
1、拿到被代理的方法的参数列表，进行遍历，如果列表中包含了pagebean，给pagebean赋值

2、核心代码： PageHelper.startPage 启动分页>正常查询业务>处理查询结果集

1、新建一个切面类（类型为Java类class）

package com.zxy.aspect;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zxy.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;

@Component
@Aspect
public class PagerAspect {

    @Around("execution(* *..*Service.*Pager(..))")
    public Object invoke(ProceedingJoinPoint args) throws Throwable {
        Object[] params = args.getArgs();//argument参数
        PageBean pageBean = null;
        for (Object param : params) {
            if(param instanceof PageBean){
                pageBean = (PageBean)param;
                break;
            }
        }

        if(pageBean != null && pageBean.isPagination()) {
            PageHelper.startPage(pageBean.getPage(), pageBean.getRows());
        }
        Object list = args.proceed(params);

        if(null != pageBean && pageBean.isPagination()){
            PageInfo pageInfo = new PageInfo((List) list);
            pageBean.setTotal(pageInfo.getTotal()+"");
        }
        return list;
    }

}

mybatis之spring集成

Java相关栏目本月热门文章