Mybatis与spring集成和分页插件以及注解式事务

最新推荐文章于 2020-11-24 05:55:49 发布
最新推荐文章于 2020-11-24 05:55:49 发布
阅读量340 收藏
点赞数
分类专栏： Mybatis 文章标签： Mybatis与spring集成和分页插件以及注解式事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lin_17970/article/details/101435551
版权

Mybatis与spring集成和分页插件以及注解式事务

Mybatis与spring集成

1. 导入pom依赖

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.lin</groupId>
  <artifactId>ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>ssm Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.plugin.version>3.7.0</maven.compiler.plugin.version>

    <!--添加jar包依赖-->
    <!--1.spring 5.0.2.RELEASE相关-->
    <spring.version>5.0.2.RELEASE</spring.version>
    <!--2.mybatis相关-->
    <mybatis.version>3.4.5</mybatis.version>
    <!--mysql-->
    <mysql.version>5.1.44</mysql.version>
    <!--pagehelper分页jar依赖-->
    <pagehelper.version>5.1.2</pagehelper.version>
    <!--mybatis与spring集成jar依赖-->
    <mybatis.spring.version>1.3.1</mybatis.spring.version>
    <!--3.dbcp2连接池相关 druid-->
    <commons.dbcp2.version>2.1.1</commons.dbcp2.version>
    <commons.pool2.version>2.4.3</commons.pool2.version>
    <!--4.log日志相关-->
    <log4j2.version>2.9.1</log4j2.version>
    <!--5.其他-->
    <junit.version>4.12</junit.version>
    <servlet.version>4.0.0</servlet.version>
    <lombok.version>1.18.2</lombok.version>
  </properties>


  <dependencies>
    <!--1.spring相关-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!--2.mybatis相关-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <!--pagehelper分页插件jar包依赖-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>${pagehelper.version}</version>
    </dependency>
    <!--mybatis与spring集成jar包依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis.spring.version}</version>
    </dependency>

    <!--3.dbcp2连接池相关-->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-dbcp2</artifactId>
      <version>${commons.dbcp2.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
      <version>${commons.pool2.version}</version>
    </dependency>

    <!--4.log日志相关依赖-->
    <!--核心log4j2jar包-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>${log4j2.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <version>${log4j2.version}</version>
    </dependency>
    <!--web工程需要包含log4j-web，非web工程不需要-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-web</artifactId>
      <version>${log4j2.version}</version>
    </dependency>

    <!--5.其他-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok.version}</version>
      <scope>provided</scope>
    </dependency>

  </dependencies>

  <build>
    <finalName>ssm</finalName>
    <resources>
      <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
           <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
          <!--**/  -->
        </includes>
      </resource>
      
      <!--解决mybatis-generator-maven-plugin运行时没有将jdbc.properites文件放入target文件夹的问题-->
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>jdbc.properties</include>
          <include>*.xml</include>
        </includes>
      </resource>
    </resources>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>

        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>${maven.compiler.plugin.version}</version>
          <configuration>
            <source>${maven.compiler.source}</source>
            <target>${maven.compiler.target}</target>
            <encoding>${project.build.sourceEncoding}</encoding>
          </configuration>
        </plugin>
        <plugin>
          <groupId>org.mybatis.generator</groupId>
          <artifactId>mybatis-generator-maven-plugin</artifactId>
          <version>1.3.2</version>
          <dependencies>
            <!--使用Mybatis-generator插件不能使用太高版本的mysql驱动 -->
            <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>${mysql.version}</version>
            </dependency>
          </dependencies>
          <configuration>
            <overwrite>true</overwrite>
          </configuration>
        </plugin>

      </plugins>
    </pluginManagement>
  </build>
</project>

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

generatorConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
<generatorConfiguration>
    <!-- 引入配置文件 -->
    <properties resource="jdbc.properties"/>

    <!--指定数据库jdbc驱动jar包的位置-->
    <classPathEntry location="D:\\app\\maven\\maven-repomts\\mysql\\mysql-connector-java\\5.1.44\\mysql-connector-java-5.1.44.jar"/>

    <!-- 一个数据库一个context -->
    <context id="infoGuardian">
        <!-- 注释 -->
        <commentGenerator>
            <property name="suppressAllComments" value="true"/><!-- 是否取消注释 -->
            <property name="suppressDate" value="true"/> <!-- 是否生成注释代时间戳 -->
        </commentGenerator>

        <!-- jdbc连接 -->
        <jdbcConnection driverClass="${jdbc.driver}"
                        connectionURL="${jdbc.url}" userId="${jdbc.username}" password="${jdbc.password}"/>

        <!-- 类型转换 -->
        <javaTypeResolver>
            <!-- 是否使用bigDecimal， false可自动转化以下类型（Long, Integer, Short, etc.） -->
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>

        <!-- 01 指定javaBean生成的位置 -->
        <!-- targetPackage：指定生成的model生成所在的包名 -->
        <!-- targetProject：指定在该项目下所在的路径  -->
        <javaModelGenerator targetPackage="com.lin.model"
                            targetProject="src/main/java">
            <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
            <property name="enableSubPackages" value="false"/>
            <!-- 是否对model添加构造函数 -->
            <property name="constructorBased" value="true"/>
            <!-- 是否针对string类型的字段在set的时候进行trim调用 -->
            <property name="trimStrings" value="false"/>
            <!-- 建立的Model对象是否 不可改变  即生成的Model对象不会有 setter方法，只有构造方法 -->
            <property name="immutable" value="false"/>
        </javaModelGenerator>

        <!-- 02 指定sql映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="com.lin.mapper"
                         targetProject="src/main/java">
            <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>

        <!-- 03 生成XxxMapper接口 -->
        <!-- type="ANNOTATEDMAPPER",生成Java Model 和基于注解的Mapper对象 -->
        <!-- type="MIXEDMAPPER",生成基于注解的Java Model 和相应的Mapper对象 -->
        <!-- type="XMLMAPPER",生成SQLMap XML文件和独立的Mapper接口 -->
        <javaClientGenerator targetPackage="com.lin.mapper"
                             targetProject="src/main/java" type="XMLMAPPER">
            <!-- 是否在当前路径下新加一层schema,false路径com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>

        <!-- 配置表信息 -->
        <!-- schema即为数据库名 -->
        <!-- tableName为对应的数据库表 -->
        <!-- domainObjectName是要生成的实体类 -->
        <!-- enable*ByExample是否生成 example类 -->
        <!--<table schema="" tableName="t_book" domainObjectName="Book"-->
               <!--enableCountByExample="false" enableDeleteByExample="false"-->
               <!--enableSelectByExample="false" enableUpdateByExample="false">-->
            <!--&lt;!&ndash; 忽略列，不生成bean 字段 &ndash;&gt;-->
            <!--&lt;!&ndash; <ignoreColumn column="FRED" /> &ndash;&gt;-->
            <!--&lt;!&ndash; 指定列的java数据类型 &ndash;&gt;-->
            <!--&lt;!&ndash; <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> &ndash;&gt;-->
        <!--</table>-->

        <table schema="" tableName="t_mvc_book" domainObjectName="Book"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
            <!-- 忽略列，不生成bean 字段 -->
            <!-- <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 -->
            <!-- <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> -->
        </table>

    </context>
</generatorConfiguration>

3. 编写配置文件applicationContexts-mybatis.xml

applicationContexts-mybatis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">



    <!--1. 注解式开发 -->
    <!-- 注解驱动 -->
    <context:annotation-config/>
    <!-- 用注解方式注入bean，并指定查找范围：com.lin.ssm及子子孙孙包-->
    <context:component-scan base-package="com.lin"/>

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"
          destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <!--初始连接数-->
        <property name="initialSize" value="10"/>
        <!--最大活动连接数-->
        <property name="maxTotal" value="100"/>
        <!--最大空闲连接数-->
        <property name="maxIdle" value="50"/>
        <!--最小空闲连接数-->
        <property name="minIdle" value="10"/>
        <!--设置为-1时，如果没有可用连接，连接池会一直无限期等待，直到获取到连接为止。-->
        <!--如果设置为N（毫秒），则连接池会等待N毫秒，等待不到，则抛出异常-->
        <property name="maxWaitMillis" value="-1"/>
    </bean>

    <!--4. spring和MyBatis整合 -->
    <!--1) 创建sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 指定数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 自动扫描XxxMapping.xml文件，**任意路径 -->
        <property name="mapperLocations" value="classpath*:com/lin/**/mapper/*.xml"/>
        <!-- 指定别名 -->
        <property name="typeAliasesPackage" value="com/lin/**/model"/>
        <!--设置mybaits对缓存的支持-->
        <property name="configurationProperties">
            <props>
                <!-- 全局映射器启用缓存 *主要将此属性设置完成即可-->
                <prop key="cacheEnabled">true</prop>
                <!-- 查询时，关闭关联对象即时加载以提高性能 -->
                <prop key="lazyLoadingEnabled">false</prop>
                <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 -->
                <prop key="aggressiveLazyLoading">true</prop>
            </props>
        </property>
        <!--配置pagehelper插件-->
        <property name="plugins">
            <array>
                <bean class="com.github.pagehelper.PageInterceptor">
                    <property name="properties">
                        <value>
                            helperDialect=mysql
                        </value>
                    </property>
                </bean>
            </array>
        </property>
    </bean>

    <!--2) 自动扫描com/lin/ssm/**/mapper下的所有XxxMapper接口(其实就是DAO接口)，并实现这些接口，-->
    <!--   即可直接在程序中使用dao接口，不用再获取sqlsession对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--basePackage 属性是映射器接口文件的包路径。-->
        <!--你可以使用分号或逗号 作为分隔符设置多于一个的包路径-->
        <property name="basePackage" value="com/lin/**/mapper"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager" />
    <aop:aspectj-autoproxy/>

