设计模式 ~ Spring。

已于 2023-02-25 12:33:33 修改
阅读量267 收藏 1
点赞数
分类专栏： 设计模式。 开发。 文章标签： spring java 设计模式
于 2023-02-20 23:28:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyfgeek/article/details/129133913
版权

设计模式看 Spring。

文章目录

自定义 Spring 框架。

7.1 Spring 使用回顾。

自定义 Spring 框架前，先回顾一下 spring 框架的使用，从而分析 spring 的核心，并对核心功能进行模拟。


        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
  • 数据访问层。定义 UserDao 接口及其子实现类。
package com.example.design.pattern.spring.dao;

/**
 * 接口 ~ 数据访问层。
 *
 * @author geek
 */
public interface IUserDao {

    /**
     * insert。
     */
    void insert();

}


package com.geek.design.pattern.spring.dao.impl;

import com.geek.design.pattern.spring.dao.IUserDao;

/**
 * 实现类 ~ 数据访问层。
 *
 * @author geek
 */
public class UserDaoImpl implements IUserDao {

    public UserDaoImpl() {
        System.out.println(" ~ UserDaoImpl ~ public UserDaoImpl(); ~ ");
    }

    /**
     * insert。
     */
    @Override
    public void insert() {
        System.out.println(" ~ UserDaoImpl ~ insert; ~ ");
    }

}
  • 业务逻辑层。定义 UserService 接口及其子实现类。
package com.geek.design.pattern.spring.service.impl;

import com.geek.design.pattern.spring.dao.IUserDao;
import com.geek.design.pattern.spring.service.IUserService;

/**
 * 实现类 ~ 业务逻辑层。
 *
 * @author geek
 */
public class UserServiceImpl implements IUserService {

    /**
     * 声明一个 IUserDao 类型的变量。
     */
    private IUserDao userDao;

    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    /**
     * add。
     */
    @Override
    public void add() {
        System.out.println(" ~ UserServiceImpl ~ add; ~ ");
        this.userDao.insert();
    }

}


package com.geek.design.pattern.spring.service.impl;

import com.geek.design.pattern.spring.dao.IUserDao;
import com.geek.design.pattern.spring.service.IUserService;

/**
 * 实现类 ~ 业务逻辑层。
 *
 * @author geek
 */
public class UserServiceImpl implements IUserService {

    /**
     * 声明一个 IUserDao 类型的变量。
     */
    private IUserDao userDao;

    public UserServiceImpl(IUserDao userDao) {
        System.out.println(" ~ UserServiceImpl ~ public UserServiceImpl(IUserDao userDao); ~ 0。");
        this.userDao = userDao;
        System.out.println(" ~ UserServiceImpl ~ public UserServiceImpl(IUserDao userDao); ~ 1。");
    }

    public void setUserDao(IUserDao userDao) {
        System.out.println(" ~ UserServiceImpl ~ serUserDao; ~ 0。");
        this.userDao = userDao;
        System.out.println(" ~ UserServiceImpl ~ serUserDao; ~ 1。");
    }

    /**
     * add。
     */
    @Override
    public void add() {
        System.out.println(" ~ UserServiceImpl ~ add; ~ ");
        this.userDao.insert();
    }

}
  • 定义 UserController 类，使用 main 方法模拟 controller 层。
package com.geek.design.pattern.spring.controller;

import com.geek.design.pattern.spring.service.IUserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author geek
 */
public class UserController {

    public static void main(String[] args) {
        // 创建 Spring 容器对象。
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 从容器对象中获取 userService 对象。
        System.out.println("使用对象前。");
        IUserService userService = applicationContext.getBean("userService", IUserService.class);
        // 调用 userService 的方法进行业务逻辑处理。
        userService.add();
    }

}

/*
Connected to the target VM, address: '127.0.0.1:49467', transport: 'socket'
00:36:39.319 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@dc24521
00:36:39.559 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 2 bean definitions from class path resource [applicationContext.xml]
00:36:39.626 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'userDao'
 ~ UserDaoImpl ~ public UserDaoImpl(); ~ 
00:36:39.649 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'userService'
 ~ UserServiceImpl ~ public UserServiceImpl();
 ~ UserServiceImpl ~ serUserDao; ~ 0。
 ~ UserServiceImpl ~ serUserDao; ~ 1。
使用对象前。
 ~ UserServiceImpl ~ add; ~ 
 ~ UserDaoImpl ~ insert; ~ 
Disconnected from the target VM, address: '127.0.0.1:49467', transport: 'socket'

Process finished with exit code 0
 */
  • 编写配置文件。在类路径下编写一个名为 applicationContext.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userDao" class="com.geek.design.pattern.spring.dao.impl.UserDaoImpl"/>

    <bean id="userService" class="com.geek.design.pattern.spring.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>

通过上面代码及结果可以看出。

  • userService 对象是从 applicationContext 容器对象获取到的，也就是 userService 对象交由 Spring 进行管理。

  • 上面结果可以看到调用了 UserDao 对象中的 add 方法，也就是说 UserDao 子实现类对象也交由 Spring 管理了。

  • UserService 中的 userDao 变量我们并没有进行赋值，但是可以正常使用，说明 Spring 已经将 UserDao 对象赋值给了 userDao 变量。

上面三点体现了 Spring 框架的 IoC（Inversion of Control）和 DI（Dependency Injection, DI）。


7.2 Spring 核心功能结构。

Spring 大约有20个模块，由1300多个不同的文件构成。这些模块可以分为:

