• Mybatis 快速入门之mybatis与spring集成

    目录

    一：基本概念撰述

    1. SqlSessionFactory对象，只有创建了SqlSessionFactory对象，才能调用openSession()方法得到SqlSession对象。

    2. dao接口的代理对象，例如StudentDao接口，需要的代理对象为：SqlSeesion.getMapper(StudentDao.class)。

    3. 数据源DataSource对象，使用一个更强大、功能更多的连接池对象代替mybatis自己的PooledDataSource。

    二：将Mybatis与Spring集成的相关操作步骤

    1：对pom.xml文件添加相关依赖

    2：创建xml文件

    3.通过插件自动生成代码

    4.使用注解式开发开发方式完成开发

     @Repository：将Mapper类扫描后注入到Spring上下文(IOC)中定义成bean对象,通常作用在Mapper层

      @Service：将实现类扫描后注入到Spring上下文(IOC)中定义成bean对象,通常作用在service的实现类上(非接口)

        @Controller：将Controller类扫描后注入到Spring上下文(IOC)中定义成bean对象，通常作用在控制层，将在Spring MVC中使用

        @Component：是一个泛化的概念，仅仅表示spring中的一个组件（Bean），可以作用在任何层次

      @Scope：模式声明（singleton单模|prototype多模）

        @Autowired：将自动在代码上下文与其匹配（默认是类型匹配）的Bean，并自动注入到相应的地方

     @Resource：

    @Resource后面没有任何内容，默认通过name属性去匹配bean，找不到再按type去匹配

    指定了name或者type则根据指定的类型去匹配bean

    指定了name和type则根据指定的name和type去匹配bean，任何一个不匹配都将报错

      @Transactional：在方法调用之前开启事务,在方法调用之后提交事务或者回滚事务，可以添加定任意地方

      5.Spring Test+Junit完美组合

    6.   使用AOP编程完成分页

    一：基本概念撰述

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

               实现 Spring 与 MyBatis 的整合常用的方式：扫描的 Mapper 动态代理Spring 像插线板一样，mybatis 框架是插头，可以容易的组合到一起。插线板 spring 插上 mybatis，两个框架就是一个整体。

                使用mybatis，需要创建mybatis框架中的某些对象，使用这些对象，就可以使用mybatis提供的功能了。

    对于mybatis执行sql语句，需要用到的对象有：

    1. SqlSessionFactory对象，只有创建了SqlSessionFactory对象，才能调用openSession()方法得到SqlSession对象。

    2. dao接口的代理对象，例如StudentDao接口，需要的代理对象为：SqlSeesion.getMapper(StudentDao.class)。

    3. 数据源DataSource对象，使用一个更强大、功能更多的连接池对象代替mybatis自己的PooledDataSource。

    二：将Mybatis与Spring集成的相关操作步骤

    1：对pom.xml文件添加相关依赖

             在Mybatis与Spring集成中所需要添加依赖如下：

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

    • spring-core
    • spring-beans
    • spring-context
    • spring-orm
    • spring-tx
    • spring-aspects
    • spring-web
    1. //Spring版本
    2. <spring.version>5.0.2.RELEASEspring.version>
    1.  
    2.     <dependency>
    3.       <groupId>org.springframeworkgroupId>
    4.       <artifactId>spring-coreartifactId>
    5.       <version>${spring.version}version>
    6.     dependency>
    7.     
    8.     <dependency>
    9.       <groupId>org.springframeworkgroupId>
    10.       <artifactId>spring-beansartifactId>
    11.       <version>${spring.version}version>
    12.     dependency>
    13.     
    14.     <dependency>
    15.       <groupId>org.springframeworkgroupId>
    16.       <artifactId>spring-contextartifactId>
    17.       <version>${spring.version}version>
    18.     dependency>
    19.     
    20.     <dependency>
    21.       <groupId>org.springframeworkgroupId>
    22.       <artifactId>spring-ormartifactId>
    23.       <version>${spring.version}version>
    24.     dependency>
    25.     <dependency>
    26.       <groupId>org.springframeworkgroupId>
    27.       <artifactId>spring-txartifactId>
    28.       <version>${spring.version}version>
    29.     dependency>
    30.     
    31.     <dependency>
    32.       <groupId>org.springframeworkgroupId>
    33.       <artifactId>spring-aspectsartifactId>
    34.       <version>${spring.version}version>
    35.     dependency>
    36.     
    37.     <dependency>
    38.       <groupId>org.springframeworkgroupId>
    39.       <artifactId>spring-webartifactId>
    40.       <version>${spring.version}version>
    41.     dependency>
    42.     
    43.     <dependency>
    44.       <groupId>org.springframeworkgroupId>
    45.       <artifactId>spring-testartifactId>
    46.       <version>${spring.version}version>
    47.     dependency>

           注意：spring 5.0.1.RELEASE有冲突

    ②： 添加mybatis相关依赖

    • mybatis核心：mybatis(3.4.5)
    • Mybatis分页：pagehelper(5.1.2)
    1.     
    2.     <mybatis.version>3.4.5mybatis.version>
    3.     
    4.     <pagehelper.version>5.1.2pagehelper.version>
    1.   
    2.     <dependency>
    3.       <groupId>org.mybatisgroupId>
    4.       <artifactId>mybatisartifactId>
    5.       <version>${mybatis.version}version>
    6.     dependency>
    7.     
    8.     <dependency>
    9.       <groupId>com.github.pagehelpergroupId>
    10.       <artifactId>pagehelperartifactId>
    11.       <version>${pagehelper.version}version>
    12.     dependency>

        ③：spring整合mybatis(1.3.1)

    •    mybatis-spring
    1.  
    2.     <mybatis.spring.version>1.3.1mybatis.spring.version>
    1.    
    2.     <dependency>
    3.       <groupId>org.mybatisgroupId>
    4.       <artifactId>mybatis-springartifactId>
    5.       <version>${mybatis.spring.version}version>
    6.     dependency>

      ④：添加dbcp2连接池

    • commons-dbcp2(2.1.1)
    •  commons-pool2(2.4.3)
    1.  
    2.     <commons.dbcp2.version>2.1.1commons.dbcp2.version>
    3.     <commons.pool2.version>2.4.3commons.pool2.version>
    1.   
    2.     <dependency>
    3.       <groupId>org.apache.commonsgroupId>
    4.       <artifactId>commons-dbcp2artifactId>
    5.       <version>${commons.dbcp2.version}version>
    6.     dependency>
    7.     <dependency>
    8.       <groupId>org.apache.commonsgroupId>
    9.       <artifactId>commons-pool2artifactId>
    10.       <version>${commons.pool2.version}version>
    11.     dependency>

    ⑤：添加日志配置(2.9.1)

    • log4j-core
    • log4j-api
    • log4j-web
    1.  
    2.     <log4j2.version>2.9.1log4j2.version>
    1.  
    2.     <dependency>
    3.       <groupId>org.apache.logging.log4jgroupId>
    4.       <artifactId>log4j-coreartifactId>
    5.       <version>${log4j2.version}version>
    6.     dependency>
    7.     <dependency>
    8.       <groupId>org.apache.logging.log4jgroupId>
    9.       <artifactId>log4j-apiartifactId>
    10.       <version>${log4j2.version}version>
    11.     dependency>

    ⑥： 其他

    •  junit(4.12)
    •  javax.servlet-api(4.0.0)
    1.     
    2.     <junit.version>4.13junit.version>
    3.     <servlet.version>4.0.1servlet.version>
    1.   
    2.     <dependency>
    3.       <groupId>junitgroupId>
    4.       <artifactId>junitartifactId>
    5.       <version>${junit.version}version>
    6.       <scope>testscope>
    7.     dependency>
    8.     <dependency>
    9.       <groupId>javax.servletgroupId>
    10.       <artifactId>javax.servlet-apiartifactId>
    11.       <version>${servlet.version}version>
    12.     dependency>

    完整版pom.xml文件代码如下：

    2.  
    3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.   <modelVersion>4.0.0modelVersion>
    6.  
    7.   <groupId>com.tangyuangroupId>
    8.   <artifactId>ssmartifactId>
    9.   <version>1.0-SNAPSHOTversion>
    10.   <packaging>warpackaging>
    11.  
    12.   <name>ssm Maven Webappname>
    13.   
    14.   <url>http://www.example.comurl>
    15.  
    16.   <properties>
    17.     <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    18.     <maven.compiler.source>1.8maven.compiler.source>
    19.     <maven.compiler.target>1.8maven.compiler.target>
    20.  
    21.     
    22.     <junit.version>4.13junit.version>
    23.     <servlet.version>4.0.1servlet.version>
    24.     
    25.     <spring.version>5.0.2.RELEASEspring.version>
    26.     
    27.     <mybatis.version>3.4.5mybatis.version>
    28.     
    29.     <mybatis.spring.version>1.3.1mybatis.spring.version>
    30.     
    31.     <mysql.version>5.1.44mysql.version>
    32.     
    33.     <commons.dbcp2.version>2.1.1commons.dbcp2.version>
    34.     <commons.pool2.version>2.4.3commons.pool2.version>
    35.     
    36.     <log4j2.version>2.9.1log4j2.version>
    37.     
    38.     <lombok.version>1.18.12lombok.version>
    39.     
    40.     <pagehelper.version>5.1.2pagehelper.version>
    41.  
    42.   properties>
    43.  
    44.   <dependencies>
    45.     
    46.     <dependency>
    47.       <groupId>junitgroupId>
    48.       <artifactId>junitartifactId>
    49.       <version>${junit.version}version>
    50.       <scope>testscope>
    51.     dependency>
    52.     <dependency>
    53.       <groupId>javax.servletgroupId>
    54.       <artifactId>javax.servlet-apiartifactId>
    55.       <version>${servlet.version}version>
    56.     dependency>
    57.     
    58.     <dependency>
    59.       <groupId>org.springframeworkgroupId>
    60.       <artifactId>spring-coreartifactId>
    61.       <version>${spring.version}version>
    62.     dependency>
    63.     
    64.     <dependency>
    65.       <groupId>org.springframeworkgroupId>
    66.       <artifactId>spring-beansartifactId>
    67.       <version>${spring.version}version>
    68.     dependency>
    69.     
    70.     <dependency>
    71.       <groupId>org.springframeworkgroupId>
    72.       <artifactId>spring-contextartifactId>
    73.       <version>${spring.version}version>
    74.     dependency>
    75.     
    76.     <dependency>
    77.       <groupId>org.springframeworkgroupId>
    78.       <artifactId>spring-ormartifactId>
    79.       <version>${spring.version}version>
    80.     dependency>
    81.     <dependency>
    82.       <groupId>org.springframeworkgroupId>
    83.       <artifactId>spring-txartifactId>
    84.       <version>${spring.version}version>
    85.     dependency>
    86.     
    87.     <dependency>
    88.       <groupId>org.springframeworkgroupId>
    89.       <artifactId>spring-aspectsartifactId>
    90.       <version>${spring.version}version>
    91.     dependency>
    92.     
    93.     <dependency>
    94.       <groupId>org.springframeworkgroupId>
    95.       <artifactId>spring-webartifactId>
    96.       <version>${spring.version}version>
    97.     dependency>
    98.     
    99.     <dependency>
    100.       <groupId>org.springframeworkgroupId>
    101.       <artifactId>spring-testartifactId>
    102.       <version>${spring.version}version>
    103.     dependency>
    104.     
    105.     
    106.     <dependency>
    107.       <groupId>mysqlgroupId>
    108.       <artifactId>mysql-connector-javaartifactId>
    109.       <version>${mysql.version}version>
    110.     dependency>
    111.    
    112.     
    113.     <dependency>
    114.       <groupId>org.mybatisgroupId>
    115.       <artifactId>mybatisartifactId>
    116.       <version>${mybatis.version}version>
    117.     dependency>
    118.     
    119.     
    120.     <dependency>
    121.       <groupId>com.github.pagehelpergroupId>
    122.       <artifactId>pagehelperartifactId>
    123.       <version>${pagehelper.version}version>
    124.     dependency>
    125.     
    126.     
    127.     <dependency>
    128.       <groupId>org.mybatisgroupId>
    129.       <artifactId>mybatis-springartifactId>
    130.       <version>${mybatis.spring.version}version>
    131.     dependency>
    132.     
    133.     
    134.     <dependency>
    135.       <groupId>org.apache.commonsgroupId>
    136.       <artifactId>commons-dbcp2artifactId>
    137.       <version>${commons.dbcp2.version}version>
    138.     dependency>
    139.     
    140.     <dependency>
    141.       <groupId>org.apache.commonsgroupId>
    142.       <artifactId>commons-pool2artifactId>
    143.       <version>${commons.pool2.version}version>
    144.     dependency>
    145.     
    146.     <dependency>
    147.       <groupId>org.apache.logging.log4jgroupId>
    148.       <artifactId>log4j-coreartifactId>
    149.       <version>${log4j2.version}version>
    150.     dependency>
    151.     <dependency>
    152.       <groupId>org.apache.logging.log4jgroupId>
    153.       <artifactId>log4j-apiartifactId>
    154.       <version>${log4j2.version}version>
    155.     dependency>
    156.     
    157.     <dependency>
    158.       <groupId>org.apache.logging.log4jgroupId>
    159.       <artifactId>log4j-webartifactId>
    160.       <version>${log4j2.version}version>
    161.     dependency>
    162.     
    163.     <dependency>
    164.       <groupId>org.projectlombokgroupId>
    165.       <artifactId>lombokartifactId>
    166.       <version>${lombok.version}version>
    167.       <scope>providedscope>
    168.     dependency>
    169.   dependencies>
    170.  
    171.   <build>
    172.     <finalName>ssmfinalName>
    173.     <plugins>
    174.       <plugin>
    175.         <groupId>org.apache.maven.pluginsgroupId>
    176.         <artifactId>maven-compiler-pluginartifactId>
    177.         <version>3.7.0version>
    178.         <configuration>
    179.           <source>${maven.compiler.source}source>
    180.           <target>${maven.compiler.target}target>
    181.           <encoding>${project.build.sourceEncoding}encoding>
    182.         configuration>
    183.       plugin>
    184.       <plugin>
    185.         <groupId>org.mybatis.generatorgroupId>
    186.         <artifactId>mybatis-generator-maven-pluginartifactId>
    187.         <version>1.3.2version>
    188.         <dependencies>
    189.           
    190.           <dependency>
    191.             <groupId>mysqlgroupId>
    192.             <artifactId>mysql-connector-javaartifactId>
    193.             <version>${mysql.version}version>
    194.           dependency>
    195.         dependencies>
    196.         <configuration>
    197.           <overwrite>trueoverwrite>
    198.         configuration>
    199.       plugin>
    200.     plugins>
    201.   build>
    202. project>

    2：创建xml文件

      (1)：spring.xml文件

    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    6.  
    7.   
    8.   <import resource="spring-mybatis.xml"/>
    9.  
    10. beans>

        (2):spring-mybatis.xml(重点文件：mybatis与spring的集成配置)

       ①：开启注解式开发,并指定扫描包的位置

    1.     
    2.     
    3.     <context:annotation-config/>
    4.     
    5.     <context:component-scan base-package="com.tangyuan"/>

     

     ②：引入外部jdbc配置文件

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

       ③：配置dbcp2数据库连接池 

    1. <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"
    2.           destroy-method="close">
    3.         <property name="driverClassName" value="${jdbc.driver}"/>
    4.         <property name="url" value="${jdbc.url}"/>
    5.         <property name="username" value="${jdbc.username}"/>
    6.         <property name="password" value="${jdbc.password}"/>
    7.         
    8.         <property name="initialSize" value="${jdbc.initialSize}"/>
    9.         
    10.         <property name="maxTotal" value="${jdbc.maxTotal}"/>
    11.         
    12.         <property name="maxIdle" value="${jdbc.maxIdle}"/>
    13.         
    14.         <property name="minIdle" value="${jdbc.minIdle}"/>
    15.         
    16.         
    17.         <property name="maxWaitMillis" value="${jdbc.maxWaitMillis}"/>
    18.     bean>

       

    ④：实现spring和mybatis整合

    2.     
    3.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    4.         
    5.         <property name="dataSource" ref="dataSource"/>
    6.         
    7.         <property name="mapperLocations" value="classpath*:com/tangyuan/**/mapper/*.xml"/>
    8.         
    9.         <property name="typeAliasesPackage" value="com/tangyuan/**/model"/>
    10.         
    11.         <property name="plugins">
    12.             <array>
    13.                 <bean class="com.github.pagehelper.PageInterceptor">
    14.                     <property name="properties">
    15.                         <value>
    16.                             helperDialect=mysql
    17.                         value>
    18.                     property>
    19.                 bean>
    20.             array>
    21.         property>
    22.      
    23.         <property name="configuration">
    24.             <bean class="org.apache.ibatis.session.Configuration">
    25.                   
    26.                   
    27.                 <property name="mapUnderscoreToCamelCase" value="true">property>
    28.             bean>
    29.         property>
    30.     bean>
    31.  
    32.     
    33.     
    34.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    35.         
    36.         
    37.         <property name="basePackage" value="com/tangyuan/**/mapper"/>
    38.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    39.     bean>

       ps：第四步操作用来替代以前的MybatisSessionFactoryUtils文件,让代码更加简洁明了，如果对此文件感兴趣的，可以参考以下博客：

    Mybatis 快速入门第一节 入门基础_靖康之耻的博客-CSDN博客MVC全名是ModelViewCotroller,是模型(model)——视图(view)——控制器（controller）的缩写,是一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码自定义MVCSSMaction(中转站-----servlet类)controller(控制层)biz(业务逻辑处理层)servicedao(数据访问层)mapperIXxxDAO.java(接口)XxxMapper.java(接口)XxxDAOImpl.java(实现类)...https://blog.csdn.net/qq_61313896/article/details/125969558

       ⑤：开启注解式事物配置

    1.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    2.         <property name="dataSource" ref="dataSource" />
    3.     bean>
    4.     
    5.     <tx:annotation-driven transaction-manager="transactionManager" />

        ps：第五步操作用来替代以前的junit4单元测试的操作代码，让测试更加便捷，如果有感兴趣的，可以参考以前的博客：

    Mybatis 快速入门第一节 入门基础_靖康之耻的博客-CSDN博客MVC全名是ModelViewCotroller,是模型(model)——视图(view)——控制器（controller）的缩写,是一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码自定义MVCSSMaction(中转站-----servlet类)controller(控制层)biz(业务逻辑处理层)servicedao(数据访问层)mapperIXxxDAO.java(接口)XxxMapper.java(接口)XxxDAOImpl.java(实现类)...https://blog.csdn.net/qq_61313896/article/details/125969558         将dbcp2数据库连接池通过ref方式注入到事物管理器中，只要拿到数据源，就能进行事务开启

       ⑥：开启动态代理

     <aop:aspectj-autoproxy/>
    外部jdbc配置文件如下：

    1. jdbc.driver=com.mysql.jdbc.Driver
    2. jdbc.url=jdbc:mysql://localhost:3306/db_shopping?useUnicode=true&characterEncoding=UTF-8&useSSL=false
    3. jdbc.username=root
    4. jdbc.password=1234
    5. jdbc.initialSize=10
    6. jdbc.maxTotal=100
    7. jdbc.maxIdle=50
    8. jdbc.minIdle=10
    9. jdbc.maxWaitMillis=-1
    我的spring-mybatis.xml文件代码如下：
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    5.        xmlns:aop="http://www.springframework.org/schema/aop"
    6.        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">
    7.  
    8.     
    9.     
    10.     
    11.     <context:annotation-config/>
    12.     
    13.     <context:component-scan base-package="com.tangyuan"/>
    14.     
    15.     <context:property-placeholder location="classpath:jdbc.properties"/>
    16.     
    17.     <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"
    18.           destroy-method="close">
    19.         <property name="driverClassName" value="${jdbc.driver}"/>
    20.         <property name="url" value="${jdbc.url}"/>
    21.         <property name="username" value="${jdbc.username}"/>
    22.         <property name="password" value="${jdbc.password}"/>
    23.         
    24.         <property name="initialSize" value="${jdbc.initialSize}"/>
    25.         
    26.         <property name="maxTotal" value="${jdbc.maxTotal}"/>
    27.         
    28.         <property name="maxIdle" value="${jdbc.maxIdle}"/>
    29.         
    30.         <property name="minIdle" value="${jdbc.minIdle}"/>
    31.         
    32.         
    33.         <property name="maxWaitMillis" value="${jdbc.maxWaitMillis}"/>
    34.     bean>
    35.     
    36.     
    37.     
    38.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    39.         
    40.         <property name="dataSource" ref="dataSource"/>
    41.         
    42.         <property name="mapperLocations" value="classpath*:com/tangyuan/**/mapper/*.xml"/>
    43.         
    44.         <property name="typeAliasesPackage" value="com/tangyuan/**/model"/>
    45.         
    46.         <property name="plugins">
    47.             <array>
    48.                 <bean class="com.github.pagehelper.PageInterceptor">
    49.                     <property name="properties">
    50.                         <value>
    51.                             helperDialect=mysql
    52.                         value>
    53.                     property>
    54.                 bean>
    55.             array>
    56.         property>
    57.      
    58.         <property name="configuration">
    59.             <bean class="org.apache.ibatis.session.Configuration">
    60.                   
    61.                   
    62.                 <property name="mapUnderscoreToCamelCase" value="true">property>
    63.             bean>
    64.         property>
    65.     bean>
    66.  
    67.     
    68.     
    69.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    70.         
    71.         
    72.         <property name="basePackage" value="com/tangyuan/**/mapper"/>
    73.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    74.     bean>
    75.  
    76.     
    77.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    78.         <property name="dataSource" ref="dataSource" />
    79.     bean>
    80.     
    81.     <tx:annotation-driven transaction-manager="transactionManager" />
    82.  
    83.     
    84.     <aop:aspectj-autoproxy/>
    85.    
    86. beans>

    3.通过插件自动生成代码

       插件的配置请参考以前的博客：
