JAVA枚举&注解&反射

枚举（enum）

1.简单类似静态变量用法

public enum UseEnum {
    
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    
}

2.添加属性描述

public enum UseEnum {

    SUNDAY(0,"星期日"),
    MONDAY(1,"星期一"),
    TUESDAY(2,"星期二"),
    WEDNESDAY(3,"星期三"),
    THURSDAY(4,"星期四"),
    FRIDAY(5,"星期五"),
    SATURDAY(6,"星期六");

    private int index;
    private String description;

    UseEnum(int index, String description) {
        this.index = index;
        this.description = description;
    }

    public int getIndex() {
        return index;
    }

    public String getDescription() {
        return description;
    }
}

3.加入抽象类方法

package com.idea.PrEnum;

/**
 * @author songbin
 * @date 2020/8/29
 */
public enum UseEnum {

    SUNDAY(0,"星期日"){
        @Override
        public UseEnum getNext() {
            return UseEnum.MONDAY;
        }
    },
    MONDAY(1,"星期一") {
        @Override
        public UseEnum getNext() {
            return UseEnum.TUESDAY;
        }
    },
    TUESDAY(2,"星期二") {
        @Override
        public UseEnum getNext() {
            return UseEnum.WEDNESDAY;
        }
    },
    WEDNESDAY(3,"星期三"){
        @Override
        public UseEnum getNext() {
            return UseEnum.THURSDAY;
        }
    },
    THURSDAY(4,"星期四") {
        @Override
        public UseEnum getNext() {
            return UseEnum.FRIDAY;
        }
    },
    FRIDAY(5,"星期五") {
        @Override
        public UseEnum getNext() {
            return UseEnum.SATURDAY;
        }
    },
    SATURDAY(6,"星期六") {
        @Override
        public UseEnum getNext() {
            return UseEnum.SUNDAY;
        }
    };

    private int index;
    private String description;
    public abstract UseEnum getNext();

    UseEnum(int index, String description) {
        this.index = index;
        this.description = description;
    }

    public int getIndex() {
        return index;
    }

    public String getDescription() {
        return description;
    }
}

注解Annotation

自定义注解

//元注解
@Target({ElementType.TYPE,ElementType.METHOD}) //注解可用的位置
@Retention(RetentionPolicy.RUNTIME) //注解编译的时间
public @interface Bean {
	//注解中添加属性
    String name() default "";
    int age() default 0;
}

注解的使用：

@Bean(name = "旺财",age = 2)
public class Dog extends Animal{

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }

    @Override
    @Deprecated
    public void eat() {

    }

    @Override
    @Bean
    public void go() {
        System.out.println("奔");
    }
}

abstract class Animal{
    public abstract void eat();
    public void go(){
        System.out.println("动");
    }
}

反射 Refelect

java中动态获取信息和动态调用对象的方法的功能称为java的反射。

setAccessible(); 启用和禁用访问安全检查的开关，值为true表示取消访问安全检查反之启用
反射：class对象
反射会降低程序的运行效率；
对象是表示或封装一些数据。一个类被加载，JVM会创建一个对应类的Class对象，类的整个结构信息会放到对应的Class对象中，这个Class对象就像一面镜子一样，通过镜子可以看到对应类的全部信息；
获取类对象

//获取类对象
        //1.
        Class clazz = Entity.class;
        System.out.println(clazz.hashCode());
        //2.
        Entity entity = new Entity();
        Class aClass = entity.getClass();
        System.out.println(aClass.hashCode());
        
        //3.推荐
        Class aClass1 = Class.forName("com.idea.reflection.Entity");
        System.out.println(aClass1.hashCode());

操作属性

Class aClass1 = Class.forName("com.idea.reflection.Entity");
        System.out.println(aClass1.hashCode());

        Entity entity = (Entity) aClass1.getConstructor().newInstance();

        //操作属性
        /*Field name = aClass1.getField("name");  //无法操作私有（private）属性 */
        Field name = aClass1.getDeclaredField("name");
        Field age = aClass1.getField("age");
        System.out.println(name);
        System.out.println(age);
        //私有方法需要关闭安全检查的开关
        name.setAccessible(true);
        name.set(entity, "songbin");

        age.set(entity, 23);

        System.out.println(age.getName() + ":" + age.get(entity));
        System.out.println(name.getName() + ":" + name.get(entity));

        Field[] fields = aClass1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        Field[] dfields = aClass1.getDeclaredFields();
        for (Field field : dfields) {
            field.setAccessible(true);
            System.out.println(field.getName()+":"+field.get(entity));
        }

