尚硅谷Spring注解开发学习笔记

原创 已于 2022-03-16 15:30:04 修改 · 2.8k 阅读 · 54
于 2022-03-03 21:13:19 首次发布
本文深入探讨了Spring框架的注解驱动开发，包括容器、扩展原理和Web相关概念。讲解了@Profile、@Bean、@ComponentScan、@Import、@Scope、@Conditional等注解的使用，以及如何自定义Bean后置处理器、注册组件、处理生命周期方法。同时，介绍了AOP、事务管理的实现，以及如何利用Spring容器底层组件如ServletContainerInitializer和WebApplicationInitializer。此外，文章还涵盖了SpringMVC的配置和异步请求处理。

文章目录

前言

此笔记为尚硅谷Spring注解驱动教程(雷丰阳源码级讲解)学习笔记

1、课程安排

在这里插入图片描述

根据上面这张脑图，我把整个专栏分成了三个大的部分，分别是：容器、扩展原理以及Web。

1.1、容器

容器作为整个专栏的第一大部分，内容包括：

  • AnnotationConfigApplicationContext
  • 组件添加
  • 组件赋值
  • 组件注入
  • AOP
  • 声明式事务

1.2、扩展原理

扩展原理作为整个专栏的第二大部分，内容包括：

  • BeanFactoryPostProcessor
  • BeanDefinitionRegistryPostProcessor
  • ApplicationListener
  • Spring容器创建过程

1.3、Web

Web作为整个专栏的第三大部分，内容包括：

  • servlet3.0
  • 异步请求

这部分，其实就是SpringMVC，在这个部分中，我们会重点来说异步请求。

2、配置文件开发

2.1、导入Spring-context依赖包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.13</version>
</dependency>

2.2、编写Spring配置文件

在 resources 目录下创建 application.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

2.3、编写Person类

public class Person {
   
   
    
    private String name;
    private Integer age;
	
    // 省略构造方法，get/set方法，toString方法
}

2.4、在Spring配置文件中创建Bean

<bean id="person" class="com.xjhqre.pojo.Person">
    <property name="name" value="xjhqre"/>
    <property name="age" value="18"/>
</bean>

2.5、编写测试类

public class SpringTest {
   
   
    public static void main(String[] args) {
   
   
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        Person person = (Person) applicationContext.getBean("person");
        System.out.println(person);
    }
}

测试结果：

Person{
   
   name='xjhqre', age=18}

3、注解开发简单案例

3.1、创建配置类

在方法上面加上@Bean注解后，Spring会以方法返回类型作为组件的类型，方法名作为组件的 id

当向@Bean中添加参数时，默认添加的第一个参数是value，强制给组件赋值id

// 配置类等同于xml配置文件
@Configuration // 告诉Spring这是一个配置类
public class MainConfig {
   
   

    // 给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
    @Bean("person")
    public Person person01(){
   
   
        return new Person("lisi", 20);
    }
}

3.2、测试代码

public static void main(String[] args) {
   
   
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    Person bean = applicationContext.getBean(Person.class);
    System.out.println(bean);
}

测试结果：

Person{
   
   name='lisi', age=20}

4、包扫描

只要标注了@Controller、@Service、@Repository、@Component的，都会被扫描加入到容器里

**注意：**配置类自身也会被扫描到容器中，如果存在多个配置类，则多个配置类里的所有bean对象都会被扫描进容器中

4.1、配置文件包扫描

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

4.2、注解扫描

在配置类上添加注解@ComponentScan

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
public class MainConfig {
   
   
    // ...
}

4.3、排除扫描

Filter[] excludeFilters() default {
   
   };

注解排除excludeFilters的返回类型为Filter[]

Filter 的排除类型 FilterType 有一下几种：

  • ANNOTATION：按注解排除，常用
  • ASSIGNABLE_TYPE：按类型排除，常用
  • ASPECTJ：按AspectJ 类型模式表达式排除，不常用
  • REGEX：按正则表达式排除
  • CUSTOM：自定义排除

下面以ANNOTATION按注解排除来演示：

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre", excludeFilters = {
   
   
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
   
   Controller.class, Service.class})
})
public class MainConfig {
   
   
    // ...
}

