Spring5注解驱动（四）

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量915 收藏 17
点赞数 25
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42035206/article/details/135271398
版权

3.生命周期

3.1. @Bean指定初始化和销毁方法

首先，定义一个Car类：

package com.hutu.bean;

public class Car {

    public Car() {
        System.out.println("car constructor...");
    }

    public void init() {
        System.out.println("car ... init ...");
    }

    public void destroy() {
        System.out.println("car ... destroy ...");
    }

}

配置类：MainConfigOfLifeCycle

package com.hutu.config;

import com.hutu.bean.Car;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * bean的生命周期：bean的创建->初始化->销毁的过程
 * 容器管理bean的生命周期：
 * 可以自定义初始化方法和销毁的方法：容器在bean进行到当前的生命周期的时候，来调用我们自定义的初始化方法和销毁方法
 * 
 * 构造（对象创建）：
 *   -- 单实例：在容器启动的时候创建对象
 *   -- 多实例：在每次获取的时候来创建对象
 * 初始化方法：
 *   --  对象创建完成，并赋值好，调用初始化方法
 * 销毁方法：
 *   -- 单实例的bean:在容器关闭的时候进行销毁
 *   -- 多实例的bean:容器不会管理这个bean,容器不会调用销毁的方法
 * <p>
 * 1)指定初始化方法和销毁方法；
 * 可以通过@Bean(initMethod = "init",destroyMethod = "destroy")来指定初始化方法和销毁方法
 * 相当于xml配置文件bean标签里面的 init-method="" 和 destroy-method="" 属性
 */
@Configuration
public class MainConfigOfLifeCycle {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

测试

@Test
public void test01() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
}

此时，还没有关闭IOC容器的时候，运行结果为

car constructor...
car ... init ...
容器创建完成

而当调用了容器的close方法关闭容器的时候：

@Test
public void test01() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
    context.close();
}

测试的运行结果为：

car constructor...
car ... init ...
容器创建完成
car ... destroy ...

而当bean的作用域为多例的时候：

@Configuration
public class MainConfigOfLifeCycle {

    @Scope("prototype")
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

再次测试

@Test
public void test01() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
    context.close();
}

测试结果

容器创建完成

当bean的作用域为多例的时候，只有在获取的时候，才会创建对象，而且在IOC容器关闭的时候，是不进行销毁的 ：

@Test
public void test01() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
    Object car = context.getBean("car");
    context.close();
}

测试结果

容器创建完成
car constructor...
car ... init ...

3.2. InitializingBean和DisposableBean

InitializingBean接口：在bean的初始化方法调用之后进行调用

package org.springframework.beans.factory;


public interface InitializingBean {

	/**
	 * Invoked by the containing {@code BeanFactory} after it has set all bean properties
	 * and satisfied {@link BeanFactoryAware}, {@code ApplicationContextAware} etc.
	 * <p>This method allows the bean instance to perform validation of its overall
	 * configuration and final initialization when all bean properties have been set.
	 * @throws Exception in the event of misconfiguration (such as failure to set an
	 * essential property) or if initialization fails for any other reason
	 */
	void afterPropertiesSet() throws Exception;

}

DisposableBean 接口

package org.springframework.beans.factory;

public interface DisposableBean {

	/**
	 * Invoked by the containing {@code BeanFactory} on destruction of a bean.
	 * @throws Exception in case of shutdown errors. Exceptions will get logged
	 * but not rethrown to allow other beans to release their resources as well.
	 */
	void destroy() throws Exception;

}

cat类：实现这两个接口

