项目结构如下:
如何思考?面向抽象编程?
先来看看一个序列图
从以上看出了什么?初学的,能看得出是什么才怪,那不管它了。看看具体实现吧
首先要建立一个实体类: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配置内容,希望可以对大家有所帮助。