Java Spring

/**
 * @author z201.coding@gmail.com
 * spring ioc 延时查找
 **/
public class DelayLookup {

    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "DelayLookup{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * @author z201.coding@gmail.com
 **/
@Point
public class AnnotationDelayLookup extends DelayLookup{
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "AnnotationDelayLookup{" +
                "address='" + address + '\'' +
                "} " + super.toString();
    }
}

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

}

public class IOCDelayLookupTest {

    @Test
    public void testLookup() {
        // 编辑 ioc-delay-lookup-context.xml 并创建对应bean。
        // 启动 spring 上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INF/ioc-delay-lookup-context.xml");
        lookup(beanFactory);
        lookupLazy(beanFactory);
        lookupType(beanFactory);
        lookupCollectionType(beanFactory);
        lookupAnnotationType(beanFactory);
    }


    /**
     * 实时查找
     *
     * @param beanFactory
     */
    private void lookup(BeanFactory beanFactory) {
        // 根据id 获取bean
        DelayLookup delayLookup = (DelayLookup) beanFactory.getBean("delayLookup");
        // 重写 DelayLookup.toString()方法成功输出 spring 。
        System.out.println("实时查找 " + delayLookup);
    }

    /**
     * 延时查找
     *
     * @param beanFactory
     */
    private void lookupLazy(BeanFactory beanFactory) {
        // 根据id 获取bean
        ObjectFactory<DelayLookup> delayLookup = (ObjectFactory<DelayLookup>) beanFactory.getBean("objectFactory");
        // 重写 DelayLookup.toString()方法成功输出 spring 。
        System.out.println("延时查找 " + delayLookup.getObject());
    }

    /**
     * 单一类型查找
     *
     * @param beanFactory
     */
    private void lookupType(BeanFactory beanFactory) {
        // 根据id 获取bean
        DelayLookup delayLookup = beanFactory.getBean(DelayLookup.class);
        // 重写 DelayLookup.toString()方法成功输出 spring 。
        System.out.println("单一类型查找  " + delayLookup);
    }


    /**
     * 单一类型集合查找
     *
     * @param beanFactory
     */
    private void lookupCollectionType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, DelayLookup> delayLookupMap = listableBeanFactory.getBeansOfType(DelayLookup.class);
            // getBeansOfType 匹配所有类型的 bean，无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
            delayLookupMap.forEach((key, value) -> {
                System.out.println("单一类型集合查找  " + key + " " + value);
            });
        }
    }

    /**
     * Java注解查找
     * 通过注解查找只需要
     *
     * @param beanFactory
     */
    private void lookupAnnotationType(BeanFactory beanFactory) {
        // Point
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, AnnotationDelayLookup> delayLookupMap = (Map) listableBeanFactory.getBeansWithAnnotation(Point.class);
            // getBeansOfType 匹配所有类型的 bean，无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
            delayLookupMap.forEach((key, value) -> {
                System.out.println("Java注解 @Point 查找  " + key + " " + value);
            });
        }

    }

}

/**
 * @author z201.coding@gmail.com
 **/
public class InjectionBean {

    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "InjectionBean{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * @author z201.coding@gmail.com
 **/
public class InjectionRepository {

    private Collection<InjectionBean> beans;

    public Collection<InjectionBean> getBeans() {
        return beans;
    }

    public void setBeans(Collection<InjectionBean> beans) {
        this.beans = beans;
    }

    @Override
    public String toString() {
        return "InjectionRepository{" +
                "beans=" + beans +
                '}';
    }
}


/**
 * @author z201.coding@gmail.com
 **/
public class IOCInjectionTest {

    @Test
    public void testInjection() {
        // 编辑 ioc-delay-lookup-context.xml 并创建对应bean。
        // 启动 spring 上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INF/ioc-delay-injection-context.xml");
        lookupType(beanFactory);
        lookupCollectionType(beanFactory);
    }

    /**
     * 单一对象注入
     *
     * @param beanFactory
     */
    private void lookupType(BeanFactory beanFactory) {
        // 根据id 获取bean
        InjectionBean injectionBean = beanFactory.getBean(InjectionBean.class);
        // 重写 DelayLookup.toString()方法成功输出 spring 。
        System.out.println("单一对象注入  " + injectionBean);
    }

