framework学习笔记day08---spring基础

最新推荐文章于 2022-09-07 20:24:56 发布
最新推荐文章于 2022-09-07 20:24:56 发布
阅读量264 收藏
点赞数
分类专栏： 笔记 spring java 文章标签： spring java jar
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wynb1020/article/details/122196144
版权
笔记 同时被 3 个专栏收录
70 篇文章 1 订阅
订阅专栏
java
37 篇文章 0 订阅
订阅专栏
spring
8 篇文章 0 订阅
订阅专栏

AOP注解开发

  • 开发步骤

    • ①开启支持AOP注解
    • ②制作目标对象类
    • ③制作通知类
      • 使用AOP注解

  • ①开启支持AOP注解

    <?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.atguigu"></context:component-scan>
    <!--开启AOP注解支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

  • ②制作目标对象类

    @Service
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() throws Exception {
        System.out.println("UserServiceImpl addUser");
        System.out.println(1 / 0);
    }

    @Override
    public void deleteUser() throws Exception {
        System.out.println("UserServiceImpl deleteUser");
    }
}

  • ③制作通知类

    @Aspect
@Component
public class MyAdvice01 {


    @Before("execution(* *..*Service.addUser())")
    public void before(){
        System.out.println("MyAdvice01 before");
    }

    @AfterReturning("execution(* *..*Service.addUser())")
    public void afterReturning(){
        System.out.println("MyAdvice01 afterReturning");
    }

    @AfterThrowing("execution(* *..*Service.addUser())")
    public void afterThrowing(){
        System.out.println("MyAdvice01 afterThrowing");
    }

    @After("execution(* *..*Service.addUser())")
    public void after(){
        System.out.println("MyAdvice01 after");
    }

    @Around("execution(* *..*Service.addUser())")
    public void around(ProceedingJoinPoint pjp){
        System.out.println("MyAdvice01 around之前");
        try {
            pjp.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("MyAdvice01 around之后");

    }

}

AOP注解获取切入点输入参数

  • 分类

    • around通知获取
    • 非around通知获取

  • 代码实现

    @Aspect
@Component
public class MyAdvice02 {

    @Around("execution(* *..*Service.*(..))")
    public void around(ProceedingJoinPoint pjp) {
        Object[] args = pjp.getArgs();
        System.out.println("MyAdvice02 around" + Arrays.toString(args));
        try {
            pjp.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }


    @Before("execution(* *..*Service.*(..))")
    public void before(JoinPoint jp){
        Object[] args = jp.getArgs();
        System.out.println("MyAdvice02 before" + Arrays.toString(args));
    }

}

AOP注解获取切入点返回值

  • 概述

    • after-returning、around可以获取切入点返回值

  • 代码实现

    @Aspect
@Component
public class MyAdvice03 {

    @Around("execution(* *..*Service.*(..))")
    public Object around(ProceedingJoinPoint pjp) {
        try {
            Object result = pjp.proceed();
            System.out.println("MyAdvice03 around " + result);
            return result;
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }

    @AfterReturning(value = "execution(* *..*Service.*(..))",returning = "result")
    public void afterReturning(Object result){
        System.out.println("MyAdvice03 afterReturning " + result);
    }


}

AOP注解获取切入点异常

  • 概述

    • after-throwing、around可以获取切入点的异常

  • 代码实现

    @Aspect
@Component
public class MyAdvice04 {

    @Around("execution(* *..*Service.*(..))")
    public void around(ProceedingJoinPoint pjp) {
        try {
            pjp.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("MyAdvice04 around " + e);
            throw new RuntimeException(e);
        }
    }

    @AfterThrowing(value = "execution(* *..*Service.*(..))" , throwing = "e")
    public void afterThrowing(Exception e){
        System.out.println("MyAdvice04 afterThrowing " + e);
    }

}

AOP对根据类型获取bean的影响场景一

  • 需求

    • 声明一个接口，接口有一个实现子类
    • 创建一个通知类，对上面接口的实现子类应用通知
    • 根据接口类型获取bean
    • 根据实现子类类型获取bean

  • 总结

