FileWatcher.java

package com.tuniu.mob.dist.site.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import org.springframework.util.ReflectionUtils;

import javax.annotation.PostConstruct;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;

/**
 * @Auther: zhengpeng
 * @Date: 2019/3/21 19:43
 * @Description:
 */
@Component
public class FileWatcher implements ApplicationContextAware {

    private static final Logger LOGGER = LoggerFactory.getLogger(FileWatcher.class);

    public static ApplicationContext applicationContext;

    private WatchService watchService;

    @Value("${howLoading.directory}")
    private String watchFile;

    @Value("${howLoading.enabled}")
    private boolean hotLoading;

    @Autowired
    private LocalProcessor localProcessor;

    @PostConstruct
    public void init() {
        if (!hotLoading) {
            return;
        }
        try {
            watchService = FileSystems.getDefault().newWatchService();
            Path path = Paths.get(watchFile);
            // 单层文件夹下
//            path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE,
//                    StandardWatchEventKinds.ENTRY_MODIFY,
//                    StandardWatchEventKinds.ENTRY_DELETE);
            // 多层文件夹下
            Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                        throws IOException {
                    dir.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_DELETE);
                    return FileVisitResult.CONTINUE;
                }
            });
        } catch (IOException e) {
            LOGGER.warn("读取修改的文件失败", e);
        }
        new Thread(new WatchThread()).start();
        /**注册关闭钩子*/
        Thread hook = new Thread(() -> {
            try {
                watchService.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        Runtime.getRuntime().addShutdownHook(hook);

    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public class WatchThread implements Runnable {

        @Override
        public void run() {
            while (true) {
                final WatchKey key;
                try {
                    key = watchService.take();
                    for (WatchEvent<?> watchEvent : key.pollEvents()) {

                        final WatchEvent.Kind<?> kind = watchEvent.kind();

                        if (kind == StandardWatchEventKinds.OVERFLOW) {
                            continue;
                        }
                        //创建事件
                        if (kind == StandardWatchEventKinds.ENTRY_CREATE) {
                            LOGGER.info("[新建]");
                        }
                        //修改事件
                        if (kind == StandardWatchEventKinds.ENTRY_MODIFY) {
                            // 热加载进jvm 并且加入spring
                            Path filePath = (Path) watchEvent.context();
                            if (!filePath.toString().endsWith(".java")) {
                                continue;
                            }
                            Path path = (Path) key.watchable();
                            LOGGER.info("[修改]:" + filePath.toString());
                            // 动态编译
                            JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
                            LOGGER.info("加载文件到" + this.getClass().getResource("/").getPath());
                            String realFilePath = String.format("%s/%s", key.watchable().toString(), filePath.toString());
                            int status = javac.run(null, null, null, "-d", this.getClass().getResource("/").getPath(), realFilePath);
                            if (status != 0) {
                                LOGGER.info("没有编译成功！");
                            } else {
                                // 动态加载 在JVM中，一个实例是通过本身的类名+加载它的ClassLoader识别的，也就是说 不同的ClassLoader 加载同一个类在JVM是不同的。
                                String className = filePath.getFileName().toString().split("\\.")[0];
                                String beanName = className.substring(0, 1).toLowerCase() + className.substring(1);
//                                String classPathName = applicationContext.getType(beanName).getTypeName();
//                                String classPathName = applicationContext.getType(beanName).getGenericSuperclass().getTypeName();
                                String classPathName = realFilePath.split("java/")[1].replace("/",".").replace(".java","");
                                Class<?> cla = new SelfClassload(classPathName).loadClass(classPathName); // 需要重新new，不然一个加载器多次加载同一个类会报错 // 创建实例,判断这个对象是不是@Service等注解修饰，如果是则替换spring容器中的对象  对象中注入的不用管
                                if (cla.isAnnotationPresent(Component.class) || cla.isAnnotationPresent(Service.class)
                                        || cla.isAnnotationPresent(Repository.class) && cla.getInterfaces().length > 0) {
//                                  CouponServiceImpl couponService1 = () cla.newInstance(); // 会报错 相同的类，不同的ClassLoader，将导致ClassCastException异常
                                    //先移除spring中的bean
                                    localProcessor.removeBean(beanName);
                                    //注入spring中
                                    localProcessor.addBean(beanName, cla);
//                                    if (cla.isAnnotationPresent(Component.class) || cla.isAnnotationPresent(Service.class) || cla.isAnnotationPresent(Repository.class)) {
                                    // 利用反射给使用到上面属性的对象重新赋值
                                    Object springObj = applicationContext.getBean(beanName);
                                    String fieldName = beanName.endsWith("Impl") ? beanName.substring(0, beanName.length() - 4) : beanName;
                                    String[] beans = applicationContext.getBeanDefinitionNames();
                                    for (String bean : beans) {
                                        try {
                                            Object temp = applicationContext.getBean(bean);
                                            Field f;
                                            f = temp.getClass().getDeclaredField(fieldName);
                                            ReflectionUtils.makeAccessible(f);
                                            f.set(temp, springObj);
                                        } catch (Exception e) {
                                            continue;
                                        }
                                    }
                                }
                                LOGGER.info("{}热加载完毕", beanName);
//                                }
//                                if (cla.isAnnotationPresent(Controller.class) || cla.isAnnotationPresent(RestController.class)) {
//                                    localProcessor.registerController(beanName, cla);
//                                }

                            }
                        }
                        //删除事件
                        if (kind == StandardWatchEventKinds.ENTRY_DELETE) {
                            LOGGER.info("[删gh除]");
                        }
                    }
                    boolean valid = key.reset();
                    if (!valid) {
                        break;
                    }
                } catch (Exception e) {
                    LOGGER.warn("热加载出错", e);
//                    重新开启线程
                    new Thread(new WatchThread()).start();
                }
            }
        }
    }


    public static void main(String[] args) {
//        System.out.println(System.getProperty("user.dir"));
    }
}