手写spring

最新推荐文章于 2025-08-12 21:36:33 发布
最新推荐文章于 2025-08-12 21:36:33 发布
阅读量788 收藏 6
点赞数 3
CC 4.0 BY-SA版权
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52076808/article/details/142778578

一、Spring

1.IOC概念（控制反转）

IOC，或控制反转，是一种设计原则，它将对象创建和依赖的管理从应用程序代码中移除，由容器来负责。这使得应用程序组件更加松耦合，便于维护和测试。

  • IOC方式：对象的创建和管理由Spring容器来负责，依赖通过配置文件或注解来注入。
  • 传统开发方式：对象在代码中直接创建和管理，依赖关系是硬编码的

2.IOC容器运行流程

2.1. 容器启动

Spring容器的启动通常从加载配置开始。配置可以是基于XML文件的配置、Java注解配置类，或者是基于Java代码的配置类。Spring会解析这些配置来构建Bean定义，并初始化容器。

  • 基于XML配置的启动：
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  • 基于注解配置的启动：
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

2.2. 读取配置和扫描

容器启动后，Spring会根据配置读取Bean定义。它可以通过解析XML文件中的Bean定义、读取Java配置类中的@Bean方法、扫描@Component注解的类等方式来获取Bean的定义信息。

  • XML配置文件：Spring会读取XML文件中的<bean>标签，以获取Bean的定义。
  • 注解扫描：Spring通过类路径扫描，找到使用@Component、@Service、@Repository等注解标识的类，并将它们注册为Bean。
  • Java配置类：Spring通过读取@Configuration类中的@Bean方法，来定义和注册Bean。

2.3. Bean的定义注册

一旦Spring读取到Bean定义，便会将这些定义存储在一个内部的数据结构中（如BeanDefinition对象），这些定义包括Bean的类名、作用域、构造参数、依赖关系等。

2.4. Bean的实例化

容器会在需要使用Bean时，根据Bean的定义实例化Bean。这一步并不涉及属性的注入，仅仅是创建Bean实例。Spring通过调用Bean的构造器（无参或有参）来创建Bean的对象。

2.5. 依赖注入（Dependency Injection）

在Bean实例化后，Spring会处理依赖注入。Spring会根据Bean的依赖配置（构造器注入或Setter注入），将其他Bean注入到当前Bean中。

  • 构造器注入：Spring通过调用Bean的有参构造器，传入所需的依赖。
  • Setter注入：Spring通过调用Bean的Setter方法，注入所需的依赖。

2.6. Bean的初始化

在完成依赖注入后，Spring会对Bean进行初始化操作。这包括调用Bean的@PostConstruct注解方法（如果有），以及执行配置的初始化方法（通过init-method属性配置）。如果Bean实现了InitializingBean接口，则会调用其afterPropertiesSet()方法。

2.7. Bean的使用

经过初始化的Bean现在已准备好被容器使用。应用程序可以通过容器获取Bean实例，并调用其方法来完成具体的业务逻辑。

  • 获取Bean：通过getBean()方法从容器中获取Bean实例。
MyClass myClass = context.getBean(MyClass.class);

2.8. Bean的销毁

当容器关闭或Bean不再需要时，Spring会销毁Bean。销毁包括调用@PreDestroy注解方法（如果有），执行配置的销毁方法（通过destroy-method属性配置），以及如果Bean实现了DisposableBean接口，调用其destroy()方法。

3.AOP（待补充）

4.简单手写一个Spring（进行bean的创建和依赖注入）

  • Bean 注解（Bean创建）
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
}
  • DI注解（依赖注入）
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Di {
}
  • 创建ApplicationContext接口定义getBean方法
public interface ApplicationContext {
    Object getBean(Class clazz);
}
  • 创建AnnotationApplicationContext对象实现ApplicationContext接口进行bean的创建和依赖注入
