Spring原理学习笔记

编程自学指南:java程序设计开发,设计思想Spring开源框架-SpringBoot原理与实战学习笔记,Spring Boot 是 Spring 项目下的一个框架,旨在简化 Spring 应用的初始 java程序设计开发,设计思想开源框架-SpringBoot原理与实战,Spring Boot 是 Spring 项目下的一个框架,旨在简化 Spring 应用的初始,Spring Boot 通过自动配置、起步依赖和嵌入式服务器等特性,大大简化了 Spring 应用的开发过程。开发者可以快速搭建和开发独立的、生产级别的 Spring 应用。在实战中,需要掌握自动配置原理、起步依赖的使用、嵌入式服务器的配置,以及如何使用 Spring Data JPA 和 Spring MVC 构建 RESTfulAPI。 阅读详情

Spring 5原理学习笔记

2020.6.28

1、Spring版本与Java版本的对应关系:

在这里插入图片描述

2、IOC:

IOC的底层原理核心思想:

前置知识:反射+xml解析

ioc概念:控制反转。控制是指new对象的控制权,反转是指控制权交给Spring框架。

思想:对象工厂,尽可能实现解耦(加载xml解析、工厂模式中用反射创建对象)

模拟ioc加载:

配置文件(bean.properties):

BEAN=com.znk.entity.Student

Java类:

Student.java

package com.znk.entity;

public class Student {
    public void print(){
        System.out.println("学生类");
    }
}

ObjectFactory.java

package com.znk;

import java.io.IOException;
import java.util.Properties;

public class ObjectFactory {

    private static Properties properties = null;
    private static String BEAN = null;

