二分查找法的变种，声明式事务的传播方式，基于注解配置声明式事务

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量412 收藏
点赞数
分类专栏： 日志 文章标签： java 算法 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdfsdfsdds2/article/details/127213907
版权

学习目标：

学习并且完善上一篇文章中的二分查找法的lower方法

学习声明式事务的七种传播方式，并且学习基于注解配置声明式事务。

学习内容：

public class BinarySearch {
    private BinarySearch(){}
    //非递归实现二分查找法
    public static <E extends Comparable<E>> int search(E[] data, E target) {
        int l = 0, r = data.length - 1;
        //在data[l,r]的范围中查找target
        while (l<=r){
            int mid=l+(r-l)/2;
            if(data[mid].compareTo(target)==0)
                return mid;
            if(data[mid].compareTo(target)<0)
                l=mid+1;
            else
                r=mid-1;
        }
        return -1;
    }
    //递归实现二分查找法
    public static <E extends Comparable<E>> int searchR(E[] data, E target) {
        return searchR(data, 0, data.length - 1, target);
    }

    private static <E extends Comparable<E>> int searchR(E[] data, int l, int r, E target) {
        if(l>r)return -1;
        int mid=l+(r-l)/2;
        if(data[mid].compareTo(target)==0)
            return mid;
        if(data[mid].compareTo(target)<0)
            return searchR(data, mid + 1, r, target);
        return searchR(data, l, mid - 1, target);
    }
    //>target的最小值索引
    public static <E extends Comparable<E>> int upper(E[] data,E target){
        int l=0,r=data.length;
        //在data[l,r]中寻找解
        while (l<r){
            int mid=l+(r-l)/2;
            if(data[mid].compareTo(target)<=0){
                l=mid+1;
            }else{
                r=mid;
            }
        }
        return l;
    }
    //>target，返回最小值索引
    //==target,返回最大索引
    public static <E extends Comparable<E>> int ceil(E[] data,E target){
        int u = upper(data, target);
        if(u-1>=0&&data[u-1].compareTo(target)==0)
            return u - 1;
        return u;
    }
    //>target，返回最小值索引
    //==target,返回最小索引
    public static <E  extends Comparable<E>> int lower_ceil(E[] data,E target){
        int u = upper(data, target);
        while (u-1>=0&&data[u-1].compareTo(target)==0){
            u-=1;
        }
        return u;
    }
    //<target的最大值索引
    public static <E extends Comparable<E>> int lower(E[] data,E target){
        int l=-1,r= data.length-1;
//        在data[l,r]中寻找解
        while (l<r){
           // System.out.println(l+""+r);
            int mid=l+(r-l+1)/2;
            if(data[mid].compareTo(target)<0)
                l=mid;
            else
                r=mid-1;
        }
        return l;
    }
    public static void main(String[] args) {
        Integer[] arr = {1, 1, 3, 3, 5, 5};
        for(int i=0;i<=6;i++){
            System.out.print(BinarySearch.lower(arr, i) + " ");
        }
        System.out.println();
    }
}

学习了声明式事务的七种传播方式，并对三种最常使用的方式进行了实际的使用，了解了各种方式的不同，同时完成了基于注解配置声明式事务的过程。

applicationContext.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.imooc"/>
    <!-- 数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url"
                  value="jdbc:mysql://localhost:3306/imooc?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai&amp;allowPublicKeyRetrieval=true"/>
        <property name="username" value="root"/>
        <property name="password" value="xxxxxx"/>
    </bean>
<!--    JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    启用注解形式声明事务-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

EmployeeDao:

package com.imooc.spring.jdbc.dao;

import com.imooc.spring.jdbc.entity.Employee;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
@Repository
public class EmployeeDao {
    @Resource
    private JdbcTemplate jdbcTemplate;

    public Employee findById(Integer eno){
        String sql = "select * from employee where eno = ?";
        //查询单条数据
        Employee employee = jdbcTemplate.queryForObject(sql, new Object[]{eno}, new BeanPropertyRowMapper<Employee>(Employee.class));
        return employee;
    }

    public List<Employee> findByDname(String dname){
        String sql = "select * from employee where dname = ?";
        //查询复合数据
        List<Employee> list = jdbcTemplate.query(sql, new Object[]{dname}, new BeanPropertyRowMapper<Employee>(Employee.class));
        return list;
    }

