模拟spring

实体类:

 1 package com.bxw.po;
 2
 3 public class User {
 4     private String username;    //账号
 5     private String password;    //密码
 6     public String getUsername() {
 7         return username;
 8     }
 9     public void setUsername(String username) {
10         this.username = username;
11     }
12     public String getPassword() {
13         return password;
14     }
15     public void setPassword(String password) {
16         this.password = password;
17     }
18
19
20 }

user

DAO:

1 package com.bxw.dao;
2
3 import com.bxw.po.User;
4
5 public interface UserDao {
6     public void save(User u);
7 }

UserDao.java

Dao实现:

 1 package com.bxw.dao.impl;
 2
 3 import com.bxw.dao.UserDao;
 4 import com.bxw.po.User;
 5
 6 public class UserDaoImpl implements UserDao {
 7     public void save(User u){
 8         System.out.println("user saved");
 9     }
10 }

UserDaoImpl

Service:

 1 package com.bxw.service;
 2
 3 import com.bxw.dao.UserDao;
 4 import com.bxw.dao.impl.UserDaoImpl;
 5 import com.bxw.po.User;
 6
 7 public class UserService {
 8     private UserDao userDao = new UserDaoImpl();
 9
10     public UserDao getUserDao() {
11         return userDao;
12     }
13
14     public void setUserDao(UserDao userDao) {
15         this.userDao = userDao;
16     }
17
18
19     public void add(User u){
20         this.userDao.save(u);
21     }
22
23 }

UserService

配置文件:

1 <beans>
2     <bean id="userDao" class="com.bxw.dao.impl.UserDaoImpl" />
3     <bean id="userService" class="com.bxw.service.UserService">
4         <property name="userDao" bean="userDao" />
5     </bean>
6 </beans>

beans.xml

BeanFactory:

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

BeanFactory.java

ClassPathXMLApplicationContext:(需要jdom.jar)

 1 package com.bxw.spring;
 2
 3 import java.lang.reflect.Method;
 4 import java.util.HashMap;
 5 import java.util.List;
 6 import java.util.Map;
 7
 8 import org.jdom.Document;
 9 import org.jdom.Element;
10 import org.jdom.input.SAXBuilder;
11
12 public class ClassPathXMLApplicationContext implements BeanFactory{
13     private Map<String, Object> beans = new HashMap<String, Object>();
14
15     public ClassPathXMLApplicationContext() throws Exception{
16         SAXBuilder sb = new SAXBuilder();
17         Document doc = sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml"));
18         Element root = doc.getRootElement();    //获取根元素
19         List<Element> list = root.getChildren("bean");
20         for(int i=0;i<list.size();i++){
21             Element element = (Element)list.get(i);
22             String id = element.getAttributeValue("id");    //属性id
23             String cls = element.getAttributeValue("class");//class
24             System.out.println(id+" "+cls);
25             Object obj = Class.forName(cls).newInstance();//反射拿到类
26             beans.put(id, obj);
27             for(Element propertyElement:(List<Element>)element.getChildren("property")){
28                 String name = propertyElement.getAttributeValue("name");    //userDao
29                 String bean = propertyElement.getAttributeValue("bean");    //userDao
30                 Object beanObject = beans.get(bean);
31                 String methodName = "set"+name.substring(0,1).toUpperCase()+name.substring(1);    //得到setUserDao方法
32                 System.out.println(methodName);
33
34                 Method m = obj.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
35                 m.invoke(obj, beanObject);
36             }
37         }
38     }
39     @Override
40     public Object getBean(String name) {
41         return beans.get(name);
42     }
43
44 }

ClassPathXMLApplicationContext.java

测试类:这里使用junit测试

 1 package com.bxw.test;
 2
 3 import static org.junit.Assert.*;
 4
 5 import org.jboss.weld.context.ApplicationContext;
 6 import org.junit.Test;
 7
 8 import com.bxw.dao.UserDao;
 9 import com.bxw.po.User;
10 import com.bxw.service.UserService;
11 import com.bxw.spring.BeanFactory;
12 import com.bxw.spring.ClassPathXMLApplicationContext;
13
14 public class UserServiceTest {
15
16     @Test
17     public void testAdd() throws Exception{
18         BeanFactory ac = new ClassPathXMLApplicationContext();    //初始化所有bean
19         UserService service = (UserService) ac.getBean("userService");    //拿到id为userService,依赖注入userDao
20         User u = new User();
21         service.add(u);
22     }
23 }

UserServiceTest.java

时间: 2024-08-05 08:00:48

模拟spring的相关文章

Java反射—模拟Spring的Aop

1.    大概流程 上篇文章已经结合Java反射解释了SpringAop的原理,这里我们简单模拟以下Spring的Aop实现.大体流程如下: ?  创建一个properties配置文件模拟Spring配置文件. ?  创建一个增强接口与一个实现类模拟Spring的Advice. ?  创建一个生成代理的工厂类,并在InvocationHandler类的invoke方法中织入增强方法(即aop). ?  创建一个生成Bean的工厂类(类似IOC工厂,只创建bean,没有依赖注入的功能),生成Be

