Spring注解驱动

package org.springframework.context.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;
import org.springframework.stereotype.Component;
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
/**
* 同@Component注解功能一样，只是语言不同
*/
public @interface Configuration {
    // 组件名称（bean的名称）
    @AliasFor(annotation= Component.class)
    String value() default "";
}

public class MyTypeFilter implements TypeFilter {
	/**
	 * 自定义匹配模式,使用自定义的的过滤器，需要设置@Filter type = FilterType.CUSTOM、 属性useDefaultFilters = false
	 */
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
			throws IOException {
		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
		String[] memberClassNames = annotationMetadata.getMemberClassNames();
		for (String v: memberClassNames) {
		System.out.println("memberClassNames："+v);
		}
		return false;
	}
}

/**
 * prototype：多实例，每次获取bean都会从容器中创建一个新的实例
 * singleton：单例，容器启动就创建一个实例
 * request：一次请求创建一个实例
 * session：一个会话创建一个实例
 * @return
 */
@Bean
@Scope("prototype")
public Employee myBean() {
	Employee employee = new Employee();
	return employee;
}

@Bean
@Lazy
@Scope("prototype")
public Employee myBean() {
	Employee employee = new Employee();
	return employee;
}

public class MyImportSelector implements ImportSelector{

	/**
	 * 这里的返回值，不要返回null,返回一个空数组也可以
	 * 返回的数组就是，对应需要导入的包，通过ImportSelector 自定导入需要的包
	 */
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		System.out.println("MyImportSelector>>>>: "+importingClassMetadata.getSuperClassName());
		System.out.println("MyImportSelector>>>>: "+importingClassMetadata.getEnclosingClassName());
		//  返回指定全类名的包，导入该指定包
		return new String[] {"com.bdr.bean.Depart4"};
	}
}

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

	/**
	 * 通过ImportBeanDefinitionRegistrar 导入指定的bean
	 */
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// importingClassMetadata 获取注解信息，BeanDefinitionRegistry bean注入操作。
		boolean containsBeanDefinition = registry.containsBeanDefinition("myWindowBean");
		if(containsBeanDefinition) {
		RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Depart4.class);
			registry.registerBeanDefinition("depart4444", rootBeanDefinition);
		}
	}
}

// MyFactoryBean
public class MyFactoryBean implements FactoryBean<Depart5> {
/**
 * 返回实例
 */
public Depart5 getObject() throws Exception {
	return new Depart5();
}

/**
 * 指定类型
 */
public Class<?> getObjectType() {
	return Depart5.class;
}

/**
 * 通过FactoryBean 导入bean
 * @return
 */
@Bean
public MyFactoryBean myFactoryBean() {
	return new MyFactoryBean();
}

@Test
public void getConfig() {
	AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
	String[] beans = context.getBeanDefinitionNames();
	for (String v : beans) {
		System.out.println(v);
	}
	// 获取MyFacoryBean
	// 通过myFactoryBean获取到的是FactoryBean 创建的实例bean
	// 若需要获取工厂bean类型，需要加上前缀&
	Object bean = context.getBean("&myFactoryBean");
	System.out.println("bean:::: "+bean);
}

public class Employee {
	private String name;
	private String no;

	public String getNo() {
		return no;
	}

	public void setNo(String no) {
		this.no = no;
	}

	public Employee() {
		System.out.println("我被创建了。。。。。。。。。。");
	}

	public void init() {
		System.out.println("我的Bean 正在初始化。。。。。");
	}

	public void destory() {
		System.out.println("我的Bean 正在销毁。。。。。");
	}

@Bean(initMethod = "init", destroyMethod = "destory")
	@Scope("prototype")
	public Employee myBean() {
		Employee employee = new Employee();
		return employee;
	}

@Test
	public void getConfigOfLifeCycle() {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig2.class);
		String[] beans = context.getBeanDefinitionNames();
		for (String v : beans) {
			System.out.println(v);
		}
		//context.getBean("myBean");
	}

//默认加在ioc容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作
@Component
public class Boss {
	private Car car;
	//构造器要用的组件，都是从容器中获取
	// 如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
	public Boss(Car car){
		this.car = car;
		System.out.println("Boss...有参构造器");
	}
	public Car getCar() {
		return car;
	}
	//@Autowired 
	//标注在方法，Spring容器创建当前对象，就会调用方法，完成赋值；
	//方法使用的参数，自定义类型的值从ioc容器中获取
	public void setCar(Car car) {
		this.car = car;
	}
	@Override
	public String toString() {
		return "Boss [car=" + car + "]";
	}
}

