SSM整理。

最新推荐文章于 2024-09-03 16:35:17 发布

Moon_xuan

最新推荐文章于 2024-09-03 16:35:17 发布

阅读量117

点赞数

分类专栏： spring框架文章标签： spring

本文链接：https://blog.csdn.net/weixin_45784715/article/details/119546016

版权

本文详细介绍了SSM框架（Spring、Mybatis、SpringMVC）的各个组件，包括Mybatis的事务、连接池、延迟加载和缓存机制，Spring的IOC容器、依赖注入、AOP以及JdbcTemplate的使用，SpringMVC的基础配置、注解、响应方式和文件上传等内容。最后探讨了SSM框架的整合步骤和注意事项。

摘要由CSDN通过智能技术生成

1.Mybatis

1.1事务

凡是涉及查询操作的不需要事务提交，更新操作需要手动事务提交。
mybatis中的事务默认是关闭的。可以选择session.commit()或者factory
.openSession()时，指定autoCommit为true

1.2连接池

mybatis连接池提供了3种方式的配置：
配置的位置：
主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。
type属性的取值：

POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现
UNPOOLED采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用池的思想。（UNPOOLED，mybatis的每次请求都是会创建一个连接，效率并不是很高，一般不推荐是使用）
JNDI 采用服务器提供的JDNI技术实现，来获取DataSource对象，不同的服务器所能拿到DataSource是不一样。
注意：如果不是web或者maven的war工程，是不能使用的。

1.3延迟加载

什么是延迟加载
在真正使用数据时才发起查询，不用的时候不查询。按需加载（懒加载）

什么是立即加载
不管用不用，只要一调用方法，马上发起查询。

在对应的四种表关系中：一对多，多对一，一对一，多对多
一对多，多对多：通常情况下我们都是采用延迟加载。
多对一，一对一：通常情况下我们都是采用立即加载。

1.4缓存

什么是缓存？
存在于内存中的临时数据。

为什么使用缓存？
减少和数据库的交互次数，提高执行效率。

什么样的数据能使用缓存，什么样的数据不能使用？
适用于缓存：

经常查询并且不经常改变的。
数据的正确与否对最终结果影响不大的

不适用于缓存：

经常改变的数据
数据的正确与否对最终结果影响很大的。例如：商品的库存，银行的汇率，股市的牌价。

mybatis中的一级缓存和二级缓存
一级缓存：
它指的是Mybatis中SqlSession对象的缓存。
当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供一块区域中。
该区域的结构是一个Map。当我们再次查询同样的数据，mybatis会先去SqlSession中
查询是否有，有的话直接拿出来用。
当SqlSession对象消失时，mybatis的一级缓存也就消失了。

一级缓存是SqlSession范围的缓存，当调用SqlSession的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。

二级缓存:
它指的是Mybatis中SqlSessionFactory对象的缓存，由同一个SqlSessionFactory对象创建的SqlSession共享其缓存
二级缓存的使用步骤：
第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）
第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）
第三步：让当前的操作支持二级缓存（在select标签中配置）

二级缓存中取出来的对象不相等的原因：
对象中的数据相等，但是地址不同。原因是：二级缓存中存放的内容是数据，而不是对象

mybaits中是默认开启一级缓存的；二级缓存在SqlMapConfig.xml里是默认开启的，但是使用xml或者注解时，仍需要进行配置。

2.Spring

2.1 ioc

2.1.1 程序的耦合
耦合：程序间的依赖关系
1.包括：

类之间的依赖
方法间的依赖

2.解耦：

降低程序间的依赖关系

3.实际开发中:

应该做到：编译器不依赖，运行时才依赖。

4.解耦的思路：

第一步：使用反射来创建对象，而避免使用new关键字
第二步：通过读取配置文件来获取要创建的对象全限定类名

2.2.2 Bean
Bean:在计算机英语中，有可重用组件的含义
javaBean：用java语言编写的可重用组件
javabean > 实体类
2.2.3 Ioc核心容器
1、获取spring的Ioc核心容器，并根据id获取对象