Java 模拟Spring

一.概述 1.目标:模拟Spring的Ioc 2.用到的知识点:利用jdom的xpath读取xml文件,反射 二.有如下文件: 1.applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans> <bean id="vehicle" class="com.tong.spring.factory.Car"> </

Spring - 模拟Spring

这个是以前的笔记,现在整理到博客把 这篇博客主要的目的是要简单的理解Spring的实现过程,模拟了Spring的读取配置文件 用户管理 首先有一个类:User private String username; private String password; // get set - 面向接口(抽象)编程,灵活性就出来了,比如说,换数据库直接在有一个OracleImpl的实现类就可以了.然后使用接口new OracleImpl(). 添加对老师的管理等,就要添加一个TeacherService和

模拟spring注入

尊重原创:原创和源代码地址 项目中的的spring出现问题,不想使用spring框架进行注入,编写一个简单的spring,实现xml解析和类的注入.所有的框架都可以用java项目,用到了java提供的基础类,所以用到的原理也就呢么多(我刚开始工作2个月,说的不对请谅解).因此spring用到了注入用到java中的反射机制,aop用到了java的代理机制proxy对象.总结一下自己的设计: 设计范围三层: 第一层是实体层,根据自己定义的xml规则抽象除了两个对象实体,一个是实体对象bean(程序中

模拟spring - 动手写一个spring AOP

一.前言 AOP (Aspect Oriented Programing) - 面向切面编程,它主要用于日志记录.性能分析.安全控制.事务处理.异常处理等方面. AOP主要使用JDK的反射和动态代理,AOP代理其实是由AOP框架动态生成的一个对象,该对象可作为目标对象使用,AOP代理包含了目标对象的全部方法,但AOP代理的方法与目标对象的方法存在差异:AOP方法在特定切入点添加了增强处理,并回调了目标对象的方法. 动态代理的文章请参考:http://blog.csdn.net/zdp072/ar

容器学习(一):动手模拟spring的IoC

介绍 学习经典框架的实现原理以及设计模式在事实上际中的运用,是很有必要的,能够让我们更好进行面向对象. 本篇文章就来模拟Spring的IOC功能.明确原理后,能够更好的使用它,进而为进行面向对象提供一种思路. 点击下载源代码:下载 动手模拟IoC实现 首先我们把我们用的dao.service.entity定义出来: Student.java : package com.bzu.entity; public class Student { private int id; private Strin

Java反射机制详解(3) -java的反射和代理实现IOC模式 模拟spring

IOC(Inverse of Control) 可翻译为“控制反转”,但大多数人都习惯将它称为“依赖注入”.在Spring中,通过IOC可以将实现类.参数信息等配置在其对应的配置文件中,那么当 需要更改实现类或参数信息时,只需要修改配置文件即可,这种方法在上例的基础上更进一步的降低了类与类之间的耦合.我们还可以对某对象所需要的其它对象进 行注入,这种注入都是在配置文件中做的,Spring的IOC的实现原理利用的就是Java的反射机制, Spring还充当了工厂的角色,我们不需要自己建立工厂类.S

采用dom4j和反射模拟Spring框架的依赖注入功能

Spring的依赖注入是指将对象的创建权交给Spring框架,将对象所依赖的属性注入进来的行为.在学习了dom4j后,其实也可以利用dom4j和反射做一个小Demo模拟Spring框架的这种功能.下面是具体的步骤: 第一步,编写配置文件.配置文件的书写,采用了和Spring的配置文件applicationContext.xml一样的书写规则: <?xml version="1.0" encoding="UTF-8"?> <!-- applicati

java proxy InvocationHandler 模拟 spring aop

在学习spring的aop的时候,老师叫我们使用java的proxy和InvocationHandler来模拟spring的aop. 首先要了解什么是代理:所谓代理就是我想让小王去买包烟,但是我又不想直接通知小王,因为那样我感觉自己非常的掉价.所以我就叫小李去通知小王,让小王完成这件事.在这个过程中,我是一个主动方,小王是一个行为执行方,而小李就是一个代理.因为小李负责我和小王之间的关系,甚至小李也可以叫小王给自己再买一包烟(实际这就是动态代理的最大用处). 动态代理模式有代理对象,被代理对象.

Spring源码阅读:使用标准AOP的API模拟Spring AOP + AspectJ的设计与实现

在上一篇博客中,提到了标准AOP与Spring AOP.这一篇就来把他们模拟出来. 在模拟之前,还需要提及的是,在Spring框架中,对于AOP的支持: Spring 支持的AOP AspectJ是另外一个有名的AOP框架,Spring也集成AspectJ,同时Spring AOP与AspectJ有一定程度的集成,这样一来Spring中就支持两种AOP:1)Spring AOP.2)AspectJ.而使用AOP的方式却又三种: 1)完全使用Spring AOP 2)完全使用AspectJ(分为注