  @Bean
	@Conditional(WindowsConditional.class)
	public Employee myWindowBean() {
		Employee employee = new Employee();
		return employee;
	}
    /**
     * 实现Condition接口完成bean条件注入
     * @author Rick
     *
     */
public class WindowsConditional implements Condition {
// 返回true 时注入
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
	// ConfigurableListableBeanFactory 可以实现注入bean，获取bean，对bean的操作
	ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
	System.out.println("==============WindowsConditional================");
	String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
	for (String beans : beanDefinitionNames) {
		System.out.println("获取到beans：" + beans);
	}
	System.out.println("==============================");
	ClassLoader classLoader = context.getClassLoader();
	System.out.println("获取到ClassLoader：" + classLoader.toString());
	System.out.println("==============================");
	Environment environment = context.getEnvironment();
	System.out.println("获取操作系统环境：" + environment.getProperty("os.name"));
	System.out.println("==============================");
	BeanDefinitionRegistry registry = context.getRegistry();
	registry.registerAlias("myBean", "employeeRegistryWindows");
	String[] registrybeans = registry.getBeanDefinitionNames();
	for (String registrybean : registrybeans) {
		System.out.println("获取注入的bean：" + registrybean);
	}
	ResourceLoader resourceLoader = context.getResourceLoader();
	System.out.println("==============================");
	// 获取到注解参数信息
	MultiValueMap<String, Object> allAnnotationAttributes = metadata
			.getAllAnnotationAttributes("org.springframework.context.annotation.Bean");
	for (String key : allAnnotationAttributes.keySet()) {
		System.out.println("获取注解：" + allAnnotationAttributes.get(key));
	}
	// 若在windows系统上则注入该bean
	String sysOs = environment.getProperty("os.name");
	if (sysOs.contains("Windows")) {
		return true;
	}
	return false;
}

// 简化的@RequestMapping,RESTFul
@GetMapping;
@PostMapping;
@PutMapping;
@DeleteMapping;
@PatchMapping

// 如果映射名称不一致需要制定@PathVariable("userId")
@GetMapping(path="/{userId}{type}/get.do")
@ResponseBody
public User getUser(@PathVariable("userId") Long id, @PathVariable Integer type) {
}

@ControllerAdvice
public class MyControllerAdvice {

    /**
     * 应用到所有@RequestMapping注解方法，在其执行之前初始化数据绑定器
     * @param binder
     */
    @InitBinder
    public void initBinder(WebDataBinder binder) {}

    /**
     * 把值绑定到Model中，使全局@RequestMapping可以获取到该值
     * @param model
     */
    @ModelAttribute
    public void addAttributes(Model model) {
        model.addAttribute("author", "Magical Sam");
    }

    /**
     * 全局异常捕捉处理
     * @param ex
     * @return
     */
    @ResponseBody
    @ExceptionHandler(value = Exception.class)
    public Map errorHandler(Exception ex) {
        Map map = new HashMap();
        map.put("code", 100);
        map.put("msg", ex.getMessage());
        return map;
    }

}

package com.bdr.bean;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
// 定义切面
@Aspect
public class AopDefinition {

	// 定义切点,也就是切入到那个目标类、目标方法上，切点名就是方法名
	// 切点表达式：作用该类下所有的公共方法，相关切面表达式查看官方文档
	@Pointcut("execution(public int com.bdr.bean.AopPointCutTest.*(..))")
	public void myPointCut() {
	}

	// @Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）,上面的切点直接引用即可
	// 引入JoinPoint 用于获取方法执行参数信息
	@Before("myPointCut()")
	public void logStart(JoinPoint joinPoint) {
		Object[] args = joinPoint.getArgs();
		System.out.println("" + joinPoint.getSignature().getName() + "运行。。。@Before:参数列表是：{" + Arrays.asList(args) + "}");
	}