2、ApplicationContext的三个常用实现类：

ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下，不在的话，加载不了。（更常用）
FileSystemXmlApplicationContext：它可以加载任意路径下的配置文件（必须有访问权限）
AnnotationConfigApplicationContext:它是用于读取注解创建容器的

3、核心容器的两个接口引发出的问题：
ApplicationContext：单例对象适用采用此接口

它在构建核心容器时，创建对象采取的策略是采用立即加载的方式，也就是说，只要一读取完配置马上就创建配置文件中配置的对象。

BeanFactory：多例对象适用

它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式，也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

2.2.4 spring对bean的管理细节
1、创建bean的三种方式
第一种方式：使用默认构造函数的创建。

在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时，
采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

<bean id="accountService" class="com.axuan.service.impl.AccountServiceImpl"></bean>

第二种方式：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器中）

 <bean id="instanceFactory" class="com.axuan.factory.InstanceFactory"></bean>
 <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器）

<bean id="accountService" class="com.axuan.factory.StaticFactory" factory-method="getAccountService"></bean>

2、bean对象的作用范围
bean标签的scope属性：
作用：用于指定bean的作用范围
取值：常用的就是单例和多例的

singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
global-session：作用于集群坏境的会话范围（全局会话范围），当不是集群环境时，它就是session

<bean id="accountService" class="com.axuan.service.impl.AccountServiceImpl" scope="prototype"></bean>

3、bean对象的生命周期
单例对象

出生：当容器创建时对象出生
活着：只要容器还在，对象一直活着
死亡：容器销毁，对象消亡
总结：单例对象的生命周期和容器相同

多例对象

出生：当我们使用对象时spring框架为我们创建
活着：对象只要是在使用过程中就一直活着
死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收

<bean id="accountService" class="com.axuan.service.impl.AccountServiceImpl" scope="prototype" init-method="init" destroy-method="destroy"></bean>

2.2.5 依赖注入
依赖注入：

Dependency injection

IOC的作用：

降低程序间的耦合（依赖关系）

依赖关系的管理：

以后都交给spring来维护

在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明

依赖关系的维护：

就称之为依赖注入。

依赖注入：

能注入的数据：有三类
基本类型和String
其他bean类型（在配置文件中或者注解配置过的bean）
复杂类型/集合类型
注入的方式：有三种
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供

1、构造函数注入：
使用的标签：constructor-arg
标签出现的位置：bean标签的内部
标签中的属性

type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数复制。索引的位置是从0开始的
name：用于指定给构造函数中指定名称的参数赋值常用的

以上三个用于指定给构造函数中哪个参数赋值

value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

优势：

在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功

弊端：

改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供

