Spring事务详解

释放双眼,带上耳机,听听看~!

事务简介

事务管理是企业级应用程序开发中比不可少的技术,用来确保数据的完整性和一致性。

事务就是一系列的动作,它们将当做一个单独的工作单元,这些动作要么全部完成,要么全部不起作用。

事务的四个关键属性(ACID)

原子性(atomicity):事务是一个原子操作,由一系列动作组成,事务的原子性确保动作要么全部完成要么完全不起作用。

一致性(consistency):一旦所有事务动作完成,事务就被提交,数据和资源就处于一种满足业务规则的一致性状态中。

隔离性(isolation):可能有许多事务会同时处理相同的数据,因此每个事务都应该与其他事务隔离开来,防止数据损坏。

持久性(durability):一旦事务完成,无论发生什么系统错误,它的结果都不应该受到影响,通常情况下,事务的结果被写到持久化存储器中。

Spring中的事务管理

作为企业级应用程序框架,Spring在不同的事务管理API之上定义了一个抽象层,而应用程序开发人员不必了解底层的事务管理API,就可以使用Spring的事务管理机制。

Spring即支持编程式事务管理,也支持声明式的事务管理。

编程式事务管理:将事务管理代码嵌入到业务方法中来控制事务的提交和回滚。在编程式管理事务时,必须在每个事务操作中包含额外的事务管理代码。

声明式事务管理:大多数情况下比编程式事务管理更好用,它将事务管理代码从业务方法中分离出来,以声明的方式来实现事务管理,事务管理作为一个横切关注点,可以通过AOP方法模块化,Spring通过Spring AOP框架支持声明式事务管理。

Spring中的事务管理器

Spring从不同的事务管理API中抽象了一整套的事务机制,开发人员不必了解底层的事务 API,就可以利用这些事务机制。有了这些事务机制,事务管理代码就能独立于特定的事务技术了。

Spring的核心事务管理抽象是PlatformTransactionManager接口,管理封装了一组独立于技术的方法,无论使用Spring的哪种事务管理策略(编程式或声明式),事务管理器都是必须的。

PlatformTransactionManager接口封装了三个方法

如:



1
2
3
4
5
6
7
1//获取当前事务的状态
2TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
3//提交事物
4void commit(TransactionStatus status) throws TransactionException;
5//回滚事务
6void rollback(TransactionStatus status) throws TransactionException;
7

1
2
1 也就是说想在spring这个平台上使用声明式事务必须提供一个
2

PlatformTransactionManager
的子类

**我们使用ctrl+t查看一下该接口的子类
Spring事务详解
**

Spring中的事务管理器的不同实现

DataSourceTransactionManager类:在应用程序中只需要处理一个数据源,而且通过JDBC存取

JtaTransactionManager类:在JavaEE应用服务器上用JTA(Java Transaction API)进行事务管理

HibernateTransactionManager类:用Hibernate框架存取数据库

事务管理器以普通的Bean形式声明在SpringIOC容器中

用事务通知声明式地管理事务

事务管理是一种横切关注点

为了在Spring2.x中启用声明式事务管理,可以通过tx Schema中定义tx:advice元素声明事务通知,为此必须事先将这个Schema定义添加到<beans>根元素中去。

声明了事务通知后,就需要将它与切入点关联起来,由于事务通知是在aop:config元素外部声明的,所以它无法直接与切入点产生关联,必须在aop:config元素中声明一个增强器通知与切入点关联起来。

由于Spring AOP是基于代理的方法,所以只能增强公共方法,因此,只有公有方法才能通过SpringAOP进行事务管理。

例:我们要使用到JDBC所以我们这里使用DataSourceTransactionManager来配置事务