	@After("myPointCut()")
	public void logEnd(JoinPoint joinPoint) {
		System.out.println("" + joinPoint.getSignature().getName() + "结束。。。@After");
	}

	// JoinPoint一定要出现在参数表的第一位
	@AfterReturning(value = "myPointCut()", returning = "result")
	public void logReturn(JoinPoint joinPoint, Object result) {
		System.out.println("" + joinPoint.getSignature().getName() + "正常返回。。。@AfterReturning:运行结果：{" + result + "}");
	}

	@AfterThrowing(value = "myPointCut()", throwing = "exception")
	public void logException(JoinPoint joinPoint, Exception exception) {
		System.out.println("" + joinPoint.getSignature().getName() + "异常。。。异常信息：{" + exception + "}");
	}
}

package com.bdr.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

import com.bdr.bean.AopDefinition;
import com.bdr.bean.AopPointCutTest;

/**
 * Aop注解学习配置类
 * @author Rick
 * 配置类
 */
// @EnableAspectJAutoProxy 开启切面注解的支持
@EnableAspectJAutoProxy
@Configuration
public class MainAopConfig {

	@Bean
	public AopPointCutTest aopPointCutTest () {
		return new AopPointCutTest();
	}
	@Bean
	public AopDefinition aopDefinition () {
		return new AopDefinition();
	}
}

// 配置加载测试类
@Test
	public void getAopConfigTest(){
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainAopConfig.class);
			AopPointCutTest bean = context.getBean(AopPointCutTest.class);
			int sum = bean.sum(1, 3);
			System.out.println(sum);
	}

<tx:annotation-driven />
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    // 当在配置文件中有多个 TransactionManager , 可以用该属性指定选择哪个事务管理器。
	@AliasFor("transactionManager")
	String value() default "";
	@AliasFor("value")
	String transactionManager() default "";
	// 事务的传播行为，默认值为 REQUIRED
	Propagation propagation() default Propagation.REQUIRED;
	// 事务的隔离度，默认值采用 DEFAULT
	Isolation isolation() default Isolation.DEFAULT;
	// 事务的超时时间，默认值为-1。如果超过该时间限制但事务还没有完成，则自动回滚事务。
	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
	// 	指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true。
	boolean readOnly() default false;
	// 用于指定能够触发事务回滚的异常类型，如果有多个异常类型需要指定，各类型之间可以通过逗号分隔。
	Class<? extends Throwable>[] rollbackFor() default {};
	// 指定那些异常类回滚事务（需要是Throwable的子类）
	String[] rollbackForClassName() default {};
	// 抛出noRollbackFor指定的异常类型，不回滚事务。
	Class<? extends Throwable>[] noRollbackFor() default {};
	// 指定那些类异常类型不回滚事务（需要是Throwable的子类）
	String[] noRollbackForClassName() default {};
}

@Transactional(rollbackFor=Exception.class)
@Service(value ="employeeService")
public class EmployeeService
{
…………
}

public enum Propagation {
    /**
     * 默认传播行为，如果当前存在事务，就沿用当前事务
     * 去否则新建一个事务运行子方法
     */
    REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

    /**
     * 如果当前存在事务，就沿用当前事务
     * 如果不存在，则继续采用无事务的方式运行子方法
     */
    SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

    /**
     * 必须使用事务，如果当前没有事务，则会抛出异常，
     * 如果存在当前事务 就沿用当前事务
     */
    MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

    /**
     * 无论当前事务是否存在，都会创建新事务运行方法
     * 新事务可以拥有新的锁和隔离级别等特性，与当前事务相互独立
     */
    REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

    /**
     * 不支持事务，当前存在事务时，将挂起事务，运行方法
     */
    NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

    /**
     * 不支持事务，如果当前方法存在事务，则抛出异常，否则继续使用无事务机制运行
     */
    NEVER(TransactionDefinition.PROPAGATION_NEVER),

    /**
     * 在当前方法调用子方法时，如果子方法发生异常，
     * 只因滚子方法执行过的 SQL ，而不回滚当前方法的事务
     */
    NESTED(TransactionDefinition.PROPAGATION_NESTED);

    private final int value;

    Propagation(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }
}