어노테이션 기반 DI 컨테이너 프레임워크 구현하기

public class UserController extends AbstractConntoller {
  private UserService userService = UserService.getInstance(UserDao.getInstance());

  // ...
}

public class UserService {
  private static UserService userService;

  private UserDao userDao = UserDao.getInstance();

  private UserService() {
  }

  private static UserService(UserDao userDao) {
    this.userDao = userDao;
  }

  public static UserService getInstance(UserDao userDao) {
    if(userService == null) {
      userService = new UserService(userDao);
    }
    return userService;
  }

  // ...
}

public class UserDao {
    private static UserDao userDao;
    private JdbcTemplate jdbcTemplate = JdbcTemplate.getInstance();

    private UserDao() {
    }

    public static UserDao getInstance() {
        if (userDao == null) {
            userDao = new UserDao();
        }
        return userDao;
    }

    public void insert(User user) {
        String sql = "INSERT INTO USERS VALUES (?, ?, ?, ?)";
        jdbcTemplate.update(sql, user.getUserId(), user.getPassword(), user.getName(), user.getEmail());
    }

    // ...

public interface UserDao {
  // ...
}

public class MockUserDao implements UserDao {
  private Map<Long, User> users = Maps.newHashMap(); // In-Memory DataBase

  @Override
  public void insert(User user) {
    users.put(user.getId(), user);
  }

  // ...
}

public class UserDaoTest {
  private UserService userService;
  private MockUserDao userDao;

  @Before
  public void setUp() {
    userDao = new UserDao();
    userService = UserService.getInstance(userDao);
  }

  @Test
  public void deleteUser() throws Exception {
    User user = new User();
    userDao.insert(user);
    userService.deleteUser();
  }
}

public class UserService {
  private UserDao userDao;

  public UserService(USerDao userDao) {
    this.userDao = userDao;
  }

  // ...
}

public class UserController extends AbstractController {
  private UserService userService;

  public UserController(UserService userService) {
    this.userService = userService;
  }

  // ...
}

public class LegacytHandlerMapping implements HandlerMapping {
  private Map<String, Controller> mappings = new HashMap<>();

  public void initMapping()
    UserDao userDao = new JdbcUserDao();
    UserService userService = new UserService(userDao);

    mappings.put("/user/signup", new SignUpController(userService));
    mappings.put("/user/login", new LoginController(userService));
    // ...
  }
}

public class BeanFactory {
    private static final Logger logger = LoggerFactory.getLogger(BeanFactory.class);

    private Set<Class<?>> preInstanticateBeans;

    private Map<Class<?>, Object> beans = Maps.newHashMap();

    public BeanFactory(Set<Class<?>> preInstanticateBeans) {
        this.preInstanticateBeans = preInstanticateBeans;
    }

    @SuppressWarnings("unchecked")
    public <T> T getBean(Class<T> requiredType) {
        return (T) beans.get(requiredType);
    }

    public void initialize() {
        for(Class<?> clazz : preInstanticateBeans) {
            if(beans.get(clazz) == null) {
                instantiateClass(clazz);
            }
        }
    }

    private Object instantiateClass(Class<?> clazz) {
        Object bean = beans.get(clazz);
        if(bean != null) {
            return bean;
        }

        Constructor<?> injectedConstructor = BeanFactoryUtils.getInjectedConstructor(clazz);
        if(injectedConstructor == null) {
            bean = BeanUtils.instantiate(clazz);
            beans.put(clazz, bean);
            return bean;
        }

        logger.debug("Constructor : {}", injectedConstructor);
        bean = instantiateConstructor(injectedConstructor);
        beans.put(clazz, bean);
        return bean;
    }

