protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //从map中获取bean如果不为空直接返回，不再进行初始化工作
    Object singletonObject = this.singletonObjects.get(beanName);
    // 缓存中的 bean 为空，且当前 bean 正在创建
    // isSingletonCurrentlyInCreation(String beanName) 方法：
    // 判断当前 singleton bean 是否处于创建中。bean 处于创建中，也就是说 bean 在初始化但是没有完成初始化，核心就在于提前曝光 bean 。
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            // 从 earlySingletonObjects 获取
            singletonObject = this.earlySingletonObjects.get(beanName);
            // earlySingletonObjects 中没有，且允许提前创建
            // allowEarlyReference 是否允许从 singletonFactories 缓存中通过 #getObject() 方法，拿到对象。
            // singletonFactories 才是 Spring 解决 singleton bean 的核心。
            if (singletonObject == null && allowEarlyReference) {
                // 从 singletonFactories 中获取对应的 ObjectFactory
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 获得 bean
                    singletonObject = singletonFactory.getObject();
                    // 添加 bean 到 earlySingletonObjects 中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 从 singletonFactories 中移除对应的 ObjectFactory
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

//用于存放完全初始化好的 bean从该缓存中取出的 bean可以直接使用
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/**
    * 存放bean工厂对象
    *
    * 对应关系也是 bean name --> bean instance。
    *
    * singletonFactories中存放的 bean 不一定是完整的。
    *
    * bean 在创建过程中就已经加入到 singletonFactories 中了，
    * 所以当在 bean 的创建过程中就可以通过 getBean() 方法获取。也是解决循环依赖的关键。
    */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

//存放的是 ObjectFactory 的映射，原始的bean对象用于解决循环依赖,注意：存到里面的对象还没有被填充属性 
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

// 解决循环依赖问题
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
// Bean 满足三个条件时：
// 单例模式
// 运行循环依赖
// 当前单例 bean 是否正在被创建
if (earlySingletonExposure) {
    if (logger.isDebugEnabled()) {
        logger.debug("Eagerly caching bean '" + beanName +
                "' to allow for resolving potential circular references");
    }
    //提前将创建的 bean 实例加入到 singletonFactories 中
    //当正在创建A时，A依赖B，此时通过（B将A作为ObjectFactory放入单例工厂中进行early expose，此处B需要引用A，但A正在创建，从单例工厂拿到ObjectFactory，从而允许循环依赖)
    //避免后期循环依赖
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

protected void addSingleton(String beanName, Object singletonObject) {
	synchronized (this.singletonObjects) {
		this.singletonObjects.put(beanName, singletonObject);
		this.singletonFactories.remove(beanName);
		this.earlySingletonObjects.remove(beanName);
		this.registeredSingletons.add(beanName);
	}
}

/**
 * 构建数据源对象
 */
@ConditionalOnClass({EnableTransactionManagement.class})
@Configuration
public class DataSourceConfig {
    private static Logger log = LoggerFactory.getLogger(DataSourceConfig.class);

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSource druidDataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
}

/**
 * 使用Redis做为缓存，和spring boot1.x不同
 */
@Configuration
@EnableCaching
public class RedisConfig  extends CachingConfigurerSupport {

    /*@Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;*/

    //自定义缓存key生成策略
    @Bean
    public KeyGenerator keyGenerator(){
        return (o, method, params) ->{
            StringBuilder sb = new StringBuilder();
            sb.append(o.getClass().getName()); // 类目
            sb.append(method.getName()); // 方法名
            for(Object param: params){
                sb.append(param.toString()); // 参数名
            }
            return sb.toString();
        };
    }
    //缓存管理器Spring boot2.X 配置
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1)) // 设置缓存有效期一小时
                // 设置key的序列化方式
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 设置value的序列化方式
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                // 不缓存null值
                .disableCachingNullValues();

        RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(config)
                .transactionAware()
                .build();

        return redisCacheManager;
    }
    //以下是Spring boot1.X 配置
    /*@Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        //设置缓存过期时间
        cacheManager.setDefaultExpiration(10000);
        return cacheManager;
    }*/
    /*@Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory){
        StringRedisTemplate template = new StringRedisTemplate(factory);
        //设置序列化工具
        setSerializer(template);
        return template;
    }*/
   /* @SuppressWarnings("all")
    private void setSerializer(StringRedisTemplate template){
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //查看Redis的Bean定义发现，对key的序列化使用的是StringRedisSerializer系列化，value值的序列化是GenericJackson2JsonRedisSerializer的序列化方法。
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
    }*/
}