public class AnnotationApplicationContext implements ApplicationContext{
    //创建map集合用于存放bean对象
    Map<Class,Object> beanFactory=new HashMap<>();
    private String rootPath;
    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }
    //设置包扫描规则
    //当前包及其子包，那个类有@Bean注解，把这个类通过反射实例化出来
    public  AnnotationApplicationContext(String basePackage){
//    public static void path1(String basePackage){
        try {

            //com.java
            //把.换成\
            String pagePath = basePackage.replaceAll("\\.", "\\\\");
            //获取包的绝对路径
            Enumeration<URL> resources = ApplicationContext.class.getClassLoader().getResources(pagePath);
            while (resources.hasMoreElements()){
                URL url = resources.nextElement();
                //对url进行转码
                String filePath = URLDecoder.decode(url.getFile(), "utf-8");
                //获取包前面路径部分，字符串截取
                rootPath= filePath.substring(0, filePath.length() - pagePath.length());
                loadBean(new File(filePath));
                //包扫描

//                System.out.println(filePath);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        loadDi();
    }

    //包扫描
    private void loadBean(File file) {
        //判断是不是文件夹
        if (file.isDirectory()) {
            //获取文件夹内容
            File[] childrenFiles = file.listFiles();
            //判断文件夹为空直接返回
            if(childrenFiles==null&&childrenFiles.length==0){
                return;
            }
            //遍历问价夹所有内容
            for (File childrenFile : childrenFiles) {
                if (childrenFile.isDirectory()){
                    loadBean(childrenFile);
                }else {
                    //通过文件路径转变成全类名,第一步把绝对路径部分去掉
                    String pathWithClass = childrenFile.getAbsolutePath().substring(rootPath.length() - 1);
                    //选中其中的class文件
                    if(pathWithClass.contains(".class")){
                        //去掉.class并且将\替换为.
                        String fullPath = pathWithClass.replaceAll( "\\\\",".").replaceAll(".class", "");
                        try {
                            Class<?> aClass = Class.forName(fullPath);
                            //获取非接口类
                            if(!aClass.isInterface()){
                                //获取含有bean注解的类
                                Bean annotation = aClass.getAnnotation(Bean.class);
                                if(annotation!=null){
                                    Object instance = aClass.newInstance();
                                    //判断instance有没有接口
                                    if(aClass.getInterfaces().length>0){
                                        //如果有的话创建实例对象
                                        System.out.println("正在加载【"+ aClass.getInterfaces()[0] +"】,实例对象是：" + instance.getClass().getName());
                                        beanFactory.put(aClass.getInterfaces()[0],instance);
                                    }else {
                                        //如果没有就将class对象当key
                                        beanFactory.put(aClass,instance);
                                    }
                                }
                            }
                        } catch (Exception e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }

        }

    }

    //属性注入
    private void loadDi(){
        //实例化对象在beanFactory的map集合里面
        //1.遍历beanFactory中的集合
        Set<Map.Entry<Class, Object>> entries = beanFactory.entrySet();
        for (Map.Entry<Class, Object> entry : entries) {
            //2.获取map集合的每个对象
            Object value = entry.getValue();
            //3.获取属性
            Field[] declaredFields = value.getClass().getDeclaredFields();
            //4.遍历属性
            for (Field declaredField : declaredFields) {
                //判断属性上是否有@Di注解
                Di annotation = declaredField.getAnnotation(Di.class);
                if(annotation!=null){
                    //属性赋值
                    try {
                        declaredField.setAccessible(true);
                        declaredField.set(value,beanFactory.get(declaredField.getType()));
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }
}

5. 手写一个复杂的Spring

4.1.流程

4.2.案例：

  • Autowired注解实现自动注入
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Autowired {
}
  • Component注解标准需要被Spring管理的类
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
    String value() default "";//自定义bean的名称
}
  • ComponentScan 注解标注需要扫描的包名
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
    String value() default "";
}
  • Scope 注解标注是否为单例bean
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Scope {
    String value() default "";
}
  • BeanDefinition 存放扫描到的bean
@Data
public class BeanDefinition {
    private Class type;
    private String scope;
}
  • 执行Aware方法时调用的方法
public interface BeanNameAware {
    public void setName(String name);
}
  • Aspect注解标注需要解析代理的bean
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Aspect {
}
  • BeanPostProcessor定义初始化前后执行的方法
 public Object postProcessBeforeInitialization(String beanName,Object bean);
 public Object postProcessAfterInitialization(String beanName,Object bean);
  • BeanPostProcessorImpl实现BeanPostProcessor接口
@Component
public class BeanPostProcessorImpl implements BeanPostProcessor {
    //初始化前调用方法
    @Override
    public Object postProcessBeforeInitialization(String beanName,Object bean) {
        if(beanName.equals("userService")){
            System.out.println(beanName+" 初始化的前置处理！");
        }
        return bean;
    }
    //初始化后调用方法
    @Override
    public Object postProcessAfterInitialization(String beanName,Object bean) {
//        System.out.println(bean.getClass().getName()+"的后置通知");
//        System.out.println(bean.getClass().isAnnotationPresent(Aspect.class));
        //aop
        if(bean.getClass().isAnnotationPresent(Aspect.class)){
            Object instance = Proxy.newProxyInstance(BeanPostProcessorImpl.class.getClassLoader(),
                    bean.getClass().getInterfaces(),
                    new InvocationHandler() {
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            System.out.println("切面逻辑");
                            return method.invoke(bean, args);
                        }
                    });
            return instance;
        }

        return bean;
    }
}
  • MyApplicationContext容器主要的功能实现
public class MyApplicationContext {
    private Class configClass;
    private ConcurrentHashMap<String,BeanDefinition> beanDefinitionMap=new ConcurrentHashMap<>();
    private ConcurrentHashMap<String,Object> beanFactory=new ConcurrentHashMap<>();
    //存放初始化前后方法对象的集合
    private List<BeanPostProcessor> beanPostProcessors=new ArrayList<>();
    private String rootPath;

    public MyApplicationContext(Class configClass) {
        this.configClass = configClass;

        //扫描
        if(configClass.isAnnotationPresent(ComponentScan.class)){
            ComponentScan componentScan= (ComponentScan) configClass.getAnnotation(ComponentScan.class);
            String path = componentScan.value();//扫描路径 com.java.service
            //com/java/service
            path=path.replaceAll("\\.","\\\\");

            //通过类加载器获取文件路径
            URL url = MyApplicationContext.class.getClassLoader().getResource(path);
            //对url进行转码
            String filePath = null;
            try {
                filePath = URLDecoder.decode(url.getFile(), "utf-8");
                //获取包前面路径部分，字符串截取
                rootPath= filePath.substring(0, filePath.length() - path.length());
                //获取beanDefinition集合
                loadBean(new File(filePath));

                //通过beanDefinition集合对其中的bean进行创建
                for (String beanName : beanDefinitionMap.keySet()) {
                    BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
                    //如果是单例模式就直接创建一个bean
                    if(beanDefinition.getScope().equals("singleton")){
                        Object bean = createBean(beanName, beanDefinition);
                        beanFactory.put(beanName,bean);
                    }
                }

            } catch (Exception e) {
                throw new RuntimeException(e);
            }


        }


    }
    //bean的注册
    private Object createBean(String beanName,BeanDefinition beanDefinition) {
        Class aClass = beanDefinition.getType();
        Object instance = null;
        try {
            instance = aClass.getConstructor().newInstance();
            //依赖注入
            for (Field declaredField : aClass.getDeclaredFields()) {
                if(declaredField.isAnnotationPresent(Autowired.class)){
                    declaredField.setAccessible(true);
                    declaredField.set(instance,getBean(declaredField.getName()));
                }
            }
            //Aware
            //通过aware回调对其bean的name进行赋值
            if(instance instanceof BeanNameAware){
                ((BeanNameAware)instance).setName(beanName);
            }

            //初始化前执行方法
            for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
                instance = beanPostProcessor.postProcessBeforeInitialization(beanName, instance);
            }

            //初始化
            if(instance instanceof InitializingBean){
                ((InitializingBean)instance).afterPropertiesSet();
            }

            //初始化后执行方法
            for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
                instance=beanPostProcessor.postProcessAfterInitialization(beanName,instance);
            }


        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return instance;
    }

    private void loadBean(File file) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //判断文件是否为文件夹
        if (file.isDirectory()) {
            //获取所有的文件
            File[] files = file.listFiles();
            if(files.length==0||files==null){
                return;
            }
            //遍历所有的文件
            for (File childrenFile : files) {
                if (childrenFile.isDirectory()) {
                    loadBean(childrenFile);
                }
                //通过文件路径转变成全类名,第一步把绝对路径部分去掉
                String pathWithClass = childrenFile.getAbsolutePath().substring(rootPath.length() - 1);
//                System.out.println(pathWithClass);
                //获取.class的文件
                if(pathWithClass.contains(".class")){
                    pathWithClass=pathWithClass.replace("\\",".").replace(".class","");
//                    System.out.println(pathWithClass);
                    //获取需要扫描的字节码文件
                    Class<?> aClass = Class.forName(pathWithClass);
                    //扫描带Component的注解，并将其存入一个beanDefinition
                    if(aClass.isAnnotationPresent(Component.class)){
                        BeanDefinition beanDefinition=new BeanDefinition();

                        //判断是否实现beanPostProcessor接口
                        if(BeanPostProcessor.class.isAssignableFrom(aClass)){
                            BeanPostProcessor beanPostProcessor = (BeanPostProcessor) aClass.newInstance();
                            beanPostProcessors.add(beanPostProcessor);
                        }

//                       //通过component注解获取bean的名字
                        Component component = aClass.getAnnotation(Component.class);

                        String beanName = component.value();

                        if(beanName.equals("")){
                            beanName= Introspector.decapitalize(aClass.getSimpleName());
                        }
                        //判断scope注解中的内容（判断单例还是多例）
                        if(aClass.isAnnotationPresent(Scope.class)){
                            //获取scope注解
                            Scope scopeAnno=aClass.getAnnotation(Scope.class);
                            //获取注解中value值
                            String scope = scopeAnno.value();
                            beanDefinition.setScope(scope);
                        }else {
                            beanDefinition.setScope("singleton");
                        }
                        beanDefinition.setType(aClass);
                        beanDefinitionMap.put(beanName,beanDefinition);
                    }
                }
            }
        }
    }
    public Object getBean(String beanName){
        BeanDefinition beanDefinition=beanDefinitionMap.get(beanName);
        if(beanDefinition==null){
            throw new NullPointerException();
        }else {
            String scope=beanDefinition.getScope();
            //为单例bean时直接取bean工厂拿
            if(scope.equals("singleton")){
                Object bean = beanFactory.get(beanName);
                if(bean==null){
                    //如果bean为空创建bean
                    Object bean1 = createBean(beanName, beanDefinition);
                    beanFactory.put(beanName,bean1);
                }
                return bean;
            }else {
                //如果是多例bean则不需要加入bean工厂集合
                return createBean(beanName, beanDefinition);
            }
        }
    }

二、SpringMVC

1.核心概念

  1. DispatcherServlet（调度器）

    ：

    • DispatcherServlet 是 Spring MVC 的核心组件，相当于一个前端控制器（Front Controller）。它接收所有的 HTTP 请求，并将它们分发给合适的处理器（Controller）。
    • 它负责初始化 Spring MVC 环境，包括加载配置文件、创建上下文等。

  2. Controller（控制器）

    ：

    • 控制器是处理 HTTP 请求的核心组件。它接收用户的输入、处理业务逻辑，并返回相应的视图或数据。
    • 控制器通过注解 @Controller 标记，并通过方法级别的注解（如 @RequestMapping）来定义如何处理不同的请求路径和请求方法。

  3. Model（模型）

    ：

    • 模型包含了应用程序的业务数据和状态。控制器将数据封装在模型中，供视图展示。
    • 在 Spring MVC 中，模型通常是 Model 或 ModelMap 类型的对象，用于传递数据到视图层。

  4. View（视图）

    ：

    • 视图负责将模型中的数据展示给用户。Spring MVC 支持多种视图技术，如 JSP、Thymeleaf、FreeMarker 等。
    • 视图的选择通常由视图解析器（View Resolver）决定。视图解析器根据逻辑视图名（由控制器返回）找到实际的视图实现。

  5. View Resolver（视图解析器）

    ：

    • 视图解析器是 Spring MVC 中用于解析视图名并将其转换为实际视图对象的组件。通过配置视图解析器，可以指定视图技术和视图文件的路径。

  6. HandlerMapping（处理器映射）

    ：

    • 处理器映射是 Spring MVC 中用于将请求 URL 映射到具体处理器（Controller）的组件。Spring 提供了多种处理器映射策略，如基于注解的映射、基于路径的映射等。

2.工作流程

  • 流程图

img

  • 具体流程

    1. Tomecat服务器接收用户请求后创建两个对象HttpServletRequest和HttpServletResqponse并将对象交给DispetcherServlet（调度器）。
    2. DispetcherServlet（调度器）获取req请求对象中的访问路径url交给HandlerMapping(处理器映射器).
    3. HandlerMapping会根据我们在Controller上的注解找到对应的Handler处理器并交给DispetcherServlet（调度器）.
    4. DispetcherServlet(调度器)会将处理器和req对象交给HandlerAdapter(处理器适配器),让处理器适配器去调用处理器中相应的处理方法并返回处理好的ModelAndView(视图模型和视图名称).(因为处理器方法会有多种对参数的要求,因此调度器只需要将req和处理器交给适配器即可,适配器可以通过req随意传入参数)
    5. DispetcherServlet(调度器）将视图名传给ViewResolver(视图解析器)解析出对应的视图文件返回给调度器.
      作流程

  • 流程图

[外链图片转存中…(img-hAiOCSPY-1728438204087)]

  • 具体流程
    1. Tomecat服务器接收用户请求后创建两个对象HttpServletRequest和HttpServletResqponse并将对象交给DispetcherServlet（调度器）。
    2. DispetcherServlet（调度器）获取req请求对象中的访问路径url交给HandlerMapping(处理器映射器).
    3. HandlerMapping会根据我们在Controller上的注解找到对应的Handler处理器并交给DispetcherServlet（调度器）.
    4. DispetcherServlet(调度器)会将处理器和req对象交给HandlerAdapter(处理器适配器),让处理器适配器去调用处理器中相应的处理方法并返回处理好的ModelAndView(视图模型和视图名称).(因为处理器方法会有多种对参数的要求,因此调度器只需要将req和处理器交给适配器即可,适配器可以通过req随意传入参数)
    5. DispetcherServlet(调度器）将视图名传给ViewResolver(视图解析器)解析出对应的视图文件返回给调度器.
    6. DispetcherServlet(调度器)将model(视图模型)对对应的view(视图文件)进行渲染得到一个有内容的也页面通过resp对象返回给客户端的浏览器.
辞南℡
关注
SpringBoot手写操作日志自动记录功能
2403_87729201的博客
08-10 355
本文介绍了基于SpringAOP的操作日志自动记录方案。通过自定义@LogAnnotation注解和切面编程，实现业务方法零侵入的日志记录功能。方案包含数据库表设计（sys_log）、自定义注解定义、核心切面实现（LogAspect）及配套工具类（HttpContextUtil、IPUtil）。使用时只需在Controller方法上添加注解，切面会自动记录操作人、方法信息、参数、耗时等数据并存入数据库。该方案解决了手动记录日志的繁琐问题，提供完整的操作审计能力，执行流程涵盖请求处理全过程。
Spring IoC实现原理详解
Rockandrollman的博客
08-12 898
Spring IoC实现原理详解
Java 反射技术：企业级开发框架Spring的 “隐形引擎“
qq_20294455的博客
08-10 634
摘要： Java反射技术是突破编译期限制的底层机制，通过Class对象实现运行时类操作。其核心应用包括框架依赖注入（如Spring）、动态代理和对象映射（如MyBatis），但伴随性能损耗和安全风险。优化策略涵盖反射对象缓存、字节码生成（CGLIB）和批量操作，同时需配合SecurityManager进行权限管控。开发者应遵循最小权限原则，结合严格测试确保代码安全。反射技术平衡了灵活性与封装性，是Java高级开发的核心技能，在框架设计与动态编程中持续发挥关键作用。
Spring学习笔记：Spring AOP入门以及基于Spring AOP配置的深入学习与使用
FeiChangWuRao的博客
08-09 919
AOP面向切面编程，通过提供一种程序结构的思考方式来补充面向对象的编程。（面向对象编程 OOP）首先代码是面向业务的，业务也有轻重缓急，也就是有的业务是核心业务，有的业务是非核心业务。比如说消息系统，接受和发送消息是核心业务，对于日志，异常报错处理，以及具体的校验就是非核心业务。这些业务是在一起的，这样让系统运作起来，只有核心业务可能系统最起码的安全性和稳定性都提供不了。但是没有核心业务，这些非核心业务也没有什么必要。
spring文件下载的方式
budongfengqing的博客
08-12 178
【代码】spring文件下载的方式。
Spring 框架中提供Aware接口，实现感知容器对象
小凯的博客
08-09 823
Spring 框架中提供Aware接口，实现感知容器对象
SpringAI实现多用户记忆隔离
又要搬砖了
08-08 251
本文介绍了基于SpringAI实现对话记忆隔离的技术方案。核心需求包括用户对话隔离、上下文连贯和高并发管理。采用SpringAI的ChatMemory组件，通过内存存储方式实现用户对话记忆隔离，使用CONVERSATION_ID标识不同用户。技术实现分三步：导入ChatMemory依赖包、配置ChatClient加入ChatMemory支持、在Prompt中设置用户ID。效果展示表明系统能正确区分不同用户的对话上下文。该方案简化了对话记忆管理，为多用户场景下的对话系统提供了实用解决方案。
Spring集成MyBatis与事务管理：从入门到精通的完整指南
真实的菜的博客
08-12 151
通过本文的详细介绍，我们深入了解了Spring与MyBatis集成的各种方式，以及事务管理的核心概念和最佳实践。希望这篇文章能够帮助大家更好地理解和应用Spring与MyBatis的集成，以及事务管理的相关知识。在实际项目中，要根据具体业务场景选择合适的配置和策略，持续优化系统性能。有任何问题欢迎在评论区讨论交流！🚀。
springboot整合sharding-jdbc 5.5.2 做单库分表
weixin_45410882的博客
08-12 265
springboot整合sharding-jdbc 5.5.2 做单库分表
用 Spring 思维快速上手 DDD——以 Kratos 为例的分层解读
最新发布
weixin_48471044的博客
08-12 560
本文从Spring开发者视角解析DDD领域驱动设计，通过与Kratos框架对比，帮助理解DDD的核心思想。文章指出，传统Spring MVC分层容易导致业务逻辑与技术实现耦合，而DDD通过严格分层（接口层、应用层、领域层、基础设施层）实现解耦。重点对比了两者在Repository实现、业务规则位置和应用服务职责上的差异，并通过锁单案例演示了DDD如何将业务逻辑封装在领域对象中。最后说明Kratos通过目录结构和依赖注入强制执行DDD分层原则，确保领域层不依赖具体技术实现。
spring.cache.type=SIMPLE详解
魏波
08-08 893
摘要：spring.cache.type=SIMPLE是Spring框架中配置简单内存缓存的参数，使用ConcurrentHashMap实现进程内缓存。它适用于轻量级场景，无需额外依赖，但功能有限，不支持分布式、自动过期等特性。相比于Redis等专业缓存，SIMPLE类型适合小型应用和开发测试环境，具有简单易用的优势，但在生产环境中面临内存限制和功能单一的局限性。开发者需根据实际需求在简单缓存与专业缓存方案间权衡选择。
云服务器--阿里云OSS(2)【Springboot使用阿里云OSS】
你我约定有三的博客
08-09 499
本文介绍了使用SpringBoot整合阿里云OSS实现异步文件上传的方案。项目结构包含控制器、服务层和主启动类，通过Maven引入阿里云OSS SDK。核心实现包括：1) OSS服务类处理文件直传；2) 异步服务类@Async注解实现非阻塞上传；3) 控制器接收文件并触发异步任务。关键点在于使用MultipartFile输入流直接上传避免本地存储，通过UUID生成唯一文件名，并设置OSS Bucket为公共读+私有写权限。方案优势是提升用户体验（快速响应）和系统性能（后台异步处理），适合作为图片/文件服务器
Spring之【详解AOP】
weixin_43945238的博客
08-10 1377
Spring AOP详解
SpringBoot集成支付宝二维码支付接口详解
aakhvb的博客
08-11 304
在电商和移动支付时代，集成支付宝支付功能已成为许多Java应用的必备功能。本文将详细介绍如何在SpringBoot项目中集成支付宝的二维码支付接口，包括从申请支付宝开发者账号到最终实现支付功能的完整流程。
SpringCloud基础
阿杰同学的博客
08-08 390
微服务架构将单体系统拆分为独立运行的多个小型服务。相比单体架构，微服务具有技术异构、隔离性好、扩展性强等优势，但也面临网络调用频繁、运维复杂等挑战。Spring Cloud作为微服务开发工具集，整合了服务发现(Eureka)、负载均衡(Ribbon)、熔断器(Hystrix)、配置中心(Config)等核心组件，并提供安全认证、链路追踪等配套功能，有效支持微服务系统的构建与治理。该框架通过标准化组件简化了分布式系统的开发复杂度，为微服务架构提供了完整的解决方案。
Spring-rabbit使用实战七
初心未改
08-09 572
Spring AMQP中@RabbitListener监听单队列与多队列的核心区别在于：单队列提供独立的线程处理、错误隔离和优先级设置，适合关键业务；多队列则共享线程和错误处理机制，适合逻辑相同的业务场景。最佳实践建议：高优先级业务采用单队列监听，相关业务使用多队列统一处理，并可通过混合策略优化系统性能。合理选择模式可提升吞吐量30%-50%，同时需配合监控和动态调优实现最佳效果。
Spring Bean生命周期InstantiationAwareBeanPostProcessor接口的执行位置
weixin_43578751的博客
08-10 352
结合你提供的代码片段，// 1. 实例化 Bean（createBeanInstance）// 【注意】postProcessBeforeInstantiation 在这一步之前执行（doCreateBean 外部）// 2. 处理合并的 Bean 定义（与 InstantiationAwareBeanPostProcessor 无关）// 3. 提前暴露单例（解决循环依赖）// 4. 初始化 Bean 实例try {
SpringCloud 核心内容
wa_ka_ka的博客
08-12 381
Spring Cloud 作为微服务架构的核心框架，集成了服务治理、配置管理、负载均衡等分布式系统解决方案。
Spring WebFlux开发指导
wys的专栏
08-10 325
Spring WebFlux是一个响应式的web服务器端应用开发框架。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值