核心容器、AOP 和设备支持、数据访问与集成、Web 组件、通信报文和集成测试等，下面是 Spring 框架的总体架构图。

核心容器由 beans、core、context 和 expression（Spring Expression Language，SpEL）4 个模块组成。

  • spring-beans 和 spring-core 模块是 Spring 框架的核心模块，包含了控制反转（Inversion of Control，IoC）和依赖注入（Dependency
    Injection，DI）。BeanFactory 使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。BeanFactory
    属于延时加载，也就是说在实例化容器对象后并不会自动实例化 Bean，只有当 Bean 被使用时，BeanFactory 才会对该 Bean
    进行实例化与依赖关系的装配。

（延时加载）。

package com.geek.design.pattern.spring.controller;

import com.geek.design.pattern.spring.service.IUserService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

/**
 * 延时加载。
 *
 * @author geek
 */
public class UserController1 {

    public static void main(String[] args) {
        // 创建 Spring 容器对象。
//        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        // 从容器对象中获取 userService 对象。
//        IUserService userService = applicationContext.getBean("userService", IUserService.class);
        System.out.println("使用对象前。");
        IUserService userService = beanFactory.getBean("userService", IUserService.class);
        // 调用 userService 的方法进行业务逻辑处理。
        userService.add();
    }

}

/*
Connected to the target VM, address: '127.0.0.1:49453', transport: 'socket'
00:35:53.288 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 2 bean definitions from class path resource [applicationContext.xml]
使用对象前。
00:35:53.299 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanFactory - Creating shared instance of singleton bean 'userService'
 ~ UserServiceImpl ~ public UserServiceImpl();
00:35:53.316 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanFactory - Creating shared instance of singleton bean 'userDao'
 ~ UserDaoImpl ~ public UserDaoImpl(); ~
 ~ UserServiceImpl ~ serUserDao; ~ 0。
 ~ UserServiceImpl ~ serUserDao; ~ 1。
 ~ UserServiceImpl ~ add; ~
 ~ UserDaoImpl ~ insert; ~
Disconnected from the target VM, address: '127.0.0.1:49453', transport: 'socket'

Process finished with exit code 0
 */

  • spring-context 模块构架于核心模块之上，扩展了 BeanFactory，为它添加了 Bean
    生命周期控制、框架事件体系及资源加载透明化等功能。此外，该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，ApplicationContext 是该模块的核心接口，它的超类是 BeanFactory。与 BeanFactory 不同，ApplicationContext 实例化后会自动对所有的单实例 Bean 进行实例化与依赖关系的装配，使之处于待用状态。

  • spring-context-support 模块是对 Spring IoC 容器及 IoC 子容器的扩展支持。

  • spring-context-indexer 模块是 Spring 的类管理组件和 Classpath 扫描组件。

  • spring-expression 模块是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。ta 的语法类似于传统 EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL 的特性是基于 Spring 产品的需求而设计的，可以非常方便地同 Spring IoC 进行交互。


7.2.1 bean 概述。

Spring 就是面向 Bean 的编程（BOP, Bean Oriented Programming），Bean 在 Spring 中处于核心地位。Bean 对于 Spring 的意义就像 Object 对于 OOP 的意义一样，Spring 中没有 Bean 也就没有 Spring 存在的意义。Spring IoC 容器通过配置文件或者注解的方式来管理 bean 对象之间的依赖关系。

Spring 中 bean 用于对一个类进行封装。如下面的配置。

    <bean id="userDao" class="com.geek.design.pattern.spring.dao.impl.UserDaoImpl"/>

    <bean id="userService" class="com.geek.design.pattern.spring.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

为什么 Bean 如此重要呢？

  • Spring 将 bean 对象交由一个叫 IoC 容器进行管理。

  • bean 对象之间的依赖关系在配置文件中体现，并由 Spring 完成。


7.3 Spring IoC 相关接口分析。

7.3.1 BeanFactory 解析。

Spring 中 Bean 的创建是典型的工厂模式，这一系列的 Bean 工厂，即 IoC 容器，为开发者管理对象之间的依赖关系提供了很多便利和基础服务，在 Spring 中有许多 IoC 容器的实现供用户选择，其相互关系如下图所示。

在这里插入图片描述

其中，BeanFactory 作为最顶层的一个接口，定义了 IoC 容器的基本功能规范，BeanFactory 有三个重要的子接口：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。但是从类图中我们可以发现最终的默认实现类是 DefaultListableBeanFactory，ta 实现了所有的接口。

在这里插入图片描述

那么为何要定义这么多层次的接口呢？

每个接口都有它的使用场合，主要是为了区分在 Spring 内部操作过程中对象的传递和转化，对对象的数据访问所做的限制。例如，

  • ListableBeanFactory 接口表示这些 Bean 可列表化。

  • HierarchicalBeanFactory 表示这些 Bean 是有继承关系的，也就是每个 Bean 可能有父 Bean。

  • AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则。

这三个接口共同定义了 Bean 的集合、Bean 之间的关系及 Bean 行为。最基本的 IoC 容器接口是 BeanFactory，来看一下它的源码。


package org.springframework.beans.factory;

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

public interface BeanFactory {

	String FACTORY_BEAN_PREFIX = "&";

	// 根据 bean 的名称获取 IoC 容器中的的 bean 对象。
	Object getBean(String name) throws BeansException;