<!--spring使用value标签时可以将一些string类型自动转换成基本数据类型，但是无法转换成其他bean类型，必须使用ref标签-->
    <bean id="accountService" class="com.axuan.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="泰斯特"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>

    <!--配置一个日期对象-->
    <bean id="now" class="java.util.Date"></bean>`java

2、set方法注入更常用的方式
涉及的标签：property
出现的位置：bean标签的内部
标签的属性

name：用于指定注入时所调用的set方法名称
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

优势：

创建对象时没有明确的限制，可以直接使用默认构造函数

弊端：

如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

<bean id="accountService2" class="com.axuan.service.impl.AccountServiceImpl2">
       <property name="name" value="TEST"></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>


    <!-- 复杂类型的注入/集合类型的注入
        用于给List结构集合注入的标签；
            list array set
        用于Map结构集合注入的标签：
            map props
        结构相同、标签可以互换
    -->
    <bean id="accountService3" class="com.axuan.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>
        <property name="myList">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>
        <property name="mySet">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>
        <property name="myMap">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>
        <property name="myProps">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB" value="bbb"></entry>
            </map>
        </property>
    </bean>

3、注解注入
曾经XML的配置：

<bean id="accountService" class="com.axuan.service.impl.AccountServiceImpl"
           scope="" init-method="" destroy-method="">
           <property name="" value="" / ref=""></property>
    </bean>

用于创建对象的
他们的作用就和在XML配置文件中编写一个标签实现的功能是一样的

Component：
作用：用于把当前类对象存入spring容器中
属性：
value：用于指定bean的id，当我们不写时，它的默认值是当前类名，且首字母改小写
Controller:一般用在表现层
Service：一般用在业务层
Repository：一般用在持久层

以上三个注解他们的作用和属性与Component是一模一样
他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰

用于注入数据的
他们的作用就和在xml配置文件中的bean标签中写一个标签的作用是一样的

Autowired:
作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功（首先按照类型匹配，再按照注入的变量名称匹配）
如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。
如果ioc容器中有多个类型匹配时：按照id注入
出现位置：
可以是变量上，也可以是方法上
细节：
在使用注解注入时，set方法就不是必须的了。
Qualifier：
作用：在按照类型注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用。但是在给方法参数注入时可以(不能单独使用，必须搭配Autowired)
属性：
value：用于指定注入bean的id。
Resource
作用：直接按照bean的id注入。它可以独立使用
属性：
name：用于指定bean的id。

以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现。
另外，集合类型的注入只能通过XML来实现。

Value：
作用：用于注入基本类型和String类型的数据
属性：
value：用于指定数据的值。它可以使用spring中的SpEL（也就是spring的el表达式）
SpEL的写法：${表达式}

用于改变作用范围的
他们的作用就和在bean标签中使用scope属性实现的功能是一样的

Scope
作用：用于指定bean的作用范围
属性：
value：指定范围的取值。常用取值：singleton prototype

和生命周期相关(了解）
他们的作用就和在bean标签中使用init-method和destroy-method的作用是一样的
PreDestroy
作用：用于指定销毁方法
PostConstruct
作用：用于指定初始化方法

2.2.6 配置类
Spring中的配置

Configuration
作用：指定当前类是一个配置类
细节：当配置类作AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。
当要加入其他子配置类时，应加上Configuration，并使用ComponentScan扫描配置类
ComponentScan
作用：用于通过注解指定spring在创建容器时要扫描的包
属性：
value：它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包。
我们使用此注解就等同于在xml中配置了：
<context:component-scan base-package=“com.axuan”></context:component-scan>
Bean
作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中
属性：
name：用于指定bean的id，当不写时，默认值是当前方法的名称
细节：
当我们使用注解配置方法时，如果方法有参数，spring框架会去当前容器中查找有没有可用的bean对象。
查找的方式和Autowired注解的作用是一样的。
Import
作用：用于导入其他的配置类
属性：
value：用于指定其他配置类的字节码。当我们使用Import的注解之后，有Import注解的类就是父配置类，而导入的都是自配置类需要导入的类并不需要@Configuration，父配置类也不需要扫描，只需要Import导入即可
PropertySource
作用：用于指定properties文件的位置
属性：
value：指定文件的名称和路径。关键字：classpath：表示类路径下（在项目打包之后，resources下的资源文件会被放到类路径下，因此要指明文件位置）

//@Configuration
@ComponentScan({
   "com.axuan"})
@Import(JdbcConfig.class)
@PropertySource("classpath:jdbcConfig.properties")
public class SpringConfiguration {
   

}

2.2 AOP

2.2.1 代理
特点：字节码随用随创建，随用随加载
作用：不修改源码的基础上对方法增强
分类：

基于接口的动态代理
基于子类的动态代理

1、基于接口的动态代理：

涉及的类：Proxy
提供者：JDK官方

如何创建代理对象：

使用Proxy类中的newProxyInstance方法

创建代理对象的要求：

被代理对象最少实现一个接口，如果没有则不能使用

newProxyInstance方法的参数：

ClassLoader：类加载器
它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
Class[]:字节码数组
它是用于让代理对象和被代理对象有相同方法。固定写法。
InvocationHandler：用于提供增强的代码
它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
此接口的实现类是谁用谁写。

IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
            producer.getClass().getInterfaces(),
            new InvocationHandler() {
   
                /**
                 * 作用：执行被代理对象的任何接口方法都会经过该方法
                 * 方法参数的含义
                 * @param proxy: 代理对象的引用
                 * @param method: 当前执行的方法
                 * @param args: 当前执行方法所需的参数
                 * @return java.lang.Object 和被代理对象有相同的返回值
                 * @author ZhouXuan
                 * @date 2021/8/11 15:49
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   

                    // 提供增强的代码
                    Object returnValue = null;
                    // 1.获取方法执行的参数
                    Float money = (Float) args[0];
                    // 2.执行当前方法是不是销售
                    if ("saleProduct".equals(method.getName())) {
   
                        returnValue = method.invoke(producer, money * 0.8f);
                    }
                    return returnValue;
                }
            });
        proxyProducer.saleProduct(10000f);
    }

2、基于子类的动态代理：

涉及的类：Enhancer
提供者：第三方cglib包

如何创建代理对象：

使用Enhancer类中的create方法

创建代理对象的要求：

被代理类不能是最终类

create方法的参数：

Class：字节码
它是用于指定被代理对象的字节码。
Callback：用于提供增强的代码
它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
此接口的实现类是谁用谁写。
我们一般写的都是该接口的子接口实现类：MethodInterceptor

Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
   
            /**
             * 执行被代理对象的任何方法都会经过该方法
             * @param proxy:
             * @param method:
             * @param args:
             *            以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
             * @param methodProxy: 当前执行方法的代理对象
             * @return java.lang.Object
             * @author ZhouXuan
             * @date 2021/8/11 16:05
             */
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
   
                // 提供增强的代码

                Object returnValue = null;
                // 1.获取方法执行的参数
                Float money = (Float) args[0];
                // 2.执行当前方法是不是销售
                if ("saleProduct".equals(method.getName())) {
   
                    returnValue = method.invoke(producer, money * 0.8f);
                }
                return returnValue;
            }
        });

        cglibProducer.saleProduct(12000f);
    }

2.2.2 AOP
Aop的作用及好处：
作用：在程序运行期间，不修改源码对已有方法进行增强。
优势：
减少重复代码
提高开发效率
维护方便

AOP的实现方式
使用动态代理技术

AOP相关术语：

Joinpoint(连接点)：所谓连接点是指那些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持
方法类型的连接点。

Pointcut(切入点)：所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。

Advice（通知/增强）：所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。通知的类型：前置通知，后置
通知，异常通知，最终通知，环绕通知。

Introduction(引介)：引介是一种特殊的通知在不修改类代码的前提下，Introduction可以在运行期为类
动态地添加一些方法或Field。

Target(目标对象)：代理的目标对象。

Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。

spring采用动态代理织入，而AspectJ采用编译器织入和类装载期织入。

Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类。

Aspect（切面）：是切入点和通知（引介）的结合。

2.2.3 基于XMl的AOP

Spring中基于XMl的AOP配置步骤
1、把通知Bean也交给spring来管理
2、使用aop:config标签表明开始AOP的配置
3、使用aop:aspect标签表明配置切面

id属性：是给切面提供一个唯一标识
ref属性：是制定通知类bean的Id。

4、在aop:aspect标签的内部使用对应标签来配置通知的类型
我们现在示例是让printLog方法在切入点方法执行之前执行：所以是前置通知

aop:before：配置前置通知
method属性：用于指定Logger类中哪个方法是前置通知
pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层哪些方法增强

切入点表达式的写法：

关键字：execution（表达式）
表达式：
访问修饰符返回值包名.包名.包名…类名.方法名（参数列表）
标准的表达式写法：
public void com.axuan.service.impl.AccountServiceImpl.saveAccount()
访问修饰符可以省略：
void com.axuan.service.impl.AccountServiceImpl.saveAccount()
返回值可以使用通配符，表示任意返回值
* com.axuan.service.impl.AccountServiceImpl.saveAccount()
包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
* ....AccountServiceImpl.saveAccount()
包名可以使用…表示当前包及其子包
* *…AccountServiceImpl.saveAccount()
类名和方法名都可以使用来实现统配
* ….()
参数列表：
可以直接写数据类型：
基本类型直接写名称 int 引用类型写包名.类名的方式 java.lang.String 可以使用通配符表示任意类型，但是必须有参数可以使用..表示有无参数均可，有参数可以是任意类型
全通配写法：
* ….*(…)
实际开发中切入点表达式的通常写法：
切到业务层实现类下的所有方法
* com.axuan.service.impl..(…)

<aop:config>
    <!-- 配置切入点表达式 id属性用于指定表达式的唯一标识，expression属性用于指定表达式内容
        此标签写在aop:aspect标签内部只能当前切面使用。
        它还可以写在aop:aspect外面，此时就变成了所有切面可用

        如果所有切面可用，必须放在上面
    -->
    <aop:pointcut id="pt1" expression="execution(* com.axuan.service.impl.*.*(..))"/>
    <!-- 配置切面-->
    <aop:aspect id="logAdvice" ref="logger">
       <!-- &lt;!&ndash; 配置前置通知：在切入点方法执行之前执行&ndash;&gt;
        <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>

        &lt;!&ndash; 配置后置通知：在切入点方法正常执行之后执行，它和异常执行永远只能执行一个&ndash;&gt;
        <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>

        &lt;!&ndash; 配置异常通知：在切入点方法执行异常之后执行。它和后置通知永远只能执行一个&ndash;&gt;
        <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>

        &lt;!&ndash; 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行&ndash;&gt;
        <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>-->

        <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
    </aop:aspect>
</aop:config>

2.2.4 环绕通知

问题：

当我们配置了环绕通知之后，切入点方法没有执行了，而通知方法执行了。
分析：
通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
解决：
Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed(),此方法就相当于明确调用切入点方法。
该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。

Spring中的环绕通知：

它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。

public Object aroundPrintLog(ProceedingJoinPoint pjp) {
   
        Object rtValue = null;
        try{
   
            Object[] args = pjp.getArgs(); // 得到方法执行所需的参数

            System.out.println("Logger类中的aroundPrintLog方法开始记录日志了。。。前置");

            rtValue = pjp.proceed(args);// 明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPrintLog方法开始记录日志了。。。后置");

            return rtValue;
        }catch (Throwable t) {
   
            System.out.println("Logger类中的aroundPrintLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
   
            System.out.println("Logger类中的aroundPrintLog方法开始记录日志了。。。最终");
        }

2.2.5 基于注解的AOP
bean.xml里面的内容

 <!-- 配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.axuan"></context:component-scan>

    <!-- 配置spring开启注解AOP的支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

配置一个切面

@Component("logger")
@Aspect// 表示当前是一个切面类
public class Logger {
   

    @Pointcut("execution(* com.axuan.service..impl.*.*(..))")
    private void pt1(){
   }


    /**
     * 前置通知
     * @return void
     * @author ZhouXuan
     * @date 2021/8/11 20:31
     */
    //@Before("pt1()")
    public void beforePrintLog() {
   
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    /**
     * 后置通知
     * @return void
     * @author ZhouXuan
     * @date 2021/8/11 20:31
     */
    //@AfterReturning("pt1()")
    public void afterReturningPrintLog() {
   
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }

    /**
     * 异常通知
     * @return void
     * @author ZhouXuan
     * @date 2021/8/11 20:31
     */
    //@AfterThrowing("pt1()")
    public void afterThrowingPrintLog() {
   
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    /**
     * 最终通知
     * @return void
     * @author ZhouXuan
     * @date 2021/8/11 20:31
     */
    //@After("pt1()")
    public void afterPrintLog() {
   
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }

    @Around("pt1()")
    public Object aroundPrintLog(ProceedingJoinPoint pjp) {
   
        Object rtValue = null;
        try{
   
            Object[] args = pjp.getArgs

最低0.47元/天解锁文章

Moon_xuan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SSM整理。

1.Mybatis1.1事务凡是涉及查询操作的不需要事务提交，更新操作需要手动事务提交。mybatis中的事务默认是关闭的。可以选择session.commit()或者factory.openSession()时，指定autoCommit为true1.2连接池mybatis连接池提供了3种方式的配置：配置的位置：主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。type属性的取值：POOLED 采用传统的javax.sql
复制链接

扫一扫

专栏目录