Spring框架2

于 2019-10-21 16:11:09 发布
阅读量133 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bibic226/article/details/102666142
版权

Spring框架2

一. Spring AOP的概念以及介绍

1. 概念：

  • AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

  • 可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,提高代码的灵活性和可扩展性，AOP可以说也是这种目标的一种实现。

2. Aop功能：
  • Aop的功能主要是为了拦截或者实现日志安全检查，一些检查的工作，aop也常用于事务管理，防止垃圾数据进入数据库。
3. 横向切割和纵向切割：
  1. Aop采用的横向切割技术，在不修改源代码的情况下完成添加功能的技术；
  2. 纵向切割技术，修改源代码情况下完成功能的操作

4.Aop里有五种增强的方式：

  • 增强/通知其实一个要添加的逻辑业务处理的方法，五种实现横向切割技术的方式

    1. 前置增强，表示在目标方法执行前实施增强

    2. 后置增强,表示在目标方法执行后实施增强

    3. 引介增强，表示在目标类中添加一些新的方法和属性。(了解)

    4. 环绕增强，表示在目标方法执行前后实施增强

    5. 异常增强，表示在目标方法抛出异常后实施增强。

    6. 最终增强，表示在目标方法执行后不管有没有异常抛出总是实施增强

二. Spring AOP的应用

1. 准备工作
  • 加入依赖坐标
    • Aspectij这个jar包，不是spring框架的一部分，可以作为spring框架的一个组件，用来配合aop完成相应的操作
<dependencies>       
    <!-- junit的jar包坐标 -->       
    <dependency>             
        <groupId>junit</groupId>     
        <artifactId>junit</artifactId>        
        <version>4.12</version>           
        <scope>test</scope>         
    </dependency>         
    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver   -->    
    <dependency>        
        <groupId>org.aspectj</groupId>   
        <artifactId>aspectjweaver</artifactId>   
        <version>1.8.9</version>      
    </dependency>    
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop   -->       <dependency>      
    <groupId>org.springframework</groupId>   
    <artifactId>spring-aop</artifactId>    
    <version>4.3.7.RELEASE</version>  
    </dependency>     
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects   -->       <dependency>      
    <groupId>org.springframework</groupId>   
    <artifactId>spring-aspects</artifactId>     
    <version>4.3.7.RELEASE</version>   
    </dependency>    
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans   -->       <dependency>       
    <groupId>org.springframework</groupId>   
    <artifactId>spring-beans</artifactId>     
    <version>4.3.7.RELEASE</version>   
    </dependency>      
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context   -->       <dependency>        
    <groupId>org.springframework</groupId>   
    <artifactId>spring-context</artifactId>       
    <version>4.3.7.RELEASE</version>     
    </dependency>    
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-core   -->       <dependency>      
    <groupId>org.springframework</groupId>     
    <artifactId>spring-core</artifactId>      
    <version>4.3.7.RELEASE</version>      
    </dependency>    
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression   -->       <dependency>         
    <groupId>org.springframework</groupId>   
    <artifactId>spring-expression</artifactId>  
    <version>4.3.7.RELEASE</version>     
    </dependency>    
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx   -->       <dependency>        
    <groupId>org.springframework</groupId> 
    <artifactId>spring-tx</artifactId>   
    <version>4.3.7.RELEASE</version>  
    </dependency>     
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc   -->       <dependency>      
    <groupId>org.springframework</groupId>    
    <artifactId>spring-jdbc</artifactId>     
    <version>4.3.7.RELEASE</version>       
    </dependency>    
    <!--   https://mvnrepository.com/artifact/org.springframework/spring-web -->   
    <dependency>         
        <groupId>org.springframework</groupId>   
        <artifactId>spring-web</artifactId>   
        <version>4.3.7.RELEASE</version>     
    </dependency>   
    <!--   https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->       <dependency>       
    <groupId>org.springframework</groupId>     
    <artifactId>spring-webmvc</artifactId>      
    <version>4.3.7.RELEASE</version>     
    </dependency>     
    <!--   https://mvnrepository.com/artifact/org.springframework/spring-test -->       <dependency>        
    <groupId>org.springframework</groupId>   
    <artifactId>spring-test</artifactId>    
    <version>4.3.7.RELEASE</version>    
    <scope>test</scope>       
    </dependency>   