	// 根据 bean 的名称获取 IoC 容器中的的 bean 对象，并指定获取到的 bean 对象的类型，这样我们使用时就不需要进行类型强转了。
	<T> T getBean(String name, Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	// 判断容器中是否包含指定名称的 bean 对象。
	boolean containsBean(String name);

	// 根据 bean 的名称判断是否是单例。
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;

	@Nullable
	Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;

	String[] getAliases(String name);

}

在 BeanFactory 里只对 IoC 容器的基本行为做了定义，根本不关心你的 Bean 是如何定义及怎样加载的。正如我们只关心能从工厂里得到什么产品，不关心工厂是怎么生产这些产品的。

BeanFactory 有一个很重要的子接口，就是 ApplicationContext 接口，该接口主要来规范容器中的 bean 对象是非延时加载，即在创建容器对象的时候就对象 bean 进行初始化，并存储到一个容器中。

要知道工厂是如何产生对象的，我们需要看具体的 IoC 容器实现，Spring 提供了许多 IoC 容器实现，比如：

  • ClasspathXmlApplicationContext : 根据类路径加载 xml 配置文件，并创建 IoC 容器对象。

  • FileSystemXmlApplicationContext ：根据系统路径加载 xml 配置文件，并创建 IoC 容器对象。

  • AnnotationConfigApplicationContext ：加载注解类配置，并创建 IoC 容器。


7.3.2 BeanDefinition 解析。

Spring IoC 容器管理我们定义的各种 Bean 对象及其相互关系，而 Bean 对象在 Spring 实现中是以 BeanDefinition 来描述的，如下面配置文件。

    <bean id="userDao" class="com.geek.design.pattern.spring.dao.impl.UserDaoImpl"/>

bean 标签还有很多属性：
scope、init-method、destory-method 等。

其继承体系如下图所示。


7.3.3 BeanDefinitionReader 解析。

Bean 的解析过程非常复杂，功能被分得很细，因为这里需要被扩展的地方很多，必须保证足够的灵活性，以应对可能的变化。Bean 的解析主要就是对 Spring 配置文件的解析。这个解析过程主要通过 BeanDefinitionReader 来完成，看看 Spring 中 BeanDefinitionReader 的类结构图，如下图所示。


在这里插入图片描述

看看 BeanDefinitionReader 接口定义的功能来理解它具体的作用。

public interface BeanDefinitionReader {

	// 获取 BeanDefinitionRegistry 注册器对象。
	BeanDefinitionRegistry getRegistry();

	@Nullable
	ResourceLoader getResourceLoader();

	@Nullable
	ClassLoader getBeanClassLoader();

	BeanNameGenerator getBeanNameGenerator();

// 下面的 loadBeanDefinitions 都是加载 bean 定义，从指定的资源中。

	int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;

	int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;

	int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;

	int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;

}

7.3.4 BeanDefinitionRegistry 解析。

BeanDefinitionReader 用来解析 bean 定义，并封装 BeanDefinition 对象，而我们定义的配置文件中定义了很多 bean 标签，所以就有一个问题，解析的 BeanDefinition 对象存储到哪儿？答案就是 BeanDefinition 的注册中心，而该注册中心顶层接口就是 BeanDefinitionRegistry。

public interface BeanDefinitionRegistry extends AliasRegistry {

	// 往注册表中注册 bean。
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException;

	// 从注册表中删除指定名称的 bean。
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 获取注册表中指定名称的 bean。
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 判断注册表中是否已经注册了指定名称的 bean。	
	boolean containsBeanDefinition(String beanName);

	// 获取注册表中所有的 bean 的名称。
	String[] getBeanDefinitionNames();

	int getBeanDefinitionCount();

	boolean isBeanNameInUse(String beanName);

}

继承结构图如下。

从上面类图可以看到 BeanDefinitionRegistry 接口的子实现类主要有以下几个。

  • DefaultListableBeanFactory。

    在该类中定义了如下代码，就是用来注册 bean。

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {


	/** Map of bean definition objects, keyed by bean name. */
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

  • SimpleBeanDefinitionRegistry。

    在该类中定义了如下代码，就是用来注册 bean。

public class SimpleBeanDefinitionRegistry extends SimpleAliasRegistry implements BeanDefinitionRegistry {

	/** Map of bean definition objects, keyed by bean name. */
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);

7.3.5 创建容器。

ClassPathXmlApplicationContext 对 Bean 配置资源的载入是从 refresh(); 方法开始的。refresh(); 方法是一个模板方法，规定了 IoC 容器的启动流程，有些逻辑要交给其子类实现。ta 对 Bean 配置资源进行载入，ClassPathXmlApplicationContext 通过调用其父类
AbstractApplicationContext 的 refresh() 方法启动整个 IoC 容器对 Bean 定义的载入过程。


7.4 自定义 SpringIoC。

现要对下面的配置文件进行解析，并自定义 Spring 框架的 IoC 对涉及到的对象进行管理。

<?xml version="1.0" encoding="UTF-8" ?>
<beans>

    <bean id="userDao" class="com.geek.design.pattern.spring.dao.impl.UserDaoImpl"/>

    <bean id="userService" class="com.geek.design.pattern.spring.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>

7.4.1 定义 bean 相关的 pojo 类。

7.4.1.1 PropertyValue 类。

用于封装 bean 的属性，体现到上面的配置文件就是封装 bean 标签的子标签 property 标签数据。

package com.geek.design.pattern.spring.geek.framework.beans;

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

/**
 * 封装 bean 标签下 property 标签的属性。
 *
 * @author geek
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PropertyValue {

    private String name;
    private String ref;
    /**
     * 给基本数据类型及 String 类型的数据赋值。
     */
    private String value;

}

7.4.1.2 MutablePropertyValues 类。

一个 bean 标签可以有多个 property 子标签，所以再定义一个 MutablePropertyValues 类，用来存储并管理多个 PropertyValue 对象。

package com.geek.design.pattern.spring.geek.framework.beans;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

/**
 * 存储和管理多个 PropertyValue 对象。
 *
 * @author geek
 */
public class MutablePropertyValues implements Iterable<PropertyValue> {

