模拟Spring的简单实现

  • Z时代
  • 2024-01-10
  • 分类：IT

项目结构如下：

如何思考？面向抽象编程？

先来看看一个序列图

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

首先要建立一个实体类：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配置内容，希望可以对大家有所帮助。

以上是 模拟Spring的简单实现 的全部内容， 来源链接： utcz.com/p/208561.html

回到顶部