</beans>

applicationContexts.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--整合mybatis框架-->
    <import resource="applicationContexts-mybatis.xml" ></import>
</beans>

4. Spring Test+junit完美组合

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

<dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-test</artifactId>
       <version>${spring.version}</version>
     </dependency>

BookService

package com.lin.service;

import com.lin.model.Book;
import com.lin.util.PageBean;

import java.util.List;
import java.util.Map;

/**
 * @authorlinfan
 * @site www.linfanmage.com
 * @company xxx公司
 * @create  2019-09-24 12:05
 */

public interface BookService {

    int deleteByPrimaryKey(Integer bid);

    int insert(Book record);

    int insertSelective(Book record);

    Book selectByPrimaryKey(Integer bid);

    int updateByPrimaryKeySelective(Book record);

    int updateByPrimaryKey(Book record);

    List<Map> aaaa(Map map, PageBean pageBean);

    List<Map> listpager(Map map, PageBean pageBean);
}

BookServiceImpl

package com.lin.service.impl;

import com.lin.mapper.BookMapper;
import com.lin.model.Book;
import com.lin.service.BookService;
import com.lin.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

/**
 * @authorlinfan
 * @site www.linfanmage.com
 * @company xxx公司
 * @create  2019-09-24 12:06
 */
@Service
public class BookServiceImpl implements BookService {
    @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);
    }

    @Override
    public List<Map> aaaa(Map map, PageBean pageBean) {
        return bookMapper.aaaa(map);
    }


    @Override
    public List<Map> listpager(Map map, PageBean pageBean) {
        return bookMapper.aaaa(map);
    }