    • 根据接口类型获取bean
      • 正常获取
    • 根据实现子类类型获取bean
      • 报错，BeanNotOfRequiredTypeException: Bean named ‘userServiceImpl’ is expected to be of type ‘com.atguigu.service.impl.UserServiceImpl’ but was actually of type ‘com.sun.proxy.$Proxy20’

AOP对根据类型获取bean的影响场景二

  • 需求

    • 声明一个类
    • 创建一个通知类，对上面的类应用通知
    • 根据这个类的类型获取bean

  • 代码实现

    @Service
public class UserServiceImpl2  {
    public String addUser(int num) throws Exception {
        System.out.println("UserServiceImpl2 addUser " + num);
        //System.out.println(1 / 0);
        return "helloworld";
    }

    public void deleteUser() throws Exception {
        System.out.println("UserServiceImpl2 deleteUser");
    }
}

    @Aspect
@Component
public class MyAdvice06 {

    @Before("execution(* *..UserServiceImpl2.*(..))")
    public void before(){
        System.out.println("MyAdvice06 before");
    }

}

    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-core.xml")
public class UserServiceImpl2Test {

    @Autowired
    private UserServiceImpl2 userServiceImpl2;

    @Test
    public void addUser() throws Exception {
        userServiceImpl2.addUser(250);
    }

    @Test
    public void deleteUser() {
    }
}

  • 总结

    • 根据这个类的类型获取bean
      • 正常获取

AOP对根据类型获取bean的影响总结

  • 有接口

    • image-20211228101251165

    • 使用JDKProxy，放入到Spring容器中的是代理类对象，而代理类实现于UserService接口，和被代理类UserServiceImpl之间没有直接关系

  • 没接口

    • image-20211228101418427

    • 使用CGLIB，放入到Spring容器中的是代理类对象，而代理类继承于UserServiceImpl(被代理类)，也就是说，代理类和被代理类之间是继承关系

JdbcTemplate模板类使用

  • 开发步骤

    • ①引入相关依赖
      • spring-jdbc
    • ②定义dao接口及其实现子类
    • ③编写spring-core.xml
      • 将JdbcTemplate对象放入Spring容器
    • ④代码测试

  • ①引入相关依赖

    <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <junit.version>4.13.2</junit.version>
    <lombok.version>1.18.22</lombok.version>
    <spring.version>5.3.13</spring.version>
    <dbutils.version>1.7</dbutils.version>
    <druid.version>1.2.8</druid.version>
    <mysql.version>5.1.48</mysql.version>
</properties>

<dependencies>

    <!--junit start-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
        <scope>test</scope>
    </dependency>
    <!--junit end-->

    <!--lombok start-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
    </dependency>
    <!--lombok end-->

    <!--spring start-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${spring.version}</version>
    </dependency>

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

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

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

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

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.7</version>
    </dependency>

    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!--spring end-->

    <!--jdbc start-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>
    <!--jdbc end-->

</dependencies>

  • ②定义dao接口及其实现子类

    @Repository
public class UserDaoImpl implements UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void addUser(User inputUser) throws Exception {
        jdbcTemplate.update(
                "insert into tb_user values(null,?,?,?)",
                inputUser.getUserName(),
                inputUser.getUserPwd(),
                inputUser.getMoney()
        );
    }

    @Override
    public void deleteUser(Integer userId) throws Exception {
        jdbcTemplate.update(
                "delete from tb_user where user_id = ?",
                userId
        );
    }

    @Override
    public void updateUser(User inputUser) throws Exception {
        jdbcTemplate.update(
                "update tb_user set user_name = ? , user_pwd = ? , money = ? where user_id = ?",
                inputUser.getUserName(),
                inputUser.getUserPwd(),
                inputUser.getMoney(),
                inputUser.getUserId()
        );
    }

    @Override
    public User selectUserById(Integer userId) throws Exception {
        String sql = "select * from tb_user where user_id = ?";
        RowMapper<? extends User> rowMapper = new RowMapper<User>() {
            @Override
            public User mapRow(ResultSet resultSet, int i) throws SQLException {
                User user = new User();
                user.setUserId(resultSet.getInt("user_id"));
                user.setUserName(resultSet.getString("user_name"));
                user.setUserPwd(resultSet.getString("user_pwd"));
                user.setMoney(resultSet.getDouble("money"));
                return user;
            }
        };
        return jdbcTemplate.queryForObject(
                sql,
                rowMapper,
                userId
        );
    }

