服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|

服务器之家 - 编程语言 - JAVA教程 - 模拟Spring的简单实现

模拟Spring的简单实现

2020-01-09 14:24IT_xiao小巫 JAVA教程

本文的主要内容就是学习Spring的开端,模拟一下Spring的实现,感兴趣的小伙伴可以参考一下

项目结构如下:

模拟Spring的简单实现

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

模拟Spring的简单实现

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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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;
  }
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
package com.wwj.dao;
 
import com.wwj.model.User;
 
/**
 * 面向抽象编程
 * @author wwj
 * 优点:增加了灵活性
 */
public interface UserDAO {
  public void save(User user);
}

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

把具体实现交给实现类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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");
  }
   
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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

?
1
2
3
4
5
6
<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>

一个工厂方法

?
1
2
3
4
5
package com.wwj.spring;
 
public interface BeanFactory {
  public Object getBean(String name);
}

一个解析xml文件的类,并实现BeanFactory

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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");
  }
 
}

来一个测试类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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配置内容,希望可以对大家有所帮助。

延伸 · 阅读

精彩推荐