//    @Override
//    public List<Map> listPager(Map map, PageBean pageBean) {
//        return bookMapper.listPager(map);
//    }
}

创建SpringBaseTest，并在该类上加上两个注解
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={“classpath:applicationContext.xml”})

SpringBaseTest

package com.lin;

import com.lin.model.Book;
import com.lin.service.impl.BookServiceImplTest;
import com.lin.util.PageBean;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @authorlinfan
 * @site www.linfanmage.com
 * @company xxx公司
 * @create  2019-09-24 11:53
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContexts.xml"})
public class SpringBaseTest {
    protected Book book;
    protected PageBean pageBean;

    @Before
    public  void init(){
        book =new Book();
        pageBean =new PageBean();
    }
}

BookServiceImplTest测试类

package com.lin.service.impl;

import com.lin.SpringBaseTest;
import com.lin.model.Book;
import com.lin.service.BookService;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @authorlinfan
 * @site www.linfanmage.com
 * @company xxx公司
 * @create  2019-09-24 14:03
 */

public class BookServiceImplTest extends SpringBaseTest {
    @Autowired
    private BookService bookService;

    @Test
    public void insert() {
        book.setBid(10006);
        book.setBname("T224 ssm");
        book.setPrice(996f);
        this.bookService.insert(book);
    }