    @Override
    public List<User> selectUserList() throws Exception {
        return jdbcTemplate.query(
                "select user_id userId,user_name userName , user_pwd userPwd ,money money from tb_user",
                new BeanPropertyRowMapper<>(User.class)
        );
    }
}

  • ③编写spring-core.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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">


    <context:component-scan base-package="com.atguigu"></context:component-scan>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driverClass}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${user}"></property>
        <property name="password" value="${password}"></property>
    </bean>

</beans>

  • ④代码测试

    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-core.xml")
public class UserDaoTest {

    @Autowired
    private UserDao userDao;

    @Test
    public void addUser() throws Exception {
        userDao.addUser(new User(1,"zhangsan","zhangsan",10000.0));
    }

    @Test
    public void deleteUser() {
    }

    @Test
    public void updateUser() {
    }

    @Test
    public void selectUserById() throws Exception {
        User user = userDao.selectUserById(52);
        System.out.println("user = " + user);
    }

    @Test
    public void selectUserList() throws Exception {
        List<User> userList = userDao.selectUserList();
        System.out.println("userList = " + userList);
    }
}

Spring事务概念

  • 分类
    • 编程式事务(难点)
      • 使用PlatformTransactionManager
      • 开发人员自己写java代码实现事务管理，是Spring事务管理原理
    • 声明式事务
      • XML配置声明
      • 注解配置声明
  • 核心类
    • PlatformTransactionManager : 事务管理类
    • TransactionDefinition : 事务信息配置类
    • TransactionStatus : 事务状态类

PlatformTransactionManager接口概述

  • 概述
    • 提供常用的操作事务的方法
  • 常用方法
    • getTransaction : 开启事务
    • commit : 提交事务
    • rollback : 回滚事务
  • 实现子类
    • DataSourceTransactionManager : 适用于Spring JDBC或mybatis
    • HibernateTransactionManager : 适用于hibernate
    • JpaTransactionManager : 适用于Spring Data JPA

TransactionDefinition接口概述

  • 概述
    • 此接口定义了事务的属性(隔离级别、传播行为、超时、只读性)
  • 常用方法
    • 设置/获取隔离级别
      • getIsolationLevel/setIsolationLevel
    • 设置/获取传播行为
      • getPropagationBehavior/setPropagationBehavior
    • 设置/获取只读性
      • setReadOnly/isReadOnly
    • 设置/获取超时
      • setTimeout/getTimeout
  • 继承结构
    • DefaultTransactionDefinition

TransactionStatus接口概述

  • 概述
    • 封装了事务的状态信息(是否是一个新的事务、是否已经结束等等)
  • 继承结构
    • DefaultTransactionStatus

Spring事务管理环境搭建

  • 需求

    • 转账业务(zhangsan向lisi转账100元)

  • 开发步骤

    • ①定义service及其实现子类
    • ②定义dao及其实现子类
    • ③代码测试

  • ①定义service及其实现子类

    @Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;


    @Override
    public void transfer(String outName, String inName, Double money) throws Exception {
        //出账
        userDao.outMoney(outName, money);

        System.out.println(1 / 0);

        //入账
        userDao.inMoney(inName, money);
    }
}

  • ②定义dao及其实现子类

    @Repository
public class UserDaoImpl implements UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Override
    public void outMoney(String outName, Double money) throws Exception {
        jdbcTemplate.update(
                "update tb_user set money = money - ? where user_name = ?",
                money,
                outName
        );
    }

    @Override
    public void inMoney(String inName, Double money) throws Exception {
        jdbcTemplate.update(
                "update tb_user set money = money + ? where user_name = ?",
                money,
                inName
        );
    }
}

  • ③代码测试

    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-core.xml")
public class UserServiceTest {

    @Autowired
    private UserServiceImpl userService;

    @Test
    public void transfer() throws Exception {
        userService.transfer("zhangsan", "lisi", 100.0);
    }
}