Mybatis 快速入门第一节 入门基础_靖康之耻的博客-CSDN博客MVC全名是ModelViewCotroller,是模型(model)——视图(view)——控制器（controller）的缩写,是一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码自定义MVCSSMaction(中转站-----servlet类)controller(控制层)biz(业务逻辑处理层)servicedao(数据访问层)mapperIXxxDAO.java(接口)XxxMapper.java(接口)XxxDAOImpl.java(实现类)...https://blog.csdn.net/qq_61313896/article/details/125969558

    generatorConfig.xml

    2. generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
    3.         "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
    4. <generatorConfiguration>
    5.     
    6.     <properties resource="jdbc.properties"/>
    7.  
    8.     
    9.     <classPathEntry location="E:\repository\mvn-repository\mysql\mysql-connector-java\5.1.44"/>
    10.  
    11.     
    12.     <context id="infoGuardian">
    13.         
    14.         <commentGenerator>
    15.             <property name="suppressAllComments" value="true"/>
    16.             <property name="suppressDate" value="true"/> 
    17.         commentGenerator>
    18.  
    19.         
    20.         <jdbcConnection driverClass="${jdbc.driver}"
    21.                         connectionURL="${jdbc.url}" userId="${jdbc.username}" password="${jdbc.password}"/>
    22.  
    23.         
    24.         <javaTypeResolver>
    25.             
    26.             <property name="forceBigDecimals" value="false"/>
    27.         javaTypeResolver>
    28.  
    29.         
    30.         
    31.         
    32.         <javaModelGenerator targetPackage="com.tangyuan.model"
    33.                             targetProject="src/main/java">
    34.             
    35.             <property name="enableSubPackages" value="false"/>
    36.             
    37.             <property name="constructorBased" value="true"/>
    38.             
    39.             <property name="trimStrings" value="false"/>
    40.             
    41.             <property name="immutable" value="false"/>
    42.         javaModelGenerator>
    43.  
    44.         
    45.         <sqlMapGenerator targetPackage="com.tangyuan.mapper"
    46.                          targetProject="src/main/resources">
    47.             
    48.             <property name="enableSubPackages" value="false"/>
    49.         sqlMapGenerator>
    50.  
    51.         
    52.         
    53.         
    54.         
    55.         <javaClientGenerator targetPackage="com.tangyuan.mapper"
    56.                              targetProject="src/main/java" type="XMLMAPPER">
    57.             
    58.             <property name="enableSubPackages" value="false"/>
    59.         javaClientGenerator>
    60.  
    61.         
    62.         
    63.         
    64.         
    65.         
    66.         
    67.                
    68.                
    69.             
    70.             
    71.             
    72.             
    73.         
    74.  
    75.       
    76.  
    77.          
    78.  
    79.     context>
    80. generatorConfiguration>

    4.使用注解式开发开发方式完成开发

    问题：若要将mapper类注入到Spring IOC上下文容器中，方式有哪几种？

    方式一：在spring-mybatis.xml文件中添加以下代码：(手动注入)

    <bean id="bookMapper" class="com.tangyuan.mapper.BookMapper">bean>

    方式二：运用@Repository注解方式在mapper接口上定义:(自动注入)

           因为在spring-mybatis.xm中开启了注解式开发，所以可以使用注解方式来开发

    •  @Repository：将Mapper类扫描后注入到Spring上下文(IOC)中定义成bean对象,通常作用在Mapper层

    1. package com.tangyuan.mapper;
    2.  
    3. import com.tangyuan.model.Book;
    4. import org.springframework.stereotype.Repository;
    5.  
    6. import java.util.List;
    7.  
    8. //将BookMapper扫描后注入到Spring上下文(IOC)中定义成bean对象
    9. //
    10. @Repository
    11. public interface BookMapper {
    12.     int deleteByPrimaryKey(Integer bid);
    13.  
    14.     int insert(Book record);
    15.  
    16.     int insertSelective(Book record);
    17.  
    18.     Book selectByPrimaryKey(Integer bid);
    19.  
    20.     int updateByPrimaryKeySelective(Book record);
    21.  
    22.     int updateByPrimaryKey(Book record);
    23.  
    24.     List queryBookPager(Book book);
    25. }

     

    •   @Service：将实现类扫描后注入到Spring上下文(IOC)中定义成bean对象,通常作用在service的实现类上(非接口)

    1. package com.tangyuan.service.impl;
    2.  
    3. import com.tangyuan.service.IBookService;
    4. import org.springframework.stereotype.Service;
    5. /**
    6.  * @author 唐渊
    7.  * @create  2022-07-24 21:46
    8.  */
    9. @Service
    10. //   @Service：通常作用在业务层 与上面作用一样
    11. //   将BookServiceImpl扫描后注入到Spring上下文(IOC)中定义成bean对象 作用于Service层的实现类上(非接口类)
    12. public class BookServiceImpl implements IBookService {
    13.   
    14. }

    •     @Controller：将Controller类扫描后注入到Spring上下文(IOC)中定义成bean对象，通常作用在控制层，将在Spring MVC中使用

    1. package com.tangyuan.Controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4.  
    5. /**
    6.  * @author 唐渊
    7.  * @create  2022-07-27 15:31
    8.  */
    9.  
    10. @Controller
    11.  
    12. public class IndexController {
    13.   
    14. }

    •     @Component：是一个泛化的概念，仅仅表示spring中的一个组件（Bean），可以作用在任何层次

            可以作用于任意一层中，将所指定的接口或类注入到Spring上下文(IOC)中定义成bean对象

            温馨提示：可以将上面四个注解方式看做setter方法，定义方式后，将其扫描后注入到Spring上下文(IOC)中定义成bean对象

    •   @Scope：模式声明（singleton单模|prototype多模）

    •     @Autowired：将自动在代码上下文与其匹配（默认是类型匹配）的Bean，并自动注入到相应的地方

     

     @Resource：

    1. @Resource后面没有任何内容，默认通过name属性去匹配bean，找不到再按type去匹配

    2. 指定了name或者type则根据指定的类型去匹配bean

    3. 指定了name和type则根据指定的name和type去匹配bean，任何一个不匹配都将报错

            温馨提示：可以将上面两个注解方式看做getter方法，定义方式后，将从Spring IOC上下文容器中获取指定的bean对象，相当于Spring中的DI(依赖注入)

    1. package com.tangyuan.service.impl;
    2.  
    3. import com.tangyuan.mapper.BookMapper;
    4. import com.tangyuan.service.IBookService;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.stereotype.Service;
    7.  
    8.  
    9. import javax.annotation.Resource;
    10.  
    11.  
    12. /**
    13.  * @author 唐渊
    14.  * @create  2022-07-24 21:46
    15.  */
    16. @Service
    17. //   @Service：通常作用在业务层 与上面作用一样
    18. //   将BookServiceImpl扫描后注入到Spring上下文(IOC)中定义成bean对象 作用于Service层的实现类上(非接口类)
    19. public class BookServiceImpl implements IBookService {
    20.     //自动注入
    21.     //Spring中的DI(依赖注入)
    22.     //@Autowired 根据类型匹配
    23.     @Resource  //@Resource后面没有任何内容，默认通过name属性去匹配bean，找不到再按type去匹配,如果找不到,就报错
    24.     private BookMapper bookMapper;
    25.  
    26.     //手动注入
    27. //    public BookMapper getBookMapper() {
    28. //        return bookMapper;
    29. //    }
    30. //
    31. //    public void setBookMapper(BookMapper bookMapper) {
    32. //        this.bookMapper = bookMapper;
    33. //    }
    34.   
    35. }

    •   @Transactional：在方法调用之前开启事务,在方法调用之后提交事务或者回滚事务，可以添加定任意地方

    1.  @Transactional   //在方法调用之前开启事务,在方法调用之后提交事务或者回滚事务
    2.     @Override
    3.     public int insert(Book record) {
    4.         //开启
    5.         return bookMapper.insert(record);
    6.         //提交或者回滚
    7.     }

     

      5.Spring Test+Junit完美组合

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

    1.   <dependency>
    2.        <groupId>org.springframeworkgroupId>
    3.        <artifactId>spring-testartifactId>
    4.        <version>${spring.version}version>
    5.      dependency>

    ②：创建BaseTestCase，并在该类上加上两个注解

    1.  @RunWith(SpringJUnit4ClassRunner.class)
    2.    @ContextConfiguration(locations={"classpath:applicationContext.xml"})
    1. package com.tangyuan.service.impl;
    2.  
    3. import org.junit.runner.RunWith;
    4. import org.springframework.test.context.ContextConfiguration;
    5. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    6.  
    7. /**
    8.  * @author 唐渊
    9.  * @create  2022-07-27 11:32
    10.  */
    11. @RunWith(SpringJUnit4ClassRunner.class)
    12. @ContextConfiguration(locations = {"classpath:spring.xml"})
    13. public class BaseTest {
    14. }

    6.   使用AOP编程完成分页

                  以前的分页代码封装繁琐，所以我们现在特地地使用AOP编程中的环绕通知来对以前的分页代码进行简化

             若对以前的分页代码有兴趣的，可以参考以前的博客：

    Mybatis 快速入门之 动态sql和分页_靖康之耻的博客-CSDN博客1)在BookMapper类定义方法(2)在BookMapper.xml文件中进行sql语句的编写/*有参构造方法*/(3)在iBookService类编写代码(4)实现接口所定义的方法@Override}(5)进行junit4单元测试@Test//查询返回结果集适合使用返回值是自定义实体类的情况适合使用返回值的数据类型是非自定义的，即jdk的提供的类型println);}测试结果如下查看sql语句//分页查询@Override}...https://blog.csdn.net/qq_61313896/article/details/125981873?spm=1001.2014.3001.5501      

             特意编写一个类，来存放用环绕通知修改的分页代码：

    1. package com.tangyuan.aspect;
    2.  
    3. import com.github.pagehelper.PageHelper;
    4. import com.github.pagehelper.PageInfo;
    5. import com.tangyuan.util.PageBean;
    6. import org.aspectj.lang.ProceedingJoinPoint;
    7. import org.aspectj.lang.annotation.Around;
    8. import org.aspectj.lang.annotation.Aspect;
    9. import org.springframework.stereotype.Component;
    10.  
    11. import java.util.List;
    12.  
    13. /**
    14.  * @author 唐渊
    15.  * @create  2022-07-25 9:46
    16.  */
    17. @Component
    18. @Aspect
    19. public class PageAspect {
    20.     //环绕通知：前+后
    21.     //切入点：* *..*Service.*Pager(..) 代表多个连接点集合
    22.     //* 代表方法返回值不限
    23.     //*.. 代表包名不限
    24.     //*Service 代表以service结尾的类或者是接口
    25.     //*Pager 代表以Pager结尾的方法
    26.     // (..) 代表方法的参数不限
    27.     //适配器：通知+切入点
    28.     @Around(value = "execution(* *..*Service.*Pager(..))")
    29.     public Object invoke(ProceedingJoinPoint joinPoint) throws Throwable {
    30.         //获取目标的执行参数
    31.         Object[] params = joinPoint.getArgs();
    32.         //定义pagebean对象
    33.         PageBean pageBean = null;
    34.         //循环参数
    35.         for (Object param : params) {
    36.             //判断参数的类型是否是pagebean
    37.             if (param instanceof PageBean) {
    38.                 pageBean = (PageBean) param;
    39.                 break;
    40.             }
    41.         }
    42.  
    43.         //判断是否分页
    44.         if (null != pageBean && pageBean.isPagination())
    45.             PageHelper.startPage(pageBean.getPage(), pageBean.getRows());
    46.  
    47.         //执行目标方法
    48.         Object returnValue = joinPoint.proceed(params);
    49.  
    50.         if (null != pageBean && pageBean.isPagination()){
    51.             if (returnValue instanceof List){
    52.                 List list = (List) returnValue;
    53.                PageInfo pageInfo = new PageInfo(list);
    54.                 pageBean.setTotal(pageInfo.getTotal()+"");
    55.     }
    56. }
    57.          return  returnValue;
    58.     }
    59.  
    60.  
    61.  
    62. }

       

         方法测试：

    1.  @Test
    2.     public void queryBookPager(){
    3.         PageBean pageBean=new PageBean();
    4.         List books = bookService.queryBookPager(Book.builder().build(),pageBean);
    5.         System.out.println("总记录数："+pageBean.getTotal());
    6.          books.forEach(System.out::println);
    7.  
    8.  
    9.     }
    10.  
    11. }

       测试结果：      

     

    查看sql语句：

     

         本人刚涉及此方面，博客可能有些地方不好，欢迎各位大佬前来一起讨论斧正

  • 相关阅读:
    解决 LocalDateTime 的序列化与反序列化问题
    聊聊客户档案模型的设计与管理
    蓄势迎接 Google 谷歌开发者大会：开发者，你准备好了吗？
    用c语言写一个剪刀石头布小游戏
    无线智慧城市业务方案建设
    Window 10下SQL Server的安装配置以及C++使用案例
    使用Java解压和压缩文件
    2流高手速成记（之八）：基于Sentinel实现微服务体系下的限流与熔断
    Git学习笔记
    做了8年前端，细说那些曾经让你浴霸不能的后端
  • 原文地址：https://blog.csdn.net/qq_61313896/article/details/126026962