@Data
public class People {
    // Autowired表示自动装配，它有个required属性默认为true
    @Autowired // 注解的成员无get,set等方法也能自动装配
    private Cat cat;
    // required为false时表示该属性可以为null，即bean文件中没有该对象时不会报错
    @Autowired(required=false) 
    private Dog dog;
    private String name;
}

@Autowired // 默认使用变量名与id匹配
@Qualifier(value = "cat") // 指定的一个id与bean id匹配
private Cat cat;

@Autowired // 为方法的每一个参数自动赋值，原理一样
private void show(@Qualifier("a") A a){ // 为某参数指定bean
    System.out.println(a);
}

@Data
public class People {
    @Resource // 自动匹配
    private Cat cat;
    @Resource(name = "dog") // 指定对象，也可指定类型type = Dog.class
    private Dog dog;
    private String name;
}

// 组件，等价于：<bean id="cat" class="ruoxijun.pojo.cat"/>
@Component // 默认id类名首字母小写，可传入字符串更改为指定id
public class Cat {
    // 属性注入,等价于：<property name="name" value="猫"/>
    @Value("猫")
    private String name;
}

// 指定作用域，等价于：<bean id="cat" class="ruoxijun.pojo.cat" scope="singleton"/>
@Scope("singleton") //单例模式，默认
@Scope("prototype") //原型模式

@Data
public class User {
    @Value("若惜君")
    private String name;
}

@Configuration // 代表这是一个配置类，等同与beans.xml文件
public class Config {
    @Bean // 等同于一个 bean标签，方法名就是id，返回值就是class
    // @Bean("user")
    public User user(){
        return new User();
    }
}

ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
User user = (User) context.getBean("user");
// getBean(Config.class) 注意配置类本身也是一个组件

// 扫描包注解，等同于：<context:component-scan base-package="ruoxijun"/>
@ComponentScan("ruoxijun")
// 导入其它配置类的bean，也可以导入组件类会在此类中自动生成组件bean
@Import(Config.class) // 可使用逗号分隔导入多个

InvocationHandler：实现动态代理的接口，invoke方法，表示代理对象要执行的方法，如下参数：
    Object proxy：代理对象
    Method method：method.invoke(目标对象实例, args) // 执行目标对象方法
    // 在目标对象方法执行前后我们可以定义我们需要的方法
    Object[] args：目标对象方法的参数
    // invoke的返回值就是代理对象执行方法后的返回值
    
Proxy：创建动态代理对象，通过它静态的 newProxyInstance 方法，如下参数：
    ClassLoader loader：通过反射获取类加载器:目标类对象.getClass().getClassLoader()
    Class<?>[] interfaces：目标对象实现的所有接口数组:目标类对象.getClass().getInterfaces()
    InvocationHandler h：代理类要完成功能（上方实现的 InvocationHandler 接口类）

// 目标类
class B implements A{
    @Override // 目标方法
    public void show() { System.out.println("A的show方法执行了"); }
}
// 目标接口
public interface A {
    void show();
    public static void main(String[] args) {
        // 目标对象(需要被代理的对象)
        A a = new B();
        // 添加功能
        InvocationHandler in = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                System.out.println("方法执行之前");
                Object o = method.invoke(a,args);
                System.out.println("方法执行之后");
                return o;
            }
        };
        // 获取目标类加载器
        ClassLoader loader = a.getClass().getClassLoader();
        // 获取目标类的实现接口数组
        Class<?>[] interfaces = a.getClass().getInterfaces();
        // 创建动态代理对象
        A o = (A) Proxy.newProxyInstance(loader,interfaces,in);
        // 调用动态代理对象的实现方法
        o.show();
    }
}

public interface UserService { // 目标接口
    void add();
    void delete();
}
public class UserServiceImpl implements UserService { // 目标类
    public void add() { System.out.println("add User"); }
    public void delete() { System.out.println("delete User"); }
}