    /**
     * 定义 list 集合对象，用来存储 PropertyValue 对象。
     */
    private final List<PropertyValue> propertyValueList;

    public MutablePropertyValues() {
        this.propertyValueList = new ArrayList<PropertyValue>();
    }

    public MutablePropertyValues(List<PropertyValue> propertyValueList) {
        if (Objects.isNull(propertyValueList)) {
            this.propertyValueList = new ArrayList<PropertyValue>();
        } else {
            this.propertyValueList = propertyValueList;
        }
    }

    /**
     * 获取迭代器对象。
     * Returns an iterator over elements of type {@code T}.
     *
     * @return an Iterator.
     */
    @Override
    public Iterator<PropertyValue> iterator() {
//        return null;
        return this.propertyValueList.iterator();
    }

    /**
     * 获取所有的 PropertyValue 对象，以数组形式返回。
     *
     * @return
     */
    public PropertyValue[] getPropertyValues() {
        // 将集合转换为数组并返回。
        return this.propertyValueList.toArray(new PropertyValue[0]);
    }

    /**
     * 根据 name 属性值获取 PropertyValue 对象。
     *
     * @param propertyName
     * @return
     */
    public PropertyValue getPropertyValue(String propertyName) {
        for (PropertyValue propertyValue : this.propertyValueList) {
            String propertyValueName = propertyValue.getName();
            if (propertyValueName.equals(propertyName)) {
                return propertyValue;
            }
        }
        return null;
    }

    /**
     * 判断集合是否为空。
     *
     * @return
     */
    public boolean isEmpty() {
        return this.propertyValueList.isEmpty();
    }

    /**
     * 添加 PropertyValue 对象。
     *
     * @param propertyValue
     * @return
     */
    public MutablePropertyValues addPropertyValue(PropertyValue propertyValue) {
        // 判断集合中存储的 PropertyValue 对象是否和传递的重复。如果重复，进行覆盖。
        for (int i = 0; i < this.propertyValueList.size(); i++) {
            PropertyValue propertyValueCurrent = this.propertyValueList.get(i);
            if (propertyValueCurrent.getName().equals(propertyValue.getName())) {
                this.propertyValueList.set(i, propertyValue);
                // 目的：实现链式编程。
                return this;
            }
        }
        this.propertyValueList.add(propertyValue);
        // 目的：实现链式编程。
        return this;
    }

    /**
     * 判断是否有指定 name 属性值的对象。
     *
     * @param propertyName
     * @return
     */
    public boolean contains(String propertyName) {
        return this.getPropertyValue(propertyName) != null;
    }

}

7.4.1.3 BeanDefinition 类。

BeanDefinition 类用来封装 bean 信息的，主要包含 id（即 bean 对象的名称）、class（需要交由 Spring 管理的类的全类名）及子标签 property 数据。

package com.geek.design.pattern.spring.geek.framework.beans;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;

/**
 * 封装 Bean 标签数据。
 * - id 属性。
 * - class 属性。
 * - property 子标签的数据。
 *
 * @author geek
 */
@Data
public class BeanDefinition {

    /**
     * 定义 list 集合对象，用来存储 PropertyValue 对象。
     */
    private final List<PropertyValue> propertyValueList;

    public BeanDefinition() {
        this.propertyValueList = new ArrayList<PropertyValue>();
    }

    public BeanDefinition(List<PropertyValue> propertyValueList) {
        if (propertyValueList == null) {
            this.propertyValueList = new ArrayList<>();
        } else {
            this.propertyValueList = propertyValueList;
        }
    }

}

7.4.2 定义注册表相关类。

7.4.2.1 BeanDefinitionRegistry 接口。

BeanDefinitionRegistry 接口定义了注册表的相关操作，定义如下功能。

  • 注册 BeanDefinition 对象到注册表中。

  • 从注册表中删除指定名称的 BeanDefinition 对象。

  • 根据名称从注册表中获取 BeanDefinition 对象。

  • 判断注册表中是否包含指定名称的 BeanDefinition 对象。

  • 获取注册表中 BeanDefinition 对象的个数。

  • 获取注册表中所有的 BeanDefinition 的名称。

package com.geek.design.pattern.spring.geek.framework.beans.factory.support;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;

/**
 * 注册表对象接口。
 *
 * @author geek
 */
public interface IBeanDefinitionRegistry {

    /**
     * 注册 BeanDefinition 对象到注册表中。
     *
     * @param beanName
     * @param beanDefinition
     */
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);

    /**
     * 从注册表中删除指定名称的 BeanDefinition 对象。
     *
     * @param beanName
     * @throws Exception
     */
    void removeBeanDefinition(String beanName) throws Exception;

    /**
     * 根据名称从注册表中获取 BeanDefinition 对象。
     *
     * @param beanName
     * @return
     * @throws Exception
     */
    BeanDefinition getBeanDefinition(String beanName) throws Exception;

    /**
     * 根据名称判断注册表中是否有 BeanDefinition 对象。
     *
     * @param beanName
     * @return
     */
    boolean containsBeanDefinition(String beanName);

    /**
     * 注册表中的对象数量。
     *
     * @return
     */
    int getBeanDefinitionCount();

