欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

手写spring时的一些工具类

程序员文章站 2023-11-08 08:17:16
一、注解操作的工具类,可以判断组合注解中是否包含某个注解package syx.mvc.util;import javax.annotation.*;import java.lang.annotation.*;public class AnnotationUtil { /** * 判断类上是否存在某个注解 * @param clazz * @param ann * @return */ public static boolean...

一、注解操作的工具类,可以判断组合注解中是否包含某个注解

package syx.mvc.util;
import javax.annotation.*;
import java.lang.annotation.*;

public class AnnotationUtil {

    /**
     * 判断类上是否存在某个注解
     * @param clazz
     * @param ann
     * @return
     */
    public static boolean checkAnnotation(Class<?> clazz,Class<?> ann){
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annotation : annotations) {
            if (annotation.annotationType() != Deprecated.class &&
                    annotation.annotationType() != SuppressWarnings.class &&
                    annotation.annotationType() != Override.class &&
                    annotation.annotationType() != PostConstruct.class &&
                    annotation.annotationType() != PreDestroy.class &&
                    annotation.annotationType() != Resource.class &&
                    annotation.annotationType() != Resources.class &&
                    annotation.annotationType() != Generated.class &&
                    annotation.annotationType() != Target.class &&
                    annotation.annotationType() != Retention.class &&
                    annotation.annotationType() != Documented.class &&
                    annotation.annotationType() != Inherited.class
            ) {
                if (annotation.annotationType() == ann){
                    return true;
                }else{
                    return checkAnnotation(annotation.annotationType(),ann);
                }
            }
        }
        return false;
    }
}

二、填充IOC容器的工具类

package syx.mvc.util;

import syx.mvc.annotation.Component;
import syx.mvc.annotation.Scope;
import syx.mvc.config.BeanDefinition;

import java.util.HashMap;
import java.util.List;

/**
 * 填充IOC容器
 */
public class IOCMapUtil {

    /**
     * 将扫描得到的类,根据注解添加到ioc容器
     * @param classNames
     * @param ioc
     * @return
     */
    public static HashMap<String, BeanDefinition> IOCMap(List<String> classNames, HashMap<String, BeanDefinition> ioc) {
        //检查类上的注解
        classNames.forEach(e->{
            try {
                Class<?> clazz = AnnotationUtil.class.getClassLoader().loadClass(e);
                //判断类上是否包含component注解
                boolean b = AnnotationUtil.checkAnnotation(clazz, Component.class);
                if(b){
                    Component component = clazz.getAnnotation(Component.class);
                    BeanDefinition beanDefinition = generateBeanDefinition(clazz,component,e);
                    ioc.put(beanDefinition.getBeanName(),beanDefinition);
                }
            } catch (ClassNotFoundException exception) {
                exception.printStackTrace();
            }
        });

        return ioc;
    }

    /**
     * 生成bean的定义信息
     * @param component
     * @return
     */
    private static BeanDefinition generateBeanDefinition(Class<?> clazz,Component component,String className){
        String beanName;
        String scopeType;
        BeanDefinition beanDefinition = new BeanDefinition();
        if(component == null){//如果component为null,则默认为单例,beanName为类名首字母小写
            String[] split = className.split("\\.");
            beanName = split[split.length-1];
            scopeType = "singleton";
        }else{
            if(component.value().isEmpty()){
                String[] split = className.split("\\.");
                beanName = split[split.length-1];
            }else{
                beanName = component.value();
            }
            Scope scope = clazz.getAnnotation(Scope.class);
            if(scope != null){
                scopeType = scope.value();
            }else{
                scopeType = "singleton";
            }
        }
        beanDefinition.setBeanName(beanName);
        beanDefinition.setBeanClass(clazz);
        beanDefinition.setScope(scopeType);
        return beanDefinition;
    }


}

三、根据包名,加载该包下所有class文件的工具类

package syx.mvc.util;

