控制反转(Inversion of Control,英文缩写为IoC)是一个重要的面向对象编程的法则来削减计算机程序的耦合问题,也是轻量级的Spring框架的核心。
控制反转一般分为两种类型,依赖注入(Dependency Injection,简称DI)和依赖查找(Dependency Lookup)。
依赖注入应用比较广泛。本文介绍java实现一个简单的依赖注入
简单而言,当你在某一个类中需要调用其他的类并且生成对象,大部分情况是new一个对象,此时如果你不确定要new哪一个对象,你就需要为所有的类作if或者switch判断,在不同情况下new不同的对象,然后给他们属性赋值
使用最多的地方就是JavaBean类和他们的对象了,假设项目的Model里面有Teacher,StudentClass,分别代表老师和班级两个javaBean类
public classTeacher {privateString name;privateString id;publicString getName() {returnname;
}public voidsetName(String name) {this.name =name;
}publicString getId() {returnid;
}public voidsetId(String id) {this.id =id;
}
@OverridepublicString toString() {return "Teacher [name=" + name + ", id=" + id + "]";
}
}
Teacher.java
public classSchoolClass {privateString schoolClassName;privateString schoolClassId;privateTeacher manager;publicString getSchoolClassName() {returnschoolClassName;
}public voidsetSchoolClassName(String schoolClassName) {this.schoolClassName =schoolClassName;
}publicString getSchoolClassId() {returnschoolClassId;
}public voidsetSchoolClassId(String schoolClassId) {this.schoolClassId =schoolClassId;
}publicTeacher getManager() {returnmanager;
}public voidsetManager(Teacher manager) {this.manager =manager;
}
@OverridepublicString toString() {return "The manager of "+schoolClassName+"("+schoolClassId+")"+"is Teacher"+manager.toString();
}
SchoolClass
此时,我们有一个老师,两个班级,那么在实际使用中是不是就要new一个老师,然后使用getter,setter为他赋值属性,然后new两个班级,并且按照老师的做法赋值,这样如果有很多的老师和班级,那么就要不停的在java代码中new,new,new......
而且每次多一个老师,班级,我们就要修改java代码,重新编译,这样耦合度就很高,能不能使用一个工具类自动新建对象,而对象的信息保存在一个文本中
IoC的设计模式解决了这个问题,使用依赖注入,我们把类以及类相依赖的类放到动态修改的文本当中,每次从文本中读取,然后根据文本信息,动态的new出这些对象,做到灵活,多样化,易扩展。这样不在需要去修改或者添加java代码,代码重复性也减少。
看看设计图:
开始,新建一个web dynamic项目
目录结构如下:
其中两个javaBean放在app包中,确切说这是pojo类
ioc包里面是ioc核心控制器
test包是一个servlet,主要用于Ioc是否成功的测试
由于个人觉得xml文件的书写和读取,传输都不是很好,尤其在spring,struts的配置均采用xml,实在厌恶
之前在做php开发的时候,配置文件一般是json的格式或者php对象的格式(好吧,两者只是本质有区别,事实上形式相似)
所以,我这次异想天开的在自己的IoC中使用Json作为依赖注入的动态配置文件取代大部分框架使用的xml文件
如下:
[
{"bean": "cn.cslg.app.Teacher","id": "class_manager","properties": {"name": "黄有为","id": "200500027"}
},
{"bean": "cn.cslg.app.SchoolClass","id": "class1","properties": {"schoolClassId": "Z094141","schoolClassName": "软件工程"},"ref": {"manager": "class_manager"}
},
{"bean": "cn.cslg.app.SchoolClass","id": "class2","properties": {"schoolClassId": "Z094142","schoolClassName": "软件工程"},"ref": {"manager": "class_manager"}
}
]
IocListener代码如下:
packagecn.cslg.ioc;importjavax.servlet.ServletContext;importjavax.servlet.ServletContextEvent;importjavax.servlet.ServletContextListener;importjavax.servlet.annotation.WebListener;
@WebListenerpublic class IocListener implementsServletContextListener{private final String filename = "/WEB-INF/ioc.json";
@Overridepublic voidcontextInitialized(ServletContextEvent sce) {//TODO Auto-generated method stub
ServletContext context =sce.getServletContext();
String configFile= context.getInitParameter("ioc-config");
String path=context.getRealPath(filename);try{if (configFile != null) {
path=context.getRealPath(configFile);
}
ConfigParser parser= newConfigParser(path);
context.setAttribute("APPLICATION_CONTEXT_BEANS", parser.parse());
}catch(IocException e) {//TODO: handle exception
e.printStackTrace();
}
}
@Overridepublic voidcontextDestroyed(ServletContextEvent sce) {//TODO Auto-generated method stub
}
}
实现对servlet上下文的监听,主要是调用了ConfigParser创建对象并在servlet中增加了一个值
APPLICATION_CONTEXT_BEANS
将刚刚创建的beans对象保存在其中,以便servlet使用过程中使用
ConfigParser实现了控制反转的依赖注入,类构成如下:
类私有属性:
private HashMap beansMap = new HashMap<>();privateString jsonString;private String filename;
类构造方法:
publicConfigParser(String filename) {super();this.filename =filename;this.jsonString =ReadJsonFile(filename);
}
使用ReadJsonFile对json进行解析,返回json的字符串,交给jsonString
ReadJsonFile代码如下:
privateString ReadJsonFile(String path) {
File file= newFile(path);
BufferedReader reader= null;
String laststr= "";try{
reader= new BufferedReader(newFileReader(file));
String tempString= null;int line = 1;while ((tempString = reader.readLine()) != null) {
System.out.println("line " + line + ": " +tempString);
laststr= laststr +tempString;
line++;
}
reader.close();
}catch(IOException e) {
e.printStackTrace();
}finally{if (reader != null) {try{
reader.close();
}catch(IOException e1) {
}
}
}returnlaststr;
}
其中解析json(JsonArray,JsonObject)需要用到json-lib,javaBean是解析需要用到common-beanutils
请使用gradle或者手动导入这两个包,如使用gradle如下:
repositories {
mavenCentral()
jcenter()
maven { url"http://repo.spring.io/release"}
}
dependencies {
compile group:'net.sf.json-lib', name: 'json-lib', version: '2.4'compile group:'commons-beanutils', name: 'commons-beanutils', version: '1.9.3'compile group:'javax.servlet', name: 'javax.servlet-api', version: '3.1.0'testImplementation'junit:junit:4.12'}
View Code
instance方法,第一步“创建对象”,class.forname和class.newInstance是核心,有了他们实现了类->对象的创建
public void instantiate() throwsIocException {
JSONArray beans=(JSONArray) JSONArray.fromObject(jsonString);try{for (Iterator it =beans.iterator(); it.hasNext();) {
JSONObject bean=(JSONObject) it.next();
String className= (String) bean.get("bean");
String idName= (String) bean.get("id");
Object obj;
Class> class1 =Class.forName(className);
obj=class1.newInstance();
beansMap.put(idName, obj);
}
}catch(Exception e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}
injection方法,为instance创建的对象赋值属性,主要包括了普通值,引用值
public void injection() throwsIocException {
JSONArray beans=(JSONArray) JSONArray.fromObject(jsonString);try{for (Iterator it =beans.iterator(); it.hasNext();) {
JSONObject bean=(JSONObject) it.next();
String beanId= bean.get("id").toString();
Object beanObj=beansMap.get(beanId);if (beanObj != null) {
PropertyDescriptor pds[]=PropertyUtils.getPropertyDescriptors(beanObj);
JSONObject properties= (JSONObject) bean.get("properties");
JSONObject ref= (JSONObject) bean.get("ref");
Iterator keyIter;
String key;
String value;if (properties != null) {
keyIter=properties.keys();while(keyIter.hasNext()) {
key=(String) keyIter.next();for(PropertyDescriptor pd : pds) {if(pd.getName().equals(key)) {
value=properties.get(key).toString();if (value != null)
pd.getWriteMethod().invoke(beanObj, (Object) value);
}
}
}
}if (ref != null) {
keyIter =ref.keys();while(keyIter.hasNext()) {
key=keyIter.next().toString();for(PropertyDescriptor pd : pds) {if(pd.getName().equals(key)) {
value=ref.get(key).toString();if (value != null)
pd.getWriteMethod().invoke(beanObj, beansMap.get(value));
}
}
}
}
}
}
}catch(Exception e) {
e.printStackTrace();
}
}
注意在json中,配置了对象的赋值,properties是普通的属性值,可以int,String值。而ref则是引用值,引用了其他的对象,这里是Teacher对象,表示班级由某一个老师管理。注意处理时要区别对待
其中使用了两重循环迭代,第一重遍历bean对象是数组JsonArray,第二重遍历bean下的properties或者是ref是对象JsonObject,从json文件中不难看出其迭代结构
核心方法是invoke,替代了getter,setter,直接对对象的属性进行赋值(初始化),值从json文件的properties和ref中获取,并且一一对应的赋值
注意java中,json对象是不能直接转化为JavaBean对象的,需要对其一层层遍历手动赋值,php则可以直接将json转化为对象,因为php本身是动态语言!
最后,parse方法返回一个HashMap,存储了所有生成的JavaBean对象:
public HashMap parse() throwsIocException {
instantiate();
injection();returnbeansMap;
}
使用,servlet进行测试:
TestIocServlet.java的代码:
@WebServlet("/TestIocServlet")public class TestIocServlet extendsHttpServlet {private static final long serialVersionUID = 1L;
@Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throwsServletException, IOException {
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html");try (PrintWriter out =resp.getWriter()) {
@SuppressWarnings("unchecked")
HashMap beans = (HashMap) this.getServletContext()
.getAttribute("APPLICATION_CONTEXT_BEANS");
Set keys =beans.keySet();for(String key : keys) {
out.println(key+ ": " + beans.get(key) + "
");
}
}
}
}
View Code
启动tomcat运行servlet,浏览器效果如下:
很明显,已经实现了对文本json文件的动态对象生成和赋值,不需要在java文件中重复new对象并且赋值
对了,项目中有个异常处理文件,IocException.java如下:
public class IocException extendsException{publicIocException(Throwable cause){super(cause);
}
}