    /**
     * 获取注册表中对象属性名集合。
     *
     * @return
     */
    String[] getBeanDefinitionNames();

}
7.4.2.2 SimpleBeanDefinitionRegistry 类。

该类实现了 BeanDefinitionRegistry 接口，定义了 Map 集合作为注册表容器。

package com.geek.design.pattern.spring.geek.framework.beans.factory.support;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;

import java.util.HashMap;
import java.util.Map;

/**
 * 注册表对象接口子实现类。
 *
 * @author geek
 */
public class SimpleBeanDefinitionRegistry implements IBeanDefinitionRegistry {

    /**
     * 存储 BeanDefinition 对象的容器。
     */
    private final Map<String, BeanDefinition> definitionMap = new HashMap<String, BeanDefinition>();

    /**
     * 注册 BeanDefinition 对象到注册表中。
     *
     * @param beanName
     * @param beanDefinition
     */
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        this.definitionMap.put(beanName, beanDefinition);
    }

    /**
     * 从注册表中删除指定名称的 BeanDefinition 对象。
     *
     * @param beanName
     */
    @Override
    public void removeBeanDefinition(String beanName) {
        this.definitionMap.remove(beanName);
    }

    /**
     * 根据名称从注册表中获取 BeanDefinition 对象。
     *
     * @param beanName
     * @return
     */
    @Override
    public BeanDefinition getBeanDefinition(String beanName) {
        return this.definitionMap.get(beanName);
    }

    /**
     * 根据名称判断注册表中是否有 BeanDefinition 对象。
     *
     * @param beanName
     * @return
     */
    @Override
    public boolean containsBeanDefinition(String beanName) {
        return this.definitionMap.containsKey(beanName);
    }

    /**
     * 注册表中的对象数量。
     *
     * @return
     */
    @Override
    public int getBeanDefinitionCount() {
        return this.definitionMap.size();
    }

    /**
     * 获取注册表中对象属性名集合。
     *
     * @return
     */
    @Override
    public String[] getBeanDefinitionNames() {
        return this.definitionMap.keySet().toArray(new String[0]);
    }

}

7.4.3 定义解析器相关类。

7.4.3.1 BeanDefinitionReader 接口。

BeanDefinitionReader 是用来解析配置文件并在注册表中注册 bean 的信息。定义了两个规范.

  • 获取注册表的功能，让外界可以通过该对象获取注册表对象。

  • 加载配置文件，并注册 bean 数据。

package com.geek.design.pattern.spring.geek.framework.beans.factory.support;

/**
 * 解析配置文件。接口 ~ 定义规范。
 *
 * @author geek
 */
public interface IBeanDefinitionReader {

    /**
     * 获取注册表对象。
     *
     * @return
     */
    IBeanDefinitionRegistry getRegistry();

    /**
     * 加载配置文件并在注册表中进行注册
     *
     * @param configLocation
     * @throws Exception
     */
    void loadBeanDefinitions(String configLocation) throws Exception;

}

7.4.3.2 XmlBeanDefinitionReader 类。

XmlBeanDefinitionReader 类是专门用来解析 xml 配置文件的。该类实现 BeanDefinitionReader 接口并实现接口中的两个功能。


        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>


package com.geek.design.pattern.spring.geek.framework.beans.factory.xml;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;
import com.geek.design.pattern.spring.geek.framework.beans.MutablePropertyValues;
import com.geek.design.pattern.spring.geek.framework.beans.PropertyValue;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionReader;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionRegistry;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.SimpleBeanDefinitionRegistry;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;

/**
 * 针对 xml 配置文件进行解析的类。
 *
 * @author geek
 */
public class XmlBeanDefinitionReader implements IBeanDefinitionReader {

    /**
     * 声明注册表对象。
     */
    private final IBeanDefinitionRegistry beanDefinitionRegistry;

    public XmlBeanDefinitionReader() {
        this.beanDefinitionRegistry = new SimpleBeanDefinitionRegistry();
    }

    /**
     * 获取注册表对象。
     *
     * @return
     */
    @Override
    public IBeanDefinitionRegistry getRegistry() {
        return this.beanDefinitionRegistry;
    }

    /**
     * 加载配置文件并在注册表中进行注册。
     *
     * @param configLocation
     * @throws DocumentException
     */
    @Override
    public void loadBeanDefinitions(String configLocation) throws DocumentException {
        // dom4j 进行 xml 配置文件解析。
        SAXReader saxReader = new SAXReader();
        // 获取类路径下的配置文件。
        InputStream resourceAsStream = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
        Document document = saxReader.read(resourceAsStream);
        // 根据 document 对象获取根标签对象（beans）。
        Element rootElement = document.getRootElement();
        // 获取根标签下所有 bean 标签对象。
        List<Element> beanElementList = rootElement.elements("bean");
        for (Element beanElement : beanElementList) {
            // 获取 id 属性。
            String id = beanElement.attributeValue("id");
            // 获取 class 属性。
            String className = beanElement.attributeValue("class");
            // 将 id 属性和 class 属性封装到 BeanDefinition 对象中。
            // 创建 BeanDefinition。
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setId(id);
            beanDefinition.setClassName(className);

            // 创建 MutablePropertyValues 对象。
            MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();

            // 获取 bean 标签下所有的 property 标签对象。
            List<Element> propertyElementList = beanElement.elements("property");
            for (Element propertyElement : propertyElementList) {
                String name = propertyElement.attributeValue("name");
                String ref = propertyElement.attributeValue("ref");
                String value = propertyElement.attributeValue("value");
                PropertyValue propertyValue = new PropertyValue(name, ref, value);
                MutablePropertyValues mutablePropertyValues1 = mutablePropertyValues.addPropertyValue(propertyValue);
                System.out.println("mutablePropertyValues1 = " + mutablePropertyValues1);
            }
            // 将 mutablePropertyValues 封装到 BeanDefinition 对象中。
            beanDefinition.setPropertyValues(mutablePropertyValues);

            // 将 beanDefinition 对象注册到注册表中。
            this.beanDefinitionRegistry.registerBeanDefinition(id, beanDefinition);
        }
    }

}