    /**
     * 集合对象注入
     *
     * @param beanFactory
     */
    private void lookupCollectionType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, InjectionRepository> delayLookupMap = listableBeanFactory.getBeansOfType(InjectionRepository.class);
            // getBeansOfType 匹配所有类型的 bean，无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
            delayLookupMap.forEach((key, value) -> {
                System.out.println("集合对象注入  " + key + " " + value);
            });
        }
    }
}

public class TestServiceImpl { 
  // 下面两种@Autowired只要使用一种即可 
  @Autowired 
  private UserDao userDao; // 用于字段上 
  
  @Autowired  // 用于属性的方法上
  public void setUserDao(UserDao userDao) 
  {  
    this.userDao = userDao; 
  } 
}
// @Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允
// 许null值，可以设置它的required属性为false。如果我们想使用按照名称（byName）来装配，可以结
// 合@Qualifier注解一起使用。如下：
public class TestServiceImpl {
  @Autowired 
  @Qualifier("userDao") private UserDao userDao;
}

public class TestServiceImpl { 
  // 下面两种@Resource只要使用一种即可 
  
  // 用于字段上 
  @Resource(name="userDao") 
  private UserDao userDao; 
  
  // 用于属性的setter方法上 
  @Resource(name="userDao") 
  public void setUserDao(UserDao userDao) { 
    this.userDao = userDao;
  } 
}

/**
 * @author z201.coding@gmail.com
 * 演示
 * DefaultListableBeanFactory 基于xml配置信息创建bean
 * AnnotationConfigApplicationContext 基于注解类创建bean
 **/
public class IocContainerTest {

    @Test
    public void setupXmlApplicationContext(){
        // 创建BeanFactory 容器
        DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(defaultListableBeanFactory);
        String location = "classpath:META-INF/ioc-delay-injection-context.xml";
        // 加载 xml格式的配置文件，并获取bean的数量
        int beanDefinitionCount =  reader.loadBeanDefinitions(location);
        System.out.println("bean 定义加载的数量 " + beanDefinitionCount);
        lookupCollectionType(defaultListableBeanFactory);
    }

    @Test
    public void setupAnnotationConfigApplicationContext(){
        // 创建BeanFactory 容器
        AnnotationConfigApplicationContext config = new AnnotationConfigApplicationContext();
        // 加载 IocContainer 作为bean配置类，配置类需要添加@Configuration注解
        config.register(IocContainer.class);
        // 启动应用上下文
        config.refresh();
        lookupCollectionType(config);
        // 关闭上下文
        config.close();
    }

    /**
     * 集合对象注入
     *
     * @param beanFactory
     */
    private void lookupCollectionType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, SuperInjectionBean> delayLookupMap = listableBeanFactory.getBeansOfType(SuperInjectionBean.class);
            // getBeansOfType 匹配所有类型的 bean，无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
            delayLookupMap.forEach((key, value) -> {
                System.out.println("集合对象注入  " + key + " " + value);
            });
        }
    }
}

// 可以使用 @Component 注解方式来注册 Bean
@Component
public class Person {
   private Integer id;
   private String name
   // 忽略其他方法
}

// @Bean 注解方式来注册 Bean
@Configuration
public class Person {
   @Bean
   public Person  person(){
      return new Person();
   }
   // 忽略其他方法
}

// 使用 BeanDefinitionRegistry.registerBeanDefinition() 方法的方式注册 Bean	
public class CustomBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
	}
	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		RootBeanDefinition personBean = new RootBeanDefinition(Person.class);
		// 新增 Bean
		registry.registerBeanDefinition("person", personBean);
	}
}

/{application}.yml
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        //创建 dev 环境下的 DataSource 
    }
 
    @Bean()
    @Profile("prod")
    public DataSource prodDataSource(){
        //创建 prod 环境下的 DataSource 
    }

@SpringBootApplication
public class BlogApplication {
    public static void main(String[] args) {
        SpringApplication.run(VueBlogApplication.class, args);
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
   
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
    @AliasFor(annotation = Component.class)
    String value() default "";
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

}


/**
	 * Return the auto-configuration class names that should be considered. By default
	 * this method will load candidates using {@link SpringFactoriesLoader} with
	 * {@link #getSpringFactoriesLoaderFactoryClass()}.
	 * @param metadata the source metadata
	 * @param attributes the {@link #getAttributes(AnnotationMetadata) annotation
	 * attributes}
	 * @return a list of candidate configurations
	 */
	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
				+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}