1
2
3
4
5
6
7
8
9
1 &lt;!--
2    事务管理器
3       不再使用jdbc的commit和rollback 必须使用事务管理器提供
4 --&gt;
5&lt;bean id=&quot;transactionMager&quot; class=&quot;org.springframework.jdbc.datasource.DataSourceTransactionManager&quot;&gt;
6   &lt;!-- 注入数据源 --&gt;
7   &lt;property name=&quot;dataSource&quot; ref=&quot;dataSource&quot;&gt;&lt;/property&gt;
8&lt;/bean&gt;
9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1&lt;!--定义通知  
2   并且关联上事务管理器 需要事务管理器来提交和回滚 如果事务管理器id=&quot;transactionManager&quot;下面的transaction-manager可以不写,它会自动关联上事务管理器
3  通知作用:当切点定位到下面的方法,它就会自动在前置通知里面加个连接,并且改成手动提交事物,在完成操作之后,提交事物,有异常便自动回滚
4       可参考下图
5--&gt;
6&lt;tx:advice id=&quot;myAdvise&quot; transaction-manager=&quot;transactionManager&quot;&gt;
7  &lt;!-- 指定拦截方法 --&gt;
8  &lt;tx:attributes&gt;
9   &lt;tx:method name=&quot;update*&quot;/&gt;
10      &lt;tx:method name=&quot;save*&quot;/&gt;
11      &lt;tx:method name=&quot;delete*&quot;/&gt;
12      &lt;!-- read-only=&quot;true&quot;只读    不开启事务--&gt;
13      &lt;tx:method name=&quot;*&quot; read-only=&quot;true&quot;/&gt;
14  &lt;/tx:attributes&gt;
15&lt;/tx:advice&gt;
16

1
2
3
4
5
6
7
8
9
10
11
12
1&lt;!--
2  定义切点  切点一般都是操作service层,这里因为是测试所有操作dao层
3--&gt;
4&lt;aop:config&gt;
5  &lt;!-- execution(* cn.*..*.dao.*.upadte*(..)) 定位切点位置:通过execution()指定切点的位置  --&gt;
6  &lt;aop:pointcut expression=&quot;execution(* cn.*..*.dao.*.*(..))&quot; id=&quot;myPoint&quot;/&gt;
7  &lt;!--
8   通过advice-ref=&quot;&quot;将切点与通知关联起来  一拦截到dao方法里的方法便通知myAdvise调事务管理器(transactionManager)开启事务
9  --&gt;
10  &lt;aop:advisor advice-ref=&quot;myAdvise&quot; pointcut-ref=&quot;myPoint&quot;/&gt;
11&lt;/aop:config&gt;
12

1
2
1 创建一个java类(dao层)
2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
1package cn.et.dao.Impl;
2
3import java.sql.SQLException;
4
5import org.springframework.beans.factory.annotation.Autowired;
6import org.springframework.jdbc.core.JdbcTemplate;
7import org.springframework.stereotype.Repository;
8
9import cn.et.dao.MyMoneyDao;
10
11/**
12 * 命名规范
13 *    增加:save*
14 *    修改:update*
15 *    删除:delete*
16 * @author Administrator
17 */
18@Repository
19public class MyMoneyDaoImpl implements MyMoneyDao{
20  @Autowired
21  JdbcTemplate jdbc;
22  public void updateAminus(int money) throws SQLException {//A-10
23      String sql = &quot;update users set lostedmoney= lostedmoney-&quot;+money+&quot; where userName=&#x27;A&#x27;&quot;;
24      jdbc.execute(sql);
25  }
26 
27  public void updateBadd(int money) throws SQLException {//B+10
28      String sql = &quot;update users set lostedmoney= lostedmoney+&quot;+money+&quot; where userName=&#x27;B&#x27;&quot;;
29      jdbc.execute(sql);
30  }
31}
32

1
2
1 由于拦截的是save\*、update\*、delete\*开头的方法,所以上面的两个方法都将被拦截下来
2

在调用这两个方法之前开启一个事务,当它执行完就提交事务(自动提交),如果出错便回滚事务。