</dependencies>

  • 创建核心配置文件并且加入相应的约束

    <?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:aop="http://www.springframework.org/schema/aop" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 		      				http://www.springframework.org/schema/beans/spring-beans.xsd
  			http://www.springframework.org/schema/aop 		 				    http://www.springframework.org/schema/aop/spring-aop.xsd"> 
        
      
</beans>
2. 基于aspectJ的xml版
1. 创建一个目标类
/* 目标类,就是在操作过程中手动调用的类
 */
public class TargetClass {

	public void login(){
		System.out.println("目标类方法:登录成功");
	}
}
2. 创建一个增强类
/*
 * 增强类,在调用目标类的时候spring利用aop思想,执行预编译的类
 */
public class HandleClass {

	public void check(){
		System.out.println("登录校验检查");
	}
}
3. 修改核心配置文件，加入bean管理和aop配置
  • 前置增强
 <!-- 对目标类进行bean注册 -->
	<bean id="targetClass" class="cn.kgc.xml.TargetClass"></bean>
  <!-- 对增强类进行bean注册 -->
	<bean id="handleClass" class="cn.kgc.xml.HandleClass"></bean>
	
	<!-- aop编程思想 -->
<aop:config>
		<!-- 切点 对应的是目标类的方法,在aop配置中可以有多个aop:ponitcut
			expression称之为表达式,属性值等于execution(* cn.kgc.xml.TargetClass.login(..))
			execution表示执行,该方法中三个参数,参数1表示* ,参数2是一个空格,参数3表示目标类方法的地址
			参数3方法中一定要携带两个点作为参数,第一个点表示参数类型,第二点表示参数名称,
			注意:不管你的方法中是否有参数,都必须有两个点
			id属性表示切点名称
		-->
<aop:pointcut expression="execution(* com.kgc.xml.TargetClass.login(..))" id="mycut1"/>
		<!-- 切面  对应的是增强类的方法 ref映射增强类的bean注册id	-->
<aop:aspect ref="handleClass">
	<!-- 前置增强  
			method属性表示方法的意思,对应的是增强类的中具体的方法名称
			pointcut-ref表示当前切面中的方法所对应的切点
	-->
	<aop:before method="check" pointcut-ref="mycut1"/>
</aop:aspect>
</aop:config>


public void handleBefore(){
        System.out.println("前置增强方法--取款操作前的用户校验");
    }
  • 后置增强
<aop:after-returning method="handleAfter" pointcut-ref="myPointCut"/>

public void handleAfter(){
        System.out.println("后置增强方法--取款后的信息输出");
    }
  • 环绕增强
<aop:around method="around" pointcut-ref="myPointCut"/>

public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("检查前。。。");
            pjp.proceed();//调用切点方法
        System.out.println("检查后。。。");
    }
  • 异常增强
    • 在业务目标方法中出现类异常情况，则会执行异常增强，如果不存在异常，则不执行异常增强
<aop:after-throwing method="excep" pointcut-ref="myPointCut"/>

public void excep(){
        System.out.println("出错啦");
    }

  • 最终增强

    不管有没有异常出现，均会执行的增强称之为最终增强

<aop:after method="finallyHandle" pointcut-ref="myPointCut"/>

public void finallyHandle(){
        System.out.println("最终增强--关闭资源");
    }
4. 测试类
 @Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
        TargetClass target = (TargetClass) context.getBean("target");
        target.getMoney();
    }
3. 基于注解版
1. 修改核心配置文件，加入注解驱动
<!-- 开启spring注解驱动 -->
<context:component-scan base-package="com.kgc.anno"></context:component-scan>
<!-- 开启aop切面注解驱动(aop执行自动动态代理)-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
2.注意事项：
  1. 目标类要设置@service注解，目的是为了在调用service时候完成实例化和注入操作
  2. 增强类要设置@Aspect切面注解，目的是定义当前类是切面，而且也要设置@service注解，目的也是为了在完成实例化和注入操作
  3. 注意：注解开发，主要更改的是增强类里的注解配置