Spring编程式事务基础版

  • 概述

    • 使用DataSourceTransactionManager进行事务管理

  • 开发步骤

    • ①编写spring-core.xml
      • 1.1,将DataSourceTransactionManager对象放入到Spring容器
        • 注入dataSource
      • 1.2,将DefaultTransactionDefinition对象放入到Spring容器，设定了两种不同的事务策略
    • ②改造UserServiceImpl代码
      • 引入事务管理

  • ①编写spring-core.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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    //....

    <!--1.1,将DataSourceTransactionManager对象放入到Spring容器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--1.2,将DefaultTransactionDefinition对象放入到Spring容器，设定了两种不同的事务策略-->
    <!--TransactionDefinition : 只读性=false,隔离级别=REPEATABLE_READ-->
    <bean id="definition1" class="org.springframework.transaction.support.DefaultTransactionDefinition">
        <property name="readOnly" value="false"></property>
    </bean>

    <!--TransactionDefinition : 只读性=true,隔离级别=REPEATABLE_READ-->
    <bean id="definition2" class="org.springframework.transaction.support.DefaultTransactionDefinition">
        <property name="readOnly" value="true"></property>
    </bean>

</beans>

  • ②改造UserServiceImpl代码

    @Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private DataSourceTransactionManager transactionManager;


    @Autowired
    @Qualifier("definition1")
    private TransactionDefinition definition;

    @Override
    public void transfer(String outName, String inName, Double money) throws Exception {
        TransactionStatus status = null;
        try {
            //开启事务
            status = transactionManager.getTransaction(definition);
            //出账
            userDao.outMoney(outName, money);
            System.out.println(1 / 0);
            //入账
            userDao.inMoney(inName, money);
            //没有异常就提交事务
            transactionManager.commit(status);
        } catch (Exception e) {
            e.printStackTrace();
            //有异常就回滚事务
            transactionManager.rollback(status);
        }
    }
}

  • 存在问题

    • 事务管理代码会被大量的使用，会有重复冗余问题。

Spring编程式事务优化版

  • 概述

    • 使用MyTransactionManager工具类(开启事务、提交事务、回滚事务)

  • 开发步骤

    • ①自定义MyTransactionManager工具类
    • ②改造UserServiceImpl代码
      • 使用MyTransactionManager工具类

  • ①自定义MyTransactionManager工具类

    @Component
public class MyTransactionManager {

    @Autowired
    private DataSourceTransactionManager transactionManager;

    @Autowired
    @Qualifier("definition1")
    private DefaultTransactionDefinition definition;

    /**
     * 开启事务
     */
    public TransactionStatus startTransaction(){
        TransactionStatus status = transactionManager.getTransaction(definition);
        return status;
    }


    /**
     * 提交事务
     * @param status
     */
    public void commit(TransactionStatus status){
        transactionManager.commit(status);
    }