    public List<Map<String, Object>> findMapByDname(String dname){
        String sql = "select eno as empno , salary as s from employee where dname = ?";
        //将查询结果作为Map进行封装
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql, new Object[]{dname});
        return maps;
    }

    public void insert(Employee employee){
        String sql = "insert into employee(eno,ename,salary,dname,hiredate) values(?,?,?,?,?)";
        //利用update方法实现数据写入操作
        jdbcTemplate.update(sql,new Object[]{
           employee.getEno() , employee.getEname(),employee.getSalary(),employee.getDname() , employee.getHiredate()
        });
    }

    public int update(Employee employee){
        String sql = "UPDATE employee SET ename = ?, salary = ?, dname = ?, hiredate = ? WHERE eno = ?";
        int count = jdbcTemplate.update(sql, new Object[]{employee.getEname(), employee.getSalary(), employee.getDname(), employee.getHiredate(), employee.getEno()});
        return count;
    }

    public int delete(Integer eno){
        String sql = "delete from employee where eno = ?";
        return jdbcTemplate.update(sql, new Object[]{eno});
    }


    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
}

Employee:

package com.imooc.spring.jdbc.entity;

import java.util.Date;

public class Employee {
    private Integer eno;
    private String ename;
    private Float salary;
    private String dname;
    private Date hiredate;

    public Integer getEno() {
        return eno;
    }

    public void setEno(Integer eno) {
        this.eno = eno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public Float getSalary() {
        return salary;
    }

    public void setSalary(Float salary) {
        this.salary = salary;
    }

    public String getDname() {
        return dname;
    }

    public void setDname(String dname) {
        this.dname = dname;
    }

    public Date getHiredate() {
        return hiredate;
    }

    public void setHiredate(Date hiredate) {
        this.hiredate = hiredate;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "eno=" + eno +
                ", ename='" + ename + '\'' +
                ", salary=" + salary +
                ", dname='" + dname + '\'' +
                ", hiredate=" + hiredate +
                '}';
    }
}

BatchService:

package com.imooc.spring.jdbc.service;

import com.imooc.spring.jdbc.dao.EmployeeDao;
import com.imooc.spring.jdbc.entity.Employee;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;
@Service
@Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)
public class BatchService {
    @Resource
    private EmployeeDao employeeDao;
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void importJob1(){
        for (int i = 1; i <= 10; i++) {
            Employee employee = new Employee();
            employee.setEno(8000 + i);
            employee.setEname("研发部员工" + i);
            employee.setSalary(4000f);
            employee.setDname("研发部");
            employee.setHiredate(new Date());
            employeeDao.insert(employee);
        }
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void importJob2(){
        for (int i = 1; i <= 10; i++) {
            Employee employee = new Employee();
            employee.setEno(9000 + i);
            employee.setEname("市场部员工" + i);
            employee.setSalary(4500f);
            employee.setDname("市场部");
            employee.setHiredate(new Date());
            employeeDao.insert(employee);
        }
    }

    public EmployeeDao getEmployeeDao() {
        return employeeDao;
    }

    public void setEmployeeDao(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }
}

EmployeeService:

package com.imooc.spring.jdbc.service;

import com.imooc.spring.jdbc.dao.EmployeeDao;
import com.imooc.spring.jdbc.entity.Employee;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;
@Service
//声明式事务核心配置
//放在类上，将声明式事务配置应用于当前类所有方法，默认事务传播为REQUIRED
@Transactional(propagation = Propagation.REQUIRED)
public class EmployeeService {
    @Resource
    private EmployeeDao employeeDao;
    @Resource
    private BatchService batchService;
    @Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)
    public Employee findById(Integer eno){
        return employeeDao.findById(eno);
    }
    public void batchImport() {
        for (int i = 1; i <= 10; i++) {
            if(i==3){
                throw new RuntimeException("意料之外的异常");
            }
            Employee employee = new Employee();
            employee.setEno(8000 + i);
            employee.setEname("员工" + i);
            employee.setSalary(4000f);
            employee.setDname("市场部");
            employee.setHiredate(new Date());
            employeeDao.insert(employee);
        }
    }

    public void startImportJob(){
        batchService.importJob1();
        if(1==1){
            throw new RuntimeException("意料之外的异常");
        }
        batchService.importJob2();
        System.out.println("批量导入成功");
    }

    public EmployeeDao getEmployeeDao() {
        return employeeDao;
    }

    public void setEmployeeDao(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }

    public BatchService getBatchService() {
        return batchService;
    }

    public void setBatchService(BatchService batchService) {
        this.batchService = batchService;
    }
}

测试类

JdbcTemplateTestor:

import com.imooc.spring.jdbc.dao.EmployeeDao;
import com.imooc.spring.jdbc.entity.Employee;
import com.imooc.spring.jdbc.service.EmployeeService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.util.Date;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class JdbcTemplateTestor {
    @Resource
    private EmployeeDao employeeDao;
    @Resource
    private EmployeeService employeeService;

    @Test
    public void testFindById(){
        Employee employee = employeeDao.findById(3308);
        System.out.println(employee);
    }

    @Test
    public void testFindByDname(){
        System.out.println(employeeDao.findByDname("市场部"));
    }

    @Test
    public void testFindMapByDname(){
        System.out.println(employeeDao.findMapByDname("研发部"));
    }

    @Test
    public void testInsert(){
        Employee employee = new Employee();
        employee.setEno(8888);
        employee.setEname("赵六");
        employee.setSalary(6666f);
        employee.setDname("研发部");
        employee.setHiredate(new Date());
        employeeDao.insert(employee);
    }

    @Test
    public void  testUpdate(){
        Employee employee = employeeDao.findById(8888);
        employee.setSalary(employee.getSalary() + 1000);
        int count = employeeDao.update(employee);
        System.out.println("本次更新" + count + "条数据");
    }

    @Test
    public void  testDelete(){
        int count = employeeDao.delete(8888);
        System.out.println("本次删除" + count + "条数据");
    }

    @Test
    public void testBatchImport(){
        employeeService.batchImport();
        System.out.println("批量导入成功");
    }

    @Test
    public void testStartImportJob(){
        employeeService.startImportJob();
    }

}

学习时间：

08：30-09：20 11：20-13：00

学习产出：

掌握了二分查找法lower的陷阱。

了解了声明式事务的传播方式，并且学习了基于注解配置声明式事务，比XML的方式简单了许多。