# Logging Systems
org.springframework.boot.logging.LoggingSystemFactory=\
org.springframework.boot.logging.logback.LogbackLoggingSystem.Factory,\
org.springframework.boot.logging.log4j2.Log4J2LoggingSystem.Factory,\
org.springframework.boot.logging.java.JavaLoggingSystem.Factory

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader
....

//获取所有factories文件中配置的LoggingSystemFactory
List<LoggingSystemFactory>> factories = 
    SpringFactoriesLoader.loadFactories(LoggingSystemFactory.class, classLoader);	

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    /*
     * 一级缓存
     * singletonObjects 这就是人们常说的单例池，从微观意义上来说，这就是我们的 Spring 容器，
     * 它用于存放完全初始化好的 bean，从缓存中取出的 bean 可以直接使用。
     */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    /*
     * 三级缓存
     * 存放 bean 工厂对象，提前曝光引用，解决循环依赖，虽然这个对象不完整，但是已经可以根据引用定位到堆内存中的对象，
     * 此对象可能是通过构造方法创建，还没装配属性。
     */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    /*
     * 二级缓存
     * 存放原始的 bean 对象用于解决循环依赖，存到里面的对象还没有被填充属性。
     */
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

    /** Names of beans that are currently in creation */
    // 标记为正在创建的 bean 的集合(A 依赖于 B，实例化 A 的过程中发现依赖 B，就去创建 B，那么 A 就会放在此集合中)
    private final Set<String> singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));
}

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class ExecuteTimeInterceptor extends HandlerInterceptorAdapter{

	private static final Logger logger = Logger.getLogger(ExecuteTimeInterceptor.class);

	//before the actual handler will be executed
	public boolean preHandle(HttpServletRequest request,
		HttpServletResponse response, Object handler)
		throws Exception {

		long startTime = System.currentTimeMillis();
		request.setAttribute("startTime", startTime);

		return true;
	}

	//after the handler is executed
	public void postHandle(
		HttpServletRequest request, HttpServletResponse response,
		Object handler, ModelAndView modelAndView)
		throws Exception {

		long startTime = (Long)request.getAttribute("startTime");

		long endTime = System.currentTimeMillis();

		long executeTime = endTime - startTime;

		//modified the exisitng modelAndView
		modelAndView.addObject("executeTime",executeTime);

		//log it
		if(logger.isDebugEnabled()){
		   logger.debug("[" + handler + "] executeTime : " + executeTime + "ms");
		}
	}
}

public interface TransactionStatus{
    boolean isNewTransaction(); // 是否是新的事物
    boolean hasSavepoint(); // 是否有恢复点
    void setRollbackOnly();  // 设置为只回滚
    boolean isRollbackOnly(); // 是否为只回滚
    boolean isCompleted; // 是否已完成
} 

public ConfigurableApplicationContext run(String... args) {
    // 1.创建并启动计时监控类
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    // 2.声明应用上下文对象和异常报告集合
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
    // 3.设置系统属性 headless 的值
    this.configureHeadlessProperty();
    // 4.创建所有 Spring 运行监听器并发布应用启动事件
    SpringApplicationRunListeners listeners = this.getRunListeners(args);
    listeners.starting();
    Collection exceptionReporters;
    try {
        // 5.处理 args 参数
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 6.准备环境
        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
        this.configureIgnoreBeanInfo(environment);
        // 7.创建 Banner 的打印类
        Banner printedBanner = this.printBanner(environment);
        // 8.创建应用上下文
        context = this.createApplicationContext();
        // 9.实例化异常报告器
        exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
        // 10.准备应用上下文
        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        // 11.刷新应用上下文
        this.refreshContext(context);
        // 12.应用上下文刷新之后的事件的处理
        this.afterRefresh(context, applicationArguments);
        // 13.停止计时监控类
        stopWatch.stop();
        // 14.输出日志记录执行主类名、时间信息
        if (this.logStartupInfo) {
            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
        }
        // 15.发布应用上下文启动完成事件
        listeners.started(context);
        // 16.执行所有 Runner 运行器
        this.callRunners(context, applicationArguments);
    } catch (Throwable var10) {
        this.handleRunFailure(context, var10, exceptionReporters, listeners);
        throw new IllegalStateException(var10);
    }
    try {
        // 17.发布应用上下文就绪事件
        listeners.running(context);
        // 18.返回应用上下文对象
        return context;
    } catch (Throwable var9) {
        this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
        throw new IllegalStateException(var9);
    }
}