    @Test
    public void selectByPrimaryKey() {
        Book b =this.bookService.selectByPrimaryKey(10006);
        System.out.println(b);
    }

 	@Test
    public void aaaa() {
        Map map = new HashMap();
        map.put("bname", StringItils.toLikeStr("圣墟"));
        List<Map> aaaa = this.service.aaaa(map, pageBean);
        for (Map m : aaaa) {
            System.out.println(m);
        }


    }

    @Test
    public void listPager() {
        Map map = new HashMap();
        map.put("bname", StringItils.toLikeStr("圣墟"));
        List<Map> aaaa = this.service.listPager(map, pageBean);
        for (Map m : aaaa) {
            System.out.println(m);
        }
    }

}

Aop整合 pagehelper 插件

  • 使用AOP编程解决分页代码重复的问题
@Around("execution(* *..*Service.*pager(..))")
   public Object invoke(ProceedingJoinPoint args)

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

PagerAspect

package com.lin;

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

/**
 * @authorlinfan
 * @site www.linfanmage.com
 * @company xxx公司
 * @create  2019-09-25 17:13
 *
 * 处理**..*Service.*Pager(..)这个方法，只要调用这个方法，就能够达到分页的效果
 *
 *  pageHelper。start
 *  调用目标方法之前
 *  处理结果集
 *
 *  *pager（map。pagebean）
 */

@Component
@Aspect
public class PagerAspect {
    /*@Around("execution(* *..*service.*pager(..))")*/
    @Around("execution(* *..*vice.*Pager(..))")
    public Object invoke(ProceedingJoinPoint args) throws Throwable{
        //判断符合条件的方法中是否包含pagebean参数
        Object[] params = args.getArgs();
        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(pageBean != null && pageBean.isPagination()){
            PageInfo pageInfo = new PageInfo((List) list);
            pageBean.setTotal(pageInfo.getTotal()+"");
        }

        return list;
    }

}

测试：两个方法测试，如果listPager能分页的数据就说明成功了


  @Test
    public void aaaa() {
        Map map = new HashMap();
        map.put("bname", StringItils.toLikeStr("圣墟"));
        List<Map> aaaa = this.service.aaaa(map, pageBean);
        for (Map m : aaaa) {
            System.out.println(m);
        }


    }


    @Test
    public void listPager() {
        Map map = new HashMap();
        map.put("bname", StringItils.toLikeStr("圣墟"));
        List<Map> aaaa = this.service.listPager(map, pageBean);
        for (Map m : aaaa) {
            System.out.println(m);
        }
    }

注解式事务

事务转载自：https://www.cnblogs.com/geningchao/p/6632283.html

@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两个注解的区别：
相当于之前spring、hibernate时代中的set注入，省去set、get方法

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