3.增强类
@Service // 实例化 增强类 
@Aspect  // @Aspect  表示 增强类 为切面
public class HandleClass {
    //前置增强
    @Before("execution(* com.kgc.anno.TargetClass.getMoney(..))")
    public void handleBefore(){
        System.out.println("注解版前置增强方法--取款操作前的用户校验");
    }
   //后置增强
    @AfterReturning("execution(* com.kgc.anno.TargetClass.getMoney(..))")
    public void handleAfter(){
        System.out.println("注解版后置增强方法--取款后的信息输出");
    }
  //环绕增强
    @Around("execution(* com.kgc.anno.TargetClass.getMoney(..))")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("注解版检查前。。。");
            pjp.proceed();//调用切点方法
        System.out.println("注解版检查后。。。");
    }
  //异常增强
    @AfterThrowing("execution(* com.kgc.anno.TargetClass.getMoney(..))")
    public void excep(){
        System.out.println("注解版出错啦");
    }
    
 //最终增强
    @After("execution(* com.kgc.anno.TargetClass.getMoney(..))")
    public void finallyHandle(){
        System.out.println("注解版最终增强--关闭资源");
    }
}
4.目标类
@Service//实例化 目标类
public class TargetClass {

    public void getMoney(){
        System.out.println("目标方法：取款！");
       // int i=1/0;
    }
}
5.测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/spring/applicationContext.xml")
public class TestAop {
    @Autowired
    TargetClass target;

    @Test
    public void test1(){
        target.getMoney();
    }
}
4. Spring的事务管理
1. 事务的概念：

​ 事务管理对于企业应用而言至关重要。它保证了用户的每一次操作都是可靠的，即便出现了异常的访问情况，也不至于破坏后台数据的完整性。就像银行的自助取款机，通常都能正常为客户服务，但是也难免遇到操作过程中机器突然出故障的情况，此时，事务就必须确保出故障前对账户的操作不生效，就像用户刚才完全没有使用过取款机一样，以保证用户和银行的利益都不受损失。

​ 简单来说:事务是一系列的动作，一旦其中有一个动作出现错误，必须全部回滚，系统将事务中对数据库的所有已完成的操作全部撤消，滚回到事务开始的状态，避免出现由于数据不一致而导致的接下来一系列的错误。事务的出现是为了确保数据的完整性和一致性，在目前企业级应用开发中，事务管理是必不可少的

2. 事务的属性：

  • 传播行为

  • 隔离级别

  • 只读提示

  • 事务超时间隔

  • 回滚原则

  • 事务的属性：是对事务策略如何应用到方法上的描述。

  1. 传播行为

    ​ 定义了事务应用到方法上的边界。也就是什么时候开始一个新的事务，或者什么时候事务被暂停，或者方法是否要在事务中运行。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C1kBakXE-1571645408029)(C:\Users\CX\AppData\Roaming\Typora\typora-user-images\1556431163971.png)]

  2. 隔离级别

    用来指定一个事务受其他并发事务活动影响的程度。隔离性是数据的事务的4个特征之一，但是实际上来说，用户使用数据库产品是需要在效率和安全上找到平衡点的，所以需要设置事务的隔离级别；

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IdS9yRoR-1571645408030)(C:\Users\CX\AppData\Roaming\Typora\typora-user-images\1556431188395.png)]

  3. 只读提示

    Read-only=true,必须配合传播行为来设置。一般建议设置在查询的方法中，

  4. 事务超时间隔

    可以让事务在特定的秒数后自动回滚，不必等到它自己结束。它也必须配合传播行为来设置。Timeout=5

  5. 回滚规则

    默认情况下在出现运行时异常RuntimeException才会回滚。检查时异常不回滚。当然也可以改变这种规则。

5. 声明式事务(常用)

  • 声明式事务管理：它将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。事务管理作为一种横切关注点，可以通过AOP方法模块化。Spring通过Spring AOP框架支持声明式事务管理。

  • 声明式事务管理有三种方法实现，分别是TransactionProxyFactoryBean的代理方式、基于AspectJ的xml配置方式和基于注解的声明方式，后两种在开发应用中常常出现。

  • 声明式事务管理是基于AOP思想完成的，类似与在给业务层加入切面，对事务操作前后进行一定的事务管理控制。

1.基于注解版–转账案例
  • 修改核心配置文件