    /**
     * 回滚事务
     * @param status
     */
    public void rollback(TransactionStatus status){
        transactionManager.rollback(status);
    }


}

  • ②改造UserServiceImpl代码

    @Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private MyTransactionManager transactionManager;

    @Override
    public String addUser(int num) throws Exception {
        System.out.println("UserServiceImpl addUser " + num);
        //System.out.println(1 / 0);
        return "helloworld";
    }

    @Override
    public void deleteUser() throws Exception {
        try {
            System.out.println("UserServiceImpl deleteUser");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void transfer(String outName, String inName, Double money) throws Exception {
        TransactionStatus status = null;
        try {
            //开启事务
            status = transactionManager.startTransaction();
            //出账
            userDao.outMoney(outName, money);
            //System.out.println(1 / 0);
            //入账
            userDao.inMoney(inName, money);
            //没有异常就提交事务
            transactionManager.commit(status);
        } catch (Exception e) {
            e.printStackTrace();
            //有异常就回滚事务
            transactionManager.rollback(status);
        }
    }
}

  • 存在问题

    • ①UserServiceImpl主要功能是增删改查，辅助功能是事务管理，也就是说事务管理属于增强功能，可以使用AOP通知；
    • ②假设UserServiceImpl中有100个方法都需要进行事务管理，意味着事务管理属于共性功能，可以使用AOP通知。

Spring编程式事务最终版

  • 概述

    • 使用环绕通知解决事务管理代码增强功能。

  • 开发步骤

    • ①定义事务通知类TxAdvice
    • ②编写spring-core.xml
      • 配置AOP通知

  • ①定义事务通知类TxAdvice

    @Component
public class TxAdvice {

    @Autowired
    private MyTransactionManager transactionManager;

    @Autowired
    @Qualifier("definition1")
    private TransactionDefinition definition1;


    /**
     * DML的事务通知
     * @param pjp
     */
    public void dmlAround(ProceedingJoinPoint pjp) {
        TransactionStatus status = null;
        //开启事务
        try {
            status = transactionManager.startTransaction(definition1);
            pjp.proceed();
            transactionManager.commit(status);
        } catch (Throwable e) {
            e.printStackTrace();
            transactionManager.rollback(status);

        }
    }


    @Autowired
    @Qualifier("definition2")
    private TransactionDefinition definition2;

    /**
     * DQL的事务通知
     * @param pjp
     */
    public void dqlAround(ProceedingJoinPoint pjp){
        TransactionStatus status = null;
        //开启事务
        try {
            status = transactionManager.startTransaction(definition2);
            pjp.proceed();
            transactionManager.commit(status);
        } catch (Throwable e) {
            e.printStackTrace();
            transactionManager.rollback(status);

        }
    }

}

  • ②编写spring-core.xml

    <!--DataSourceTransactionManager-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!--TransactionDefinition : 只读性=false,隔离级别=REPEATABLE_READ-->
<bean id="definition1" class="org.springframework.transaction.support.DefaultTransactionDefinition">
    <property name="readOnly" value="false"></property>
</bean>

<!--TransactionDefinition : 只读性=true,隔离级别=REPEATABLE_READ-->
<bean id="definition2" class="org.springframework.transaction.support.DefaultTransactionDefinition">
    <property name="readOnly" value="true"></property>
</bean>


<aop:config>
    <aop:aspect ref="txAdvice">
        <aop:around method="dmlAround" pointcut="execution(* *..*Service.transfer(..))"></aop:around>
        <aop:around method="dmlAround" pointcut="execution(* *..*Service.deleteUser(..))"></aop:around>
        <aop:around method="dmlAround" pointcut="execution(* *..*Service.addUser(..))"></aop:around>
        <aop:around method="dqlAround" pointcut="execution(* *..*Service.selectUser(..))"></aop:around>
    </aop:aspect>
</aop:config>

声明式事务概述

  • 概述
    • 将编程式事务中的通用代码抽取出来，制作成独立的around通知使用AOP工作原理，将事 务管理的代码动态织入到原始方法中。由于该功能使用量较大，Spring已经将该通知制作完 毕。
    • 开发人员只需要通过xml配置或注解配置的方式进行使用即可
  • 分类
    • xml声明式事务
    • 注解声明式事务

xml声明式事务

  • 开发步骤

    • ①编写spring-core.xml
      • 配置tx:advice
      • 将tx:advice作用到对应的切入点

  • ①编写spring-core.xml

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="transfer" read-only="false"/>
        <tx:method name="selectUserList" read-only="true"/>
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:advisor advice-ref="txAdvice" pointcut="execution(* *..*Service.*(..))"></aop:advisor>
</aop:config>

xml声明式事务属性配置

  • 常用属性

    • read-only : 只读事务
    • isolation : 事务隔离级别
    • timeout : 事务超时属性
    • rollback-for : 指定异常需要回滚
    • no-rollback-for : 指定异常不需要回滚

  • 代码实现

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="transfer" read-only="false" isolation="REPEATABLE_READ" timeout="10" propagation="REQUIRED" />
        <tx:method name="select*" read-only="true" isolation="REPEATABLE_READ" timeout="10" propagation="REQUIRED"/>
        <tx:method name="add*" read-only="false" isolation="REPEATABLE_READ" timeout="10" propagation="REQUIRED"/>
        <tx:method name="delete*" read-only="false" isolation="REPEATABLE_READ" timeout="10" propagation="REQUIRED"/>
        <tx:method name="update*" read-only="false" isolation="REPEATABLE_READ" timeout="10" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:advisor advice-ref="txAdvice" pointcut="execution(* *..*Service.*(..))"></aop:advisor>
</aop:config>

注解声明式事务

  • 开发步骤

    • ①编写spring-core.xml
      • 开启事务注解支持
    • ②改造UserServiceImpl
      • 使用事务注解

  • ①编写spring-core.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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">


    <!--注解声明式事务-->

    <context:component-scan base-package="com.atguigu"></context:component-scan>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driverClass}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${user}"></property>
        <property name="password" value="${password}"></property>
    </bean>

    <!--DataSourceTransactionManager-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!--开启事务注解支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