注解式事务管理相对声明式事务管理显得更加灵活,我们只需要在需要进行事务管理的方法或者类前加上@Transactional+相关控制参数
注意要点

  1. @Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.

  2. 用 spring 事务管理器,由spring来负责数据库的打开,提交,回滚.默认遇到运行期例外(throw new RuntimeException(“注释”);)会回滚，即遇到不受检查（unchecked）的例外时回滚；而遇到需要捕获的例外(throw new Exception(“注释”);)不会回滚,即遇到受检查的例外（就是非运行时抛出的异常，编译器会检查到的异常叫受检查例外或说受检查异常）时，需我们指定方式来让事务回滚 要想所有异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常}) .如果让unchecked例外不回滚： @Transactional(notRollbackFor=RunTimeException.class)

  3. @Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。然而，请注意仅仅 @Transactional 注解的出现不足于开启事务行为，它仅仅 是一种元数据，能够被可以识别 @Transactional 注解和上述的配置适当的具有事务行为的beans所使用。上面的例子中，其实正是 tx:annotation-driven/元素的出现 开启 了事务行为。

  4. Spring团队的建议是你在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上。你当然可以在接口上使用 @Transactional 注解，但是这将只能当你设置了基于接口的代理时它才生效。因为注解是 不能继承 的，这就意味着如果你正在使用基于类的代理时，那么事务的设置将不能被基于类的代理所识别，而且对象也将不会被事务代理所包装（将被确认为严重的）。因 此，请接受Spring团队的建议并且在具体的类上使用 @Transactional 注解。

LIN_17970
关注
专栏目录
Mybatis：注解方式使用PageHeler分页插件
q736317048的博客
12-25 1063
原有分页查询需要执行两条查询语句 SELECT * FROM video LIMIT 0,3 SELECT COUNT(*) FROM video 使用注解的方式完成PageHelper插件分页 dao层 就写一个最简单的查询语句就OK /** * 查询全部视频列表 * @return */ @Select("SELECT * FROM video") List<Video> listVideo(); Step1：引入依赖 <
Spring框架下分页功能的java实现（使用注解）
z2014ypd的博客
03-12 1232
分页功能 之前写分页功能时，网上的很多都不完整，不容易看明白，解释不清楚。现在自己实现了之歌功能，便详细写写，供大家参考。 注解层 用于自动定位到数据库进行数据的查找。 &amp;lt;关联表&amp;gt; package cn.itsource.annotation; import java.lang.annotation.Documented; import java.lang.annotation.E...
Mybatis与spring集成和分页插件
what_where的博客
09-24 1329
Mybatis与spring集成和分页插件Mybatis 与spring集成1.添加相关依赖2、利用mybatis逆向工程生成模型层层代码3、编写配置文件applicationContext-mybatis.xml4、Spring Test+junit完美组合常用的注解Aop整合 pagehelper 插件 Mybatis 与spring集成 1.添加相关依赖 <?xml version="...
SpringBoot-15-之整合MyBatis-注解篇+分页
dianju8374的博客
08-17 356
0.相关配置 pom.xml <!--mysql依赖--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> ...
mybatis分页插件_[Mybatis]-[基础支持层]-插件-第三方分页插件简单剖析
weixin_39874881的博客
11-24 111
该系列文章针对 Mybatis 3.5.1 版本在 mybatis 中允许针对 SQL 在执行前后进行扩展操作，而这些扩展操作也叫做插件。在 Mybaits 中允许用插件来拦截的方法包括：Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)ParameterHandl...
SpringBoot整合Mybatis及分页插件pageHelper和事务
qq_36594703的博客
07-31 594
spring事务分类： 1.声明事务 2.编程事务 spring事务原理：AOP技术 环绕通知进行拦截 使用spring事务的注意事项：不要Try。因为要将异常抛出给外层 Springboot默认集成事务，只要在方法上加上@Transactional注解 pom.xml配置文件： &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xm...
spring boot和mybatis集成分页插件
08-30
Spring Boot与MyBatis集成分页插件 Spring Boot与MyBatis集成分页插件是一种常用的解决方案，它可以帮助开发者快速实现分页功能。下面我们将详细介绍如何集成Spring Boot与MyBatis的分页插件。 什么是MyBatis ...
Spring集成MyBatis 通用Mapper以及 pagehelper分页插件
04-05
PageHelper是另一个MyBatis的分页插件，它提供了强大的分页功能，可以无缝地与MyBatis和Spring整合。PageHelper不仅支持简单的物理分页，还支持逻辑分页，且兼容各种数据库，如MySQL、Oracle、SQL Server等。在使用...
spring mybatis 通用mapper 和分页插件的集成
最新发布
02-02
本文将详细介绍如何将Spring、MyBatis、通用Mapper与分页插件进行集成。 首先，我们需要理解每个组件的作用： 1. Spring：这是一个全面的开源应用框架，提供依赖注入（DI）、面向切面编程（AOP）以及各种企业级...
MyBatis基于Spring-boot集成通用Mapper以及pagehelper分页插件
09-17
首先，`MyBatis`是MyBatis-Spring的集成，它为Spring环境下的MyBatis提供了一个简单的配置和强大的事务管理。通过Spring的Bean管理，我们可以方便地在Service层注入Mapper接口，无需编写DAO层，使得代码更加简洁。 ...
Spring与Mybatis整合&&aop整合pageHelper分页插件
08-25
Spring与Mybatis的整合，可以利用Spring的管理能力，将Mybatis的SqlSession、Mapper接口和事务管理统一起来，提高代码的可维护性和测试性。 1. Spring与Mybatis的整合步骤： - 配置Mybatis的SqlSessionFactoryBean...
使用spring,pageHelper ，注解完成分页。
weixin_30466953的博客
06-13 204
第一步 maven 依赖pageHeler aspectj 开启aop的注解 基础工作完成！第二步： 建立一个注解 建立注解实现，建立环绕通知 最后一步：加上 @EnablePaging 注解 就可以完成分页！ 转载于:https://www.cnblogs.com/whm-blog/p/7000478.html...
Spring Boot 项目学习 (二) MySql + MyBatis 注解 + 分页控件 配置
weixin_30408675的博客
06-19 82
引言 　　本文主要在Spring Boot 基础项目的基础上，添加 Mysql 、MyBatis（注解方式）与 分页控件 的配置，用于协助完成数据库操作。 创建数据表 　　这个过程就暂时省略了。 搭建 MyBatis 修改pom.xml，添加一下依赖 <!-- mybatis --> <dependency> ...
SSM利用PageHelper插件进行分页(配置文件版+注解版)
qq_43059621的博客
02-26 928
PageHelper只针对Mybatis有用 1.导PageHelper坐标(尽量导坐标,不要自己下jar包) <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version&...
注解方式集成MyBatis-PageHelper分页
谢文峰的博客
06-23 3093
  1.后台引入pagehelper依赖  springboot版本为1.5.3 &lt;!-- springboot-aop包,AOP切面注解,Aspectd等相关注解 --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spr...