    private Object instantiateConstructor(Constructor<?> constructor) {
        Class<?>[] pTypes = constructor.getParameterTypes();
        List<Object> args = Lists.newArrayList();
        for(Class<?> clazz : pTypes) {
            Class<?> concreteClazz = BeanFactoryUtils.findConcreteClass(clazz, preInstanticateBeans);
            if(!preInstanticateBeans.contains(concreteClazz)) {
                throw new IllegalArgumentException(clazz + "는 Bean 이 아닙니다.");
            }

            Object bean = beans.get(concreteClazz);
            if(bean == null) {
                bean = instantiateClass(concreteClazz);
            }
            args.add(bean);
        }
        return BeanUtils.instantiateClass(constructor, args.toArray());
    }

    public Map<Class<?>, Object> getControllers() {
        Map<Class<?>, Object> controllers = Maps.newHashMap();
        for(Class<?> clazz : preInstanticateBeans) {
            Annotation annotation = clazz.getAnnotation(Configurable.class);
            if(annotation != null) {
                controllers.put(clazz, beans.get(clazz));
            }
        }
        return controllers;
    }
}

public class BeanScanner {
    private Reflections reflections;

    public BeanScanner(Object... basePackage) {
        reflections = new Reflections(basePackage);
    }

    @SuppressWarnings("unchecked")
    public Set<Class<?>> scan() {
        return getTypesAnnotatedWith(Controller.class, Service.class, Repository.class);
    }

    @SuppressWarnings("unchecked")
    private Set<Class<?>> getTypesAnnotatedWith(Class<? extends Annotation>... annotations) {
        Set<Class<?>> preInstantiatedBeans = Sets.newHashSet();
        for(Class<? extends Annotation> annotation : annotations) {
            preInstantiatedBeans.addAll(reflections.getTypesAnnotatedWith(annotation));
        }
        return preInstantiatedBeans;
    }
}

public class AnnotationHandlerMapping implements HandlerMapping {
    private static final Logger logger = LoggerFactory.getLogger(AnnotationHandlerMapping.class);

    private Object[] basePackage;

    private Map<HandlerKey, HandlerExecution> handlerExecutions = Maps.newHashMap();

    public AnnotationHandlerMapping(Object... basePackage) {
        this.basePackage = basePackage;
    }

    public void initialize() {
        BeanScanner scanner = new BeanScanner(basePackage);
        BeanFactory beanFactory = new BeanFactory(scanner.scan());
        beanFactory.initialize();
        Map<Class<?>, Object> controllers = beanFactory.getControllers();
        Set<Method> methods = getRequestMappingMethods(controllers.keySet());
        for (Method method : methods) {
            RequestMapping rm = method.getAnnotation(RequestMapping.class);
            logger.debug("register handlerExecution : url is {}, method is {}", rm.value(), method);
            handlerExecutions.put(createHandlerKey(rm),
                    new HandlerExecution(controllers.get(method.getDeclaringClass()), method));
        }

        logger.info("Initialized AnnotationHandlerMapping!");
    }

    private HandlerKey createHandlerKey(RequestMapping rm) {
        return new HandlerKey(rm.value(), rm.method());
    }

    @SuppressWarnings("unchecked")
    private Set<Method> getRequestMappingMethods(Set<Class<?>> controlleers) {
        Set<Method> requestMappingMethods = Sets.newHashSet();
        for (Class<?> clazz : controlleers) {
            requestMappingMethods
                    .addAll(ReflectionUtils.getAllMethods(clazz, ReflectionUtils.withAnnotation(RequestMapping.class)));
        }
        return requestMappingMethods;
    }

    @Override
    public HandlerExecution getHandler(HttpServletRequest request) {
        String requestUri = request.getRequestURI();
        RequestMethod rm = RequestMethod.valueOf(request.getMethod().toUpperCase());
        logger.debug("requestUri : {}, requestMethod : {}", requestUri, rm);
        return handlerExecutions.get(new HandlerKey(requestUri, rm));
    }
}

@Service
public class TestService {
  private TestRepository testRepository;

  @Inject
  public TestService(TestRepository testRepository) {
    this.testRepository = testRepository;
  }
  // ...
}

@Repository
public class TestRepository {
  // ...
}