public class Student implements Serializable {
    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student(String name) {
        this.name = name;
    }
    public Student(){}
    @Override
    public String toString() {
        return "\n{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

@Mapper
public interface StudentMapper {
    @Insert("insert into Student(name) values(#{name})")
    int insertStudent(Student student);

    @Select("select * from Student")
    List<Student> selectStudent();
}

/**
 * @Cacheable(cacheNames = "student") 这样就使用了缓存
 * 
 */
@Service
public class StudentService {

    @Autowired
    StudentMapper studentMapper;

    public int saveStudent(Student student){
        return studentMapper.insertStudent(student);
    }

    @Cacheable(cacheNames = "student")
    public List<Student> getStudents(){
        return studentMapper.selectStudent();
    }
}


测试类：
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class Test {
    @Autowired
    StudentService studentService;

    @org.junit.Test
    public void stu(){

        Random random = new Random();
        Student student = new Student("小米"+random.nextInt(100));

        //System.out.println(studentService.saveStudent(student));

        System.out.println(Arrays.toString(studentService.getStudents().toArray()));
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ClearCache {
    String[] keys(); //需要清除的key
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisCache {
    Class type(); //用户存放类类型
}

/**
 * 缓存切面
 */
@Aspect
@Component
public class RedisCacheAspect {
    @Autowired
    private RedisClient redisClient;

    /**
     * 方法调用前，先查询缓存。如果存在缓存，则返回缓存数据，如果没有缓存，查數據庫，然后将结果放到缓存中
     */
    @Around("execution(public * com.hu.service.StudentService.getStudent(..))")
    public Object cache(ProceedingJoinPoint jp) throws Throwable {
        //获取被代理的方法
        MethodSignature msig = (MethodSignature) jp.getSignature();
        Object target = jp.getTarget();
        Object[] args = jp.getArgs();
        Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        String clazzName = target.getClass().getName();
        //得到被代理方法上的注解
        RedisCache annotation = currentMethod.getAnnotation(RedisCache.class);
        //如果没有缓存注解直接放行,查询数据库
        if(annotation==null){
            return jp.proceed(args);
        }
        System.out.println("cache");
        //有缓存注解，查询redis
        //生成对应的key值
        String key = genKey(clazzName, currentMethod.getName(), args);
        //查询redis
        Student student = (Student) redisClient.get(key);
        //如果redis中有直接返回缓存中内容
        if(student!=null){
            return student;
        }
        //如果redis中没有，查询数据库
        Object  object=jp.proceed(args);
        //如果数据库中查询不为空，将数据添加到reids中
        if(object!=null){
            redisClient.set(key,object);
        }
        return object;
    }


    /**
     * 对于插入，在方法调用前清除缓存，然后调用业务方法
     */
    @Around("execution(public * com.hu.service.StudentService.saveStudent(..))")
    public Object clearCache(ProceedingJoinPoint jp) throws Throwable {
        MethodSignature msig = (MethodSignature) jp.getSignature();
        Object target = jp.getTarget();
        Object[] args = jp.getArgs();
        Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        String clazzName = target.getClass().getName();
        //得到被代理方法上的注解
        ClearCache annotation = currentMethod.getAnnotation(ClearCache.class);
        String[] keys =annotation.keys();
        System.out.println("clearCache");
        if(keys!=null&&keys.length>0){
            // 清除对应缓存
            for(String key :keys){
                redisClient.delete(key);
            }
        }
        return jp.proceed(jp.getArgs());
    }


    /**
     * 根据类名、方法名和参数生成key
     */
    protected String genKey(String clazzName, String methodName, Object[] args) {
        StringBuilder sb = new StringBuilder(clazzName);
        sb.append(":");
        sb.append(methodName);
        for (Object obj : args) {
            sb.append(":");
            sb.append(obj.toString());
        }

        return sb.toString();
    }
}

@Configuration
@EnableAutoConfiguration
public class MyRedisTemplate {
    @Bean
    public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, String> template = new StringRedisTemplate(factory);
        //设置序列化工具
        setSerializer(template);
        return template;
    }
    @SuppressWarnings("all")
    private void setSerializer(RedisTemplate template){
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //查看Redis的Bean定义发现，对key的序列化使用的是StringRedisSerializer系列化，value值的序列化是GenericJackson2JsonRedisSerializer的序列化方法。
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
    }
}


/**
 * 操作方法
 */
@Component
public class RedisClient {

    private final static Logger log = LoggerFactory.getLogger(RedisClient.class);

    @Autowired
    RedisTemplate redisTemplate;

    /**
     * 删除key
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void delete(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 获取key
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 存入key
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.info(e.getMessage());
            return false;
        }
    }

    /**
     * key存放并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.info(e.getMessage());
            return false;
        }
    }

}

@Service
public class StudentService {

    @Autowired
    StudentMapper studentMapper;

    //清除对应的缓存
    @ClearCache(keys={"com.hu.service.StudentService:saveStudent:10"})
    public int saveStudent(Student student){
        return studentMapper.insertStudent(student);
    }

    @RedisCache(type=Student.class)
    public Student getStudent(Long id){
        return studentMapper.selectStudent(id);
    }
}

测试：
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class Test {
    @Autowired
    StudentService studentService;

    @org.junit.Test
    public void stu(){

        Random random = new Random();
        Student student = new Student("小米"+random.nextInt(100));

        //System.out.println(studentService.saveStudent(student));

        System.out.println(studentService.getStudent(6L));
    }
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSourceType {
    String value() default "";
}

/**
 * 构建数据源对象
 */
@ConditionalOnClass({EnableTransactionManagement.class})
@Configuration
public class DataSourceConfig {
    private static Logger log = LoggerFactory.getLogger(DataSourceConfig.class);

    @Value("${spring.datasource.type}")
    public Class<? extends DataSource> type;

    @Bean(name = "masterDataSource", destroyMethod = "close", initMethod = "init")
    @ConfigurationProperties(prefix = "spring.master")
    public DataSource masterDataSource() {
        log.info("************ masterDataSource init ************");
        return DataSourceBuilder.create().type(type).build();
    }

    @Bean(name = "slaveDataSource", destroyMethod = "close", initMethod = "init")
    @ConfigurationProperties(prefix = "spring.slave")
    public DataSource slaveDataSource() {
        log.info("************ slaveDataSource init ************");
        return DataSourceBuilder.create().type(type).build();
    }

    /**
     * 注册的bean放入一个map里面,后面就可以动态从这个map里面获取对应的数据源
     */
    @Bean
    public RoutingDataSource routingDataSource() {
        RoutingDataSource routingDataSource = new RoutingDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put("write", masterDataSource());
        dataSourceMap.put("read", slaveDataSource());
        routingDataSource.setTargetDataSources(dataSourceMap);
        //默认数据源
        routingDataSource.setDefaultTargetDataSource(masterDataSource());
        return routingDataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        //这里直接写上面生成的Bean，不然@Value("${spring.datasource.type}")获取不到，就会走默认的连接池
        sqlSessionFactoryBean.setDataSource(routingDataSource());
        //sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/**/*.xml"));
        sqlSessionFactoryBean.setTypeAliasesPackage("com.hu.entity");
        sqlSessionFactoryBean.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
        return sqlSessionFactoryBean.getObject();
    }

}

/**
 * 根据ThreadLocal来实现数据源的动态改变
 */
public class DataSourceContextHolder {
    private static Logger log = LoggerFactory.getLogger(DataSourceContextHolder.class);

    private static ThreadLocal<String> datasourceContext = new ThreadLocal<>();

    public static void switchDataSource(String datasource) {
        log.info("数据源: {}", datasource);
        datasourceContext.set(datasource);
    }

    public static String getDataSource() {
        return datasourceContext.get();
    }

    public static void clear() {
        datasourceContext.remove();
    }
}

/**
 * AbstractRoutingDataSource提供了程序运行时动态切换数据源的方法 *
 * 在dao类或方法上标注需要访问数据源的关键字，路由到指定数据源，获取连接。
 *
 * 这里通过配置注解方式
 */
public class RoutingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

/**
 * 利用springAOP对方法的切入,在方法执行前判断使用哪个数据源
 */
@Aspect
@Component
public class DataSourceAop {
    private static Logger log = LoggerFactory.getLogger(DataSourceAop.class);

    @Pointcut("@annotation(com.hu.aop.DataSourceType)")
    public void cutMethod() {
    }

    @Before("cutMethod()")
    public void beforeRead(JoinPoint point) {
        String className = point.getTarget().getClass().getName();
        String methodName = point.getSignature().getName();
        log.info("执行" + className + "." + methodName + "()方法");
        Method method = ((MethodSignature) point.getSignature()).getMethod();
        DataSourceType annotation = method.getAnnotation(DataSourceType.class);
        if (null == annotation) {
            annotation = point.getTarget().getClass().getAnnotation(DataSourceType.class);        }
        if (null != annotation) {
            // 切换数据源
            DataSourceContextHolder.switchDataSource(annotation.value());
        }
    }
    @After("cutMethod()")
    public void afterExecute() {
        DataSourceContextHolder.clear();
    }
}

public class Student implements Serializable {
    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student(String name) {
        this.name = name;
    }
    public Student(){}
    @Override
    public String toString() {
        return "\n{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

@Mapper
public interface StudentMapper {
    @Insert("insert into Student(name) values(#{name})")
    int insertStudent(Student student);

    @Select("select * from Student")
    List<Student> selectStudent();
}


@Service
public class StudentService {

    @Autowired
    StudentMapper studentMapper;

    @DataSourceType("write")
    public int saveStudent(Student student){
        return studentMapper.insertStudent(student);
    }

    @DataSourceType("read")
    @Transactional(propagation= Propagation.REQUIRED,isolation= Isolation.DEFAULT,readOnly=true)
    public List<Student> getStudents(){
        return studentMapper.selectStudent();
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest(classes = APP.class)
public class Test {
    @Autowired
    StudentService studentService;

    @org.junit.Test
    public void stu(){
        Random random = new Random();
        Student student = new Student("小米"+random.nextInt(100));

        System.out.println(studentService.saveStudent(student));

        System.out.println(Arrays.toString(studentService.getStudents().toArray()));
    }
}

public static void main(String[] args) throws IOException {
    log.info("info");    //信息日志
    log.warning("warning"); //警告日志
    log.log(Level.SEVERE,"server"); //严重日志
    log.fine("fine");
}

log.setLevel(Level.ALL);//设置logger的日志级别为全部，默认输出所有级别日志信息

log.setUseParentHandlers(false); //禁用日志原本处理类
ConsoleHandler consoleHandler = new ConsoleHandler(); //创建控制台输出控制Handler
consoleHandler.setLevel(Level.INFO); //设置控制台输出级别
log.addHandler(consoleHandler); //将Handler加入logger中

//文件输出日志方式
log.setUseParentHandlers(false); //禁用日志原本处理类

FileHandler fileHandler = new FileHandler("日志路径/testlog.log");
fileHandler.setLevel(Level.ALL); //记录级别
log.addHandler(fileHandler); //添加Handler

public class MyHandler extends Handler {

    private LogRecord record;

    @Override
    public void publish(LogRecord record) {
        this.record = record;
        //自定义内容
    }

    @Override
    public void flush() {
        System.out.println("logger:"+this.record.getLoggerName()+"flush");
    }

    @Override
    public void close() throws SecurityException {
        System.out.println("logger:"+this.record.getLoggerName()+"close");
    }
}


    //测试
    public static void main(String[] args) throws IOException {

        log.setUseParentHandlers(false); //禁用日志原本处理类

        MyHandler myHandler = new MyHandler();  //创建自定义日志处理类实体
        log.addHandler(myHandler); //添加日志处理实体类
        
        //...
    }

public class MyFormate extends Formatter {
    @Override
    public String format(LogRecord record) {
        return new Date()+"-["+record.getSourceClassName()+"."+record.getSourceMethodName()+"]"+record.getLevel()+":"+record.getMessage()+"\n";
    }
}


man方法中修改为：
        FileHandler fileHandler = new FileHandler("日志路径/testlog.log");
        fileHandler.setLevel(Level.ALL); //记录级别
        fileHandler.setFormatter(new MyFormate()); //设置自定义样式
        log.addHandler(fileHandler); //添加Handler

public class SLF4j {
    public static void main(String[] args){
        Logger log = LoggerFactory.getLogger("SLF4j");
        log.info("SLF4j");
    }
}

public static Logger getLogger(Class<?> clazz) {
    Logger logger = getLogger(clazz.getName());
    if (DETECT_LOGGER_NAME_MISMATCH) {
        Class<?> autoComputedCallingClass = Util.getCallingClass();
        if (autoComputedCallingClass != null && nonMatchingClasses(clazz, autoComputedCallingClass)) {
            Util.report(String.format("Detected logger name mismatch. Given name: \"%s\"; computed name: \"%s\".", logger.getName(),
                            autoComputedCallingClass.getName()));
            Util.report("See " + LOGGER_NAME_MISMATCH_URL + " for an explanation");
        }
    }
    return logger;
}

    private final static void bind() {
        try {
            Set<URL> staticLoggerBinderPathSet = null;
            // skip check under android, see also
            // http://jira.qos.ch/browse/SLF4J-328
            if (!isAndroid()) {
                //去classpath下找STATIC_LOGGER_BINDER_PATH，STATIC_LOGGER_BINDER_PATH值为"org/slf4j/impl/StaticLoggerBinder.class"，
	//即所有slf4j的实现，\提供的jar包路径下，一定是有"org/slf4j/impl/StaticLoggerBinder.class"存在
                staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
            }
            // the next line does the binding 选取一个StaticLoggerBinder.class来创建一个单例
            StaticLoggerBinder.getSingleton();
            INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
            reportActualBinding(staticLoggerBinderPathSet);
            fixSubstituteLoggers();
            replayEvents();
            // release all resources in SUBST_FACTORY
            SUBST_FACTORY.clear();
        } catch (NoClassDefFoundError ncde) {
            String msg = ncde.getMessage();
            if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
                INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
                Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
                Util.report("Defaulting to no-operation (NOP) logger implementation");
                Util.report("See " + NO_STATICLOGGERBINDER_URL + " for further details.");
            } else {
                failedBinding(ncde);
                throw ncde;
            }
        } catch (java.lang.NoSuchMethodError nsme) {
            String msg = nsme.getMessage();
            if (msg != null && msg.contains("org.slf4j.impl.StaticLoggerBinder.getSingleton()")) {
                INITIALIZATION_STATE = FAILED_INITIALIZATION;
                Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
                Util.report("Your binding is version 1.5.5 or earlier.");
                Util.report("Upgrade your binding to version 1.6.x.");
            }
            throw nsme;
        } catch (Exception e) {
            failedBinding(e);
            throw new IllegalStateException("Unexpected initialization failure", e);
        }
    }

//获取所有加载的实现放到set中 避免在系统中同时引入多个slf4j的实现，所以接收的地方是一个Set。
    static Set<URL> findPossibleStaticLoggerBinderPathSet() {
        // 通过ClassLoader加载"org/slf4j/impl/StaticLoggerBinder.class"
        Set<URL> staticLoggerBinderPathSet = new LinkedHashSet<URL>();
        try {
            ClassLoader loggerFactoryClassLoader = LoggerFactory.class.getClassLoader();
            Enumeration<URL> paths;
            if (loggerFactoryClassLoader == null) {
                paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
            } else {
                paths = loggerFactoryClassLoader.getResources(STATIC_LOGGER_BINDER_PATH);
            }
            while (paths.hasMoreElements()) {
                URL path = paths.nextElement();
                staticLoggerBinderPathSet.add(path);
            }
        } catch (IOException ioe) {
            Util.report("Error getting resources from path", ioe);
        }
        return staticLoggerBinderPathSet;
    }

/**
     * 若在class path中找到多个绑定类,则打印警告信息
     */
    private static void reportMultipleBindingAmbiguity(Set<URL> binderPathSet) {
        if (isAmbiguousStaticLoggerBinderPathSet(binderPathSet)) {
            Util.report("Class path contains multiple SLF4J bindings.");
            for (URL path : binderPathSet) {
                Util.report("Found binding in [" + path + "]");
            }
            Util.report("See " + MULTIPLE_BINDINGS_URL + " for an explanation.");
        }
    }

private static void reportActualBinding(Set<URL> binderPathSet) {
    // binderPathSet can be null under Android
    if (binderPathSet != null && isAmbiguousStaticLoggerBinderPathSet(binderPathSet)) {
        Util.report("Actual binding is of type [" + StaticLoggerBinder.getSingleton().getLoggerFactoryClassStr() + "]");
    }
}

    public static Logger getLogger(String name) {
//不同的StaticLoggerBinder其getLoggerFactory实现不同 返回一个ILoggerFactory实例 StaticLoggerBinder.getSingleton().getLoggerFactory();
        ILoggerFactory iLoggerFactory = getILoggerFactory();
        return iLoggerFactory.getLogger(name);
    }

    public Logger getLogger(String name) {
        Logger slf4jLogger = (Logger)this.loggerMap.get(name);
        if (slf4jLogger != null) {
            return slf4jLogger;
        } else {
            org.apache.log4j.Logger log4jLogger;
	////调用日志框架实现生成"org.apache.log4j.Logger "
            if (name.equalsIgnoreCase("ROOT")) {
                log4jLogger = LogManager.getRootLogger();
            } else {
                log4jLogger = LogManager.getLogger(name);
            }
	//使用适配器包装"org.apache.log4j.Logger "
            Logger newInstance = new Log4jLoggerAdapter(log4jLogger);
            Logger oldInstance = (Logger)this.loggerMap.putIfAbsent(name, newInstance);
            return (Logger)(oldInstance == null ? newInstance : oldInstance);
        }
    }

static {
    try {
        Class.forName("org.apache.log4j.Log4jLoggerFactory");
        String part1 = "Detected both log4j-over-slf4j.jar AND bound slf4j-log4j12.jar on the class path, preempting StackOverflowError. ";
        String part2 = "See also http://www.slf4j.org/codes.html#log4jDelegationLoop for more details.";
        Util.report(part1);
        Util.report(part2);
        throw new IllegalStateException(part1 + part2);
    } catch (ClassNotFoundException var2) {
//TODO:增加日志
    }
}

public interface BeanFactory {    
     
     //对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象， 如果需要得到工厂本身，需要转义。 
     String FACTORY_BEAN_PREFIX = "&"; 
        
     //根据bean的名字，获取在IOC容器中得到bean实例    
     Object getBean(String name) throws BeansException;    
   
    //根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。    
     Object getBean(String name, Class requiredType) throws BeansException;    
    
    //提供对bean的检索，看看是否在IOC容器有这个名字的bean    
     boolean containsBean(String name);    
    
    //根据bean名字得到bean实例，并同时判断这个bean是不是单例    
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;    
    
    //得到bean实例的Class类型    
    Class getType(String name) throws NoSuchBeanDefinitionException;    
    
    //得到bean的别名，如果根据别名检索，那么其原名也会被检索出来    
   String[] getAliases(String name);    
    
 }