【PageHelper】SpringBoot之分页插件PageHelper的使用
热门推荐
engineer_hzl
02-23 4万+
在springboot中使用PageHelper插件有两种较为相似的方式，接下来我就将这两种方式进行总结。 方式一：使用原生的PageHelper 1.在pom.xml中引入依赖 <dependency> <groupId>com.github.pagehelper</groupId> &l...
Spring中集成Mybatis分页插件PageHelper
chenjunfengf的博客
08-06 2597
1. 使用Maven方式引入分页插件 在pom.xml中添加如下依赖： <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version>5.0.0</version> </dependency>2. 配置拦截器插件 在Spring配置文件中配置
SpringBoot 通过注解的方式整合 Mybatis + PageHelper 分页显示
村雨遥
07-27 871
文章目录1. 前言2. 整合过程2.1 新建 Spring Boot 项目2.2 添加 pom 依赖2.3 准备数据库2.4 pojo 层2.5 dao 层2.6 util 层2.7 service 层2.8 controller 层2.9 入口程序配置2.10 网页测试 1. 前言 本篇博客主要利用 SpringBoot 通过注解的方式整合 Mybatis 同时利用 PageHelper 对结果分页，所有涉及的代码已经上传 Github mybatis-pagehelper。下面是整个整合过程，接下来开
Mybatis分页插件&注解模式
qq_41028544的博客
10-18 1412
Mybatis分页插件 1. 分页插件的依赖 <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version>5.1.10</version> </dependency> 2. 在核心配置文件中配置分页查询 3. 分页代码
Spring与MyBatis集成通用Mapper及分页插件指南
以下是基于Spring、MyBatis、通用mapper和分页插件集成的一个简单配置示例： 1. Spring配置文件示例： ```xml <!-- 数据源配置 --> ***mons.dbcp.BasicDataSource" destroy-method="close"> <!-- ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值