package com.hutu.bean;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Car implements InitializingBean, DisposableBean {

    public Car() {
        System.out.println("car constructor...");
    }

    public void init() {
        System.out.println("car ... init ...");
    }

    @Override
    public void destroy() {
        System.out.println("car ... destroy ...");
    }

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

用包扫描的方式来进行装配

@Configuration
@ComponentScan("com.hutu.bean")
public class MainConfigOfLifeCycle {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

测试

@Test
public void test01() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
    context.close();
}

测试结果

car constructor...
Cat...afterPropertiesSet...
car ... init ...
容器创建完成
car ... destroy ...

3.3. @PostConstruct&@PreDestroy

可以使用JSR250规范里面定义的两个注解：

  • @PostConstruct :在bean创建完成并且属性赋值完成，来执行初始化方法

  • @PreDestroy ：在容器销毁bean之前通知我们来进行清理工作

@PostConstruct：在bean创建完成并且属性赋值完成，来执行初始化方法

@PreDestroy：在容器销毁bean之前通知我们来进行清理工作

定义一个Dog类

package com.hutu.bean;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class Dog {
    public Dog() {
        System.out.println("Dog...Contructor...");
    }

    //在对象创建并赋值之后调用
    @PostConstruct
    public void init() {
        System.out.println("Dog...@PostConstruct...");
    }

    //在对象创建并赋值之后调用
    @PreDestroy
    public void destroy() {
        System.out.println("Dog...@PreDestroy...");
    }
}

再来运行这个测试方法：

@Test
public void test01() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
    context.close();
}

测试结果

Dog...Contructor...
Dog...@PostConstruct...
car constructor...
Cat...afterPropertiesSet...
car ... init ...
容器创建完成
car ... destroy ...
Dog...@PreDestroy...

3.4. BeanPostProcessor-后置处理器

BeanPostProcessor接口：bean的后置处理器，在bean初始化前后做一些处理工作，这个接口有两个方法：

  • postProcessBeforeInitialization：在初始化之前工作

  • postProcessAfterInitialization：在初始化之后工作

BeanPostProcessor接口

package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;
import org.springframework.lang.Nullable;

public interface BeanPostProcessor {

	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

同样，还是使用包扫描的方式来进行装配：

@Configuration
@ComponentScan("com.hutu.bean")
@ComponentScan("com.hutu.config")
public class MainConfigOfLifeCycle {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

写一个类并且实现这个后置处理器接口 BeanPostProcessor ：

package com.hutu.config;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization..." + beanName + "=>" + bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization..." + beanName + "=>" + bean);
        return bean;
    }
}

测试

@Test
public void test01() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
    context.close();
}

测试结果

