package org.springframework.beans.factory;
import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;
public interface BeanFactory {
	// 前綴
    String FACTORY_BEAN_PREFIX = "&";
	// 多個getBean方法
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
	// 是否包含Bean
    boolean containsBean(String name);
	//是否單例
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	// 是否原型
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
	// 是否類型匹配
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
	// 獲取Bean的類型
    @Nullable
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	// 獲取Bean的別名
    @Nullable
    Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
    String[] getAliases(String name);
}

public class User {
	private Long id; 
	private String userName; 
/**setter and getter **/ 
}

import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Con f工guration ;
import com.springboot.chapter3.po] o.User;
@Configuration 
public class AppConfig { 
	@Bean(name =”user” } 
	public User ini tUser () { 
		User user= new User (); 
		user. set Id (1L) ; 
		user.setUserName (”aa”); 
		return user;
	}
}

import org.apache. log4j .Logger; 
import org. springframework.context.ApplicationContext; 
import org. springframework.context annotation.AnnotationConfigApplicat工onContext;
import com.springboot.chapter3.po] o .User;
public class IoCTest { 
	private static Logger log= Logger.getLogger(IoCTest.class); 
	publ工c static 飛roid main (String [] args) { 
		ApplicationContext ctx = new AnnotationConfigAppl豐cationContext(AppConfig. class);
 		User user= ctx.getBean(User.class); 
	}
}

@Component(”user") 
public class User { 
	@Value("1") 
	private Long id; 
	@Value("aa"} 
	private String userName; 
/**setter and getter **/ 
}

import org.springframework.context.annotat工on.ComponentScan;
import org.springframework.context.annotation Configuration; 
@Configuration 
@ComponentScan 
public class AppConfig {
}

Applicat工onContext ctx = new AnnotationConfigApplicationContext{AppConfig.class) ;
User user= ctx.getBean(User.class); 
log. info(user.getid());

package org.springframework.context.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.core.annotation.AliasFor;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
//在一個類中可重復定義
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
	// 定義掃描的包
    @AliasFor("basePackages")
    String[] value() default {};
	//定義掃描的包
    @AliasFor("value")
    String[] basePackages() default {};
	//定義掃描的類
    Class<?>[] basePackageClasses() default {};
	//Bean name生成器
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
	//作用域解析器
    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
	//作用域代理模式
    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
	//資源匹配模式
    String resourcePattern() default "**/*.class";
	//是否啟用默認的過濾器
    boolean useDefaultFilters() default true;
	//當滿足過濾器的條件時掃描
    Filter[] includeFilters() default {};
	//當不滿足過濾器的條件時掃描
    Filter[] excludeFilters() default {};
	//是否延遲初始化
    boolean lazyInit() default false;
	//定義過濾器
    @Retention(RetentionPolicy.RUNTIME)
    @Target({})
    public @interface Filter {
   		//過濾器類型，可以按注解類型或者正則式等過濾
        FilterType type() default FilterType.ANNOTATION;
		//定義過濾的類
        @AliasFor("classes")
        Class<?>[] value() default {};
        @AliasFor("value")
        Class<?>[] classes() default {};
		//匹配方式
        String[] pattern() default {};
    }
}

@ComponentScan ("com.springboot.example.* ")
@ComponentScan(basePackages = {"com.springboot.example.pojo"})
@ComponentScan(basePackageClasses = {User.class} ) 

//掃描example下所有包除了@Service裝配的類
//這樣，由于加入了 excludeFilters 的配置，使標注了＠Service 的類將不被 IoC 容器掃描注入，這樣就可以把它類排除到 Spring IoC容器中了。
@ComponentScan(basePackages = {"com.dragon.restart"},excludeFilters = {@ComponentScan.Filter(classes = Service.class)})

@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 {
	//通過類型排除自動配置
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};
	//通過名稱排除自動配置類
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};
	//定義掃描包
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};
	//定義被掃描的類
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};

@Bean(name = "dataSource", destroyMethod = "close" ) 
@Conditional(DatabaseConditional.class)
public DataSource getDataSource ( 
@Value("${database.driverName}") String driver, 
@Value("${database.url}") String url, 
@Value("${database.username}") String username, 
@Value("{database.password}") String password 
){ 
	Properties props= new Properties(); 
	props.setProperty("driver", driver); 
	props setProperty("url", url); 
	props.setProperty("username", username); 
	props setProperty("password", password); 
	DataSource dataSource = null; 
	try { 
		dataSource = BasicDataSourceFactory.createDataSource(props) ; 
	) catch (Exception e) { 
		e.printStackTrace();
	}
	return dataSource;
}

public class DatabaseConditional implements Condition { 
/**
* 數(shù)據(jù)庫裝配條件
* 
* ＠param context 條件上下文
* @param metadata 注釋類型的元數(shù)據(jù)
* ＠return true 裝配 Bean，否則不裝配
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
	//取出環(huán)境配置
	Environment env = context.getEnvironment(); 
	//判斷屬性文件是否存在對應的數(shù)據(jù)庫配置
	return env.containsProperty(”database.driverName” ) 
		&& env.containsProperty(”database.url”) 
		&& env.containsProperty(” database.username”) 
		&& env.containsProperty (”database.password");

<dependency> 
	<groupid>org.apache.commons</groupid> 
	<artifactid>commons-dbcp2</artifactid> 
</dependency> 
<dependency> 
	<groupid>mysql</groupid> 
	<artifactid>mysql-connector-ava</artifactid>
</dependency>

@Bean(name = "dataSource") 
@Conditional(DatabaseConditional.class)
public DataSource getDataSource (){ 
	Properties props= new Properties(); 
	props.setProperty("driver", driver); 
	props setProperty("url", url); 
	props.setProperty("username", username); 
	props setProperty("password", password); 
	DataSource dataSource = null; 
	try { 
		dataSource = BasicDataSourceFactory.createDataSource(props) ; 
	) catch (Exception e) { 
		e.printStackTrace();
	}
	return dataSource;
}