@TOC

前言

上一篇点击查看使用xml来实现自定义IOC以及依赖注入关系维护,动态代理,以及事务操作;

这次使用注解来实现IOC以及依赖关系维护

步骤以及思路分析

基于xml实现方式时,仅仅只需要在xml里面配置好bean的id以及bean的权限定命名,然后反射实例化对象,最后加入到ioc容器中
依赖注入时候仅仅需要获取property标签以及父级标签,根据property名从ioc容器中获取到需要注入的bean示例即可;

如果是基于注解实现呢!

• 1 首先需要自定义注解
• 2 如何获取自定义到的注解
• 3 实例化打了注解的实例
• 4 在指定bean成员变量上是否包含需要注入的注解,然后依赖注入
• 5 生成代理对象,基于接口判断是否选择JDK动态代理或者CGLIB代理

代码实现

首先自定义注解

实例bean的注解 @Repository 和@Service

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {
    String value() default "";
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Repository {
    String value() default "";
}

自动装配的注解

@Target({ ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    String name() default "";
}

事务注解 Transactional

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Transactional {
}

然后 在类上标注注解,以及依赖注入

在这里插入图片描述

事务注解以及DI 以及Bean自动装配

在这里插入图片描述

项目结构

在这里插入图片描述

配置信息

版本 JDK8 , tomcat 7 , IDEA 2019 03

所需依赖

    <!-- servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    
    <!--引入cglib依赖包-->
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.1_2</version>
    </dependency>

tomcat插件

   <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>8080</port>
          <path>/</path>
        </configuration>
      </plugin>

这里我们使用一个StartApplication类来表示当前的顶级包下的启动类,相当于SpringBoot里的Main方法所在的类(目的仅仅是指定包,也可以在xml里面配置包名)

在Web.xml里面进行配置一下这个启动类

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
    <display-name>tomcat启动时候启动IOC容器</display-name>
    <listener>
        <!-- 启动容器-->
        <!--      注解实现-->
        <listener-class>com.udeam.edu.factory.impl.AnnotationBeanFactory</listener-class>
        <!--    xml实现ioc-->
        <!--    <listener-class>com.udeam.edu.factory.impl.ClassPathXmlBeanFactory</listener-class>-->
    </listener>
</web-app>

定义BeanFactory接口类

/**
 * 底层BeanFactory工厂接口
 * @author Pilgrim
 */
public interface BeanFactory {

    /**
     * 存储bean单例
     */
    public final static Map<String, Object> IOC_MAP = new HashMap<>();


    /**
     * 对外提供获取bean接口
     *
     * @param id
     * @return bean对象
     */
    public Object getBean(String id);


    /**
     * 根据类型对外提供获取bean示例
     *
     * @param classz
     * @return bean
     */
    public Object getBean(Class<?> classz);

    /**
     * 获取容器中所有的bean名字
     *
     * @return
     */
    public Object getAllBeanName();
}

抽象类AbstractBeanFactory扩展一些属性

public abstract class AbstractBeanFactory implements BeanFactory {

    /**
     * 存储bean单例
     */
    public final static Map<String, Object> IOC_MAP = new HashMap<>();

    /**
     * 容器执行一次 标识
     */
    public static boolean isTag = false;

    public static final String CLASS_STR = ".class";

}

然后编写bean工厂实现类AnnotationBeanFactory

定义初始化方法

initBeanFactory(String packageName);

初始化方法包含以下方法

文件扫描路径

    /**
     * 递归处理路径下文件夹是否包含文件夹,如不包含则获取当前类的权限定命名存入set中
     *
     * @param packName
     * @param classNameSet
     * @param path
     */
    public static void parseFilePackName(String packName, Set<String> classNameSet, String path) 

bean实例化方法

 private void setBean();

bean依赖注入方法

 beanAutoWired()

事务处理注解方法

doScanTransactional()

/**
 * 注解方式 实现 Bean工厂
 *
 * @author Pilgrim
 */
public class AnnotationBeanFactory extends AbstractBeanFactory {

    /**
     * 2  注解 + 扫描包 方式实现 ioc 容器
     * tomcat启动的时候去初始化容器
     */
    public AnnotationBeanFactory() {
            if (isTag) {
            return;
        }
        try {
            String packageName = StartApplication.class.getPackage().getName();
            //扫描启动类的包名
            System.out.println("------------------- [容器]正在初始化 ------------ ");
            System.out.println(String.format("------------------- 扫描当前包是%s  ------------ ", packageName));
            initBeanFactory(packageName);
            System.out.println("------------------- [容器]初始化完成 ------------ ");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        isTag = true;
    }


}

包扫描

递归扫描包下的文件
com.xxx.xxx 包名需要转换成磁盘目录 c:/xxx/xx这样的形式

获取包名

   String packageName = StartApplication.class.getPackage().getName();

转换包名以及扫描包得到所有的class文件名

        if (Objects.isNull(packName) || packName.length() == 0) {
            throw new RuntimeException("无效的包路径");
        }
        packName = packName.replace(".", File.separator);
        URL resource = AnnotationBeanFactory.class.getClassLoader().getResource(packName);
        String path = resource.getPath();
        //解析中文
        String filePath = URLDecoder.decode(path, "UTF-8");

递归处理

    /**
     * 递归处理路径下文件夹是否包含文件夹,如不包含则获取当前类的权限定命名存入set中
     *
     * @param packName
     * @param classNameSet
     * @param path
     */
    public static void parseFilePackName(String packName, Set<String> classNameSet, String path) {

        File packNamePath = new File(path);

        if (!packNamePath.isDirectory() || !packNamePath.exists()) {
            return;
        }
        //递归路径下所有文件和文件夹
        for (File file : packNamePath.listFiles()) {
            boolean directory = file.isDirectory();
            String classNamePath = packName + File.separator + file.getName().replace(File.separator, ".");
            if (directory) {
                parseFilePackName(classNamePath, classNameSet, file.getPath());
            } else if (file.isFile() && file.getName().endsWith(CLASS_STR)) {
                //存入set
                classNameSet.add(classNamePath.replace(File.separator, ".").replace(CLASS_STR, ""));
            }
        }

    }

bean实例化

得到所有的java文件名,然后去实例化bean

判断是否包含我们刚才自定义的注解

    private void setBean() {
        stringSet.forEach(x -> {
            try {
                //排除指定包 servlet 类不能被实例化 这儿排除
                if (!x.contains("servlet")) {
                    Class<?> aClassz = Class.forName(x);
                    serviceAnnotation(aClassz);
                    repositoryAnnotation(aClassz);
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        });
    }

判断是否含有Service和Repository注解

获取bean的名字 并且判断当前类是否有 Service 注解,如有则存入Ioc 如包含属性value不为空,则设置value属性为bean的key

    public void serviceAnnotation(Class aClass1) throws InstantiationException, IllegalAccessException {
        Service annotation = (Service) aClass1.getAnnotation(Service.class);
        if (Objects.nonNull(annotation)) {
            setIocNameMap(annotation.value(), aClass1.getSimpleName(), aClass1);
        }
    }

Repository 同理

    public void repositoryAnnotation(Class aClass) throws InstantiationException, IllegalAccessException {
        Repository annotation = (Repository) aClass.getAnnotation(Repository.class);
        if (Objects.nonNull(annotation)) {
            setIocNameMap(annotation.value(), aClass.getSimpleName(), aClass);
        }
    }

获取bean的name setIocNameMap方法然后实例化bean加入到容器
这儿判断一下是否是单例bean 这儿的单例指的是是否已经有一个bean了

    public void setIocNameMap(String value, String className, Class clasz) throws IllegalAccessException, InstantiationException {
        String iocNameString = value;
        Object beanDefinition =  clasz.newInstance() ;
        if (value.length() > 0) {
            if (IOC_MAP.containsKey(value)) {
                throw new RuntimeException("the named" + className + ",  had one ... ");
            }
        } else {
            //默认设置bean首字母小写的
            iocNameString = getIocNameString(className);
            if (IOC_MAP.containsKey(iocNameString)) {
                throw new RuntimeException("the named  " + className + ",  had one ... ");
            }
        }

        // 根据父接口类型注入
        Class<?>[] interfaces = clasz.getInterfaces();
        if (interfaces != null) {
            for (Class<?> anInterface : interfaces) {
                IOC_MAP.put(anInterface.getSimpleName(), beanDefinition);
            }
        }
        IOC_MAP.put(iocNameString, beanDefinition);
    }

设置首字母小写

   public static String getIocNameString(String className) {
        return (String.valueOf(className.toCharArray()[0])).toLowerCase() + className.substring(1, className.length());
    }

依赖注入

依赖注入方法,获取成员变量上有 Autowired 注解的字段,然后根据当前类类型去自动装配

    public static void beanAutoWired() throws ClassNotFoundException {
        //获取成员变量上有 Autowired 注解的字段,然后根据当前类类型去自动装配
        for (Map.Entry<String, Object> stringObjectEntry : IOC_MAP.entrySet()) {

            Object beanDefinition = stringObjectEntry.getValue();
            Class<?> aClass = beanDefinition.getClass();
            Field[] declaredFields = aClass.getDeclaredFields();

            if (Objects.isNull(declaredFields) && declaredFields.length == 0) {
                continue;
            }

            for (Field field : declaredFields) {
                //字段含有 Autowired 注解的需要被自动装配对象
                Autowired autowired = field.getAnnotation(Autowired.class);

                if (Objects.nonNull(autowired)) {
                    //根据当前key获取需要注入示例对象
                    //先根据名字注入,如果名字获取不到,再根据类型去注入
                    String beanName = autowired.name();

                    if (StringUtils.isEmpty(beanName)) {
                        beanName = field.getType().getSimpleName();
                    }

                    //反射设置值
                    try {
                        field.setAccessible(true);
                        //自动装配 线程不安全,Spring中默认单例
                        field.set(stringObjectEntry.getValue(), IOC_MAP.get(beanName));
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    }

扫描事务注解

    public void doScanTransactional() throws IllegalAccessException, InstantiationException, ClassNotFoundException {

        for (Map.Entry<String, Object> classBeanDefinitionEntry : IOC_MAP.entrySet()) {
            Object beanDefinition = classBeanDefinitionEntry.getValue();
            //判断生成代理对象
            Object proxy = getProxy(beanDefinition);
            if (proxy==null){
                proxy = beanDefinition;
            }
            //更新bean
            IOC_MAP.put(classBeanDefinitionEntry.getKey(), proxy);
        }


    }

判断选择哪个代理实现方式 根据是否实现接口

    public Object getProxy(Object aClass) {
        Object jdkProxy = null;

        Transactional annotation =  aClass.getClass().getDeclaredAnnotation(Transactional.class);
            if (Objects.nonNull(annotation)) {
                //有接口使用jdk动态代理
                 if (aClass.getClass().getInterfaces() == null || aClass.getClass().getInterfaces().length <= 0) {

                    //cglib动态代理
                    jdkProxy = ProxyFactory.getCglibProxy(aClass);
                } else {
                    /*for (Class anInterface : aClass.getClass().getInterfaces()) {
                        System.out.println(anInterface.getSimpleName());
                    }*/
                    jdkProxy = ProxyFactory.getJdkProxy(aClass);
                }
        }
      return jdkProxy;

    }

代理对象实现 以及方法执行前后处理事务

/**
 * 代理类工厂
 *
 * @author Pilgrim
 */
public class ProxyFactory {

    /**
     * 事务管理器
     */
  private final TransferServiceManager t = TransferServiceManager.get();

    /**
     * Jdk动态代理
     *
     * @param obj 被代理的对象
     * @return 返回代理对象
     */
    public static Object getJdkProxy(Object obj) {

        Object o = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {

                Object invoke = null;
                try {
                    // 开启事务(关闭事务的自动提交)
                    TransferServiceManager.get().start();
                    invoke = method.invoke(obj, objects);
                    // 提交事务
                    TransferServiceManager.get().commit();
                } catch (Exception e) {
                    e.printStackTrace();
                    // 回滚事务
                    TransferServiceManager.get().rowback();
                    throw e;
                }

                return invoke;
            }
        });

        return o;

    }


    /**
     * cglib动态代理
     *
     * @param object 被代理的对象
     * @return 返回代理对象
     */
    public static Object getCglibProxy(Object object) {

        //生成代理对象
        return Enhancer.create(object.getClass(), new MethodInterceptor() {

            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object result = null;
                try {

                    //开启事务
                    TransferServiceManager.get().start();

                    result = method.invoke(object, objects);

                    //提交事务
                    TransferServiceManager.get().commit();
                } catch (Exception e) {
                    //回滚事务
                    TransferServiceManager.get().rowback();
                    throw e;
                }
                return result;

            }
        });

    }

初始化方法步骤

    /**
     * 初始化bean
     * 1 递归扫描包获取类权限定命名
     * 2 实例化bean
     * 3 依赖注入
     * 4 扫描事务注解 生成代理对象
     *
     * @param packName
     * @throws UnsupportedEncodingException
     */
    public void initBeanFactory(String packName) throws UnsupportedEncodingException, InstantiationException, IllegalAccessException, ClassNotFoundException {

        if (Objects.isNull(packName) || packName.length() == 0) {
            throw new RuntimeException("无效的包路径");
        }
        packName = packName.replace(".", File.separator);
        URL resource = AnnotationBeanFactory.class.getClassLoader().getResource(packName);
        String path = resource.getPath();
        //解析中文
        String filePath = URLDecoder.decode(path, "UTF-8");

        //解析包成java权限定命名com
        parseFilePackName(packName, stringSet, filePath);
        //实例化bean
        setBean();

        //System.out.println(String.format("获取到的bean : %s ", IOC_MAP));

        //自动装配
        beanAutoWired();

        //扫描事务注解
        doScanTransactional();

    }

对外提供getBean(方法)

实现getBean方法

    @Override
    //根据id名获取
    public Object getBean(String id) {
        if (Objects.nonNull(id) && id.length() > 0) {
            Object beanDefinition = IOC_MAP.get(id);
            return beanDefinition;
        }
        return null;
    }


    @Override
    //根据类型获取
    public Object getBean(Class<?> aClass) {
        if (Objects.isNull(aClass)) {
            return null;
        }
        return IOC_MAP.get(aClass.getSimpleName());
    }

    @Override
    public Object getAllBeanName() {
        return IOC_MAP.keySet();
    }

测试

启动tomcat可以看到启动成功,bean实例化完成

在这里插入图片描述

在servlet init方法里可以调用看一下

    private TransferService transferService  ;

    @Override
    public void init() throws ServletException {
        BeanFactory  beanFactory = new AnnotationBeanFactory();
        transferService= (TransferService)beanFactory.getBean("transferServiceImpl");
        TransferService transferService2  = (TransferService) beanFactory.getBean(TransferService.class);
        super.init();
    }

debug可以看到 根据类型还是id都可以获取到代理之后的bean

在这里插入图片描述