TeaFramework——IOC容器实现（一）_tea component password-优快云博客

本文链接：https://blog.youkuaiyun.com/dong_lxkm/article/details/80575113

Spring的IOC/DI让层与层之间解耦，让接口和实现类不必强依赖，提高程序的扩展性和对需求的适应性。TeaFramework也提供了一个IOC容器，帮我们来生成实例，那么具体设计是什么样的呢？请往下看。

纯注解以其简单的优势迅速得到广大程序员的青睐，那么这里还是以注解的方式来标示bean和注入bean。TeaFramework中标示bean的注解有两种：@Component、@TeaDao。

@Component用于控制层和service层.

@TeaDao用于数据访问层

@Component包含两个属性，分别标示bean的name、生成对象的模式（单例、原型，默认是单例），代码如下：

@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {

	public String value() default "";

	public Scope scope() default Scope.singleton;
}

接下来是注入了，注入又分两种：ByName和ByType，那么注解里只需要一个参数即可搞定，当传入beanName时是按ByName注入，否则按ByType注入。

@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Inject {
	public String value() default "";
}

那么这样一来我们的代码变得很简洁，控制层代码可以这样写

@Component
public class UserController {

	@Inject
	private UserService userService;
}

service层代码可以这样写

@Component
public class UserServiceImpl implements UserService {
	@Inject
	private UserDao userDao;

	@Override
	public User addUser(User user) {
		userDao.addUser(user);
		return userDao.getUserById(user.getId());
	}

}

数据访问层代码可以这样写

@TeaDao
public interface UserDao {

	@GetPrimaryKey(sql = "select s_users.nextval from dual", primaryKeyProperty = "id")
	@SQL("insert into users(id,username,password) values(#id#,#username#,#password#)")
	public void addUser(User user);

	@SQL("select * from users where id=#id#")
	public User getUserById(Long id);
}

接下来看第二个问题，怎么把bean装进Bean容器呢？这里需要定义两个Map，一个是beanName和对象之间的映射，另一个是beanType和bean List的映射，具体代码如下：

public class BeanContainer {
	private static BeanContainer instance;

	private static Map<Class<?>, List<Object>> CLASS_BEAN_MAPPING = new ConcurrentHashMap<Class<?>, List<Object>>(200);

	private static Map<String, Object> NAME_BEAN_MAPPING = new ConcurrentHashMap<String, Object>(200);

	private BeanContainer() {
	}

	public synchronized static BeanContainer getInstance() {
		if (instance == null) {
			instance = new BeanContainer();
		}
		return instance;
	}

	public boolean contains(String beanName) {
		return NAME_BEAN_MAPPING.containsKey(beanName);
	}

	public void putBean(Class<?> beanClass, Object object) {
		if (CLASS_BEAN_MAPPING.get(beanClass) == null) {
			List<Object> list = new ArrayList<Object>();
			list.add(object);
			CLASS_BEAN_MAPPING.put(beanClass, list);
		} else {
			CLASS_BEAN_MAPPING.get(beanClass).add(object);
		}
	}

	public void putBean(String beanName, Object object) {
		NAME_BEAN_MAPPING.put(beanName, object);
	}

	public <T> T getBeanByName(String beanName) {
		return (T) NAME_BEAN_MAPPING.get(beanName);
	}

	public <T> List<T> getBeansByType(Class<?> beanClass) {
		return (List<T>) CLASS_BEAN_MAPPING.get(beanClass);
	}

	public void inject() {
		for (Map.Entry<String, Object> entry : NAME_BEAN_MAPPING.entrySet()) {
			injectProperties(entry.getValue());
		}
	}

	private void injectProperties(Object bean) {
		List<Field> result = new ArrayList<Field>();
		findAllField(bean.getClass(), result);
		for (Field field : result) {
			Inject inject = field.getAnnotation(Inject.class);
			if (inject != null) {
				field.setAccessible(true);
				Object object = null;
				if (!"".equals(inject.value())) {// id注入
					object = NAME_BEAN_MAPPING.get(inject.value());
					if (object == null) {
						throw new TeaInjectException("没找到beanName为" + inject.value() + "的Bean");
					}
				} else {
					List<Object> list = CLASS_BEAN_MAPPING.get(field.getGenericType());// 类型注入
					if (list == null || list.size() == 0) {
						throw new TeaInjectException("没找到类型为" + field.getGenericType().getTypeName() + "的Bean");
					} else if (list.size() > 1) {
						throw new TeaInjectException("存在多个类型为" + field.getGenericType().getTypeName() + "的Bean");
					}
					object = list.get(0);
				}
				if (object == null) {
					throw new TeaInjectException("没找到对应bean");
				}
				try {
					field.set(bean, object);
				} catch (Exception e) {
					throw new TeaInjectException(e);
				}
			}
		}
	}

	private void findAllField(Class<?> clazz, List<Field> result) {
		Field[] fields = clazz.getDeclaredFields();
		if (fields != null && fields.length > 0) {
			for (int i = 0; i < fields.length; i++) {
				result.add(fields[i]);
			}
		}
		Class<?> superclass = clazz.getSuperclass();
		if (superclass != null && !java.lang.Object.class.equals(superclass)) {
			findAllField(superclass, result);
		}
	}
}

上面有个重载的putBean方法，一个是把<beanName,对象>放进Map<String, Object>，另一个是对象按照类型映射到List，即Map<Class<?>, List<Object>>。

injectProperties则是注入属性的具体实现了，如果@Inject的value不为空串，则是根据beanName注入，否则则是根据type注入，ByType注入做了一个特殊处理，就是如果一个Type下有很多实例，拿第一个注入，这里有两个功能是没有实现的属性为集合时注入的场景、原型模式下产生实例的场景，后期可以补上。

这样就很简易了的实现了IOC容器和依赖注入，那么容器在启动时要扫描哪些包、对象是怎么实例化放进Map的？请关注TeaFramework——IOC容器实现（二）

项目地址：https://git.oschina.net/lxkm/teaframework
博客：https://blog.youkuaiyun.com/dong_lxkm