7.4.4 IoC 容器相关类。

7.4.4.1 BeanFactory 接口。

在该接口中定义 IoC 容器的统一规范即获取 bean 对象。

package com.geek.design.pattern.spring.geek.framework.beans.factory;

/**
 * IoC 容器父接口。
 *
 * @author geek
 */
public interface IBeanFactory {

    /**
     * 根据 bean 对象的名称获取 bean 对象。
     *
     * @param name
     * @return
     */
    Object getBean(String name);

    /**
     * 根据 bean 对象的名称获取 bean 对象，并进行类型转换。
     *
     * @param name
     * @param clazz
     * @param <T>
     * @return
     * @throws Exception
     */
    <T> T getBean(String name, Class<? extends T> clazz) throws Exception;

}
7.4.4.2 ApplicationContext 接口。

该接口的所以的子实现类对 bean 对象的创建都是非延时的，所以在该接口中定义 refresh() 方法，该方法主要完成以下两个功能：

  • 加载配置文件。

  • 根据注册表中的 BeanDefinition 对象封装的数据进行 bean 对象的创建。

package com.geek.design.pattern.spring.geek.framework.context;

import com.geek.design.pattern.spring.geek.framework.beans.factory.IBeanFactory;

/**
 * 定义非延时加载功能。
 *
 * @author geek
 */
public interface IApplicationContext extends IBeanFactory {

    /**
     * 进行配置文件加载并进行对象创建。
     */
    void refresh();

}

7.4.4.3 AbstractApplicationContext 类。

  • 作为 ApplicationContext 接口的子类，所以该类也是非延时加载，所以需要在该类中定义一个 Map 集合，作为 bean 对象存储的容器。

  • 声明 BeanDefinitionReader 类型的变量，用来进行 xml 配置文件的解析，符合单一职责原则。
    BeanDefinitionReader 类型的对象创建交由子类实现，因为只有子类明确到底创建 BeanDefinitionReader 哪儿个子实现类对象。

package com.geek.design.pattern.spring.geek.framework.context.support;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionReader;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionRegistry;
import com.geek.design.pattern.spring.geek.framework.context.IApplicationContext;
import org.dom4j.DocumentException;
import org.omg.CORBA.Object;

import java.util.HashMap;
import java.util.Map;

/**
 * IApplicationContext 接口的子实现类，用于立即加载。
 *
 * @author geek
 */
public abstract class AbstractClassApplicationContext implements IApplicationContext {

    /**
     * 声明解析器变量。
     */
    protected IBeanDefinitionReader beanDefinitionReader;

    /**
     * 用于存储 bean 对象的 map 容器。
     */
    protected Map<String, Object> singletonObjectMap = new HashMap<String, Object>();

    /**
     * 配置文件路径。
     */
    protected String configLocation;

    /**
     * 进行配置文件加载并进行对象创建。
     */
    @Override
    public void refresh() throws DocumentException {
        // 加载 BeanDefinition 对象。
        this.beanDefinitionReader.loadBeanDefinitions(this.configLocation);
        // 初始化 Bean。

    }

    /**
     * bean 的初始化。
     */
    private void finishBeanInitialization() {
        // 获取注册表对象。
        IBeanDefinitionRegistry beanDefinitionReaderRegistry = this.beanDefinitionReader.getRegistry();
        // 获取 BeanDefinition 对象。
        String[] beanNames = beanDefinitionReaderRegistry.getBeanDefinitionNames();
        // bean 的初始化。
        for (String beanName : beanNames) {
            BeanDefinition beanDefinition = beanDefinitionReaderRegistry.getBeanDefinition(beanName);
            this.getBean(beanName);
        }
    }

}

注意：该类 finishBeanInitialization(); 方法中调用 getBean(); 方法使用到了模板方法模式。


7.4.4.4 ClassPathXmlApplicationContext 类。

该类主要是加载类路径下的配置文件，并进行 bean 对象的创建，主要完成以下功能。

  • 在构造方法中，创建 BeanDefinitionReader 对象。

  • 在构造方法中，调用 refresh(); 方法，用于进行配置文件加载、创建 bean 对象并存储到容器中。

  • 重写父接口中的 getBean(); 方法，并实现依赖注入操作。

package com.geek.design.pattern.spring.geek.framework.context.support;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;
import com.geek.design.pattern.spring.geek.framework.beans.MutablePropertyValues;
import com.geek.design.pattern.spring.geek.framework.beans.PropertyValue;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionRegistry;
import com.geek.design.pattern.spring.geek.framework.beans.factory.xml.XmlBeanDefinitionReader;
import com.geek.design.pattern.spring.geek.framework.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.dom4j.DocumentException;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * IoC 容器具体的子实现类。加载类路径下的 xml 格式的配置文件。
 *
 * @author geek
 */
@Slf4j
public class ClassPathXmlApplicationContext extends AbstractClassApplicationContext {