现在运行测试还是会报错,我们还需要配置扫描、指定四要素、数据源、数据库连接


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1&lt;!-- 指定扫描的位置 --&gt;
2&lt;context:component-scan base-package=&quot;cn.et&quot;&gt;&lt;/context:component-scan&gt;
3  
4&lt;!-- 指定四要素的位置 --&gt;
5&lt;context:property-placeholder location=&quot;classpath:jdbc.properties&quot; /&gt;  
6&lt;!-- 数据源只是为了获取连接 --&gt;  
7&lt;bean id=&quot;dataSource&quot; class=&quot;org.springframework.jdbc.datasource.DriverManagerDataSource&quot;&gt;  
8     &lt;property name=&quot;url&quot; value=&quot;${url}&quot;&gt;&lt;/property&gt;  
9     &lt;property name=&quot;driverClassName&quot; value=&quot;${driverClass}&quot;&gt;&lt;/property&gt;  
10     &lt;property name=&quot;username&quot; value=&quot;${userid}&quot;&gt;&lt;/property&gt;  
11     &lt;property name=&quot;password&quot; value=&quot;${password}&quot;&gt;&lt;/property&gt;  
12&lt;/bean&gt;  
13&lt;!-- 数据库连接 --&gt;
14&lt;bean id=&quot;jdbcTemplate&quot; class=&quot;org.springframework.jdbc.core.JdbcTemplate&quot;&gt;
15  &lt;!-- 注入数据源 --&gt;
16  &lt;property name=&quot;dataSource&quot; ref=&quot;dataSource&quot;&gt;&lt;/property&gt;
17&lt;/bean&gt;
18

1
2
1 写个main方法  
2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1package cn.et;
2
3import org.springframework.context.ConfigurableApplicationContext;
4import org.springframework.context.support.GenericXmlApplicationContext;
5
6import cn.et.dao.MyMoneyDao;
7
8public class Test {
9   static ConfigurableApplicationContext context;
10  static MyMoneyDao dao;
11  static{
12      context = new GenericXmlApplicationContext(&quot;classpath:spring.xml&quot;);
13      dao = (MyMoneyDao) context.getBean(&quot;myMoneyDaoImpl&quot;);
14  }
15  public static void main(String[] args) throws Exception {
16      dao.updateAminus(10);
17      dao.updateBadd(10);
18      context.close();
19  }
20}
21
22

查看数据库

运行main方法再次查看数据库

我们弄个错误试一下(按照我们的逻辑,当它报错了,A和B一起回滚)

再次运行后我们发现A减了10,B却没有变,说明它们两不在同一次事务中
我们需要将它们置于同一个事务中,如何做呢?需要使用到事务传播属性

事务传播属性

当事务方法被另一个事务方法调用时,必须指定事务应该如何传播,例如:方法可能继续在现有事务中运行,也可能开启一个新事务,并在自己的事务中运行。

事务的传播行为可以由传播属性指定,Spring定义了7种类传播行为。

Spring支持的事务传播行为

REQUIRE:没有事务创建一个事务,有事务使用当前事务

REQUIRE_NEW:不管父方法是否存在事务,都会新建事务

SUPPORTS:父方法存在事务,使用当前事务,没有事务,使用jdbc的事务(自动提交)

NOT_SUPPORTS:不管父方法是否存在事务,都会不会使用事务(挂起事务)

MANDATORY:必须在事务环境下运行,父方法没有事务,抛出异常

No existing transaction found for transaction marked with propagation 'mandatory'

EEVER:父方法不能存在事务,有事务抛出异常

Existing transaction found for transaction marked with propagation 'never'

只需在tx:method元素里设置 propagation="REQUIRED"即可

下面发布完整的代码

