模仿Spring实现注解注入

写这个极其蛋疼，我一直在想我们用SSM写项目时，写Service和Controller的时候，会给Service和Controller私有属性，比如Service需要dao，Controller需要Service，但是我们没有写过setter方法，而且也没有写带参构造器。那么它是怎么注入的呢？

我绞尽脑汁，用了Field类的 set（Object,Object）办法，发现不能对private修饰的私有属性进行注入，其实我已经很接近答案了。但是！我辗转了一个晚上，才知道setAccessible（boolean）这个方法可以强行干进去。。。

不说了，一会儿还要睡觉，直接上代码。我用的是注解注入的，而且稍微修改了昨晚mapper的代码，最后目录被我改成这样了。。。

把昨晚的DaoProxy改成了DaoFactory。我其实是想写工厂模式的，但是我没有这个经验，现在先把基础功能写起来，后面再看看设计模式改造一下吧。。。

下面这些接受困难的可以先移步

模仿Mybatis用mapper.xml实现Dao层接口的功能

最后DaoProxy被我改成了这样。。。暴露出来的getBean方法里的参数是在xml文件中读取的。。。

package com.yck.yebatis;

import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.yck.bean.Function;
import com.yck.bean.MapperBean;
import com.yck.exception.NoConfigFileException;
import com.yck.util.DataUtil;

public class DaoFactory implements BeanFactory
{

    private static Map<String,Object> beans;

    static
    {
        configDao();
    }

    @Override
    public Object getBean(String beanName) //暴露获取Bean的方法
    {
        return beans.get(beanName);
    }