    static {
        properties = new Properties();
        try {
            properties.load(ObjectFactory.class.getClassLoader().getResourceAsStream("bean.properties"));
            BEAN = properties.getProperty("BEAN");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public Object getBean() throws Exception {
        return Class.forName(BEAN).newInstance();
    }

}

Test.java

package com.znk.test;

import com.znk.ObjectFactory;
import com.znk.entity.Student;

public class Test {
    public static void main(String []args) throws Exception{
        Student student = (Student) new ObjectFactory().getBean();
        student.print();
    }
}

spring格式xml解析(剥洋葱,一层一层剥开):

package com.znk.entity;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.util.Iterator;

public class XmlTest {
    public static void main(String[] args) {
        SAXReader saxReader = new SAXReader();
        try {
            //将xml转换成一个document对象
            Document document = saxReader.read("src/main/resources/spring.xml");
            //根节点是beans
            Element root = document.getRootElement();
            //迭代根节点
            Iterator<Element> iterator = root.elementIterator();
            while (iterator.hasNext()) {
                Element bean = iterator.next();
                //取bean标签里的内容
                if (bean.getName().equals("bean")) {
                    
                    System.out.println(bean.attributeValue("id"));
                    System.out.println(bean.attributeValue("class"));
                }
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }
}

spring提供的两种接口实现IOC:(BeanFactory、ApplicationContext)

1、BeanFactory:spring里面内部使用接口,一般不提供给我们开发人员进行使用。有个特点:加载配置文件时不会创建里边的对象,而是在你获取或者是使用时才创建对象。

<bean id="Student" class="com.znk.entity.Student"></bean>
BeanFactory beanFactory=new ClassPathXmlApplicationContext("spring.xml");//这时候并没有创建Student对象
Student student = beanFactory.getBean("Student", Student.class);//此时才创建了Student对象

2、ApplicationContext:是BeanFactory的一个子接口,提供了更强大的功能,供开发人员进行使用。(核心)

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");//此时已创建Student对象

区别:BeanFactory只有在调用时才会创建对象,而ApplicationContext在加载配置文件时已经创建了对应的对象。

误区:既然这样,用BeanFactory好一点,节约资源,什么时候用什么时候创建。

正解:一般情况下用ApplicationContext会点,因为大多数情况下是服务于web项目,在服务器项目启动时一次性加载,这样就不会在服务时候去创建,而是提前准备好对象。

Ioc 的实现:

1、ioc读取xml文件,获取相关信息类:信息、属性信息(xml解析)

2、根据第一步获取的信息动态创建对象(反射)

spring.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="user" class="com.znk.entity.User">
        <property name="id" value="1"/>
        <property name="name" value="张三"/>
        <property name="age" value="18"/>
    </bean>

    <bean id="user2" class="com.znk.entity.User">
        <property name="id" value="2"/>
        <property name="name" value="李四"/>
        <property name="age" value="19"/>
    </bean>

</beans>

User.java

package com.znk.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private Long id;
    private String name;
    private Integer age;

}

MyClassPathApplicationContext.java

package com.znk.ioc;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.MessageSourceResolvable;
import org.springframework.context.NoSuchMessageException;
import org.springframework.core.ResolvableType;
import org.springframework.core.env.Environment;
import org.springframework.core.io.Resource;

import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;

public class MyClassPathApplicationContext implements ApplicationContext {

    private String xmlPath = null;
    private SAXReader saxReader = null;
    private static Map<String, Object> iocContainer = null;

    static {
        iocContainer = new HashMap<>();
    }

    public MyClassPathApplicationContext(String xmlPath) {
        this.xmlPath = xmlPath;
        saxReader = new SAXReader();
        try {
            Document document = saxReader.read("src/main/resources/" + xmlPath);
            Element root = document.getRootElement();
            Iterator<Element> iteratorRoot = root.elementIterator();
            Object object = null;
            while (iteratorRoot.hasNext()) {
                Element bean = iteratorRoot.next();
                if (bean.getName().equals("bean")) {
                    Class aClass = Class.forName(bean.attributeValue("class"));
                   
                    Constructor constructor = aClass.getConstructor();
                    object = constructor.newInstance();
                    Iterator iterator = bean.elementIterator();
                    Object value = null;
                    while (iterator.hasNext()) {
                        Element property = (Element) iterator.next();
                        String name = property.attributeValue("name");
                        String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
                        //直接getField()是拿不到私有的成员变量,要getDeclaredField();
                        Field field = aClass.getDeclaredField(name);
                        Method method = aClass.getMethod(methodName, field.getType());
                        value = property.attributeValue("value");
                        switch (field.getType().getName()) {
                            case "java.lang.Long":
                                value = Long.parseLong(property.attributeValue("value"));
                                break;
                            case "java.lang.Integer":
                                value = Integer.parseInt(property.attributeValue("value"));
                                break;
                        }
                        method.invoke(object, value);
                    }
                }
                iocContainer.put(bean.attributeValue("id"), object);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
    
    //只实现这两个方法,其他方法省略

    @Override
    public Object getBean(String s) throws BeansException {
        return iocContainer.get(s);
    }

    @Override
    public <T> T getBean(Class<T> aClass) throws BeansException {
        Collection<Object> objects = iocContainer.values();
        for (Object object : objects) {
            if (object.getClass().equals(aClass)) {
                return (T) object;
            }
        }
        return null;
    }

测试类

package com.znk.test;

import com.znk.entity.User;
import com.znk.ioc.MyClassPathApplicationContext;
import org.springframework.context.ApplicationContext;

public class MyDemo {
    public static void main(String[] args) {
        ApplicationContext context = new MyClassPathApplicationContext("spring.xml");
        User user = (User) context.getBean("user");
        System.out.println(user);
        User user2 = (User) context.getBean("user2");
        System.out.println(user2);
        User user1 = context.getBean(User.class);
        System.out.println(user1);

    }
}

3、AOP:

AOP的底层原理核心思想:

底层是用动态代理方式来实现的。

两种情况:1、有接口(jdk的动态代理) 2、无接口(CGLIB动态代理)

AopProxy的实现类:

在这里插入图片描述

JdkDynamicAopProxy的核心方法:

  • getProxy():返回动态代理对象

    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

    作用是动态创建类和动态创建对象

    Interfaces:目标类的接口(因为要有目标类一样的功能)

    ClassLoader:类加载器把目标类加载到内存里

    this

  • invoke():代理对象的调用

步骤:

1、目标类添加@Component注解和切面类添加@Component注解和@Aspect,则会在程序启动时自动创建对应的对象加入到ioc容器中。

2、当加载配置文件时,扫描到<aop:aspectj-autoproxy/>标签,则会在ioc容器中自动创建动态代理对象。(程序是通过JdkDynamicProxy类来动态创建一个代理类进而创建一个类,并为其创建这个类的对象,即代理对象)

当没有改标签时:

在这里插入图片描述

当有标签时:

在这里插入图片描述

4、自动创建的动态代理对象会覆盖掉原来的目标类对象,拥有切面功能的同时兼具目标类功能。

需要注意的是:

代理对象调用的是invoke方法里执行的方法。

主要的业务方法还是由目标类的对象(委托对象)去调用方法执行。(写在invoke方法里)

aop的实现:

MyJdkDynamicProxy.java:

package com.znk.aop;

import org.springframework.aop.framework.AopProxy;

import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class MyJdkDynamicProxy implements AopProxy, InvocationHandler, Serializable {

    //目标对象(委托对象)
    private Object target = null;

    //接收目标对象,返回动态代理对象
    public Object bind(Object o) {
        target = o;
        return this.getProxy(MyJdkDynamicProxy.class.getClassLoader());
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(target, args);
        System.out.println(method.getName() + "的方法参数是:" + Arrays.asList(args));
        System.out.println(method.getName() + "的方法结果是:" + result);
        return result;
    }

    @Override
    public Object getProxy() {
        return null;
    }

    @Override
    public Object getProxy(ClassLoader classLoader) {
        return Proxy.newProxyInstance(classLoader, target.getClass().getInterfaces(), this);
    }
}

Cal接口:

package com.znk.aop;

public interface Cal {
    int add(int num1, int num2);
}

CalImpl.java:

package com.znk.aop.impl;

import com.znk.aop.Cal;
import org.springframework.stereotype.Component;

@Component
public class CalImpl implements Cal {

    private int result = 0;

    public int add(int num1, int num2) {
        result = num1 + num2;
        return result;
    }

}

测试类:

package com.znk.test;

import com.znk.aop.Cal;
import com.znk.aop.MyJdkDynamicProxy;
import com.znk.aop.impl.CalImpl;

public class MyTest {
    public static void main(String[] args) {
        Cal cal = new CalImpl();
        MyJdkDynamicProxy myJdkDynamicProxy = new MyJdkDynamicProxy();
        Cal proxy = (Cal) myJdkDynamicProxy.bind(cal);
        System.out.println(proxy.add(1, 1));
    }
}
编程自学指南:java程序设计开发,设计思想Spring开源框架-SpringBoot原理与实战之常用注解 @SpringBootApplication学习笔记 编程自学指南:java程序设计开发,设计思想Spring开源框架-SpringBoot原理与实战之常用注解 @SpringBootApplication学习笔记,Spring Boot 中的注解是开发过程中的重要工具,它们可以帮助开发者快速搭建应用、注册组件、进行依赖注入和处理 HTTP 请求。通过合理使用这些注解,可以提高开发效率,使代码更加简洁和易于维护。在实际开发中,要根据具体的需求选择合适的注解,并深入理解其原理和使用方法。 阅读详情

相关推荐

Java反射机制笔记(简单易懂)

Java反射机制笔记,简单易懂,轻松搞定Java反射机制

序号8、Spring原理讲解

Spring原理讲解 1、什么是Spring框架,Spring框架主要包含哪些模块 ​ Spring是一个开源框架,Spring是一个轻量级的Java 开发框架。它是为了解决企业应用开发的复杂性而创建的。 框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。 Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从

Alan先生的代码屋 691

Jaspersoft Studio安装与配置全攻略:从下载到首个报表生成

本文提供Jaspersoft Studio从下载、安装到创建首个报表的完整实战指南。详细介绍了如何获取安装包、配置工作空间,并通过可视化设计器创建报表模板、添加参数与字段,最终实现数据预览与PDF导出。帮助Java开发者快速掌握这一强大的开源报表工具,提升报表开发效率。

weixin_28826521的博客 708

Spring 原理

1、Spring 特点 1.1、轻量级 从大小和开销两方面而言 Spring 都是清轻量的。完整的 Spring 框架可以在一个大小只有 1M 多的 Jar 文件里发布,并且 Spring 所需的处理开销也是微不足道的。 此外,Spring 是非侵入式的:典型的 Spring 应用中的对象不依赖与 Spring 的特定的类。 1.2、控制反转 Spring 通过控制反转(IOC)技术促进了低耦合。 当应用了IOC,一个对象依赖的其他对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖。

qq_40896594的博客 4095

STM32F407与AD7766实战:如何用SPI+DMA实现高速ADC数据采集(附完整代码)

本文详细介绍了如何利用STM32F407的SPI接口与DMA控制器,高效稳定地驱动24位高精度ADC芯片AD7766,实现高速连续数据采集。通过对比传统中断方式的瓶颈,阐述了SPI+DMA方案如何大幅降低CPU负载,并提供了从硬件设计、CubeMX配置到核心驱动代码的完整实战指南,帮助工程师解决高速ADC数据采集中的性能难题。

weixin_29281941的博客 190

遥感图像语义分割的全流程实现(Python代码)

本节介绍了加载遥感 RGB 图像和对应的单通道掩膜(mask)。掩膜中每个像素值为类别索引(如0=背景,1=植被,2=建筑),通过 transform 统一缩放(256×256)和归一化(ImageNet 均值/标准差),确保输入模型的一致性。# 自定义数据集类(适配遥感RGB+单通道掩膜)mask = Image.open(mask_path).convert("L") # 单通道掩膜return image, mask.squeeze(0).long() # 返回RGB图像和类别索引。

qq_42679807的博客 1854

深入理解spring工作原理--总体概括

spring实际上是一个bean容器,它负责整个bean生命周期的管理,包括创建、初始化、销毁等。那么在spring中是如何创建一个对象的呢?按照个人理解,实际上是先初始化bean工厂,然后通过bean工厂生产制造bean,最后将bean缓存起来,用的时候根据beanName获取bean,容器销毁,bean也消失。以前我们需要使用一个对象,必须先new出来,但是在spring中,对象的创建、依赖关系、初始化、销毁等都由spring管理。

老布丁 444

某音私信接口二进制解析

本文探讨了某音私信接口的二进制请求处理过程,重点分析了请求体中的非文本字符和混合编码结构。文章详细描述了编码过程,包括使用Protocol Buffers的序列化方法将结构化数据转换为字节流,并通过Uint8Array包装成二进制数组。作者展示了如何提取和补全s.encode方法,并将其转化为Base64字符串以便在Python中解码执行

码王吴彦祖的博客 903

Spring全面讲解(无比详细)

希望大家共同进步,有兴趣的可以互相加个关注。

m0_54854484的博客 2998

大厂校招:星宸科技嵌入式面试及参考答案(5万字长文)

当一个新的硬件设备被插入系统时,内核会发送一个设备事件通知 udev,udev 会根据设备的属性和规则,为该设备创建一个合适的设备文件。通过去除不必要的驱动程序、禁用不需要的功能、选择合适的内核配置选项、优化内核编译选项和定制内核模块等方法,可以减小内核的大小和复杂性,提高系统的性能和稳定性。上半部通常是在中断关闭的情况下执行的,以确保中断处理的原子性。处理碎片化内存是内存管理中的一个重要问题,可以采用内存压缩、内存池管理、伙伴系统、首次适应算法和最佳适应算法等方法来减少内存碎片的产生,提高内存的利用率。

大模型大数据攻城狮的专栏 2929

如何理解S参数的三大特性

提到S参数的时候经常会涉及一些概念,如无源性、因果性、互易性等,本文逐一介绍这些特性的概念、成因以及判断方式。

一只豌豆象的博客 4502

【学习笔记】(五)Spring代理对象的创建流程与原理

记录源码阅读时,Spring代理对象创建流程

Riven_mikasa的博客 1068

【Unity】【VR】如何让Distance Grab抓取物品时限制物品的Rotation

VR中Canvas抓取旋转问题的解决方案 在VR应用中,Canvas作为UI面板常需被抓取拖动,但默认会随手柄产生Z轴旋转,导致UI歪斜。Unity的Rigidbody冻结旋转功能对此无效,因为XR抓取直接修改Transform而非物理模拟。

每日出拳老爷子的博客 611

黑马程序员Spring视频教程,全面深度讲解spring5底层原理 学习笔记

介绍 代码仓库地址:https://gitee.com/CandyWall/spring-source-study 跟着黑马满一航老师的spring高级49讲做的学习笔记,本笔记跟视频内容的项目名称和代码略有不同,都是基于我自己的考量,代码都已经过运行验证过的,仅供参考。 视频教程地址:https://www.bilibili.com/video/BV1P44y1N7QG 每个子项目对应的视频链接以及一些重要内容的笔记 第一讲 BeanFactory与ApplicationContext的区别与联系 spr

糖果墙的博客 3万+

逆强化学习:从专家示范中学习策略

逆强化学习(Inverse Reinforcement Learning,简称IRL)是强化学习(Reinforcement Learning,简称RL)的一个子领域,它的目标是从专家的行为中学习策略。在传统的强化学习中,智能体通过与环境交互,根据奖励信号来学习一个策略。而在逆强化学习中,我们没有直接的奖励信号,而是通过观察专家的行为来推断出奖励函数,从而学习到一个与专家类似的策略。逆强化学习作为强化学习的一个重要子领域,在许多实际应用场景中都取得了显著的成功。

AI天才研究院 1456

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

[spring入门学习笔记][spring的IoC原理]

什么叫IoC控制反转(Inversion of Control,缩写为IoC),是面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection,简称DI),还有一种方式叫“依赖查找”(Dependency Lookup)。通过控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体,将其所依赖的对象的引用传递给它。也

学习之路 5760

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

spring原理学习笔记

20190412 初学spring,spring框架原理心得记录学习视屏地址 学习视屏地址 http://www.mayikt.com/course/video/1100 理解spring ioc容器 xml方式框架原理 ,我的简单理解是xml方式的spring对象创建是通过读取xml配置文件,然后把里面所有的bean节点进行封装在map中,然后通过bean对象的方法进行获取与之对应的对象时,通...

weixin_40003787的博客 222

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Spring全家桶原理源码学习笔记(终极版)

Spring这个技术栈,在LZ心目中一直是最好的Java项目,没有之一。这玩意面试必考工作必用,是我们Java人的饭碗;它跟它后面诞生的一系列解决方案被我们亲切的成为Spring全家桶,如果你自诩是一名合格的Java程序员,这玩意一定要全部掌握

weixin_50205273的博客 300

Spring底层原理学习笔记

①bean的创建过程②spring启动③spring启动源码

2303_76364859的博客 487

Spring 学习笔记之 @Transactinal实现原理

主要借助 Spring 的 AOP(面向切面编程)机制来达成事务管理。当一个方法被注解修饰时,Spring 会在该方法执行前后添加事务相关的处理逻辑,以保证方法内的数据库操作在一个统一的事务环境中进行。注解通过 Spring 的 AOP 机制,在目标方法执行前后插入事务管理逻辑,从而实现了数据库事务的自动管理。它大大简化了事务处理的代码,提升了开发效率。

freeRoad 891

Spring IOC原理学习笔记

Spring容器高层视图 Spring 启动时读取应用程序提供的Bean配置信息,并在Spring容器中生成一份相应的Bean配置注册表,然后根据这张注册表实例化Bean,装配好Bean之间的依赖关系,为上层应用提供准备就绪的运行环境。 IOC容器介绍 pring 通过一个配置文件描述 Bean 及 Bean 之间的依赖关系,利用 Java 语言的反射功能实例化 Bean 并建立 Bean 之间...

时间蜗牛的博客 344

Spring基本原理学习笔记

Spring基本原理学习笔记

qq_43657722的博客 475

学习笔记——spring5概念和原理

文章目录一、 spring5概述和原理Spring5 框架概述Spring5入门案例IOC(概念和原理)IOC(BeanFactory 接口)IOC操作 Bean 管理(概念)IOC操作 Bean 管理(基于 xml 方式)IOC操作 Bean 管理( xml 注入其他类型属性)IOC 操作 Bean 管理(xml 注入集合属性)IOC操作 Bean 管理( FactoryBean)IOC操作 Bean 管理( bean 作用域)IOC操作 Bean 管理( bean 生命周期)IOC操作 Bean 管理(

fangfeng1021的博客 556

Java学习笔记分享之Spring篇(原理)

Spring 学习笔记分享

一叶知春秋 768

Spring(9. Spring 底层原理)学习笔记

上一篇 :8. 声明式事务 文章目录1. 自动配置原理1. 手写一个简单的自动装配示例2. 手写一个 @Autowired 注解的简单实现3. 示例小结2. 简单的 IOC 原理图3. 容器演变过程4. Spring 框架的架构设计5. DeBug 源码验证上述流程 1. 自动配置原理 自动装配本质上就是利用 反射 实现的 1. 手写一个简单的自动装配示例 这是一个很简单的示例 在这个示例中,自动装配的对象是一个写死的对象,主要理解思想 代码实现 先写一个 UserService ,简单示例,里

圆的博客 651

Spring Security 原理学习笔记

Spring Security主要包括两大功能:验证和鉴权。 验证就是确认用户的身份,一般采用用户名和密码的形式; 鉴权就是确认用户拥有的身份(角色、权限)能否访问受保护的资源。 一、Security配置 和Security相关的代码只需要一个类SecurityConfiguration(继承了WebSecurityConfigurerAdapter) 二、验证流程 ​ Authentication类:参与验证的要素(用户名、密码)在前端由表单提交,由网络传入后端后,会形...

和光同尘的博客 643
上一篇: 学习笔记:spring框架下跨域问题的解决(后端解决)
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值