spring.xml配置文件


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
1&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
2&lt;beans
3   xmlns=&quot;http://www.springframework.org/schema/beans&quot;
4   xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
5   xmlns:p=&quot;http://www.springframework.org/schema/p&quot;
6   xmlns:context=&quot;http://www.springframework.org/schema/context&quot;
7   xmlns:aop=&quot;http://www.springframework.org/schema/aop&quot;
8   xmlns:tx=&quot;http://www.springframework.org/schema/tx&quot;
9   xsi:schemaLocation=&quot;
10  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
11  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
12  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
13  http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
14  &quot;&gt;
15  &lt;!-- 指定扫描的位置 --&gt;
16  &lt;context:component-scan base-package=&quot;cn.et.test&quot;&gt;&lt;/context:component-scan&gt;
17  
18      &lt;!-- 指定四要素的位置 --&gt;
19    &lt;context:property-placeholder location=&quot;classpath:jdbc.properties&quot; /&gt;  
20  &lt;!-- 数据源只是为了获取连接 --&gt;  
21   &lt;bean id=&quot;dataSource&quot; class=&quot;org.springframework.jdbc.datasource.DriverManagerDataSource&quot;&gt;  
22        &lt;property name=&quot;url&quot; value=&quot;${url}&quot;&gt;&lt;/property&gt;  
23        &lt;property name=&quot;driverClassName&quot; value=&quot;${driverClass}&quot;&gt;&lt;/property&gt;  
24        &lt;property name=&quot;username&quot; value=&quot;${userid}&quot;&gt;&lt;/property&gt;  
25        &lt;property name=&quot;password&quot; value=&quot;${password}&quot;&gt;&lt;/property&gt;  
26    &lt;/bean&gt;  
27    &lt;!-- 数据库连接 --&gt;
28  &lt;bean id=&quot;jdbcTemplate&quot; class=&quot;org.springframework.jdbc.core.JdbcTemplate&quot;&gt;
29      &lt;!-- 注入数据源 --&gt;
30      &lt;property name=&quot;dataSource&quot; ref=&quot;dataSource&quot;&gt;&lt;/property&gt;
31  &lt;/bean&gt;
32 
33    &lt;!--
34      事务管理器
35          不再使用jdbc的commit和rollback 必须使用事务管理器提供
36    --&gt;
37  &lt;bean id=&quot;transactionManager&quot; class=&quot;org.springframework.jdbc.datasource.DataSourceTransactionManager&quot;&gt;
38      &lt;!-- 注入数据源 --&gt;
39      &lt;property name=&quot;dataSource&quot; ref=&quot;dataSource&quot;&gt;&lt;/property&gt;
40  &lt;/bean&gt;
41 
42      &lt;!--
43          定义通知  
44              并且关联上事务管理器 需要事务管理器来提交和回滚 如果事务管理器id=&quot;transactionManager&quot;下面的transaction-manager可以不写,它会自动关联上事务管理器
45          通知作用:当切点定位到下面的方法,它就会自动在前置通知里面加个连接,并且改成手动提交事物
46                  在完成操作之后,提交事物,有异常便自动回滚
47                  可参考下图
48      --&gt;
49      &lt;tx:advice id=&quot;myAdvise&quot; transaction-manager=&quot;transactionManager&quot;&gt;
50          &lt;!-- 指定拦截方法 --&gt;
51          &lt;tx:attributes&gt;
52              &lt;tx:method name=&quot;update*&quot; propagation=&quot;REQUIRED&quot;/&gt;
53              &lt;tx:method name=&quot;save*&quot;/&gt;
54              &lt;tx:method name=&quot;delete*&quot;/&gt;
55              &lt;!-- read-only=&quot;true&quot;只读    不开启事务--&gt;
56              &lt;tx:method name=&quot;*&quot; read-only=&quot;true&quot;/&gt;
57          &lt;/tx:attributes&gt;
58      &lt;/tx:advice&gt;
59      &lt;!--
60          定义切点
61      --&gt;
62      &lt;aop:config&gt;
63          &lt;!-- execution(* cn.*..*.dao.*.upadte*(..)) --&gt;
64          &lt;aop:pointcut expression=&quot;execution(* cn.*..*.service.*.*(..))&quot; id=&quot;myPoint&quot;/&gt;
65          &lt;!--
66              将切点与通知关联起来  一拦截到dao方法里的方法便通知myAdvise调事务管理器(transactionMager)开启事务
67          --&gt;
68          &lt;aop:advisor advice-ref=&quot;myAdvise&quot; pointcut-ref=&quot;myPoint&quot;/&gt;
69      &lt;/aop:config&gt;
70&lt;/beans&gt;
71

