class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        HashSet<String> set = new HashSet<>(wordDict);
        if(s.length() == 0) return set.contains(s);
        boolean[] dp = new boolean[s.length()];
        for(int i = 0; i < s.length(); i++){
            if(set.contains(s.substring(0, i + 1))){
                dp[i] = true;
                continue;
            }
            int tmp = 0;
            while(tmp < i){
                if(dp[tmp] && set.contains(s.substring(tmp + 1, i + 1))){
                    dp[i] = true;
                    break;
                }
                tmp++;
            }
            if(dp[i]) continue;
            dp[i] = false;
        }
        return dp[s.length() - 1];
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<TreeNode> generateTrees(int n) {
        Map<Pair<Integer, Integer>, List<TreeNode>> memo = new HashMap<>();
        return generateTreesWithRoot(1, n, memo);
    }
    public List<TreeNode> generateTreesWithRoot(int l, int r, Map<Pair<Integer, Integer>, List<TreeNode>> memo) {
        List<TreeNode> res = new ArrayList<>();
        if(l > r) {
            res.add(null);
            return res;
        }

        if(memo.containsKey(new Pair<>(l, r))) {
            return memo.get(new Pair<>(l, r));
        }

        for(int i = l; i <= r; i++) {
            List<TreeNode> leftSubTrees = generateTreesWithRoot(l, i - 1, memo);
            List<TreeNode> rightSubTrees = generateTreesWithRoot(i + 1, r, memo);
            for (TreeNode left: leftSubTrees) {
                for (TreeNode right: rightSubTrees) {
                    TreeNode root = new TreeNode(i, left, right);
                    res.add(root);
                }
            }
        }
        memo.put(new Pair<>(l, r), res);
        return res;
    }
}

class Solution {
    public int numMusicPlaylists(int n, int goal, int k) {
        int MOD = 1_000_000_007;

        // Initialize the DP table
        long[][] dp = new long[goal + 1][n + 1];
        dp[0][0] = 1;

        for (int i = 1; i <= goal; i++) {
            for (int j = 1; j <= Math.min(i, n); j++) {
                // The i-th song is a new song
                dp[i][j] = dp[i - 1][j - 1] * (n - j + 1) % MOD;
                // The i-th song is a song we have played before
                if (j > k) {
                    dp[i][j] = (dp[i][j] + dp[i - 1][j] * (j - k)) % MOD;
                }
            }
        }

        return (int) dp[goal][n];
    }
}

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int m = matrix.length;
        int n = matrix[0].length;
        int left = 0, right = m * n - 1;
        while(left <= right) {
            int mid = left + (right - left) / 2;
            int mid_row = mid / n;
            int mid_col = mid - mid_row * n;

            if(matrix[mid_row][mid_col] == target) {
                return true;
            }
            if(matrix[mid_row][mid_col] < target){
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return false;
    }
}

class Solution {
    public int numOfWays(int n) {
        long a121 = 6, a123 = 6, b121, b123, mod = (long)1e9 + 7;
        for (int i = 1; i < n; ++i) {
            b121 = a121 * 3 + a123 * 2;
            b123 = a121 * 2 + a123 * 2;
            a121 = b121 % mod;
            a123 = b123 % mod;
        }
        return (int)((a121 + a123) % mod);
    }
}