    public ClassPathXmlApplicationContext(String configLocation) {
        this.configLocation = configLocation;
        // 构建 XmlBeanDefinitionReader 对象。
        beanDefinitionReader = new XmlBeanDefinitionReader();
        try {
            this.refresh();
        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 根据 bean 对象的名称获取 bean 对象。
     *
     * @param name
     * @return
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     * @throws NoSuchMethodException
     */
    @Override
    public Object getBean(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        // 判断对象容器中是否包含指定名称的 bean 对象。
        Object object = this.singletonObjectMap.get(name);
        log.info(" ~ ClassPathXmlApplicationContext ~ getBean; ~ object ~ {}",
                object);
        if (object != null) {
            return object;
        }

        // 获取 BeanDefinition 对象。
        IBeanDefinitionRegistry beanDefinitionReaderRegistry = this.beanDefinitionReader.getRegistry();
        BeanDefinition beanDefinition = beanDefinitionReaderRegistry.getBeanDefinition(name);
        if (beanDefinition == null) {
            return null;
        }
        // 获取 bean 信息中的 className。
        String className = beanDefinition.getClassName();
        // 通过反射创建对象。
        Class<?> clazz = Class.forName(className);
        Object beanObj = clazz.newInstance();
        // 依赖注入。
        MutablePropertyValues beanDefinitionPropertyValues = beanDefinition.getPropertyValues();

        for (PropertyValue propertyValue : beanDefinitionPropertyValues) {

            // name 属性值。
            String propertyName = propertyValue.getName();
            // value 属性。
            String value = propertyValue.getValue();
            // ref 属性。
            String ref = propertyValue.getRef();

            if (ref != null && !"".equals(ref)) {
                // 获取依赖的 bean 对象。递归。
                Object bean = getBean(ref);
                // 拼接方法名。
                String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);
                // 获取所有的方法对象。
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if (method.getName().equals(methodName)) {
                        // 执行该 setter 方法。
                        method.invoke(beanObj, bean);
                    }
                }
            }

            if (value != null && !"".equals(value)) {
                // 拼接方法名。
                String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);
                // 获取 Method 对象。
                Method method = clazz.getMethod(methodName, String.class);
                method.invoke(beanObj, value);
            }
        }
        // 在返回 BeanObj 对象之前，将该对象存储到 map 容器中。
        this.singletonObjectMap.put(name, beanObj);
        return beanObj;
    }

    /**
     * 根据 bean 对象的名称获取 bean 对象，并进行类型转换。
     *
     * @param name
     * @param clazz
     * @param <T>
     * @return
     * @throws ClassNotFoundException
     * @throws InvocationTargetException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws NoSuchMethodException
     */
    @Override
    public <T> T getBean(String name, Class<? extends T> clazz) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {

        Object beanObj = getBean(name);
        if (beanObj != null) {
            // 类型强转。
            return clazz.cast(beanObj);
        }
        return null;
    }

}

7.4.5 自定义 Spring IoC 总结。

7.4.5.1 使用到的设计模式。

  • 工厂模式。
    工厂模式 + 配置文件的方式。

  • 单例模式。
    Spring IoC 管理的 bean 对象都是单例的，此处的单例不是通过构造器进行单例的控制的，而是 Spring 框架对每一个 bean 只创建了一个对象。

  • 模板方法模式。
    AbstractApplicationContext 类中的 finishBeanInitialization(); 方法调用了子类的 getBean(); 方法，因为 getBean(); 的实现和环境息息相关。

  • 迭代器模式。
    对于 MutablePropertyValues 类定义使用到了迭代器模式，因为此类存储并管理 PropertyValue 对象，也属于一个容器，所以给该容器提供一个遍历方式。

Spring 框架其实使用到了很多设计模式，如 AOP 使用到了代理模式，选择 JDK 代理或者 CGLIB 代理使用到了策略模式，还有适配器模式，装饰者模式，观察者模式等。


7.4.5.2 符合大部分设计原则。
7.4.5.3 整个设计和 Spring 的设计还是有一定的出入。

spring 框架底层是很复杂的，进行了很深入的封装，并对外提供了很好的扩展性。而我们自定义 SpringIoC 有以下几个目的。

  • 了解 Spring 底层对对象的大体管理机制。

  • 了解设计模式在具体的开发中的使用。

  • 以后学习 Spring 源码，通过该案例的实现，可以降低 Spring 学习的入门成本。

