Class<?> clazz = bean.getClass();
// 扫描所有字段
for (Field field : clazz.getDeclaredFields()) {
if (!field.isAnnotationPresent(Autowired.class)) {
continue;
}
// 根据类型从容器中查找Bean
Object dependency = getBean(field.getType());
if (dependency == null) {
throw new BeanNotFoundException("找不到依赖: " + field.getType());
}
// 通过反射设置字段值
field.setAccessible(true);
// 如果目标类实现了接口，目标类实现的接口数量大于0
if (interfaces.length > 0) {
// 使用JDK动态代理创建代理对象
return Proxy.newProxyInstance(
// 指定类加载器，用于加载动态生成的代理类
classLoader,
// 代理类需要实现的接口数组，代理对象需要实现接口的所有方法
interfaces,
// 创建调用处理器，将目标对象和切面列表传入
// AopInvocationHandler负责处理方法调用时的切面逻辑
new AopInvocationHandler(target, aspects)
);
}
// 如果目标类没有接口，创建CGLIB增强器对象，用于生成代理类
Enhancer enhancer = new Enhancer();
// 设置要继承的父类（目标类），CGLIB通过继承方式创建代理
enhancer.setSuperclass(targetClass);
// 设置方法拦截器，将目标对象和切面列表传入
// AopMethodInterceptor负责在方法调用前后执行切面逻辑
enhancer.setCallback(new AopMethodInterceptor(target, aspects));
// 创建并返回代理对象
public class DispatcherServlet extends HttpServlet {
protected void service(HttpServletRequest req, HttpServletResponse resp) {
// 1. 获取请求路径
String uri = req.getRequestURI();
// 2. 查找处理器
HandlerMethod handler = getHandler(uri);
// 3. 解析参数
Object[] args = resolveArguments(handler, req, resp);
// 4. 调用Controller方法
Object result = handler.invoke(args);
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
conn = getConnection(); // 1. 获取连接
stmt = prepareStatement(sql); // 2. 创建语句
setParameters(stmt, args); // 3. 设置参数
rs = stmt.executeQuery(); // 4. 执行查询
return mapper.mapRow(rs, 0); // 5. 映射结果（你只需要关心这一步）
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
closeResources(rs, stmt, conn); // 6. 关闭资源
Class<?> clazz = Class.forName("com.example.UserService");
if (clazz.isAnnotationPresent(Service.class)) {
// 这是一个Service，注册为Bean
}
// 扫描字段上的注解
for (Field field : clazz.getDeclaredFields()) {
if (field.isAnnotationPresent(Autowired.class)) {
// 这个字段需要依赖注入
Constructor<?> constructor = clazz.getDeclaredConstructor();
Object bean = constructor.newInstance();ttzb.gs.cn
// 2. 通过反射设置字段值
Field field = clazz.getDeclaredField("userDao");
field.setAccessible(true);
field.set(bean, userDaoBean);
// 3. 通过反射调用方法
Method method = clazz.getDeclaredMethod("registerUser", User.class);
method.invoke(bean, user);
private Map<Class<?>, Constructor<?>> constructorCache = new ConcurrentHashMap<>();
public Object createBean(Class<?> clazz) {
Constructor<?> constructor = constructorCache.computeIfAbsent(clazz, c -> {
return c.getDeclaredConstructor();
private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
// ✗ 不推荐：Hashtable（方法级锁，性能差）
private Map<String, Object> singletonObjects = new Hashtable<>();
// ✗ 不推荐：synchronized包装（同样是粗粒度锁）
private Map<String, Object> singletonObjects =sky-sports.cn
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
// 三级缓存机制（解决循环依赖的核心）
// 一级缓存：完整初始化的Bean对象（依赖注入完成、初始化方法执行完成）
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
// 二级缓存：早期Bean引用（已实例化但未完成依赖注入，可能是代理对象）
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();
// 三级缓存：ObjectFactory工厂对象（关键！延迟生成早期引用，支持AOP提前代理）
private final Map<String, ObjectFactory<?>> singletonFactories = new ConcurrentHashMap<>();
// 正在创建的Bean集合（用于检测和处理循环依赖）
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>());
// Bean后处理器列表（支持生命周期扩展）
private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<>();
// 构造器缓存（性能优化，避免重复反射）
private final Map<Class<?>, Constructor<?>> constructorCache = new ConcurrentHashMap<>();
public SpringWindApplicationContext(Class<?> configClass) {
scanComponents(configClass); // 1. 扫描组件
createSingletonBeans(); // 2. 创建单例Bean
dependencyInjection(); // 3. 依赖注入
invokeInitMethods(); // 4. 执行初始化方法（已在getBean中完成，保留兼容）
Object bean = singletonObjects.get(beanName);
if (bean != null) {
return bean;
}
// 2. 检查循环依赖：如果当前Bean正在创建中
if (singletonsCurrentlyInCreation.contains(beanName)) {
// 先从二级缓存获取早期对象
bean = earlySingletonObjects.get(beanName);
if (bean != null) {
return bean;
}
// 如果二级缓存没有，尝试从三级缓存获取ObjectFactory
ObjectFactory<?> factory = singletonFactories.get(beanName);
if (factory != null) {
// 调用ObjectFactory获取早期对象，并放入二级缓存
bean = factory.getObject(); // 此处关键！可能创建AOP代理
earlySingletonObjects.put(beanName, bean);
singletonFactories.remove(beanName);
return bean;
}
}
// 3. 标记为正在创建
singletonsCurrentlyInCreation.add(beanName);
try {
// 4. 实例化
bean = createBeanInstance(beanDefinition.getBeanClass());
// 5. 放入三级缓存（ObjectFactory，支持AOP提前创建代理）
final Object rawBean huluzhibo.cn= bean;
singletonFactories.put(beanName, () -> getEarlyBeanReference(beanName, rawBean));
// 6. 依赖注入（可能触发循环依赖）
doDependencyInjection(bean);
// 7. 前置处理器
bean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
// 8. @PostConstruct初始化方法
if (beanDefinition.getInitMethod() != null) {
beanDefinition.getInitMethod().invoke(bean);
}
// 9. 后置处理器（AOP通常在这里发生）
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
// 10. 放入一级缓存（完全初始化好的Bean）
singletonObjects.put(beanName, bean);
// 11. 清理二级缓存和三级缓存
earlySingletonObjects.remove(beanName);
singletonFactories.remove(beanName);
// 在Bean早期引用被获取时调用（循环依赖场景）
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
// 如果Bean需要AOP代理，在这里提前创建
if (shouldProxy(bean)) {
return createProxy(bean); // 创建代理对象
}
return bean; // 不需要代理，返回原始对象
}
// 在Bean初始化后调用（正常场景）
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
// 如果已经在getEarlyBeanReference中创建了代理，这里跳过
if (已经创建过代理) {
return bean;
}
// 否则在这里创建代理
if (shouldProxy(bean)) {
List<AspectInfo> matchedAspects = findMatchedAspects(target.getClass());
if (matchedAspects.isEmpty()) {
return target; ttkq.com.cn // 没有切面，返回原始对象
}
// 如果实现了接口，使用JDK动态代理
Class<?>[] interfaces = target.getClass().getInterfaces();
if (interfaces.length > 0) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
interfaces,
new AopInvocationHandler(target, matchedAspects)
);
}
// 否则使用CGLIB代理
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(new AopMethodInterceptor(target, matchedAspects));
return enhancer.create();
}
PreparedStatement stmt = null;
ResultSet rs = null;
try {
conn = getConnection(ttkq.mo.cn); // 固定步骤1
stmt = prepareStatement(sql); // 固定步骤2
setParameters(stmt, args); // 固定步骤3
rs = stmt.executeQuery(); // 固定步骤4
return mapResults(rs, mapper); // 可变步骤（回调）
} catch (SQLException e) {
public Object createBean(Class<?> clazz) {
Constructor<?> constructor = constructorCache.computeIfAbsent(clazz, c -> {
try {
return c.getDeclaredConstructor();
} catch (NoSuchMethodException e) {
throw new BeanCreationException("找不到无参构造器", e);
}
private final Map<String, Pattern> patternCache = new ConcurrentHashMap<>();
public boolean matches(String pointcut, String methodName) {
Pattern pattern = patternCache.computeIfAbsent(pointcut, p -> {
String regex =ttkq-163.com pointcut.replace("*", ".*").replace(".", "\\.");
return Pattern.compile(regex);
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@RequestMapping("/list")
@ResponseBody
public List<User> list(ttkq-24.com) {
return userService.getAllUsers();
}
@RequestMapping("/get")
@ResponseBody chengyiwl.com
public User getUser(@RequestParam("id") Long id) {
return userService.getUserById(id);
}
@RequestMapping("/create")
@ResponseBody
public User createUser(@RequestBody User user) {
return userService.createUser(user);
}
}
来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/70048957/viewspace-3108994/ ，如需转载，请注明出处，否则将追究法律责任。
