mybatis-java-依赖注入

第一种  setXXX形式的注入

我们的所有dao都会继承自定义的BaseDao，因此在BaseDao中完成对所有dao的注入

   在DaoUtil中增加方法injectDao()来注入具体的dao

package com.yangwei.shop.util;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

import com.yangwei.shop.dao.IDaoFactory;

/**dao工具类，主要使用反射机制*/
public class DaoUtil {

    /**
     * 思路：获取自己的所有方法，在判断是否有setXXX方法，如果有就对这个方法进行对象注入
     */
    public static void injectDao(Object obj){
        try {
            //1,获取自己定义的所有方法
            Method[] methods=obj.getClass().getDeclaredMethods();
            for(Method method:methods){
                //获取方法名
                String mn=method.getName();
                //2,查找set方法  
                if(mn.startsWith("set")){
                    //比如 setUserDao
                    mn=mn.substring(3);
                    mn=mn.substring(0, 1).toLowerCase()+mn.substring(1);
                    //3,从我们定义的工厂中获取dao对象
                    Object o=DaoUtil.createDaoFactory().getDao(mn);
                    //4，利用反射调用方法注入
                    //method是setXXX方法，调用者是this，参数是工厂取的具体dao对象
                    method.invoke(obj, o);
                }
            }
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    public static IDaoFactory createDaoFactory(){
        
        Properties prop = PropertiesUtil.getDaoProp();
        
        try {
            
            Class clz=Class.forName((String)prop.get("factory"));
            String mm="getInstance";
            
            Method method=clz.getMethod(mm);
            //调用静态方法   使用类来调用
            return (IDaoFactory)method.invoke(clz);    
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        return null;
    }
    
  }

在BaseDao类中增加构造来调用injectDao方法，目的是继承BaseDao的具体Dao内部可能有其它dao需要使用，完成注入

    public BaseDao(){
        DaoUtil.injectDao(this);
    }

写一个基础测试类，完成对测试类中所有setXXX的注入，其实这里针对的是Dao的注入

package com.yangwei.shop.test;

import com.yangwei.shop.util.DaoUtil;

public class BaseTest {

    public BaseTest(){
        DaoUtil.injectDao(this);
    }
}

每一个测试类继承BaseDao即可，写上get set方法即可，对用到的dao进行注入

package com.yangwei.shop.test;

import org.junit.Test;

import com.yangwei.shop.dao.UserDao;

public class TestInject extends BaseTest{

    /**
     * 测试set形式的依赖注入
     */
    
    private UserDao userDao=null;
    
    @Test
    public void testSetDao(){
        System.out.println(userDao);
    }

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    
}

第二种  annotation形式的注入

  自定义注解类

package com.yangwei.shop.entity;

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

/**
 * 用这个annotation标注需要进行依赖注入的方法
 * @ShopDi("userDao"),说明需要注入userDao对象
 * 如果是@ShopDi就规定使用setXXX注入
 *
 */
//必须让它在运行时能够执行
@Retention(RetentionPolicy.RUNTIME)
public @interface ShopDi {

    
    /**
     * value是Annotation的默认属性，在定义的时候可以不用vaule=""定义，而是直接通过
     * @ShopDi("XXX")
     * 特别注意，当需要定义两个以上的属性时，默认属性就不起作用了，此时需要如下形式定义
     * @ShopDi(value="XXX",abc="YYY")
     */
    String value() default "";
}

在DaoUtil中增加方法injectDao1()来注入具体的dao

/**
     * 使用注解的形式，完成对Dao对象的注入
     * @param obj
     */
    public static void injectDao1(Object obj){
        
        try {
            //针对属性的注解
            Field[] fields=obj.getClass().getDeclaredFields();
            for(Field field:fields){
                //有ShopDi的注解的属性
                if(field.isAnnotationPresent(ShopDi.class)){
                    ShopDi shopDi=field.getAnnotation(ShopDi.class);
                    String value=shopDi.value();
                    if(value==null || "".equals(value.trim())){
                        //为空时，使用属性名称
                        value=field.getName();
                    }
                    Object o=DaoUtil.createDaoFactory().getDao(value);
                    //当属性被private修饰时，一定要设置可访问为true
                    field.setAccessible(true);
                    field.set(obj, o);
                }
            }
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        
    }

基础测试类中，调用刚刚写的方法

package com.yangwei.shop.test;

import com.yangwei.shop.util.DaoUtil;

public class BaseTest {

    public BaseTest(){
        DaoUtil.injectDao(this);
    }
}

具体的测试类继承BaseTest类，对需要注入dao的属性添加自定义注解

package com.yangwei.shop.test;
import org.junit.Test;

import com.yangwei.shop.dao.UserDao;
import com.yangwei.shop.entity.ShopDi;

public class TestAnnotation extends BaseTest{

    
    @ShopDi("userDao")
    private UserDao userDao;
    
    
    @Test
    public void abc(){
        System.out.println(userDao);
    }  
    
}