public class UserBefore implements MethodBeforeAdvice { // 方法执行前接口
    @Override // 参数解析：参1：目标方法对象，参2：目标方法参数，参3：目标对象
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("MethodBeforeAdvice："+o.getClass().getName()+
                "类"+method.getName()+"方法");
    }
}

public class UserAfter implements AfterReturningAdvice { // 方法执行后接口
    @Override// 参数解析：参1：目标方法返回值，参2：目标方法对象，参3：目标方法参数，参4：目标对象
    public void afterReturning(Object o, Method method, Object[] objects, Object o1)
            throws Throwable {
        System.out.println("AfterReturningAdvice："+o1.getClass().getName()+
                "类"+method.getName()+"方法,返回"+o);
    }
}

ApplicationContext context = new
        ClassPathXmlApplicationContext("applicationContext.xml");
// 这里看似获取目标类，实则获取到的是代理类。     
// 因为返回的是代理类，所以这里只能使用接口类型接受对象。使用目标类型会报错
UserService userService = (UserService) context.getBean("userService");
userService.add();

public class UserProxy {
    // 自定义方法，实现目标方法执行前执行
    public void before(){
        System.out.println("目标方法执行前");
    }
    // 自定义方法，实现目标方法执行后执行
    public void after(){
        System.out.println("目标方法执行后");
    }
}

@Aspect // 标注此类为一个切面
public class UserProxy {
    // @Before定义目标方法执行前的操作，参数为execution表达式指定给那些方法添加
    @Before("execution(* ruoxijun.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("目标方法执行前");
    }
    // @After定义目标方法执行后的操作
    @After("execution(* ruoxijun.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("目标方法执行后");
    }
    // @Around 环绕通知，类似于一个完整的动态代理
    @Around("execution(* ruoxijun.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕开始");
        Object re = pjp.proceed(); // 让目标开始执行方法，并返回方法返回值
        System.out.println("环绕结束");
        return re; // 返回方法执行后的返回值
    }
}

@Aspect // 标注此类为一个切面

@Before // 在目标方法之前
@After // 在目标方法结束后
@AfterReturning // 在目标方法正常返回之后
@AfterThrowing // 在目标方法抛出异常之后运行

@Around // 定义目标方法执行时环绕的操作

try{
    @Before // 方法前置
    pjp.procced(args) // 方法执行
    @AfterReturning // 方法正常返回
} catch(Exception exception) {
    @AfterThrowing // 方法抛出异常时
} finally {
    @After // 方法执行完成后
}

@Before("execution(* ruoxijun.service.CountImpl.*(..))")
// 在切面类的通知方法的参数中添加一个JoinPoint参数，这个参数能拿到方法信息
public void aspectBefore(JoinPoint joinPoint){
    // 获取方法参数
    Object[] args = joinPoint.getArgs();
    // 方法签名
    Signature signature = joinPoint.getSignature();
    signature.getName(); // 方法名
}

@AfterReturning(value = "execution(* ruoxijun.service.CountImpl.*(..))",
        returning = "result")
// AfterReturning的returning属性指定接收方法返回值的参数，并添加同名的参数
public void aspectAfterReturning(Object result){
    System.out.println("目标方法的返回值："+result);
}

@AfterThrowing(value = "execution(* ruoxijun.service.CountImpl.*(..))",
        throwing = "exception")
// AfterThrowing的throwing属性指定接收方法产生异常的参数，并添加Exception类型的同名参数
public void aspectAfterThrowing(Exception exception){
    System.out.println("目标方法抛出异常："+exception);
}

@Pointcut("execution(* ruoxijun.service.CountImpl.*(..))") // 切入点写入
public void init(){};
// 填写上方方法(其它方法需要在同样的execution表达式直接复用即可)
@Before(value = "init()")

@Aspect // 标注此类为一个切面
@Order(1) // 当有多个切面时可添加此注解，设置当前切面的优先级，值小的优先级高