</beans>

  • ②改造UserServiceImpl

    @Transactional(readOnly = false, isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED, timeout = 10)
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;
    
    @Transactional(readOnly = true)
    @Override
    public List<User> selectUserList() throws Exception {
        return userDao.selectUserList();
    }

    @Override
    public String addUser(int num) throws Exception {
        System.out.println("UserServiceImpl addUser " + num);
        //System.out.println(1 / 0);
        return "helloworld";
    }

    @Override
    public void deleteUser() throws Exception {
        System.out.println("UserServiceImpl deleteUser");
    }

    @Override
    public void transfer(String outName, String inName, Double money) throws Exception {
        userDao.outMoney(outName, money);
        System.out.println(1 / 0);
        userDao.inMoney(inName, money);
    }
}

事务的readOnly属性

  • 概述

    • 对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及 写操作。这样数据库就能够针对查询操作来进行优化。

  • 代码实现

    @Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional(readOnly = true)
    @Override
    public List<User> selectUserList() throws Exception {
        return userDao.selectUserList();
    }


    @Transactional(readOnly = false)
    @Override
    public String addUser(User inputUser) throws Exception {
        //System.out.println(1 / 0);
        userDao.addUser(inputUser);
        return "helloworld";
    }

    @Override
    public void deleteUser() throws Exception {
        System.out.println("UserServiceImpl deleteUser");
    }

    @Override
    public void transfer(String outName, String inName, Double money) throws Exception {
        userDao.outMoney(outName, money);
        System.out.println(1 / 0);
        userDao.inMoney(inName, money);
    }
}

  • 注意事项

    • DML操作的readOnly必须是false，否则报错"Connection is read-only"

事务的timeout属性

  • 概述

    • 事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资 源。而长时间占用资源，大概率是因为程序运行出现了问题
    • 此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来， 让其他正常程序可以执行。

  • 代码实现

    @Transactional(readOnly = false,timeout = 5)
@Override
public String addUser(User inputUser) throws Exception {
    //操作数据库之前超时，有效
    Thread.sleep(6000);
    userDao.addUser(inputUser);
    //操作数据库之后超时，无效
    //Thread.sleep(6000);

    return "helloworld";
}

  • 注意事项
    userDao.selectUserList();
    }

    @Transactional(readOnly = false)
@Override
public String addUser(User inputUser) throws Exception {
    //System.out.println(1 / 0);
    userDao.addUser(inputUser);
    return "helloworld";
}

@Override
public void deleteUser() throws Exception {
    System.out.println("UserServiceImpl deleteUser");
}

@Override
public void transfer(String outName, String inName, Double money) throws Exception {
    userDao.outMoney(outName, money);
    System.out.println(1 / 0);
    userDao.inMoney(inName, money);
}

    }

  • 注意事项

    • DML操作的readOnly必须是false，否则报错"Connection is read-only"

事务的timeout属性

  • 概述

    • 事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资 源。而长时间占用资源，大概率是因为程序运行出现了问题
    • 此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来， 让其他正常程序可以执行。

  • 代码实现

    @Transactional(readOnly = false,timeout = 5)
@Override
public String addUser(User inputUser) throws Exception {
    //操作数据库之前超时，有效
    Thread.sleep(6000);
    userDao.addUser(inputUser);
    //操作数据库之后超时，无效
    //Thread.sleep(6000);

    return "helloworld";
}

  • 注意事项

    • 操作数据库之前超时，有效；操作数据库之后超时，无效