白浊.
关注
专栏目录
BAT 大厂Java 面试题集锦之核心篇附参考答案
AI天才研究院
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
同一个类或者两个分别不同的类中a方法调用b方法事务的隔离级别问题
依然在路上、
09-08 2058
BookService: buyBook方法(a) updatePrice方法(b) transactional 不加注解 a报错 b不报错 事务回滚 transactional 不加注解 b报错 a不报错 事务回滚 不加注解 transactional a报错 b不报错 事务都不回滚 不加注解 transactional b报错 a不报错 ...
事务传播行为 @Transactional
学海无涯,我用JAVA
05-09 714
事务传播行为: 指的是在项目中开启多个事务后,他们之间的影响关系;虽然事务的传播枚举还有很多,但是其实,只要掌握这两个就够了,其他的了解即可;如果当前存在事务，就在当前事务内执行；否则，就执行与 PROPAGATION_REQUIRED 类似的操作。如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。以非事务方式运行，如果当前存在事务，则把当前事务挂起。以非事务方式运行，如果当前存在事务，则抛出异常。
Spring相同类方法调用事务管理
u011487710的博客
05-20 848
关键词 事务的特性 事务的传播性 事务的管理 BUG:一个ServiceImpl方法A调用同一个类中的方法B，A循环调用B,A无需事务，B必须事务 参考文档 踩坑! spring事务,非事务方法与事务方法执行相互调用 Spring中同一个service类中方法相互调用事务不生效问题解决方案 Spring事务管理嵌套事务详解 : 同一个类中，一个方法调用另外一个有事务的方法 spring 事务处理中，同一个类中:A方法（无事务）调B方法（有事务）,事务不生效问题 @Transactional 同一个类中
spring事务-2（事务传播级别组合说明）
daliucheng的博客
02-23 610
Spring事务 例子 配置类 package com.lc.jdbc; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.datasource.DataSourc
@Transactional 注解 同一个类下的两个方法
qq_34486648的博客
11-30 1378
calculateAllByEaArea方法（有声明式事务注解 事务传播级别为propagation = Propagation.REQUIRES_NEW 访问域为public）calculateAllByEaArea方法（有声明式事务注解 事务传播级别为propagation = Propagation.REQUIRES_NEW 访问域为public）calculateAllByEaArea方法（有声明式事务注解 事务传播级别为默认 访问域为public）原理是Spring的动态代理。
斩获 offer 的 Java 面试宝典
程序员爱酸奶
04-11 1万+
这是本人整理的数万字的面试笔记，基本上涵盖了 Java 领域的所有技术栈，本人也是凭借这份面试笔记斩获了近 10 个 offer，面试成功率高达80%。当然这份笔记是我根据自身的经验和技术栈整理的，自己觉得很重要的或者记不清的就会记录记录下来，面试被问到的时候也有回答的思路。现在共享给大家，希望对准备面试的小伙伴有帮助。 1. 微服务 1.1 主流注册中心对比 zookeeper：zookeeper 作为注册中心主要是因为它具有节点变更通知功能。只要客户端监听相关服务节点，服务节点有所变更就能及时的通知到监
【2021-09-22 修订】【梳理】计算机网络：自顶向下方法 第二章 应用层（docx）
COFACTOR
10-17 8937
计算机网络 知 识 梳 理 （第一版） 建议先修课程：数据结构。 配套教材： Computer Networking - A Top Down Approach, 7th edition James F. Kurose, Keith W. Ross 参考书目： 1、计算机网络（第7版） 谢希仁 编著 高等教育出版社 链接：https://pan.baidu.com/s/1MeSnQtQi8PYlzjFv-8RLLA 提取码：0000 二 应用层 2.1 网络应用背后的原理 现代网络应用程序常用的
Java知识点概览
qq_48403611的博客
08-03 3389
java后端开发常见面试题总结
2021 Java面试真题集锦
热门推荐
GL1765852966的博客
12-26 8万+
目录 … 1 大厂面试的基本流程 17 字节跳动 17 阿里 17 腾讯 18 网易游戏 18 面试前需要准备： 18 面试中可以借鉴的套路 19 用简历争取到更多的面试机会 19 自我介绍时，立即全面抛出技术栈和亮点 20 先介绍项目背景，打消面试官疑问 21 通过说项目管理工具，说明你不仅会写代码 22 用 SPRING BOOT 项目举例，说明你的技术基本面 23 用实例说明你在内存调优方面的经验 24 展示你在数据库调优方面的经验 25 总结前文说辞 26 准备项目说辞时，更可以准备后继面试官的问
嵌套事务，测试事务传播性，同类中事务方法互相调用，不同类中事务方法互相调用，try/catch后事务也回滚
qq_31839075的博客
03-22 1139
总结： 前提：传播机制默认为REQUIRED 一个类中，一个没有事务的方法A调用本类另外一个有事务注解（@Transational）的方法B，注解是不会生效的。B中异常时，B中sql不回滚；如果调用的是其他类有事务的方法C，C中异常时，C中的sql会回滚。 一个类中，一个有事务的方法A调用本类中的方法B，B中出现异常，无论B有没有事务，sql都会回滚，A中sql也会回滚；如果将B中异常try/catch住，默认情况A中的sql不会回滚，B（无论有没有事务）中的sql也不回滚；精彩的来了，如果A调用的是其他
spring 事物 关于在同一个类中一个方法调用另一个方法，事物的传播行为会失效
u011186019的专栏
05-06 1万+
spring 提供了强大的事物管理机制，直接到在方法或者类上加@Transactional，也可以使用XML配置事物。在一次的测试中发现当一个方法在同一个类被其它方法调用的时候，导致事物的传播行为不生效。具体说明：类结构:public class Demo { public void methodA() { this.methodB(); } public void metho...
深入理解Spring的事务传播行为
凯耐的博客
10-22 860
前言 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，它不属于的事务实际提供方数据库行为。这是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文...
Spring事务传播机制，多个事务方法互相调用时，事务如何在这些方法间传播
weixin_44979389的博客
08-31 2975
Spring事务传播机制，多个事务方法互相调用时，事务如何在这些方法间传播
spring，springboot之事务（事务传播机制详解、嵌套事务）
qq_35493807的博客
04-27 8879
spring，springboot之事务（事务传播机制、嵌套事务、事务隔离机制详解）
Spring同一个类事务处理
tsp150600的博客
05-18 2294
Spring同一个类事务处理同一个类不同方法事务可以传播（需要满足事务的前提）同一个类两个不同方法调用（注解方式）同一个类两个不同方法调用（注解方式，父方法捕捉了异常）同一个类两个不同方法调用（注解方式，父方法未使用事务）同一个类两个不同方法调用（子方法编码事务方式，父方法未使用事务）同一个类两个不同方法调用（子方法编码事务方式，父方法使用注解事务）结论 同一个类不同方法事务可以传播（需要满足事务的前提） 你好！查看一些博客说，同一个类的不同标有事务注解的方法不可以传播。今天就以身试法，尝试一下，不同情况下
Java 事务的传播性（Transactional）
yy139926的博客
06-22 4942
事务的传播性是Spring特有的概念，是基于Spring AOP技术实现的，原本的方法不具备事务的功能，运用Spring AOP的方式动态的增加了事务的功能，来确保数据库的数据的一致性。
工厂模式的介绍及实现
户伟伟的博客
09-25 100
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 223
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
二分查找与二叉查找树解题指南
3. 旋转数组查找：在经过旋转的排序数组中查找元素也是二分查找的一个变种。旋转数组意味着数组的一部分被移动到了另一部分的前面或后面，因此需要特别处理边界情况。 二叉查找树（Binary Search Tree，BST）是另一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值