<!--开启 类的注解 切点的注解-->
    <context:component-scan base-package="com.kgc"></context:component-scan>
    <!--开启切点的注解-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <!--实例化 jdbc模板对象  需要数据源  -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--创建一个自己的dataSource-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/k8514?characterEncoding=utf-8"/>
        <property name="user" value="root"/>
        <property name="password" value="ROOT"/>
    </bean>

    <!--配置事务 管理  需要数据源 数据源有回滚 rollback（撤回）方法 -->
    <bean id="transactionManager1" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--开启 事务的注解 -->
    <tx:annotation-driven transaction-manager="transactionManager1"></tx:annotation-driven>
  • Dao实现类
@Repository
public class AccountDaoImpl  implements AccountDao{

   @Autowired
   private JdbcTemplate template;

    @Override
    public void outAccount(String outCard, double money) {

        String sql="update account set money=money-? where account=?";
        template.update(sql, money,outCard);

    }

    @Override
    public void inAccount(String inCard, double money) {
        String sql="update account set money=money+? where account=?";
        template.update(sql, money,inCard);

    }
}
  • Service实现类
@Transactional//事务的注解,表示当前类下的所有方法均加入事务
@Service
public class AccountServiceImpl implements AccountService{
   @Autowired
    private AccountDao dao;
   
    @Override
    public void transferAccounts(String inCard, String outCard, double money) {
        dao.outAccount(outCard,money);
        //int i=1/0;
        dao.inAccount(inCard,money);
    }
}
  • 测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/spring/applicationContext.xml")
public class TestTx {
    @Autowired
    private AccountService service;