操作方法

Class aClass1 = Class.forName("com.idea.reflection.Entity");
        System.out.println(aClass1.hashCode());

        Entity entity = (Entity) aClass1.getConstructor().newInstance();
        /*aClass1.getConstructor()  //获取构造器*/
        //无参方法操作
        Method print = aClass1.getMethod("print");
        System.out.println(print.);
        print.invoke(entity);

        //有参方法操作
        Method print1 = aClass1.getMethod("print",String.class);
        System.out.println(print1.hashCode());
        print1.invoke(entity,"zsm");

一个简单的反射实例（自动装在工具类）

package reflection;

import reflection.annotation.InjectField;
import reflection.annotation.MyAnnotation;
import org.apache.log4j.Logger;

import java.io.File;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.*;

/**
 * @author songbin
 * @date 2020/8/29
 */
public class ReflectFactory {

    private static Logger log = Logger.getLogger(ReflectFactory.class);

    private static final Map<Class,Object> mapFactory = new HashMap<>();
    private static String filePath;

    public static Object getBean(Class clazz){
        if (mapFactory.size()==0){
            initFactory2();
        }
        return mapFactory.get(clazz);
    }

    //通过配置文件进行装配
    public void initFactory() throws Exception {

        InputStream is = ReflectFactory.class.getClassLoader().getResourceAsStream("reflect.config");

        Properties properties = new Properties();
        properties.load(is);
        {
            Set<Object> keys = properties.keySet();
            for (Object key : keys) {
                Class<?> iClass = Class.forName(key.toString());
                Class clazz = Class.forName(properties.getProperty(key.toString()));
                mapFactory.put(iClass,clazz.getConstructor().newInstance());
            }

        }
    }



    public static void initFactory2() {
        filePath = ReflectFactory.class.getClassLoader().getResource("").getFile();
        try {
            filePath = java.net.URLDecoder.decode(filePath,"utf-8");
            loadOn(filePath);
            injectForFields();
        } catch (Exception e) {
            log.debug("项目路径获取失败");
        }

    }

    //暴力注入 给属性复制
    private static void injectForFields(){
        for (Class clazz:mapFactory.keySet()) {
            Object obj = mapFactory.get(clazz);
            Field[] fields = obj.getClass().getDeclaredFields();
            for (Field field : fields) {
                try {
                    InjectField annotation = field.getAnnotation(InjectField.class);
                    if (annotation != null) {
                        log.debug("给"+obj+"的"+field.getName()+"属性"+"注入了"+field.getType()+"对象");
                        field.setAccessible(true);
                        field.set(obj,mapFactory.get(field.getType()));
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 借助Annotation完成自动装配
     * @param path
     */
    private static void loadOn(String path) {
        File parentfile = new File(path);
        //判断文件是否存在切不为空
        if (parentfile != null && parentfile.exists()) {
            //判断文件是否是文件夹
            if (parentfile.isDirectory()) {
                //获取当前文件的子文件集合
                File[] files = parentfile.listFiles();
                //遍历文件集
                for (File file : files) {
                    if (file.isDirectory()){
                        //进行递归遍历操作
                        loadOn(file.getPath());
                    }else{
                        //获取文件路径
                        String str = file.getAbsolutePath();
                        //筛选出.class文件
                        if (str.contains(".class")){
                            //获取全限定路径 如：com.idea.dao.DaoImpl
                            String url = str.substring(filePath.length()-1);
                            url = url.replaceAll("\\\\",".").replace(".class","");

                            Class<?> aClass = null;
                            try {
                                //加载类
                                aClass = Class.forName(url);
                                if (!aClass.isInterface()){
                                    MyAnnotation myAnnotation = aClass.getAnnotation(MyAnnotation.class);
                                    if (myAnnotation!=null){
                                        //将加载类的势力对象put进工厂
                                        Class<?>[] interfaces = aClass.getInterfaces();
                                        if (interfaces.length>0){
                                            log.debug("\r\n加载了以"+aClass.getInterfaces()[0]+"为接口的"+aClass+"的实例对象");
                                            mapFactory.put(aClass.getInterfaces()[0],aClass.getConstructor().newInstance());
                                        }else {
                                            log.debug("\r\n加载了以"+aClass+"为接口的"+aClass.getName()+"的实例对象");
                                            mapFactory.put(aClass,aClass.getConstructor().newInstance());
                                        }
                                    }
                                }
                            } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
                                e.printStackTrace();
                            }

                        }
                    }
                }
            }
        }
    }
}


//附带注解类
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectField {
}

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