import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class LoadFileUtil {
    /**
     * 加载扫描包名下的所有class文件,返回全限定类名,例如:syx.web.controller.UserController
     * @param packageName
     * @return
     */
    public static List<String> loadFiles(String packageName) {
        if(packageName == null || packageName.isEmpty()){
            throw new RuntimeException("包名不能为空");
        }
        String path = packageName.replaceAll("\\.", "/");
        ClassLoader classLoader = LoadFileUtil.class.getClassLoader();
        URL resource = classLoader.getResource(path);
        File file = new File(resource.getFile());
        return  DFSLoadFile(file,"syx",".class");
    }


    /**
     * 深度优先搜索,扫描包下的文件
     * @param file
     * @param prefix
     * @param suffix
     * @return
     */
    private static List<String> DFSLoadFile(File file, String prefix, String suffix) {
        List<String> classFiles = new ArrayList<>();
        Stack<File> stack = new Stack<>();
        stack.push(file);
        while (!stack.isEmpty()) {
            File f = stack.pop();
            File[] files = f.listFiles();
            for (File F : files) {
                if(F.isDirectory()){
                    stack.push(F);
                }else {
                    classFiles.add(replace(F.getAbsolutePath(),prefix,suffix));
                }
            }
        }
        return classFiles;
    }
    private static String replace(String target,String prefix,String suffix){
        target = target.substring(target.indexOf(prefix), target.indexOf(suffix)).replace("\\", ".");
        return target;
    }
}

四、加载配置文件的工具类

package syx.mvc.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class PropertiesUtil {
    private static final Logger logger = LoggerFactory.getLogger(PropertiesUtil.class);

    public static Properties loadPropertoes(String fileName) throws IOException {
        Properties properties = null;
        InputStream inputStream = null;

        try {
            inputStream = PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName);
            if (inputStream == null){
                throw new FileNotFoundException(fileName + "is not found");
            }

            properties = new Properties();
            properties.load(inputStream);
        }catch (IOException e){
            logger.error("load properties failure",e);
        }finally {
            if (inputStream != null){
                inputStream.close();
            }
        }

        return properties;
    }


    /**
     * 获取 String 类型的属性值(可指定默认值)
     */
    public static String getString(Properties props, String key, String defaultValue) {
        String value = defaultValue;
        if (props.containsKey(key)) {
            value = props.getProperty(key);
        }
        return value;
    }

    /**
     * 获取 String 类型的属性值(默认值为空字符串)
     */
    public static String getString(Properties props, String key) {
        return getString(props, key, "");
    }


    /**
     * 获取 int 类型的属性值(默认值为 0)
     */
    public static int getInt(Properties props, String key) {
        return getInt(props, key, 0);
    }

    /**
     * 获取 int 类型的属性值(可指定默认值)
     */
    public static int getInt(Properties props, String key, int defaultValue) {
        int value = defaultValue;
        if (props.containsKey(key)) {
            value = Integer.parseInt(props.getProperty(key));
        }
        return value;
    }


    /**
     * 获取 boolean 类型属性(默认值为 false)
     */
    public static boolean getBoolean(Properties props, String key) {
        return getBoolean(props, key, false);
    }

    /**
     * 获取 boolean 类型属性(可指定默认值)
     */
    public static boolean getBoolean(Properties props, String key, boolean defaultValue) {
        boolean value = defaultValue;
        if (props.containsKey(key)) {
            value = Boolean.parseBoolean(props.getProperty(key));
        }
        return value;
    }
}

五、反射工具类

package syx.mvc.util;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 反射工具类
 */
public class ReflectionUtil {
    private static final Logger logger = LoggerFactory.getLogger(ReflectionUtil.class);

    /**
     * 反射创建对象
     *
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T crtInstance(Class<T> clazz) {
        T instance = null;
        try {
            instance = clazz.newInstance();
        } catch (Exception e) {
            logger.error("new instance failure", e);
            e.printStackTrace();
        }
        return instance;
    }


    /**
     * 调用方法
     * @param object
     * @param method
     * @param args
     * @return
     */
    public static Object invokeMethod(Object object, Method method, Object... args) {
        Object result = null;
        try {
            method.setAccessible(true);
            result = method.invoke(object, args);
        } catch (Exception e) {
            logger.error("new instance failure", e);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 设置成员变量的值
     */
    public static void setField(Object obj, Field field, Object value) {
        try {
            field.setAccessible(true); //去除私有权限
            field.set(obj, value);
        } catch (Exception e) {
            logger.error("set field failure", e);
            throw new RuntimeException(e);
        }
    }
}

本文地址:https://blog.csdn.net/weixin_42304484/article/details/112059457

相关标签: web框架