    @Test
    public void testTx1(){
        service.transferAccounts("曹操","刘备",50);
        System.out.println(1);
    }
}
bibic226
关注
Spring框架介绍及使用
qq_22583741的博客
03-17 39万+
Spring框架—控制反转（IOC） 1 Spring框架概述 1.1 什么是Spring 1.2 Spring的优点 1.3 Spring的体系结构 2 入门案例:（IoC） 2.1导入jar包 2.2目标类 2.3 配置文件 2.4测试 3 入门案例：DI 3.1 目标类 3.2 dao 3.3 service 3.4 配置文件 3.5 测试 4 依赖注入...
Spring-aop
Ken_ki的博客
07-21 251
Spring-Aop 一. Spring AOP的概念以及介绍 1. 概念： AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得...
经典三层框架初识(二)---Spring 2.2入门案例2
XiaodunLP的博客
10-26 185
前面我们模拟了一下用spring创建dao对象的案例并测试.也就是原来我们数据持久层的代码,我们下面深入一下,我们以前是在表示层就直接调用了下面的数据持久层,但是现在咱们需要业务逻辑层.所以我们用service这层来实现一下业务逻辑层的代码 首先我们还是用原来的传统方式做一下.我们在上面案例的基础上实现 在src下创建一个service的包,里面定义一个UserService接口 pack...
开始全心投入《深入Spring 2：轻量级J2EE开发框架原理与实践》
.NET博文收藏
06-08 697
　　上周给出版社的申请，终于批复了下来，出版合同也定了，《深入Spring 2：轻量级J2EE开发框架原理与实践》是一本讲解Spring设计原理的书，参与写作的是EasyJF的几位成员。前期基本完成了一半，离交稿时间还有一个月，这段时间将全身心投入到这本书的写作及案例开发中。我们会争取从书中提出一些精彩章节在Blog及EasyJF官网上发布出来，有兴趣的朋友请关注。    　　在写前一半给我的
spring 2.x总结
bdql的专栏
12-15 311
Spring是分层的java SE/EE应用一站式的轻量级开源框架，以IOC和AOP为内核，提供了展示层spring mvc和持久层spring jdbc，以及业务层事务管理等众多的企业级应用技术。 相关的网站： spring.jactiongroup.net www.springside.org.cn www.iteye.com   spring的体系结构 spring共有1400个类，其框架按...
spring框架api中文版.zip(spring开发手册）
04-06
即Spring框架的概述 1。 介绍Spring框架 1.1。 依赖注入和控制反转 1.2。 模块 1.2.1。 核心容器 1.2.2。 数据访问/集成 1.2.3。 web 1.2.4。 AOP和仪表 1 2 5。 测试 1.3。 使用场景 1.3.1。 依赖关系管理和命名...
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6。 此外，还有：log4j、slf4j、junit4、ehcache等知识点。 项目...
spring框架2016
08-26
最新spring框架2016视频教程，包含源码和笔记。小白入手实用教程。
Spring框架精讲
06-29
通过Spring的入门程序介绍了Spring的 IoC 和 DI 的概念，介绍了Spring的基本模块。详细介绍了对象创建的细节和依赖注入的几种方式；介绍了如何使用注解完成Spring的相关功能；介绍了如何借助于Spring搭建JUnit测试...
框架(Spring、Struts2和Hibernate三者)整合
~~~~~~~~~~~~
03-13 4607
总结一下就是： 1.Struts2与Spring相连的是：action不是Struts2框架new 出来的，而是从Spring的xml(applicationContext.xml)配置文件中拿出 2.Spring和Hibernate相通的是：Hibernate的SessionFactory采用Spring注入，同时dao的实现类继承Spring的类(HibernateDaoSupport)
Spring框架总结【无比详细】
热门推荐
zp的博客
08-07 25万+
以下内容是我在初学spring时候做的笔记，当时是把比较放在了备忘录里面，如今把笔记重整到csdn上，为了复习也为了分析给大家，笔记写的算比较完整，回看自己做的还是有点羞涩。如有错误之处，欢迎指正，当我日后更强大的时候，我会不断的对内容进行补充和完善。当然学习也就是这么一个过程，学习-实践-总结-实践-总结... 转载请申明原文地址，希望大家支持，谢谢。 1、IOC和DI IOC: ...
Spring框架详解
lichencute的博客
09-29 5万+
一、web应用 1.我们生活在web时代，每一分钟都有上百万个网页在生成，包含很多内容 web应用是一种客户端-服务器端的程序 客户端包括用户界面和客户端逻辑，运行环境为web浏览器 2.常见的web应用有：网页邮件，在线销售， 在线拍卖，维基，快捷的信息服务 客户端的软件就在网页下载 3.浏览器后还有更多的东西 这些浏览器程序经由web服务器下载下来，很多动态的东西在云端生成，一些应用会用到数...
考虑励磁控制系统的水热两区互联电力系统网络自动生成控制simulink.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Python 实现BO-CNN-BiLSTM贝叶斯优化卷积双向长短期记忆网络数据多变量时间序列预测（包含详细的完整的程序和数据）
10-09
内容概要：本文详细介绍了如何使用 Python 和深度学习方法（包括卷积神经网络 CNN 与双向长短期记忆网络 BiLSTM 结合的 BO-CNN-BiLSTM）进行多变量时间序列的数据预测。内容涵盖了从数据准备到超参数优化的全过程，并提供了完整的代码实现和实例展示。 适用人群：机器学习初学者，尤其适合对时间序列预测感兴趣的深度学习爱好者、研究者、工程技术人员。 使用场景及目标：适用于需要对时间序列数据如股票价格、环境数据、医疗健康监控等领域做精准预测的情况。本教程可以帮助理解深度学习在网络模型优化方面的运用。 其它：文中还讨论了项目的注意事项，并指出了可能的方向性改进路径，比如增加模型解释能力、实际应用等
用于kpca降维，对于故障特征诊断具有重要的作用不能运行.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Python 实现 INFO-ELM（向量加权算法优化极限学习机）进行多输入单输出回归预测（包含详细的完整的程序和数据）
10-09
内容概要：本文详细介绍了如何利用PYTHON实现INFO-ELM（一种加权优化极限学习机）来进行多输入单输出（MISO）回归预测的方法。其中包括数据生成、算法建模、权重迭代更新以及最终的效果评估等一系列过程，并附有可视化的结果比较。 适用人群：适合熟悉或正在学习机器学习基本理论，特别是有兴趣深入理解和应用ELM和加权回归算法的研究人员和技术人员。 使用场景及目标：适用于解决多个输入变量对应一个连续数值输出的实际预测问题，通过优化模型提升预测准确性和稳定性。 其他说明：文中还提供了进一步研究和改进的方向，如扩展隐含节点数量、改善权重调节方法及采用平行计算等方式提高预测质量。
005-基于51单片机的酒精测试设计
最新发布
10-09
请结合博客看 https://blog.csdn.net/weixin_41011452/article/details/140587967?spm=1001.2014.3001.5502
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值