通过自定义的匹配规则--->com.hutu.test.MainTest
通过自定义的匹配规则--->com.hutu.test.MainTest01
通过自定义的匹配规则--->com.hutu.bean.Blue
通过自定义的匹配规则--->com.hutu.bean.Car
通过自定义的匹配规则--->com.hutu.bean.Color
通过自定义的匹配规则--->com.hutu.bean.Dog
通过自定义的匹配规则--->com.hutu.bean.Person
通过自定义的匹配规则--->com.hutu.bean.RainBow
通过自定义的匹配规则--->com.hutu.bean.Red
通过自定义的匹配规则--->com.hutu.bean.Yellow
通过自定义的匹配规则--->com.hutu.config.ColorFactoryBean
通过自定义的匹配规则--->com.hutu.config.LinuxCondition
通过自定义的匹配规则--->com.hutu.config.MainConfig2
通过自定义的匹配规则--->com.hutu.config.MainConfigOfLifeCycle
通过自定义的匹配规则--->com.hutu.config.MyBeanPostProcessor
通过自定义的匹配规则--->com.hutu.config.MyImportBeanDefinitionRegistrar
通过自定义的匹配规则--->com.hutu.config.MyImportSelector
通过自定义的匹配规则--->com.hutu.config.MyTypeFilter
通过自定义的匹配规则--->com.hutu.config.WindowsCondition
通过自定义的匹配规则--->com.hutu.controller.BookController
通过自定义的匹配规则--->com.hutu.dao.BookDao
通过自定义的匹配规则--->com.hutu.service.BookService
postProcessBeforeInitialization...mainConfigOfLifeCycle=>com.hutu.config.MainConfigOfLifeCycle$$EnhancerBySpringCGLIB$$58dbf743@50a638b5
postProcessAfterInitialization...mainConfigOfLifeCycle=>com.hutu.config.MainConfigOfLifeCycle$$EnhancerBySpringCGLIB$$58dbf743@50a638b5
Dog...Contructor...
postProcessBeforeInitialization...dog=>com.hutu.bean.Dog@1725dc0f
Dog...@PostConstruct...
postProcessAfterInitialization...dog=>com.hutu.bean.Dog@1725dc0f
postProcessBeforeInitialization...mainConfig=>com.hutu.config.MainConfig$$EnhancerBySpringCGLIB$$d6ed4678@3911c2a7
postProcessAfterInitialization...mainConfig=>com.hutu.config.MainConfig$$EnhancerBySpringCGLIB$$d6ed4678@3911c2a7
postProcessBeforeInitialization...mainConfig2=>com.hutu.config.MainConfig2$$EnhancerBySpringCGLIB$$5b037c42@4ac3c60d
postProcessAfterInitialization...mainConfig2=>com.hutu.config.MainConfig2$$EnhancerBySpringCGLIB$$5b037c42@4ac3c60d
postProcessBeforeInitialization...person=>Person(name=null, age=null)
postProcessAfterInitialization...person=>Person(name=null, age=null)
postProcessBeforeInitialization...myTypeFilter=>com.hutu.config.MyTypeFilter@76508ed1
postProcessAfterInitialization...myTypeFilter=>com.hutu.config.MyTypeFilter@76508ed1
postProcessBeforeInitialization...bookController=>com.hutu.controller.BookController@41e36e46
postProcessAfterInitialization...bookController=>com.hutu.controller.BookController@41e36e46
postProcessBeforeInitialization...bookService=>com.hutu.service.BookService@15c43bd9
postProcessAfterInitialization...bookService=>com.hutu.service.BookService@15c43bd9
postProcessBeforeInitialization...person666=>Person(name=小糊涂仙, age=20)
postProcessAfterInitialization...person666=>Person(name=小糊涂仙, age=20)
postProcessBeforeInitialization...com.hutu.bean.Color=>com.hutu.bean.Color@188715b5
postProcessAfterInitialization...com.hutu.bean.Color=>com.hutu.bean.Color@188715b5
postProcessBeforeInitialization...com.hutu.bean.Red=>com.hutu.bean.Red@1ea9f6af
postProcessAfterInitialization...com.hutu.bean.Red=>com.hutu.bean.Red@1ea9f6af
postProcessBeforeInitialization...com.hutu.bean.Blue=>com.hutu.bean.Blue@6a192cfe
postProcessAfterInitialization...com.hutu.bean.Blue=>com.hutu.bean.Blue@6a192cfe
postProcessBeforeInitialization...com.hutu.bean.Yellow=>com.hutu.bean.Yellow@5119fb47
postProcessAfterInitialization...com.hutu.bean.Yellow=>com.hutu.bean.Yellow@5119fb47
postProcessBeforeInitialization...bill=>Person(name=Bill Gates, age=28)
postProcessAfterInitialization...bill=>Person(name=Bill Gates, age=28)
postProcessBeforeInitialization...linux=>Person(name=linus, age=19)
postProcessAfterInitialization...linux=>Person(name=linus, age=19)
postProcessBeforeInitialization...colorFactoryBean=>com.hutu.config.ColorFactoryBean@1dde4cb2
postProcessAfterInitialization...colorFactoryBean=>com.hutu.config.ColorFactoryBean@1dde4cb2
postProcessBeforeInitialization...rainBow=>com.hutu.bean.RainBow@393671df
postProcessAfterInitialization...rainBow=>com.hutu.bean.RainBow@393671df
car constructor...
postProcessBeforeInitialization...car=>com.hutu.bean.Car@55b7a4e0
Cat...afterPropertiesSet...
car ... init ...
postProcessAfterInitialization...car=>com.hutu.bean.Car@55b7a4e0
容器创建完成
car ... destroy ...
Dog...@PreDestroy...

3.5. BeanPostProcessor原理

在这个后置处理器的两个方法上面打上断点

以debug的方式来运行这个测试方法

前置处理器调用的方法：