4.4、指定扫描

扫描的时候只需要包含哪些组件，编写方式和excludeFilters一样

注意要关闭默认的扫描过滤器

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre", includeFilters = {
   
   
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
   
   Controller.class, Service.class})
}, useDefaultFilters = false)
public class MainConfig {
   
   
    // ...
}

在 jdk8 之后可以写多个@ComponentScan，写法如下：

@Configuration // 告诉Spring这是一个配置类
@ComponentScans(
        value = {
   
   
                @ComponentScan(value = "com.xjhqre", includeFilters = {
   
   
                        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
   
   Controller.class, Service.class})
                }, useDefaultFilters = false)
        }
)
public class MainConfig {
   
   
    // ...
}

4.5、按类型扫描

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre", includeFilters = {
   
   
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {
   
   BookController.class})
}, useDefaultFilters = false)
public class MainConfig {
   
   
    // ...
}

4.6、自定义扫描

4.6.1、编写TypeFilter的实现类

public class MyTypeFilter implements TypeFilter {
   
   

    /**
     * @param metadataReader 读取到当前正在扫描类的信息
     * @param metadataReaderFactory 可以获取其他任何类的信息
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
   
   
        // 获取当前类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();

        // 获取当前正在扫描类的信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();

        // 获取当前类的资源信息（类的路径）
        Resource resource = metadataReader.getResource();

        String className = classMetadata.getClassName();
        System.out.println(className);
        return className.contains("er");
    }
}

4.6.2、修改配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre", includeFilters = {
   
   
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {
   
   MyTypeFilter.class})
}, useDefaultFilters = false)
public class MainConfig {
   
   
    // ...
}

5、@scope注解

5.1、默认单实例

5.1.1、编写配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
public class MainConfig2 {
   
   

    @Bean("person")
    public Person person() {
   
   
        return new Person("张三", 25);
    }
}

5.1.2、编写测试

@Test
public void test2() {
   
   
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    Person bean = applicationContext.getBean(Person.class);
    Person bean2 = applicationContext.getBean(Person.class);
    System.out.println(bean.hashCode());
    System.out.println(bean2.hashCode());
}

输出结果：

com.xjhqre.config.MainConfig2
com.xjhqre.config.MyTypeFilter
com.xjhqre.controller.BookController
com.xjhqre.pojo.Person
404214852
404214852

可以看到 bean 和 bean2 是同一个实例

5.2、@scope参数

ConfigurableBeanFactory.SCOPE_PROTOTYPE,

ConfigurableBeanFactory.SCOPE_SINGLETON,

org.springframework.web.context.WebApplicationContext.SCOPE_REQUEST,

org.springframework.web.context.WebApplicationContext.SCOPE_SESSION, value

后两个需要导入 Spring web 的jar包，且基本不用，只讨论前两个

在ConfigurableBeanFactory中有两个常量：

// 单实例，默认值，在IOC容器启动时就会调用方法创建对象，以后每次获取直接从容器中拿（map.get()）
String SCOPE_SINGLETON = "singleton";
// 多实例，在使用getBean()获取bean对象时才会创建
String SCOPE_PROTOTYPE = "prototype";

WebApplicationContext中的两个常量

// 同一次请求创建一个实例
String SCOPE_REQUEST = "request";
// 同一个session创建一个实例
String SCOPE_SESSION = "session";

5.3、测试多实例

5.3.1、修改配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
public class MainConfig2 {
   
   
    
    @Bean("person")
    @Scope("prototype")
    public Person person() {
   
   
        return new Person("张三", 25);
    }

}

5.3.2、测试代码

@Test
public void test2() {
   
   
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    Person bean = applicationContext.getBean(Person.class);
    Person bean2 = applicationContext.getBean(Person.class);
    System.out.println(bean.hashCode());
    System.out.println(bean2.hashCode());
}

测试结果：

com.xjhqre.config.MainConfig2
com.xjhqre.config.MyTypeFilter
com.xjhqre.controller.BookController
com.xjhqre.pojo.Person
961712517
1928931046

可以看到两个 bean 的哈希值不同

5.4、懒加载

针对单实例设置，因为单实例是在容器启动时创建对象

懒加载就是不让单实例在容器启动时创建，在第一次获取Bean时创建对象并初始化。

只需要在方法上添加注解@Lazy

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
public class MainConfig2 {
   
   

    @Bean("person")
    @Lazy
    public Person person() {
   
   
        return new Person("张三", 25);
    }

}

6、@Conditional注解(重点)

按照一定的条件进行判断，满足条件给容器中注册Bean

@Conditional源码

@Target({
   
   ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
   
   

    // 传入一个Condition数组
    Class<? extends Condition>[] value();

}

Condition接口源码：

@FunctionalInterface
public interface Condition {
   
   

    /**
     * ConditionContext：判断条件能使用的上下文环境
     * AnnotatedTypeMetadata：注释信息
     */
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);

}

