Spring Framework核心模块

	//缓存已检查过的成员变量
	private final Set<String> lookupMethodsChecked = Collections.newSetFromMap(new ConcurrentHashMap<>(256));

	//缓存类的候选构造函数
	private final Map<Class<?>, Constructor<?>[]> candidateConstructorsCache = new ConcurrentHashMap<>(256);

	//缓存类的依赖注入元数据
	private final Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap<>(256);


	public void processInjection(Object bean) throws BeanCreationException {
		Class<?> clazz = bean.getClass();
        //查找Bean中的包含@Autowire注解的字段、构造方法、方法
		InjectionMetadata metadata = findAutowiringMetadata(clazz.getName(), clazz, null);
		try {
			metadata.inject(bean, null, null);
		}
		catch (BeanCreationException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					"Injection of autowired dependencies failed for class [" + clazz + "]", ex);
		}
	}

	//遍历方法实现
	private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
		// Fall back to class name as cache key, for backwards compatibility with custom callers.
		String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
		// Quick check on the concurrent map first, with minimal locking.
		InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
		if (InjectionMetadata.needsRefresh(metadata, clazz)) {
			synchronized (this.injectionMetadataCache) {
				metadata = this.injectionMetadataCache.get(cacheKey);
				if (InjectionMetadata.needsRefresh(metadata, clazz)) {
					if (metadata != null) {
						metadata.clear(pvs);
					}
					metadata = buildAutowiringMetadata(clazz);
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
			}
		}
		return metadata;
	}

public class UserService {
    public void createUser(User user) {
        Logger.log("Creating user: " + user.getName());
        // 执行创建用户的逻辑
        Logger.log("User created: " + user.getName());
    }

    public void deleteUser(String userId) {
        Logger.log("Deleting user: " + userId);
        // 执行删除用户的逻辑
        Logger.log("User deleted: " + userId);
    }
}

public aspect LoggingAspect {
    before(): execution(public void UserService.*(..)) {
        Logger.log("Method execution started: " + thisJoinPoint.getSignature().getName());
    }

    after(): execution(public void UserService.*(..)) {
        Logger.log("Method execution completed: " + thisJoinPoint.getSignature().getName());
    }
}

public class UserService {
    public void createUser(User user) {
        // 执行创建用户的逻辑
    }

    public void deleteUser(String userId) {
        // 执行删除用户的逻辑
    }
}

	private final Set<Integer> registriesPostProcessed = new HashSet<>();

	private final Set<Integer> factoriesPostProcessed = new HashSet<>();

 	/**
	 * Prepare the Configuration classes for servicing bean requests at runtime
	 * by replacing them with CGLIB-enhanced subclasses.
	 */
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		int factoryId = System.identityHashCode(beanFactory);
		if (this.factoriesPostProcessed.contains(factoryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + beanFactory);
		}
		this.factoriesPostProcessed.add(factoryId);
		if (!this.registriesPostProcessed.contains(factoryId)) {
			// BeanDefinitionRegistryPostProcessor hook apparently not supported...
			// Simply call processConfigurationClasses lazily at this point then.
			processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
		}

		enhanceConfigurationClasses(beanFactory);
		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
	}

public class SpelTest {
    public static void main(String[] args) {
        SpelExpressionParser parser = new SpelExpressionParser();
        Expression exp = parser.parseExpression("'xxx'.concat('yyy')");
        String value = (String) exp.getValue();
        System.out.println(value);
        exp = parser.parseExpression("'xxx'.bytes");
        byte[] bytes = (byte[]) exp.getValue();
        exp = parser.parseExpression("'xxx'.bytes.length");
        Object expValue = exp.getValue();
        System.out.println("length: " + expValue);

        UserDto userDto = new UserDto();
        userDto.setUserName("test");
        userDto.setRoleNameZh("admin");
        userDto.setId(1);

        UserDto userDto2 = new UserDto();
        userDto2.setUserName(userDto.getUserName());

        //定义解析器
        ExpressionParser expressionParser = new SpelExpressionParser();
        //制定表达式
        Expression expression = expressionParser.parseExpression("userName");
        // 2 使用解析器解析表达式，获取对象的属性值
        String name = (String) expression.getValue(userDto2);
        //获取解析结果
        System.out.println(name);

        //使用解析器解析表达式，获取对象的属性值并进行运算
        Expression exp2 = expressionParser.parseExpression("userName == 'xxx'");
        // 3.1 获取解析结果
        boolean result = exp2.getValue(userDto2, Boolean.class);
        System.out.println(result);//true
    }
}