    private static void configDao() //初始化
    {
        Map<String,Object> map = new HashMap<String,Object>();
        try
        {
            File[] files = getAllFiles();
            for(File f:files)
            {
                MapperBean mapper = readMapper(f.getPath());
                Object obj = implDao(mapper);
                map.put(mapper.getProxyName(), obj);
            }
        } catch (NoConfigFileException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        beans = map;
    }

    /**
     * 得到所有的mapper.xml文件
     * @return
     * @throws NoConfigFileException
     */
    private static File[] getAllFiles() throws NoConfigFileException
    {
        File configPath = new File("src/mapper"); //为了简单起见，规定写在该目录下
        FileFilter fileFilter = new FileFilter()  //写过滤器，筛选后缀为.xml的文件
        {

            @Override
            public boolean accept(File pathname)
            {
                String str = pathname.getName().toLowerCase();
                if(str.endsWith(".xml"))
                    return true;
                return false;
            }
        };

        File[] files = configPath.listFiles(fileFilter);
        if(files == null || files.length == 0)  //如果没有这样的文件，抛出异常
        {
            files = null;
            throw new NoConfigFileException();
        }
        return files;
    }

    /**
     * 通过读取配置文件实现dao接口
     * @param path
     * @return
     */
    private  static Object implDao(MapperBean mapper)
    {
        ClassLoader classLoader = DaoFactory.class.getClassLoader();
        Class<?> interfaze = null;
        try
        {
            interfaze = classLoader.loadClass(mapper.getInterfaceName()); //加载一个接口类
        } catch (ClassNotFoundException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        /**
         * 下面这几句相当重要了，是用xml文件实现dao接口的核心代码，因为数据库相关的大量工作我之前都写过了，所以这个看起来代码量很少
         * 我也不太懂下面这个东西，我查API查了相当久，一开始写总是错，因为我理解错了InvocationHandler接口下那个方法的Object数组参数
         * 它应该理解为一个可变长数组，而不是必须为数组
         */
        Object instanze = Proxy.newProxyInstance(classLoader, new Class[]{interfaze}, new InvocationHandler(){

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
            {
                List<Function> list = mapper.getList();
                Object obj = null;
                for(Function f:list)
                {
                    if(f.getFuncName().equals(method.getName()))
                    {
                        /**
                         * 判断是不是select语句，是则调用DateUtil的select方法
                         * 否则调用update的方法
                         */
                        if(f.getSqltype().equals("select"))
                        {
                            if("java.util.ArrayList".equals(f.getResultType()))
                            {
                                if(f.isParameter())
                                    obj = DataUtil.selectForBeanList(Class.forName(f.getResultOf()), f.getSql(), args);
                                else obj = DataUtil.selectForBeanList(Class.forName(f.getResultOf()), f.getSql());
                            }
                            else
                            {
                                if(f.isParameter())
                                    obj = DataUtil.selectForBean(Class.forName(f.getResultType()), f.getSql(), args);
                                else obj = DataUtil.selectForBean(Class.forName(f.getResultType()), f.getSql());
                            }

                        }

                        else
                        {
                            if(f.isParameter())
                                obj = DataUtil.updata(f.getSql(), args);
                            else obj = DataUtil.updata(f.getSql());
                        }
                    }
                }
                return obj;
            }
        });
        return instanze;
        //返回这个接口，即mapper.getInterfaceName()这个接口

    }

    /**
     * 读取xml文件的信息
     * @param path
     * @return
     */
    private static MapperBean readMapper(String path)
    {
        File file = new File(path);
        SAXReader reader = new SAXReader();
        MapperBean mapper = new MapperBean();
        try
        {
            Document doc = reader.read(file);
            Element root = doc.getRootElement(); //读取根节点 即dao节点
            mapper.setInterfaceName(root.attributeValue("class").trim()); //把dao节点的class值存为接口名
            mapper.setProxyName(root.attributeValue("id").trim());       //把id值设为代理名
            List<Function> list = new ArrayList<Function>(); //用来存储方法的List
            for(Iterator<?> rootIter = root.elementIterator();rootIter.hasNext();) //遍历根节点下所有子节点
            {
                Function fun = new Function();    //用来存储一条方法的信息
                Element e = (Element) rootIter.next();
                String sqltype = e.getName().trim();
                String funcName = e.attributeValue("id").trim();
                String sql = e.getText().trim();
                String resultType = e.attributeValue("resultType").trim();
                String resultOf = "";
                if("java.util.ArrayList".equals(resultType))
                    resultOf = e.attributeValue("resultOf").trim();
                String parameter = e.attributeValue("parameter");
                fun.setSqltype(sqltype);
                fun.setFuncName(funcName);
                fun.setResultType(resultType);
                fun.setSql(sql);
                fun.setResultOf(resultOf);
                fun.setParameter("true".equals(parameter));
                list.add(fun);
            }
            mapper.setList(list);

        } catch (DocumentException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return mapper;
    }

下面写ServiceFactory我自己写了个注解

package com.yck.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SelfInject
{
    String value();

}

在Service类中使用了这个注解

package com.yck.service;

import com.yck.annotation.SelfInject;
import com.yck.bean.User;
import com.yck.dao.IUserDao;

public class UserService
{
    @SelfInject(value="userdao")
    private IUserDao userdao;

    public User find(Integer id)
    {
        return userdao.selectById(id);
    }

}

下面是ServiceFactory，先贴配置文件

<?xml version="1.0" encoding="UTF-8"?>
<services>
    <service id="userService" class="com.yck.service.UserService"/>
</services>
package com.yck.yebatis;

import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.yck.annotation.SelfInject;
import com.yck.bean.ServiceBean;

public class ServiceFactory implements BeanFactory
{
    private static DaoFactory daoFactory = new DaoFactory();
    private static Map<String,Object> beans;

    static
    {
        configService();
    }

    /**
     * 暴露获取方法
     */
    @Override
    public Object getBean(String beanName)
    {
        return beans.get(beanName);
    }

    /**
     * 静态初始化方法
     */
    private static void configService()
    {
        Map<String,Object> map = new HashMap<String,Object>();
        List<ServiceBean> list= getServiceBeans();
        for(ServiceBean service:list)
        {
            map.put(service.getProxyName(), implService(service));
        }
        beans = map;
    }

    /**
     * 读取所有的Service配置
     * @return
     */
    private static List<ServiceBean> getServiceBeans()
    {
        SAXReader reader = new SAXReader();
        List<ServiceBean> list = new ArrayList<ServiceBean>();
        try
        {
            Document doc = reader.read(new File("src/service/service.xml"));
            Element root = doc.getRootElement();
            for(Iterator<?> iter = root.elementIterator("service");iter.hasNext();)
            {
                Element e = (Element) iter.next();
                String proxyName = e.attributeValue("id");
                String className = e.attributeValue("class");
                ServiceBean bean = new ServiceBean(proxyName, className);
                list.add(bean);

            }
        } catch (DocumentException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return list;

    }

    /**
     * 实例化Service并注入所需依赖
     * @param service
     * @return
     */
    public static Object implService(ServiceBean service)
    {
        Object obj = null;
        try
        {
            obj = Class.forName(service.getClassName()).newInstance();
            Class<?> c = obj.getClass();
            Field[] fields = c.getDeclaredFields();
            for(Field f:fields)
            {
                Annotation[] annotations = f.getAnnotations();
                for(Annotation a:annotations)
                {
                    if(a instanceof SelfInject)
                    {
                        Object o = daoFactory.getBean(((SelfInject) a).value());
                        try
                        {
                            f.setAccessible(true);
                            f.set(obj,o);
                            f.setAccessible(false);
                        } catch (IllegalArgumentException | IllegalAccessException e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            }

        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return obj;
    }
}

最后测试有没有注入

package com.yck.test;

import com.yck.bean.User;
import com.yck.dao.IUserDao;
import com.yck.service.UserService;
import com.yck.yebatis.DaoFactory;
import com.yck.yebatis.ServiceFactory;

public class Test2
{

    public static void main(String[] args)
    {
        DaoFactory bf = new DaoFactory();
        IUserDao userdao = (IUserDao) bf.getBean("userdao");
        User u = userdao.selectById(2);
        System.out.println(u);

        ServiceFactory sf = new ServiceFactory();
        UserService userService = (UserService) sf.getBean("userService");
        User us = userService.find(2);

        System.out.println(us);

    }

}

最后查出结果，说明已经通过注解注入了

以上内容都是原创，如果转载请标注并标明来源于

大王让我写代码：http://www.cnblogs.com/yeyeck/p/7468644.html

时间： 2024-10-05 06:40:29

模仿Spring实现注解注入的相关文章

Spring通过注解注入组件的方法

组件声明 在类上声明 @Component.@Configuration.@RestController.@Service.@Repository 等注解,表示这个类需要被注入IoC容器. 1.@Configuration 和 @Bean @Configuration 常用来和 @Bean 配合使用,来注入第三方组件. 例子:注入 Druid 数据源 @Configuration public class DruidConfig { @Bean @ConfigurationProperties(

注解学习(模仿springMvc的注解注入方式)

最近在看springMvc的源码,看到了该框架的注入注解的部分觉的有点吃力,可能还是对注解的方面的知识还认识的不够深刻,所以特意去学习注解方面的知识.由于本人也是抱着学习的态度来阅读源码,若文章在表述和代码方面如有不妥之处,欢迎批评指正.留下你的脚印,欢迎评论!希望能互相学习. 1,首先定义三个常用的注解Service,Autowired,Contrller:(主要的解释都在代码中有,在这里就不多陈述) Service: package com.lishun.Annotation; import

Spring 使用注解注入 学习（四）

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/sch

利用反射实现简单的Spring注解注入实例

一时兴起,这两天看了看Spring的源代码,就想写一个简单的Spring利用注解注入!!Spring的注解注入方式给了我们很方便的好处!大家应该都了解Spring的注入原理,在这里写下一个非常简单的使用注解来注入的实例,做个小小的笔记! 要使用注解,那就绝对和反射离不开.摘抄一段 Reflection是Java 程序开发语言的特征之一,它允许运行中的 Java 程序对自身进行检查,或者说"自审",并能直接操作程序的内部属性.例如,使用它能获得 Java 类中各成员的名称并显示出来. J

Spring使用注解方式注入多例的方式

目前Spring+Netty的开发方式这么火热,想把Netty注册成Spring组件就一定得用多例的方式,我不由得想吐槽明明这么常见的需求网上相关博客都少的很,这里给出Spring使用注解注入多例的方式: 在需要多例调用的类上加@Scope("prototype") 在进行注入时,不能直接使用@Autowired,否则注入的还是单例,需要使用工厂,最简单的是用 @Autowired private ObjectFactory<T> objectFactory; 对象进行注入

spring使用注解进行DI（依赖）注入

使用@Resource: 使用方法: 1.在spring的配置文件中导入命名空间 xmlns:context="http://www.springframework.org/schema/context" http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd 2.引入注解解析器 <context:annot

Spring AOP注解通过@Autowired，@Resource，@Qualifier，@PostConstruct，@PreDestroy注入属性的配置文件详解

原创整理不易,转载请注明出处:Spring AOP注解通过@Autowired,@Resource,@Qualifier,@PostConstruct,@PreDestroy注入属性的配置文件详解 代码下载地址:http://www.zuidaima.com/share/1772661373422592.htm 本文介绍了使用Spring注解注入属性的方法.使用注解以前,注入属性通过类以及配置文件来实现.现在,注入属性可以通过引入@Autowired注解,或者@Resource,@Qualifi

spring注解注入:&lt;context:component-scan&gt;详解（转）

spring从2.5版本开始支持注解注入,注解注入可以省去很多的xml配置工作.由于注解是写入java代码中的,所以注解注入会失去一定的灵活性,我们要根据需要来选择是否启用注解注入. 我们首先看一个注解注入的实际例子,然后再详细介绍context:component-scan的使用. 如果你已经在用spring mvc的注解配置,那么你一定已经在使用注解注入了,本文不会涉及到spring mvc,我们用一个简单的例子来说明问题. 本例中我们会定义如下类: PersonService类,给上层提供

spring 四种依赖注入方式以及注解注入方式

平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化, 而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中.依赖注入的另一种说法是“控制反转”,通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员, 而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做. spring有多种依赖注