lyfGeek
关注
专栏目录
设计模式在Spring框架中的应用汇总
08-25
设计模式在 Spring 框架中的应用汇总 设计模式是一种软件设计的解决方案，它可以使得我们的代码更加可维护、可扩展和可重用。在 Spring 框架中，设计模式被广泛应用于解决复杂的软件问题。本文将详细介绍在 Spring ...
54-Spring设计模式之装饰器模式1
08-08
Spring 设计模式之装饰器模式详解 在软件设计中，经常会遇到需要在不修改原有代码的情况下，添加新的功能或行为。这时，装饰器模式便可以发挥其作用。在 Spring 设计模式中，装饰器模式是非常重要的一种设计模式。 ...
深入挖掘Spring系列 -- 从设计模式角度看Spring
Danny_idea的博客
06-04 388
Spring的生态演进变化 Spring是一款伟大的框架产品，在发展过程中一直都是靠一家叫做Pivotal的技术公司在背后支撑。Spring真正流行的时间是在2007年11月份，发布了2.5版本的时候。 Spring Source 在3.0升级为了后续的发展所以拆分为了Spring Framework4.0 发布于2013年，随后Spring Boot发布于2014年，和传统的Spring Framework有所不同，SpringBoot是一款完全独立的产品路线，很多设计都是在为了简化对于Spring.
Spring中所使用的设计模式
张维鹏的博客
01-14 4万+
Spring是一个非常优秀的开源框架，项目源码中所使用的设计模式随处可见，这篇文章主要记录一下Spring中常见的设计模式： （1）工厂模式：Spring使用工厂模式，通过BeanFactory和ApplicationContext来创建对象 （2）单例模式：Bean默认为单例模式 （3）策略模式：例如Resource的实现类，针对不同的资源文件，实现了不同方式的资源获取策略 （4）代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术 （5）模板方法：可以将相同部分
Spring Boot 常用设计模式
萧曳丶
08-06 1366
在Spring Boot中，常用的设计模式多种多样，这些设计模式不仅帮助维护了代码的清晰度和灵活性，还使得框架易于扩展和维护。
Spring(22) Spring中的9种设计模式
ACGkaka的博客
03-04 2705
Spring(22) Spring中的9种设计模式
spring源码中使用了哪些设计模式？
宽带你的世界
05-07 1319
Spring的Resource接口和它的实现类（如ClassPathResource，FileSystemResource）展示了桥接模式，将资源的抽象与资源的实现分离。例如，PlatformTransactionManager接口和它的实现类如DataSourceTransactionManager，根据事务的不同状态来执行相应的操作。Spring MVC的HandlerAdapter接口和它的实现类，如RequestMappingHandlerAdapter，封装了控制器处理请求的具体逻辑。
Spring中用到的设计模式
wdquan19851029的专栏
04-17 3260
1.模板模式 Spring IOC容器的初始化过程->AbstractApplicationContext.java抽象类 -> refresh()方法，就是一个模板方法
java Spring中使用到的设计模式
weixin_49131718的博客
07-11 2593
这种方式同样使用了classLoader机制来保证初始化instace时只有一个线程，它跟第三种方式不同的是：第3种方式只要Singleton类被装载了，那么instance就会被实例化，而这种方式是Singleton类被撞在了，instance不一定被初始化。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式地指定它们的类，每个生成的工厂都能按照工厂模式提供对象。
Spring中常见的设计模式
Ling的博客
02-19 3055
Spring中常见的设计模式 1、Java设计模式 设计模式（Design Pattern）是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。 早在1995 年，GOF合作出版了《设计模式：可复用面向对象软件的基础》一书，共收录了 23 种设计模式，人称「GoF设计模式」。 这 23 种设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性，以及类的关联关系和组合关系的充分理解。 当然，软件设计模式只是
设计模式23模式介绍
热门推荐
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
Spring中有哪些设计模式
快乐江小鱼的博客
11-15 1640
本文介绍了几种在Spring中使用的设计模式
Spring中的设计模式
01-31
应该说设计模式是我们在写代码时候的一种被承认的较好的模式。好的设计模式就像是给代码造了一个...下面来简单列举Spring中的设计模式：又叫做静态工厂方法（StaticFactoryMethod）模式，但不属于23种GOF设计模式之一。
design-patterns-spring-boot：Spring引导中的设计模式
01-30
该存储库是一个简单的spring boot应用程序，演示了一些设计模式： 辛格尔顿 控制者 厂 战略 代理 观察者 面向方面的编程 该演示应用程序从2个不同的银行的网站（可以添加更多的银行）中检索联系电话，每个银行都有...
第四章：Spring AOP API 设计模式1
08-03
【Spring AOP设计模式】是Spring框架中面向切面编程的重要组成部分，它允许开发者通过分离关注点来解耦代码，实现灵活的模块化设计。在本章中，我们将探讨17种设计模式在Spring AOP中的应用和实现，以及它们如何帮助...
第三章 SpringBoot项目构建 - 整合Spring Security入门
想做一个小孩的杨先生的博客
09-11 612
Spring Security 是一个强大的框架，用于保护基于 Spring 的应用程序。它提供了全面的认证和授权功能，使得安全机制与应用逻辑相分离。以下是 Spring Security 的基本使用指南，包括如何集成 Spring Security、定义用户角色和权限、以及自定义安全配置。在 Java 生态中，目前有 Spring Security 和 Apache Shiro 两个安全框架，可以完成认证和授权的功能。
Spring Framework 学习总结博客
最新发布
2302_80084329的博客
09-13 1066
通过本文的学习，我们从Spring的核心架构入手，逐步理解了IoC和DI的概念，并通过代码示例掌握了如何在实际项目中使用这些技术。Spring通过IoC容器管理bean，依赖注入将bean之间的关系解耦，大大简化了复杂系统的开发过程。这些基本的Spring知识是理解其高级特性（如AOP、事务管理）的基础，掌握这些概念后，我们可以更加自如地使用Spring构建复杂的企业级应用。
基于spring的博客系统（总）
2202_76101487的博客
09-12 1400
本文写了基于spring mvc创建的博客系统；
SpringCloud gateway
c1tenj2的博客
09-11 1106
由此案例，我们可以感受到gateway带给我们的方便。有了gateway，前端就只需要请求8080端口，以模块进行路径的书写，就能访问所有的后端接口了，同时gateway也解决了跨域的问题。
深入理解Spring MVC设计模式及其应用
"本文将对Spring MVC设计模式的理念进行深入解析，探讨其在软件开发中的应用和重要性。" Spring MVC是Spring框架的一部分，它遵循MVC（Model-View-Controller）设计模式，该模式在Web应用开发中广泛应用，旨在提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lyfGeek

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值