class Solution {
    public boolean isRobotBounded(String instructions) {
        int[][] directions = new int[][]{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        int x = 0, y = 0;
        int idx = 0;
        for (char i : instructions.toCharArray()) {
            if (i == 'L')
                idx = (idx + 3) % 4;
            else if (i == 'R')
                idx = (idx + 1) % 4;
            else {
                x += directions[idx][0];
                y += directions[idx][1];
            }    
        }
        return (x == 0 && y == 0) || (idx != 0);
    }
}

class Solution {
    public int leftMostColumnWithOne(BinaryMatrix binaryMatrix) {
        int rows = binaryMatrix.dimensions().get(0);
        int columns = binaryMatrix.dimensions().get(1);
        int res = columns;
        for(int row = 0; row < rows; row++) {
            int lo = 0;
            int hi = columns - 1;
            while(lo < hi) {
                int mid = lo + (hi - lo) / 2;
                if(binaryMatrix.get(row, mid) == 0) {
                    lo = mid + 1;
                } else {
                    hi = mid;
                }
            }
            if(binaryMatrix.get(row, lo) == 1) {
                res = Math.min(lo, res);
            }
        }
        return res == columns ? -1 : res;
    }
}

class Solution {
    public int leftMostColumnWithOne(BinaryMatrix binaryMatrix) {
        List<Integer> dimensions = binaryMatrix.dimensions();
        int r = dimensions.get(0) - 1;
        int c = dimensions.get(1) - 1;
        
        while (r >= 0 && c >= 0) {
            if (binaryMatrix.get(r, c) == 0) {
                r--;
            } else {
                c--;
            }
        }
        
        if (c == dimensions.get(1) - 1) {
            return -1;
        }
        return c + 1;
    }
}

class Solution {
    public void moveZeroes(int[] nums) {
        for(int p = 0, q = 0; p < nums.length; p++) {
            if(nums[p] != 0) {
                int temp = nums[p];
                nums[p] = nums[q];
                nums[q] = temp;
                q++;
            }
        }
    }
}

class Solution {
    public int numPairsDivisibleBy60(int[] time) {
        int[] remains = new int[60];
        int count = 0;
        for(int t : time) {
            if (t % 60 == 0) {
                count += remains[0];
            } else {
                count += remains[60 - t % 60];
            }
            remains[t % 60]++;
        }
        return count;
    }
}

public class HelloLoader {
    public static void main(String[] args) {
        System.out.println("谢谢ClassLoader加载我....");
        System.out.println("你的大恩大德，我下辈子再报！");
    }
}

public class HelloApp {
    private static int a = 1;   //prepare：a = 0 ---> initial : a = 1

    public static void main(String[] args) {
        System.out.println(a);
    }
}

public class ClassInitTest {
    private static int num = 1;
    private static int number = 10;      //linking之prepare: number = 0 --> initial: 10 --> 20

    static {
        num = 2;
        number = 20;
        System.out.println(num);
        //System.out.println(number);    //报错：非法的前向引用（可以赋值，但不能调用）
    }

    public static void main(String[] args) {
        System.out.println(ClassInitTest.num);//2
        System.out.println(ClassInitTest.number);//10
    }
}

blic class ClassInitTest {
   private static int num = 1;

   static{
       num = 2;
       number = 20;
       System.out.println(num);
       //System.out.println(number);    //报错：非法的前向引用（可以赋值，但不能调用）
   }

   private static int number = 10;      //linking之prepare: number = 0 --> initial: 20 --> 10

    public static void main(String[] args) {
        System.out.println(ClassInitTest.num);		//2
        System.out.println(ClassInitTest.number);	//10
    }
}

public class ClinitTest {
    //任何一个类声明以后，内部至少存在一个类的构造器
    private int a = 1;
    private static int c = 3;

    public static void main(String[] args) {
        int b = 2;
    }

    public ClinitTest(){
        a = 10;
        int d = 20;
    }

}

public class ClinitTest1 {
    static class Father{
        public static int A = 1;
        static{
            A = 2;
        }
    }

    static class Son extends Father{
        public static int B = A;
    }