6.1、业务场景

如果是linux系统则注册linus，如果是windows系统则注册bill Gates

6.2、编写WindowsCondition

编写windows条件，需要实现接口Condition，重写matches方法

public class WindowsCondition implements Condition {
   
   
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
   
   
        // 判断是否是Windows系统
        // 1. 获取到IOC使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 2. 获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        // 3. 获取运行环境
        Environment environment = context.getEnvironment();
        // 4. 获取到bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();

        // 容器中是否包含person,判断容器中的bean注册情况，也可以给容器中注册bean
        boolean person = registry.containsBeanDefinition("person");

        // 运行环境是否是Windows
        String property = environment.getProperty("os.name");
        assert property != null;
        return property.contains("Windows");
    }
}

6.3、编写LinuxCondition

public class LinuxCondition implements Condition {
   
   
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
   
   
        Environment environment = context.getEnvironment();
        String property = environment.getProperty("os.name");
        assert property != null;
        return property.contains("linux");
    }
}

6.4、编写配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
public class MainConfig3 {
   
   

    @Bean("bill")
    @Conditional({
   
   WindowsCondition.class})
    public Person person() {
   
   
        return new Person("bill gates", 62);
    }

    @Bean("linus")
    @Conditional({
   
   LinuxCondition.class})
    public Person person2() {
   
   
        return new Person("linus", 48);
    }

}

6.5、编写测试

@Test
public void test3() {
   
   
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig3.class);
    Map<String, Person> beansOfType = applicationContext.getBeansOfType(Person.class);
    System.out.println(beansOfType);
}

测试结果：

{
   
   bill=Person{
   
   name='bill gates', age=62}}

当@Conditional配置在类上时，表示只有满足条件时，这个配置类配置的所有bean才会生效

7、组件注册方法

  1. 包扫描 + 组件标注注解（@Controller、@Service、@Repository、@Component），这种方式只能注册自己写的类
  2. @Bean，可以注册第三方包的类
  3. @Import：快速给容器中导入一个组件，id默认是全类名
    1. ImportSelector：一个接口，返回需要导入的组件的全类名数组
    2. ImportBeanDefinitionRegistrar：一个接口，手动注册bean到容器中
  4. 使用Spring提供的FactoryBean（工厂Bean）

7.1、@Import(重点)

7.1.1、编写配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
@Import({
   
   Color.class, Red.class}) // 导入组件，id默认是组件的全类名
public class MainConfig3 {
   
   }

7.1.2、编写测试

@Test
public void test4() {
   
   
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig3.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String beanDefinitionName : beanDefinitionNames) {
   
   
        System.out.println(beanDefinitionName);
    }
}

测试结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig3
com.xjhqre.pojo.Color
com.xjhqre.pojo.Red

7.2、ImportSelector

7.2.1、编写MyImportSelector

// 自定义逻辑，返回需要导入的组件
public class MyImportSelector implements ImportSelector {
   
   
    // 返回值就是要导入到容器中的组件的全类名
    // AnnotationMetadata：当前标注@Import注解类的所有信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
   
   
        return new String[]{
   
   "com.xjhqre.pojo.Blue", "com.xjhqre.pojo.Yellow"};
    }
}

7.2.2、修改配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
@Import({
   
   Color.class, Red.class, MyImportSelector.class}) // 导入组件，id默认是组件的全类名
public class MainConfig3 {
   
   }

7.2.3、测试

