How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

What difficulty level is this coding question?

This is a medium difficulty Coding & Algorithms question, commonly asked during Technical Screen rounds at TikTok.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at TikTok during technical interviews.

Explain Java DI, AOP, and transactions

Quick Overview

This question evaluates understanding of Java framework internals and related competencies including dependency injection, aspect-oriented programming and proxy mechanisms, transaction management, annotation processing, bean lifecycle, classpath scanning, bean scopes, and circular dependency detection or resolution.

Company: TikTok

Role: Software Engineer

Category: Coding & Algorithms

Difficulty: medium

Interview Round: Technical Screen

Explain how dependency injection and AOP proxies are implemented in a modern Java framework such as Spring: bean lifecycle (creation, post-processing, initialization, destruction), proxy mechanisms (JDK dynamic proxies vs. CGLIB), transaction management via proxies, and annotation processing at runtime. Describe classpath scanning, bean scopes, and how circular dependencies are detected or resolved.

Quick Answer: This question evaluates understanding of Java framework internals and related competencies including dependency injection, aspect-oriented programming and proxy mechanisms, transaction management, annotation processing, bean lifecycle, classpath scanning, bean scopes, and circular dependency detection or resolution.

Modern Java frameworks such as Spring discover classes on the classpath, register beans, resolve dependencies, and wrap some beans in AOP proxies. In this problem, you will implement a simplified container startup simulator. You are given a list of discovered class definitions. Each definition is a tuple: (name, annotations, dependencies, injection_type, scope, has_interface, is_final) Rules: 1. Only classes whose annotations contain "component" are registered as beans. 2. A registered bean may depend only on other registered beans. 3. Bean creation must respect dependencies. 4. Circular dependencies are allowed only if every bean in the cycle uses setter injection and has singleton scope. 5. A bean annotated with "transactional" must be proxied: - Use "JDK" if has_interface is True - Otherwise use "CGLIB" if is_final is False - Otherwise startup fails because the bean is unproxyable 6. If startup succeeds, return the bean creation order and the proxy type for every registered bean. Failure priority: - First check for missing dependencies - Then check for unresolvable circular dependencies - Then check for unproxyable transactional beans For deterministic output: - If multiple beans have no remaining prerequisites, create the lexicographically smallest next - Inside a resolvable cycle, output bean names in lexicographical order - If multiple invalid cycles exist, report the lexicographically smallest sorted bean list

Constraints

1 <= number of discovered classes <= 10^5 in the general case, but your algorithm should be near-linear in the number of classes and dependencies
Class names are unique
Each dependency name is a string
annotations may include 'component' and/or 'transactional'
A cycle is resolvable only when every bean in that cycle has scope 'singleton' and injection_type 'setter'

Examples

Input: ([('Repo', ['component'], [], 'constructor', 'singleton', False, False), ('Service', ['component', 'transactional'], ['Repo'], 'constructor', 'singleton', True, False), ('IgnoredUtil', [], [], 'constructor', 'singleton', False, False)],)

Expected Output: {'status': 'OK', 'order': ['Repo', 'Service'], 'proxies': {'Repo': 'NONE', 'Service': 'JDK'}}

Explanation: Only Repo and Service are registered because IgnoredUtil is not a component. Service depends on Repo, so Repo is created first. Service is transactional and has an interface, so it uses a JDK proxy.

Input: ([('A', ['component'], ['B'], 'setter', 'singleton', False, False), ('B', ['component', 'transactional'], ['A'], 'setter', 'singleton', False, False), ('C', ['component'], ['A'], 'constructor', 'singleton', False, False)],)

Expected Output: {'status': 'OK', 'order': ['A', 'B', 'C'], 'proxies': {'A': 'NONE', 'B': 'CGLIB', 'C': 'NONE'}}

Explanation: A and B form a cycle, but it is allowed because both are singleton beans using setter injection. Their SCC is emitted in lexicographical order. B is transactional, has no interface, and is not final, so it uses CGLIB.

Input: ([('A', ['component'], ['B'], 'constructor', 'singleton', False, False), ('B', ['component'], ['A'], 'setter', 'singleton', False, False)],)

Expected Output: {'status': 'CIRCULAR', 'beans': ['A', 'B']}

Explanation: The cycle A <-> B is not resolvable because A uses constructor injection.

Input: ([('A', ['component'], ['B'], 'constructor', 'singleton', False, False), ('B', [], [], 'constructor', 'singleton', False, False)],)

Expected Output: {'status': 'MISSING_DEPENDENCY', 'bean': 'A', 'dependency': 'B'}

Explanation: B exists in the discovered class list but is not a component, so it is not registered as a bean. A therefore has a missing dependency.

Input: ([('FinalService', ['component', 'transactional'], [], 'constructor', 'singleton', False, True)],)

Expected Output: {'status': 'UNPROXYABLE', 'bean': 'FinalService'}

Explanation: FinalService is transactional, has no interface, and is final. It cannot be proxied with JDK proxies or CGLIB.

Input: ([],)

Expected Output: {'status': 'OK', 'order': [], 'proxies': {}}

Explanation: With no discovered classes, startup succeeds trivially with no beans.

Hints

Model beans and dependencies as a directed graph. Strongly connected components help identify cycles.
After collapsing each strongly connected component into one node, the remaining graph is a DAG that can be topologically sorted.

Quick Overview