持久层代码


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1package cn.et.test.dao;
2
3import java.sql.SQLException;
4
5import org.springframework.beans.factory.annotation.Autowired;
6import org.springframework.jdbc.core.JdbcTemplate;
7import org.springframework.stereotype.Repository;
8
9
10@Repository
11public class AbdaoImpl{
12  @Autowired
13  JdbcTemplate jdbc;
14
15  public void updateBadd(int money) throws SQLException {
16      String sql = &quot;update users set lostedmoney= lostedmoney+&quot;+money+&quot; where userName=&#x27;B&#x27;&quot;;
17      jdbc.execute(sql);
18  }
19  public void updateAminus(int money) throws SQLException {
20      String sql = &quot;update users set lostedmoney= lostedmoney-&quot;+money+&quot; where userName=&#x27;A&#x27;&quot;;
21      jdbc.execute(sql);
22  }
23}
24

业务层代码


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1package cn.et.test.service;
2
3import org.springframework.beans.factory.annotation.Autowired;
4import org.springframework.stereotype.Service;
5
6import cn.et.test.dao.AbdaoImpl;
7
8@Service
9public class AbServiceImpl {
10  @Autowired
11  AbdaoImpl dao;
12  public void updateAB(Integer money) throws Exception{
13      dao.updateAminus(money);
14      int i=5/0;
15      dao.updateBadd(money);
16  }
17}
18

main方法


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1package cn.et.test;
2
3import org.springframework.context.ConfigurableApplicationContext;
4import org.springframework.context.support.GenericXmlApplicationContext;
5
6import cn.et.test.service.AbServiceImpl;
7
8public class Test {
9   static ConfigurableApplicationContext context;
10  static AbServiceImpl service;
11  static{
12      context = new GenericXmlApplicationContext(&quot;classpath:/cn/et/test/spring.xml&quot;);
13      service = (AbServiceImpl) context.getBean(&quot;abServiceImpl&quot;);
14  }
15  public static void main(String[] args) throws Exception {
16      service.updateAB(20);
17      context.close();
18  }
19}
20

1
2
1 测试-查看数据库将A置为100,B置为200
2

运行main方法-出现异常了

再次查看数据库-数据AB都没有变,说明事务传播属性设置成功了

事务的隔离级别

从理论上来说,事务应该彼此完全隔离,以避免并发事务所导致的问题,然而,那样会对性能产生极大的影响,因此事务必须按顺序运行。

在实际开发中,为了提升性能,事务会以较低的隔离级别运行。

事务的隔离级别可以通过隔离事务属性指定

Spring支持的事务隔离级别

事务的隔离级别要得到底层数据库引擎的支持,而不是应用程序或者框架的支持。

Oracle支持2种事务隔离级别:READ_COMMITED,SERIALIZABLE

Mysql支持4种事务隔离级别。

isolation="DEFAULT" 隔离级别

DEFAULT   使用数据库默认的隔离级别 ORACLE(读已提交),MYSQL(可重复读)。从隔离级别来讲,oracle的效率比mysql高。

READ_UNCOMMITTED:spring实现读未提交(脏读)

READ_COMMITTED:spring实现读已提交(不可重复读+幻读)

REPEATABLE_READ:spring实现可重复读(幻读)

SERIALIZABLE:spring实现串行化(已解决)按顺序执行,一次只有一个事务执行。效率极低。

建议不用配,使用数据库的,只要配置了数据库的隔离级别就可以了

设置隔离事务属性

在spring2.x事务通知中,可以在tx:method元素中指定隔离级别

设置回滚事务属性

默认情况下只有未检查异常(RuntimeException和Error类型的异常)会导致事务回滚,而受检查异常不会。

事务的回滚规则可以通过在tx:method元素中指定回滚规则,如果有不止一种异常,用逗号分隔。

Spring事务运行过程中,碰到运行时异常自动回滚,非运行时异常不会回滚

rollback-for="java.lang.exception":遇到指定异常必须进行回滚。

**no-rollback-for="**java.lang.exception":遇到指定异常,必须不回滚

一般都会设置为rollback-for="java.lang.exception"有异常便回滚。****

超时和只读属性

由于事务可以在行和表上获得锁,因此长事务会占用资源,并对整体性能产生影响。

如果一个事务只读取数据但不做修改,数据库引擎可以对这个事务进行优化。

超时事务属性:事务在强制回滚之前可以保持多久,这样可以防止长期运行的事务占用资源。

只读事务属性:表示这个事务只读数据但不更新数据,这样可以帮助数据库引擎优化事务。