@Test
public void test4() {
   
   
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig3.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String beanDefinitionName : beanDefinitionNames) {
   
   
        System.out.println(beanDefinitionName);
    }
}

测试结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig3
com.xjhqre.pojo.Color
com.xjhqre.pojo.Red
com.xjhqre.pojo.Blue
com.xjhqre.pojo.Yellow

7.3、ImportBeanDefinitionRegistrar

7.3.1、编写MyImportBeanDefinitionRegistrar

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
   
   

    /**
     * AnnotationMetadata：当前类的注解信息
     * BeanDefinitionRegistry：注册类
     * 把所有需要添加到容器中的bean，调用BeanDefinitionRegistry.registerBeanDefinition手动注册
     */
    @Override
    public void registerBeanDefinitions
标签
#经验分享 #后端 #spring #tomcat #java
最低0.47元/天 解锁文章
尚硅谷springcloud脑图xmind版（全）
09-01
尚硅谷springcloud脑图xmind版（全），包含备注等，非pdf版
spring注解笔记
10-20
spring注解笔记spring注解笔记spring注解笔记spring注解笔记
尚硅谷Spring注解驱动教程(雷丰阳源码级讲解)
weixin_44229645的博客
05-28 1206
01注解驱动开发 p02 创建个maven项目 xml以前的写法 实体类 配置类写法 p03 组件注册@ComponentScan 自动扫描组件
1 - 11 Spring源码分析（注解开发）B站 雷丰阳 如何向Spring容器中注册bean的知识 参考博主李阿昀
Princess_Y
04-25 460
Spring源码分析（注解开发） Spring注解驱动开发第2讲——使用@Configuration和@Bean给容器中注册组件 我们在使用注解方式向Spring的IOC容器中注入JavaBean时，如果没有在@Bean注解中明确指定bean的名称，那么就会使用当前方法的名称来作为bean的名称；如果在@Bean注解中明确指定了bean的名称，那么就会使用@Bean注解中指定的名称来作为bean的名称。 /** * 以前配置文件的方式被替换成了配置类，即配置类==配置文件 * @author liay
Spring注解驱动笔记（一） - 雷丰阳源码级讲解
qq_38973118的博客
09-28 1383
Spring注解驱动开发（一） 简介-注解驱动开发 组件注册-@Configuration&@Bean给容器中注册组件 组件注册-@ComponentScan-自动扫描组件&指定扫描规则 组件注册-自定义TypeFilter指定过滤规则 [组件注册-@Scope-设置组件作用域](# 组件注册-@Scope-设置组件作用域) B站视频地址：https://www.bilibili.com/video/BV1gW411W7wy 简介-注解驱动开发 当我们还在使用Spring、SpringMV
尚硅谷-Spring5框架2020最新版教程笔记
面向百度编程专家
10-18 6253
尚硅谷-Spring5框架2020最新版教程 文章目录尚硅谷-Spring5框架2020最新版教程一、Spring框架概述1、Spring特点2、Spring版本选择3、入门案例二、IOC容器1、IOC底层原理2、IOC接口（BeanFactory）4、IOC操作 Bean 管理5、IOC操作 Bean 管理（基于xml）6、IOC操作Bean管理（xml注入其他类型属性）7、IOC操作Bean管理（xml注入集合属性）8、IOC操作Bean管理（FactotyBean）9、IOC操作Bean管理（bean
学习笔记：尚硅谷Spring6基础篇
D_boj的博客
08-14 5800
本章介绍，Spring6基础使用、Spring的IOC原理、Spring6整合日志框架、容器IOC、面向切面AOP以及依赖注入的方式、自动装配和依赖注入等
尚硅谷-Spring5框架2020笔记
oldhen的博客
08-11 2410
尚硅谷-Spring5框架2020最新版教程 文章目录 尚硅谷-Spring5框架2020最新版教程 一、Spring框架概述 1、Spring特点 2、Spring版本选择 3、入门案例 二、IOC容器 1、IOC底层原理 2、IOC接口（BeanFactory） 4、IOC操作 Bean 管理 5、IOC操作 Bean 管理（基于xml） 6、IOC操作Bean管理（xml注入其他类型属性） 7、IOC操作Bean管理（xml注入集合属性） 8、IOC操作Bean管理（FactotyB
尚硅谷——Spring注解驱动教程笔记
最新发布
qq_42449963的博客
03-18 431
目录01_尚硅谷_课程简介-注解驱动开发02_尚硅谷_组件注册-@Configuration&@Bean给容器中注册组件 01_尚硅谷_课程简介-注解驱动开发 大纲介绍，不在记录 02_尚硅谷_组件注册-@Configuration&@Bean给容器中注册组件 ...
SpringBoot3 全栈指南教程——尚硅谷学习笔记 2023年
末影小黑xh的博客
09-15 8716
Java17Maven、IDEA1、Spring 使用作为内部日志，但底层日志实现是开放的。可对接其他日志框架。① spring5 及以后 commons-logging 被 spring 直接自己实现了。2、支持jullog4j2logback。SpringBoot 提供了默认的控制台输出配置，也可以配置输出为文件。3、logback是默认使用的。4、虽然日志框架很多，但是不用担心，使用 SpringBoot 的默认配置就能工作的很好。SpringBoot 怎么把日志默认配置好的。1、每个。
Spring-尚硅谷-学习笔记
weixin_45581692的博客
10-10 7222
Spring框架是一个轻量级的开源的JavaEE框架。 Spring可以解决企业应用开发的复杂性。 Spring有两个核心部分：IOC和AOP IOC：控制反转，把创建对象的过程交给Spring AOP：面向切面，不修改源代码的情况下进行功能增强 Spring特点 方便解耦，简化开发 AOP编程支持 方便程序测试 方便和其他框架进行整合
SSM整合尚硅谷Spring
byteyoung
11-17 1368
Spring(一)----IOC控制反转、DI依赖注入 Spring基础知识学习笔记(一)，内容包括： Spring入门案例 IOC控制反转理解 属性注入的不同方式 注入不同类型的属性值 自动装配与注解开发 参考视频： B站 尚硅谷雷丰阳大神的Spring、Spring MVC、MyBatis课程 【狂神说Java】Spring5最新完整教程IDEA版通俗易懂 1. Spring概述 开源的免费框架，是一个容器，可以管理所有的组件(类)；
尚硅谷-spring注解驱动开发-学习记录
多思考思考
08-10 736
本章比较难，建议学完spring,springmvc之后再使用一段时间再来看，因为目前我的阶段也不能完全理解这个里面的内容，里面多是关于注解源码的解释。用到的时候再看，暂且在这里记录一下。 创建maven工程 AnnotationConfigApplicationContext @ComponentScan @Bean package com.atguigu.config; import org.springframework.context.annotati...
2、SpringBoot2入门
希望有点用
10-24 308
SpringBoot2入门
Spring Boot 2 入门笔记（尚硅谷）
ttxbgjj的博客
02-20 2463
一、基础入门 1、Spring与Spring boot 1）Spring 生态圈 ① 微服务（Microservices）：开发应用所有功能拆分的小模块 ② 相应式编程（Reactive）：异步非阻塞，高吞吐量应用 ③ 分布式云开发（Cloud）：大型应用拆分微小模块 ④ Web开发（Web apps）：发请求、响应页面... ⑤ 无服务开发（Serverless）：函数式服务 ⑥ 事件驱动（Event Driver）：实时数据流 ⑦ 批处理（Batch） 2）Spring boot
尚硅谷2025最新SpringCloud速通-操作步骤（详细）
热门推荐
github账号：https://github.com/michael-lei
02-11 2万+
本文基于【尚硅谷2025最新SpringCloud - 快速通关】进行实践操作，并对雷神的笔记做一个更详细的补充，供大家学习参考，一起加油！
SSM尚硅谷 --雷丰阳
dearand的博客
02-16 1458
第22-31集 第22集 实现点击实现点击模态框的保存按钮，实现将数据提交给服务器保存 1，实现点击模态框的保存按钮，实现将数据提交给服务器保存 2，发送ajax请求保存员工 URI：的定义 /emp/{id} GET 查询员工 /emp POST 保存员工 /emp/{id} PUT 修改员工 /emp/{id} DELETE 删除员工 //点击模态框的保存按钮实现 $("#save_add_b
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值