调用getBeanPostProcessors()方法找到容器里面的所有的BeanPostProcessor，挨个遍历，调用BeanPostProcessor的postProcessBeforeInitialization方法，一旦调用postProcessBeforeInitialization方法的返回值为null的时候，就直接跳出遍历 ，后面的BeanPostProcessor 的postProcessBeforeInitialization也就不会执行了：

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)  throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

后置处理器调用的方法：

调用getBeanPostProcessors()方法找到容器里面的所有的BeanPostProcessor，挨个遍历，调用BeanPostProcessor的postProcessAfterInitialization方法，一旦调用postProcessAfterInitialization方法的返回值为null的时候，就直接跳出遍历 ，后面的BeanPostProcessor 的postProcessAfterInitialization也就不会执行了：

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

//前置处理器执行 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); //初始化方法执行 invokeInitMethods(beanName, wrappedBean, mbd); //后置处理器执行 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

在看源码的时候，可以发现： 在执行exposedObject = initializeBean(beanName, exposedObject, mbd);方法之前先调用了populateBean(beanName, mbd, instanceWrapper);这个方法：

populateBean(beanName, mbd, instanceWrapper);–给bean进行属性赋值 exposedObject = initializeBean(beanName, exposedObject, mbd);–初始化方法，在这个初始化方法内部包括了前置处理器、初始化方法、后置处理器的调用

3.6. BeanPostProcessor在Spring底层的使用

Spring底层对 BeanPostProcessor 的使用：

  • bean赋值，注入其他组件，@Autowired,生命周期注解等功能,@Async等等都是使用BeanPostProcessor来完成的

BeanPostProcessor 这个接口有很多的实现类

如果我们想要获取IOC容器，可以这样做：

package com.hutu.bean;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class Dog implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    public Dog() {
        System.out.println("Dog...Contructor...");
    }

    //在对象创建并赋值之后调用
    @PostConstruct
    public void init() {
        System.out.println("Dog...@PostConstruct...");
    }

    //在对象创建并赋值之后调用
    @PreDestroy
    public void destroy() {
        System.out.println("Dog...@PreDestroy...");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

可以debug来调试

还可以debug运行这个测试方法

@Test
public void test01() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
    context.close();
}

实际上BeanPostProcessor接口还有很多的实现类，比如说BeanValidationPostProcessor，这个是用来做数据校验的：

像InitDestroyAnnotationBeanPostProcessor这个实现类就是实现了@PostConstruct和@PreDestroy这两个注解的功能：

在这个地方打个断点

