模拟Spring的简单实现

项目结构如下：

如何思考？面向抽象编程？
先来看看一个序列图

从以上看出了什么？初学的，能看得出是什么才怪，那不管它了。看看具体实现吧

首先要建立一个实体类：user,放在model包下

package com.wwj.model; 
 
/** 
 * 实体类 
 * @author wwj 
 * spring 
 */ 
public class user { 
  private string username; 
  private string password; 
   
  public string getusername() { 
    return username; 
  } 
  public void setusername(string username) { 
    this.username = username; 
  } 
  public string getpassword() { 
    return password; 
  } 
  public void setpassword(string password) { 
    this.password = password; 
  } 
} 

下面就是叫你如何面向抽象编程，简单来说如何面向接口编程，下面定义一个接口

package com.wwj.dao; 
 
import com.wwj.model.user; 
 
/** 
 * 面向抽象编程 
 * @author wwj 
 * 优点：增加了灵活性 
 */ 
public interface userdao { 
  public void save(user user); 
} 

可以很清楚看到，这个接口声明了一个方法，save方法，里面有一个参数user对象，我们可以想到它是可以用来保存user对象到数据库里去的。

把具体实现交给实现类

package com.wwj.dao.impl; 
 
import com.wwj.dao.userdao; 
import com.wwj.model.user; 
 
/** 
 * 接口实现类 
 * @author wwj 
 * 
 */ 
public class userdaoimpl implements userdao{ 
 
  @override 
  public void save(user user) { 
    system.out.println("save user"); 
  } 
   
} 

这样做的好处是，如果你要更换数据库环境，你就能灵活定义不同的数据库代码了。
怎么调用以上的方法，为了使业务逻辑和数据库操作分离开，我们需要定义一个业务逻辑类

package com.wwj.service; 
 
import com.wwj.dao.userdao; 
import com.wwj.dao.impl.userdaoimpl; 
import com.wwj.model.user; 
 
/** 
 * 服务类，实现业务逻辑 
 * @author wwj 
 * 
 */ 
public class userservice { 
  private userdao userdao; 
   
  public userdao getuserdao() { 
    return userdao; 
  } 
 
  public void setuserdao(userdao userdao) { 
    this.userdao = userdao; 
  } 
 
  public void add(user user) { 
    this.userdao.save(user); 
  } 
} 

我们可以看到，上面有一个东西，东西？userdao啊，看到它的作用了没有，看到才怪。这里设计到一个ioc也叫做di的概念，中文意思叫做依赖注入，也叫控制反转，这在spring是一个很重要的概念，要把它弄懂，才能很好的理解spring的原理。

下面真正模拟spring的实现，有点像工厂模式，利用spring，我们可以把不同对象装配在一起使用。
先看一下配置文件beans.xml

<beans> 
  <bean id="u" class="com.wwj.dao.impl.userdaoimpl" /> 
  <bean id="userservice" class="com.wwj.service.userservice" > 
    <property name="userdao" bean="u"/> 
  </bean> 
</beans> 

一个工厂方法

package com.wwj.spring; 
 
public interface beanfactory { 
  public object getbean(string name); 
} 

一个解析xml文件的类，并实现beanfactory

package com.wwj.spring; 
 
import java.lang.reflect.method; 
import java.util.hashmap; 
import java.util.list; 
import java.util.map; 
 
import org.jdom.document; 
import org.jdom.element; 
import org.jdom.input.saxbuilder; 
 
public class classpathxmlapplicationcontext implements beanfactory{ 
  //定义一个容器，用来存放对象 
  private map<string,object> beans = new hashmap<string, object>(); 
   
   
  public classpathxmlapplicationcontext() throws exception{ 
    saxbuilder sb = new saxbuilder(); 
    document doc = sb.build(this.getclass().getclassloader().getresourceasstream("beans.xml")); 
    element root = doc.getrootelement();  //获取根结点 
    list list = root.getchildren("bean");  //取名为bean的所有元素 
    for(int i = 0; i < list.size(); i++) { 
      element element = (element) list.get(i); 
      string id = element.getattributevalue("id");  //取id值 
      string cla = element.getattributevalue("class"); //取class值 
      object o = class.forname(cla).newinstance(); 
      system.out.println(id); 
      system.out.println(cla); 
      beans.put(id,o); 
       
      for(element propertyelement : (list<element>)element.getchildren("property")){ 
        string name = propertyelement.getattributevalue("name");  //userdao 
        string bean = propertyelement.getattributevalue("bean");  //u 
        object beanobject = beans.get(bean);//userdaoimpl instance 
         
        //拼凑方法名，实现setuserdao方法 
        string methodname = "set" + name.substring(0, 1).touppercase() + name.substring(1); 
        system.out.println("method name = " + methodname); 
         
        //利用反射机制获取方法对象 
        method m = o.getclass().getmethod(methodname, beanobject.getclass().getinterfaces()[0]); 
        m.invoke(o, beanobject);  //调用方法 
      } 
       
    } 
     
  } 
 
 
  @override 
  public object getbean(string name) { 
    return beans.get("id"); 
  } 
 
} 

来一个测试类

package com.wwj.service; 
 
import org.junit.test; 
 
import com.wwj.model.user; 
import com.wwj.spring.beanfactory; 
import com.wwj.spring.classpathxmlapplicationcontext; 
 
/** 
 * 单元测试类 
 * @author wwj 
 * 
 */ 
public class userservicetest { 
   
  @test 
  public void testadd() throws exception{ 
    beanfactory beanfactory = new classpathxmlapplicationcontext(); 
     
    userservice service =(userservice)beanfactory.getbean("userservice"); 
    user u = new user(); 
    service.add(u); 
  } 
   
} 

从测试类我们可以看出点端倪了，首先定义一个beanfactory对象，通过这个对象调换用其getbean的方法，获取业务逻辑类对象，后面就可以通过调用这个服务类的add方法把user对象添加到数据库中去。当然这里没有实现插入数据库，只是简单的实现了测试。其实整个过程很明了的，spring的核心配置文件，将对象控制起来了，当要使用的时候就将对象注入到服务类当中去，服务类就可以利用dao层的对象，进行数据库相关的操作。

以上就是整理的网上关于spring配置内容，希望可以对大家有所帮助。