    public static void main(String[] args) {
        //加载Father类，其次加载Son类。
        System.out.println(Son.B);//2
    }
}

public class DeadThreadTest {
    public static void main(String[] args) {
        Runnable r = () -> {
            System.out.println(Thread.currentThread().getName() + "开始");
            DeadThread dead = new DeadThread();
            System.out.println(Thread.currentThread().getName() + "结束");
        };

        Thread t1 = new Thread(r, "线程1");
        Thread t2 = new Thread(r, "线程2");

        t1.start();
        t2.start();
    }
}

class DeadThread {
    static {
        if (true) {
            System.out.println(Thread.currentThread().getName() + "初始化当前类");
            while (true) {

            }
        }
    }
}

public class ClassLoaderTest {
    public static void main(String[] args) {

        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取其上层：扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent();
        System.out.println(extClassLoader);//sun.misc.Launcher$ExtClassLoader@1540e19d

        //获取其上层：获取不到引导类加载器
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();
        System.out.println(bootstrapClassLoader);//null

        //对于用户自定义类来说：默认使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //String类使用引导类加载器进行加载的。---> Java的核心类库都是使用引导类加载器进行加载的。
        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1);//null

    }
}

public class ClassLoaderTest1 {
    public static void main(String[] args) {

        System.out.println("**********启动类加载器**************");
        //获取BootstrapClassLoader能够加载的api的路径
        URL[] urLs = sun.misc.Launcher.getBootstrapClassPath().getURLs();
        for (URL element : urLs) {
            System.out.println(element.toExternalForm());
        }
        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:引导类加载器
        ClassLoader classLoader = Provider.class.getClassLoader();
        System.out.println(classLoader);//null

        System.out.println("***********扩展类加载器*************");
        String extDirs = System.getProperty("java.ext.dirs");
        for (String path : extDirs.split(";")) {
            System.out.println(path);
        }

        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:扩展类加载器
        ClassLoader classLoader1 = CurveDB.class.getClassLoader();
        System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@1540e19d

    }
}

public class CustomClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {

        try {
            byte[] result = getClassFromCustomPath(name);
            if (result == null) {
                throw new FileNotFoundException();
            } else {
                return defineClass(name, result, 0, result.length);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        throw new ClassNotFoundException(name);
    }

    private byte[] getClassFromCustomPath(String name) {
        //从自定义路径中加载指定类:细节略
        //如果指定路径的字节码文件进行了加密，则需要在此方法中进行解密操作。
        return null;
    }

    public static void main(String[] args) {
        CustomClassLoader customClassLoader = new CustomClassLoader();
        try {
            Class<?> clazz = Class.forName("One", true, customClassLoader);
            Object obj = clazz.newInstance();
            System.out.println(obj.getClass().getClassLoader());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ClassLoaderTest2 {
    public static void main(String[] args) {
        try {
            
            //1.Class.forName().getClassLoader()
            ClassLoader classLoader = Class.forName("java.lang.String").getClassLoader();
            System.out.println(classLoader); // String 类由启动类加载器加载，我们无法获取

            //2.Thread.currentThread().getContextClassLoader()
            ClassLoader classLoader1 = Thread.currentThread().getContextClassLoader();
            System.out.println(classLoader1);

            //3.ClassLoader.getSystemClassLoader().getParent()
            ClassLoader classLoader2 = ClassLoader.getSystemClassLoader();
            System.out.println(classLoader2);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
// 输出
null
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$AppClassLoader@18b4aac2

package java.lang;

public class String {
    static{
        System.out.println("我是自定义的String类的静态代码块");
    }
}

public class StringTest {

    public static void main(String[] args) {
        java.lang.String str = new java.lang.String();
        System.out.println("hello,atguigu.com");

        StringTest test = new StringTest();
        System.out.println(test.getClass().getClassLoader());
    }
}

package java.lang;

public class String {
    static{
        System.out.println("我是自定义的String类的静态代码块");
    }
    //错误: 在类 java.lang.String 中找不到 main 方法
    public static void main(String[] args) {
        System.out.println("hello,String");
    }
}

package java.lang;

public class ShkStart {
    public static void main(String[] args) {
        System.out.println("hello!");
    }
}

//配置类
@Configuration //告诉spring这事一个配置类
//@ComponentScan //value表示要扫描包的位置
//excludeFilters 要排除哪些Component,里面装着是Filter[]
@ComponentScan(value="com.atguigu", excludeFilters = {
  @Filter(type="FilterType.ANNOTATION",classes={Controller.class})
})
//Filter的type是表明按照什么方式去排除，里面有5种,分别是：FilterType.ANNOTATION, FilterType.ASPECTJ, FilterType.ASSIGNABLE, FilterType.CUSTOM, FilterType.REGEX 在后面跟classes 表明要去掉哪些包
//FilterType.ANNOTATION 按照注解
//FilterType.ASSIGNABLE_TYPE 按照给定的类型
@Filter(type="FilterType.ASSIGNABLE_TYPE",classes={BookService.class})
//FilterType.ASPECTJ 使用ASPECTJ表达式
//FilterType.REGEX 使用正则表达式规则
//FilterType.CUSTOM 给定一个TypeFilter的实现类
@Filter(type=FilterType.CUSTOM, classes={MyTypeFilter.class}) //就是看MyTypeFilter里面的math返回true或者false来决定匹不匹配

//includeFilters 扫描的时候只需要包含哪些组件，里面装着是Filter[] 注意只包含生效的条件是要禁用默认规则，默认规则是扫描所有的因此要禁用掉
@ComponentScan(value="com.atguigu", includeFilters = {
  @Filter(type="FilterType.ANNOTATION",classes={Controller.class})},useDefaultFilters = false)
//制定扫描策略，可以写多条
@ComponentScans(
	value = {
    @ComponentScan(value="com.atguigu", includeFilters = {
      @Filter(type="FilterType.ANNOTATION",classes={Controller.class})},useDefaultFilters = false)
  }
)
public class MainConfig{
  //给容器中注册一个Bean; 类型为返回值的类型，id默认是方法名作为id
  @Bean("person")
  public Person person(){
    return new Person("lisi",20);
  }
}

public class MyTypeFilter implements TypeFilter{
  //metadatareader读取的是当前正在扫描的类的信息
  //MetaDataReaderFactory 可以获取到其他任何类的信息
  @Override
  public boolean math(MetadataReader metadataReader, MetaDataReaderFactory metadatareaderfactory) {
    //获取当前类注解的信息
    AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
    //获取当前正在扫描类的类信息
    ClassMetadata classMetadata = metadataReader.getClassMetadata();
    //获取当前类资源信息(类的路径)
    Resource resource = metadataReader.getResource();
    //classMetadata 可以获取到当前类名 当前类子类、父类类名
    return false;
  }
}

@Configuration
//类中组件统一设置 满足当前条件，这个类中配置的所有bean注册才能生效
@Conditional({WindowsCondition.class})
@Import({Color.class, Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar})
public class MainConfig2{
  /*
  * 默认是单实例的
  * ConfigurableBeanFactory#SCOPE_PROTOTYPE -> "prototype"
  * ConfigurableBeanFacotry#SCOPE_SINGLETON -> "singleton"
  * org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST -> request
  * org.springframework.web.context.WebApplicationContext#SCOPE_SESSION -> session
  * 
  * prototype: 多实例: ioc容器启动并不会去调用方法创建对象放在容器中 每次获取的时候才会调用方法创建对象
  * singleton: 单实例(默认值) ioc容器启动会调用方法创建对象放到ioc容器中。以后每次获取就是直接从容器中(map.get())拿。
  * request: 同一请求创建一个实例
  * session: 同一个session创建一个实例
  * 
  * 懒加载 @Lazy
  * 	单实例bean:默认在容器启动的时候创建对象
  *   懒加载: 容器启动不创建对象。在第一次使用(获取)Bean创建对象，并初始化。
  */
  @Scope("prototype"/"singleton")
  @Lazy
  @Bean("person")
  public Person person() {
    return new Person("zhangsan",25);
  }
  
  /**
   * @Conditional({Conditon}): 按照一定的条件进行判断，满足条件给容器中注册bean
   * 如果系统是windows，给容器中注册("bill")
   * 如果系统是linux，给容器中注册("linux")
   */
  @Conditional({WindowsCondition.class})
  @Bean("bill")
  public Person person01(){
    return new Person("Bill Gates",62);
  }
  
  @Conditional({LinuxCondition.class})
  @Bean("linus")
  public Person person02(){
    return new Person("linus", 48);
  }
  
  /*
   * 给容器中注册组件
   * 1. 包扫描+标注注解(@Controller/@Service/@Service/@Repository/@Component)[自己写的]
   * 2. 使用@Bean[导入的第三方包的组件] --> 每次导入都需要写一条 有些麻烦
   * 3. @Import[快速的给容器导入一个组件]
   * 	1. @Import(要导入的组件) //容器中就会自动注册这个组件，id默认为全类名
   *  2. @ImportSelector(返回需要导入的组件的全类名数组)
   *  3. @ImportBeanDefinitionRegistrar: 手动注册bean到容器中
   * 4. 使用Spring提供的FactoryBean(工厂bean)
   *  1. 默认获取到的是工厂bean本身调用getObject创建的对象
   *  2. 要获取工厂bean本身，我们需要给id前面加一个&
   *		 &colorFactoryBean
   */
  
	//工厂bean获取的是调用getObject方法创建的对象，直接打印显示的是ColorFactoryBean 但是调用getClass的时候返回的是Color
  @Bean
  public ColorFactoryBean colorFactoryBean(){
    return new ColorFactoryBean();
  }
  
}

//随便创一个，假装外部组件
public class Color{
  
}
public class Red{
  
}
public class Blue{
  
}
public class Yellow{
  
}
public class RainBow{
  
}

//自定义逻辑 返回需要导入的组件
public class MyImportSelector implements ImportSelector{
  
  //返回值就是导入到容器中的组件全类名
  //AnnotationMetadata 当前标注@Import注解的类的所有注解信息
  @Override
  public String[] selectImports(AnnotationMetadata importingClassMetadata){
    
    //方法不要返回null
    //return null;
    return new String[]{"com.bean.Blue", "com.bean.Yellow"};
  }
}

//判断是否是linux系统
public class LinuxCondition implements Condition {

  /*
  * ConditionContext: 判断条件能使用的上下文(环境)
  * AnnotatedTypeMetadata: 注释信息
  */
  @Override
  public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
    // 是否是linux系统
    //1、能获取到ioc使用的beanfactory
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    //2、获取到类加载器
    ClassLoader classLoader = context.getClassLoader();
    //3、获取当前环境
    Environment environment = context.getEnvironment();
    //4、获取到bean定义的注册类
    BeanDefinitionRegistry registry = context.getregistry();
    
    //可以判断容器中的bean注册情况，也可以给容器中注册bean
    boolean definition = registry.containsBeanDefinition("person");
    
    String property = environment.getProperty("os.name");
    if(property.contains("Linux")) {
      return true;
    }
    return false;
  }
}

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar{
  
  /*
   *
   * AnnotationMetadata: 当前类的注解信息
   * BeanDefinitionRegistry: BeanDefinition注册类
   * 把所有需要添加到容器中的bean， 调用 beanDefinitionRegistry.registerBeanDefinitions 手工注册 
   */
  
  @Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    boolean definition = registry.containsBeanDefinition("Red->要写全类名");
    boolean definition2 = registry.containsBeanDefinition("Blue->要写全类名");
    if(definition && definition2) {
      //制定bean的定义信息 Bean的类型 Bean的scope
      RootBeanDefinition beanDefinition new RootBeanDefinition(Rainbow.class);
      //注册一个Bean
      registry.registerBeanDefinitions("rainBow",beanDefinition);
    }
  }
}

//创建一个spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color>{
  //返回一个Color对象，这个对象会添加到容器中
  @Override
  public Color getObject() thorws Exception{
    return new Color();
  }
  
  @Override
  public Class<?> getObjectType() {
    return Color.class
  }
  
  //是单例?
  //true 这个bean是单实例，在容器中会保存一份
  //false 这是一个多实例，每次获取都会创建一个新的bean -> 调用getObject方法
  @Override
  public boolean isSingleton(){
    return false;
  }
}

//判断是否是windows系统
public class WindowsCondition implements Condition {
  
  /*
  * ConditionContext: 判断条件能使用的上下文(环境)
  * AnnotatedTypeMetadata: 类的注解信息
  */
  
  @Override
  public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		Environment environment = context.getEnvironment();
    String property = environment.getProperty("os.name");
    if(property.contains("Windows")) {
      return true;
    }
    return false;
  }
}

@Controller
public class BookController{
  @AutoWired(required=false) // true:强制要求 false如果找不到就不装配了
  private BookService bookService;
}

@Service
public class BookService{
  @AutoWired
  private BookDao bookDao;
}

@Repository
public class BookDao{
  
}

public class MainTest{
  public static void main(String... args) {
    //配置文件方式启动
    //返回ioc容器
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    Person bean = (Person) applicationContext.getBean("person");
    System.out.println(bean);
    //配置类方式启动
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    Person bean = applicationContext.getBean("person");
    System.out.println(bean);
    
    String[] namesForType = applicationContext.getBeanNamesForType(Person.class);
    //person
    for(String string : namesForType) {
      System.out.println(string);
    }
  }
}

public class IOCTest{
  @Test
  public void test01(){
    AnnotationConfigapplicationContext applicationContext new AnnotationConfigapplicationContext(MainConfig.class);
    String[] definitionNames applicationContext.getBeanDefinitionName();
    for(String name : definitionNames) {
      System.out.println(name);
    }
    /* Output
     * mainConfig
     * bookController -> 要被排除掉
     * bookDao
     * bookService -> 要被排除掉
     * person
    */
  }
  
  public void test02(){
    AnnotationConfigapplicationContext applicationContext new AnnotationConfigapplicationContext(MainConfig2.class);
    String[] definitionNames applicationContext.getBeanDefinitionName();
    for(String name : definitionNames) {
      System.out.println(name);
    }
    //默认是单实例的
   	//bean == bean2
    Object bean = applicationContext.getBean("person");
    Object bean2 = applicationContext.getBean("person");
  }
  
  public void test03(){
    AnnotationConfigapplicationContext applicationContext new AnnotationConfigapplicationContext(MainConfig2.class);
    //获取当前context运行环境
    ConfigurableEnvironment environment = applicationContext.getEnvironment();
    environment.getProperty("os.name");
    //动态获取环境变量的值
    System.out.println(property);
    
    String[] definitionNames applicationContext.getBeanNamesForType(Person.class);
    for(String name : definitionNames) {
      System.out.println(name);
    }
    Map<String, Person> persons =  applicationContext.getBeansOfType(Person.class);
    System.out.println(persons);
  }
  
  @Test
  public void testImport(){
    AnnotationConfigapplicationContext applicationContext new AnnotationConfigapplicationContext(MainConfig2.class);
    String[] definitionNames applicationContext.getBeanDefinitionName();
    for(String name : definitionNames) {
      System.out.println(name);
    }
    Blue bean = applicationContext.getBean(Blue.class);
    System.out.println(bean);
    
    //工厂bean获取的是调用getObject方法创建的对象
    Object bean2 = applicationContext.getBean("colorFactoryBean");
    System.out.println("bean的类型" + bean2.getClass());
    //Output: color
    
    //通过id获取
    Object bean3 = applicationContext.getBean("&colorFactoryBean");
    System.out.println("bean的类型" + bean3.getClass());
    //class -> ColorFactoryBean
  }
}

/* bean的生命周期
 *		bean的创建---初始化---销毁的过程
 * 容器管理bean的生命周期
 * 我们可以自定义初始化和销毁方法，容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
 * 
 * 构造(对象创建)
 * 		单实例，在容器启动的时候创建对象
 *		多实例，在容器获取的时候创建对象
 * 初始化
 *		对象创建完成，并赋值好，调用初始方法。。。
 * 销毁
 *		单实例bean 容器关闭的时候进行销毁
 *		多实例bean 容器不会管理这个bean 容器不会调用销毁方法
 *
 * 遍历得到容器中所有的BeanPostProcessor 挨个执行beforeInitialization 一旦返回null 就直接跳出for循环 不会执行后面的BeanPostProcessor.applyBeanPostProcessorsBeforeInitialization
 * 
 *
 * BeanPostProcessor的原理
 * polulateBean(beanName, mbd, instanceWrapper); //给bean进行属性赋值
 * => initialization
 * {
 * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 * invokeInitMethods(beanName, wrappedBean, mbd); //执行自定义初始化方法
 * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 * }
 *
 * 1 指定初始化和销毁方法
 * 		init-method 和 destroy-method 以前使用配置文件指定
 *    通过@Bean指定init-method和destroy-method
 *
 * 2 通过让bean实现Initializingbean来定义初始化逻辑 DisposableBean(定义销毁逻辑)
 * 
 * 3 可以使用JRS250
 *		@PostConstruct 在bean创建完成并且属性赋值完成 来执行初始化
 *		@PreDestroy		 在容器销毁bean之前通知我们进行清理工作
 *
 * 4 BeanPostProcessor[interface] bean的后置处理器
 *		在bean初始化前后做一些处理工作->即使bean没有指定初始化方法
 *		postProcessBeforeInitialization: 在初始化之前进行后置处理工作
 *		postProcessAfterInitilization: 在初始化之后进行后置处理工作
 *
 * Spring底层对BeanPostProcessor的使用 ->底层好多
 * 		bean的赋值 注入其他组件 @Autowired生命周期注解功能 @Async BeanPostProcessor
 *
 */
@Configuration
@ComponentScan("com.bean")
public class MainConfigOfLifeCycle{
  
  @bean(initMethod="init",destroyMethod="destroy")
  public Car car(){
  	return new Car();  
  }
}

/*
 *	自定义后置处理器，初始化前后进行处理工作
 *	将后置处理器加入到容器中
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor{
  @Override	
  public Object postProcessBeforeInitialization(Object bean,String beanName) throws BeanException{
    System.out.println(beanName + "=>" + bean);
    return bean;
  }
 	@Override	
  public Object postProcessAfterInitilization(Object bean,String beanName) throws BeanException{
    System.out.println(beanName + "=>" + bean);
    return bean;
  }
}

public class Car{
  public Car(){
    System.out.println("car constructor");
  }
  public init(){
    System.out.println("car init...");
  }
  public destroy(){
    System.out.println("car destroy...");
  }
}

@Component
public class Cat implements InitilizingBean, DisposableBean{
  public Cat(){
    System.out.println("cat instructor");
  }
  
  @Override
  public void destroy() throws Exception{
    System.out.println("cat... destroy...");
  }
  @Override
  public void afterPropertiesSet() throws Exception{
    System.out.println("Cat... afterPropertiesSet...");
  }
}

@Component
public class Dog implements ApplicationContextAware{
  
  private ApplicationContext applicationContext;
  
  public Dog(){
    System.out.println("dog constructor");
  }
  
  //对象创建并赋值之后调用
  @PostConstruct
  public void init(){
    System.out.println("dog @PostConstruct...");
  }
  //容器移除对象之前
  @PreDestroy
  public void destroy(){
    System.out.println("dog @PostDestroy");
  }
  
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeanException{
    this.applicationContext = applicationContext;
  }
}

public class IOCTest_LifeCycle{
  
  @Test
  public void test01(){
    //创建ioc容器
    AnnotationConfigapplicationContext applicationContext new AnnotationConfigapplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
    
    applicationContext.close();
  }
}

@Configuration
//使用@PropertySource读取外部配置文件中的属性 保存到运行的环境变量中 加载完外部的配置文件以后再使用${}取出配置文件的值
@PropertySource(value={"classpath:/person.properties"})
public class MainConfigOfPropertyValues{
  @Bean
  public Person person(){
    
  }
}

public class Person{
  //使用@Value赋值
  //基本数值
  //可以写SpEL #{}
  //可以写${} 取出配置文件中的值[properties](在运行环境变量里面的值)
  
  @Value("zhangsan")
  private String name;
  
  @Value("#{20-2}")
  private Integer age;
  @Value("${person.nickName}")
  private String NickName;
}

public class IOCTest_PropertyValue{
  
  @Test
  public void test01(){
    //创建ioc容器
    AnnotationConfigapplicationContext applicationContext new AnnotationConfigapplicationContext(MainConfigOfPropertyValues.class);
    System.out.println("容器创建完成");
    Person person = (Person)applicationContext.getBean("person");
    ConfigurableEnvironment environment = applicationContext.getEnvironment();
    String property = environment.getProperty("person.nickName");
    System.out.println(property);
    String[] definitionNames applicationContext.getBeanDefinitionName();
    for(String name : definitionNames) {
      System.out.println(name);
    }
    applicationContext.close();
  }
}

/*
 * 自动装配
 * 		Spring利用依赖注入(DI) 完成对IOC容器中各个组件的关系依赖赋值
 *		1. AutoWired 自动注入
 *			1. 默认优先按照类型去容器中找对应的组件，找到就赋值
 *			2. 如果找到相同类型的组件，再将属性的名称作为组件的id去容器中查找
 *					applicationContext.getBean("bookDao")
 *			3. @Qualifier("bookdao")使用@Qualifier指定需要装配的组件的id
 *			4. 自动装配默认一定要将属性赋值好，没有就报错
 *			5. Primary 让Spring进行自动装配的时候默认使用首选bean 这个时候不用Qualifier 但是也可以继续使用@Qualifier指定需要装配的bean的名字
 *		2. Spring还支持使用@Resource(JSR250)@Inject(JSR330)[Java规范的注解]
 *			@Resource:
 *				可以和Autowired一样实现自动装配功能，但是这个注解默认是按照组件名称进行装配 也可以使用@Resource(name="bookDao2")指定装配的bean
 *				没有支持@Primary功能没有支持@Autowired(required=false)
 *			@Inject:
 *				需要导入javax.inject的包，和Autowired功能一样
 *	@Autowired:Spring定义的:@Resource,@Inject都是java规范
 *		3. @Autowired: 构造器 参数 方法 属性 都是从容器中获取参数组件的值
 *			1. 标在方法位置 @Bean标注的方法，创建对象的时候 方法参数的值从容器中获取 默认不写也是一样的 都能自动装配
 *			2. 标在构造器上 如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是能够自动从容器中获取
 *			3. 放在参数位置上
 *		4. 自定义组件想要用Spring容器底层的一些组件(ApplicationContext, BeanFactory)
 *			自定义组件实现xxxAware 在创建对象的时候 会调用接口规定的方法注入相关组件 Aware
 *			把Spring底层一些组件注入到自定义的bean中
 *			xxxAware 功能 使用xxxProcessor来处理
 */
@Configuration
@ComponentScan({"com.service","com.dao","com.controller"})
public class MainConfigAutowired{
	
  
}

//默认加载ioc容器中的组件 容器启动会调用无参构造器创建对象，再进行初始化赋值等操作
@Component
public class Boss{
  //@Autowired
  private Car car;
  
  @Autowired
  public Boss(@Autowired Car car){
    this.car = car;
  }
  
  //@Autowired //标注在方法上 Spring容器创建当前对象 就会调用方法 完成赋值
  //方法使用的参数，自定义类型的值从ioc容器中获取
  public void setCar(Car car){
    this.car = car;
  }
}

public class IOCTest_Autowired{
  
  @Test
  public void test01(){
    //创建ioc容器
    AnnotationConfigapplicationContext applicationContext new AnnotationConfigapplicationContext(MainConfigAutowired.class);
    System.out.println("容器创建完成");
    BookService bookService = applicationContext.getBean(BookService.class);
    System.out.println(bookService);
    BookDao bookDao = applicationContext.getBean(BookDao.class);
    //bookDao == bookService.bookDao;
    applicationContext.close();
  }
}