设置超时和只读事务属性

超时和只读属性可以在tx:method元素中进行指定

所需jar包


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
1&lt;project xmlns=&quot;http://maven.apache.org/POM/4.0.0&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot; xsi:schemaLocation=&quot;http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd&quot;&gt;
2  &lt;modelVersion&gt;4.0.0&lt;/modelVersion&gt;
3  &lt;groupId&gt;cn.et&lt;/groupId&gt;
4  &lt;artifactId&gt;Spring_affair&lt;/artifactId&gt;
5  &lt;version&gt;0.0.1-SNAPSHOT&lt;/version&gt;
6  &lt;packaging&gt;war&lt;/packaging&gt;
7  &lt;dependencies&gt;
8   &lt;!-- spring依赖 --&gt;
9   &lt;dependency&gt;
10        &lt;groupId&gt;org.springframework&lt;/groupId&gt;
11        &lt;artifactId&gt;spring-context&lt;/artifactId&gt;
12        &lt;version&gt;4.3.12.RELEASE&lt;/version&gt;
13    &lt;/dependency&gt;
14      &lt;!-- aop依赖 --&gt;
15      &lt;dependency&gt;
16      &lt;groupId&gt;org.springframework&lt;/groupId&gt;
17      &lt;artifactId&gt;spring-aop&lt;/artifactId&gt;
18      &lt;version&gt;4.3.11.RELEASE&lt;/version&gt;
19  &lt;/dependency&gt;
20  &lt;!-- spring事务依赖 --&gt;
21  &lt;dependency&gt;
22      &lt;groupId&gt;org.springframework&lt;/groupId&gt;
23      &lt;artifactId&gt;spring-orm&lt;/artifactId&gt;
24      &lt;version&gt;4.3.11.RELEASE&lt;/version&gt;
25  &lt;/dependency&gt;
26  &lt;dependency&gt;
27      &lt;groupId&gt;aopalliance&lt;/groupId&gt;
28      &lt;artifactId&gt;aopalliance&lt;/artifactId&gt;
29      &lt;version&gt;1.0&lt;/version&gt;
30  &lt;/dependency&gt;
31  &lt;dependency&gt;
32       &lt;groupId&gt;aspectj&lt;/groupId&gt;
33       &lt;artifactId&gt;aspectjweaver&lt;/artifactId&gt;
34       &lt;version&gt;1.5.3&lt;/version&gt;
35   &lt;/dependency&gt;
36  &lt;!-- jdbc依赖 --&gt;
37  &lt;dependency&gt;
38        &lt;groupId&gt;org.springframework&lt;/groupId&gt;
39        &lt;artifactId&gt;spring-jdbc&lt;/artifactId&gt;
40        &lt;version&gt;4.3.12.RELEASE&lt;/version&gt;
41    &lt;/dependency&gt;
42    &lt;!-- mysql数据库依赖 --&gt;
43    &lt;dependency&gt;
44        &lt;groupId&gt;mysql&lt;/groupId&gt;
45        &lt;artifactId&gt;mysql-connector-java&lt;/artifactId&gt;
46        &lt;version&gt;5.1.26&lt;/version&gt;
47    &lt;/dependency&gt;
48    &lt;!-- 日志依赖 --&gt;
49    &lt;dependency&gt;
50      &lt;groupId&gt;log4j&lt;/groupId&gt;
51      &lt;artifactId&gt;log4j&lt;/artifactId&gt;
52      &lt;version&gt;1.2.17&lt;/version&gt;
53    &lt;/dependency&gt;
54  &lt;dependency&gt;
55       &lt;groupId&gt;aspectj&lt;/groupId&gt;
56       &lt;artifactId&gt;aspectjrt&lt;/artifactId&gt;
57       &lt;version&gt;1.2&lt;/version&gt;
58  &lt;/dependency&gt;    
59  &lt;/dependencies&gt;
60&lt;/project&gt;
61

给TA打赏
共{{data.count}}人
人已打赏
安全技术

C/C++内存泄漏及检测

2022-1-11 12:36:11

安全技术

SSM-Spring-17:Spring中aspectJ注解版

2022-1-12 12:36:11

个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索