这里使用到的反射是模拟Spring框架的自动装配这一个功能,在我们没有学习Spring框架的时候,或没学反射机制的时候,通常我们创建一个类的实例都是通过new关键字来实例化一个类的,后来我们则陆续的学了java的反射机制,通过反射机制也可以实例化一个类,但是每次都要写一堆的代码,相对与来说是痛苦的,而后来我们有学习了Spring框架,它里面的依赖注入,则使用了Java的反射机制,通过配置文件,就可以实现类的实例化。
下面我们就自己模拟Spring的依赖注入这一个功能来实现,真正的Spring框架的依赖注入当然没我这个简单,这个我只是把反射机制巩固一下,方便以后使用
当然这些说的都是我自己瞎掰的,说错了的地方或写错了的地方,还请多多指教。
这个例子的步骤
1、创建一个Java项目
2、创建所需要的类
3、创建一个xml文件
第一步就免了
2、这里我创建的类有Users.java、UsersDao.java、UsersDaoImpl.java、UsersService.java、UsersServiceImpl.java、BeanFactory.java、ClassPathXmlApplicationContext.java
代码加上:
Users.java
package com.tenghu.spring.model;
public class Users {
//编号
private int id;
//姓名
private String name;
//年龄
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
UsersDao.java---接口
package com.tenghu.spring.dao;
import com.tenghu.spring.model.Users;
public interface UsersDao {
public void addUsers(Users user);
}
UsersDaoImpl.java
package com.tenghu.spring.dao.impl;
import com.tenghu.spring.dao.UsersDao;
import com.tenghu.spring.model.Users;
public class UsersDaoImpl implements UsersDao{
@Override
public void addUsers(Users user) {
System.out.println("添加成功");
}
}
UsersService.java
package com.tenghu.spring.service;
import com.tenghu.spring.model.Users;
public interface UsersService {
public void addUsers(Users user);
}
UsersServiceImpl.java
package com.tenghu.spring.service.impl;
import com.tenghu.spring.dao.UsersDao;
import com.tenghu.spring.model.Users;
import com.tenghu.spring.service.UsersService;
public class UsersServiceImpl implements UsersService{
private UsersDao userDao;
public UsersDao getUserDao() {
return userDao;
}
public void setUserDao(UsersDao userDao) {
this.userDao = userDao;
}
@Override
public void addUsers(Users user) {
userDao.addUsers(user);
}
}
BeanFactory.java
package com.tenghu.spring.spring;
public interface BeanFactory {
//根据名称获取对象
public Object getBean(String name);
}
ClassPathXmlApplicationContext.java
package com.tenghu.spring.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;
import com.tenghu.spring.test.Test;
public class ClassPathXmlApplicationContext implements BeanFactory {
//创建Map集合
private Map<String, Object> bean=new HashMap<String, Object>();
public ClassPathXmlApplicationContext() {
try {
//创建SAXBuilde对象
SAXBuilder builder = new SAXBuilder();
//获取文档对象
Document doc = builder.build(Test.class.getClassLoader()
.getResourceAsStream("myApplicationContext.xml"));
// 获取根节点
Element ele = doc.getRootElement();
// 获取子节点
List list = ele.getChildren("bean");
for (int i = 0; i < list.size(); i++) {
Element child = (Element) list.get(i);
String id = child.getAttributeValue("id");
String clazz = child.getAttributeValue("class");
//通过反射获取对象
Object o=Class.forName(clazz).newInstance();
//添加到集合中
bean.put(id, o);
for(Element childElement:(List<Element>)child.getChildren("property")){
//获取参数
String name=childElement.getAttributeValue("name");
String ref=childElement.getAttributeValue("ref");
//获取对象
Object obj=bean.get(ref);
//拼接set方法
String methodName="set"+name.substring(0,1).toUpperCase()+name.substring(1);
//反射获取方法
Method m=o.getClass().getDeclaredMethod(methodName, obj.getClass().getInterfaces()[0]);
m.invoke(o, obj);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public Object getBean(String name) {
return bean.get(name);
}
}
3、创建xml文件
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="ud" class="com.tenghu.spring.dao.impl.UsersDaoImpl"/>
<bean id="userServiceImpl" class="com.tenghu.spring.service.impl.UsersServiceImpl">
<property name="userDao" ref="ud"/>
</bean>
</beans>
测试
package com.tenghu.spring.test;
import com.tenghu.spring.model.Users;
import com.tenghu.spring.service.UsersService;
import com.tenghu.spring.spring.BeanFactory;
import com.tenghu.spring.spring.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
//创建ClassPathXmlApplicationPath对象
BeanFactory factory=new ClassPathXmlApplicationContext();
Users user=new Users();
user.setId(1);
user.setName("李四");
user.setAge(23);
UsersService us=(UsersService) factory.getBean("userServiceImpl");
us.addUsers(user);
}
}
这样整个功能就算是实现了
分享到:
相关推荐
通过反射创建带有泛型参数的类 1.Limin.Reflector.DLL中的BaseDal.cs里包含要创建的带泛型参数的类 2.Limin.Reflector.Invoke中的Factory.cs完成泛型类的创建 代码写的不是很好,不足之处,请多多指教
“反射”其实就是利用程序集的元数据信息。 反射可以有很多方法,编写程序时请先导入 System.Reflection 命名... // 创建类的实例 2、若要反射当前项目中的类(即当前项目已经引用它了)可以为: Assembly assembly
C__利用反射动态编译代码,创建类的实例,并调用其成员
反射和泛型是一种重要的解决途径。 此代码是一个生成泛型对象的类。 比如: Pool<Point> pool = new Pool(){}; Point p = pool.get(x, y); //在此构造Point对象 ... pool.put(p); 希望能帮助那些为查找泛型构造器、...
C#,利用反射动态创建对象 C#,利用反射动态创建对象 C#,利用反射动态创建对象 C#,利用反射动态创建对象
反射的原理,反射创建类实例的三种方式是什么反射机制:在通常情况下,如果有一个类,可以通过类创建对象;(2)类.class:需要输入一个明确的类Class cla
使用单例,工厂,函数指针实现的反射,减少了分支语句,次方法可以动态创建类实例,减少了工厂类里面的分支语句(工厂类完成后基本不需要修改,就可以随意创建想要的类的实例)。
利用Type动态创建类实例(C#反射)可以演变抽象工厂
2.3.2 通过反射创建类对象 2.3.3 通过反射获取类属性、方法、构造器(初步) 三 反射小结 3.1 小结 3.2 反射中类加载器、构造器、Method、Field的进阶操作 3.2.1 对类加载器的操作: 3.2.2 对构造器的操作: ...
在软件开发尤其是框架和底层开发时,为了更灵活的控制代码,常常需要进行一些动态的操作。比如根据用户的输入等动态的调用类中的方法或者根据数据库表结构、用户要求动态的生成一些类,然后再动态的调用类中的方法。
1、 使用反射方法强制创建某各类或者接口对应的java.lang.Class对象时,会进行类加载,(而类加载会将字节码的class文件读入内存,并为之创建一个Class对象)。 2、 反射让类加载了,当然接着可以调用类的属性和方法...
主要介绍了java使用反射创建并操作对象的方法,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
下面通过实例代码给大家介绍Tomcat解析XML和反射创建对象原理,具体代码如下所示: import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.List; import org....
反射是指程序在运行时动态获取对象属性与...简单一点说,就是可以通过类名称来创建一个类对象,这在Java和Object-C中是原生支持的,所以实现起来非常简单,但是C++就不支持了,如果想要用到反射机制,那就得自己实现。
类的反射机制 自己遇到的一个知识点 通过代理创建出一个类 执行类的方法
根据网上例子,自己做了一个例子,内容包括: 1.使用winform按钮事件,反射dll中函数调用; 2.codeDOM创建动态类整个过程 3.类中包括函数和属性; 4.反射dll,并获取方法。
C#实现根据实体类反射自动创建增,删,改,查相关功能,采用xml形式存储数据
Java中,反射是一种强大的工具。...反射允许我们在编写与执行时,使我们的程序代码能够接入装载到JVM中的类的内 部信息,而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。