小糊涂神0610
关注
spring5注解开发学习笔记
java
08-07 748
spring注解开发
通俗易懂的Spring注解驱动开发教程（含配套资料）
06-14
《Spring注解驱动开发》是一套帮助我们深入了解Spring原理机制的教程。现今SpringBoot.SpringCloud技术非常火热，作为Spring之上的框架，他们大量使用到了Spring的一些底层注解.原理，比如@Conditional.@Import.@...
Spring注解驱动
我爱写代码 我爱写代码 我爱写代码
01-10 1567
自定义组件想要使用Spring底层的一些组件(ApplicationContext, BeanFactory, xxx)自定义组件实现xxxAware，在创建对象的时候，会调用接口规定的方法注入相关的Spring底层组件，xxxAware全都实现自Aware接口。xxxAware的功能，使用对应xxxProcessor来处理，如 ApplicationContextAware==>ApplicationContextAwareProcessor。案例创建自定义组件，实现xxxAware接口。
尚硅谷Java Spring注解驱动开发视频教程
IT资源分享
05-09 2912
=====00-FF-64-DD-1D-B3=====|=====9999=====|=====Decrypt=====
Spring Boot：注解驱动开发综合指南
陈书予
03-23 7555
Spring Boot注解是一种特殊的注释，用于指示Spring Boot框架应该如何配置应用程序。Spring Boot注解可以用于许多不同的方面，包括配置文件、控制器、服务、数据访问、安全性和测试。
注解驱动事务：Spring中基于注解的事务属性配置详解
学而时习之，不亦说乎？温故而知新，可以为师矣！
01-08 9385
Spring的基于注解的事务配置为开发者提供了更为便捷和直观的方式来定义事务属性。本文将深入讨论如何使用注解来配置Spring事务的隔离级别、传播行为等关键属性。我们将详细介绍@Transactional注解的各种参数，并提供实际案例演示如何应用这些注解来管理事务。
Spring注解驱动开发——AOP常用注解
紫罗兰与海棠的博客
01-10 1926
一、用于开启注解AOP支持的 @EnableAspectJAutoProxy (一) 作用 表示开启spring对注解aop的支持。它有两个属性，分别是指定采用的代理方式和 是否暴露代理对象，通过AopContext可以进行访问。 (三) 属性 proxyTargetClass： 指定是否采用cglib进行代理。默认值是false，表示使用jdk的代理。 exposeProxy： 指定是否暴露代理对象，通过AopContext可以进行访问。 (四) 细节 (1) proxyTargetClass 当使用J
spring自定义注解及使用
qq_43985303的博客
04-29 1869
在spring项目中使用注解，简化了代码量，减轻对业务代码的侵入性；对框架统一处理鉴权、日志等起到极大的作用，可以结合着拦截器、aop在请求调用前后添加额外处理。spring有内置的@Controller、@Service等注解，出于业务考虑，我们可以自定义想要的注解。自定义注解类似于定义接口，但是需要指明注解的作用范围、生命周期等属性。
Spring高手之路2——深入理解注解驱动配置与XML配置的融合与区别
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
05-26 8678
本文旨在深入探讨Spring框架的注解驱动配置与XML配置，揭示两者之间的相似性与差异。我们首先介绍了配置类的编写与Bean的注册，然后比较了注解驱动的IOC依赖注入与XML依赖注入。文章进一步解析了Spring的组件注册与组件扫描，包括使用@ComponentScan和XML启用component-scan的情况，以及不使用@ComponentScan的场景。接下来，我们深入探讨了其他相关的组件注册注解。最后，我们展示了如何将注解驱动的配置与XML驱动的配置结合使用，并通过思考总结部分提出了一些重要的问题
Spring注解驱动开发——IOC的常用注解
紫罗兰与海棠的博客
01-07 1594
一、用于注解驱动的注解 @Configuration (一) 作用 它是在spring3.0版本之后加入的。此注解是spring支持注解驱动开发的一个标志。表明当前类是spring的一个配置类，作用是替代spring的applicationContext.xml。但其本质就是@Component注解，被此注解修饰的类，也会被存入spring的ioc容器。 (二) 属性 value:用于存入spring的Ioc容器中Bean的id。 (三) 本质 就是@Component注解，被此注解修饰的类，也会被存入s
【Spring注解驱动开发】聊聊Spring注解驱动开发那些事儿！
冰河的专栏
06-04 3297
写在前面 今天，面了一个工作5年的小伙伴，面试结果不理想啊！也不是我说，工作5年了，问多线程的知识：就只知道继承Thread类和实现Runnable接口！问Java集合，竟然说HashMap是线程安全的！问MySQL的MyISAM存储引擎和InnoDB存储引擎的区别，竟然说成是MyISAM存储引擎支持事务，InnoDB不支持！问Spring就只知道IOC和AOP的概念，深一点就不知道了！再问项目。。。哎，算了，不说了！ 大家对于设计模式、高并发和Java8新特性，不了解的，就去看我的专栏吧！今天，我们来
Spring注解驱动之AOP功能测试
08-19
Spring注解驱动之AOP功能测试 Spring框架提供了一个强大的功能，即Aspect-Oriented Programming（面向方面编程），也就是AOP。AOP是一种编程范式，它提供了一种将横切关注点模块化的方法，例如日志记录、安全检查...
Spring注解驱动笔记.md
01-06
Spring注解描述，底层笔记
Spring注解驱动开发.pdf
08-22
### Spring注解驱动开发知识点详解 #### 一、Spring注解驱动概述 Spring框架通过引入注解支持，极大地简化了Java EE应用的开发工作。它不仅提供了基础的依赖注入功能，还增强了对组件扫描的支持，使得开发者能够...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 330
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 395
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java分布式锁
juanmiao的专栏
10-12 719
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 692
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 573
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值