Mr.W.code
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-framework-5.0.0.RELEASE-dist.zip
01-07
spring-framework-5.0.0.RELEASE-dist.zip： docs文件夹、 libs文件夹（jar包）、 schema文件夹
framework学习笔记day05---Spring基础
Wynb1020的博客
12-24 216
Spring Spring简介 spring是分层的JavaSE及JavaEE应用于全栈的轻量级开源框架，以IoC（Inverse Of Control：控制反转/反转控制）和AOP（Aspact Oriented Programming：面向切面编程）为核心，提供了表现层SpringMVC和持久层Spring JDBC以及业务层事务管理等众多模块的企业级应用技术，还能整合开源世界中众多著名的第三方框架和类库，逐渐成为使用最多的JavaEE企业应用开源框架。 SSH(struts2 spring hiber
Framework学习笔记
xingye813的博客
02-20 261
# Framework简介 # ![](https://i.imgur.com/HHQUkoi.png) # 系统服务 #       SystemServer 是framework中非常重要的一个进程，它是在虚拟机启动后运行的第一个java进程，SystemServer启动其他系统服务，这些系统服务都是以一个线程的方式存在于SystemServer进程中。  a) EntropyService ...
关于framework一些知识点（入门的同学做笔记！）
popsmile的博客
06-29 2837
什么是framework Framework定义了客户端组件和服务端组件功能及接口。包含3个主要部分：服务端，客户端和Linux驱动。 (一）服务端 <wbr> <wbr> <wbr> 服务端主要包含两个重要类，分别是WindowManagerService(Wms)和ActivityManagerService(Ams)。Wms的作用是为所有的应用程序分配窗口，并管理这些窗口。包括分配窗口大小，调节各窗口的叠放次序，隐藏或显示窗口。Ams的作用是管理所有应用程
android培训那里好！万字长文轻松彻底入门Flutter，含泪整理面经
clhcowboy的博客
03-02 710
我，来自大山。 我，不甘平凡。 笔者80后，出生在江西一个偏远的山村。虽然出生时已经不是那个温饱都是问题的年代，但是也谈不上有个幸福的童年。家里很穷。幼儿园并没有读，因为家里觉得花那个钱没有必要，小学才开始学拼音字母。我的童年，就是和我的姐姐弟弟在山中的梯田里放牛，抓泥鳅，割鱼草。 父亲在广东打工，母亲一个人在家里带着我们三个孩子。种种原因，在我从小学开始到高中毕业，我的学习一直很差。 直到我高考成绩出来的那一天。我妈看着我不堪入目的成绩哭成了泪人。我心都要碎了。也是从那一天开始，我决心要改变这种现状。.
Framework 学习笔记
dawuafang
03-26 82
JNI： http://blog.csdn.net/droidpioneer/article/details/6787571 其中的目录： internal目录：\frameworks\base\core\java\com\android\internal\os RegFNIRec gRegJNI[]数组对应的函数在：\frameworks\base\core\jni jniRegist...
spring-framework-4.3.30.RELEASE-dist.zip
01-07
spring-framework-4.3.30.RELEASE-dist.zip： docs文件夹 libs文件夹（jar包） schema文件夹
spring-framework-4.3.30.RELEASE-docs.zip
01-07
spring-framework-4.3.30.RELEASE-docs.zip
spring-framework-4.3.6.RELEASE-dist.zip
08-25
spring-framework-4.3.6.RELEASE-dist.zip，spring开发架包
spring-framework-4.3.30.RELEASE-schema.zip
01-07
spring-framework-4.3.30.RELEASE-schema.zip
听说你想去大厂看妹子，带你看看字节跳动Android开发岗面试是啥样？
wenyusuran的专栏
04-14 2443
前言 金三银四跳槽季，你准备好了吗？希望各位小伙伴能够苦练技术，早日达成自己心仪的offer。 在这里给自己打个广告，需要的小伙伴请自行订阅。 python快速学习实战应用系列课程 https://blog.csdn.net/wenyusuran/category_2239261.html 手把手教你ML机器学习算法源码全解析 https://blog.csdn.net/wenyusuran/category_2239263.html 【一面】 Android四大组件是什么？你最熟悉哪.
Framework学习笔记（一）
jiujiaopanduola的博客
04-09 255
参考https://blog.csdn.net/huaxun66/category_7203839.html，写下自己的学习笔记，因为敲一遍印象会深刻，感谢原博主提供学习素材。 Android系统架构 Android本质上是在Linux系统上增加了Java虚拟机，并在虚拟机上搭建了一个JAVA的application framework,所有的应用程序是基于这个framework之上的。 A...
基本数据类型包装类、包装类的用途
Wynb1020的博客
06-14 1814
基本数据类型包装类 **Java是面向对象语言，但是不是“纯面向对象”，因为我们常用的基本数据类型就不是对象。但是在实际应用中我们常常将基本数据类型转化为对象，以方便操作。例如：将基本数据类型存储到object【】数组或者集合中的操作。 为了解决这个不足，Java 在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。 包装类均位于 java.lang 包，八种包装类和基本数据类型的对应关系如表 ** 基本数据类型 包装类
垃圾回收机制
Wynb1020的博客
05-23 1482
垃圾回收机制 垃圾回收一般分为两步，分别是： 1、发现无用的对象 2、回收无用对象站用电内存空间 垃圾回收常用的两种算法： 1、引用计数法（优点是算法简单，缺点是：循环引用大额无用对象无法识别） 2、引用可达法（根搜索算法） 堆内存划分成：年轻代、年老代、永久代； 垃圾回收器划分成：Minor GC、Major GC、Full GC这三种垃圾回收器分别对应那些区域？ 所有新生成的对象首先放在Eden区，对应的是Minor GC，Minor GC用于清理年轻代区域， Eden区域满了会触发一次Minor GC
自动装箱和拆箱、包装类空指针异常问题、包装类的缓存问题
Wynb1020的博客
06-15 1394
自动装箱和拆箱 自动装箱和拆箱就是将基本数据类型和包装类之间进行自动的互相转化。JDK1.5以后Java引入了自动装箱（autoboxing）和自动拆箱（unboxing） 自动装箱： 基本数据类型处于需要对象的环境中时，会自动转为”对象“。例如：‘ Integer i= 5；相当于编译器自动执行Integer i= Integer，valueOf（5） 自动拆箱子： 每当需要一个值时，对象会自动转成基本数据类型，没必要再去使用intvalue（） 自动装箱过程时通过包装类的valueOf（）方法，而自动拆
十六进制String字符串转byte数组
Wynb1020的博客
09-07 1363
数组操作
Javaweb学习笔记day10---cookie
Wynb1020的博客
12-10 1056
会话技术介绍 为什么? ServletRequest域对象共享范围太小了，ServletContext域对象共享范围太大了。 概述 指的是web开发中的一次通话过程，当打开浏览器，访问网站地址后，会话开始，当关闭浏 览器（或者到了过期时间），会话结束。 作用 存储数据并实现共享 分类 Cookie : 浏览器端会话技术 Session : 服务器端会话技术 cookie概述 概述 它是客户端浏览器的缓存文件，里面记录了客户浏览器访问网站的一些内容。同时，也是 HTTP协议请求
MySQL高级day02
Wynb1020的博客
03-23 991
索引 1.索引的概念 索引是帮助MySQL高效获取数据的数据结构。可以的到索引的本质就是一种数据结构，可简单理解为：排好序的快速查找数据结构 索引的目的: 提高查询效率，可类比字典 2.索引优势劣势 优势 类似于大学图书馆数目索引，提高数据检索的效率，降低数据库的IO成本 通过索引列对数据进行排序，降低数据排序的成本，降低了CPU的小号 劣势 虽然索引大大提高了查询速度，同时却会降低更新表的速度 索引列要额外占用空间的 3.时间复杂度 时间复杂度:随着N数据量级的增加，在时间维度的复杂程度 空间复杂
framwork学习笔记day02---mybatis
Wynb1020的博客
12-20 867
原始jdbc存在的问题 mybatis基本概念 mybatis入门程序 mapper文件说明 添加用户 删除用户 修改用户 mybatis相关API Resources类介绍 概述 用于读取资源的工具类 SqlSessionFactoryBuilder类介绍 概述 这个类可以被实例化、使用和丢弃，一旦创建类SqlFactory，就不在需要它 但最好不要一直保留它 最好使用匿名创建 SqlSessionFactory接口介绍 概述 SqlSession接口介绍 mybatis传统dao开发 myb
spring-framework-5.0.2.release-中文注释版
最新发布
10-10
spring-framework-5.0.2.release-中文注释版是Spring Framework的一个版本，它是一个Java开发框架，用于构建企业级应用程序。 Spring Framework被设计为一个轻量级的、模块化的开发框架，它提供了一系列的功能和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值