欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

模拟Spring的简单实现

程序员文章站 2024-03-07 10:25:03
项目结构如下: 如何思考?面向抽象编程? 先来看看一个序列图 从以上看出了什么?初学的,能看得出是什么才怪,那不管它了。看看具体实现吧 首先要建立一个实体类...

项目结构如下:

模拟Spring的简单实现

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

模拟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配置内容,希望可以对大家有所帮助。